WordPress Tag

What’s new in WordPress 6.0

WordPress 6.0 was released earlier this week, and it is the second major release of 2022.

Several notable updates, which you can read more about in the following sections, include:

• Faster website performance
• Page creation patterns
• Block locking
• Global style variations
• Ability to select text across multiple blocks

Some of the changes, like faster website performance, will be felt immediately. Others, like the brand new page creation patterns, are features for theme developers to roll out.

The official WordPress announcement explains:

“The latest version of the software takes full site editing one step further and looks to consolidate the ‘no code’ experience for site-building, expanding upon the existing customization tools, bringing new blocks, and focusing on the writing and design workflows.

An example of this is the new style switcher for block themes, one of the most anticipated features for the flexibility and creative opportunities it introduces without having to switch themes.

‘With thoughtful updates to the writing experience, building better block functionality, and adding a new intuitive style switcher, I’m really proud of the work that’s been done in this release to make a great site editing experience,’ says WordPress’ Executive Director, Josepha Haden Chomphosy.”

WordPress 6.0 Is An Incremental Update

WordPress 6.0 is the culmination of the work of over 500 people in at least 58 countries, encompassing close to 1,000 improvements.

Ordinarily, when a product undergoes a version change, like a new Android phone model, end-users expect to see dramatic changes. That’s not really the case with WordPress version changes.

While this is a “dot 0” release, version 6.0 is best understood as part of a series of incremental improvements meant to preserve backward compatibility while also introducing improvements.

WordPress 6.0 is a version number change but it’s not on the scale of a revamp. The publishing experience between versions 5.9 and 6 is improved.

According to the official WordPress announcement, there is no need to be wary of updating, encouraging all site owners to update now in order to enjoy the many benefits of this release.

“Site owners and administrators should upgrade to take full advantage of the many stability, performance, and usability enhancements today.

WordPress content creators will enjoy a suite of new features geared toward improving the writing and designing experiences.”

New Features That End Users Will Love

Page Creation Patterns

One of the most important changes is the Page Creation Patterns feature.

Ordinarily, when creating a web page a publisher might start with a blank layout. Page creation patterns is a way to select from multiple layouts as a starting point.

The WordPress core itself won’t ship with the layouts, this is something that theme developers need to build into their themes.

Block Locking

Block Locking is a feature that prevents an end-user from accidentally deleting or moving an important block. The new feature is available through a block settings drop-down menu.

Pic courtesy: wpbeginner.com

Andrew Wilder of the WordPress support company, NerdPress offered his opinion that while 6.0 ships with “tons” of improvements that end users will like, he believes that the page creation patterns feature is one that they will most appreciate.

Wilder said:

“For many of our clients, the Page Creation Patterns will be really helpful, especially once plugins are available to pre-built patterns that are specific to their content. That could be a huge time-saver!

I’m also glad to see the new Block Locking feature – right now it doesn’t let you lock changes to the block content, but it can stop you from accidentally moving or deleting a block.”

Easily Switch Theme Styles

WordPress 6.0 comes with an easy way to switch your entire theme style with a single click.

Click on the Style button at the top right corner and then switch to the Browse Styles tab to see available styles for your theme.

Pic courtesy: wpbeginner.com

Theme styles is a WordPress theme feature and its availability depends on your WordPress theme.

Edit More Theme Templates with WordPress 6.0

WordPress 6.0 brings the ability to edit even more templates inside the theme editor.

Pic courtesy: wpbeginner.com

The new archive templates that you can edit include:

• Author
• Category
• Date
• Tag
• Other custom taxonomies

Export Your Block Theme with All The Changes

WordPress 6.0 now allows you to save and export all the changes you made to your block theme.

Pic courtesy: wpbeginner.com

WordPress will prepare a theme zip file that includes all the changes you made using the full site editor. You can then download and install that theme on any other WordPress website.

Multi-Select: Select Text Across Multiple Blocks

In the new blocked-based WordPress editors, creating a web page layout is done using what’s called blocks, building blocks, so to speak.

Blocks are like containers where content can be inserted. Content can be images, text, whatever.

An example of an incremental but exciting change in WordPress 6.0 is the ability to select text across multiple content blocks.

This allows a user to select the content within multiple blocks without selecting multiple blocks themselves. This gives publishers the ability to write and control content in an expected manner, contributing to a more intuitive writing experience.

