HOME

Mini Shell 1.0
DIR:/home/s/www/wp-content/plugins/simple-lightbox/includes/
Current File : //home/s/www/wp-content/plugins/simple-lightbox/includes/class.base.php
<?php

/**
 * @package Simple Lightbox
 * @subpackage Base
 * @author Archetyped
 *
 */
class SLB_Base {
	/* Configuration */

	/**
	 * Class type
	 * Controls initialization, etc.
	 * > full - Fully-functional class
	 * > sub - Sub-class (attached to an instance)
	 * > object - Simple object class (no hooks, etc.)
	 * @var string
	 */
	protected $mode = 'full';

	/**
	 * Indicates that instance is model (main controller)
	 * @var bool
	 */
	protected $model = false;

	/* Properties */

	/**
	 * Variable name of base object in global scope
	 * @var string
	 */
	protected $base = 'slb';

	/**
	 * Prefix for plugin-related data (attributes, DB tables, etc.)
	 * @var string
	 */
	public $prefix = 'slb';

	/**
	 * Prefix to be added when creating internal hook (action/filter) tags
	 * Used by Utilities
	 * @var string
	 */
	public $hook_prefix = '';

	/**
	 * Global data
	 * Facilitates sharing between decoupled objects
	 * @var array
	 */
	private static $globals = array();

	protected $shared = array('options', 'admin');

	/**
	 * Capabilities
	 * @var array
	 */
	protected $caps = null;

	protected $_init = false;

	private static $_init_passed = false;

	/* Client */

	/**
	 * Client files
	 * @var array
	 * Structure
	 * > Key: unique file ID
	 * > Properties
	 *   > file (string) File path (Relative to plugin base)
	 *   > deps (array) Script dependencies
	 * 		> Internal dependencies are wrapped in square brackets ([])
	 *   > context (string|array)
	 * 		> Context in which the script should be included
	 *   > in_footer (bool) optional [Default: FALSE]
	 * 		> If TRUE, file will be included in footer of page, otherwise it will be included in the header
	 *
	 * Array is processed and converted to an object on init
	 */
	private $client_files = array (
		'scripts'	=> array(),
		'styles'	=> array()
	);

	/*-** Instances **-*/

	/**
	 * Utilities
	 * @var SLB_Utilities
	 */
	var $util = null;

	/**
	 * Options
	 * @var SLB_Options
	 */
	protected $options = null;

	/**
	 * Admin
	 * @var SLB_Admin
	 */
	var $admin = null;

	/*-** Initialization **-*/

	/**
	 * Constructor
	 */
	function __construct() {
		$this->util = new SLB_Utilities($this);
		if ( $this->can('init') ) {
			$hook = 'init';
			if ( did_action($hook) || self::$_init_passed ) {
				$this->_init();
			} else {
				add_action($hook, $this->m('_init'), 1);
			}
		}
	}

	/**
	 * Default initialization method
	 * @uses _init_passed
	 * @uses _env()
	 * @uses _options()
	 * @uses _admin()
	 * @uses _hooks()
	 * @uses _client_files()
	 */
	public function _init() {
		self::$_init_passed = true;
		if ( $this->_init || !isset($this) || !$this->can('init') )
			return false;
		$this->_init = true;
		// Environment
		$this->_env();

		if ( $this->can('control') ) {
			// Options
			$this->_options();

			// Admin
			if ( is_admin() )
				$this->_admin();
		}

		// Hooks
		$this->_hooks();

		// Client files
		$this->_client_files();
	}

	/**
	 * Initialize environment (Localization, etc.)
	 */
	private function _env() {
		if ( !$this->can('singleton') ) {
			return false;
		}
		// Localization
		$ldir = 'l10n';
		$lpath = $this->util->get_plugin_file_path($ldir, array(false, false));
		$lpath_abs = $this->util->get_file_path($ldir);
		if ( is_dir($lpath_abs) ) {
			load_plugin_textdomain('simple-lightbox', false, $lpath);
		}

		// Context
		add_action( ( is_admin() ) ? 'admin_print_footer_scripts' : 'wp_footer', $this->util->m('set_client_context'), $this->util->priority('client_footer_output') );
	}

	/**
	 * Initialize options
	 * To be implemented in child classes
	 */
	protected function _options() {}

	/**
	 * Initialize options
	 * To be called by child class
	 */
	protected function _set_options($options_config = null) {
		$class = $this->util->get_class('Options');
		$key = 'options';
		if ( $this->shares($key) ) {
			$opts = $this->gvar($key);
			// Setup options instance
			if ( !($opts instanceof $class) ) {
				$opts = $this->gvar($key, new $class());
			}
		} else {
			$opts = new $class();
		}
		// Load options
		if ( $this->is_options_valid($options_config, false) ) {
			$opts->load($options_config);
		}
		// Set instance property
		$this->options = $opts;
	}

