Introducing WP Core pluggin v2.0 - Developer friendly

This new update we are getting ready for you has a ton of new updates and here we will bring some of these new ideas and builds to you before the release that is to follow soon.

The main goal of this plugin was to change it from the plugin that brings Ziggeo to WordPress to a Core plugin that does so much more.

In the same time as it does that, to also be very friendly to the WordPress devs looking for quick and simple ways of utilizing the power of video Zigggeo brings.

This is achieved by several main ways:

JS class that you can ping at any time and utilize for your requirements
JS Hooks to hook into different aspects of the plugin on client side
PHP Hooks (actions and filters) to hook into different sections of the back end
Simple AJAX support
Improved way to hook into the addons/integrations page with your own plugin
Own usage of the same hooks, allowing you to quickly see examples of how we are using them and making awesome changes.

JS class

Lets face it, it is super easy to just post different options to the window object. While easy it makes it hard to find and use in your own plugin.

We have created ZiggeoWP object that you can access and which holds the details that you might need or want to use.

JS Hooks

Most common thing to see in Wordpress is action and filter setup. Sometimes just one filter or one action is all you need to bring the functionality you need or want.

We also added JS based hooks working in a similar fashion. This makes it super easy to hook into various segments, from templates editor to API.

PHP Hooks

We have added almost 30 hooks for you. To be specific it is 18 filters and 10 actions.

Now only did we add the hooks, we also looked to utilize our own hooks as much as possible. All of the hook examples can be found in a single file making it easy to find, edit, and re-utilize.

This is the list of the actions you will have available:

Current user hook
```
add_action('ziggeo_get_user_modify', 'your-function-name');
```
* Allows you to change the details of the current user. Useful if you want to change the name of the current user or alter some other details before they are used by our plugin.
Default recorder template code
```
add_action('ziggeo_get_template_recorder_default', 'your-function-name');
```
* Allows you to change the code that is used as recorder default
Default comments recorder template name
```
add_action('ziggeo_get_template_recorder_comments', 'your-function-name');
```
* Allows you to change the template name that is used as default for comments recorder
Default player template code
```
add_action('ziggeo_get_template_player_default', 'your-function-name');
```
* Allows you to change the code that is used as player default
Default comments player template name
```
add_action('ziggeo_get_template_player_comments', 'your-function-name');
```
* Allows you to change the template name that is used as default for comments player
Add custom code or messages to templates editor
```
add_action('ziggeo_settings_before_editor', 'your-function-name');
```
* Allows you to pass any info into the templates editor. This will output the code right above the editor textarea.
Add your own code after the assets have been registered and loaded
```
add_action('ziggeo_assets_post', 'your-function-name');
```
* Allows you to output your own code after all other assets have been loaded.
Add custom data points within ZiggeoWP object, allowing things to be within the same namespace
```
add_action('ziggeo_add_to_ziggeowp_object', 'your-function-name');
```
* Useful if you are creating a plugin and want to keep everything within the ZiggeoWP object
Add your own buttons into the toolbar above the posts
```
add_action('ziggeo_toolbar_button', 'your-function-name');
```
* Useful when you want specific embedding type to be used for recording as you add or edit posts
Have an integration that connects our plugin with some other? Show it in the Ziggeo's Integrations page
```
add_action('ziggeo_list_integration', 'your-function-name');
```
* This makes it possible for your plugin to run, yet in the same time for people to disable it from processing Ziggeo codes

This is the list of the filters you will have available:

