Location: PHPKode > projects > Wallpaper Script > Wallpapers_Script/Wallpapers_Script/system/application/libraries/WS_Loader.php
<?php

/**
 * Matchbox Loader class
 *
 * This file is part of Matchbox
 *
 * Matchbox is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Matchbox is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * @package   Matchbox
 * @copyright 2007-2008 Zacharias Knudsen
 * @license   http://www.gnu.org/licenses/gpl.html
 * @version   $Id: Loader.php 205 2008-02-24 01:43:55Z hide@address.com $
 */

if ( ! defined ( 'BASEPATH' ) ) {
	exit ( 'No direct script access allowed' );
}

/**
 * Replaces the CodeIgniter Loader class
 *
 * All code not encapsulated in {{{ Matchbox }}} was made by EllisLab
 *
 * @package   Matchbox
 * @copyright 2007-2008 Zacharias Knudsen
 * @license   http://www.gnu.org/licenses/gpl.html
 */
class WS_Loader {

	// {{{ Matchbox
	

	/**
	 * The Matchbox object
	 *
	 * @var    object
	 * @access private
	 */
	var $_matchbox;

	/**
	 * Loads library from module
	 *
	 * @param  string
	 * @param  string
	 * @param  mixed
	 * @return void
	 * @access public
	 */
	function module_library ( $module, $library = '', $params = null ) {
		return $this->library ( $library, $params, $module );
	}

	/**
	 * Loads model from module
	 *
	 * @param  string
	 * @param  string
	 * @param  string
	 * @param  mixed
	 * @return void
	 * @access public
	 */
	function module_model ( $module, $model, $name = '', $db_conn = false ) {
		return $this->model ( $model, $name, $db_conn, $module );
	}

	/**
	 * Loads view from module
	 *
	 * @param  string
	 * @param  string
	 * @param  array
	 * @param  bool
	 * @return void
	 * @access public
	 */
	function module_view ( $module, $view, $vars = array(), $return = false ) {
		return $this->view ( $view, $vars, $return, $module );
	}

	/**
	 * Loads file from module
	 *
	 * @param  string
	 * @param  string
	 * @param  bool
	 * @return void
	 * @access public
	 */
	function module_file ( $module, $path, $return = false ) {
		return $this->file ( $path, $return, $module );
	}

	/**
	 * Loads helper from module
	 *
	 * @param  string
	 * @param  mixed
	 * @return void
	 * @access public
	 */
	function module_helper ( $module, $helpers = array() ) {
		return $this->helper ( $helpers, $module );
	}

	/**
	 * Loads plugin from module
	 *
	 * @param  string
	 * @param  mixed
	 * @return void
	 * @access public
	 */
	function module_plugin ( $module, $plugins = array() ) {
		return $this->plugin ( $plugins, $module );
	}

	/**
	 * Loads script from module
	 *
	 * @param  string
	 * @param  mixed
	 * @return void
	 * @access public
	 */
	function module_script ( $module, $scripts = array() ) {
		return $this->script ( $scripts, $module );
	}

	/**
	 * Loads language file from module
	 *
	 * @param  string
	 * @param  mixed
	 * @param  string
	 * @return void
	 * @access public
	 */
	function module_language ( $module, $file = array(), $lang = '' ) {
		return $this->language ( $file, $lang, $module );
	}

	/**
	 * Loads config file from module
	 *
	 * @param  string
	 * @param  string
	 * @param  bool
	 * @param  bool
	 * @return void
	 * @access public
	 */
	function module_config ( $module, $file = '', $use_sections = false, $fail_gracefully = false ) {
		return $this->config ( $file, $use_sections, $fail_gracefully, $module );
	}

	//}}}
	

	// All these are set automatically. Don't mess with them.
	var $_ci_ob_level;

	var $_ci_view_path = '';

	var $_ci_is_php5 = FALSE;

	var $_ci_is_instance = FALSE; // Whether we should use $this or $CI =& get_instance()

