WB 2.11.0

<?php

/**

 * PhpThumb Library Definition File

 *

 * This file contains the definitions for the PhpThumb class.

 *

 * PHP Version 5 with GD 2.0+

 * PhpThumb : PHP Thumb Library <http://phpthumb.gxdlabs.com>

 * Copyright (c) 2009, Ian Selby/Gen X Design

 *

 * Author(s): Ian Selby <ian@gen-x-design.com>

 *

 * Licensed under the MIT License

 * Redistributions of files must retain the above copyright notice.

 *

 * @author Ian Selby <ian@gen-x-design.com>

 * @copyright Copyright (c) 2009 Gen X Design

 * @link http://phpthumb.gxdlabs.com

 * @license http://www.opensource.org/licenses/mit-license.php The MIT License

 * @version 3.0

 * @package PhpThumb

 * @filesource

 */

/**

 * PhpThumb Object

 *

 * This singleton object is essentially a function library that helps with core validation

 * and loading of the core classes and plugins.  There isn't really any need to access it directly,

 * unless you're developing a plugin and need to take advantage of any of the functionality contained

 * within.

 *

 * If you're not familiar with singleton patterns, here's how you get an instance of this class (since you

 * can't create one via the new keyword):

 * <code>$pt = PhpThumb::getInstance();</code>

 *

 * It's that simple!  Outside of that, there's no need to modify anything within this class, unless you're doing

 * some crazy customization... then knock yourself out! :)

 *

 * @package PhpThumb

 * @subpackage Core

 */

class PhpThumb

{

    /**

     * Instance of self

     *

     * @var object PhpThumb

     */

    protected static $_instance;

    /**

     * The plugin registry

     *

     * This is where all plugins to be loaded are stored.  Data about the plugin is

     * provided, and currently consists of:

     *  - loaded: true/false

     *  - implementation: gd/imagick/both

     *

     * @var array

     */

    protected $_registry;

    /**

     * What implementations are available

     *

     * This stores what implementations are available based on the loaded

     * extensions in PHP, NOT whether or not the class files are present.

     *

     * @var array

     */

    protected $_implementations;

    /**

     * Returns an instance of self

     *

     * This is the usual singleton function that returns / instantiates the object

     *

     * @return PhpThumb

     */

    public static function getInstance ()

    {

        if(!(self::$_instance instanceof self))

        {

            self::$_instance = new self();

        }

        return self::$_instance;

    }

    /**

     * Class constructor

     *

     * Initializes all the variables, and does some preliminary validation / checking of stuff

     *

     */

    private function __construct ()

    {

        $this->_registry        = array();

        $this->_implementations    = array('gd' => false, 'imagick' => false);

        $this->getImplementations();

    }

    /**

     * Finds out what implementations are available

     *

     * This function loops over $this->_implementations and validates that the required extensions are loaded.

     *

     * I had planned on attempting to load them dynamically via dl(), but that would provide more overhead than I

     * was comfortable with (and would probably fail 99% of the time anyway)

     *

     */

    private function getImplementations ()

    {

        foreach($this->_implementations as $extension => $loaded)

        {

            if($loaded)

            {

                continue;

            }

            if(extension_loaded($extension))

            {

                $this->_implementations[$extension] = true;

            }

        }

    }

    /**

     * Returns whether or not $implementation is valid (available)

     *

     * If 'all' is passed, true is only returned if ALL implementations are available.

     *

     * You can also pass 'n/a', which always returns true

     *

     * @return bool

     * @param string $implementation

     */

    public function isValidImplementation ($implementation)

    {

        if ($implementation == 'n/a')

        {

            return true;

        }

        if ($implementation == 'all')

        {

            foreach ($this->_implementations as $imp => $value)

            {

                if ($value == false)

                {

                    return false;

                }

            }

            return true;

        }

        if (array_key_exists($implementation, $this->_implementations))

        {

            return $this->_implementations[$implementation];

        }

        return false;

    }

    /**

     * Registers a plugin in the registry

     *

     * Adds a plugin to the registry if it isn't already loaded, and if the provided

     * implementation is valid.  Note that you can pass the following special keywords

     * for implementation:

     *  - all - Requires that all implementations be available

     *  - n/a - Doesn't require any implementation

     *

     * When a plugin is added to the registry, it's added as a key on $this->_registry with the value

     * being an array containing the following keys:

     *  - loaded - whether or not the plugin has been "loaded" into the core class

     *  - implementation - what implementation this plugin is valid for

     *

     * @return bool

     * @param string $pluginName

     * @param string $implementation

     */

    public function registerPlugin ($pluginName, $implementation)

    {

        if (!array_key_exists($pluginName, $this->_registry) && $this->isValidImplementation($implementation))

        {

            $this->_registry[$pluginName] = array('loaded' => false, 'implementation' => $implementation);

            return true;

        }

        return false;

    }

    /**

     * Loads all the plugins in $pluginPath

     *

     * All this function does is include all files inside the $pluginPath directory.  The plugins themselves

     * will not be added to the registry unless you've properly added the code to do so inside your plugin file.

     *

     * @param string $pluginPath

     */

    public function loadPlugins ($pluginPath)

    {

        // strip the trailing slash if present

        if (substr($pluginPath, strlen($pluginPath) - 1, 1) == '/')

        {

            $pluginPath = substr($pluginPath, 0, strlen($pluginPath) - 1);

        }

        if ($handle = opendir($pluginPath))

        {

            while (false !== ($file = readdir($handle)))

            {

                if ($file == '.' || $file == '..' || $file == '.svn')

                {

                    continue;

                }

                include_once($pluginPath . '/' . $file);

            }

        }

    }

    /**

     * Returns the plugin registry for the supplied implementation

     *

     * @return array

     * @param string $implementation

     */

    public function getPluginRegistry ($implementation)

    {

        $returnArray = array();

        foreach ($this->_registry as $plugin => $meta)

        {

            if ($meta['implementation'] == 'n/a' || $meta['implementation'] == $implementation)

            {

                $returnArray[$plugin] = $meta;

            }

        }

        return $returnArray;

    }

}