first commit

modules/leoslideshow/libs/Helper.php

@@ -0,0 +1,104 @@
+<?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
+ */
+
+if (!class_exists('LeoSlideshowHelper')) {
+
+    class LeoSlideshowHelper
+    {
+        const MODULE_NAME = 'leoslideshow';
+
+        public static function l($string, $specific = false, $name = '')
+        {
+            if (empty($name)) {
+                $name = self::MODULE_NAME;
+            }
+            return Translate::getModuleTranslation($name, $string, ($specific) ? $specific : $name);
+        }
+
+        /**
+         * Copy js, css to theme folder
+         */
+        public static function copyToTheme()
+        {
+            include_once(_PS_MODULE_DIR_.'leoslideshow/libs/phpcopy.php');
+
+            $theme_dir = _PS_ROOT_DIR_.'/themes/'.LeoSlideshowHelper::getThemeName().'/';
+            $module_dir = _PS_MODULE_DIR_.self::MODULE_NAME.'/';
+
+            $theme_js_dir = $theme_dir.'js/modules/leoslideshow/views/js';
+            $theme_css_dir = $theme_dir.'css/modules/leoslideshow/views/css';
+
+            // Create js folder
+            mkdir($theme_js_dir, 0755, true);
+            PhpCopy::safeCopy($module_dir.'views/js/', $theme_js_dir);
+
+            // Create css folder
+            mkdir($theme_css_dir, 0755, true);
+            PhpCopy::safeCopy($module_dir.'views/css/', $theme_css_dir);
+
+            $url = 'index.php?controller=adminmodules&configure=leoslideshow&token='.Tools::getAdminTokenLite('AdminModules')
+                    .'&tab_module=front_office_features&module_name=leoslideshow';
+            Tools::redirectAdmin($url);
+        }
+        
+        public static function getImgThemeUrl()
+        {
+            # LeoSlideshowHelper::getImgThemeUrl()
+            static $img_theme_url;
+            if (!$img_theme_url) {
+                // Not exit image or icon
+//                $img_theme_url = _THEME_IMG_DIR_.'modules/leoslideshow/';
+                $img_theme_url = _THEMES_DIR_.self::getThemeName().'/assets/img/modules/leoslideshow/';
+            }
+
+            return $img_theme_url;
+        }
+    
+        public static function getImgThemeDir()
+        {
+            static $img_theme_dir;
+            if (!$img_theme_dir) {
+                $img_theme_dir = _PS_ALL_THEMES_DIR_.LeoSlideshowHelper::getThemeName().'/assets/img/modules/leoslideshow/';
+            }
+            return $img_theme_dir;
+        }
+        
+        public static function genKey()
+        {
+            return md5(time().rand());
+        }
+        
+        public static function getThemeName()
+        {
+            static $theme_name;
+            if (!$theme_name) {
+                # DEFAULT SINGLE_SHOP
+                $theme_name = _THEME_NAME_;
+
+                # GET THEME_NAME MULTI_SHOP
+                if (Shop::getTotalShops(false, null) >= 2) {
+                    $id_shop = Context::getContext()->shop->id;
+
+                    $shop_arr = Shop::getShop($id_shop);
+                    if (is_array($shop_arr) && !empty($shop_arr)) {
+                        $theme_name = $shop_arr['theme_name'];
+                    }
+                }
+            }
+
+            return $theme_name;
+        }
+    }
+}

modules/leoslideshow/libs/LeoValidate.php

@@ -0,0 +1,25 @@
+<?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
+ */
+
+if (!defined('_PS_VERSION_')) {
+    # module validation
+    exit;
+}
+
+
+class Datasample
+{
+    
+}

modules/leoslideshow/libs/index.php