Pic courtesy: wpbeginner.com

Style Variations

Another exciting new feature is called Global Style Variations.

Style variations allows theme authors to provide their customers a way to easily change the look and feel of their website without having to edit CSS or HTML, dramatically speeding up the process of getting a website up and running.

This is a feature that is implemented on the WordPress theme developer side which improves the WordPress publishing experience for end users.

Copy Image URL from Media Library List View

If you view your media library in the list view, then you can now see a ‘Copy URL to clipboard’ link below each image and media file.

Pic courtesy: wpbeginner.com

Noteworthy Changes For Developers

• Style variations, including different fonts powered by a private theme.json handler.
• Improved block theme creation and tooling from within the site editor itself.
• Easier ability to incorporate patterns (creating a new page, in the inserter itself, etc):
• Registration of blocks from within themes.
• Updates to the @wordpress/create-block templating system.

WordPress Full Site Editor Beta Label

Something that may be useful to consider about WordPress 6.0 is that the Full Site Editor (FSE) is still labeled as Beta.

WordPress 6.0 improves the editing experience for the end users by making the process of writing easier as well as making it easier to dream up unique website layouts without having to deal with code. But FSE is still considered as a Beta product.

For more information and to build the website using WordPress, Hire WordPress Developer from us as we provide you high-quality services by utilizing all the latest themes, plugins, and advanced technology. E-mail us any clock at – hello@hkinfosoft.com or Skype us: “hkinfosoft“.

To develop a custom website, plugin, or theme using WordPress, please visit our technology page.

Best lead migration plugin ever for Unbounce and Gravity Forms – U2GF

Nowadays, Lead Generation is one of the best ways used to get client prerequisite and expectations. The lead contains useful data so it is extremely valuable for developing one’s business rapidly. Unbounce and Gravity Forms are the two distinct tools doing precisely the same thing: Getting leads!

First of all, let’s understand some of the basics about both the tools.

What is Unbounce?

Unbounce makes it simple to create landing pages without a committed developer. Just drag and drop via their editor and create incredible landing pages in minutes.

What is Gravity Forms?

Gravity Forms is a premier WordPress plugin that makes it easy to create powerful forms. One can start building complex, powerful contact forms in just minutes.

For the websites which are developed and maintained using WordPress, ‘Gravity Forms’ is the most popular form builder plugin that is used to create and display forms dynamically.

Why use both?

Now the question is, how do we manage the leads data at any single place? In general, there is no any direct way or solution approached by WordPress team so that you can manage your leads data coming out from any of your Unbounce landing pages to their associated Gravity Forms which are built and/or designed at WordPress.

Integrated solution:

Here is a quick and easy solution to migrate and manage your leads data between Unbounce and Gravity Forms which is called U2GF.

Unbounce to Gravity Forms shortly referred to as U2GF is leads integration plugin or tool for WordPress ever available in the market using which one can integrate any number of Unbounce landing pages with Gravity Forms to easily set a connection in order to obtain leads data from Unbounce and drive it through your WordPress site database.

The plugin works as a mediator that helps to fetch all the leads from Unbounce and post the data automatically to their respective Gravity Forms on WordPress side.

Everything is just dynamic! Checkout the list below.

1. Remove the rush to create a gravity form anymore manually as it will be automatically created from your Unbounce landing page.
2. No need to manage the form fields to get each valuable information as it’s going to create and map all fields of your Unbounce form together.
3. Should be able to manage all leads coming from Unbounce to Gravity Form immediately.
4. Better control to allow/disallow sending email notifications.
5. Provided default support to all field types including Advanced.
6. Supported third-party APIs and add-ons.

Want to try it out?

There are two possible choices of the available plugin version: Free and Pro.

What is the difference?

$0

Free Version

• Auto Lead Migration
• Manage Lead Migration

Download

$3900

Pro Version

• Auto Lead Migration
• Manage Lead Migration
• GF Add-Ons Support
• Auto Form Management
• Send Email Notifications
• Priority Support

Why Pro?

Quick Connection

Connecting GF and UB is very easy through Webhook

Add-On & APIs Support

Get support of unlimited GF Add-Ons and custom APIs hooks.

Auto Lead Transaction

Each lead will migrate from UB automatically.

Manage Notifications

Takes control to get the email notification.