	var $_ci_cached_vars = array ();

	var $_ci_classes = array ();

	var $_ci_models = array ();

	var $_ci_helpers = array ();

	var $_ci_plugins = array ();

	var $_ci_scripts = array ();

	var $_ci_varmap = array ( 
		'unit_test' => 'unit', 'user_agent' => 'agent' 
	);

	/**
	 * Constructor
	 *
	 * Sets the path to the view files and gets the initial output buffering level
	 *
	 * @access    public
	 */
	function __construct () {
		// {{{ Matchbox
		

		$this->_matchbox = &load_class ( 'Matchbox' );
		
		// }}}
		

		$this->_ci_is_php5 = ( floor ( phpversion () ) >= 5 ) ? TRUE : FALSE;
		$this->_ci_view_path = APPPATH . 'views/';
		$this->_ci_ob_level = ob_get_level ();
		
		log_message ( 'debug', "Loader Class Initialized" );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Class Loader
	 *
	 * This function lets users load and instantiate classes.
	 * It is designed to be called from a user's app controllers.
	 *
	 * @access    public
	 * @param    string    the name of the class
	 * @param    mixed    the optional parameters
	 * @return    void
	 */
	function library ( $library = '', $params = NULL ) {
		if ( $library == '' ) {
			return FALSE;
		}
		
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 2 );
		
		if ( is_array ( $library ) ) {
			foreach ( $library as $class ) {
				$this->_ci_load_class ( $class, $params, $module );
			}
		}
		else {
			$this->_ci_load_class ( $library, $params, $module );
		}
		
		// }}}
		

		$this->_ci_assign_to_models ();
	}

	// --------------------------------------------------------------------
	

	/**
	 * Model Loader
	 *
	 * This function lets users load and instantiate models.
	 *
	 * @access    public
	 * @param    string    the name of the class
	 * @param    mixed    any initialization parameters
	 * @return    void
	 */
	function model ( $model, $name = '', $db_conn = FALSE ) {
		if ( is_array ( $model ) ) {
			foreach ( $model as $babe ) {
				$this->model ( $babe );
			}
			return;
		}
		
		if ( $model == '' ) {
			return;
		}
		
		// Is the model in a sub-folder? If so, parse out the filename and path.
		if ( strpos ( $model, '/' ) === FALSE ) {
			$path = '';
		}
		else {
			$x = explode ( '/', $model );
			$model = end ( $x );
			unset ( $x [ count ( $x ) - 1 ] );
			$path = implode ( '/', $x ) . '/';
		}
		
		if ( $name == '' ) {
			$name = $model;
		}
		
		if ( in_array ( $name, $this->_ci_models, TRUE ) ) {
			return;
		}
		
		$CI = & get_instance ();
		if ( isset ( $CI->$name ) ) {
			show_error ( 'The model name you are loading is the name of a resource that is already being used: ' . $name );
		}
		
		$model = strtolower ( $model );
		
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 3 );
		
		if ( ! $filepath = $this->_matchbox->find ( 'models/' . $path . $model . EXT, $module ) ) {
			show_error ( 'Unable to locate the model you have specified: ' . $model );
		}
		
		// }}}
		

		if ( $db_conn !== FALSE and ! class_exists ( 'CI_DB' ) ) {
			if ( $db_conn === TRUE )
				$db_conn = '';
			
			$CI->load->database ( $db_conn, FALSE, TRUE );
		}
		
		if ( ! class_exists ( 'Model' ) ) {
			load_class ( 'Model', FALSE );
		}
		
		// {{{ Matchbox
		

		require_once ( $filepath );
		
		// }}}
		

		$model = ucfirst ( $model );
		
		$CI->$name = new $model ( );
		$CI->$name->_assign_libraries ();
		