v2 application creation hook
```
add_filter('ziggeo_setting_header_code', 'your-function-name');
```
* Allows you to modify any options used to create the V2 application by hooking into that hook
Change which templates are available when you use Ziggeo plugin (like ziggeoplayer, ziggeorecorder, ziggeovideowall, etc.)
```
add_filter('ziggeo_manage_template_options_pre', 'your-function-name');
```
* Allows you to extend the plugin and create your own custom templates to which you can react and fully customize.
Version and revision hook
```
add_filter('ziggeo_assets_init', 'your-function-name');
```
+ Allows you to influence which revision (and version) of our file should be loaded dynamically by hooking into it
Comments recorder JS code output
```
add_filter('ziggeo_comments_js_template_vrto', 'your-function-name', 10, 2);
```
* If you want to change the JS code that is outputted to the browser when video comments recorder is requested (video required and text optional) this hook will allow you to change all JS code
Pre template search
```
add_filter('ziggeo_content_filter_pre', 'your-function-name');
```
* Allows you to grab and inspect or modify the content that is about to be checked for ziggeo templates
Post template search
```
add_filter('ziggeo_content_filter_post', 'your-function-name');
```
* Allows you to grab and inspect or modify the content that was checked for ziggeo templates
Recorder tags
```
add_filter('ziggeo_template_parsing_tag_set', 'your-function-name', 10, 2);
```
* Allows you to change the tag that is added as the location where the recording is taking place.
Template Parameters list
```
add_filter('ziggeo_template_parameters_list');
```
* Allows you to change the array of accepted parameters. useful to add your own that you want to change before embedding is used.
Available Template bases
```
add_filter('ziggeo_setting_available_templates', 'your-function-name');
```
* Allows developers to create their own base and code based around it
Filter custom tags from content having our embedding codes
```
add_filter('ziggeo_custom_tags_processing', 'your-function-name');
```
* Allows you to extend the available tags you can use in your embedding. It is recommended to use percentage around it like %TAG%
Add custom sections into the simple / easy templates builder
```
add_filter('ziggeo_templates_editor_easy_parameters_section', 'your-function-name');
```
* Allows you to add your own section to the parameters editor (simple)
Add custom sections into the advanced templates builder
```
add_filter('ziggeo_templates_editor_advanced_parameters_section', 'your-function-name');
```
* Allows you to add your own section to the parameters editor (advanced)
Add your own assets or code before main JS and CSS files are called from servers
```
add_filter('ziggeo_assets_pre_server_load', 'your-function-name');
```
* Allows you to add comments before the HTML code output and output your own code
Add your own assets or code after main JS and CSS files are called from servers
```
add_filter('ziggeo_assets_pre_local_load', 'your-function-name');
```
* Allows you to close comments after the HTML code output for scripts and output your own code
Use AJAX hooks to get notified when AJAX call was made through Ziggeo core. Allows plugin developers to listen for specific plugin related calls
```
add_filter('ziggeo_ajax_call' 'your-function-name');
```
* for calls originating from Admin side
```
add_filter('ziggeo_ajax_call_client' 'your-function-name');
```
* for calls originating from Public side
Make sure core functions do not process your new parameters
```
add_filter('ziggeo_parameter_prep_skip_list' 'your-function-name');
```
+ Useful when adding new parameters that should not be handled by the core functions

Simple AJAX support

Wordpress has an easy way to add AJAx to the plugin and theme. Still in case you want to, there is also AJAX implementation through the core Ziggeo plugin. It allows the plugin to listen to the message submitted to servers and react when needed.

Integrations page

Our plugin had an integrations tab. In it you would see the integrations that would connect our plugin to some other plugin, like Gravity Forms integration.

Instead of creating modules of our plugin that are not as easy to manage or hook into the plugin, we made it possible for you to hook into from your theme or plugin through the use of simple hook.

Once present, it allows administrators to disable the integration itself while still leaving your plugin running, if that is what their workflow is all about.

This also allows us to have the least amount of code running. The old modules approach would load everything and then decide if it is used or not. This new approach however allows you to install only the things you will actually be using.

Utilizing own hooks

Any type of documentation is helpful. Having comments in the code is another layer that helps around the same. Still seeing the exact codes that can be used, and how they are used is always the best way to get things done quickly and easily.

What's next?

We will post on the forum a bit more about the new updates. We will do this before the update is released as well as after we do. We are also looking to release several different integrations following this.

What you can expect are integrations for:

To make it simple to update and maintain as well , the videowalls will be moved into a new plugin on its own within few new revisions of the plugin.

Of course as this happens, the same calls and hooks will still be utilized, so that the switch is easy and simple :)

Have a question or suggestion? Comment and let us know.