Leads Management

Manage leads from migration as per your convenience time.

Easy Control Settings

Provides the best admin tool to manage settings easily.

Auto Form Management

Manage GF form fields and entries respectively.

24/7 Support

We will be very happy to support you on your way.

Unbounce To Gravity Form is carefully handcrafted lead migration plugin available and very useful for WordPress website owners those who are seeking to manage their leads data at any single place as a part of the best marketing team practice. It’s built with 100% Unbounce and WordPress plugin standards. The U2GF Plugin is completely free to download and use for your personal projects.

Looking for more automation processes? Kindly upgrade to the pro version!

For Commercial use, we recommend you to checkout U2GF Pro version, which includes various useful features including priority support.

For more information and to develop web applications using PHP, WordPress, OR Laravel, Hire PHP Developer from us as we give you a high-quality solution by utilizing all the latest tools and advanced technology. E-mail us any clock at – support@hkinfosoft.com or Skype us: “hkinfosoft“.

To develop your custom web app using PHP, Laravel or WordPress, please visit our technology page.

What’s new in PHP 8

PHP 8 is here! PHP 8 is a new major improved version, which means that it will introduce performance improvements and lots of new features such as the JIT compiler, union types, attributes, and more.

New features

Let’s start with all new features, it’s quite a list!

Union types

Given the dynamically typed nature of PHP, there are lots of cases where union types can be useful. Union types are a collection of two or more types which indicate that either one of those can be used.

public function foo(Foo|Bar $input): int|float;

Note that void can never be part of a union type, since it indicates “no return value at all”. Furthermore, nullable unions can be written using |null, or by using the existing ? notation:

public function foo(Foo|null $foo): void;

public function bar(?Bar $bar): void;

JIT

The JIT — just in time — compiler promises significant performance improvements, albeit not always within the context of web requests. I’ve done my own benchmarks on real-life web applications, and it seems like the JIT doesn’t make that much of a difference, if any, on those kinds of PHP projects.

The nullsafe operator

If you’re familiar with the null coalescing operator you’re already familiar with its shortcomings: it doesn’t work on method calls. Instead you need intermediate checks, or rely on optional helpers provided by some frameworks:

$startDate = $booking->getStartDate();

$dateAsString = $startDate ? $startDate->asDateTimeString() : null;

With the addition of the nullsafe operator, we can now have null coalescing-like behaviour on methods!

$dateAsString = $booking->getStartDate()?->asDateTimeString();

Named arguments

Named arguments allow you to pass in values to a function, by specifying the value name, so that you don’t have to take their order into consideration, and you can also skip optional parameters!

function foo(string $a, string $b, ?string $c = null, ?string $d = null) 
{ /* … */ }

foo(
    b: 'value b', 
    a: 'value a', 
    d: 'value d',
);

Attributes

Attributes, commonly known as annotations in other languages, offers a way to add meta data to classes, without having to parse docblocks.

As for a quick look, here’s an example of what attributes look like, from the RFC:

use App\Attributes\ExampleAttribute;

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}

#[Attribute]
class ExampleAttribute
{
    public $value;
 
    public function __construct($value)
    {
        $this->value = $value;
    }
}

Note that this base Attribute used to be called PhpAttribute in the original RFC, but was changed with another RFC afterwards. If you want to take a deep dive in how attributes work, and how you can build your own; you can read about attributes in depth on this blog.

Match expression

You could call it the big brother of the switch expression: match can return values, doesn’t require break statements, can combine conditions, uses strict type comparisons and doesn’t do any type coercion.

It looks like this:

$result = match($input) {
    0 => "hello",
    '1', '2', '3' => "world",
};

Constructor property promotion

This RFC adds syntactic sugar to create value objects or data transfer objects. Instead of specifying class properties and a constructor for them, PHP can now combine them into one.

Instead of doing this:

class Money 
{
    public Currency $currency;
 
    public int $amount;
 
    public function __construct(
        Currency $currency,
        int $amount,
    ) {
        $this->currency = $currency;
        $this->amount = $amount;
    }
}

You can now do this:

class Money 
{
    public function __construct(
        public Currency $currency,
        public int $amount,
    ) {}
}

New static return type

While it was already possible to return self, static wasn’t a valid return type until PHP 8. Given PHP’s dynamically typed nature, it’s a feature that will be useful to many developers.

