first commit

modules/ph_simpleblog/assets/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/ph_simpleblog/assets/phpthumb/PhpThumb.inc.php

@@ -0,0 +1,247 @@
+<?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;
+	}
+}

modules/ph_simpleblog/assets/phpthumb/ThumbBase.inc.php

@@ -0,0 +1,323 @@
+<?php
+/**
+ * PhpThumb Base Class Definition File
+ * 
+ * This file contains the definition for the ThumbBase object
+ * 
+ * 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
+ */
+
+/**
+ * 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/ph_simpleblog/assets/phpthumb/ThumbLib.inc.php

@@ -0,0 +1,146 @@
+<?php
+/**
+ * PhpThumb Library Definition File
+ * 
+ * This file contains the definitions for the PhpThumbFactory class.
+ * It also includes the other required base class files.
+ * 
+ * If you've got some auto-loading magic going on elsewhere in your code, feel free to
+ * remove the include_once statements at the beginning of this file... just make sure that
+ * these files get included one way or another in your code.
+ * 
+ * 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
+ */
+
+// 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/ph_simpleblog/assets/phpthumb/thumb_plugins/gd_reflection.inc.php

@@ -0,0 +1,180 @@
+<?php
+/**
+ * GD Reflection Lib Plugin Definition File
+ * 
+ * This file contains the plugin definition for the GD Reflection Lib for PHP Thumb
+ * 
+ * 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
+ */
+
+/**
+ * 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 = substr($hex, 1);
+        } 
+		elseif (0 === strpos($hex, '&H')) 
+		{
+           $hex = substr($hex, 2);
+        }
+
+        // break into hex 3-tuple
+        $cutpoint = ceil(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/ph_simpleblog/assets/recaptchalib.php

@@ -0,0 +1,138 @@
+<?php
+/**
+ * This is a PHP library that handles calling reCAPTCHA.
+ *    - Documentation and latest version
+ *          https://developers.google.com/recaptcha/docs/php
+ *    - Get a reCAPTCHA API Key
+ *          https://www.google.com/recaptcha/admin/create
+ *    - Discussion group
+ *          http://groups.google.com/group/recaptcha
+ *
+ * @copyright Copyright (c) 2014, Google Inc.
+ * @link      http://www.google.com/recaptcha
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * A ReCaptchaResponse is returned from checkAnswer().
+ */
+class ReCaptchaResponse
+{
+    public $success;
+    public $errorCodes;
+}
+
+class ReCaptcha
+{
+    private static $_signupUrl = "https://www.google.com/recaptcha/admin";
+    private static $_siteVerifyUrl =
+        "https://www.google.com/recaptcha/api/siteverify?";
+    private $_secret;
+    private static $_version = "php_1.0";
+
+    /**
+     * Constructor.
+     *
+     * @param string $secret shared secret between site and ReCAPTCHA server.
+     */
+    function ReCaptcha($secret)
+    {
+        if ($secret == null || $secret == "") {
+            die("To use reCAPTCHA you must get an API key from <a href='"
+                . self::$_signupUrl . "'>" . self::$_signupUrl . "</a>");
+        }
+        $this->_secret=$secret;
+    }
+
+    /**
+     * Encodes the given data into a query string format.
+     *
+     * @param array $data array of string elements to be encoded.
+     *
+     * @return string - encoded request.
+     */
+    private function _encodeQS($data)
+    {
+        $req = "";
+        foreach ($data as $key => $value) {
+            $req .= $key . '=' . urlencode(stripslashes($value)) . '&';
+        }
+
+        // Cut the last '&'
+        $req=substr($req, 0, strlen($req)-1);
+        return $req;
+    }
+
+    /**
+     * Submits an HTTP GET to a reCAPTCHA server.
+     *
+     * @param string $path url path to recaptcha server.
+     * @param array  $data array of parameters to be sent.
+     *
+     * @return array response
+     */
+    private function _submitHTTPGet($path, $data)
+    {
+        $req = $this->_encodeQS($data);
+        $response = file_get_contents($path . $req);
+        return $response;
+    }
+
+    /**
+     * Calls the reCAPTCHA siteverify API to verify whether the user passes
+     * CAPTCHA test.
+     *
+     * @param string $remoteIp   IP address of end user.
+     * @param string $response   response string from recaptcha verification.
+     *
+     * @return ReCaptchaResponse
+     */
+    public function verifyResponse($remoteIp, $response)
+    {
+        // Discard empty solution submissions
+        if ($response == null || strlen($response) == 0) {
+            $recaptchaResponse = new ReCaptchaResponse();
+            $recaptchaResponse->success = false;
+            $recaptchaResponse->errorCodes = 'missing-input';
+            return $recaptchaResponse;
+        }
+
+        $getResponse = $this->_submitHttpGet(
+            self::$_siteVerifyUrl,
+            array (
+                'secret' => $this->_secret,
+                'remoteip' => $remoteIp,
+                'v' => self::$_version,
+                'response' => $response
+            )
+        );
+        $answers = json_decode($getResponse, true);
+        $recaptchaResponse = new ReCaptchaResponse();
+
+        if (trim($answers ['success']) == true) {
+            $recaptchaResponse->success = true;
+        } else {
+            $recaptchaResponse->success = false;
+            $recaptchaResponse->errorCodes = $answers [error-codes];
+        }
+
+        return $recaptchaResponse;
+    }
+}