	/**
	 * Initialize admin
	 * To be called by child class
	 */
	private function _admin() {
		if ( !is_admin() ) {
			return false;
		}
		$class = $this->util->get_class('Admin');
		$key = 'admin';
		if ( $this->shares($key) ) {
			$adm = $this->gvar($key);
			// Setup options instance
			if ( !($adm instanceof $class) ) {
				$adm = $this->gvar($key, new $class($this));
			}
		} else {
			$adm = new $class($this);
		}
		// Set instance property
		$this->admin = $adm;
	}

	/**
	 * Register default hooks
	 */
	protected function _hooks() {
		$base = $this->util->get_plugin_base_file();
		// Activation
		$func_activate = '_activate';
		if ( method_exists($this, $func_activate) )
			register_activation_hook($base, $this->m($func_activate));

		// Deactivation
		$func_deactivate = '_deactivate';
		if ( method_exists($this, $func_deactivate) )
			register_deactivation_hook($base, $this->m($func_deactivate));
	}

	/**
	 * Initialize client files
	 */
	protected function _client_files($files = null) {
		// Validation
		if ( !is_array($files) || empty($files) ) {
			return false;
		}
		foreach ( $this->client_files as $key => $val ) {
			if ( isset($files[$key]) && is_array($files[$key]) || !empty($files[$key]) ) {
				$this->client_files[$key] = $this->util->parse_client_files($files[$key], $key);
			}
			// Remove empty file groups
			if ( empty($this->client_files[$key]) ) {
				unset($this->client_files[$key]);
			}
		}


		// Stop if no files are set for registration
		if ( empty($this->client_files) ) {
			return false;
		}

		// Register
		add_action('init', $this->m('register_client_files'));

		// Enqueue
		$hk_prfx = ( ( is_admin() ) ? 'admin' : 'wp' );
		$hk_enqueue = $hk_prfx . '_enqueue_scripts' ;
		$hk_enqueue_ft = $hk_prfx . '_footer';
		add_action($hk_enqueue, $this->m('enqueue_client_files'), 10, 0);
		add_action($hk_enqueue_ft, $this->m('enqueue_client_files_footer'), 1);
	}

	/**
	 * Register client files
	 * @see enqueue_client_files() for actual loading of files based on context
	 * @uses `init` Action hook for execution
	 * @return void
	 */
	public function register_client_files() {
		$v = $this->util->get_plugin_version();
		foreach ( $this->client_files as $type => $files ) {
			$func = $this->get_client_files_handler($type, 'register');
			if ( !$func )
				continue;
			foreach ( $files as $f ) {
				// Get file URI
				$f->file = ( !$this->util->is_file($f->file) && is_callable($f->file) ) ? call_user_func($f->file) : $this->util->get_file_url($f->file, true);
				$params = array($f->id, $f->file, $f->deps, $v);
				// Set additional parameters based on file type (script, style, etc.)
				switch ( $type ) {
					case 'scripts':
						$params[] = $f->in_footer;
						break;
					case 'styles':
						$params[] = $f->media;
						break;
				}
				// Register file
				call_user_func_array($func, $params);
			}
		}
	}

	/**
	 * Enqueues files for client output (scripts/styles) based on context
	 * @uses `admin_enqueue_scripts` Action hook depending on context
	 * @uses `wp_enqueue_scripts` Action hook depending on context
	 * @param bool $footer (optional) Whether to enqueue footer files (Default: No)
	 * @return void
	 */
	function enqueue_client_files($footer = false) {
		// Validate
		if ( !is_bool($footer) ) {
			$footer = false;
		}
		// Enqueue files
		foreach ( $this->client_files as $type => $files ) {
			$func = $this->get_client_files_handler($type, 'enqueue');
			if ( !$func ) {
				continue;
			}
			foreach ( $files as $fkey => $f ) {
				// Skip previously-enqueued files and shadow files
				if ( $f->enqueued || !$f->enqueue ) {
					continue;
				}
				// Enqueue files only for current location (header/footer)
				if ( isset($f->in_footer) ) {
					if ( $f->in_footer != $footer ) {
						continue;
					}
				} elseif ( $footer ) {
					continue;
				}
				$load = true;
				// Global Callback
				if ( is_callable($f->callback) && !call_user_func($f->callback) ) {
					$load = false;
				}
				// Context
				if ( $load && !empty($f->context) ) {
					// Reset $load before evaluating context
					$load = false;
					// Iterate through contexts
					foreach ( $f->context as $ctx ) {
						// Context + Callback
						if ( is_array($ctx) ) {
							// Stop checking context if callback is invalid
							if ( !is_callable($ctx[1]) || !call_user_func($ctx[1]) )
								continue;
							$ctx = $ctx[0];
						}
						// Stop checking context if valid context found
						if ( $this->util->is_context($ctx) ) {
							$load = true;
							break;
						}
					}
				}
				// Load valid file
				if ( $load ) {
					// Mark file as enqueued
					$this->client_files[$type]->{$fkey}->enqueued = true;
					$func($f->id);
				}
			}
		}
	}