@@ -0,0 +1,35 @@
+<?php
+/**
+* 2007-2014 PrestaShop
+*
+* NOTICE OF LICENSE
+*
+* This source file is subject to the Academic Free License (AFL 3.0)
+* that is bundled with this package in the file LICENSE.txt.
+* It is also available through the world-wide-web at this URL:
+* http://opensource.org/licenses/afl-3.0.php
+* If you did not receive a copy of the license and are unable to
+* obtain it through the world-wide-web, please send an email
+* to license@prestashop.com so we can send you a copy immediately.
+*
+* DISCLAIMER
+*
+* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+* versions in the future. If you wish to customize PrestaShop for your
+* needs please refer to http://www.prestashop.com for more information.
+*
+*  @author    PrestaShop SA <contact@prestashop.com>
+*  @copyright 2007-2014 PrestaShop SA
+*  @license   http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
+*  International Registered Trademark & Property of PrestaShop SA
+*/
+
+header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
+header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
+
+header('Cache-Control: no-store, no-cache, must-revalidate');
+header('Cache-Control: post-check=0, pre-check=0', false);
+header('Pragma: no-cache');
+
+header('Location: ../');
+exit;

modules/leoslideshow/libs/phpcopy.php

@@ -0,0 +1,96 @@
+<?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
+ */
+
+if (!class_exists('phpcopy')) {
+
+    class PhpCopy
+    {
+
+        /**
+         * @reference http://snipplr.com/view/74297/copy-files-and-folder-recursive/
+         * copy and override
+         */
+        public static function cpy($source, $dest)
+        {
+            if (is_dir($source)) {
+                $dir_handle = opendir($source);
+                while ($file = readdir($dir_handle)) {
+                    if ($file != "." && $file != "..") {
+                        if (is_dir($source."/".$file)) {
+                            if (!is_dir($dest."/".$file)) {
+                                mkdir($dest."/".$file);
+                            }
+                            self::cpy($source."/".$file, $dest."/".$file);
+                        } else {
+                            // if this is file then copy
+                            copy($source."/".$file, $dest."/".$file);
+                        }
+                    }
+                }
+                closedir($dir_handle);
+            } else {
+                // if this is file then copy
+                copy($source, $dest);
+            }
+        }
+
+        /**
+         * Copy but not override
+         */
+        public static function safeCopy($source, $dest)
+        {
+            if (is_dir($source)) {
+                $dir_handle = opendir($source);
+                while ($file = readdir($dir_handle)) {
+                    if ($file != "." && $file != "..") {
+                        if (is_dir($source."/".$file)) {
+                            if (!is_dir($dest."/".$file)) {
+                                mkdir($dest."/".$file);
+                            }
+                            self::safeCopy($source."/".$file, $dest."/".$file);
+                        } else {
+                            if (is_file($dest."/".$file) === false) {
+                                // if this is file then copy
+                                copy($source."/".$file, $dest."/".$file);
+                            }
+                        }
+                    }
+                }
+                closedir($dir_handle);
+            } else {
+                if (is_file($dest) === false) {
+                    // if this is file then copy
+                    // if the destination file already exists, it will NOT be overwritten.
+                    copy($source, $dest);
+                }
+            }
+        }
+
+        /**
+         * create folder foler path : a/b/c/d
+         * recursively create a long directory path
+         */
+        public static function createPath($path)
+        {
+            if (is_dir($path)) {
+                # module validation
+                return true;
+            }
+            $prev_path = Tools::substr($path, 0, strrpos($path, '/', -2) + 1);
+            $return = self::createPath($prev_path);
+            return ($return && is_writable($prev_path)) ? mkdir($path) : false;
+        }
+    }
+}

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;
+    }
+}

modules/leoslideshow/libs/phpthumb/README.md