class Foo
{
    public function test(): static
    {
        return new static();
    }
}

New mixed type

Some might call it a necessary evil: the mixed type causes many to have mixed feelings. There’s a very good argument to make for it though: a missing type can mean lots of things in PHP:

• A function returns nothing or null
• We’re expecting one of several types
• We’re expecting a type that can’t be type hinted in PHP

Because of the reasons above, it’s a good thing the mixed type is added. mixed itself means one of these types:

• array
• bool
• callable
• int
• float
• null
• object
• resource
• string

Note that mixed can also be used as a parameter or property type, not just as a return type.

Also note that since mixed already includes null, it’s not allowed to make it nullable. The following will trigger an error:

// Fatal error: Mixed types cannot be nullable, null is already part of the mixed type.
function bar(): ?mixed {}

Throw expression

This RFC changes throw from being a statement to being an expression, which makes it possible to throw exception in many new places:

$triggerError = fn () => throw new MyError();

$foo = $bar['offset'] ?? throw new OffsetDoesNotExist('offset');

Inheritance with private methods

Previously, PHP used to apply the same inheritance checks on public, protected and private methods. In other words: private methods should follow the same method signature rules as protected and public methods. This doesn’t make sense, since private methods won’t be accessible by child classes.

This RFC changed that behaviour, so that these inheritance checks are not performed on private methods anymore. Furthermore, the use of final private function also didn’t make sense, so doing so will now trigger a warning:

Warning: Private methods cannot be final as they are never overridden by other classes

Allowing ::class on objects

A small, yet useful, new feature: it’s now possible to use ::class on objects, instead of having to use get_class() on them. It works the same way as get_class().

$foo = new Foo();

var_dump($foo::class);

Non-capturing catches

Whenever you wanted to catch an exception before PHP 8, you had to store it in a variable, regardless whether you used that variable or not. With non-capturing catches, you can omit the variable, so instead of this:

try {
    // Something goes wrong
} catch (MySpecialException $exception) {
    Log::error("Something went wrong");
}

You can now do this:

try {
    // Something goes wrong
} catch (MySpecialException) {
    Log::error("Something went wrong");
}

Note that it’s required to always specify the type, you’re not allowed to have an empty catch. If you want to catch all exceptions and errors, you can use Throwable as the catching type.

Trailing comma in parameter lists

Already possible when calling a function, trailing comma support was still lacking in parameter lists. It’s now allowed in PHP 8, meaning you can do the following:

public function(
    string $parameterA,
    int $parameterB,
    Foo $objectfoo,
) {
    // …
}

Create DateTime objects from interface

You can already create a DateTime object from a DateTimeImmutable object using DateTime::createFromImmutable($immutableDateTime), but the other way around was tricky. By adding DateTime::createFromInterface() and DatetimeImmutable::createFromInterface() there’s now a generalised way to convert DateTime and DateTimeImmutable objects to each other.

DateTime::createFromInterface(DateTimeInterface $other);

DateTimeImmutable::createFromInterface(DateTimeInterface $other);

New Stringable interface

The Stringable interface can be used to type hint anything that implements __toString(). Whenever a class implements __toString(), it automatically implements the interface behind the scenes and there’s no need to manually implement it.

class Foo
{
    public function __toString(): string
    {
        return 'foo';
    }
}

function bar(string|Stringable $stringable) { /* … */ }

bar(new Foo());
bar('abc');

New str_contains() function

Some might say it’s long overdue, but we finally don’t have to rely on strpos() anymore to know whether a string contains another string.

Instead of doing this:

if (strpos('string with lots of words', 'words') !== false) { /* … */ }

You can now do this

if (str_contains('string with lots of words', 'words')) { /* … */ }

New str_starts_with() and str_ends_with() functions

Two other ones long overdue, these two functions are now added in the core.

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

New fdiv() function

The new fdiv() function does something similar as the fmod() and intdiv() functions, which allows for division by 0. Instead of errors you’ll get INF, -INF or NAN, depending on the case.

New get_debug_type() function

get_debug_type() returns the type of a variable. Sounds like something gettype() would do? get_debug_type() returns more useful output for arrays, strings, anonymous classes and objects.

For example, calling gettype() on a class \Foo\Bar would return object. Using get_debug_type() will return the class name.

