first commit

modules/leoslideshow/libs/phpthumb/PhpThumb.inc.php

@@ -0,0 +1,220 @@
+<?php
+/**
+ * 2007-2015 Leotheme
+ *
+ * NOTICE OF LICENSE
+ *
+ * Adds image, text or video to your homepage.
+ *
+ * DISCLAIMER
+ *
+ *  @author    leotheme <leotheme@gmail.com>
+ *  @copyright 2007-2015 Leotheme
+ *  @license   http://leotheme.com - prestashop template provider
+ */
+
+/**
+ * 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 (Tools::substr($pluginPath, Tools::strlen($pluginPath) - 1, 1) == '/') {
+            $pluginPath = Tools::substr($pluginPath, 0, Tools::strlen($pluginPath) - 1);
+        }
+
+        if ($handle = opendir($pluginPath)) {
+            while (false !== ($file = readdir($handle))) {
+                if ($file == '.' || $file == '..' || $file == '.svn' || $file == 'index.php') {
+                    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;
+    }
+}