';
}
}
}
}
}
/*
____ _ _ ____ _ ___ ____ _ ____ ___
| _ \| | | | __ )| | |_ _/ ___| / \ | _ \_ _|
| |_) | | | | _ \| | | | | / _ \ | |_) | |
| __/| |_| | |_) | |___ | | |___ / ___ \| __/| |
|_| \___/|____/|_____|___\____| /_/ \_\_| |___|
*/
// PUBLIC REUSABLE STATIC METHODS ----> START
/**
* PUBLIC | Checks if the installation is in development mode ( set by user on theme options )
* @since 1.0
*/
public static function is_developermode()
{
// Notice...comments MUST be disabled in this option call, to avoid endless loop between methods
$development = self::option(THEMEOPTION_PREFIX . 'dev', 0, 0, 0);
if ($development == 1) {
return 1;
}
return 0;
}
public static function get_version($what_version = 'current')
{
$version = '1.0';
switch ($what_version) {
case 'first_installed':
$version = get_option('plethora_theme_ver_installed_initial', $version);
break;
case 'current':
default:
$version = get_option(OPTNAME_THEME_VER, $version);
break;
}
return $version;
}
/**
* PUBLIC | Checks if the Plethora Library plugin is active
* @since 1.0
*/
public static function is_library_active()
{
if (!function_exists('is_plugin_active ')) {
include_once ABSPATH . 'wp-admin/includes/plugin.php';
}
if (is_plugin_active('plethora-featureslib/plethora_featureslib.php')) {
return true;
}
return false;
}
/**
* PUBLIC | Checks if the given feature is active
* @param $group ( feature group slug ), $slug ( feature slug )
* @since 1.0
*/
public static function is_feature_activated($controller, $feature)
{
// no margin for errors!
if (empty($controller) || empty($feature)) {return false;}
$feature = self::get_feature(array('controller' => $controller, 'feature' => $feature));
if (!empty($feature)) {
return isset($feature['theme_option_status']) ? $feature['theme_option_status'] : false;
}
return false;
}
/**
* PUBLIC
* Will return the page id for the current view.
* On blog, author, date, search and any taxonomy view, it will
* return the static page id ( if this is set by the user ).
* Notice: You should not treat this as an alternative of native WP get_the_id() function
*/
public static function get_this_page_id()
{
$page_id = 0;
if (is_home() || is_search() || is_category() || is_tag() || is_author() || is_date()) {
$page_id = get_option('page_for_posts');
} else {
$page_id = get_queried_object_id();
}
return apply_filters('plethora_this_page_id', $page_id);
}
/**
* PUBLIC
* Will return the associated post type for the current view.
* On blog, author, date, and search view, it will return 'post'.
* On a CPT archive or taxonomy view, it will return the associating CPT slug.
* Notice: You should not treat this as an alternative of native WP get_post_type() function.
*/
public static function get_this_view_post_type()
{
$object = get_queried_object();
$post_type = !empty($object->post_type) ? $object->post_type : get_post_type();
if (is_home() || is_search() || is_category() || is_tag() || is_author() || is_date()) {
$post_type = 'post';
} elseif (is_tax()) {
// find which taxonomy using the queried object
if (isset($object->taxonomy)) {
$get_post_type = self::get_post_type_by_taxonomy($object->taxonomy);
$post_type = isset($get_post_type[0]) ? $get_post_type[0] : 'post';
}
} elseif (is_archive()) {
$post_types = self::get_supported_post_types();
foreach ($post_types as $type) {
if (is_post_type_archive($type)) {
$post_type = $type;
}
}
}
return apply_filters('plethora_this_view_post_type', $post_type);
}
/**
* PUBLIC | Returns true if the current post_type is a archive view.
* Notice: We consider all listing display views ( post or CPT ) as archive pages
* Notice: Will work as expected after 'init' hook
* @since 1.0
*/
public static function is_archive_page()
{
$post_type = self::get_this_view_post_type();
if (!empty($post_type)) {
if (is_home()) {return true;} // This is blog
if (is_category() || is_tag() || is_tax() || is_author() || is_date()) {return true;} // if any type of taxonomy
if (is_search()) {return true;} // This is blog
if (is_post_type_archive($post_type)) {return true;} // if is a CPT archive
} else {
if (is_post_type_archive()) {return true;} // if is a CPT archive
}
return false;
}
/**
* PUBLIC
* It will return the saved DB value for the given option ID.
* The method check first if a post meta value exists. If nothing is found
* in post meta, it checks for the master value of the given ID on theme options.
* If again nothing is found, it returns the default value set on call.
* Notice: you should always give a specific postid when used in loop!
* The previously 4th 'comment' argument is deprecated after Xenia Theme
*/
public static function option($option_id, $user_value = '', $postid = 0, $deprecated = 1)
{
$postid = $postid == 0 ? self::get_this_page_id() : $postid; // if no postid is given, use self::get_the_ID().
$post_option_val = is_numeric($postid) ? get_post_meta($postid, $option_id, true) : ''; // If $postid is a number, then search first if post has saved a value for this option on its metaboxes
// If nothing is found on this post meta, then check theme defaults for this option, otherwise use value that set on option call
if ((is_array($post_option_val) && empty($post_option_val)) || (!is_array($post_option_val) && $post_option_val == '')) {
$theme_options = get_option(THEME_OPTVAR); // Use this please...NOT SAFE TO USE the global redux option
$theme_option_val = (isset($theme_options[$option_id])) ? $theme_options[$option_id] : $user_value;
$source = (isset($theme_options[$option_id])) ? 'Theme options value' : 'Value given on option call';
$option_val = $theme_option_val;
} else {
$option_val = $post_option_val;
$source = 'Post meta value';
}
// Return the value
return $option_val;
}
/**
* PUBLIC
* Echoes the given comment. Is activated only on frontend,
* while it will display the comment only if the installation
* runs in developer mode, and the specific comments group is activated.
*/
public static function dev_comment($comment = '', $commentgroup = '')
{
$commentgroup_status = self::option(THEMEOPTION_PREFIX . 'dev-' . $commentgroup, 'disable');
// All comment types ( except 'layout' and page_info )
if (!is_admin() && !is_feed() && self::is_developermode() && did_action('get_header') && current_user_can('manage_options') && $commentgroup_status === 'enable') {
switch ($commentgroup) {
case 'customization_info':
if (!empty($comment)) {
print_r("\n" . '' . "\n");
}
break;
case 'page_info':
$comment_parts = self::get_dev_comment_page_info();
if (!empty($comment_parts)) {
print_r("\n" . '' . "\n");
}
break;
case 'layout':
if (!empty($comment)) {
print_r("\n" . '' . "\n");
}
break;
}
}
}
/**
* PUBLIC | Returns native, Plethora CPTs and any non Plethora CPT that has frontend archive/single views.
* Notice: Will work as expected after 'init' hook
* @since 1.0
*/
public static function get_supported_post_types($args = array())
{
$default_args = array(
'type' => 'singles', // 'singles', 'archives'
'output' => 'names', // 'names' | 'objects'
'public' => true, // true/false for post types that have single post pages on frontend
'include' => array(), // include those post types in output
'exclude' => array(), // exclude those post types from output
'plethora_only' => false, // return only those that don't have Plethora frontend implementation ( this is checked according to Plethora_Posttype_ class )
);
// Merge user given arguments with default
$args = wp_parse_args($args, $default_args);
$args['include'] = is_array($args['include']) ? $args['include'] : array($args['include']); // Make sure that this will be an array
$args['exclude'] = is_array($args['exclude']) ? $args['exclude'] : array($args['exclude']); // Make sure that this will be an array
// get the built in first!
$builtin_post_types['post'] = get_post_type_object('post');
$builtin_post_types['page'] = get_post_type_object('page');
// now we want the CPT ones
$query_args = array('public' => $args['public'], '_builtin' => false);
$unfiltered_results = get_post_types($query_args, 'objects');
$unfiltered_results = array_merge($builtin_post_types, $unfiltered_results);
// Filtering according to arguments
$supported_posttypes = array();
foreach ($unfiltered_results as $post_type => $post_type_obj) {
// Check if this is excluded
if (!in_array($post_type, $args['exclude'])) {
// Get singles / archives
if ($args['type'] === 'singles' || (($args['type'] === 'archives' && !empty($post_type_obj->has_archive) && $post_type_obj->has_archive) || $post_type === 'post')) {
// Get plethora / non plethora
if ($args['plethora_only'] && class_exists('Plethora_Posttype_' . ucfirst($post_type))) {
$supported_posttypes[$post_type] = $args['output'] === 'objects' ? $post_type_obj : $post_type;
} elseif (!$args['plethora_only']) {
$supported_posttypes[$post_type] = $args['output'] === 'objects' ? $post_type_obj : $post_type;
}
}
}
}
if (!empty($args['include'])) {
foreach ($args['include'] as $post_type) {
$post_type_obj = get_post_type_object($post_type);
if (!is_null($post_type_obj)) {
$supported_posttypes[$post_type] = $args['output'] === 'objects' ? $post_type_obj : $post_type;
}
}
}
return apply_filters('plethora_supported_post_types', $supported_posttypes, $args);
}
public static function get_non_plethora_post_types($args = array())
{
$default_args = array(
'type' => 'singles', // 'singles', 'archives'
'output' => 'names', // 'names' | 'objects'
'public' => true, // true/false for post types that have single post pages on frontend
'include' => array(), // include those post types in output
'exclude' => array(), // exclude those post types from output
);
// Merge user given arguments with default
$args = wp_parse_args($args, $default_args);
unset($args['plethora_only']); // just in case
$args_plethora_only = $args;
$args_plethora_only['plethora_only'] = true;
$all_pts = self::get_supported_post_types($args);
$plethora_only_pts = self::get_supported_post_types($args_plethora_only);
$non_plethora_pts = array_diff_key($all_pts, $plethora_only_pts);
return $non_plethora_pts;
}
/**
* PUBLIC | Returns native, Plethora Taxonomies and any non Plethora CPT associated with supported public post types
* Notice: Will work as expected after 'init' hook
* @since 1.0
*/
public static function get_supported_taxonomies($args = array())
{
$default_args = array(
'output' => 'names', // 'names' | 'objects'
'public' => 'all', // true/false for public, 'all' for all taxonomies
'post_type' => array(), // array of post types, associating with the desired output
'include' => array(), // exclude those post types from output
'exclude' => array(), // include those post types in output
'plethora_only' => false, // return only those that don't have Plethora frontend implementation ( this is checked according to Plethora_Posttype_ class )
);
// Merge user given arguments with default
$args = wp_parse_args($args, $default_args);
$args['include'] = is_array($args['include']) ? $args['include'] : array($args['include']); // Make sure that this will be an array
$args['exclude'] = is_array($args['exclude']) ? $args['exclude'] : array($args['exclude']); // Make sure that this will be an array
$args['post_type'] = is_array($args['post_type']) ? $args['post_type'] : array($args['post_type']); // Make sure that this will be an array
// get the post types first!
$post_types = empty($args['post_type']) ? self::get_supported_post_types() : $args['post_type'];
$supported_taxonomies = array();
// get taxonomies, after excluding according to 'exclude' argument
foreach ($post_types as $post_type) {
$post_type_taxonomies = get_object_taxonomies($post_type, 'objects');
foreach ($post_type_taxonomies as $taxonomy_slug => $taxonomy_obj) {
if (!in_array($taxonomy_slug, $args['exclude']) && ($args['public'] === 'all' || $args['public'] === $taxonomy_obj->public)) {
if ($taxonomy_obj) {
$supported_taxonomies[$taxonomy_slug] = $taxonomy_obj;
}
}
}
}
// include taxomies requested on 'include' argument ( if are actual taxonomies and matching 'public' argument )
if (!empty($args['include'])) {
foreach ($args['include'] as $taxonomy_slug) {
$taxonomy_obj = get_taxonomy($taxonomy_slug);
if (!is_null($taxonomy_obj) && ($args['public'] === 'all' || $args['public'] === $taxonomy_obj->public)) {
$supported_taxonomies[$taxonomy_slug] = $args['output'] === 'objects' ? $taxonomy_obj : $taxonomy_slug;
}
}
}
return apply_filters('plethora_supported_taxonomies', $supported_taxonomies, $args);
}
/**
* PUBLIC | Passing script variables to theme.js file
* @param $var_group ( variables group name
* @param $vars ( array with values in key=>value format )
* @since 1.0
*/
public static function set_themeconfig($var_group, $vars = array())
{
if (!empty($var_group) && !empty($vars)) {
self::themeconfig($var_group, $vars);
}
}
/**
* PUBLIC | Will enqueue a handle's init script only if this is present on page
* @since 1.0
*/
public static function enqueue_init_script($args = array())
{
$default_args = array(
'handle' => '', // Main script(s) handle(s) WITHOUT PREFIX ( main script is the script that will be initialized )
'function' => '', // Function/Class method that returns the markup ( class method should be arrays )
'script' => '', // Ready script to enqueue...useful for scripts that have variable values
'header' => false, // If true, script will be included on header, otherwise on footer
'multiple' => false, // If true, script will be allowed to enqueued more than once
);
$args = wp_parse_args($args, $default_args); // MERGE GIVEN ARGS WITH DEFAULTS
// extract & verify arguments
extract($args);
$handle = !is_array($handle) ? $handle : array($handle);
$callback = empty($function) ? $script : $function; // select between func or normal script
if (empty($handle) || (empty($callback))) {return false;} // no point to continue
// Add init script to global array variable 'plethora_init_scripts'
global $plethora_init_scripts;
$plethora_init_scripts = empty($plethora_init_scripts) ? array() : $plethora_init_scripts; // avoid php warning if empty
if (!$multiple && array_key_exists($handle, $plethora_init_scripts)) {return true;} // exit if multiple not allowed and script exists
$plethora_init_scripts[$handle][] = array(
'callback_type' => empty($function) ? 'script' : 'function',
'callback' => $callback,
'position' => $header ? 'header' : 'footer',
);
return true;
}
/**
* PUBLIC
* Returns frontend feature template status, as set on the get_template_status method
* of the given feature class
* @return boolean
*/
public static function get_template_status($controller, $feature, $args = array())
{
$status = false;
if (!empty($controller) && !empty($feature)) {
$feature_instance = self::get_feature_instance($controller, $feature);
if (method_exists($feature_instance, 'get_template_status')) {
return (!empty($args)) ? $feature_instance->get_template_status($args) : $feature_instance->get_template_status();
}
}
return $status;
}
/**
* PUBLIC
* Returns frontend feature template configuration, as set on the get_template_config method
* of the given feature class
* @return array
*/
public static function get_template_config($controller, $feature, $args = array())
{
$config = array();
if (!empty($controller) && !empty($feature)) {
$feature_instance = self::get_feature_instance($controller, $feature);
if (method_exists($feature_instance, 'get_template_config')) {
return (!empty($args)) ? $feature_instance->get_template_config($args) : $feature_instance->get_template_config();
}
}
return $config;
}
/**
* PUBLIC | Adds attributes ( ie. class, id, style, etc. ) to core layout container tags
* @since 1.0
*/
public static function add_container_attr($container, $attr_name, $attr_values)
{
if (!empty($container) && !empty($attr_name) && !empty($attr_values)) {
// make sure that $attr_value is array
$attr_values_arr = is_array($attr_values) ? $attr_values : array($attr_values);
// make sure that an array record exists on $plethora global
global $plethora;
if (!isset($plethora['layout'][$container][$attr_name])) {
$plethora['layout'][$container][$attr_name] = array();
}
// add the user given values to the $plethora global
foreach ($attr_values_arr as $attr_value) {
$attr_value_key = sanitize_key($attr_value);
$plethora['layout'][$container][$attr_name][$attr_value_key] = $attr_value;
}
// finally add the filter
return add_filter('plethora_container_' . $container . '_atts', array('Plethora_Theme', 'filter_container_attr'));
}
return false;
}
/**
* PUBLIC | Remove attributes ( ie. class, id, style, etc. ) from core layout container tags
* @since 1.0
*/
public static function remove_container_attr($container, $attr_name, $attr_values = array())
{
if (!empty($container) && !empty($attr_name)) {
// make sure that $attr_value is array
$attr_values_arr = is_array($attr_values) ? $attr_values : array($attr_values);
global $plethora;
if (!empty($attr_values_arr)) {
foreach ($attr_values_arr as $attr_value) {
if (!empty($attr_value)) {
$attr_value_key = sanitize_key($attr_value);
unset($plethora['layout'][$container][$attr_name][$attr_value_key]);
// if attribute is empty of values, remove it completely
if (empty($plethora['layout'][$container][$attr_name])) {
unset($plethora['layout'][$container][$attr_name]);
}
}
}
} else {
unset($plethora['layout'][$container][$attr_name]);
}
// add the filter
return add_filter('plethora_container_' . $container . '_atts', array('Plethora_Theme', 'filter_container_attr'), 20);
}
return false;
}
/**
* PUBLIC | Will return page layout settings according to given post type.
* Works with all WP native and Plethora created single/archive pages
* Notice: you should follow the same layout option naming pattern for this to work with your CPTs
* Notice: Will work after 'init' hook
* @since 1.0
*/
public static function get_layout($post_type = '')
{
$post_type = empty($post_type) ? self::get_this_view_post_type() : $post_type;
if (is_search()) {
$layout = Plethora_Theme::option(METAOPTION_PREFIX . 'search-layout', 'right_sidebar');
} elseif (is_singular()) {
$layout = Plethora_Theme::option(METAOPTION_PREFIX . $post_type . '-layout', 'right_sidebar');
} elseif (self::is_archive_page()) {
$layout = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-layout', 'right_sidebar');
} elseif (is_404()) {
$layout = 'no_sidebar'; // layout for 404 is full by default
} else {
$layout = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-layout', 'right_sidebar');
}
// Filter and return layout key
return apply_filters('plethora_layout', $layout);
}
/**
* PUBLIC | Add a new template element.
*/
public static function add_element($container, $handle, $args)
{
if (empty($container) || empty($handle)) {return false;}
$default_args = array(
'container' => $container,
'handle' => $handle,
'file' => false,
'function' => false,
'html' => false,
'status' => true,
'priority' => 10,
'options' => array(),
);
$args = wp_parse_args($args, $default_args);
// Find the correct container section
if (in_array($container, array('head', 'head_before', 'body_open', 'header_topbar', 'header_main'))) {
$container_section = 'header';
} elseif (in_array($container, array('content_top', 'content_main_loop_before', 'content_main_loop', 'content_main_loop_after', 'content_bottom'))) {
$container_section = 'content';
} elseif (in_array($container, array('footer_top', 'footer_main', 'footer_bar'))) {
$container_section = 'footer';
} elseif ($container === 'mediapanel') {
$container_section = 'mediapanel';
}
global $plethora;
$plethora['add_elements'][$container_section][] = $args;
return true;
}
/**
* PUBLIC | Update an existing a template element.
* If the template element exists, the arguments will be merged.
* If the template element does not exist, nothing will happen.
*/
public static function update_element($container, $handle, $args)
{
if (empty($container) || empty($handle) || empty($args)) {return false;}
global $plethora;
$plethora['update_elements'][$container . '-' . $handle] = $args;
return true;
}
/**
* PUBLIC | Update a template element's option.
* If the option exists, it will be replaced with value given.
* If the option does not exists, it will be created.
*/
public static function update_element_option($container, $handle, $opt_name, $opt_val = '')
{
if (empty($container) || empty($handle) || empty($opt_name)) {return false;}
return self::update_element($container, $handle, array(
'options' => array($opt_name => $opt_val),
));
}
/**
* PUBLIC | Update a template element's display order.
* If the option exists, it will be replaced with value given.
* If the option does not exists, it will be created.
*/
public static function update_element_order($container, $handle, $order)
{
if (empty($container) || empty($handle) || empty($order)) {return false;}
return self::update_element($container, $handle, array(
'priority' => $order,
));
}
/**
* PUBLIC | Remove a template element
*/
public static function remove_element($container, $handle)
{
if (empty($container) || empty($handle)) {return false;}
global $plethora;
$plethora['remove_elements'][] = $container . '-' . $handle;
return true;
}
/**
* PUBLIC | Will return container type settings according to container
* $container: 'header', 'content' ( default ), 'footer', 'mediapanel'
* Works with all WP native and Plethora created single/archive pages
* Notice: you should follow the same container option naming pattern for this to work with your CPTs
* Notice: Will work after 'init' hook
* @since 1.4
*/
public static function get_container_type($container = 'content')
{
$container = empty($container) ? 'content' : $container;
switch ($container) {
case 'content':
default:
$post_type = self::get_this_view_post_type();
if (is_search()) {
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'search-containertype', 'container', 0, 0);
} elseif (is_singular()) {
$type = Plethora_Theme::option(METAOPTION_PREFIX . $post_type . '-containertype', 'container', 0, 0);
} elseif (self::is_archive_page()) {
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-containertype', 'container', 0, 0);
} elseif (is_404()) {
$type = Plethora_Theme::option(METAOPTION_PREFIX . '404-containertype', 'container', 0, 0);
} else {
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-containertype', 'container', 0, 0);
}
break;
case 'header':
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'header-container-type', 'container', 0, 0);
break;
case 'mediapanel':
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'mediapanel-container-type', 'container', 0, 0);
break;
case 'footer_top':
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'footer_top-container-type', 'container', 0, 0);
break;
case 'footer_main':
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'footer_main-container-type', 'container', 0, 0);
break;
case 'footer_bar':
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'footer_bar-container-type', 'container', 0, 0);
break;
case 'footer': // deprecated after Hotel Xenia
$type = Plethora_Theme::option(METAOPTION_PREFIX . 'footer-container-type', 'container', 0, 0);
break;
}
// Filter and return escaped value
$type = apply_filters('plethora_container_type', $type, $container);
return esc_attr($type);
}
/**
* PUBLIC | Prepares admin notice to be displayed on admin_notices() method call
*/
public static function add_admin_notice($handle, $args)
{
# Use only on admin views
if (!is_admin()) {return;}
# Default arguments configuration
$default_args = array(
'condition' => true, // Bool value..practicaly, this should be the admin display condition result
'theme' => array(THEME_SLUG => '1.0'), // Set the themes/versions that this notice should be displayed. The version should be the initial version
'theme_update_only' => false, // Display this notice only in case of theme update
'title' => '', // Notice title ( may be empty )
'notice' => '', // The main notice text
'type' => 'info', // 'info', 'success', 'warning', 'error'
'dismiss_text' => esc_html__('Dismiss this notice', 'plethora-framework'),
'links' => array(), // Array of arrays with links configuration
);
$args = wp_parse_args($args, $default_args); // MERGE GIVEN ARGS WITH DEFAULTS
//Check handle and add it to $plethora global variable
if (empty($handle)) {return;}
global $plethora;
$handle = !empty($plethora['admin_notices']) && array_key_exists($handle, $plethora['admin_notices']) ? $handle . '-2' : $handle;
$plethora['admin_notices'][$handle] = $args;
}
/**
* Locates template files within the given path and returns several administrating information.
*
* Since its main purpose is to return template files information and supported options, it will respect child theme templates/overrides if 'child_templates' argument is set to true.
* The $path parameter must contain a theme root folder path ( ie. '/templates/shortcodes'). It will return all meta values included in file, in a manner similar to
* the core style.css file.
*
* Arguments:
* array(
* 'filter_prefix' => '', Prefix string filter to match the beggining of the filename
* 'filter_suffix' => '', Prefix string filter to match the end of the filename
* 'meta_data' => false, If true, it will return meta data information
* 'supported_params' => array(), An array of arrays, such as array( 'param' => array( 'option_to_search1', 'option_to_search2' ) )
* 'child_templates' => true, If true, it will respect the parent/child theme hierarchy
* 'return' => 'all' 'all' will return full info, while 'basic' will return only a simple key => title array for use within a select option
* )
*
* Example return for shortcode-button.php and filter_prefix set to 'shortcode-':
* array(
* 'slug' => 'shortcode-button',
* 'slug_filtered' => 'shortcode-button',
* 'file_name' => 'button.php',
* 'file_path' => '\httdocs\wp-content\themes\mytheme\templates\shortcodes\shortcode-button.php',
* 'template_path' => 'templates/shortcodes/button.php',
* 'title' => 'Title given in file meta section if exists OR the filename capitalized and spaces instead of dashes/hyphens',
* 'params_supported' => array( 'supported_field1', 'supported_field2' ),
* {custom_key} => {custom value given in file}
* )
*
* You may add as many meta key/values needed on each file, required that they will be given on separate lines ( similar to the theme's style.css )
*
* @param string $path The directory path, relative to theme root folder ( ie. 'templates/shortcodes' )
* @param array $args An array with arguments ( check description )
* @return array It will return array with template information ( check description )
* @api Features API
* @since 2.0.1 New method added.
*/
public static function get_path_templates($rel_dir_path, $args = array())
{
$path_templates = array();
$args_defaults = array(
'filter_prefix' => '',
'filter_suffix' => '',
'meta_data' => false,
'supported_params' => array(),
'child_templates' => true,
'return' => 'all',
);
$args = wp_parse_args($args, $args_defaults);
extract($args);
$parent_dir = file_exists(PLE_THEME_DIR . '/' . $rel_dir_path) ? PLE_THEME_DIR . '/' . $rel_dir_path : false;
$child_dir = $child_templates && is_child_theme() && file_exists(PLE_CHILD_DIR . '/' . $rel_dir_path) ? PLE_CHILD_DIR . '/' . $rel_dir_path : false;
if (is_admin() && $parent_dir) {
// get parent files
$files_found = glob($parent_dir . '/' . $filter_prefix . '*' . $filter_suffix . '.php');
// merge with child files, if any
$child_files_found = array();
if ($child_dir) {
$child_files_found = glob($child_dir . '/' . $filter_prefix . '*' . $filter_suffix . '.php');
$files_found = array_merge($files_found, $child_files_found);
}
foreach ($files_found as $filepath) {
$filename_with_ext = basename($filepath);
$filename_no_ext = str_replace('.php', '', $filename_with_ext);
$slug_filtered = substr_replace($filename_no_ext, '', 0, strlen($filter_prefix));
$slug_filtered = substr_replace($slug_filtered, '', strlen($slug_filtered) - strlen($filter_suffix), strlen($filter_suffix));
$path_templates[$rel_dir_path . '/' . $filename_no_ext] = array(
'slug' => $filename_no_ext,
'slug_filtered' => $slug_filtered,
'file_name' => $filename_with_ext,
'file_path' => $filepath,
'template_path' => $rel_dir_path . '/' . $filename_no_ext,
'title' => Plethora_Helper::slug_to_title($filename_with_ext, 'all', '.php'),
);
if ($supported_params) { // find supported parameters and append them to the return value
$path_templates[$rel_dir_path . '/' . $filename_no_ext]['supported_params'] = self::get_supported_template_params($filepath, $supported_params);
}
if ($meta_data) { // find meta key/values and append them to the return value
$metas = self::get_file_meta($filepath);
foreach ($metas as $meta_key => $meta_val) {
if ($meta_key && !in_array($meta_key, array('slug', 'file_name', 'file_path', 'template_path'))) {
// if 'default' meta_key exists and is true, then add this information to the title
if ($meta_key === 'default' && $meta_val) {
$path_templates[$rel_dir_path . '/' . $filename_no_ext]['title'] = $path_templates[$rel_dir_path . '/' . $filename_no_ext]['title'] . ' ( default )';
}
$path_templates[$rel_dir_path . '/' . $filename_no_ext][$meta_key] = $meta_val;
}
}
}
}
}
return $path_templates;
}
/**
* Searches a file for meta data and returns them in key/value array
*
* It will return all key: value matches included within the first comment starting with /*! and ends with inverse string
*
* @param string $file_dir_path The full directory path ( ie. '/httpdocs/wp-content/theme/mytheme/templates/shortcodes/test.php' )
* @return array It will return array with all meta data in key/value array
* @api Features API
* @since 2.0.2 New method added.
*/
public static function get_file_meta($file_dir_path, $meta_key = 'all')
{
$file_meta = $meta_key === 'all' ? array() : '';
if (file_exists($file_dir_path)) {
$file_contents = Plethora_Helper::get_file_contents($file_dir_path);
$reg_pattern = '/\/\*\!(.*?)\!\*\//s';
preg_match_all($reg_pattern, $file_contents, $meta_raw, PREG_SET_ORDER, 0);
if (!empty($meta_raw[0][1])) {
$meta_reg_pattern = '/(?:[\n]{0,1})(\w+)(?:\ *:\ *)([^\n]*)(?:[\n]{0,1})/m';
preg_match_all($meta_reg_pattern, $meta_raw[0][1], $metas, PREG_SET_ORDER, 0);
foreach ($metas as $meta) {
$key = !empty($meta[1]) ? sanitize_key($meta[1]) : false;
$val = !empty($meta[2]) ? trim(esc_html($meta[2])) : '';
if ($key) {
// if $meta_key is not 'all', then compare with the current key and return accordingly
if ($meta_key !== 'all' && $meta_key === $key) {
return $val;
} elseif ($meta_key === 'all') {
// if 'default' key exists, make it a legit boolean value
if ($key === 'default') {
$val = in_array($val, array('1', 'true')) ? true : false;
}
$file_meta[$key] = $val;
}
}
}
}
}
return $file_meta;
}
/**
* PUBLIC | Will return container extra classes ( given by users on theme options / metaboxes )
* $container: 'header', 'content' ( default ), 'footer', 'mediapanel'
* Works with all WP native and Plethora created single/archive pages
* Notice: you should follow the same container option naming pattern for this to work with your CPTs
* Notice: Will work after 'init' hook
* @since 1.4
*/
public static function get_extra_class($container = 'content')
{
$container = empty($container) ? 'content' : $container;
switch ($container) {
case 'content':
default:
$post_type = self::get_this_view_post_type();
if (is_search()) {
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'search-extraclass', '');
} elseif (is_singular()) {
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . $post_type . '-extraclass', '');
} elseif (self::is_archive_page()) {
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-extraclass', '');
} elseif (is_404()) {
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . '404-extraclass', '');
} else {
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-extraclass', '');
}
break;
case 'header':
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'header-extraclass', '');
break;
case 'mediapanel':
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'mediapanel-extraclass', '');
break;
case 'footer':
$extra_class = Plethora_Theme::option(METAOPTION_PREFIX . 'footer-extraclass', '');
break;
}
// Filter and return escaped value
$extra_class = apply_filters('plethora_extra_class', $extra_class, $container);
return !empty($extra_class) ? esc_attr($extra_class) : '';
}
/**
* PUBLIC | Will return header layout_class
* $container: 'header', 'content' ( default ), 'footer', 'mediapanel'
* Works with all WP native and Plethora created single/archive pages
* Notice: you should follow the same container option naming pattern for this to work with your CPTs
* Notice: Will work after 'init' hook
* @since 1.4
*/
public static function get_header_layout_class()
{
$header_layout_class = Plethora_Theme::option(METAOPTION_PREFIX . 'header-layout', '');
// Filter and return escaped value
$header_layout_class = apply_filters('plethora_header_layout_class', $header_layout_class);
return !empty($header_layout_class) ? esc_attr($header_layout_class) : '';
}
/**
* PUBLIC | Will return main page layout settings according to given post type.
* Works with all WP native and Plethora created single/archive pages
* Notice: you should follow the same sidebar option naming pattern for this to work with your CPTs
* Notice: Will work as expected after 'init' hook
* @since 1.0
*/
public static function get_main_sidebar($post_type = '')
{
$post_type = empty($post_type) ? self::get_this_view_post_type() : $post_type;
// if showing a single page/post/cpt
if (is_search()) {
$sidebar = Plethora_Theme::option(METAOPTION_PREFIX . 'search-sidebar', 'sidebar-default');
} elseif (is_singular()) {
$sidebar = Plethora_Theme::option(METAOPTION_PREFIX . $post_type . '-sidebar', 'sidebar-default');
} elseif (self::is_archive_page()) {
$sidebar = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-sidebar', 'sidebar-default');
} else {
$sidebar = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-sidebar', 'sidebar-default');
}
// Filter and return sidebar key
return apply_filters('plethora_main_sidebar', $sidebar);
}
/**
* PUBLIC | Will return archive grid class according to settings.
* Works with all WP native and Plethora created archive pages
* Notice: you should follow the same grid type option naming pattern for this to work with your CPTs
* Notice: Will work as expected after 'init' hook
* @since 1.0
*/
public static function get_archive_list($args = array())
{
$default_args = array(
'output' => 'option', // 'option' | 'class'
'add_classes' => array(), // APPEND ADDITIONAL CLASSES WHEN 'output' == 'class'. In example, this will output a 'masonry boxed_children' class ( 'add_classes' => array( 'masonry' => array( 'boxed_children' ) ) )
);
$args = wp_parse_args($args, $default_args); // MERGE GIVEN ARGS WITH DEFAULTS
$output = array();
if (self::is_archive_page()) {
$post_type = self::get_this_view_post_type();
$list_type = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-listtype', 'classic');
if ($args['output'] === 'class') {
$output[] = $list_type;
if (isset($args['add_classes'][$list_type])) {
foreach ($args['add_classes'][$list_type] as $key => $addclass) {
$output[] = $addclass; // output classes setup
}
}
} else {
$output = $list_type; // output the option value
}
}
// APPLY FILTER ONLY ON CLASSES OUTPUT !!! )
if ($args['output'] === 'class') {
$output = apply_filters('plethora_archive_list_class', $output); // apply filters ONLY on classes output
}
return $output;
}
/**
* PUBLIC | Returns any Plethora post/archive title ( views: singular, archive, 404, search )
* @since 1.0
*/
public static function get_title($args = array())
{
$default_args = array(
'tag' => 'h2', // HTML tag ( leave empty for raw output )
'class' => array('post_title'), // HTML tag class(es)
'id' => '', // HTML tag id
'listing' => false, // this MUST be set 'true' for listing view requests ( will add a link too )
'link' => true, // adds a post link ( requires 'listing' set to true )
'force_display' => false, // force title display without checking for options
'post_type' => '', // force specific post type
'apply_filters' => true, // don't apply filters
);
$args = wp_parse_args($args, $default_args); // Merge user given arguments with default
$post_type = empty($args['post_type']) ? self::get_this_view_post_type() : $args['post_type'];
$title = '';
if (is_404()) {
$title = self::option(METAOPTION_PREFIX . '404-title-text', 1);
} elseif (is_search() && !$args['listing']) {
$display = $args['force_display'] ? true : self::option(THEMEOPTION_PREFIX . 'search-title', 1);
$title = $display ? self::option(THEMEOPTION_PREFIX . 'search-title-text', esc_html__('Search For:', 'plethora-framework')) . ' "' . get_search_query() . '"' : '';
} elseif (is_singular() || (self::is_archive_page() && $args['listing'])) {
$display_single = $args['force_display'] ? true : self::option(METAOPTION_PREFIX . $post_type . '-title', 1);
$display = self::is_archive_page() ? 1 : $display_single; // Special workaround for title display control ( different when in blog view )
if ($display && is_singular()) {
$title = get_the_title(get_queried_object_id());
} elseif ($display && $args['listing']) {
$title = get_the_title();
}
} elseif (self::is_archive_page() && !$args['listing'] || !self::is_library_active()) { // archive title ( contains a fix when PFL is inactive in order to display blog title out of the box )
$display = $args['force_display'] ? true : self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-title', 1);
$display_tax = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-title-tax', 1);
$display_author = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-title-author', 1);
$display_date = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-title-date', 1);
if ((is_category() || is_tag() || is_tax()) && $display_tax) { // taxonomy term
$title = $display ? strip_tags(single_term_title('', false)) : '';
} elseif (is_author() && $display_author) { // author display name
$title = $display ? strip_tags(get_the_author()) : '';
} elseif (is_date() && $display_date) { // month title
$title = $display ? strip_tags(single_month_title(' ', false)) : '';
} else { // default title
$title = $display ? self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-title-text', esc_html__('The Blog', 'plethora-framework')) : '';
}
}
// apply filters before final html tasks
$title = $args['apply_filters'] ? apply_filters('plethora_get_title', $title, $args) : $title;
if (!empty($title) && !empty($args['tag'])) {
$class = !empty($args['class']) ? ' class="' . esc_attr(implode(' ', $args['class'])) . '"' : '';
$id = !empty($args['id']) ? ' id="' . esc_attr($args['id']) . '"' : '';
$link_open = $args['listing'] && $args['link'] ? '' : '';
$link_close = $args['listing'] && $args['link'] ? '' : '';
$title = '<' . $args['tag'] . $class . $id . '>' . $link_open . esc_html($title) . $link_close . '';
}
return $title;
}
/**
* PUBLIC | Returns any Plethora post/archive subtitle ( views: singular, archive, 404, search )
* @since 1.0
*/
public static function get_subtitle($args = array())
{
$default_args = array(
'tag' => 'p', // HTML tag ( leave empty for raw output )
'class' => array('post_subtitle'), // HTML tag class(es)
'id' => '', // HTML tag id
'listing' => false, // this MUST be set 'true' for listing view requests
'force_display' => false, // force title display without checking for options
'post_type' => '', // force specific post type
'apply_filters' => true, // don't apply filters
);
// Merge user given arguments with default
$args = wp_parse_args($args, $default_args);
$post_type = empty($args['post_type']) ? self::get_this_view_post_type() : $args['post_type'];
$subtitle = '';
if (is_404()) {
$subtitle = self::option(METAOPTION_PREFIX . '404-subtitle-text', '');
} elseif (is_search() && !$args['listing']) {
$display = $args['force_display'] ? true : self::option(THEMEOPTION_PREFIX . 'search-subtitle', 1);
$subtitle = $display ? self::option(THEMEOPTION_PREFIX . 'search-subtitle-text', '') : '';
} elseif (is_singular() || $args['listing']) {
$display_single = $args['force_display'] ? true : self::option(METAOPTION_PREFIX . $post_type . '-subtitle', 1);
$display_archive = $args['force_display'] ? true : self::option(METAOPTION_PREFIX . 'archive' . $post_type . '-listing-subtitle', 1, get_the_id());
$display = $args['listing'] ? $display_archive : $display_single;
$subtitle = $display ? self::option(METAOPTION_PREFIX . $post_type . '-subtitle-text', '', get_the_id()) : '';
} elseif (self::is_archive_page() && !$args['listing']) { // archive subtitle
$display = $args['force_display'] ? true : self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-subtitle', 0);
$display_tax = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-tax-subtitle', 1);
$display_author = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-author-subtitle', 1);
$display_date = self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-date-subtitle', 0);
if ((is_category() || is_tag() || is_tax()) && $display_tax) { // taxonomy term description
$subtitle = $display ? strip_tags(term_description()) : '';
} elseif (is_author() && $display_author) { // author bio
$subtitle = $display ? strip_tags(get_the_author_meta('description')) : '';
} elseif (is_date() && $display_date) { // author bio
$subtitle = $display ? self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-subtitle-text', '') : '';
} else { // default subtitle
$subtitle = $display ? self::option(THEMEOPTION_PREFIX . 'archive' . $post_type . '-subtitle-text', '') : '';
}
}
// apply filters before final html tasks
$subtitle = $args['apply_filters'] ? apply_filters('plethora_get_subtitle', $subtitle, $args) : $subtitle;
if (!empty($subtitle) && !empty($args['tag'])) {
$class = !empty($args['class']) ? ' class="' . esc_attr(implode(' ', $args['class'])) . '"' : '';
$id = !empty($args['id']) ? ' id="' . esc_attr($args['id']) . '"' : '';
$subtitle = '<' . $args['tag'] . $class . $id . '>' . esc_html($subtitle) . '';
}
return $subtitle;
}
/**
* PUBLIC | Returns any content section colorset
* @since 1.0
*/
public static function get_content_colorset($post_type = '')
{
$post_type = empty($post_type) ? self::get_this_view_post_type() : $post_type;
$colorset = '';
if (is_404()) {
$colorset = Plethora_Theme::option(THEMEOPTION_PREFIX . '404-colorset');
} elseif (is_search()) {
$colorset = Plethora_Theme::option(THEMEOPTION_PREFIX . 'search-colorset');
} elseif (is_singular()) {
$colorset = Plethora_Theme::option(METAOPTION_PREFIX . $post_type . '-colorset');
} elseif (self::is_archive_page()) {
$colorset = Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-colorset');
}
return apply_filters('plethora_get_content_colorset', $colorset, $post_type);
}
/**
* PUBLIC | Returns Plethora listing content according to theme options
* Notice: Will not work outside the loop
* @since 1.0
*/
public static function get_listing_content($args = array())
{
if (!in_the_loop()) {return;} // not working outside loop
// those will by applied only on excerpt output
$default_args = array(
'listing' => false, // this MUST be set 'true' for listing view requests
'tag' => 'p', // HTML tag ( leave empty for raw output )
'class' => array(), // HTML tag class(es)
'id' => '', // HTML tag id
'force_display' => '', // 'excerpt'/'content' force a view without checking for options
);
// Merge user given arguments with default
$args = wp_parse_args($args, $default_args);
$args['force_display'] = $args['force_display'] === 'excerpt' || $args['force_display'] === 'content' ? $args['force_display'] : '';
$post_type = self::get_this_view_post_type();
$option = empty($args['force_display']) ? Plethora_Theme::option(METAOPTION_PREFIX . 'archive' . $post_type . '-listing-content', 'content', get_the_id()) : $args['force_display']; // Display Excerpt or Content?
switch ($option) {
case 'excerpt':
$output = get_the_excerpt('');
if (!empty($output) && !empty($args['tag'])) {
$class = !empty($args['class']) ? ' class="' . implode(' ', $args['class']) . '"' : '';
$id = !empty($args['id']) ? ' id="' . $args['id'] . '"' : '';
$output = '<' . $args['tag'] . $class . $id . '>' . $output . '';
}
return $output;
break;
default:
$output = get_the_content();
return apply_filters('the_content', $output);
break;
}
}
public static function get_post_content($args = array())
{
if (!in_the_loop()) {return;} // not working outside loop
$default_args = array(
'listing' => false,
'tag' => 'p', // HTML tag ( leave empty for raw output )
'class' => array(), // HTML tag class(es)
'id' => '', // HTML tag id
'force_display' => '', // 'excerpt'/'content' force a view without checking for options
'echo' => false, // true if you need to echo this output, false for return
'wp_link_pages' => true,
'wp_link_pages_before' => '