A full list of differences between get_debug_type() and gettype() can be found in the RFC.

New get_resource_id() function

Resources are special variables in PHP, referring to external resources. One example is a MySQL connection, another one a file handle.

Each one of those resources gets assigned an ID, though previously the only way to know that id was to cast the resource to int:

$resourceId = (int) $resource;

PHP 8 adds the get_resource_id() functions, making this operation more obvious and type-safe:

$resourceId = get_resource_id($resource);

Abstract methods in traits improvements

Traits can specify abstract methods which must be implemented by the classes using them. There’s a caveat though: before PHP 8 the signature of these method implementations weren’t validated. The following was valid:

trait Test {
    abstract public function test(int $input): int;
}

class UsesTrait
{
    use Test;

    public function test($input)
    {
        return $input;
    }
}

PHP 8 will perform proper method signature validation when using a trait and implementing its abstract methods. This means you’ll need to write this instead:

class UsesTrait
{
    use Test;

    public function test(int $input): int
    {
        return $input;
    }
}

Object implementation of token_get_all()

The token_get_all() function returns an array of values. This RFC adds a PhpToken class with a PhpToken::tokenize() method. This implementation works with objects instead of plain values. It consumes less memory and is easier to read.

Variable syntax tweaks

From the RFC: “the Uniform Variable Syntax RFC resolved a number of inconsistencies in PHP’s variable syntax. This RFC intends to address a small handful of cases that were overlooked.”

Type annotations for internal functions externals

Lots of people pitched in to add proper type annotations to all internal functions. This was a long standing issue, and finally solvable with all the changes made to PHP in previous versions. This means that internal functions and methods will have complete type information in reflection.

ext-json always available

Previously it was possible to compile PHP without the JSON extension enabled, this is not possible anymore. Since JSON is so widely used, it’s best developers can always rely on it being there, instead of having to ensure the extension exist first.

For more information and to develop web application using PHP, WordPress OR Laravel, Hire PHP Developer from us as we give you a high-quality product by utilizing all the latest tools and advanced technology. E-mail us any clock at – hello@hkinfosoft.com or Skype us: “hkinfosoft”. To develop custom web apps using PHP, Laravel or WordPress, please visit our technology page.

Content Source:

1. stitcher.io

Eventy: WordPress-like Actions and Filters for Laravel

Eventy is a Laravel package by Tor Morten Jensen that brings WordPress-style actions and filters to your Laravel app.

This package has a lightweight API and makes it easy to build an action and filter system as found in WordPress. The action and filter system in WordPress is a powerful way to customize WordPress themes without modifying the template. For example, your users could easily tap into the <title></title> tag (think wp_title) to modify the way that title tags work without modifying the template.

Actions

Actions are code that you want to enable the ability to tap into code execution at a given point in your code.

Here’s the basic API for creating actions:

Eventy::action('my.hook', 'awesome');

The best place to add action listeners is in a service provider boot() method:

public function boot()
{
    Eventy::addAction('my.hook', function($what) {
        echo 'You are '. $what;
    }, 20, 1);
}

The Eventy::addAction() method accepts the action name, the callback, the priority, and the number of expected args. The lower the priority number, the earlier the execution.

Filters

Like WordPress filters, the Eventy library provides a filter method to modify passed values. Every time a filter is called it returns it’s value after running through various callbacks:

$value = Eventy::filter('my.hook', 'awesome');

The first argument is the filter name, and the second is the value. If no filter listeners are attached, the return value would be awesome.

The method siguature is the same as actions, including the priority and number of expected arguments:

Eventy::addFilter('my.hook', function($what) {
    $what = 'not '. $what;
    return $what;
}, 20, 1); // returns `not awesome`

You can even combine actions and filters together:

Eventy::addAction('my.hook', function($what) {
    $what = Eventy::filter('my.hook', 'awesome');
    echo 'You are '. $what;
});

Templates

Using the same examples from the project’s readme, here’s what the template syntax looks like for this package:

{{-- for example, `echo "awesome"` --}}
@action('my.hook', 'awesome')

You are @filter('my.hook', 'awesome')

For more Information and to build website using Laravel, Hire Laravel Developer from us as we give you high quality product by utilizing all the latest tools and advanced technology. E-mail us any clock at – hello@hkinfosoft.com or Skype us: “hkinfosoft“.