		$this->_ci_models [ ] = $name;
	}

	// --------------------------------------------------------------------
	

	/**
	 * Database Loader
	 *
	 * @access    public
	 * @param    string    the DB credentials
	 * @param    bool    whether to return the DB object
	 * @param    bool    whether to enable active record (this allows us to override the config setting)
	 * @return    object
	 */
	function database ( $params = '', $return = FALSE, $active_record = FALSE ) {
		// Grab the super object
		$CI = & get_instance ();
		
		// Do we even need to load the database class?
		if ( class_exists ( 'CI_DB' ) and $return == FALSE and $active_record == FALSE and isset ( $CI->db ) and is_object ( $CI->db ) ) {
			return FALSE;
		}
		
		require_once ( BASEPATH . 'database/DB' . EXT );
		
		if ( $return === TRUE ) {
			return DB ( $params, $active_record );
		}
		
		// Initialize the db variable.  Needed to prevent
		// reference errors with some configurations
		$CI->db = '';
		
		// Load the DB class
		$CI->db = & DB ( $params, $active_record );
		
		// Assign the DB object to any existing models
		$this->_ci_assign_to_models ();
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load the Utilities Class
	 *
	 * @access    public
	 * @return    string
	 */
	function dbutil () {
		if ( ! class_exists ( 'CI_DB' ) ) {
			$this->database ();
		}
		
		$CI = & get_instance ();
		
		// for backwards compatibility, load dbforge so we can extend dbutils off it
		// this use is deprecated and strongly discouraged
		$CI->load->dbforge ();
		
		require_once ( BASEPATH . 'database/DB_utility' . EXT );
		require_once ( BASEPATH . 'database/drivers/' . $CI->db->dbdriver . '/' . $CI->db->dbdriver . '_utility' . EXT );
		$class = 'CI_DB_' . $CI->db->dbdriver . '_utility';
		
		$CI->dbutil = new $class ( );
		
		$CI->load->_ci_assign_to_models ();
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load the Database Forge Class
	 *
	 * @access    public
	 * @return    string
	 */
	function dbforge () {
		if ( ! class_exists ( 'CI_DB' ) ) {
			$this->database ();
		}
		
		$CI = & get_instance ();
		
		require_once ( BASEPATH . 'database/DB_forge' . EXT );
		require_once ( BASEPATH . 'database/drivers/' . $CI->db->dbdriver . '/' . $CI->db->dbdriver . '_forge' . EXT );
		$class = 'CI_DB_' . $CI->db->dbdriver . '_forge';
		
		$CI->dbforge = new $class ( );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load View
	 *
	 * This function is used to load a "view" file.  It has three parameters:
	 *
	 * 1. The name of the "view" file to be included.
	 * 2. An associative array of data to be extracted for use in the view.
	 * 3. TRUE/FALSE - whether to return the data or load it.  In
	 * some cases it's advantageous to be able to return data so that
	 * a developer can process it in some way.
	 *
	 * @access    public
	 * @param    string
	 * @param    array
	 * @param    bool
	 * @return    void
	 */
	function view ( $view, $vars = array(), $return = FALSE ) {
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 3 );
		
		return $this->_ci_load ( array ( 
			'_ci_view' => $view, '_ci_vars' => $this->_ci_object_to_array ( $vars ), '_ci_return' => $return 
		), $module );
		
	// }}}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load File
	 *
	 * This is a generic file loader
	 *
	 * @access    public
	 * @param    string
	 * @param    bool
	 * @return    string
	 */
	function file ( $path, $return = FALSE ) {
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 2 );
		
		return $this->_ci_load ( array ( 
			'_ci_path' => $path, '_ci_return' => $return 
		), $module );
		
	// }}}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Set Variables
	 *
	 * Once variables are set they become available within
	 * the controller class and its "view" files.
	 *
	 * @access    public
	 * @param    array
	 * @return    void
	 */
	function vars ( $vars = array() ) {
		$vars = $this->_ci_object_to_array ( $vars );
		
		if ( is_array ( $vars ) and count ( $vars ) > 0 ) {
			foreach ( $vars as $key => $val ) {
				$this->_ci_cached_vars [ $key ] = $val;
			}
		}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load Helper
	 *
	 * This function loads the specified helper file.
	 *
	 * @access    public
	 * @param    mixed
	 * @return    void
	 */
	function helper ( $helpers = array() ) {
		if ( ! is_array ( $helpers ) ) {
			$helpers = array ( 
				$helpers 
			);
		}
		
		foreach ( $helpers as $helper ) {
			$helper = strtolower ( str_replace ( EXT, '', str_replace ( '_helper', '', $helper ) ) . '_helper' );
			
			if ( isset ( $this->_ci_helpers [ $helper ] ) ) {
				continue;
			}
			
			// {{{ Matchbox
			

			$module = $this->_matchbox->argument ( 1 );
			
			if ( $ext_helper = $this->_matchbox->find ( 'helpers/' . config_item ( 'subclass_prefix' ) . $helper . EXT, $module ) ) {
				$base_helper = BASEPATH . 'helpers/' . $helper . EXT;
				
				if ( ! file_exists ( $base_helper ) ) {
					show_error ( 'Unable to load the requested file: helpers/' . $helper . EXT );
				}
				
				include_once ( $ext_helper );
				include_once ( $base_helper );
			}
			elseif ( $filepath = $this->_matchbox->find ( 'helpers/' . $helper . EXT, $module, 2 ) ) {
				include ( $filepath );
			}
			else {
				show_error ( 'Unable to load the requested file: helpers/' . $helper . EXT );
			}
			
			// }}}
			

			$this->_ci_helpers [ $helper ] = TRUE;
		
		}
		
		log_message ( 'debug', 'Helpers loaded: ' . implode ( ', ', $helpers ) );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load Helpers
	 *
	 * This is simply an alias to the above function in case the
	 * user has written the plural form of this function.
	 *
	 * @access    public
	 * @param    array
	 * @return    void
	 */
	function helpers ( $helpers = array() ) {
		$this->helper ( $helpers );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load Plugin
	 *
	 * This function loads the specified plugin.
	 *
	 * @access    public
	 * @param    array
	 * @return    void
	 */
	function plugin ( $plugins = array() ) {
		if ( ! is_array ( $plugins ) ) {
			$plugins = array ( 
				$plugins 
			);
		}
		
		foreach ( $plugins as $plugin ) {
			$plugin = strtolower ( str_replace ( EXT, '', str_replace ( '_pi', '', $plugin ) ) . '_pi' );
			
			if ( isset ( $this->_ci_plugins [ $plugin ] ) ) {
				continue;
			}
			
			// {{{ Matchbox
			

			$module = $this->_matchbox->argument ( 1 );
			
			if ( ! $filepath = $this->_matchbox->find ( 'plugins/' . $plugin . EXT, $module, 2 ) ) {
				show_error ( 'Unable to load the requested file: plugins/' . $plugin . EXT );
			}
			
			include ( $filepath );
			
			// }}}
			

			$this->_ci_plugins [ $plugin ] = TRUE;
		}
		
		log_message ( 'debug', 'Plugins loaded: ' . implode ( ', ', $plugins ) );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load Plugins
	 *
	 * This is simply an alias to the above function in case the
	 * user has written the plural form of this function.
	 *
	 * @access    public
	 * @param    array
	 * @return    void
	 */
	function plugins ( $plugins = array() ) {
		$this->plugin ( $plugins );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load Script
	 *
	 * This function loads the specified include file from the
	 * application/scripts/ folder.
	 *
	 * NOTE:  This feature has been deprecated but it will remain available
	 * for legacy users.
	 *
	 * @access    public
	 * @param    array
	 * @return    void
	 */
	function script ( $scripts = array() ) {
		if ( ! is_array ( $scripts ) ) {
			$scripts = array ( 
				$scripts 
			);
		}
		
		foreach ( $scripts as $script ) {
			$script = strtolower ( str_replace ( EXT, '', $script ) );
			
			if ( isset ( $this->_ci_scripts [ $script ] ) ) {
				continue;
			}
			
			// {{{ Matchbox
			

			$module = $this->_matchbox->argument ( 1 );
			
			if ( ! $filepath = $this->_matchbox->find ( 'scripts/' . $script . EXT, $module, 2 ) ) {
				show_error ( 'Unable to load the requested script: scripts/' . $script . EXT );
			}
			
			include ( $filepath );
			
		// }}}
		}
		
		log_message ( 'debug', 'Scripts loaded: ' . implode ( ', ', $scripts ) );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Loads a language file
	 *
	 * @access    public
	 * @param    array
	 * @param    string
	 * @return    void
	 */
	function language ( $file = array(), $lang = '' ) {
		$CI = & get_instance ();
		
		if ( ! is_array ( $file ) ) {
			$file = array ( 
				$file 
			);
		}
		
		foreach ( $file as $langfile ) {
			// {{{ Matchbox
			

			$module = $this->_matchbox->argument ( 2 );
			
			$CI->lang->load ( $langfile, $lang, false, $module );
			
		// }}}
		}
	}

	/**
	 * Loads language files for scaffolding
	 *
	 * @access    public
	 * @param    string
	 * @return    arra
	 */
	function scaffold_language ( $file = '', $lang = '', $return = FALSE ) {
		$CI = & get_instance ();
		return $CI->lang->load ( $file, $lang, $return );
	}

	// --------------------------------------------------------------------
	

	/**
	 * Loads a config file
	 *
	 * @access    public
	 * @param    string
	 * @return    void
	 */
	function config ( $file = '', $use_sections = FALSE, $fail_gracefully = FALSE ) {
		$CI = & get_instance ();
		
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 3 );
		
		$CI->config->load ( $file, $use_sections, $fail_gracefully, $module );
		
	// }}}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Scaffolding Loader
	 *
	 * This initializing function works a bit different than the
	 * others. It doesn't load the class.  Instead, it simply
	 * sets a flag indicating that scaffolding is allowed to be
	 * used.  The actual scaffolding function below is
	 * called by the front controller based on whether the
	 * second segment of the URL matches the "secret" scaffolding
	 * word stored in the application/config/routes.php
	 *
	 * @access    public
	 * @param    string
	 * @return    void
	 */
	function scaffolding ( $table = '' ) {
		if ( $table === FALSE ) {
			show_error ( 'You must include the name of the table you would like to access when you initialize scaffolding' );
		}
		
		$CI = & get_instance ();
		$CI->_ci_scaffolding = TRUE;
		$CI->_ci_scaff_table = $table;
	}

	// --------------------------------------------------------------------
	

	/**
	 * Loader
	 *
	 * This function is used to load views and files.
	 * Variables are prefixed with _ci_ to avoid symbol collision with
	 * variables made available to view files
	 *
	 * @access    private
	 * @param    array
	 * @return    void
	 */
	function _ci_load ( $_ci_data ) {
		// Set the default data variables
		foreach ( array ( 
			'_ci_view', '_ci_vars', '_ci_path', '_ci_return' 
		) as $_ci_val ) {
			$$_ci_val = ( ! isset ( $_ci_data [ $_ci_val ] ) ) ? FALSE : $_ci_data [ $_ci_val ];
		}
		
		// Set the path to the requested file
		// {{{ Matchbox
		

		if ( $_ci_path == '' ) {
			$_ci_ext = pathinfo ( $_ci_view, PATHINFO_EXTENSION );
			$_ci_file = ( $_ci_ext == '' ) ? $_ci_view . EXT : $_ci_view;
			$_ci_path = str_replace ( APPPATH, '', $this->_ci_view_path ) . $_ci_file;
			$search = 1;
		}
		else {
			$_ci_x = explode ( '/', $_ci_path );
			$_ci_file = end ( $_ci_x );
			$search = 3;
		}
		
		$module = $this->_matchbox->argument ( 1 );
		
		if ( ! $_ci_path = $this->_matchbox->find ( $_ci_path, $module, $search ) ) {
			show_error ( 'Unable to load the requested file: ' . $_ci_file );
		}
		
		// }}}
		

		// This allows anything loaded using $this->load (views, files, etc.)
		// to become accessible from within the Controller and Model functions.
		// Only needed when running PHP 5
		

		if ( $this->_ci_is_instance () ) {
			$_ci_CI = & get_instance ();
			foreach ( get_object_vars ( $_ci_CI ) as $_ci_key => $_ci_var ) {
				if ( ! isset ( $this->$_ci_key ) ) {
					$this->$_ci_key = & $_ci_CI->$_ci_key;
				}
			}
		}
		
		/*
         * Extract and cache variables
         *
         * You can either set variables using the dedicated $this->load_vars()
         * function or via the second parameter of this function. We'll merge
         * the two types and cache them so that views that are embedded within
         * other views can have access to these variables.
         */
		if ( is_array ( $_ci_vars ) ) {
			$this->_ci_cached_vars = array_merge ( $this->_ci_cached_vars, $_ci_vars );
		}
		extract ( $this->_ci_cached_vars );
		
		/*
         * Buffer the output
         *
         * We buffer the output for two reasons:
         * 1. Speed. You get a significant speed boost.
         * 2. So that the final rendered template can be
         * post-processed by the output class.  Why do we
         * need post processing?  For one thing, in order to
         * show the elapsed page load time.  Unless we
         * can intercept the content right before it's sent to
         * the browser and then stop the timer it won't be accurate.
         */
		ob_start ();
		
		// If the PHP installation does not support short tags we'll
		// do a little string replacement, changing the short tags
		// to standard PHP echo statements.
		

		if ( ( bool ) @ini_get ( 'short_open_tag' ) === FALSE and config_item ( 'rewrite_short_tags' ) == TRUE ) {
			echo eval ( '?>' . preg_replace ( "/;*\s*\?>/", "; ?>", str_replace ( '<?=', '<?php echo ', file_get_contents ( $_ci_path ) ) ) . '<?php ' );
		}
		else {
			include ( $_ci_path );
		}
		
		log_message ( 'debug', 'File loaded: ' . $_ci_path );
		
		// Return the file data if requested
		if ( $_ci_return === TRUE ) {
			$buffer = ob_get_contents ();
			@ob_end_clean ();
			return $buffer;
		}
		
		/*
         * Flush the buffer... or buff the flusher?
         *
         * In order to permit views to be nested within
         * other views, we need to flush the content back out whenever
         * we are beyond the first level of output buffering so that
         * it can be seen and included properly by the first included
         * template and any subsequent ones. Oy!
         *
         */
		if ( ob_get_level () > $this->_ci_ob_level + 1 ) {
			ob_end_flush ();
		}
		else {
			// PHP 4 requires that we use a global
			global $OUT;
			$OUT->append_output ( ob_get_contents () );
			@ob_end_clean ();
		}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Load class
	 *
	 * This function loads the requested class.
	 *
	 * @access    private
	 * @param     string    the item that is being loaded
	 * @param    mixed    any additional parameters
	 * @return     void
	 */
	function _ci_load_class ( $class, $params = NULL ) {
		// Get the class name
		$class = str_replace ( EXT, '', $class );
		
		// We'll test for both lowercase and capitalized versions of the file name
		foreach ( array ( strtolower ( $class ), ucfirst ( $class ) ) as $class ) {
			// {{{ Matchbox

			$module = $this->_matchbox->argument ( 2 );

			if ( $subclass = $this->_matchbox->find ( 'libraries/' . config_item ( 'subclass_prefix' ) . $class . EXT, $module ) ) {

				$baseclass = $this->_matchbox->find ( 'libraries/' . $class . EXT, $module, 2 );
				
				// }}}
				

				if ( file_exists ( $baseclass ) ) {
					include ( $baseclass );
				}
				
				// Safety:  Was the class already loaded by a previous call?
				if ( in_array ( $subclass, $this->_ci_classes ) ) {
					$is_duplicate = TRUE;
					log_message ( 'debug', $class . " class already loaded. Second attempt ignored." );
					return;
				}
				
				
				include ( $subclass );
				$this->_ci_classes [ ] = $subclass;
				
				// {{{ Matchbox
				

				return $this->_ci_init_class ( $class, config_item ( 'subclass_prefix' ), $params, $module );
				
			// }}}
			}
			
			// Lets search for the requested library file and load it.
			$is_duplicate = FALSE;
			
			// {{{ Matchbox
			

			if ( $filepath = $this->_matchbox->find ( 'libraries/' . $class . EXT, $module, 2 ) ) {
				if ( in_array ( $class, $this->_ci_classes ) ) {
					$is_duplicate = true;
					log_message ( 'debug', $class . ' class already loaded. Second attempt ignored.' );
					return;
				}
				
				include_once ( $filepath );
				$this->_ci_classes [ ] = $class;
				return $this->_ci_init_class ( $class, '', $params, $module );
			}
			
		// }}}
		

		} // END FOREACH
		

		// If we got this far we were unable to find the requested class.
		// We do not issue errors if the load call failed due to a duplicate request
		if ( $is_duplicate == FALSE ) {
			log_message ( 'error', "Unable to load the requested class: " . $class );
			show_error ( "Unable to load the requested class: " . $class );
		}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Instantiates a class
	 *
	 * @access    private
	 * @param    string
	 * @param    string
	 * @return    null
	 */
	function _ci_init_class ( $class, $prefix = '', $config = FALSE ) {
		$class = strtolower ( $class );
		
		// Is there an associated config file for this class?
		// {{{ Matchbox
		

		$module = $this->_matchbox->argument ( 3 );
		
		if ( $config === null ) {
			if ( $filepath = $this->_matchbox->find ( 'config/' . $class . EXT, $module ) ) {
				include ( $filepath );
			}
		}
		
		// }}}
		

		if ( $prefix == '' ) {
			$name = ( class_exists ( 'CI_' . $class ) ) ? 'CI_' . $class : $class;
		}
		else {
			$name = $prefix . $class;
		}
		
		// Set the variable name we will assign the class to
		$classvar = ( ! isset ( $this->_ci_varmap [ $class ] ) ) ? $class : $this->_ci_varmap [ $class ];
		
		// Instantiate the class
		$CI = & get_instance ();
		if ( $config !== NULL ) {
			$CI->$classvar = new $name ( $config );
		}
		else {
			$CI->$classvar = new $name ( );
		}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Autoloader
	 *
	 * The config/autoload.php file contains an array that permits sub-systems,
	 * libraries, plugins, and helpers to be loaded automatically.
	 *
	 * @access    private
	 * @param    array
	 * @return    void
	 */
	function _ci_autoloader () {
		// {{{ Matchbox
		

		$ci = &get_instance ();
		$ci->matchbox = &load_class ( 'Matchbox' );
		
		//}}}
		

		include ( APPPATH . 'config/autoload' . EXT );
		
		if ( ! isset ( $autoload ) ) {
			return FALSE;
		}
		
		// Load any custom config file
		if ( count ( $autoload [ 'config' ] ) > 0 ) {
			// {{{ Matchbox
			

			foreach ( $autoload [ 'config' ] as $key => $value ) {
				if ( is_string ( $key ) ) {
					if ( is_array ( $value ) ) {
						foreach ( $value as $config ) {
							$ci->config->module_load ( $key, $config );
						}
					}
					else {
						$ci->config->module_load ( $key, $value );
					}
				}
				else {
					$ci->config->load ( $value );
				}
			}
			
		// }}}
		}
		
		// Autoload plugins, helpers, scripts and languages
		foreach ( array ( 
			'helper', 'plugin', 'script', 'language' 
		) as $type ) {
			if ( isset ( $autoload [ $type ] ) and count ( $autoload [ $type ] ) > 0 ) {
				
				// {{{ Matchbox
				

				foreach ( $autoload [ $type ] as $key => $value ) {
					if ( is_string ( $key ) ) {
						$this->{'module_' . $type} ( $key, $value );
					}
					else {
						$this->$type ( $value );
					}
				}
				
			// }}}
			}
		}
		
		// A little tweak to remain backward compatible
		// The $autoload['core'] item was deprecated
		if ( ! isset ( $autoload [ 'libraries' ] ) ) {
			$autoload [ 'libraries' ] = $autoload [ 'core' ];
		}
		
		// Load libraries
		if ( isset ( $autoload [ 'libraries' ] ) and count ( $autoload [ 'libraries' ] ) > 0 ) {
			// Load the database driver.
			if ( in_array ( 'database', $autoload [ 'libraries' ] ) ) {
				$this->database ();
				$autoload [ 'libraries' ] = array_diff ( $autoload [ 'libraries' ], array ( 
					'database' 
				) );
			}
			
			// Load scaffolding
			if ( in_array ( 'scaffolding', $autoload [ 'libraries' ] ) ) {
				$this->scaffolding ();
				$autoload [ 'libraries' ] = array_diff ( $autoload [ 'libraries' ], array ( 
					'scaffolding' 
				) );
			}
			
			// {{{ Matchbox
			

			foreach ( $autoload [ 'libraries' ] as $key => $value ) {
				if ( is_string ( $key ) ) {
					$this->module_library ( $key, $value );
				}
				else {
					$this->library ( $value );
				}
			}
			
		// }}}
		

		}
		
		// {{{ Matchbox
		

		if ( isset ( $autoload [ 'model' ] ) ) {
			foreach ( $autoload [ 'model' ] as $key => $value ) {
				if ( is_string ( $key ) ) {
					$this->module_model ( $key, $value );
				}
				else {
					$this->model ( $value );
				}
			}
		}
		
	// }}}
	

	}

	// --------------------------------------------------------------------
	

	/**
	 * Assign to Models
	 *
	 * Makes sure that anything loaded by the loader class (libraries, plugins, etc.)
	 * will be available to models, if any exist.
	 *
	 * @access    private
	 * @param    object
	 * @return    array
	 */
	function _ci_assign_to_models () {
		if ( count ( $this->_ci_models ) == 0 ) {
			return;
		}
		
		if ( $this->_ci_is_instance () ) {
			$CI = & get_instance ();
			foreach ( $this->_ci_models as $model ) {
				$CI->$model->_assign_libraries ();
			}
		}
		else {
			foreach ( $this->_ci_models as $model ) {
				$this->$model->_assign_libraries ();
			}
		}
	}

	// --------------------------------------------------------------------
	

	/**
	 * Object to Array
	 *
	 * Takes an object as input and converts the class variables to array key/vals
	 *
	 * @access    private
	 * @param    object
	 * @return    array
	 */
	function _ci_object_to_array ( $object ) {
		return ( is_object ( $object ) ) ? get_object_vars ( $object ) : $object;
	}

	// --------------------------------------------------------------------
	

	/**
	 * Determines whether we should use the CI instance or $this
	 *
	 * @access    private
	 * @return    bool
	 */
	function _ci_is_instance () {
		if ( $this->_ci_is_php5 == TRUE ) {
			return TRUE;
		}
		
		global $CI;
		return ( is_object ( $CI ) ) ? TRUE : FALSE;
	}

}
Return current item: Wallpaper Script