%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/**
* Options collection
* @package Simple Lightbox
* @subpackage Options
* @author Archetyped
* @uses SLB_Field_Collection
*/
class SLB_Options extends SLB_Field_Collection {
/* Properties */
public $hook_prefix = 'options';
var $item_type = 'SLB_Option';
/**
* Key for saving version to DB
* @var string
*/
private $version_key = 'version';
/**
* Whether version has been checked
* @var bool
*/
var $version_checked = false;
var $items_migrated = false;
var $build_vars = array (
'validate_pre' => false,
'validate_post' => false,
'save_pre' => false,
'save_post' => false
);
/* Init */
function __construct($id = '', $props = array()) {
// Validate arguments
$args = func_get_args();
// Set default ID
if ( !$this->validate_id($id) ) {
$id = 'options';
}
$defaults = $this->integrate_id($id);
$props = $this->make_properties($args, $defaults);
parent::__construct($props);
$this->add_prefix_ref($this->version_key);
}
protected function _hooks() {
parent::_hooks();
// Register fields
$this->util->add_action('register_fields', $this->m('register_fields'), 10, 1, false);
// Set option parents
$this->util->add_action('fields_registered', $this->m('set_parents'), 10, 1, false);
// Building
$this->util->add_action('build_init', $this->m('build_init'));
// Admin
$this->util->add_action('admin_page_render_content', $this->m('admin_page_render_content'), 10, 3, false);
$this->util->add_filter('admin_action_reset', $this->m('admin_action_reset'), 10, 3, false);
}
/* Legacy/Migration */
/**
* Checks whether new version has been installed and migrates necessary settings
* @uses $version_key as option name
* @uses get_option() to retrieve saved version number
* @uses SLB_Utilities::get_plugin_version() to retrieve current version
* @return bool TRUE if version has been changed
*/
function check_update() {
if ( !$this->version_checked ) {
$this->version_checked = true;
$version_changed = false;
// Get version from DB
$vo = $this->get_version();
// Get current version
$vn = $this->util->get_plugin_version();
// Compare versions
if ( $vo != $vn ) {
// Update saved version
$this->set_version($vn);
// Migrate old version to new version
if ( strcasecmp($vo, $vn) < 0 ) {
// Force full migration
$version_changed = true;
}
}
// Migrate
$this->migrate($version_changed);
}
return $this->version_checked;
}
/**
* Save plugin version to DB
* If no version supplied, will fetch plugin data to determine version
* @uses $version_key as option name
* @uses update_option() to save version to options table
* @param string $ver (optional) Plugin version
*/
function set_version($ver = null) {
if ( empty($ver) ) {
$ver = $this->util->get_plugin_version();
}
return update_option($this->version_key, $ver);
}
/**
* Retrieve saved version data
* @return string Saved version
*/
function get_version() {
return get_option($this->version_key, '');
}
/**
* Migrate options from old versions to current version
* @uses self::items_migrated to determine if simple migration has been performed in current request or not
* @uses self::save() to save data after migration
* @param bool $full Whether to perform a full migration or not (Default: No)
*/
function migrate($full = false) {
if ( !$full && $this->items_migrated )
return false;
// Legacy options
$d = null;
$this->load_data();
$items = $this->get_items();
// Migrate separate options to unified option
if ( $full ) {
foreach ( $items as $opt => $props ) {
$oid = $this->add_prefix($opt);
$o = get_option($oid, $d);
if ( $o !== $d ) {
// Migrate value to data array
$this->set_data($opt, $o, false);
// Delete legacy option
delete_option($oid);
}
}
}
// Migrate legacy items
if ( is_array($this->properties_init) && isset($this->properties_init['legacy']) && is_array($this->properties_init['legacy']) ) {
$l =& $this->properties_init['legacy'];
// Normalize legacy map
foreach ( $l as $opt => $dest ) {
if ( !is_array($dest) ) {
if ( is_string($dest) )
$l[$opt] = array($dest);
else
unset($l[$opt]);
}
}
/* Separate options */
if ( $full ) {
foreach ( $l as $opt => $dest ) {
$oid = $this->add_prefix($opt);
$o = get_option($oid, $d);
// Only migrate valid values
if ( $o !== $d ) {
// Process destinations
foreach ( $dest as $id ) {
$this->set_data($id, $o, false, true);
}
}
// Remove legacy option
delete_option($oid);
}
}
/* Simple Migration (Internal options only) */
// Get existing items that are also legacy items
$opts = array_intersect_key($this->get_data(), $l);
foreach ( $opts as $opt => $val ) {
$d = $this->get_data($opt);
// Migrate data from old option to new option
$dest = $l[$opt];
// Validate new options to send data to
foreach ( $dest as $id ) {
$this->set_data($id, $d, false, true);
}
// Remove legacy option
$this->remove($opt, false);
}
}
// Save changes
$this->save();
// Set flag
$this->items_migrated = true;
}
/* Option setup */
/**
* Get elements for creating fields
* @return obj
*/
function get_field_elements() {
static $o = null;
if ( empty($o) ) {
$o = new stdClass();
/* Layout */
$layout = new stdClass();
$layout->label = '<label for="{field_id}" class="title block">{label}</label>';
$layout->label_ref = '{label ref_base="layout"}';
$layout->field_pre = '<div class="input block">';
$layout->field_post = '</div>';
$layout->opt_pre = '<div class="' . $this->add_prefix('option_item') . '">';
$layout->opt_post = '</div>';
$layout->form = '<{form_attr ref_base="layout"} /> <span class="description">(' . __('Default', 'simple-lightbox') . ': {data context="display" top="0"})</span>';
/* Combine */
$o->layout =& $layout;
}
return $o;
}
/**
* Register option-specific fields
* @param SLB_Fields $fields Reference to global fields object
* @return void
*/
function register_fields($fields) {
// Layouts
$o = $this->get_field_elements();
$l =& $o->layout;
$form = implode('', array (
$l->opt_pre,
$l->label_ref,
$l->field_pre,
$l->form,
$l->field_post,
$l->opt_post
));
// Text input
$otxt = new SLB_Field_Type('option_text', 'text');
$otxt->set_property('class', '{inherit} code');
$otxt->set_property('size', null);
$otxt->set_property('value', '{data context="form"}');
$otxt->set_layout('label', $l->label);
$otxt->set_layout('form', $form);
$fields->add($otxt);
// Checkbox
$ocb = new SLB_Field_Type('option_checkbox', 'checkbox');
$ocb->set_layout('label', $l->label);
$ocb->set_layout('form', $form);
$fields->add($ocb);
// Select
$othm = new SLB_Field_Type('option_select', 'select');
$othm->set_layout('label', $l->label);
$othm->set_layout('form_start', $l->field_pre . '{inherit}');
$othm->set_layout('form_end', '{inherit}' . $l->field_post);
$othm->set_layout('form', $l->opt_pre . '{inherit}' . $l->opt_post);
$fields->add($othm);
}
/**
* Set parent field types for options
* Parent only set for Admin pages
* @uses SLB_Option::set_parent() to set parent field for each option item
* @uses is_admin() to determine if current request is admin page
* @param object $fields Collection of default field types
* @return void
*/
function set_parents($fields) {
if ( !is_admin() )
return false;
$items = &$this->get_items();
foreach ( array_keys($items) as $opt ) {
$items[$opt]->set_parent();
}
foreach ( $this->items as $opt ) {
$p = $opt->parent;
if ( is_object($p) )
$p = 'o:' . $p->id;
}
}
/* Processing */
/**
* Validate option values
* Used for validating options (e.g. admin form submission) prior to saving options to DB
* Reformats values based on options' default values (i.e. bool, int, string, etc.)
* Adds option items not included in original submission
* @param array $values (optional) Option values
* @return array Full options data
*/
function validate($values = null) {
$qvar = $this->get_id('formatted');
if ( empty($values) && isset($_REQUEST[$qvar]) ) {
$values = $_REQUEST[$qvar];
}
if ( is_array($values) ) {
// Format data based on option type (bool, string, etc.)
foreach ( $values as $id => $val ) {
// Get default
$d = $this->get_default($id);
if ( is_bool($d) && !empty($val) )
$values[$id] = true;
}
// Merge in additional options that are not in post data
// Missing options (e.g. disabled checkboxes, empty fields, etc.)
// Get groups that were output in request
$qvar_groups = $qvar . '_groups';
if ( isset($_REQUEST[$qvar_groups]) ) {
$groups = explode( ',', implode(',', $_REQUEST[$qvar_groups]) );
// Get group items
$items = array();
$items_temp = null;
foreach ( $groups as $gid ) {
$items_temp = $this->get_group_items($gid);
$items = array_merge($items, $items_temp);
}
unset($items_temp);
$items = call_user_func_array('array_merge', $items);
foreach ( $items as $id => $opt ) {
// Add options that were not included in form submission
if ( !array_key_exists($id, $values) ) {
if ( is_bool($opt->get_default()) )
$values[$id] = false;
else
$values[$id] = $opt->get_default();
}
}
}
}
// Return value
return $values;
}
/* Data */
/**
* Retrieve options from database
* @uses get_option to retrieve option data
* @return array Options data
*/
function fetch_data($sanitize = true) {
// Get data
$data = get_option($this->get_key(), null);
if ( $sanitize && is_array($data) ) {
// Sanitize loaded data based on default values
foreach ( $data as $id => $val ) {
if ( $this->has($id) ) {
$opt = $this->get($id);
if ( is_bool($opt->get_default()) )
$data[$id] = !!$val;
}
}
}
return $data;
}
/**
* Retrieves option data for collection
* @see SLB_Field_Collection::load_data()
*/
function load_data() {
if ( !$this->data_loaded ) {
// Retrieve data
$this->data = $this->fetch_data();
$this->data_loaded = true;
// Check update
$this->check_update();
}
}
/**
* Resets option values to their default values
* @param bool $hard Reset all options if TRUE (default), Reset only unset options if FALSE
*/
function reset($hard = true) {
$this->load_data();
// Reset data
if ( $hard ) {
$this->data = null;
}
// Save
$this->save();
}
/**
* Save options data to database
*/
function save() {
$this->normalize_data();
update_option($this->get_key(), $this->data);
}
/**
* Normalize data
* Assures that data in collection match items
* @uses self::data to reset and save collection data after normalization
*/
function normalize_data() {
$data = array();
foreach ( $this->get_items() as $id => $opt ) {
$data[$id] = $opt->get_data();
}
$this->data =& $data;
return $data;
}
/* Collection */
/**
* Build key for saving/retrieving data to options table
* @return string Key
*/
function get_key() {
return $this->add_prefix($this->get_id());
}
/**
* Add option to collection
* @uses SLB_Field_Collection::add() to add item
* @param string $id Unique item ID
* @param array $properties Item properties
* @param bool $update (optional) Should item be updated or overwritten (Default: FALSE)
* @return SLB_Option Option instance
*/
function &add($id, $properties = array(), $update = false) {
// Create item
$args = func_get_args();
$ret = call_user_func_array(array('parent', 'add'), $args);
return $ret;
}
/**
* Retrieve option value
* @uses get_data() to retrieve option data
* @param string $option Option ID to retrieve value for
* @param string $context (optional) Context for formatting data
* @return mixed Option value
*/
function get_value($option, $context = '') {
return $this->get_data($option, $context);
}
/**
* Retrieve option value as boolean (true/false)
* @uses get_data() to retrieve option data
* @param string $option Option ID to retrieve value for
* @return bool Option value
*/
function get_bool($option) {
return $this->get_value($option, 'bool');
}
function get_string($option) {
return $this->get_value($option, 'string');
}
/**
* Retrieve option's default value
* @uses get_data() to retrieve option data
* @param string $option Option ID to retrieve value for
* @param string $context (optional) Context for formatting data
* @return mixed Option's default value
*/
function get_default($option, $context = '') {
return $this->get_data($option, $context, false);
}
/* Output */
function build_init() {
if ( $this->build_vars['validate_pre'] ) {
$values = $this->validate();
if ( $this->build_vars['save_pre'] ) {
$this->set_data($values);
}
}
}
/**
* Build array of option values for client output
* @return array Associative array of options
*/
function build_client_output() {
$items = $this->get_items();
$out = array();
foreach ( $items as $option ) {
if ( !$option->get_in_client() )
continue;
$out[$option->get_id()] = $option->get_data('default');
}
return $out;
}
/* Admin */
/**
* Handles output building for options on admin pages
* @param obj|array $opts Options instance or Array of options instance and groups to build
* @param obj $page Admin Page instance
* @param obj $state Admin Page state properties
*/
public function admin_page_render_content($opts, $page, $state) {
$groups = null;
if ( is_array($opts) && count($opts) == 2 ) {
$groups = $opts[1];
$opts = $opts[0];
}
if ( $opts === $this ) {
// Set build variables and callbacks
$this->set_build_var('admin_page', $page);
$this->set_build_var('admin_state', $state);
if ( !empty($groups) ) {
$this->set_build_var('groups', $groups);
}
$hooks = array (
'filter' => array (
'parse_build_vars' => array( $this->m('admin_parse_build_vars'), 10, 2 )
)
);
// Add hooks
foreach ( $hooks as $type => $hook ) {
$m = 'add_' . $type;
foreach ( $hook as $tag => $args ) {
array_unshift($args, $tag);
call_user_func_array($this->util->m($m), $args);
}
}
// Build output
$this->build(array('build_groups' => $this->m('admin_build_groups')));
// Remove hooks
foreach ( $hooks as $type => $hook ) {
$m = 'remove_' . $type;
foreach ( $hook as $tag => $args ) {
call_user_func($this->util->m($m), $tag, $args[0]);
}
}
// Clear custom build vars
$this->delete_build_var('admin_page');
$this->delete_build_var('admin_state');
}
}
/**
* Builds option groups output
*/
public function admin_build_groups() {
$page = $this->get_build_var('admin_page');
$state = $this->get_build_var('admin_state');
$groups = $this->get_build_var('groups');
// Get all groups
$groups_all = $this->get_groups();
$groups_built = array();
if ( empty($groups) ) {
$groups = array_keys($groups_all);
}
// Iterate through groups
foreach ( $groups as $gid ) {
// Validate
if ( !isset($groups_all[$gid]) || !count($this->get_items($gid)) ) {
continue;
}
// Add meta box for each group
$g = $groups_all[$gid];
add_meta_box($g->id, $g->title, $this->m('admin_build_group'), $state->screen, $state->context, $state->priority, array('group' => $g->id, 'page' => $page));
$groups_built[] = $gid;
}
// Define groups built
if ( !empty($groups_built) ) {
echo $this->util->build_html_element(array(
'tag' => 'input',
'attributes' => array (
'type' => 'hidden',
'value' => implode(',', $groups_built),
'name' => $this->get_id('formatted') . '_groups[]'
),
));
}
}
/**
* Group output handler for admin pages
* @param obj $obj Object passed by `do_meta_boxes()` call (Default: NULL)
* @param array $box Meta box properties
*/
public function admin_build_group($obj, $box) {
$a = $box['args'];
$group = $a['group'];
$this->build_group($group);
}
/**
* Parse build vars
* @uses `options_parse_build_vars` filter hook
*/
public function admin_parse_build_vars($vars, $opts) {
// Handle form submission
if ( isset($_REQUEST[$opts->get_id('formatted')]) ) {
$vars['validate_pre'] = $vars['save_pre'] = true;
}
return $vars;
}
/**
* Admin reset handler
* @param bool $res Current result
* @param obj $opts Options instance
* @param obj $reset Admin Reset instance
*/
public function admin_action_reset($res, $opts, $reset) {
// Only process matching options instance
if ( $opts === $this ) {
// Reset options
$this->reset();
// Set result
$res = true;
}
return $res;
}
}
Zerion Mini Shell 1.0