To develop custom website using Laravel, please visit our technology page.

The Top WordPress Trends

When it comes to web development, WordPress is king. 27% of the internet is powered by WordPress and top brands such as TechCrunch, CNN and UPS uses it. WordPress also offers a massive library of plugins to its users, making it completely customizable to any web development need. All WordPress websites are also mobile and SEO-friendly.

WordPress trends are driven by overall web design trends in addition to new features provided by the company itself. Last year, WordPress gave us version 4.9 recently, which included new and improved widgets for adding images, audio, and video to your website.

New WordPress Features and Improvements

Users can expect to see improvements in editing code, managing themes, managing plugins, and easier customization. These improvements will help developers in addition to website administrators. These improvements are exciting as ease-of-use is one of the most important aspects of WordPress for our clients. Once we create a website, we want to empower our clients to make website changes on their own as their business grows.

Drag-and-Drop WordPress Themes

While WordPress offers many basic layout themes for free, customizable themes are often worth the price. Since WordPress prides itself on being user-friendly, there are themes that range from simple to complex at various price points. Last year, we saw a rise in the amount of “drag-and-drop” themes, which allow users to create and customize websites without writing any code. These themes are easy to use for both web developers and non-coders alike. Drag-and-drop makes experimentation with different layouts and plugins easy as well. Want to experiment with video headers? Simply drag and drop a video header widget and see if it increases time on site! Here are some examples of drag and drop WordPress themes:

• Foundry – Foundry is an elegant, visually stunning responsive theme that’s flexible and easy to customize.
• Uplift – Uplift’s drag and drop builder features 54 elements to completely customize your website with ease.
• BeTheme – BeTheme is an easy-to-use, responsive and fast-loading theme that’s great for beginners!

WordPress Video Headers

It’s no secret that video will dominate web design in 2018. Video headers and backgrounds might not be “new”, but it is becoming trendy in the web design world. Luckily, WordPress makes it easy to get on board with this trend by offering themes that feature video headers. Here are a few examples:

• Inspiro – This theme features a full-screen video that’s great for showing off a video portfolio.
• Naila – Naila is a single-page theme with an optional full-screen video background display.
• Balzac – Balzac is a responsive theme with full video support. It includes multiple layouts within the theme, so it’s incredibly flexible. Here are a few examples:

Virtual Reality WordPress Plugins

Web developers and designers on on-pace to start including virtual reality and augmented reality in web designs. WordPress fully supports virtual reality content as well as 360° videos and images. There are several plugins already available. Expect to see more WordPress websites make use of this content in 2018. Here are a few plugins that are currently available:

• MomentoPress – MomentoPress is a free plugin for displaying 360° photos and videos.
• 360° Panoramic Image Viewer – 360° Panoramic Image Viewer is a responsive plugin that allows you to add “hotspots” to static images, creating a completely immersive experience for your visitors.
• WP-VR View – WP-VR View is a popular plugin that allows you to display PhotoSphere images and 360° video on your WordPress site. Smartphone users can even get the virtual reality experience using Google Cardboard!

Enhanced Ecommerce Websites

Ecommerce makes up a large portion of WordPress websites with WooCommerce being the most popular plugin by far. Other ecommerce platforms such as PayPal and Google Checkout integrate easily with WordPress as well, making it a popular choice for online stores. Ecommerce trends such as mobile shopping, subscription-based services, and personalized shopping are easily addressed by WordPress in its newer ecommerce themes.

• Uncode – Uncode offers a ton of options to enhance your online store. It offers plenty of customizable shop templates and easy shortcuts for store-related features, such as pricing plans. It’s responsive and integrates with WooCommerce.
• Divi – Divi bills itself as “The Ultimate WordPress Theme and Visual Page Builder” and it is completely accurate! It’s especially powerful for ecommerce websites which includes sleek product pages and is completely responsive, dynamic, and integrates seamlessly with WooCommerce.
• Handmade – Handmade includes powerful ecommerce features such as a one-click demo importer, product filter widgets, and plenty of options to customize your online store.

For more Information and to build website using WordPress, Hire WordPress Developer from us as we provide you high quality services by utilizing all the latest themes, plugins and advanced technology. E-mail us any clock at – hello@hkinfosoft.com or Skype us: “hkinfosoft“.

To develop custom website, plugin or theme using WordPress, please visit our technology page.