@@ -0,0 +1,13 @@
+# PHP Thumb
+
+PHP Thumb is a light-weight image manipulation library 
+aimed at thumbnail generation. It features the ability to 
+resize by width, height, and percentage, create custom crops, 
+or square crops from the center, and rotate the image. You can 
+also easily add custom functionality to the library through plugins. 
+It also features the ability to perform multiple manipulations per 
+instance (also known as chaining), without the need to save and 
+re-initialize the class with every manipulation.
+
+More information and documentation is available at the project's 
+homepage: [http://phpthumb.gxdlabs.com](http://phpthumb.gxdlabs.com)

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

@@ -0,0 +1,304 @@
+<?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
+ */
+
+/**
+ * ThumbBase Class Definition
+ *
+ * This is the base class that all implementations must extend.  It contains the
+ * core variables and functionality common to all implementations, as well as the functions that
+ * allow plugins to augment those classes.
+ *
+ * @package PhpThumb
+ * @subpackage Core
+ */
+abstract class ThumbBase
+{
+    /**
+     * All imported objects
+     *
+     * An array of imported plugin objects
+     *
+     * @var array
+     */
+    protected $imported;
+    /**
+     * All imported object functions
+     *
+     * An array of all methods added to this class by imported plugin objects
+     *
+     * @var array
+     */
+    protected $importedFunctions;
+    /**
+     * The last error message raised
+     *
+     * @var string
+     */
+    protected $errorMessage;
+    /**
+     * Whether or not the current instance has any errors
+     *
+     * @var bool
+     */
+    protected $hasError;
+    /**
+     * The name of the file we're manipulating
+     *
+     * This must include the path to the file (absolute paths recommended)
+     *
+     * @var string
+     */
+    protected $fileName;
+    /**
+     * What the file format is (mime-type)
+     *
+     * @var string
+     */
+    protected $format;
+    /**
+     * Whether or not the image is hosted remotely
+     *
+     * @var bool
+     */
+    protected $remoteImage;
+    /**
+     * Whether or not the current image is an actual file, or the raw file data
+     *
+     * By "raw file data" it's meant that we're actually passing the result of something
+     * like file_get_contents() or perhaps from a database blob
+     *
+     * @var bool
+     */
+    protected $isDataStream;
+
+    /**
+     * Class constructor
+     *
+     * @return ThumbBase
+     */
+    public function __construct($fileName, $isDataStream = false)
+    {
+        $this->imported = array();
+        $this->importedFunctions = array();
+        $this->errorMessage = null;
+        $this->hasError = false;
+        $this->fileName = $fileName;
+        $this->remoteImage = false;
+        $this->isDataStream = $isDataStream;
+
+        $this->fileExistsAndReadable();
+    }
+
+    /**
+     * Imports plugins in $registry to the class
+     *
+     * @param array $registry
+     */
+    public function importPlugins($registry)
+    {
+        foreach ($registry as $plugin => $meta) {
+            $this->imports($plugin);
+        }
+    }
+
+    /**
+     * Imports a plugin
+     *
+     * This is where all the plugins magic happens!  This function "loads" the plugin functions, making them available as
+     * methods on the class.
+     *
+     * @param string $object The name of the object to import / "load"
+     */
+    protected function imports($object)
+    {
+        // the new object to import
+        $newImport = new $object();
+        // the name of the new object (class name)
+        $importName = get_class($newImport);
+        // the new functions to import
+        $importFunctions = get_class_methods($newImport);
+
+        // add the object to the registry
+        array_push($this->imported, array($importName, $newImport));
+
+        // add the methods to the registry
+        foreach ($importFunctions as $key => $functionName) {
+            $this->importedFunctions[$functionName] = &$newImport;
+        }
+    }
+
+    /**
+     * Checks to see if $this->fileName exists and is readable
+     *
+     */
+    protected function fileExistsAndReadable()
+    {
+        if ($this->isDataStream === true) {
+            return;
+        }
+
+        if (stristr($this->fileName, 'http://') !== false) {
+            $this->remoteImage = true;
+            return;
+        }
+
+        if (!file_exists($this->fileName)) {
+            $this->triggerError('Image file not found: '.$this->fileName);
+        } elseif (!is_readable($this->fileName)) {
+            $this->triggerError('Image file not readable: '.$this->fileName);
+        }
+    }
+
+    /**
+     * Sets $this->errorMessage to $errorMessage and throws an exception
+     *
+     * Also sets $this->hasError to true, so even if the exceptions are caught, we don't
+     * attempt to proceed with any other functions
+     *
+     * @param string $errorMessage
+     */
+    protected function triggerError($errorMessage)
+    {
+        $this->hasError = true;
+        $this->errorMessage = $errorMessage;
+
+        throw new Exception($errorMessage);
+    }
+
+    /**
+     * Calls plugin / imported functions
+     *
+     * This is also where a fair amount of plugins magaic happens.  This magic method is called whenever an "undefined" class
+     * method is called in code, and we use that to call an imported function.
+     *
+     * You should NEVER EVER EVER invoke this function manually.  The universe will implode if you do... seriously ;)
+     *
+     * @param string $method
+     * @param array $args
+     */
+    public function __call($method, $args)
+    {
+        if (array_key_exists($method, $this->importedFunctions)) {
+            $args[] = $this;
+            return call_user_func_array(array($this->importedFunctions[$method], $method), $args);
+        }
+
+        throw new BadMethodCallException('Call to undefined method/class function: '.$method);
+    }
+
+    /**
+     * Returns $imported.
+     * @see ThumbBase::$imported
+     * @return array
+     */
+    public function getImported()
+    {
+        return $this->imported;
+    }
+
+    /**
+     * Returns $importedFunctions.
+     * @see ThumbBase::$importedFunctions
+     * @return array
+     */
+    public function getImportedFunctions()
+    {
+        return $this->importedFunctions;
+    }
+
+    /**
+     * Returns $errorMessage.
+     *
+     * @see ThumbBase::$errorMessage
+     */
+    public function getErrorMessage()
+    {
+        return $this->errorMessage;
+    }
+
+    /**
+     * Sets $errorMessage.
+     *
+     * @param object $errorMessage
+     * @see ThumbBase::$errorMessage
+     */
+    public function setErrorMessage($errorMessage)
+    {
+        $this->errorMessage = $errorMessage;
+    }
+
+    /**
+     * Returns $fileName.
+     *
+     * @see ThumbBase::$fileName
+     */
+    public function getFileName()
+    {
+        return $this->fileName;
+    }
+
+    /**
+     * Sets $fileName.
+     *
+     * @param object $fileName
+     * @see ThumbBase::$fileName
+     */
+    public function setFileName($fileName)
+    {
+        $this->fileName = $fileName;
+    }
+
+    /**
+     * Returns $format.
+     *
+     * @see ThumbBase::$format
+     */
+    public function getFormat()
+    {
+        return $this->format;
+    }
+
+    /**
+     * Sets $format.
+     *
+     * @param object $format
+     * @see ThumbBase::$format
+     */
+    public function setFormat($format)
+    {
+        $this->format = $format;
+    }
+
+    /**
+     * Returns $hasError.
+     *
+     * @see ThumbBase::$hasError
+     */
+    public function getHasError()
+    {
+        return $this->hasError;
+    }
+
+    /**
+     * Sets $hasError.
+     *
+     * @param object $hasError
+     * @see ThumbBase::$hasError
+     */
+    public function setHasError($hasError)
+    {
+        $this->hasError = $hasError;
+    }
+}

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

@@ -0,0 +1,129 @@
+<?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
+ */
+
+// define some useful constants
+define('THUMBLIB_BASE_PATH', dirname(__FILE__));
+define('THUMBLIB_PLUGIN_PATH', THUMBLIB_BASE_PATH.'/thumb_plugins/');
+define('DEFAULT_THUMBLIB_IMPLEMENTATION', 'gd');
+
+/**
+ * Include the PhpThumb Class
+ */
+require_once THUMBLIB_BASE_PATH.'/PhpThumb.inc.php';
+/**
+ * Include the ThumbBase Class
+ */
+require_once THUMBLIB_BASE_PATH.'/ThumbBase.inc.php';
+/**
+ * Include the GdThumb Class
+ */
+require_once THUMBLIB_BASE_PATH.'/GdThumb.inc.php';
+
+/**
+ * PhpThumbFactory Object
+ *
+ * This class is responsible for making sure everything is set up and initialized properly,
+ * and returning the appropriate thumbnail class instance.  It is the only recommended way
+ * of using this library, and if you try and circumvent it, the sky will fall on your head :)
+ *
+ * Basic use is easy enough.  First, make sure all the settings meet your needs and environment...
+ * these are the static variables defined at the beginning of the class.
+ *
+ * Once that's all set, usage is pretty easy.  You can simply do something like:
+ * <code>$thumb = PhpThumbFactory::create('/path/to/file.png');</code>
+ *
+ * Refer to the documentation for the create function for more information
+ *
+ * @package PhpThumb
+ * @subpackage Core
+ */
+class PhpThumbFactory
+{
+    /**
+     * Which implemenation of the class should be used by default
+     *
+     * Currently, valid options are:
+     *  - imagick
+     *  - gd
+     *
+     * These are defined in the implementation map variable, inside the create function
+     *
+     * @var string
+     */
+    public static $defaultImplemenation = DEFAULT_THUMBLIB_IMPLEMENTATION;
+    /**
+     * Where the plugins can be loaded from
+     *
+     * Note, it's important that this path is properly defined.  It is very likely that you'll
+     * have to change this, as the assumption here is based on a relative path.
+     *
+     * @var string
+     */
+    public static $pluginPath = THUMBLIB_PLUGIN_PATH;
+
+    /**
+     * Factory Function
+     *
+     * This function returns the correct thumbnail object, augmented with any appropriate plugins.
+     * It does so by doing the following:
+     *  - Getting an instance of PhpThumb
+     *  - Loading plugins
+     *  - Validating the default implemenation
+     *  - Returning the desired default implementation if possible
+     *  - Returning the GD implemenation if the default isn't available
+     *  - Throwing an exception if no required libraries are present
+     *
+     * @return GdThumb
+     * @uses PhpThumb
+     * @param string $filename The path and file to load [optional]
+     */
+    public static function create($filename = null, $options = array(), $isDataStream = false)
+    {
+        // map our implementation to their class names
+        $implementationMap = array
+            (
+            'imagick' => 'ImagickThumb',
+            'gd' => 'GdThumb'
+        );
+
+        // grab an instance of PhpThumb
+        $pt = PhpThumb::getInstance();
+        // load the plugins
+        $pt->loadPlugins(self::$pluginPath);
+
+        $toReturn = null;
+        $implementation = self::$defaultImplemenation;
+
+        // attempt to load the default implementation
+        if ($pt->isValidImplementation(self::$defaultImplemenation)) {
+            $imp = $implementationMap[self::$defaultImplemenation];
+            $toReturn = new $imp($filename, $options, $isDataStream);
+        }
+        // load the gd implementation if default failed
+        else if ($pt->isValidImplementation('gd')) {
+            $imp = $implementationMap['gd'];
+            $implementation = 'gd';
+            $toReturn = new $imp($filename, $options, $isDataStream);
+        }
+        // throw an exception if we can't load
+        else {
+            throw new Exception('You must have either the GD or iMagick extension loaded to use this library');
+        }
+
+        $registry = $pt->getPluginRegistry($implementation);
+        $toReturn->importPlugins($registry);
+        return $toReturn;
+    }
+}

modules/leoslideshow/libs/phpthumb/index.php

@@ -0,0 +1,35 @@
+<?php
+/**
+* 2007-2014 PrestaShop
+*
+* NOTICE OF LICENSE
+*
+* This source file is subject to the Academic Free License (AFL 3.0)
+* that is bundled with this package in the file LICENSE.txt.
+* It is also available through the world-wide-web at this URL:
+* http://opensource.org/licenses/afl-3.0.php
+* If you did not receive a copy of the license and are unable to
+* obtain it through the world-wide-web, please send an email
+* to license@prestashop.com so we can send you a copy immediately.
+*
+* DISCLAIMER
+*
+* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+* versions in the future. If you wish to customize PrestaShop for your
+* needs please refer to http://www.prestashop.com for more information.
+*
+*  @author    PrestaShop SA <contact@prestashop.com>
+*  @copyright 2007-2014 PrestaShop SA
+*  @license   http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
+*  International Registered Trademark & Property of PrestaShop SA
+*/
+
+header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
+header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
+
+header('Cache-Control: no-store, no-cache, must-revalidate');
+header('Cache-Control: post-check=0, pre-check=0', false);
+header('Pragma: no-cache');
+
+header('Location: ../');
+exit;

modules/leoslideshow/libs/phpthumb/thumb_plugins/gd_reflection.inc.php

@@ -0,0 +1,149 @@
+<?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
+ */
+
+/**
+ * GD Reflection Lib Plugin
+ *
+ * This plugin allows you to create those fun Apple(tm)-style reflections in your images
+ *
+ * @package PhpThumb
+ * @subpackage Plugins
+ */
+class GdReflectionLib
+{
+    /**
+     * Instance of GdThumb passed to this class
+     *
+     * @var GdThumb
+     */
+    protected $parentInstance;
+    protected $currentDimensions;
+    protected $workingImage;
+    protected $newImage;
+    protected $options;
+
+    public function createReflection($percent, $reflection, $white, $border, $borderColor, &$that)
+    {
+        // bring stuff from the parent class into this class...
+        $this->parentInstance = $that;
+        $this->currentDimensions = $this->parentInstance->getCurrentDimensions();
+        $this->workingImage = $this->parentInstance->getWorkingImage();
+        $this->newImage = $this->parentInstance->getOldImage();
+        $this->options = $this->parentInstance->getOptions();
+
+        $width = $this->currentDimensions['width'];
+        $height = $this->currentDimensions['height'];
+        $reflectionHeight = intval($height * ($reflection / 100));
+        $newHeight = $height + $reflectionHeight;
+        $reflectedPart = $height * ($percent / 100);
+
+        $this->workingImage = imagecreatetruecolor($width, $newHeight);
+
+        imagealphablending($this->workingImage, true);
+
+        $colorToPaint = imagecolorallocatealpha($this->workingImage, 255, 255, 255, 0);
+        imagefilledrectangle($this->workingImage, 0, 0, $width, $newHeight, $colorToPaint);
+
+        imagecopyresampled
+                (
+                $this->workingImage, $this->newImage, 0, 0, 0, $reflectedPart, $width, $reflectionHeight, $width, ($height - $reflectedPart)
+        );
+
+        $this->imageFlipVertical();
+
+        imagecopy($this->workingImage, $this->newImage, 0, 0, 0, 0, $width, $height);
+
+        imagealphablending($this->workingImage, true);
+
+        for ($i = 0; $i < $reflectionHeight; $i++) {
+            $colorToPaint = imagecolorallocatealpha($this->workingImage, 255, 255, 255, ($i / $reflectionHeight * -1 + 1) * $white);
+
+            imagefilledrectangle($this->workingImage, 0, $height + $i, $width, $height + $i, $colorToPaint);
+        }
+
+        if ($border == true) {
+            $rgb = $this->hex2rgb($borderColor, false);
+            $colorToPaint = imagecolorallocate($this->workingImage, $rgb[0], $rgb[1], $rgb[2]);
+
+            imageline($this->workingImage, 0, 0, $width, 0, $colorToPaint); //top line
+            imageline($this->workingImage, 0, $height, $width, $height, $colorToPaint); //bottom line
+            imageline($this->workingImage, 0, 0, 0, $height, $colorToPaint); //left line
+            imageline($this->workingImage, $width - 1, 0, $width - 1, $height, $colorToPaint); //right line
+        }
+
+        if ($this->parentInstance->getFormat() == 'PNG') {
+            $colorTransparent = imagecolorallocatealpha
+                    (
+                    $this->workingImage, $this->options['alphaMaskColor'][0], $this->options['alphaMaskColor'][1], $this->options['alphaMaskColor'][2], 0
+            );
+
+            imagefill($this->workingImage, 0, 0, $colorTransparent);
+            imagesavealpha($this->workingImage, true);
+        }
+
+        $this->parentInstance->setOldImage($this->workingImage);
+        $this->currentDimensions['width'] = $width;
+        $this->currentDimensions['height'] = $newHeight;
+        $this->parentInstance->setCurrentDimensions($this->currentDimensions);
+
+        return $that;
+    }
+
+    /**
+     * Flips the image vertically
+     *
+     */
+    protected function imageFlipVertical()
+    {
+        $x_i = imagesx($this->workingImage);
+        $y_i = imagesy($this->workingImage);
+
+        for ($x = 0; $x < $x_i; $x++) {
+            for ($y = 0; $y < $y_i; $y++) {
+                imagecopy($this->workingImage, $this->workingImage, $x, $y_i - $y - 1, $x, $y, 1, 1);
+            }
+        }
+    }
+
+    /**
+     * Converts a hex color to rgb tuples
+     *
+     * @return mixed
+     * @param string $hex
+     * @param bool $asString
+     */
+    protected function hex2rgb($hex, $asString = false)
+    {
+        // strip off any leading #
+        if (0 === strpos($hex, '#')) {
+            $hex = Tools::substr($hex, 1);
+        } elseif (0 === strpos($hex, '&H')) {
+            $hex = Tools::substr($hex, 2);
+        }
+
+        // break into hex 3-tuple
+        $cutpoint = ceil(Tools::strlen($hex) / 2) - 1;
+        $rgb = explode(':', wordwrap($hex, $cutpoint, ':', $cutpoint), 3);
+
+        // convert each tuple to decimal
+        $rgb[0] = (isset($rgb[0]) ? hexdec($rgb[0]) : 0);
+        $rgb[1] = (isset($rgb[1]) ? hexdec($rgb[1]) : 0);
+        $rgb[2] = (isset($rgb[2]) ? hexdec($rgb[2]) : 0);
+
+        return ($asString ? "{$rgb[0]} {$rgb[1]} {$rgb[2]}" : $rgb);
+    }
+}
+$pt = PhpThumb::getInstance();
+$pt->registerPlugin('GdReflectionLib', 'gd');

modules/leoslideshow/libs/phpthumb/thumb_plugins/index.php

@@ -0,0 +1,36 @@
+<?php
+/*
+* 2007-2014 PrestaShop
+*
+* NOTICE OF LICENSE
+*
+* This source file is subject to the Open Software License (OSL 3.0)
+* that is bundled with this package in the file LICENSE.txt.
+* It is also available through the world-wide-web at this URL:
+* http://opensource.org/licenses/osl-3.0.php
+* If you did not receive a copy of the license and are unable to
+* obtain it through the world-wide-web, please send an email
+* to license@prestashop.com so we can send you a copy immediately.
+*
+* DISCLAIMER
+*
+* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+* versions in the future. If you wish to customize PrestaShop for your
+* needs please refer to http://www.prestashop.com for more information.
+*
+*  @author PrestaShop SA <contact@prestashop.com>
+*  @copyright  2007-2014 PrestaShop SA
+*  @version  Release: $Revision$
+*  @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
+*  International Registered Trademark & Property of PrestaShop SA
+*/
+                    
+header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
+header("Last-Modified: ".gmdate("D, d M Y H:i:s")." GMT");
+    
+header("Cache-Control: no-store, no-cache, must-revalidate");
+header("Cache-Control: post-check=0, pre-check=0", false);
+header("Pragma: no-cache");
+    
+header("Location: ../");
+exit;