843 lines
22 KiB
PHP
843 lines
22 KiB
PHP
<?php
|
|
/**
|
|
* Managed collection of fields
|
|
* @package Simple Lightbox
|
|
* @subpackage Fields
|
|
* @author Archetyped
|
|
*/
|
|
class SLB_Field_Collection extends SLB_Field_Base {
|
|
|
|
/* Configuration */
|
|
|
|
protected $mode = 'sub';
|
|
|
|
/* Properties */
|
|
|
|
/**
|
|
* Item type
|
|
* @var string
|
|
*/
|
|
public $item_type = 'SLB_Field';
|
|
|
|
/**
|
|
* Indexed array of items in collection
|
|
* @var array
|
|
*/
|
|
public $items = array();
|
|
|
|
public $build_vars_default = array(
|
|
'groups' => array(),
|
|
'context' => '',
|
|
'layout' => 'form',
|
|
'build' => true,
|
|
'build_groups' => true,
|
|
);
|
|
|
|
/**
|
|
* Associative array of groups in collection
|
|
* Key: Group ID
|
|
* Value: object of group properties
|
|
* > id
|
|
* > title
|
|
* > description string Group description
|
|
* > items array Items in group
|
|
* @var array
|
|
*/
|
|
public $groups = array();
|
|
|
|
protected $properties_init = null;
|
|
|
|
/* Constructors */
|
|
|
|
/**
|
|
* Class constructor
|
|
* @uses parent::__construct()
|
|
* @uses self::make_properties()
|
|
* @uses self::init()
|
|
* @uses self::add_groups()
|
|
* @uses self::add_items()
|
|
* @param string $id Collection ID
|
|
* @param array $properties (optional) Properties to set for collection (Default: none)
|
|
*/
|
|
public function __construct( $id, $properties = null ) {
|
|
$args = func_get_args();
|
|
$properties = $this->make_properties( $args );
|
|
// Parent constructor
|
|
parent::__construct( $properties );
|
|
|
|
// Save initial properties
|
|
$this->properties_init = $properties;
|
|
}
|
|
|
|
public function _init() {
|
|
parent::_init();
|
|
|
|
// Load properties.
|
|
$this->load( $this->properties_init, false );
|
|
|
|
// Add custom ID format(s).
|
|
$this->add_id_format(
|
|
'formatted',
|
|
[
|
|
'wrap' => [ 'open' => '_' ],
|
|
'prefix' => [ 'get_prefix' ],
|
|
'recursive' => false,
|
|
]
|
|
);
|
|
}
|
|
|
|
/*-** Getters/Setters **-*/
|
|
|
|
/* Setup */
|
|
|
|
/**
|
|
* Load collection with specified properties
|
|
* Updates existing properties
|
|
* @param array $properties Properties to load
|
|
* @param bool $update (optional) Update (TRUE) or overwrite (FALSE) items/groups (Default: TRUE)
|
|
* @return object Current instance
|
|
*/
|
|
public function load( $properties, $update = true ) {
|
|
$args = func_get_args();
|
|
$properties = $this->make_properties( $args );
|
|
if ( ! empty( $properties ) ) {
|
|
// Groups
|
|
if ( isset( $properties['groups'] ) ) {
|
|
$this->add_groups( $properties['groups'], $update );
|
|
}
|
|
// Items
|
|
if ( isset( $properties['items'] ) ) {
|
|
$this->add_items( $properties['items'], $update );
|
|
}
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/* Data */
|
|
|
|
/**
|
|
* Retrieve external data for items in collection
|
|
* Retrieved data is saved to the collection's $data property
|
|
* Uses class properties to determine how data is retrieved
|
|
* Examples:
|
|
* > DB
|
|
* > XML
|
|
* > JSON
|
|
* @return void
|
|
*/
|
|
function load_data() {
|
|
$this->data_loaded = true;
|
|
}
|
|
|
|
/**
|
|
* Set data for an item
|
|
* @param mixed $item Field to set data for
|
|
* > string Field ID
|
|
* > object Field Reference
|
|
* > array Data for multiple items (associative array [field ID => data])
|
|
* @param mixed $value Data to set
|
|
* @param bool $save (optional) Whether or not data should be saved to DB (Default: Yes)
|
|
*/
|
|
function set_data( $item, $value = '', $save = true, $force_set = false ) {
|
|
// Set data for entire collection
|
|
if ( is_array( $item ) ) {
|
|
$this->data = wp_parse_args( $item, $this->data );
|
|
// Update save option
|
|
$args = func_get_args();
|
|
if ( 2 === count( $args ) && is_bool( $args[1] ) ) {
|
|
$save = $args[1];
|
|
}
|
|
} elseif ( is_object( $item ) && method_exists( $item, 'get_id' ) ) {
|
|
// Get $item's ID
|
|
$item = $item->get_id();
|
|
}
|
|
// Set data
|
|
if ( is_string( $item ) && ! empty( $item ) && ( isset( $this->items[ $item ] ) || ! ! $force_set ) ) {
|
|
$this->data[ $item ] = $value;
|
|
}
|
|
if ( ! ! $save ) {
|
|
$this->save();
|
|
}
|
|
}
|
|
|
|
/* Item */
|
|
|
|
/**
|
|
* Adds item to collection
|
|
* @param string|obj $id Unique name for item or item instance
|
|
* @param array $properties (optional) Item properties
|
|
* @param bool $update (optional) Update or overwrite existing item (Default: FALSE)
|
|
* @return object Newly-added item
|
|
*/
|
|
function add( $id, $properties = array(), $update = false ) {
|
|
$item = null;
|
|
$args = func_get_args();
|
|
// Get properties.
|
|
foreach ( array_reverse( $args ) as $arg ) {
|
|
if ( is_array( $arg ) ) {
|
|
$properties = $arg;
|
|
break;
|
|
}
|
|
}
|
|
if ( ! is_array( $properties ) ) {
|
|
$properties = array();
|
|
}
|
|
|
|
// Prep item.
|
|
if ( $id instanceof $this->item_type ) {
|
|
// Use existing item.
|
|
$item = $id;
|
|
$item->set_properties( $properties );
|
|
} elseif ( class_exists( $this->item_type ) ) {
|
|
// Create new item.
|
|
$defaults = array(
|
|
'parent' => null,
|
|
'group' => null,
|
|
);
|
|
$properties = array_merge( $defaults, $properties );
|
|
if ( is_string( $id ) ) {
|
|
$properties['id'] = $id;
|
|
}
|
|
if ( ! ! $update && $this->has( $properties['id'] ) ) {
|
|
// Update existing item
|
|
$item = $this->get( $properties['id'] );
|
|
$item->set_properties( $properties );
|
|
} else {
|
|
// Init item
|
|
$type = $this->item_type;
|
|
$item = new $type( $properties );
|
|
}
|
|
}
|
|
|
|
if ( empty( $item ) || strlen( $item->get_id() ) === 0 ) {
|
|
return false;
|
|
}
|
|
|
|
// Set container
|
|
$item->set_container( $this );
|
|
|
|
// Add item to collection
|
|
$this->items[ $item->get_id() ] = $item;
|
|
|
|
if ( isset( $properties['group'] ) ) {
|
|
$this->add_to_group( $properties['group'], $item->get_id() );
|
|
}
|
|
|
|
return $item;
|
|
}
|
|
|
|
/**
|
|
* Removes item from collection
|
|
* @param string|object $item Object or item ID to remove
|
|
* @param bool $save (optional) Whether to save the collection after removing item (Default: YES)
|
|
*/
|
|
function remove( $item, $save = true ) {
|
|
// Remove item
|
|
if ( $this->has( $item ) ) {
|
|
$item = $this->get( $item );
|
|
$item = $item->get_id();
|
|
// Remove from items array
|
|
unset( $this->items[ $item ] );
|
|
// Remove item from groups
|
|
$this->remove_from_group( $item );
|
|
}
|
|
// Remove item data from collection
|
|
$this->remove_data( $item, false );
|
|
|
|
if ( ! ! $save ) {
|
|
$this->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove item data from collection
|
|
* @param string|object $item Object or item ID to remove
|
|
* @param bool $save (optional) Whether to save the collection after removing item (Default: YES)
|
|
*/
|
|
function remove_data( $item, $save = true ) {
|
|
// Get item ID from object
|
|
if ( $this->has( $item ) ) {
|
|
$item = $this->get( $item );
|
|
$item = $item->get_id();
|
|
}
|
|
|
|
// Remove data from data member
|
|
if ( is_string( $item ) && is_array( $this->data ) ) {
|
|
unset( $this->data[ $item ] );
|
|
if ( ! ! $save ) {
|
|
$this->save();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if item exists in the collection.
|
|
*
|
|
* @param string|object $item Item ID or instance.
|
|
* @return bool True if item is in collection, False otherwise.
|
|
*/
|
|
function has( $item ) {
|
|
// Item ID.
|
|
if ( is_string( $item ) ) {
|
|
return in_array( $item, array_keys( $this->get_items() ), true );
|
|
}
|
|
// Item instance.
|
|
if ( $item instanceof $this->item_type ) {
|
|
$items = $this->get_items( null, false );
|
|
$id = $item->get_id();
|
|
return ( isset( $items[ $id ] ) && $item === $items[ $id ] );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Retrieve specified item in collection.
|
|
*
|
|
* @param string|object $item Item ID or instance to retrieve.
|
|
* @return SLB_Field|null Specified item. Null if item is not in collection.
|
|
*/
|
|
function get( $item, $safe_mode = false ) {
|
|
$invalid = null;
|
|
// Stop processing if item is not in collection.
|
|
if ( ! $this->has( $item ) ) {
|
|
return $invalid;
|
|
}
|
|
// Get item instance from ID.
|
|
if ( is_string( $item ) ) {
|
|
$items = $this->get_items( null, false );
|
|
if ( isset( $items[ $item ] ) ) {
|
|
$item = $items[ $item ];
|
|
}
|
|
}
|
|
// Return valid item instance.
|
|
if ( $item instanceof $this->item_type ) {
|
|
return $item;
|
|
}
|
|
// Invalid item.
|
|
return $invalid;
|
|
}
|
|
|
|
/**
|
|
* Retrieve item data
|
|
* @param $item Item to get data for
|
|
* @param $context (optional) Context
|
|
* @param $top (optional) Iterate through ancestors to get data (Default: Yes)
|
|
* @return mixed|null Item data. Null if no data retrieved.
|
|
*/
|
|
function get_data( $item = null, $context = '', $top = true ) {
|
|
$this->load_data();
|
|
$ret = null;
|
|
if ( $this->has( $item ) ) {
|
|
$item = $this->get( $item );
|
|
$ret = $item->get_data( $context, $top );
|
|
} else {
|
|
$ret = parent::get_data( $context, $top );
|
|
}
|
|
|
|
if ( is_string( $item ) && is_array( $ret ) && isset( $ret[ $item ] ) ) {
|
|
$ret = $ret[ $item ];
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/* Items (Collection) */
|
|
|
|
/**
|
|
* Add multiple items to collection
|
|
* @param array $items Items to add to collection
|
|
* Array Structure:
|
|
* > Key (string): Item ID
|
|
* > Val (array): Item properties
|
|
* @return void
|
|
*/
|
|
function add_items( $items = array(), $update = false ) {
|
|
// Validate
|
|
if ( ! is_array( $items ) || empty( $items ) ) {
|
|
return false;
|
|
}
|
|
// Add items
|
|
foreach ( $items as $id => $props ) {
|
|
$this->add( $id, $props, $update );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve reference to items in collection
|
|
* @return array Collection items (reference)
|
|
*/
|
|
function &get_items( $group = null, $sort = 'priority' ) {
|
|
$gset = $this->group_exists( $group );
|
|
if ( $gset ) {
|
|
$items = $this->get_group_items( $group );
|
|
} elseif ( ! empty( $group ) ) {
|
|
$items = array();
|
|
} else {
|
|
$items = $this->items;
|
|
}
|
|
if ( ! empty( $items ) ) {
|
|
// Sort items
|
|
if ( ! empty( $sort ) && is_string( $sort ) ) {
|
|
if ( 'priority' === $sort ) {
|
|
if ( $gset ) {
|
|
// Sort by priority
|
|
ksort( $items, SORT_NUMERIC );
|
|
}
|
|
}
|
|
}
|
|
// Release from buckets
|
|
if ( $gset ) {
|
|
$items = call_user_func_array( 'array_merge', $items );
|
|
}
|
|
}
|
|
return $items;
|
|
}
|
|
|
|
/**
|
|
* Build output for items in specified group
|
|
* If no group specified, all items in collection are built
|
|
* @param string|object $group (optional) Group to build items for (ID or instance object)
|
|
*/
|
|
function build_items( $group = null ) {
|
|
// Get group items
|
|
$items =& $this->get_items( $group );
|
|
if ( empty( $items ) ) {
|
|
return false;
|
|
}
|
|
|
|
$this->util->do_action_ref_array( 'build_items_pre', array( $this ) );
|
|
foreach ( $items as $item ) {
|
|
$item->build();
|
|
}
|
|
$this->util->do_action_ref_array( 'build_items_post', array( $this ) );
|
|
}
|
|
|
|
/* Group */
|
|
|
|
/**
|
|
* Sanitizes group ID.
|
|
*
|
|
* @param string $id Group ID.
|
|
* @param bool $fallback Optional. Use fallback group if ID is invalid. Default true.
|
|
* @return string Sanitized group ID.
|
|
*/
|
|
protected function sanitize_group_id( $id, $fallback = true ) {
|
|
// Sanitize.
|
|
$id = sanitize_title_with_dashes( $id );
|
|
// Use default ID (fallback).
|
|
if ( strlen( $id ) === 0 && ! ! $fallback ) {
|
|
$id = 'default';
|
|
}
|
|
return $id;
|
|
}
|
|
|
|
/**
|
|
* Add groups to collection
|
|
* @param array $groups Associative array of group properties
|
|
* Array structure:
|
|
* > Key (string): group ID
|
|
* > Val (string): Group Title
|
|
*/
|
|
function add_groups( $groups = array(), $update = false ) {
|
|
// Validate
|
|
if ( ! is_array( $groups ) || empty( $groups ) ) {
|
|
return false;
|
|
}
|
|
// Iterate
|
|
foreach ( $groups as $id => $props ) {
|
|
$this->add_group( $id, $props, null, $update );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds group to collection
|
|
* Groups are used to display related items in the UI
|
|
* @param string $id Unique name for group
|
|
* @param string $title Group title
|
|
* @param string $description Short description of group's purpose
|
|
* @param array $items (optional) ID's of existing items to add to group
|
|
* @return object Group object
|
|
*/
|
|
function &add_group( $id, $properties = array(), $items = array(), $update = false ) {
|
|
// Create new group and set properties
|
|
$default = array(
|
|
'title' => '',
|
|
'description' => '',
|
|
'priority' => 10,
|
|
);
|
|
$p = ( is_array( $properties ) ) ? array_merge( $default, $properties ) : $default;
|
|
if ( ! is_int( $p['priority'] ) || $p['priority'] < 0 ) {
|
|
$p['priority'] = $default['priority'];
|
|
}
|
|
$id = $this->sanitize_group_id( $id );
|
|
// Retrieve or init group
|
|
if ( ! ! $update && $this->group_exists( $id ) ) {
|
|
$grp = $this->get_group( $id );
|
|
$grp->title = $p['title'];
|
|
$grp->description = $p['description'];
|
|
$grp->priority = $p['priority'];
|
|
} else {
|
|
$this->groups[ $id ] =& $this->create_group( $id, $p['title'], $p['description'], $p['priority'] );
|
|
}
|
|
// Add items to group (if supplied)
|
|
if ( ! empty( $items ) && is_array( $items ) ) {
|
|
$this->add_to_group( $id, $items );
|
|
}
|
|
return $this->groups[ $id ];
|
|
}
|
|
|
|
/**
|
|
* Remove specified group from collection
|
|
* @param string $id Group ID to remove
|
|
*/
|
|
function remove_group( $id ) {
|
|
$id = trim( $id );
|
|
if ( $this->group_exists( $id ) ) {
|
|
unset( $this->groups[ $id ] );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new item group.
|
|
*
|
|
* @param string $title Group title (used in meta boxes, etc.)
|
|
* @param string $description Short description of group's purpose
|
|
* @param int $priority (optional) Group priority (e.g. used to sort groups during output)
|
|
* @return object {
|
|
* Group object.
|
|
*
|
|
* @type string $id ID.
|
|
* @type string $title Title.
|
|
* @type string $description Description.
|
|
* @type int $priority Priority (relative to other groups in collection).
|
|
* @type array $items {
|
|
* Group items. Grouped by item priority.
|
|
* Items indexed by item ID.
|
|
* Example: `$items[10]['item_id'] = {item}
|
|
* }
|
|
* }
|
|
*/
|
|
function &create_group( $id = '', $title = '', $description = '', $priority = 10 ) {
|
|
// Create new group object
|
|
$group = new stdClass();
|
|
/* Set group properties */
|
|
// Set ID
|
|
$id = ( is_scalar( $id ) ) ? trim( $id ) : '';
|
|
$group->id = $id;
|
|
// Set Title
|
|
$title = ( is_scalar( $title ) ) ? trim( $title ) : '';
|
|
$group->title = $title;
|
|
// Set Description
|
|
$description = ( is_scalar( $description ) ) ? trim( $description ) : '';
|
|
$group->description = $description;
|
|
// Priority
|
|
$group->priority = ( is_int( $priority ) ) ? $priority : 10;
|
|
// Create array to hold items
|
|
$group->items = array();
|
|
return $group;
|
|
}
|
|
|
|
/**
|
|
* Checks if group exists in collection.
|
|
*
|
|
* @param string|object $id Group name or object.
|
|
* @return bool True if group exists, False otherwise.
|
|
*/
|
|
function group_exists( $group ) {
|
|
if ( is_object( $group ) ) {
|
|
return true;
|
|
}
|
|
if ( ! is_string( $group ) ) {
|
|
return false;
|
|
}
|
|
$group = $this->sanitize_group_id( $group );
|
|
if ( strlen( $group ) === 0 ) {
|
|
return false;
|
|
}
|
|
// Check if group exists
|
|
return ( ! is_null( $this->get_member_value( 'groups', $group, null ) ) );
|
|
}
|
|
|
|
/**
|
|
* Adds item to a group in the collection.
|
|
*
|
|
* Group is created if it does not already exist.
|
|
*
|
|
* @param string|array $group {
|
|
* Group ID (or parameters array) to add item to.
|
|
*
|
|
* Array structure:
|
|
*
|
|
* @type string $0 Group ID.
|
|
* @type int $1 Item priority in group.
|
|
* }
|
|
* @param string|object|array $items Item ID/Instance or array of items to add to group.
|
|
* @param int $priority Optional. Default priority to set for items in group. Default 10.
|
|
* @return bool True if item(s) successfully added to group.
|
|
* False if item(s) not added to group.
|
|
*/
|
|
function add_to_group( $group, $items, $priority = 10 ) {
|
|
// Validate.
|
|
if ( empty( $items ) || empty( $group ) || ( ! is_string( $group ) && ! is_array( $group ) ) ) {
|
|
return false;
|
|
}
|
|
// Parse group properties.
|
|
if ( is_string( $group ) ) {
|
|
$gid = $group;
|
|
} elseif ( is_array( $group ) ) {
|
|
$group = array_values( $group );
|
|
if ( count( $group ) < 2 ) {
|
|
$group[] = $priority;
|
|
}
|
|
list( $gid, $priority ) = $group;
|
|
}
|
|
|
|
// Format group ID.
|
|
$gid = $this->sanitize_group_id( $gid );
|
|
if ( strlen( $gid ) === 0 ) {
|
|
return false;
|
|
}
|
|
|
|
// Item priority.
|
|
$priority = (int) $priority;
|
|
|
|
// Prepare items
|
|
if ( ! is_array( $items ) ) {
|
|
$items = [ $items ];
|
|
}
|
|
|
|
// Add Items.
|
|
$items_skipped = [];
|
|
foreach ( $items as $item ) {
|
|
// Skip if item is not in current collection.
|
|
$itm_ref = $this->get( $item );
|
|
if ( ! $itm_ref ) {
|
|
$items_skipped[] = $item;
|
|
continue;
|
|
}
|
|
// Remove item from all groups (items can only be in one group).
|
|
$this->remove_from_group( $itm_ref );
|
|
// Add reference to item in group.
|
|
$items =& $this->get_group( $gid )->items;
|
|
// Ensure priority level exists for group.
|
|
if ( ! isset( $items[ $priority ] ) ) {
|
|
$items[ $priority ] = array();
|
|
}
|
|
// Add item to group.
|
|
$items[ $priority ][ $itm_ref->get_id() ] = $itm_ref;
|
|
}
|
|
unset( $itm_ref );
|
|
return ( count( $items_skipped ) < count( $items ) );
|
|
}
|
|
|
|
/**
|
|
* Removes item from a group.
|
|
*
|
|
* If group is not specified, item is removed from all groups.
|
|
*
|
|
* @param string|object $item ID or object of item to remove from group.
|
|
* @param string|object|array $groups Optional. Group(s) to remove item from. Default null.
|
|
* - @type string Group ID.
|
|
* - @type object Group object.
|
|
* - @type array Multiple groups (ID or object).
|
|
* @return void
|
|
*/
|
|
function remove_from_group( $item, $groups = null ) {
|
|
// Validate item.
|
|
$item = $this->get( $item );
|
|
if ( ! $item ) {
|
|
return;
|
|
}
|
|
// Get item ID.
|
|
$item = $item->get_id();
|
|
// Validate item ID.
|
|
if ( ! $item ) {
|
|
return;
|
|
}
|
|
|
|
// Setup groups.
|
|
if ( is_string( $groups ) || is_object( $groups ) ) {
|
|
$groups = [ $groups ];
|
|
} elseif ( ! is_array( $groups ) ) {
|
|
$groups = array_keys( $this->get_groups() );
|
|
}
|
|
|
|
// Remove item from group(s).
|
|
foreach ( $groups as $group ) {
|
|
$group = $this->get_group( $group );
|
|
foreach ( array_keys( $group->items ) as $priority ) {
|
|
unset( $group->items[ $priority ][ $item ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves specified group.
|
|
*
|
|
* @param string|object $group Group ID or object to retrieve.
|
|
* @return object Reference to specified group.
|
|
*/
|
|
function &get_group( $group ) {
|
|
if ( is_object( $group ) ) {
|
|
return $group;
|
|
}
|
|
// Create group if it doesn't already exist.
|
|
if ( ! $this->group_exists( $group ) ) {
|
|
return $this->add_group( $group );
|
|
}
|
|
// Get existing group.
|
|
$group = $this->sanitize_group_id( $group );
|
|
return $this->get_member_value( 'groups', $group );
|
|
}
|
|
|
|
/**
|
|
* Retrieve a group's items
|
|
* @uses SLB_Field_Collection::get_group() to retrieve group object
|
|
* @param object|string $group Group object or group ID
|
|
* @return array Group's items
|
|
*/
|
|
function &get_group_items( $group ) {
|
|
$group =& $this->get_group( $group );
|
|
return $group->items;
|
|
}
|
|
|
|
/**
|
|
* Retrieve all groups in collection
|
|
* @return object[] Reference to group objects
|
|
*/
|
|
function &get_groups( $opts = array() ) {
|
|
$groups =& $this->get_member_value( 'groups' );
|
|
if ( is_array( $opts ) && ! empty( $opts ) ) {
|
|
extract( $opts, EXTR_SKIP );
|
|
if ( ! empty( $groups ) && ! empty( $sort ) && is_string( $sort ) ) {
|
|
if ( property_exists( current( $groups ), $sort ) ) {
|
|
// Sort groups by property
|
|
$sfunc = function ( $a, $b ) use ( $sort ) {
|
|
$ap = $a->$sort;
|
|
$bp = $b->$sort;
|
|
if ( $ap === $bp ) {
|
|
return 0;
|
|
}
|
|
return ( $ap > $bp ) ? 1 : -1;
|
|
};
|
|
uasort( $groups, $sfunc );
|
|
}
|
|
}
|
|
}
|
|
return $groups;
|
|
}
|
|
|
|
/**
|
|
* Output groups
|
|
* @uses self::build_vars to determine groups to build
|
|
*/
|
|
function build_groups() {
|
|
$this->util->do_action_ref_array( 'build_groups_pre', array( $this ) );
|
|
|
|
// Get groups to build
|
|
$groups = ( ! empty( $this->build_vars['groups'] ) ) ? $this->build_vars['groups'] : array_keys( $this->get_groups( array( 'sort' => 'priority' ) ) );
|
|
// Check options
|
|
if ( is_callable( $this->build_vars['build_groups'] ) ) {
|
|
// Pass groups to callback to build output
|
|
call_user_func_array( $this->build_vars['build_groups'], array( $this, $groups ) );
|
|
} elseif ( ! ! $this->build_vars['build_groups'] ) {
|
|
// Build groups
|
|
foreach ( $groups as $group ) {
|
|
$this->build_group( $group );
|
|
}
|
|
}
|
|
|
|
$this->util->do_action_ref_array( 'build_groups_post', array( $this ) );
|
|
}
|
|
|
|
/**
|
|
* Build group
|
|
*/
|
|
function build_group( $group ) {
|
|
if ( ! $this->group_exists( $group ) ) {
|
|
return false;
|
|
}
|
|
$group =& $this->get_group( $group );
|
|
// Stop processing if group contains no items
|
|
if ( ! count( $this->get_items( $group ) ) ) {
|
|
return false;
|
|
}
|
|
|
|
// Pre action
|
|
$this->util->do_action_ref_array( 'build_group_pre', array( $this, $group ) );
|
|
|
|
// Build items
|
|
$this->build_items( $group );
|
|
|
|
// Post action
|
|
$this->util->do_action_ref_array( 'build_group_post', array( $this, $group ) );
|
|
}
|
|
|
|
/* Collection */
|
|
|
|
/**
|
|
* Build entire collection of items
|
|
* Prints output
|
|
*/
|
|
function build( $build_vars = array() ) {
|
|
// Parse vars
|
|
$this->parse_build_vars( $build_vars );
|
|
$this->util->do_action_ref_array( 'build_init', array( $this ) );
|
|
// Pre-build output
|
|
$this->util->do_action_ref_array( 'build_pre', array( $this ) );
|
|
// Build groups
|
|
$this->build_groups();
|
|
// Post-build output
|
|
$this->util->do_action_ref_array( 'build_post', array( $this ) );
|
|
}
|
|
|
|
/**
|
|
* Set build variable
|
|
* @param string $key Variable name
|
|
* @param mixed $val Variable value
|
|
*/
|
|
function set_build_var( $key, $val ) {
|
|
$this->build_vars[ $key ] = $val;
|
|
}
|
|
|
|
/**
|
|
* Retrieve build variable
|
|
* @param string $key Variable name
|
|
* @param mixed $default Value if variable is not set
|
|
* @return mixed Variable value
|
|
*/
|
|
function get_build_var( $key, $default = null ) {
|
|
return ( array_key_exists( $key, $this->build_vars ) ) ? $this->build_vars[ $key ] : $default;
|
|
}
|
|
|
|
/**
|
|
* Delete build variable
|
|
* @param string $key Variable name to delete
|
|
*/
|
|
function delete_build_var( $key ) {
|
|
if ( array_key_exists( $key, $this->build_vars ) ) {
|
|
unset( $this->build_vars[ $key ] );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parses build variables prior to use
|
|
* @uses this->reset_build_vars() to reset build variables for each request
|
|
* @param array $build_vars Variables to use for current request
|
|
*/
|
|
function parse_build_vars( $build_vars = array() ) {
|
|
$this->reset_build_vars();
|
|
$this->build_vars = $this->util->apply_filters( 'parse_build_vars', wp_parse_args( $build_vars, $this->build_vars ), $this );
|
|
}
|
|
|
|
/**
|
|
* Reset build variables to defaults
|
|
* Default Variables
|
|
* > groups - array - Names of groups to build
|
|
* > context - string - Context of current request
|
|
* > layout - string - Name of default layout to use
|
|
*/
|
|
function reset_build_vars() {
|
|
$this->build_vars = wp_parse_args( $this->build_vars, $this->build_vars_default );
|
|
}
|
|
}
|