	/**
	 * Enqueue client files in the footer
	 */
	public function enqueue_client_files_footer() {
		$this->enqueue_client_files(true);
	}

	/**
	 * Build function name for handling client operations
	 */
	function get_client_files_handler($type, $action) {
		$func = 'wp_' . $action . '_' . substr($type, 0, -1);
		if ( !function_exists($func) )
			$func = false;
		return $func;
	}

	/*-** Reflection **-*/

	/**
	 * Retrieve base object
	 * @return object|bool Base object (FALSE if object does not exist)
	 */
	function &get_base() {
		$base = false;
		if ( isset($GLOBALS[$this->base]) )
			$base =& $GLOBALS[$this->base];
		return $base;
	}

	/*-** Method/Function calling **-*/

	/**
	 * Returns callback to instance method
	 * @param string $method Method name
	 * @return array Callback array
	 */
	function m($method) {
		return $this->util->m($this, $method);
	}

	/*-** Prefix **-*/

	/**
	 * Retrieve class prefix (with separator if set)
	 * @param bool|string $sep Separator to append to class prefix (Default: no separator)
	 * @return string Class prefix
	 */
	function get_prefix($sep = null) {
		$args = func_get_args();
		return call_user_func_array($this->util->m($this->util, 'get_prefix'), $args);
	}

	/**
	 * Check if a string is prefixed
	 * @param string $text Text to check for prefix
	 * @param string $sep (optional) Separator used
	 */
	function has_prefix($text, $sep = null) {
		$args = func_get_args();
		return call_user_func_array($this->util->m($this->util, 'has_prefix'), $args);
	}

	/**
	 * Prepend plugin prefix to some text
	 * @param string $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix($text, $sep = null, $once = true) {
		$args = func_get_args();
		return call_user_func_array($this->util->m($this->util, 'add_prefix'), $args);
	}

	/**
	 * Prepend uppercased plugin prefix to some text
	 * @param string $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix_uc($text, $sep = null, $once = true) {
		$args = func_get_args();
		return call_user_func_array($this->util->m($this->util, 'add_prefix_uc'), $args);
	}

	/**
	 * Add prefix to variable reference
	 * Updates actual variable rather than return value
	 * @uses SLB_Utilities::add_prefix_ref();
	 * @param string $var Variable to add prefix to
	 * @param string $sep (optional) Separator text
	 * @param bool $once (optional) Add prefix only once
	 * @return void
	 */
	function add_prefix_ref(&$var, $sep = null, $once = true) {
		$args = func_get_args();
		$args[0] =& $var;
		call_user_func_array($this->util->m($this->util, 'add_prefix_ref'), $args);
	}

	/**
	 * Remove prefix from specified string
	 * @param string $text String to remove prefix from
	 * @param string $sep (optional) Separator used with prefix
	 */
	function remove_prefix($text, $sep = null) {
		$args = func_get_args();
		return call_user_func_array($this->util->m($this->util, 'remove_prefix'), $args);
	}

	/*-** Capabilities **-*/

	protected function can($cap) {
		if ( is_null($this->caps) ) {
			// Build capabilities based on instance properties
			$this->caps = array(
				'init'			=> ( 'object' != $this->mode ) ? true : false,
				'singleton'		=> ( !!$this->model ) ? true : false,
				'control'		=> ( 'sub' == $this->mode || 'object' == $this->mode ) ? false : true,
			);
		}
		return ( isset($this->caps[$cap]) ) ? $this->caps[$cap] : false;
	}

	/*-** Globals **-*/

	/**
	 * Get/Set (internal) global variables
	 * @uses $globals to get/set global variables
	 * @param string $name Variable name - If no name is specified, entire globals array is returned
	 * @param mixed $val (optional) Set the value of a variable (Returns variable value if omitted)
	 * @return mixed Variable value
	 */
	private function gvar($name = null, $val = null) {
		$g =& self::$globals;
		if ( !is_array($g) ) {
			$g = array();
		}
		if ( !is_string($name) || empty($name) ) {
			return $g;
		}
		$ret = $val;
		if ( null !== $val ) {
			// Set Value
			$g[$name] = $val;
		} elseif ( isset($g[$name]) ) {
			// Retrieve variable
			$ret = $g[$name];
		}
		return $ret;
	}

	private function shares($name) {
		return ( !empty($this->shared) && in_array($name, $this->shared) ) ? true : false;
	}

	/*-** Options **-*/

	/**
	 * Checks if options are valid
	 * @param array $data Data to be used on options
	 * @return bool TRUE if options are valid, FALSE otherwise
	 */
	function is_options_valid($data, $check_var = true) {
		$class = $this->util->get_class('Options');
		$ret = ( empty($data) || !is_array($data) || !class_exists($class) ) ? false : true;
		if ( $ret && $check_var && !($this->options instanceof $class) )
			$ret = false;
		return $ret;
	}
}

?>