mambax7 / XoopsCore25

htdocs/class/libraries/vendor/xoops/xmf/src/Highlighter.php

Spacing +5 added lines, -5 removed lines

@@ -69,15 +69,15 @@ 
         $encoding = static::ENCODING;
         return preg_replace_callback(
             '#((?:(?!<[/a-z]).)*)([^>]*>|$)#si',
-            function ($capture) use ($needle, $pre, $post, $encoding) {
+            function($capture) use ($needle, $pre, $post, $encoding) {
                 $haystack = $capture[1];
                 if (function_exists('mb_substr')) {
                     $p1 = mb_stripos($haystack, $needle, 0, $encoding);
                     $l1 = mb_strlen($needle, $encoding);
                     $ret = '';
                     while ($p1 !== false) {
-                        $ret .= mb_substr($haystack, 0, $p1, $encoding) . $pre
-                            . mb_substr($haystack, $p1, $l1, $encoding) . $post;
+                        $ret .= mb_substr($haystack, 0, $p1, $encoding).$pre
+                            . mb_substr($haystack, $p1, $l1, $encoding).$post;
                         $haystack = mb_substr($haystack, $p1 + $l1, mb_strlen($haystack), $encoding);
                         $p1 = mb_stripos($haystack, $needle, 0, $encoding);
                     }
@@ -86,12 +86,12 @@ 
                     $l1 = strlen($needle);
                     $ret = '';
                     while ($p1 !== false) {
-                        $ret .= substr($haystack, 0, $p1) . $pre . substr($haystack, $p1, $l1) . $post;
+                        $ret .= substr($haystack, 0, $p1).$pre.substr($haystack, $p1, $l1).$post;
                         $haystack = substr($haystack, $p1 + $l1);
                         $p1 = stripos($haystack, $needle);
                     }
                 }
-                $ret .= $haystack . $capture[2];
+                $ret .= $haystack.$capture[2];
 
                 return $ret;
             },

htdocs/class/libraries/vendor/firebase/php-jwt/src/JWT.php

Spacing +8 added lines, -8 removed lines

@@ -116,7 +116,7 @@ 
         // token can actually be used. If it's not yet that time, abort.
         if (isset($payload->nbf) && $payload->nbf > ($timestamp + static::$leeway)) {
             throw new BeforeValidException(
-                'Cannot handle token prior to ' . date(DateTime::ISO8601, $payload->nbf)
+                'Cannot handle token prior to '.date(DateTime::ISO8601, $payload->nbf)
             );
         }
 
@@ -125,7 +125,7 @@ 
         // correctly used the nbf claim).
         if (isset($payload->iat) && $payload->iat > ($timestamp + static::$leeway)) {
             throw new BeforeValidException(
-                'Cannot handle token prior to ' . date(DateTime::ISO8601, $payload->iat)
+                'Cannot handle token prior to '.date(DateTime::ISO8601, $payload->iat)
             );
         }
 
@@ -159,7 +159,7 @@ 
         if ($keyId !== null) {
             $header['kid'] = $keyId;
         }
-        if ( isset($head) && is_array($head) ) {
+        if (isset($head) && is_array($head)) {
             $header = array_merge($head, $header);
         }
         $segments = array();
@@ -191,7 +191,7 @@ 
             throw new DomainException('Algorithm not supported');
         }
         list($function, $algorithm) = static::$supported_algs[$alg];
-        switch($function) {
+        switch ($function) {
             case 'hash_hmac':
                 return hash_hmac($algorithm, $msg, $key, true);
             case 'openssl':
@@ -225,7 +225,7 @@ 
         }
 
         list($function, $algorithm) = static::$supported_algs[$alg];
-        switch($function) {
+        switch ($function) {
             case 'openssl':
                 $success = openssl_verify($msg, $signature, $key, $algorithm);
                 if ($success === 1) {
@@ -235,7 +235,7 @@ 
                 }
                 // returns 1 on success, 0 on failure, -1 on error.
                 throw new DomainException(
-                    'OpenSSL error: ' . openssl_error_string()
+                    'OpenSSL error: '.openssl_error_string()
                 );
             case 'hash_hmac':
             default:
@@ -277,7 +277,7 @@ 
              * manually detect large ints in the JSON string and quote them (thus converting
              *them to strings) before decoding, hence the preg_replace() call.
              */
-            $max_int_length = strlen((string) PHP_INT_MAX) - 1;
+            $max_int_length = strlen((string)PHP_INT_MAX) - 1;
             $json_without_bigints = preg_replace('/:\s*(-?\d{'.$max_int_length.',})/', ': "$1"', $input);
             $obj = json_decode($json_without_bigints);
         }
@@ -358,7 +358,7 @@ 
         throw new DomainException(
             isset($messages[$errno])
             ? $messages[$errno]
-            : 'Unknown JSON error: ' . $errno
+            : 'Unknown JSON error: '.$errno
         );
     }
 

htdocs/class/libraries/vendor/autoload.php

Spacing +1 added lines, -1 removed lines

@@ -2,6 +2,6 @@
 
 // autoload.php @generated by Composer
 
-require_once __DIR__ . '/composer/autoload_real.php';
+require_once __DIR__.'/composer/autoload_real.php';
 
 return ComposerAutoloaderInitfb0e5c3e4af98ed910184391855ba473::getLoader();

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/PaletteImage.php

Indentation +101 added lines, -102 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-	/**
+    /**
 ##DOC-SIGNATURE##
 
     This file is part of WideImage.
@@ -17,9 +17,8 @@ 
     You should have received a copy of the GNU Lesser General Public License
     along with WideImage; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-    
-    * @package WideImage
-  **/
+     * @package WideImage
+     **/
 
 namespace WideImage;
 
@@ -31,120 +30,120 @@ 
  */
 class PaletteImage extends Image
 {
-	/**
-	 * Create a palette image
-	 *
-	 * @param int $width
-	 * @param int $height
-	 * @return \WideImage\PaletteImage
-	 */
-	public static function create($width, $height)
-	{
-		if ($width * $height <= 0 || $width < 0) {
-			throw new InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
-		}
+    /**
+     * Create a palette image
+     *
+     * @param int $width
+     * @param int $height
+     * @return \WideImage\PaletteImage
+     */
+    public static function create($width, $height)
+    {
+        if ($width * $height <= 0 || $width < 0) {
+            throw new InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
+        }
 		
-		return new PaletteImage(imagecreate($width, $height));
-	}
+        return new PaletteImage(imagecreate($width, $height));
+    }
 	
-	public function doCreate($width, $height)
-	{
-		return static::create($width, $height);
-	}
+    public function doCreate($width, $height)
+    {
+        return static::create($width, $height);
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#isTrueColor()
-	 */
-	public function isTrueColor()
-	{
-		return false;
-	}
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#isTrueColor()
+     */
+    public function isTrueColor()
+    {
+        return false;
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#asPalette($nColors, $dither, $matchPalette)
-	 */
-	public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
-	{
-		return $this->copy();
-	}
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#asPalette($nColors, $dither, $matchPalette)
+     */
+    public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
+    {
+        return $this->copy();
+    }
 	
-	/**
-	 * Returns a copy of the image
-	 * 
-	 * @param $trueColor True if the new image should be truecolor
-	 * @return \WideImage\Image
-	 */
-	protected function copyAsNew($trueColor = false)
-	{
-		$width = $this->getWidth();
-		$height = $this->getHeight();
+    /**
+     * Returns a copy of the image
+     * 
+     * @param $trueColor True if the new image should be truecolor
+     * @return \WideImage\Image
+     */
+    protected function copyAsNew($trueColor = false)
+    {
+        $width = $this->getWidth();
+        $height = $this->getHeight();
 		
-		if ($trueColor) {
-			$new = TrueColorImage::create($width, $height);
-		} else {
-			$new = PaletteImage::create($width, $height);
-		}
+        if ($trueColor) {
+            $new = TrueColorImage::create($width, $height);
+        } else {
+            $new = PaletteImage::create($width, $height);
+        }
 		
-		// copy transparency of source to target
-		if ($this->isTransparent()) {
-			$rgb = $this->getTransparentColorRGB();
+        // copy transparency of source to target
+        if ($this->isTransparent()) {
+            $rgb = $this->getTransparentColorRGB();
 			
-			if (is_array($rgb)) {
-				$tci = $new->allocateColor($rgb['red'], $rgb['green'], $rgb['blue']);
-				$new->fill(0, 0, $tci);
-				$new->setTransparentColor($tci);
-			}
-		}
+            if (is_array($rgb)) {
+                $tci = $new->allocateColor($rgb['red'], $rgb['green'], $rgb['blue']);
+                $new->fill(0, 0, $tci);
+                $new->setTransparentColor($tci);
+            }
+        }
 		
-		imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height);
+        imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height);
 		
-		return $new;
-	}
+        return $new;
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#asTrueColor()
-	 */
-	public function asTrueColor()
-	{
-		$width  = $this->getWidth();
-		$height = $this->getHeight();
-		$new    = WideImage::createTrueColorImage($width, $height);
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#asTrueColor()
+     */
+    public function asTrueColor()
+    {
+        $width  = $this->getWidth();
+        $height = $this->getHeight();
+        $new    = WideImage::createTrueColorImage($width, $height);
 		
-		if ($this->isTransparent()) {
-			$new->copyTransparencyFrom($this);
-		}
+        if ($this->isTransparent()) {
+            $new->copyTransparencyFrom($this);
+        }
 		
-		if (!imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height)) {
-			throw new GDFunctionResultException("imagecopy() returned false");
-		}
+        if (!imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height)) {
+            throw new GDFunctionResultException("imagecopy() returned false");
+        }
 		
-		return $new;
-	}
+        return $new;
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#getChannels()
-	 */
-	public function getChannels()
-	{
-		$args = func_get_args();
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#getChannels()
+     */
+    public function getChannels()
+    {
+        $args = func_get_args();
 		
-		if (count($args) == 1 && is_array($args[0])) {
-			$args = $args[0];
-		}
+        if (count($args) == 1 && is_array($args[0])) {
+            $args = $args[0];
+        }
 		
-		return OperationFactory::get('CopyChannelsPalette')->execute($this, $args);
-	}
+        return OperationFactory::get('CopyChannelsPalette')->execute($this, $args);
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#copyNoAlpha()
-	 */
-	public function copyNoAlpha()
-	{
-		return WideImage::loadFromString($this->asString('png'));
-	}
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#copyNoAlpha()
+     */
+    public function copyNoAlpha()
+    {
+        return WideImage::loadFromString($this->asString('png'));
+    }
 }

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/Image.php

Indentation +928 added lines, -929 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-	/**
+    /**
 ##DOC-SIGNATURE##
 
     This file is part of WideImage.
@@ -17,9 +17,8 @@ 
     You should have received a copy of the GNU Lesser General Public License
     along with WideImage; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-	* @package WideImage
-  **/
+     * @package WideImage
+     **/
 
 namespace WideImage;
 
@@ -33,947 +32,947 @@ 
  */
 abstract class Image
 {
-	/**
-	 * Holds the image resource
-	 * @var resource
-	 */
-	protected $handle = null;
-	
-	/**
-	 * Flag that determines if WideImage should call imagedestroy() upon object destruction
-	 * @var bool
-	 */
-	protected $handleReleased = false;
-	
-	/**
-	 * Canvas object
-	 * @var \WideImage\Canvas
-	 */
-	protected $canvas = null;
-	
-	/**
-	 * @var string
-	 */
-	protected $sdata = null;
-	
-	/**
-	 * The base class constructor
-	 *
-	 * @param resource $handle Image handle (GD2 resource)
-	 */
-	public function __construct($handle)
-	{
-		WideImage::assertValidImageHandle($handle);
-		$this->handle = $handle;
-	}
-	
-	/**
-	 * Cleanup
-	 * 
-	 * Destroys the handle via \WideImage\Image::destroy() when called by the GC.
-	 */
-	public function __destruct()
-	{
-		$this->destroy();
-	}
-	
-	/**
-	 * This method destroy the image handle, and releases the image resource.
-	 * 
-	 * After this is called, the object doesn't hold a valid image any more.
-	 * No operation should be called after that.
-	 */
-	public function destroy()
-	{
-		if ($this->isValid() && !$this->handleReleased) {
-			imagedestroy($this->handle);
-		}
+    /**
+     * Holds the image resource
+     * @var resource
+     */
+    protected $handle = null;
+	
+    /**
+     * Flag that determines if WideImage should call imagedestroy() upon object destruction
+     * @var bool
+     */
+    protected $handleReleased = false;
+	
+    /**
+     * Canvas object
+     * @var \WideImage\Canvas
+     */
+    protected $canvas = null;
+	
+    /**
+     * @var string
+     */
+    protected $sdata = null;
+	
+    /**
+     * The base class constructor
+     *
+     * @param resource $handle Image handle (GD2 resource)
+     */
+    public function __construct($handle)
+    {
+        WideImage::assertValidImageHandle($handle);
+        $this->handle = $handle;
+    }
+	
+    /**
+     * Cleanup
+     * 
+     * Destroys the handle via \WideImage\Image::destroy() when called by the GC.
+     */
+    public function __destruct()
+    {
+        $this->destroy();
+    }
+	
+    /**
+     * This method destroy the image handle, and releases the image resource.
+     * 
+     * After this is called, the object doesn't hold a valid image any more.
+     * No operation should be called after that.
+     */
+    public function destroy()
+    {
+        if ($this->isValid() && !$this->handleReleased) {
+            imagedestroy($this->handle);
+        }
 		
-		$this->handle = null;
-	}
-	
-	/**
-	 * Returns the GD image resource
-	 * 
-	 * @return resource GD image resource
-	 */
-	public function getHandle()
-	{
-		return $this->handle;
-	}
-	
-	/**
-	 * @return bool True, if the image object holds a valid GD image, false otherwise
-	 */
-	public function isValid()
-	{
-		return WideImage::isValidImageHandle($this->handle);
-	}
-	
-	/**
-	 * Releases the handle
-	 */
-	public function releaseHandle()
-	{
-		$this->handleReleased = true;
-	}
-	
-	/**
-	 * Saves an image to a file
-	 * 
-	 * The file type is recognized from the $uri. If you save to a GIF8, truecolor images
-	 * are automatically converted to palette.
-	 * 
-	 * This method supports additional parameters: quality (for jpeg images) and 
-	 * compression quality and filters (for png images). See http://www.php.net/imagejpeg and
-	 * http://www.php.net/imagepng for details.
-	 * 
-	 * Examples:
-	 * <code>
-	 * // save to a GIF
-	 * $image->saveToFile('image.gif');
-	 * 
-	 * // save to a PNG with compression=7 and no filters
-	 * $image->saveToFile('image.png', 7, PNG_NO_FILTER);
-	 * 
-	 * // save to a JPEG with quality=80
-	 * $image->saveToFile('image.jpg', 80);
-	 * 
-	 * // save to a JPEG with default quality=100
-	 * $image->saveToFile('image.jpg');
-	 * </code>
-	 * 
-	 * @param string $uri File location
-	 */
-	public function saveToFile($uri)
-	{
-		$mapper = MapperFactory::selectMapper($uri, null);
-		$args = func_get_args();
-		array_unshift($args, $this->getHandle());
-		$res = call_user_func_array(array($mapper, 'save'), $args);
+        $this->handle = null;
+    }
+	
+    /**
+     * Returns the GD image resource
+     * 
+     * @return resource GD image resource
+     */
+    public function getHandle()
+    {
+        return $this->handle;
+    }
+	
+    /**
+     * @return bool True, if the image object holds a valid GD image, false otherwise
+     */
+    public function isValid()
+    {
+        return WideImage::isValidImageHandle($this->handle);
+    }
+	
+    /**
+     * Releases the handle
+     */
+    public function releaseHandle()
+    {
+        $this->handleReleased = true;
+    }
+	
+    /**
+     * Saves an image to a file
+     * 
+     * The file type is recognized from the $uri. If you save to a GIF8, truecolor images
+     * are automatically converted to palette.
+     * 
+     * This method supports additional parameters: quality (for jpeg images) and 
+     * compression quality and filters (for png images). See http://www.php.net/imagejpeg and
+     * http://www.php.net/imagepng for details.
+     * 
+     * Examples:
+     * <code>
+     * // save to a GIF
+     * $image->saveToFile('image.gif');
+     * 
+     * // save to a PNG with compression=7 and no filters
+     * $image->saveToFile('image.png', 7, PNG_NO_FILTER);
+     * 
+     * // save to a JPEG with quality=80
+     * $image->saveToFile('image.jpg', 80);
+     * 
+     * // save to a JPEG with default quality=100
+     * $image->saveToFile('image.jpg');
+     * </code>
+     * 
+     * @param string $uri File location
+     */
+    public function saveToFile($uri)
+    {
+        $mapper = MapperFactory::selectMapper($uri, null);
+        $args = func_get_args();
+        array_unshift($args, $this->getHandle());
+        $res = call_user_func_array(array($mapper, 'save'), $args);
 		
-		if (!$res) {
-			throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while saving to $uri");
-		}
-	}
-	
-	/**
-	 * Returns binary string with image data in format specified by $format
-	 * 
-	 * Additional parameters may be passed to the function. See \WideImage\Image::saveToFile() for more details.
-	 * 
-	 * @param string $format The format of the image
-	 * @return string The binary image data in specified format
-	 */
-	public function asString($format)
-	{
-		ob_start();
-		$args = func_get_args();
-		$args[0] = null;
-		array_unshift($args, $this->getHandle());
+        if (!$res) {
+            throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while saving to $uri");
+        }
+    }
+	
+    /**
+     * Returns binary string with image data in format specified by $format
+     * 
+     * Additional parameters may be passed to the function. See \WideImage\Image::saveToFile() for more details.
+     * 
+     * @param string $format The format of the image
+     * @return string The binary image data in specified format
+     */
+    public function asString($format)
+    {
+        ob_start();
+        $args = func_get_args();
+        $args[0] = null;
+        array_unshift($args, $this->getHandle());
 		
-		$mapper = MapperFactory::selectMapper(null, $format);
-		$res    = call_user_func_array(array($mapper, 'save'), $args);
+        $mapper = MapperFactory::selectMapper(null, $format);
+        $res    = call_user_func_array(array($mapper, 'save'), $args);
 		
-		if (!$res) {
-			throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while writing the image data");
-		}
+        if (!$res) {
+            throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while writing the image data");
+        }
 		
-		return ob_get_clean();
-	}
-	
-	/**
-	 * Output a header to browser.
-	 * 
-	 * @param $name Name of the header
-	 * @param $data Data
-	 */
-	protected function writeHeader($name, $data)
-	{
-		header($name . ": " . $data);
-	}
-	
-	/**
-	 * Outputs the image to browser
-	 * 
-	 * Sets headers Content-length and Content-type, and echoes the image in the specified format.
-	 * All other headers (such as Content-disposition) must be added manually. 
-	 * 
-	 * Example:
-	 * <code>
-	 * WideImage::load('image1.png')->resize(100, 100)->output('gif');
-	 * </code>
-	 * 
-	 * @param string $format Image format
-	 */
-	public function output($format)
-	{
-		$args = func_get_args();
-		$data = call_user_func_array(array($this, 'asString'), $args);
+        return ob_get_clean();
+    }
+	
+    /**
+     * Output a header to browser.
+     * 
+     * @param $name Name of the header
+     * @param $data Data
+     */
+    protected function writeHeader($name, $data)
+    {
+        header($name . ": " . $data);
+    }
+	
+    /**
+     * Outputs the image to browser
+     * 
+     * Sets headers Content-length and Content-type, and echoes the image in the specified format.
+     * All other headers (such as Content-disposition) must be added manually. 
+     * 
+     * Example:
+     * <code>
+     * WideImage::load('image1.png')->resize(100, 100)->output('gif');
+     * </code>
+     * 
+     * @param string $format Image format
+     */
+    public function output($format)
+    {
+        $args = func_get_args();
+        $data = call_user_func_array(array($this, 'asString'), $args);
 		
-		$this->writeHeader('Content-length', strlen($data));
-		$this->writeHeader('Content-type', MapperFactory::mimeType($format));
-		echo $data;
-	}
-	
-	/**
-	 * @return int Image width
-	 */
-	public function getWidth()
-	{
-		return imagesx($this->handle);
-	}
-	
-	/**
-	 * @return int Image height
-	 */
-	public function getHeight()
-	{
-		return imagesy($this->handle);
-	}
-	
-	/**
-	 * Allocate a color by RGB values.
-	 * 
-	 * @param mixed $R Red-component value or an RGB array (with red, green, blue keys)
-	 * @param int $G If $R is int, this is the green component
-	 * @param int $B If $R is int, this is the blue component
-	 * @return int Image color index
-	 */
-	public function allocateColor($R, $G = null, $B = null)
-	{
-		if (is_array($R)) {
-			return imageColorAllocate($this->handle, $R['red'], $R['green'], $R['blue']);
-		}
+        $this->writeHeader('Content-length', strlen($data));
+        $this->writeHeader('Content-type', MapperFactory::mimeType($format));
+        echo $data;
+    }
+	
+    /**
+     * @return int Image width
+     */
+    public function getWidth()
+    {
+        return imagesx($this->handle);
+    }
+	
+    /**
+     * @return int Image height
+     */
+    public function getHeight()
+    {
+        return imagesy($this->handle);
+    }
+	
+    /**
+     * Allocate a color by RGB values.
+     * 
+     * @param mixed $R Red-component value or an RGB array (with red, green, blue keys)
+     * @param int $G If $R is int, this is the green component
+     * @param int $B If $R is int, this is the blue component
+     * @return int Image color index
+     */
+    public function allocateColor($R, $G = null, $B = null)
+    {
+        if (is_array($R)) {
+            return imageColorAllocate($this->handle, $R['red'], $R['green'], $R['blue']);
+        }
 		
-		return imageColorAllocate($this->handle, $R, $G, $B);
-	}
-	
-	/**
-	 * @return bool True if the image is transparent, false otherwise
-	 */
-	public function isTransparent()
-	{
-		return $this->getTransparentColor() >= 0;
-	}
-	
-	/**
-	 * @return int Transparent color index
-	 */
-	public function getTransparentColor()
-	{
-		return imagecolortransparent($this->handle);
-	}
-	
-	/**
-	 * Sets the current transparent color index. Only makes sense for palette images (8-bit).
-	 * 
-	 * @param int $color Transparent color index
-	 */
-	public function setTransparentColor($color)
-	{
-		return imagecolortransparent($this->handle, $color);
-	}
-	
-	/**
-	 * Returns a RGB array of the transparent color or null if none.
-	 * 
-	 * @return mixed Transparent color RGBA array
-	 */
-	public function getTransparentColorRGB()
-	{
-		$total = imagecolorstotal($this->handle);
-		$tc    = $this->getTransparentColor();
+        return imageColorAllocate($this->handle, $R, $G, $B);
+    }
+	
+    /**
+     * @return bool True if the image is transparent, false otherwise
+     */
+    public function isTransparent()
+    {
+        return $this->getTransparentColor() >= 0;
+    }
+	
+    /**
+     * @return int Transparent color index
+     */
+    public function getTransparentColor()
+    {
+        return imagecolortransparent($this->handle);
+    }
+	
+    /**
+     * Sets the current transparent color index. Only makes sense for palette images (8-bit).
+     * 
+     * @param int $color Transparent color index
+     */
+    public function setTransparentColor($color)
+    {
+        return imagecolortransparent($this->handle, $color);
+    }
+	
+    /**
+     * Returns a RGB array of the transparent color or null if none.
+     * 
+     * @return mixed Transparent color RGBA array
+     */
+    public function getTransparentColorRGB()
+    {
+        $total = imagecolorstotal($this->handle);
+        $tc    = $this->getTransparentColor();
 		
-		if ($tc >= $total && $total > 0) {
-			return null;
-		}
+        if ($tc >= $total && $total > 0) {
+            return null;
+        }
 		
-		return $this->getColorRGB($tc);
-	}
-	
-	/**
-	 * Returns a RGBA array for pixel at $x, $y
-	 * 
-	 * @param int $x
-	 * @param int $y
-	 * @return array RGB array 
-	 */
-	public function getRGBAt($x, $y)
-	{
-		return $this->getColorRGB($this->getColorAt($x, $y));
-	}
-	
-	/**
-	 * Writes a pixel at the designated coordinates
-	 * 
-	 * Takes an associative array of colours and uses getExactColor() to
-	 * retrieve the exact index color to write to the image with.
-	 *
-	 * @param int $x
-	 * @param int $y
-	 * @param array $color
-	 */
-	public function setRGBAt($x, $y, $color)
-	{
-		$this->setColorAt($x, $y, $this->getExactColor($color));
-	}
-	
-	/**
-	 * Returns a color's RGB
-	 * 
-	 * @param int $colorIndex Color index
-	 * @return mixed RGBA array for a color with index $colorIndex
-	 */
-	public function getColorRGB($colorIndex)
-	{
-		return imageColorsForIndex($this->handle, $colorIndex);
-	}
-	
-	/**
-	 * Returns an index of the color at $x, $y
-	 * 
-	 * @param int $x
-	 * @param int $y
-	 * @return int Color index for a pixel at $x, $y
-	 */
-	public function getColorAt($x, $y)
-	{
-		return imagecolorat($this->handle, $x, $y);
-	}
-	
-	/**
-	 * Set the color index $color to a pixel at $x, $y
-	 * 
-	 * @param int $x
-	 * @param int $y
-	 * @param int $color Color index
-	 */
-	public function setColorAt($x, $y, $color)
-	{
-		return imagesetpixel($this->handle, $x, $y, $color);
-	}
-	
-	/**
-	 * Returns closest color index that matches the given RGB value. Uses
-	 * PHP's imagecolorclosest()
-	 * 
-	 * @param mixed $R Red or RGBA array
-	 * @param int $G Green component (or null if $R is an RGB array)
-	 * @param int $B Blue component (or null if $R is an RGB array)
-	 * @return int Color index
-	 */
-	public function getClosestColor($R, $G = null, $B = null)
-	{
-		if (is_array($R)) {
-			return imagecolorclosest($this->handle, $R['red'], $R['green'], $R['blue']);
-		}
+        return $this->getColorRGB($tc);
+    }
+	
+    /**
+     * Returns a RGBA array for pixel at $x, $y
+     * 
+     * @param int $x
+     * @param int $y
+     * @return array RGB array 
+     */
+    public function getRGBAt($x, $y)
+    {
+        return $this->getColorRGB($this->getColorAt($x, $y));
+    }
+	
+    /**
+     * Writes a pixel at the designated coordinates
+     * 
+     * Takes an associative array of colours and uses getExactColor() to
+     * retrieve the exact index color to write to the image with.
+     *
+     * @param int $x
+     * @param int $y
+     * @param array $color
+     */
+    public function setRGBAt($x, $y, $color)
+    {
+        $this->setColorAt($x, $y, $this->getExactColor($color));
+    }
+	
+    /**
+     * Returns a color's RGB
+     * 
+     * @param int $colorIndex Color index
+     * @return mixed RGBA array for a color with index $colorIndex
+     */
+    public function getColorRGB($colorIndex)
+    {
+        return imageColorsForIndex($this->handle, $colorIndex);
+    }
+	
+    /**
+     * Returns an index of the color at $x, $y
+     * 
+     * @param int $x
+     * @param int $y
+     * @return int Color index for a pixel at $x, $y
+     */
+    public function getColorAt($x, $y)
+    {
+        return imagecolorat($this->handle, $x, $y);
+    }
+	
+    /**
+     * Set the color index $color to a pixel at $x, $y
+     * 
+     * @param int $x
+     * @param int $y
+     * @param int $color Color index
+     */
+    public function setColorAt($x, $y, $color)
+    {
+        return imagesetpixel($this->handle, $x, $y, $color);
+    }
+	
+    /**
+     * Returns closest color index that matches the given RGB value. Uses
+     * PHP's imagecolorclosest()
+     * 
+     * @param mixed $R Red or RGBA array
+     * @param int $G Green component (or null if $R is an RGB array)
+     * @param int $B Blue component (or null if $R is an RGB array)
+     * @return int Color index
+     */
+    public function getClosestColor($R, $G = null, $B = null)
+    {
+        if (is_array($R)) {
+            return imagecolorclosest($this->handle, $R['red'], $R['green'], $R['blue']);
+        }
 		
-		return imagecolorclosest($this->handle, $R, $G, $B);
-	}
-	
-	/**
-	 * Returns the color index that exactly matches the given RGB value. Uses
-	 * PHP's imagecolorexact()
-	 * 
-	 * @param mixed $R Red or RGBA array
-	 * @param int $G Green component (or null if $R is an RGB array)
-	 * @param int $B Blue component (or null if $R is an RGB array)
-	 * @return int Color index
-	 */
-	public function getExactColor($R, $G = null, $B = null)
-	{
-		if (is_array($R)) {
-			return imagecolorexact($this->handle, $R['red'], $R['green'], $R['blue']);
-		}
+        return imagecolorclosest($this->handle, $R, $G, $B);
+    }
+	
+    /**
+     * Returns the color index that exactly matches the given RGB value. Uses
+     * PHP's imagecolorexact()
+     * 
+     * @param mixed $R Red or RGBA array
+     * @param int $G Green component (or null if $R is an RGB array)
+     * @param int $B Blue component (or null if $R is an RGB array)
+     * @return int Color index
+     */
+    public function getExactColor($R, $G = null, $B = null)
+    {
+        if (is_array($R)) {
+            return imagecolorexact($this->handle, $R['red'], $R['green'], $R['blue']);
+        }
 		
-		return imagecolorexact($this->handle, $R, $G, $B);
-	}
-	
-	/**
-	 * Copies transparency information from $sourceImage. Optionally fills
-	 * the image with the transparent color at (0, 0).
-	 * 
-	 * @param object $sourceImage
-	 * @param bool $fill True if you want to fill the image with transparent color
-	 */
-	public function copyTransparencyFrom($sourceImage, $fill = true)
-	{
-		if ($sourceImage->isTransparent()) {
-			$rgba = $sourceImage->getTransparentColorRGB();
+        return imagecolorexact($this->handle, $R, $G, $B);
+    }
+	
+    /**
+     * Copies transparency information from $sourceImage. Optionally fills
+     * the image with the transparent color at (0, 0).
+     * 
+     * @param object $sourceImage
+     * @param bool $fill True if you want to fill the image with transparent color
+     */
+    public function copyTransparencyFrom($sourceImage, $fill = true)
+    {
+        if ($sourceImage->isTransparent()) {
+            $rgba = $sourceImage->getTransparentColorRGB();
 			
-			if ($rgba === null) {
-				return;
-			}
+            if ($rgba === null) {
+                return;
+            }
 			
-			if ($this->isTrueColor()) {
-				$rgba['alpha'] = 127;
-				$color = $this->allocateColorAlpha($rgba);
-			} else {
-				$color = $this->allocateColor($rgba);
-			}
+            if ($this->isTrueColor()) {
+                $rgba['alpha'] = 127;
+                $color = $this->allocateColorAlpha($rgba);
+            } else {
+                $color = $this->allocateColor($rgba);
+            }
 			
-			$this->setTransparentColor($color);
+            $this->setTransparentColor($color);
 			
-			if ($fill) {
-				$this->fill(0, 0, $color);
-			}
-		}
-	}
-	
-	/**
-	 * Fill the image at ($x, $y) with color index $color
-	 * 
-	 * @param int $x
-	 * @param int $y
-	 * @param int $color
-	 */
-	public function fill($x, $y, $color)
-	{
-		return imagefill($this->handle, $x, $y, $color);
-	}
-	
-	/**
-	 * Used internally to create Operation objects
-	 *
-	 * @param string $name
-	 * @return object
-	 */
-	protected function getOperation($name)
-	{
-		return OperationFactory::get($name);
-	}
-	
-	/**
-	 * Returns the image's mask
-	 * 
-	 * Mask is a greyscale image where the shade defines the alpha channel (black = transparent, white = opaque).
-	 * 
-	 * For opaque images (JPEG), the result will be white. For images with single-color transparency (GIF, 8-bit PNG), 
-	 * the areas with the transparent color will be black. For images with alpha channel transparenct, 
-	 * the result will be alpha channel.
-	 * 
-	 * @return \WideImage\Image An image mask
-	 **/
-	public function getMask()
-	{
-		return $this->getOperation('GetMask')->execute($this);
-	}
-	
-	/**
-	 * Resize the image to given dimensions.
-	 * 
-	 * $width and $height are both smart coordinates. This means that you can pass any of these values in:
-	 *   - positive or negative integer (100, -20, ...)
-	 *   - positive or negative percent string (30%, -15%, ...)
-	 *   - complex coordinate (50% - 20, 15 + 30%, ...)
-	 *   - null: if one dimension is null, it's calculated proportionally from the other.
-	 * 
-	 * $fit parameter can be set to one of these three values:
-	 *   - 'inside': resize proportionally and fit the resulting image tightly in the $width x $height box
-	 *   - 'outside': resize proportionally and fit the resulting image tighly outside the box
-	 *   - 'fill': resize the image to fill the $width x $height box exactly
-	 *
-	 * $scale parameter can be:
-	 *   - 'down': only resize the image if it's larger than the $width x $height box
-	 *   - 'up': only resize the image if it's smaller than the $width x $height box
-	 *   - 'any': resize the image
-	 *
-	 * Example (resize to half-size):
-	 * <code>
-	 * $smaller = $image->resize('50%');
-	 * 
-	 * $smaller = $image->resize('100', '100', 'inside', 'down');
-	 * is the same as
-	 * $smaller = $image->resizeDown(100, 100, 'inside');
-	 * </code>
-	 * 
-	 * @param mixed $width The new width (smart coordinate), or null.
-	 * @param mixed $height The new height (smart coordinate), or null.
-	 * @param string $fit 'inside', 'outside', 'fill'
-	 * @param string $scale 'down', 'up', 'any'
-	 * @return \WideImage\Image The resized image
-	 */
-	public function resize($width = null, $height = null, $fit = 'inside', $scale = 'any')
-	{
-		return $this->getOperation('Resize')->execute($this, $width, $height, $fit, $scale);
-	}
-	
-	/**
-	 * Same as \WideImage\Image::resize(), but the image is only applied if it is larger then the given dimensions.
-	 * Otherwise, the resulting image retains the source's dimensions.
-	 * 
-	 * @param int $width New width, smart coordinate
-	 * @param int $height New height, smart coordinate
-	 * @param string $fit 'inside', 'outside', 'fill'
-	 * @return \WideImage\Image resized image
-	 */
-	public function resizeDown($width = null, $height = null, $fit = 'inside')
-	{
-		return $this->resize($width, $height, $fit, 'down');
-	}
-	
-	/**
-	 * Same as \WideImage\Image::resize(), but the image is only applied if it is smaller then the given dimensions.
-	 * Otherwise, the resulting image retains the source's dimensions.
-	 * 
-	 * @param int $width New width, smart coordinate
-	 * @param int $height New height, smart coordinate
-	 * @param string $fit 'inside', 'outside', 'fill'
-	 * @return \WideImage\Image resized image
-	 */
-	public function resizeUp($width = null, $height = null, $fit = 'inside')
-	{
-		return $this->resize($width, $height, $fit, 'up');
-	}
-	
-	/**
-	 * Rotate the image for angle $angle clockwise.
-	 * 
-	 * Preserves transparency. Has issues when saving to a BMP.
-	 * 
-	 * @param int $angle Angle in degrees, clock-wise
-	 * @param int $bgColor color of the new background
-	 * @param bool $ignoreTransparent
-	 * @return \WideImage\Image The rotated image
-	 */
-	public function rotate($angle, $bgColor = null, $ignoreTransparent = true)
-	{
-		return $this->getOperation('Rotate')->execute($this, $angle, $bgColor, $ignoreTransparent);
-	}
-	
-	/**
-	 * This method lays the overlay (watermark) on the image.
-	 * 
-	 * Hint: if the overlay is a truecolor image with alpha channel, you should leave $pct at 100.
-	 * 
-	 * This operation supports alignment notation in coordinates:
-	 * <code>
-	 * $watermark = WideImage::load('logo.gif');
-	 * $base = WideImage::load('picture.jpg');
-	 * $result = $base->merge($watermark, "right - 10", "bottom - 10", 50);
-	 * // applies a logo aligned to bottom-right corner with a 10 pixel margin
-	 * </code>
-	 * 
-	 * @param \WideImage\Image $overlay The overlay image
-	 * @param mixed $left Left position of the overlay, smart coordinate
-	 * @param mixed $top Top position of the overlay, smart coordinate
-	 * @param int $pct The opacity of the overlay
-	 * @return \WideImage\Image The merged image
-	 */
-	public function merge($overlay, $left = 0, $top = 0, $pct = 100)
-	{
-		return $this->getOperation('Merge')->execute($this, $overlay, $left, $top, $pct);
-	}
-	
-	/**
-	 * Resizes the canvas of the image, but doesn't scale the content of the image
-	 * 
-	 * This operation creates an empty canvas with dimensions $width x $height, filled with 
-	 * background color $bg_color and draws the original image onto it at position [$pos_x, $pos_y].
-	 * 
-	 * Arguments $width, $height, $pos_x and $pos_y are all smart coordinates. $width and $height are 
-	 * relative to the current image size, $pos_x and $pos_y are relative to the newly calculated
-	 * canvas size. This can be confusing, but it makes sense. See the example below.
-	 * 
-	 * The example below loads a 100x150 image and then resizes its canvas to 200% x 100%+20 
-	 * (which evaluates to 200x170). The image is placed at position [10, center+20], which evaluates to [10, 30].
-	 * <code>
-	 * $image = WideImage::load('someimage.jpg'); // 100x150
-	 * $white = $image->allocateColor(255, 255, 255);
-	 * $image->resizeCanvas('200%', '100% + 20', 10, 'center+20', $white);
-	 * </code>
-	 * 
-	 * The parameter $merge defines whether the original image should be merged onto the new canvas.
-	 * This means it blends transparent color and alpha colors into the background color. If set to false,
-	 * the original image is just copied over, preserving the transparency/alpha information.
-	 * 
-	 * You can set the $scale parameter to limit when to resize the canvas. For example, if you want 
-	 * to resize the canvas only if the image is smaller than the new size, but leave the image intact 
-	 * if it's larger, set it to 'up'. Likewise, if you want to shrink the canvas, but don't want to 
-	 * change images that are already smaller, set it to 'down'. 
-	 * 
-	 * @param mixed $width Width of the new canvas (smart coordinate, relative to current image width)
-	 * @param mixed $height Height of the new canvas (smart coordinate, relative to current image height)
-	 * @param mixed $pos_x x-position of the image (smart coordinate, relative to the new width)
-	 * @param mixed $pos_y y-position of the image (smart coordinate, relative to the new height)
-	 * @param int $bg_color Background color (created with allocateColor or allocateColorAlpha), defaults to null (tries to use a transparent color)
-	 * @param string $scale Possible values: 'up' (enlarge only), 'down' (downsize only), 'any' (resize precisely to $width x $height). Defaults to 'any'.
-	 * @param bool $merge Merge the original image (flatten alpha channel and transparency) or copy it over (preserve). Defaults to false.
-	 * @return \WideImage\Image The resulting image with resized canvas
-	 */
-	public function resizeCanvas($width, $height, $pos_x, $pos_y, $bg_color = null, $scale = 'any', $merge = false)
-	{
-		return $this->getOperation('ResizeCanvas')->execute($this, $width, $height, $pos_x, $pos_y, $bg_color, $scale, $merge);
-	}
-	
-	/**
-	 * Returns an image with round corners
-	 * 
-	 * You can either set the corners' color or set them transparent.
-	 * 
-	 * Note on $smoothness: 1 means jagged edges, 2 is much better, more than 4 doesn't noticeably improve the quality.
-	 * Rendering becomes increasingly slower if you increase smoothness.
-	 * 
-	 * Example:
-	 * <code>
-	 * $nice = $ugly->roundCorners(20, $ugly->allocateColor(255, 0, 0), 2);
-	 * </code>
-	 * 
-	 * Use $corners parameter to specify which corners to draw rounded. Possible values are
-	 * WideImage::SIDE_TOP_LEFT, WideImage::SIDE_TOP,
-	 * WideImage::SIDE_TOP_RIGHT, WideImage::SIDE_RIGHT,
-	 * WideImage::SIDE_BOTTOM_RIGHT, WideImage::SIDE_BOTTOM, 
-	 * WideImage::SIDE_BOTTOM_LEFT, WideImage::SIDE_LEFT, and WideImage::SIDE_ALL.
-	 * You can specify any combination of corners with a + operation, see example below.
-	 * 
-	 * Example:
-	 * <code>
-	 * $white = $image->allocateColor(255, 255, 255);
-	 * $diagonal_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_TOP_LEFT + WideImage::SIDE_BOTTOM_RIGHT);
-	 * $right_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_RIGHT);
-	 * </code>
-	 * 
-	 * @param int $radius Radius of the corners
-	 * @param int $color The color of corners. If null, corners are rendered transparent (slower than using a solid color).
-	 * @param int $smoothness Specify the level of smoothness. Suggested values from 1 to 4.
-	 * @param int $corners Specify which corners to draw (defaults to WideImage::SIDE_ALL = all corners)
-	 * @return \WideImage\Image The resulting image with round corners
-	 */
-	public function roundCorners($radius, $color = null, $smoothness = 2, $corners = 255)
-	{
-		return $this->getOperation('RoundCorners')->execute($this, $radius, $color, $smoothness, $corners);
-	}
-	
-	/**
-	 * Returns an image with applied mask
-	 * 
-	 * A mask is a grayscale image, where the shade determines the alpha channel. Black is fully transparent
-	 * and white is fully opaque.
-	 * 
-	 * @param \WideImage\Image $mask The mask image, greyscale
-	 * @param mixed $left Left coordinate, smart coordinate
-	 * @param mixed $top Top coordinate, smart coordinate
-	 * @return \WideImage\Image The resulting image
-	 **/
-	public function applyMask($mask, $left = 0, $top = 0)
-	{
-		return $this->getOperation('ApplyMask')->execute($this, $mask, $left, $top);
-	}
-	
-	/**
-	 * Applies a filter
-	 *
-	 * @param int $filter One of the IMG_FILTER_* constants
-	 * @param int $arg1
-	 * @param int $arg2
-	 * @param int $arg3
-	 * @param int $arg4
-	 * @return \WideImage\Image
-	 */
-	public function applyFilter($filter, $arg1 = null, $arg2 = null, $arg3 = null, $arg4 = null)
-	{
-		return $this->getOperation('ApplyFilter')->execute($this, $filter, $arg1, $arg2, $arg3, $arg4);
-	}
-	
-	/**
-	 * Applies convolution matrix with imageconvolution()
-	 *
-	 * @param array $matrix
-	 * @param float $div
-	 * @param float $offset
-	 * @return \WideImage\Image
-	 */
-	public function applyConvolution($matrix, $div, $offset)
-	{
-		return $this->getOperation('ApplyConvolution')->execute($this, $matrix, $div, $offset);
-	}
-	
-	/**
-	 * Returns a cropped rectangular portion of the image
-	 * 
-	 * If the rectangle specifies area that is out of bounds, it's limited to the current image bounds.
-	 * 
-	 * Examples:
-	 * <code>
-	 * $cropped = $img->crop(10, 10, 150, 200); // crops a 150x200 rect at (10, 10)
-	 * $cropped = $img->crop(-100, -50, 100, 50); // crops a 100x50 rect at the right-bottom of the image
-	 * $cropped = $img->crop('25%', '25%', '50%', '50%'); // crops a 50%x50% rect from the center of the image
-	 * </code>
-	 * 
-	 * This operation supports alignment notation in left/top coordinates.
-	 * Example:
-	 * <code>
-	 * $cropped = $img->crop("right", "bottom", 100, 200); // crops a 100x200 rect from right bottom
-	 * $cropped = $img->crop("center", "middle", 50, 30); // crops a 50x30 from the center of the image
-	 * </code>
-	 * 
-	 * @param mixed $left Left-coordinate of the crop rect, smart coordinate
-	 * @param mixed $top Top-coordinate of the crop rect, smart coordinate
-	 * @param mixed $width Width of the crop rect, smart coordinate
-	 * @param mixed $height Height of the crop rect, smart coordinate
-	 * @return \WideImage\Image The cropped image
-	 **/
-	public function crop($left = 0, $top = 0, $width = '100%', $height = '100%')
-	{
-		return $this->getOperation('Crop')->execute($this, $left, $top, $width, $height);
-	}
-	
-	/**
-	 * Performs an auto-crop on the image
-	 *
-	 * The image is auto-cropped from each of four sides. All sides are 
-	 * scanned for pixels that differ from $base_color for more than 
-	 * $rgb_threshold in absolute RGB difference. If more than $pixel_cutoff 
-	 * differentiating pixels are found, that line is considered to be the crop line for the side.
-	 * If the line isn't different enough, the algorithm procedes to the next line 
-	 * towards the other edge of the image.
-	 * 
-	 * When the crop rectangle is found, it's enlarged by the $margin value on each of the four sides.
-	 *
-	 * @param int $margin Margin for the crop rectangle, can be negative.
-	 * @param int $rgb_threshold RGB difference which still counts as "same color".
-	 * @param int $pixel_cutoff How many pixels need to be different to mark a cut line.
-	 * @param int $base_color The base color index. If none specified (or null given), left-top pixel is used.
-	 * @return \WideImage\Image The cropped image
-	 */
-	public function autoCrop($margin = 0, $rgb_threshold = 0, $pixel_cutoff = 1, $base_color = null)
-	{
-		return $this->getOperation('AutoCrop')->execute($this, $margin, $rgb_threshold, $pixel_cutoff, $base_color);
-	}
-	
-	/**
-	 * Returns a negative of the image
-	 *
-	 * This operation differs from calling \WideImage\Image::applyFilter(IMG_FILTER_NEGATIVE), because it's 8-bit and transparency safe.
-	 * This means it will return an 8-bit image, if the source image is 8-bit. If that 8-bit image has a palette transparency,
-	 * the resulting image will keep transparency.
-	 *
-	 * @return \WideImage\Image negative of the image
-	 */
-	public function asNegative()
-	{
-		return $this->getOperation('AsNegative')->execute($this);
-	}
-	
-	/**
-	 * Returns a grayscale copy of the image
-	 * 
-	 * @return \WideImage\Image grayscale copy
-	 **/
-	public function asGrayscale()
-	{
-		return $this->getOperation('AsGrayscale')->execute($this);
-	}
-	
-	/**
-	 * Returns a mirrored copy of the image
-	 * 
-	 * @return \WideImage\Image Mirrored copy
-	 **/
-	public function mirror()
-	{
-		return $this->getOperation('Mirror')->execute($this);
-	}
-	
-	/**
-	 * Applies the unsharp filter
-	 * 
-	 * @param float $amount
-	 * @param float $radius
-	 * @param float $threshold
-	 * @return \WideImage\Image Unsharpened copy of the image
-	 **/
-	public function unsharp($amount, $radius, $threshold)
-	{
-		return $this->getOperation('Unsharp')->execute($this, $amount, $radius, $threshold);
-	}
-	
-	/**
-	 * Returns a flipped (mirrored over horizontal line) copy of the image
-	 * 
-	 * @return \WideImage\Image Flipped copy
-	 **/
-	public function flip()
-	{
-		return $this->getOperation('Flip')->execute($this);
-	}
-	
-	/**
-	 * Corrects gamma on the image
-	 * 
-	 * @param float $inputGamma
-	 * @param float $outputGamma
-	 * @return \WideImage\Image Image with corrected gamma
-	 **/
-	public function correctGamma($inputGamma, $outputGamma)
-	{
-		return $this->getOperation('CorrectGamma')->execute($this, $inputGamma, $outputGamma);
-	}
-	
-	/**
-	 * Adds noise to the image
-	 * 
-	 * @author Tomasz Kapusta
-	 * 
-	 * @param int $amount Number of noise pixels to add
-	 * @param string $type Type of noise 'salt&pepper', 'color' or 'mono'
-	 * @return \WideImage\Image Image with noise added
-	 **/
-	public function addNoise($amount, $type)
-	{
-		return $this->getOperation('AddNoise')->execute($this, $amount, $type);
-	}
-	
-	/**
-	 * Used internally to execute operations
-	 *
-	 * @param string $name
-	 * @param array $args
-	 * @return \WideImage\Image
-	 */
-	public function __call($name, $args)
-	{
-		$op = $this->getOperation($name);
-		array_unshift($args, $this);
-		return call_user_func_array(array($op, 'execute'), $args);
-	}
-	
-	/**
-	 * Returns an image in GIF or PNG format
-	 *
-	 * @return string
-	 */
-	public function __toString()
-	{
-		if ($this->isTransparent()) {
-			return $this->asString('gif');
-		}
+            if ($fill) {
+                $this->fill(0, 0, $color);
+            }
+        }
+    }
+	
+    /**
+     * Fill the image at ($x, $y) with color index $color
+     * 
+     * @param int $x
+     * @param int $y
+     * @param int $color
+     */
+    public function fill($x, $y, $color)
+    {
+        return imagefill($this->handle, $x, $y, $color);
+    }
+	
+    /**
+     * Used internally to create Operation objects
+     *
+     * @param string $name
+     * @return object
+     */
+    protected function getOperation($name)
+    {
+        return OperationFactory::get($name);
+    }
+	
+    /**
+     * Returns the image's mask
+     * 
+     * Mask is a greyscale image where the shade defines the alpha channel (black = transparent, white = opaque).
+     * 
+     * For opaque images (JPEG), the result will be white. For images with single-color transparency (GIF, 8-bit PNG), 
+     * the areas with the transparent color will be black. For images with alpha channel transparenct, 
+     * the result will be alpha channel.
+     * 
+     * @return \WideImage\Image An image mask
+     **/
+    public function getMask()
+    {
+        return $this->getOperation('GetMask')->execute($this);
+    }
+	
+    /**
+     * Resize the image to given dimensions.
+     * 
+     * $width and $height are both smart coordinates. This means that you can pass any of these values in:
+     *   - positive or negative integer (100, -20, ...)
+     *   - positive or negative percent string (30%, -15%, ...)
+     *   - complex coordinate (50% - 20, 15 + 30%, ...)
+     *   - null: if one dimension is null, it's calculated proportionally from the other.
+     * 
+     * $fit parameter can be set to one of these three values:
+     *   - 'inside': resize proportionally and fit the resulting image tightly in the $width x $height box
+     *   - 'outside': resize proportionally and fit the resulting image tighly outside the box
+     *   - 'fill': resize the image to fill the $width x $height box exactly
+     *
+     * $scale parameter can be:
+     *   - 'down': only resize the image if it's larger than the $width x $height box
+     *   - 'up': only resize the image if it's smaller than the $width x $height box
+     *   - 'any': resize the image
+     *
+     * Example (resize to half-size):
+     * <code>
+     * $smaller = $image->resize('50%');
+     * 
+     * $smaller = $image->resize('100', '100', 'inside', 'down');
+     * is the same as
+     * $smaller = $image->resizeDown(100, 100, 'inside');
+     * </code>
+     * 
+     * @param mixed $width The new width (smart coordinate), or null.
+     * @param mixed $height The new height (smart coordinate), or null.
+     * @param string $fit 'inside', 'outside', 'fill'
+     * @param string $scale 'down', 'up', 'any'
+     * @return \WideImage\Image The resized image
+     */
+    public function resize($width = null, $height = null, $fit = 'inside', $scale = 'any')
+    {
+        return $this->getOperation('Resize')->execute($this, $width, $height, $fit, $scale);
+    }
+	
+    /**
+     * Same as \WideImage\Image::resize(), but the image is only applied if it is larger then the given dimensions.
+     * Otherwise, the resulting image retains the source's dimensions.
+     * 
+     * @param int $width New width, smart coordinate
+     * @param int $height New height, smart coordinate
+     * @param string $fit 'inside', 'outside', 'fill'
+     * @return \WideImage\Image resized image
+     */
+    public function resizeDown($width = null, $height = null, $fit = 'inside')
+    {
+        return $this->resize($width, $height, $fit, 'down');
+    }
+	
+    /**
+     * Same as \WideImage\Image::resize(), but the image is only applied if it is smaller then the given dimensions.
+     * Otherwise, the resulting image retains the source's dimensions.
+     * 
+     * @param int $width New width, smart coordinate
+     * @param int $height New height, smart coordinate
+     * @param string $fit 'inside', 'outside', 'fill'
+     * @return \WideImage\Image resized image
+     */
+    public function resizeUp($width = null, $height = null, $fit = 'inside')
+    {
+        return $this->resize($width, $height, $fit, 'up');
+    }
+	
+    /**
+     * Rotate the image for angle $angle clockwise.
+     * 
+     * Preserves transparency. Has issues when saving to a BMP.
+     * 
+     * @param int $angle Angle in degrees, clock-wise
+     * @param int $bgColor color of the new background
+     * @param bool $ignoreTransparent
+     * @return \WideImage\Image The rotated image
+     */
+    public function rotate($angle, $bgColor = null, $ignoreTransparent = true)
+    {
+        return $this->getOperation('Rotate')->execute($this, $angle, $bgColor, $ignoreTransparent);
+    }
+	
+    /**
+     * This method lays the overlay (watermark) on the image.
+     * 
+     * Hint: if the overlay is a truecolor image with alpha channel, you should leave $pct at 100.
+     * 
+     * This operation supports alignment notation in coordinates:
+     * <code>
+     * $watermark = WideImage::load('logo.gif');
+     * $base = WideImage::load('picture.jpg');
+     * $result = $base->merge($watermark, "right - 10", "bottom - 10", 50);
+     * // applies a logo aligned to bottom-right corner with a 10 pixel margin
+     * </code>
+     * 
+     * @param \WideImage\Image $overlay The overlay image
+     * @param mixed $left Left position of the overlay, smart coordinate
+     * @param mixed $top Top position of the overlay, smart coordinate
+     * @param int $pct The opacity of the overlay
+     * @return \WideImage\Image The merged image
+     */
+    public function merge($overlay, $left = 0, $top = 0, $pct = 100)
+    {
+        return $this->getOperation('Merge')->execute($this, $overlay, $left, $top, $pct);
+    }
+	
+    /**
+     * Resizes the canvas of the image, but doesn't scale the content of the image
+     * 
+     * This operation creates an empty canvas with dimensions $width x $height, filled with 
+     * background color $bg_color and draws the original image onto it at position [$pos_x, $pos_y].
+     * 
+     * Arguments $width, $height, $pos_x and $pos_y are all smart coordinates. $width and $height are 
+     * relative to the current image size, $pos_x and $pos_y are relative to the newly calculated
+     * canvas size. This can be confusing, but it makes sense. See the example below.
+     * 
+     * The example below loads a 100x150 image and then resizes its canvas to 200% x 100%+20 
+     * (which evaluates to 200x170). The image is placed at position [10, center+20], which evaluates to [10, 30].
+     * <code>
+     * $image = WideImage::load('someimage.jpg'); // 100x150
+     * $white = $image->allocateColor(255, 255, 255);
+     * $image->resizeCanvas('200%', '100% + 20', 10, 'center+20', $white);
+     * </code>
+     * 
+     * The parameter $merge defines whether the original image should be merged onto the new canvas.
+     * This means it blends transparent color and alpha colors into the background color. If set to false,
+     * the original image is just copied over, preserving the transparency/alpha information.
+     * 
+     * You can set the $scale parameter to limit when to resize the canvas. For example, if you want 
+     * to resize the canvas only if the image is smaller than the new size, but leave the image intact 
+     * if it's larger, set it to 'up'. Likewise, if you want to shrink the canvas, but don't want to 
+     * change images that are already smaller, set it to 'down'. 
+     * 
+     * @param mixed $width Width of the new canvas (smart coordinate, relative to current image width)
+     * @param mixed $height Height of the new canvas (smart coordinate, relative to current image height)
+     * @param mixed $pos_x x-position of the image (smart coordinate, relative to the new width)
+     * @param mixed $pos_y y-position of the image (smart coordinate, relative to the new height)
+     * @param int $bg_color Background color (created with allocateColor or allocateColorAlpha), defaults to null (tries to use a transparent color)
+     * @param string $scale Possible values: 'up' (enlarge only), 'down' (downsize only), 'any' (resize precisely to $width x $height). Defaults to 'any'.
+     * @param bool $merge Merge the original image (flatten alpha channel and transparency) or copy it over (preserve). Defaults to false.
+     * @return \WideImage\Image The resulting image with resized canvas
+     */
+    public function resizeCanvas($width, $height, $pos_x, $pos_y, $bg_color = null, $scale = 'any', $merge = false)
+    {
+        return $this->getOperation('ResizeCanvas')->execute($this, $width, $height, $pos_x, $pos_y, $bg_color, $scale, $merge);
+    }
+	
+    /**
+     * Returns an image with round corners
+     * 
+     * You can either set the corners' color or set them transparent.
+     * 
+     * Note on $smoothness: 1 means jagged edges, 2 is much better, more than 4 doesn't noticeably improve the quality.
+     * Rendering becomes increasingly slower if you increase smoothness.
+     * 
+     * Example:
+     * <code>
+     * $nice = $ugly->roundCorners(20, $ugly->allocateColor(255, 0, 0), 2);
+     * </code>
+     * 
+     * Use $corners parameter to specify which corners to draw rounded. Possible values are
+     * WideImage::SIDE_TOP_LEFT, WideImage::SIDE_TOP,
+     * WideImage::SIDE_TOP_RIGHT, WideImage::SIDE_RIGHT,
+     * WideImage::SIDE_BOTTOM_RIGHT, WideImage::SIDE_BOTTOM, 
+     * WideImage::SIDE_BOTTOM_LEFT, WideImage::SIDE_LEFT, and WideImage::SIDE_ALL.
+     * You can specify any combination of corners with a + operation, see example below.
+     * 
+     * Example:
+     * <code>
+     * $white = $image->allocateColor(255, 255, 255);
+     * $diagonal_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_TOP_LEFT + WideImage::SIDE_BOTTOM_RIGHT);
+     * $right_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_RIGHT);
+     * </code>
+     * 
+     * @param int $radius Radius of the corners
+     * @param int $color The color of corners. If null, corners are rendered transparent (slower than using a solid color).
+     * @param int $smoothness Specify the level of smoothness. Suggested values from 1 to 4.
+     * @param int $corners Specify which corners to draw (defaults to WideImage::SIDE_ALL = all corners)
+     * @return \WideImage\Image The resulting image with round corners
+     */
+    public function roundCorners($radius, $color = null, $smoothness = 2, $corners = 255)
+    {
+        return $this->getOperation('RoundCorners')->execute($this, $radius, $color, $smoothness, $corners);
+    }
+	
+    /**
+     * Returns an image with applied mask
+     * 
+     * A mask is a grayscale image, where the shade determines the alpha channel. Black is fully transparent
+     * and white is fully opaque.
+     * 
+     * @param \WideImage\Image $mask The mask image, greyscale
+     * @param mixed $left Left coordinate, smart coordinate
+     * @param mixed $top Top coordinate, smart coordinate
+     * @return \WideImage\Image The resulting image
+     **/
+    public function applyMask($mask, $left = 0, $top = 0)
+    {
+        return $this->getOperation('ApplyMask')->execute($this, $mask, $left, $top);
+    }
+	
+    /**
+     * Applies a filter
+     *
+     * @param int $filter One of the IMG_FILTER_* constants
+     * @param int $arg1
+     * @param int $arg2
+     * @param int $arg3
+     * @param int $arg4
+     * @return \WideImage\Image
+     */
+    public function applyFilter($filter, $arg1 = null, $arg2 = null, $arg3 = null, $arg4 = null)
+    {
+        return $this->getOperation('ApplyFilter')->execute($this, $filter, $arg1, $arg2, $arg3, $arg4);
+    }
+	
+    /**
+     * Applies convolution matrix with imageconvolution()
+     *
+     * @param array $matrix
+     * @param float $div
+     * @param float $offset
+     * @return \WideImage\Image
+     */
+    public function applyConvolution($matrix, $div, $offset)
+    {
+        return $this->getOperation('ApplyConvolution')->execute($this, $matrix, $div, $offset);
+    }
+	
+    /**
+     * Returns a cropped rectangular portion of the image
+     * 
+     * If the rectangle specifies area that is out of bounds, it's limited to the current image bounds.
+     * 
+     * Examples:
+     * <code>
+     * $cropped = $img->crop(10, 10, 150, 200); // crops a 150x200 rect at (10, 10)
+     * $cropped = $img->crop(-100, -50, 100, 50); // crops a 100x50 rect at the right-bottom of the image
+     * $cropped = $img->crop('25%', '25%', '50%', '50%'); // crops a 50%x50% rect from the center of the image
+     * </code>
+     * 
+     * This operation supports alignment notation in left/top coordinates.
+     * Example:
+     * <code>
+     * $cropped = $img->crop("right", "bottom", 100, 200); // crops a 100x200 rect from right bottom
+     * $cropped = $img->crop("center", "middle", 50, 30); // crops a 50x30 from the center of the image
+     * </code>
+     * 
+     * @param mixed $left Left-coordinate of the crop rect, smart coordinate
+     * @param mixed $top Top-coordinate of the crop rect, smart coordinate
+     * @param mixed $width Width of the crop rect, smart coordinate
+     * @param mixed $height Height of the crop rect, smart coordinate
+     * @return \WideImage\Image The cropped image
+     **/
+    public function crop($left = 0, $top = 0, $width = '100%', $height = '100%')
+    {
+        return $this->getOperation('Crop')->execute($this, $left, $top, $width, $height);
+    }
+	
+    /**
+     * Performs an auto-crop on the image
+     *
+     * The image is auto-cropped from each of four sides. All sides are 
+     * scanned for pixels that differ from $base_color for more than 
+     * $rgb_threshold in absolute RGB difference. If more than $pixel_cutoff 
+     * differentiating pixels are found, that line is considered to be the crop line for the side.
+     * If the line isn't different enough, the algorithm procedes to the next line 
+     * towards the other edge of the image.
+     * 
+     * When the crop rectangle is found, it's enlarged by the $margin value on each of the four sides.
+     *
+     * @param int $margin Margin for the crop rectangle, can be negative.
+     * @param int $rgb_threshold RGB difference which still counts as "same color".
+     * @param int $pixel_cutoff How many pixels need to be different to mark a cut line.
+     * @param int $base_color The base color index. If none specified (or null given), left-top pixel is used.
+     * @return \WideImage\Image The cropped image
+     */
+    public function autoCrop($margin = 0, $rgb_threshold = 0, $pixel_cutoff = 1, $base_color = null)
+    {
+        return $this->getOperation('AutoCrop')->execute($this, $margin, $rgb_threshold, $pixel_cutoff, $base_color);
+    }
+	
+    /**
+     * Returns a negative of the image
+     *
+     * This operation differs from calling \WideImage\Image::applyFilter(IMG_FILTER_NEGATIVE), because it's 8-bit and transparency safe.
+     * This means it will return an 8-bit image, if the source image is 8-bit. If that 8-bit image has a palette transparency,
+     * the resulting image will keep transparency.
+     *
+     * @return \WideImage\Image negative of the image
+     */
+    public function asNegative()
+    {
+        return $this->getOperation('AsNegative')->execute($this);
+    }
+	
+    /**
+     * Returns a grayscale copy of the image
+     * 
+     * @return \WideImage\Image grayscale copy
+     **/
+    public function asGrayscale()
+    {
+        return $this->getOperation('AsGrayscale')->execute($this);
+    }
+	
+    /**
+     * Returns a mirrored copy of the image
+     * 
+     * @return \WideImage\Image Mirrored copy
+     **/
+    public function mirror()
+    {
+        return $this->getOperation('Mirror')->execute($this);
+    }
+	
+    /**
+     * Applies the unsharp filter
+     * 
+     * @param float $amount
+     * @param float $radius
+     * @param float $threshold
+     * @return \WideImage\Image Unsharpened copy of the image
+     **/
+    public function unsharp($amount, $radius, $threshold)
+    {
+        return $this->getOperation('Unsharp')->execute($this, $amount, $radius, $threshold);
+    }
+	
+    /**
+     * Returns a flipped (mirrored over horizontal line) copy of the image
+     * 
+     * @return \WideImage\Image Flipped copy
+     **/
+    public function flip()
+    {
+        return $this->getOperation('Flip')->execute($this);
+    }
+	
+    /**
+     * Corrects gamma on the image
+     * 
+     * @param float $inputGamma
+     * @param float $outputGamma
+     * @return \WideImage\Image Image with corrected gamma
+     **/
+    public function correctGamma($inputGamma, $outputGamma)
+    {
+        return $this->getOperation('CorrectGamma')->execute($this, $inputGamma, $outputGamma);
+    }
+	
+    /**
+     * Adds noise to the image
+     * 
+     * @author Tomasz Kapusta
+     * 
+     * @param int $amount Number of noise pixels to add
+     * @param string $type Type of noise 'salt&pepper', 'color' or 'mono'
+     * @return \WideImage\Image Image with noise added
+     **/
+    public function addNoise($amount, $type)
+    {
+        return $this->getOperation('AddNoise')->execute($this, $amount, $type);
+    }
+	
+    /**
+     * Used internally to execute operations
+     *
+     * @param string $name
+     * @param array $args
+     * @return \WideImage\Image
+     */
+    public function __call($name, $args)
+    {
+        $op = $this->getOperation($name);
+        array_unshift($args, $this);
+        return call_user_func_array(array($op, 'execute'), $args);
+    }
+	
+    /**
+     * Returns an image in GIF or PNG format
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        if ($this->isTransparent()) {
+            return $this->asString('gif');
+        }
 		
-		return $this->asString('png');
-	}
-	
-	/**
-	 * Returns a copy of the image object
-	 * 
-	 * @return \WideImage\Image The copy
-	 **/
-	public function copy()
-	{
-		$dest = $this->doCreate($this->getWidth(), $this->getHeight());
-		$dest->copyTransparencyFrom($this, true);
-		$this->copyTo($dest, 0, 0);
-		return $dest;
-	}
-	
-	/**
-	 * Copies this image onto another image
-	 * 
-	 * @param \WideImage\Image $dest
-	 * @param int $left
-	 * @param int $top
-	 **/
-	public function copyTo($dest, $left = 0, $top = 0)
-	{
-		if (!imagecopy($dest->getHandle(), $this->handle, $left, $top, 0, 0, $this->getWidth(), $this->getHeight())) {
-			throw new GDFunctionResultException("imagecopy() returned false");
-		}
-	}
-	
-	/**
-	 * Returns the canvas object
-	 * 
-	 * The Canvas object can be used to draw text and shapes on the image
-	 * 
-	 * Examples:
-	 * <code>
-	 * $img = WideImage::load('pic.jpg);
-	 * $canvas = $img->getCanvas();
-	 * $canvas->useFont('arial.ttf', 15, $img->allocateColor(200, 220, 255));
-	 * $canvas->writeText(10, 50, "Hello world!");
-	 * 
-	 * $canvas->filledRectangle(10, 10, 80, 40, $img->allocateColor(255, 127, 255));
-	 * $canvas->line(60, 80, 30, 100, $img->allocateColor(255, 0, 0));
-	 * $img->saveToFile('new.png');
-	 * </code>
-	 * 
-	 * @return \WideImage\Canvas The Canvas object
-	 **/
-	function getCanvas()
-	{
-		if ($this->canvas == null) {
-			$this->canvas = new Canvas($this);
-		}
+        return $this->asString('png');
+    }
+	
+    /**
+     * Returns a copy of the image object
+     * 
+     * @return \WideImage\Image The copy
+     **/
+    public function copy()
+    {
+        $dest = $this->doCreate($this->getWidth(), $this->getHeight());
+        $dest->copyTransparencyFrom($this, true);
+        $this->copyTo($dest, 0, 0);
+        return $dest;
+    }
+	
+    /**
+     * Copies this image onto another image
+     * 
+     * @param \WideImage\Image $dest
+     * @param int $left
+     * @param int $top
+     **/
+    public function copyTo($dest, $left = 0, $top = 0)
+    {
+        if (!imagecopy($dest->getHandle(), $this->handle, $left, $top, 0, 0, $this->getWidth(), $this->getHeight())) {
+            throw new GDFunctionResultException("imagecopy() returned false");
+        }
+    }
+	
+    /**
+     * Returns the canvas object
+     * 
+     * The Canvas object can be used to draw text and shapes on the image
+     * 
+     * Examples:
+     * <code>
+     * $img = WideImage::load('pic.jpg);
+     * $canvas = $img->getCanvas();
+     * $canvas->useFont('arial.ttf', 15, $img->allocateColor(200, 220, 255));
+     * $canvas->writeText(10, 50, "Hello world!");
+     * 
+     * $canvas->filledRectangle(10, 10, 80, 40, $img->allocateColor(255, 127, 255));
+     * $canvas->line(60, 80, 30, 100, $img->allocateColor(255, 0, 0));
+     * $img->saveToFile('new.png');
+     * </code>
+     * 
+     * @return \WideImage\Canvas The Canvas object
+     **/
+    function getCanvas()
+    {
+        if ($this->canvas == null) {
+            $this->canvas = new Canvas($this);
+        }
 		
-		return $this->canvas;
-	}
-	
-	/**
-	 * Returns true if the image is true-color, false otherwise
-	 * 
-	 * @return bool
-	 **/
-	abstract public function isTrueColor();
-	
-	/**
-	 * Returns a true-color copy of the image
-	 * 
-	 * @return \WideImage\TrueColorImage
-	 **/
-	abstract public function asTrueColor();
-	
-	/**
-	 * Returns a palette copy (8bit) of the image
-	 *
-	 * @param int $nColors Number of colors in the resulting image, more than 0, less or equal to 255
-	 * @param bool $dither Use dithering or not
-	 * @param bool $matchPalette Set to true to use imagecolormatch() to match the resulting palette more closely to the original image 
-	 * @return \WideImage\Image
-	 **/
-	abstract public function asPalette($nColors = 255, $dither = null, $matchPalette = true);
-	
-	/**
-	 * Retrieve an image with selected channels
-	 * 
-	 * Examples:
-	 * <code>
-	 * $channels = $img->getChannels('red', 'blue');
-	 * $channels = $img->getChannels('alpha', 'green');
-	 * $channels = $img->getChannels(array('green', 'blue'));
-	 * </code>
-	 * 
-	 * @return \WideImage\Image
-	 **/
-	abstract public function getChannels();
-	
-	/**
-	 * Returns an image without an alpha channel
-	 * 
-	 * @return \WideImage\Image
-	 **/
-	abstract public function copyNoAlpha();
-	
-	/**
-	 * Returns an array of serializable protected variables. Called automatically upon serialize().
-	 * 
-	 * @return array
-	 */
-	public function __sleep()
-	{
-		$this->sdata = $this->asString('png');
+        return $this->canvas;
+    }
+	
+    /**
+     * Returns true if the image is true-color, false otherwise
+     * 
+     * @return bool
+     **/
+    abstract public function isTrueColor();
+	
+    /**
+     * Returns a true-color copy of the image
+     * 
+     * @return \WideImage\TrueColorImage
+     **/
+    abstract public function asTrueColor();
+	
+    /**
+     * Returns a palette copy (8bit) of the image
+     *
+     * @param int $nColors Number of colors in the resulting image, more than 0, less or equal to 255
+     * @param bool $dither Use dithering or not
+     * @param bool $matchPalette Set to true to use imagecolormatch() to match the resulting palette more closely to the original image 
+     * @return \WideImage\Image
+     **/
+    abstract public function asPalette($nColors = 255, $dither = null, $matchPalette = true);
+	
+    /**
+     * Retrieve an image with selected channels
+     * 
+     * Examples:
+     * <code>
+     * $channels = $img->getChannels('red', 'blue');
+     * $channels = $img->getChannels('alpha', 'green');
+     * $channels = $img->getChannels(array('green', 'blue'));
+     * </code>
+     * 
+     * @return \WideImage\Image
+     **/
+    abstract public function getChannels();
+	
+    /**
+     * Returns an image without an alpha channel
+     * 
+     * @return \WideImage\Image
+     **/
+    abstract public function copyNoAlpha();
+	
+    /**
+     * Returns an array of serializable protected variables. Called automatically upon serialize().
+     * 
+     * @return array
+     */
+    public function __sleep()
+    {
+        $this->sdata = $this->asString('png');
 		
-		return array('sdata', 'handleReleased');
-	}
-	
-	/**
-	 * Restores an image from serialization. Called automatically upon unserialize().
-	 */
-	public function __wakeup()
-	{
-		$temp_image = WideImage::loadFromString($this->sdata);
-		$temp_image->releaseHandle();
-		$this->handle = $temp_image->handle;
-		$temp_image = null;
-		$this->sdata = null;
-	}
+        return array('sdata', 'handleReleased');
+    }
+	
+    /**
+     * Restores an image from serialization. Called automatically upon unserialize().
+     */
+    public function __wakeup()
+    {
+        $temp_image = WideImage::loadFromString($this->sdata);
+        $temp_image->releaseHandle();
+        $this->handle = $temp_image->handle;
+        $temp_image = null;
+        $this->sdata = null;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -153,7 +153,7 @@ 
 		$res = call_user_func_array(array($mapper, 'save'), $args);
 		
 		if (!$res) {
-			throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while saving to $uri");
+			throw new UnknownErrorWhileMappingException(get_class($mapper)." returned an invalid result while saving to $uri");
 		}
 	}
 	
@@ -176,7 +176,7 @@ 
 		$res    = call_user_func_array(array($mapper, 'save'), $args);
 		
 		if (!$res) {
-			throw new UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while writing the image data");
+			throw new UnknownErrorWhileMappingException(get_class($mapper)." returned an invalid result while writing the image data");
 		}
 		
 		return ob_get_clean();
@@ -190,7 +190,7 @@ 
 	 */
 	protected function writeHeader($name, $data)
 	{
-		header($name . ": " . $data);
+		header($name.": ".$data);
 	}
 	
 	/**

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/TrueColorImage.php

Indentation +177 added lines, -177 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-	/**
+    /**
 ##DOC-SIGNATURE##
 
     This file is part of WideImage.
@@ -17,7 +17,7 @@ 
     You should have received a copy of the GNU Lesser General Public License
     along with WideImage; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-  **/
+     **/
 
 namespace WideImage;
 
@@ -30,117 +30,117 @@ 
  */
 class TrueColorImage extends Image
 {
-	/**
-	 * Creates the object
-	 *
-	 * @param resource $handle
-	 */
-	public function __construct($handle)
-	{
-		parent::__construct($handle);
+    /**
+     * Creates the object
+     *
+     * @param resource $handle
+     */
+    public function __construct($handle)
+    {
+        parent::__construct($handle);
 		
-		$this->alphaBlending(false);
-		$this->saveAlpha(true);
-	}
+        $this->alphaBlending(false);
+        $this->saveAlpha(true);
+    }
 	
-	/**
-	 * Factory method that creates a true-color image object
-	 *
-	 * @param int $width
-	 * @param int $height
-	 * @return \WideImage\TrueColorImage
-	 */
-	public static function create($width, $height)
-	{
-		if ($width * $height <= 0 || $width < 0) {
-			throw new InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
-		}
+    /**
+     * Factory method that creates a true-color image object
+     *
+     * @param int $width
+     * @param int $height
+     * @return \WideImage\TrueColorImage
+     */
+    public static function create($width, $height)
+    {
+        if ($width * $height <= 0 || $width < 0) {
+            throw new InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
+        }
 		
-		return new TrueColorImage(imagecreatetruecolor($width, $height));
-	}
+        return new TrueColorImage(imagecreatetruecolor($width, $height));
+    }
 	
-	public function doCreate($width, $height)
-	{
-		return static::create($width, $height);
-	}
+    public function doCreate($width, $height)
+    {
+        return static::create($width, $height);
+    }
 	
-	public function isTrueColor()
-	{
-		return true;
-	}
+    public function isTrueColor()
+    {
+        return true;
+    }
 	
-	/**
-	 * Sets alpha blending mode via imagealphablending()
-	 *
-	 * @param bool $mode
-	 * @return bool
-	 */
-	public function alphaBlending($mode)
-	{
-		return imagealphablending($this->handle, $mode);
-	}
+    /**
+     * Sets alpha blending mode via imagealphablending()
+     *
+     * @param bool $mode
+     * @return bool
+     */
+    public function alphaBlending($mode)
+    {
+        return imagealphablending($this->handle, $mode);
+    }
 	
-	/**
-	 * Toggle if alpha channel should be saved with the image via imagesavealpha()
-	 *
-	 * @param bool $on
-	 * @return bool
-	 */
-	public function saveAlpha($on)
-	{
-		return imagesavealpha($this->handle, $on);
-	}
+    /**
+     * Toggle if alpha channel should be saved with the image via imagesavealpha()
+     *
+     * @param bool $on
+     * @return bool
+     */
+    public function saveAlpha($on)
+    {
+        return imagesavealpha($this->handle, $on);
+    }
 	
-	/**
-	 * Allocates a color and returns its index
-	 * 
-	 * This method accepts either each component as an integer value,
-	 * or an associative array that holds the color's components in keys
-	 * 'red', 'green', 'blue', 'alpha'.
-	 *
-	 * @param mixed $R
-	 * @param int $G
-	 * @param int $B
-	 * @param int $A
-	 * @return int
-	 */
-	public function allocateColorAlpha($R, $G = null, $B = null, $A = null)
-	{
-		if (is_array($R)) {
-			return imageColorAllocateAlpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
-		}
+    /**
+     * Allocates a color and returns its index
+     * 
+     * This method accepts either each component as an integer value,
+     * or an associative array that holds the color's components in keys
+     * 'red', 'green', 'blue', 'alpha'.
+     *
+     * @param mixed $R
+     * @param int $G
+     * @param int $B
+     * @param int $A
+     * @return int
+     */
+    public function allocateColorAlpha($R, $G = null, $B = null, $A = null)
+    {
+        if (is_array($R)) {
+            return imageColorAllocateAlpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
+        }
 		
-		return imageColorAllocateAlpha($this->handle, $R, $G, $B, $A);
-	}
+        return imageColorAllocateAlpha($this->handle, $R, $G, $B, $A);
+    }
 	
-	/**
-	 * @see \WideImage\Image#asPalette($nColors, $dither, $matchPalette)
-	 */
-	public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
-	{
-		$nColors = intval($nColors);
+    /**
+     * @see \WideImage\Image#asPalette($nColors, $dither, $matchPalette)
+     */
+    public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
+    {
+        $nColors = intval($nColors);
 		
-		if ($nColors < 1) {
-			$nColors = 1;
-		} elseif ($nColors > 255) {
-			$nColors = 255;
-		}
+        if ($nColors < 1) {
+            $nColors = 1;
+        } elseif ($nColors > 255) {
+            $nColors = 255;
+        }
 		
-		if ($dither === null) {
-			$dither = $this->isTransparent();
-		}
+        if ($dither === null) {
+            $dither = $this->isTransparent();
+        }
 		
-		$temp = $this->copy();
+        $temp = $this->copy();
 		
-		imagetruecolortopalette($temp->handle, $dither, $nColors);
+        imagetruecolortopalette($temp->handle, $dither, $nColors);
 		
-		if ($matchPalette == true && function_exists('imagecolormatch')) {
-			imagecolormatch($this->handle, $temp->handle);
-		}
+        if ($matchPalette == true && function_exists('imagecolormatch')) {
+            imagecolormatch($this->handle, $temp->handle);
+        }
 		
-		// The code below isn't working properly; it corrupts transparency on some palette->tc->palette conversions.
-		// Why is this code here?
-		/*
+        // The code below isn't working properly; it corrupts transparency on some palette->tc->palette conversions.
+        // Why is this code here?
+        /*
 		if ($this->isTransparent())
 		{
 			$trgb = $this->getTransparentColorRGB();
@@ -149,97 +149,97 @@ 
 		}
 		/**/
 		
-		$temp->releaseHandle();
+        $temp->releaseHandle();
 		
-		return new PaletteImage($temp->handle);
-	}
+        return new PaletteImage($temp->handle);
+    }
 	
-	/**
-	 * Returns the index of the color that best match the given color components
-	 *
-	 * This method accepts either each component as an integer value,
-	 * or an associative array that holds the color's components in keys
-	 * 'red', 'green', 'blue', 'alpha'.
-	 *
-	 * @param mixed $R Red component value or an associative array
-	 * @param int $G Green component
-	 * @param int $B Blue component
-	 * @param int $A Alpha component
-	 * @return int The color index
-	 */
-	public function getClosestColorAlpha($R, $G = null, $B = null, $A = null)
-	{
-		if (is_array($R)) {
-			return imagecolorclosestalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
-		}
+    /**
+     * Returns the index of the color that best match the given color components
+     *
+     * This method accepts either each component as an integer value,
+     * or an associative array that holds the color's components in keys
+     * 'red', 'green', 'blue', 'alpha'.
+     *
+     * @param mixed $R Red component value or an associative array
+     * @param int $G Green component
+     * @param int $B Blue component
+     * @param int $A Alpha component
+     * @return int The color index
+     */
+    public function getClosestColorAlpha($R, $G = null, $B = null, $A = null)
+    {
+        if (is_array($R)) {
+            return imagecolorclosestalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
+        }
 		
-		return imagecolorclosestalpha($this->handle, $R, $G, $B, $A);
-	}
+        return imagecolorclosestalpha($this->handle, $R, $G, $B, $A);
+    }
 	
-	/**
-	 * Returns the index of the color that exactly match the given color components
-	 *
-	 * This method accepts either each component as an integer value,
-	 * or an associative array that holds the color's components in keys
-	 * 'red', 'green', 'blue', 'alpha'.
-	 *
-	 * @param mixed $R Red component value or an associative array
-	 * @param int $G Green component
-	 * @param int $B Blue component
-	 * @param int $A Alpha component
-	 * @return int The color index
-	 */
-	public function getExactColorAlpha($R, $G = null, $B = null, $A = null)
-	{
-		if (is_array($R)) {
-			return imagecolorexactalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
-		}
+    /**
+     * Returns the index of the color that exactly match the given color components
+     *
+     * This method accepts either each component as an integer value,
+     * or an associative array that holds the color's components in keys
+     * 'red', 'green', 'blue', 'alpha'.
+     *
+     * @param mixed $R Red component value or an associative array
+     * @param int $G Green component
+     * @param int $B Blue component
+     * @param int $A Alpha component
+     * @return int The color index
+     */
+    public function getExactColorAlpha($R, $G = null, $B = null, $A = null)
+    {
+        if (is_array($R)) {
+            return imagecolorexactalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
+        }
 		
-		return imagecolorexactalpha($this->handle, $R, $G, $B, $A);
-	}
+        return imagecolorexactalpha($this->handle, $R, $G, $B, $A);
+    }
 	
-	/**
-	 * @see \WideImage\Image#getChannels()
-	 */
-	public function getChannels()
-	{
-		$args = func_get_args();
+    /**
+     * @see \WideImage\Image#getChannels()
+     */
+    public function getChannels()
+    {
+        $args = func_get_args();
 		
-		if (count($args) == 1 && is_array($args[0])) {
-			$args = $args[0];
-		}
+        if (count($args) == 1 && is_array($args[0])) {
+            $args = $args[0];
+        }
 		
-		return OperationFactory::get('CopyChannelsTrueColor')->execute($this, $args);
-	}
+        return OperationFactory::get('CopyChannelsTrueColor')->execute($this, $args);
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#copyNoAlpha()
-	 */
-	public function copyNoAlpha()
-	{
-		$prev   = $this->saveAlpha(false);
-		$result = WideImage::loadFromString($this->asString('png'));
-		$this->saveAlpha($prev);
-		//$result->releaseHandle();
-		return $result;
-	}
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#copyNoAlpha()
+     */
+    public function copyNoAlpha()
+    {
+        $prev   = $this->saveAlpha(false);
+        $result = WideImage::loadFromString($this->asString('png'));
+        $this->saveAlpha($prev);
+        //$result->releaseHandle();
+        return $result;
+    }
 	
-	/**
-	 * (non-PHPdoc)
-	 * @see \WideImage\Image#asTrueColor()
-         * @return TrueColorImage
-	 */
-	public function asTrueColor()
-	{
-		return $this->copy();
-	}
+    /**
+     * (non-PHPdoc)
+     * @see \WideImage\Image#asTrueColor()
+     * @return TrueColorImage
+     */
+    public function asTrueColor()
+    {
+        return $this->copy();
+    }
         
-	/**
-	 * Calls imageinterlace() using the current handler
-	 * @see \WideImage\Image#asTrueColor()
-         * @return TrueColorImage A copy of the image, with imageinterlace() applied
-	 */
+    /**
+     * Calls imageinterlace() using the current handler
+     * @see \WideImage\Image#asTrueColor()
+     * @return TrueColorImage A copy of the image, with imageinterlace() applied
+     */
         public function asProgressive()
         {
             $dest = $this->asTrueColor();

Spacing +1 added lines, -1 removed lines

@@ -267,7 +267,7 @@
          * @return TrueColorImage A new, resized image
          */
         public function resizeInsideRect($width, $height, $fit = 'inside', $scale = 'down', $alignLeft = 'center', 
-                $alignTop = 'center', $mergeOpacity = 100,  $fillColor = null)
+                $alignTop = 'center', $mergeOpacity = 100, $fillColor = null)
         {
 
             if ($fillColor) {

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/Coordinate.php

Indentation +147 added lines, -148 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-	/**
+    /**
 ##DOC-SIGNATURE##
 
     This file is part of WideImage.
@@ -17,9 +17,8 @@ 
     You should have received a copy of the GNU Lesser General Public License
     along with WideImage; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-	* @package Internals
-  **/
+     * @package Internals
+     **/
 
 namespace WideImage;
 
@@ -33,166 +32,166 @@ 
  **/
 class Coordinate
 {
-	protected static $coord_align   = array('left', 'center', 'right', 'top', 'middle', 'bottom');
-	protected static $coord_numeric = array('[0-9]+', '[0-9]+\.[0-9]+', '[0-9]+%', '[0-9]+\.[0-9]+%');
+    protected static $coord_align   = array('left', 'center', 'right', 'top', 'middle', 'bottom');
+    protected static $coord_numeric = array('[0-9]+', '[0-9]+\.[0-9]+', '[0-9]+%', '[0-9]+\.[0-9]+%');
 	
-	/**
-	 * Parses a numeric or string representation of a corrdinate into a structure
-	 * 
-	 * @param string $coord Smart coordinate
-	 * @return array Parsed smart coordinate
-	 */
-	public static function parse($c)
-	{
-		$tokens    = array();
-		$operators = array('+', '-');
+    /**
+     * Parses a numeric or string representation of a corrdinate into a structure
+     * 
+     * @param string $coord Smart coordinate
+     * @return array Parsed smart coordinate
+     */
+    public static function parse($c)
+    {
+        $tokens    = array();
+        $operators = array('+', '-');
 		
-		$flush_operand    = false;
-		$flush_operator   = false;
-		$current_operand  = '';
-		$current_operator = '';
-		$coordinate       = strval($c);
-		$expr_len         = strlen($coordinate);
+        $flush_operand    = false;
+        $flush_operator   = false;
+        $current_operand  = '';
+        $current_operator = '';
+        $coordinate       = strval($c);
+        $expr_len         = strlen($coordinate);
 		
-		for ($i = 0; $i < $expr_len; $i++) {
-			$char = $coordinate[$i];
+        for ($i = 0; $i < $expr_len; $i++) {
+            $char = $coordinate[$i];
 			
-			if (in_array($char, $operators)) {
-				$flush_operand    = true;
-				$flush_operator   = true;
-				$current_operator = $char;
-			} else {
-				$current_operand .= $char;
-				if ($i == $expr_len - 1) {
-					$flush_operand = true;
-				}
-			}
+            if (in_array($char, $operators)) {
+                $flush_operand    = true;
+                $flush_operator   = true;
+                $current_operator = $char;
+            } else {
+                $current_operand .= $char;
+                if ($i == $expr_len - 1) {
+                    $flush_operand = true;
+                }
+            }
 			
-			if ($flush_operand) {
-				if (trim($current_operand) != '') {
-					$tokens[] = array('type' => 'operand', 'value' => trim($current_operand));
-				}
+            if ($flush_operand) {
+                if (trim($current_operand) != '') {
+                    $tokens[] = array('type' => 'operand', 'value' => trim($current_operand));
+                }
 				
-				$current_operand = '';
-				$flush_operand   = false;
-			}
+                $current_operand = '';
+                $flush_operand   = false;
+            }
 			
-			if ($flush_operator) {
-				$tokens[]       = array('type' => 'operator', 'value' => $char);
-				$flush_operator = false;
-			}
-		}
+            if ($flush_operator) {
+                $tokens[]       = array('type' => 'operator', 'value' => $char);
+                $flush_operator = false;
+            }
+        }
 		
-		return $tokens;
-	}
+        return $tokens;
+    }
 	
-	/**
-	 * Evaluates the $coord relatively to $dim
-	 * 
-	 * @param string $coord A numeric value or percent string
-	 * @param int $dim Dimension
-	 * @param int $sec_dim Secondary dimension (for align)
-	 * @return int Calculated value
-	 */
-	public static function evaluate($coord, $dim, $sec_dim = null)
-	{
-		$comp_regex = implode('|', self::$coord_align) . '|' . implode('|', self::$coord_numeric);
+    /**
+     * Evaluates the $coord relatively to $dim
+     * 
+     * @param string $coord A numeric value or percent string
+     * @param int $dim Dimension
+     * @param int $sec_dim Secondary dimension (for align)
+     * @return int Calculated value
+     */
+    public static function evaluate($coord, $dim, $sec_dim = null)
+    {
+        $comp_regex = implode('|', self::$coord_align) . '|' . implode('|', self::$coord_numeric);
 		
-		if (preg_match("/^([+-])?({$comp_regex})$/", $coord, $matches)) {
-			$sign = intval($matches[1] . "1");
-			$val  = $matches[2];
+        if (preg_match("/^([+-])?({$comp_regex})$/", $coord, $matches)) {
+            $sign = intval($matches[1] . "1");
+            $val  = $matches[2];
 			
-			if (in_array($val, self::$coord_align)) {
-				if ($sec_dim === null) {
-					switch ($val) {
-						case 'left':
-						case 'top':
-							return 0;
-							break;
-						case 'center':
-						case 'middle':
-							return $sign * intval($dim / 2);
-							break;
-						case 'right':
-						case 'bottom':
-							return $sign * $dim;
-							break;
-						default:
-							return null;
-					}
-				} else {
-					switch ($val) {
-						case 'left':
-						case 'top':
-							return 0;
-							break;
-						case 'center':
-						case 'middle':
-							return $sign * intval($dim / 2 - $sec_dim / 2);
-							break;
-						case 'right':
-						case 'bottom':
-							return $sign * ($dim - $sec_dim);
-							break;
-						default:
-							return null;
-					}
-				}
-			} elseif (substr($val, -1) === '%') {
-				return intval(round($sign * $dim * floatval(str_replace('%', '', $val)) / 100));
-			} else {
-				return $sign * intval(round($val));
-			}
-		}
-	}
+            if (in_array($val, self::$coord_align)) {
+                if ($sec_dim === null) {
+                    switch ($val) {
+                        case 'left':
+                        case 'top':
+                            return 0;
+                            break;
+                        case 'center':
+                        case 'middle':
+                            return $sign * intval($dim / 2);
+                            break;
+                        case 'right':
+                        case 'bottom':
+                            return $sign * $dim;
+                            break;
+                        default:
+                            return null;
+                    }
+                } else {
+                    switch ($val) {
+                        case 'left':
+                        case 'top':
+                            return 0;
+                            break;
+                        case 'center':
+                        case 'middle':
+                            return $sign * intval($dim / 2 - $sec_dim / 2);
+                            break;
+                        case 'right':
+                        case 'bottom':
+                            return $sign * ($dim - $sec_dim);
+                            break;
+                        default:
+                            return null;
+                    }
+                }
+            } elseif (substr($val, -1) === '%') {
+                return intval(round($sign * $dim * floatval(str_replace('%', '', $val)) / 100));
+            } else {
+                return $sign * intval(round($val));
+            }
+        }
+    }
 	
-	/**
-	 * Calculates and fixes a smart coordinate into a numeric value
-	 * 
-	 * @param mixed $value Smart coordinate, relative to $dim
-	 * @param int $dim Coordinate to which $value is relative
-	 * @param int $sec_dim Secondary dimension (for align)
-	 * @return int Calculated value
-	 */
-	public static function fix($value, $dim, $sec_dim = null)
-	{
-		$coord_tokens = self::parse($value);
+    /**
+     * Calculates and fixes a smart coordinate into a numeric value
+     * 
+     * @param mixed $value Smart coordinate, relative to $dim
+     * @param int $dim Coordinate to which $value is relative
+     * @param int $sec_dim Secondary dimension (for align)
+     * @return int Calculated value
+     */
+    public static function fix($value, $dim, $sec_dim = null)
+    {
+        $coord_tokens = self::parse($value);
 		
-		if (count($coord_tokens) == 0 || $coord_tokens[count($coord_tokens) - 1]['type'] != 'operand') {
-			throw new InvalidCoordinateException("Couldn't parse coordinate '$value' properly.");
-		}
+        if (count($coord_tokens) == 0 || $coord_tokens[count($coord_tokens) - 1]['type'] != 'operand') {
+            throw new InvalidCoordinateException("Couldn't parse coordinate '$value' properly.");
+        }
 		
-		$value     = 0;
-		$operation = 1;
+        $value     = 0;
+        $operation = 1;
 		
-		foreach ($coord_tokens as $token) {
-			if ($token['type'] == 'operand') {
-				$operand_value = self::evaluate($token['value'], $dim, $sec_dim);
+        foreach ($coord_tokens as $token) {
+            if ($token['type'] == 'operand') {
+                $operand_value = self::evaluate($token['value'], $dim, $sec_dim);
 				
-				if ($operation == 1) {
-					$value = $value + $operand_value;
-				} elseif ($operation == -1) {
-					$value = $value - $operand_value;
-				} else {
-					throw new InvalidCoordinateException("Invalid coordinate syntax.");
-				}
+                if ($operation == 1) {
+                    $value = $value + $operand_value;
+                } elseif ($operation == -1) {
+                    $value = $value - $operand_value;
+                } else {
+                    throw new InvalidCoordinateException("Invalid coordinate syntax.");
+                }
 				
-				$operation = 0;
-			} elseif ($token['type'] == 'operator') {
-				if ($token['value'] == '-') {
-					if ($operation == 0) {
-						$operation = -1;
-					} else {
-						$operation = $operation * -1;
-					}
-				} elseif ($token['value'] == '+') {
-					if ($operation == 0) {
-						$operation = '1';
-					}
-				}
-			}
-		}
+                $operation = 0;
+            } elseif ($token['type'] == 'operator') {
+                if ($token['value'] == '-') {
+                    if ($operation == 0) {
+                        $operation = -1;
+                    } else {
+                        $operation = $operation * -1;
+                    }
+                } elseif ($token['value'] == '+') {
+                    if ($operation == 0) {
+                        $operation = '1';
+                    }
+                }
+            }
+        }
 		
-		return $value;
-	}
+        return $value;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -96,10 +96,10 @@
 	 */
 	public static function evaluate($coord, $dim, $sec_dim = null)
 	{
-		$comp_regex = implode('|', self::$coord_align) . '|' . implode('|', self::$coord_numeric);
+		$comp_regex = implode('|', self::$coord_align).'|'.implode('|', self::$coord_numeric);
 		
 		if (preg_match("/^([+-])?({$comp_regex})$/", $coord, $matches)) {
-			$sign = intval($matches[1] . "1");
+			$sign = intval($matches[1]."1");
 			$val  = $matches[2];
 			
 			if (in_array($val, self::$coord_align)) {

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/WideImage.php

Indentation +285 added lines, -286 removed lines

@@ -18,7 +18,6 @@ 
  You should have received a copy of the GNU Lesser General Public License
  along with WideImage; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- 
  * @package WideImage
 **/
 	
@@ -37,336 +36,336 @@ 
  */
 class WideImage
 {
-	const SIDE_TOP_LEFT = 1;
-	const SIDE_TOP = 2;
-	const SIDE_TOP_RIGHT = 4;
-	const SIDE_RIGHT = 8;
-	const SIDE_BOTTOM_RIGHT = 16;
-	const SIDE_BOTTOM = 32;
-	const SIDE_BOTTOM_LEFT = 64;
-	const SIDE_LEFT = 128;
-	const SIDE_ALL = 255;
+    const SIDE_TOP_LEFT = 1;
+    const SIDE_TOP = 2;
+    const SIDE_TOP_RIGHT = 4;
+    const SIDE_RIGHT = 8;
+    const SIDE_BOTTOM_RIGHT = 16;
+    const SIDE_BOTTOM = 32;
+    const SIDE_BOTTOM_LEFT = 64;
+    const SIDE_LEFT = 128;
+    const SIDE_ALL = 255;
 	
-	/**
-	 * @var string Path to the library base directory
-	 */
-	protected static $path = null;
+    /**
+     * @var string Path to the library base directory
+     */
+    protected static $path = null;
 	
-	/**
-	 * Returns the library version
-	 * @return string The library version
-	 */
-	public static function version()
-	{
-		return '##DEV##';
-	}
+    /**
+     * Returns the library version
+     * @return string The library version
+     */
+    public static function version()
+    {
+        return '##DEV##';
+    }
 	
-	/**
-	 * Returns the path to the library
-	 * @return string
-	 */
-	public static function path()
-	{
-		if (static::$path === null) {
-			static::$path = __DIR__ . DIRECTORY_SEPARATOR;
-		}
+    /**
+     * Returns the path to the library
+     * @return string
+     */
+    public static function path()
+    {
+        if (static::$path === null) {
+            static::$path = __DIR__ . DIRECTORY_SEPARATOR;
+        }
 		
-		return static::$path;
-	}
+        return static::$path;
+    }
 	
-	/**
-	 * Checks whether the gd library is loaded, and throws an exception otherwise
-	 */
-	public static function checkGD()
-	{
-		if (!extension_loaded('gd')) {
-			throw new Exception("WideImage requires the GD extension, but it's apparently not loaded.");
-		}
-	}
+    /**
+     * Checks whether the gd library is loaded, and throws an exception otherwise
+     */
+    public static function checkGD()
+    {
+        if (!extension_loaded('gd')) {
+            throw new Exception("WideImage requires the GD extension, but it's apparently not loaded.");
+        }
+    }
 
-	/**
-	 * Registers a custom mapper for image loading and saving
-	 * 
-	 * Example:
-	 * <code>
-	 * 	\WideImage\WideImage::registerCustomMapper('\\WideImage\\Mapper\\TGA', 'image/tga', 'tga');
-	 * </code>
-	 * 
-	 * @param string $mapper_class_name
-	 * @param string $mime_type
-	 * @param string $extension
-	 */
-	public static function registerCustomMapper($mapper_class_name, $mime_type, $extension)
-	{
-		MapperFactory::registerMapper($mapper_class_name, $mime_type, strtoupper($extension));
-	}
+    /**
+     * Registers a custom mapper for image loading and saving
+     * 
+     * Example:
+     * <code>
+     * 	\WideImage\WideImage::registerCustomMapper('\\WideImage\\Mapper\\TGA', 'image/tga', 'tga');
+     * </code>
+     * 
+     * @param string $mapper_class_name
+     * @param string $mime_type
+     * @param string $extension
+     */
+    public static function registerCustomMapper($mapper_class_name, $mime_type, $extension)
+    {
+        MapperFactory::registerMapper($mapper_class_name, $mime_type, strtoupper($extension));
+    }
 	
-	/**
-	 * Loads an image from a file, URL, HTML input file field, binary string, or a valid image handle.
-	 * The image format is auto-detected. 
-	 * 
-	 * Currently supported formats: PNG, GIF, JPG, BMP, TGA, GD, GD2.
-	 * 
-	 * This function analyzes the input and decides whether to use WideImage::loadFromHandle(),
-	 * WideImage::loadFromFile(), WideImage::loadFromUpload() or WideImage::loadFromString(),
-	 * all of which you can also call directly to spare WideImage some guessing.
-	 * 
-	 * Arrays are supported for upload fields; it returns an array of loaded images. 
-	 * To load only a single image from an array field, use WideImage::loadFromUpload('img', $i), 
-	 * where $i is the index of the image you want to load.
-	 * 
-	 * <code>
-	 * $img = WideImage::load('http://url/image.png'); // image URL
-	 * $img = WideImage::load('/path/to/image.png'); // local file path
-	 * $img = WideImage::load('img'); // upload field name
-	 * $img = WideImage::load(imagecreatetruecolor(10, 10)); // a GD resource
-	 * $img = WideImage::load($image_data); // binary string containing image data
-	 * </code>
-	 * 
-	 * @param mixed $source File name, url, HTML file input field name, binary string, or a GD image resource
-	 * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
-	 */
-	public static function load($source)
-	{
-		$predictedSourceType = '';
+    /**
+     * Loads an image from a file, URL, HTML input file field, binary string, or a valid image handle.
+     * The image format is auto-detected. 
+     * 
+     * Currently supported formats: PNG, GIF, JPG, BMP, TGA, GD, GD2.
+     * 
+     * This function analyzes the input and decides whether to use WideImage::loadFromHandle(),
+     * WideImage::loadFromFile(), WideImage::loadFromUpload() or WideImage::loadFromString(),
+     * all of which you can also call directly to spare WideImage some guessing.
+     * 
+     * Arrays are supported for upload fields; it returns an array of loaded images. 
+     * To load only a single image from an array field, use WideImage::loadFromUpload('img', $i), 
+     * where $i is the index of the image you want to load.
+     * 
+     * <code>
+     * $img = WideImage::load('http://url/image.png'); // image URL
+     * $img = WideImage::load('/path/to/image.png'); // local file path
+     * $img = WideImage::load('img'); // upload field name
+     * $img = WideImage::load(imagecreatetruecolor(10, 10)); // a GD resource
+     * $img = WideImage::load($image_data); // binary string containing image data
+     * </code>
+     * 
+     * @param mixed $source File name, url, HTML file input field name, binary string, or a GD image resource
+     * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
+     */
+    public static function load($source)
+    {
+        $predictedSourceType = '';
 		
-		if ($source == '') {
-			$predictedSourceType = 'String';
-		}
+        if ($source == '') {
+            $predictedSourceType = 'String';
+        }
 		
-		// Creating image via a valid resource
-		if (!$predictedSourceType && static::isValidImageHandle($source)) {
-			$predictedSourceType = 'Handle';
-		}
+        // Creating image via a valid resource
+        if (!$predictedSourceType && static::isValidImageHandle($source)) {
+            $predictedSourceType = 'Handle';
+        }
 		
-		// Check for binary string
-		if (!$predictedSourceType) {
-			// search first $binLength bytes (at a maximum) for ord<32 characters (binary image data)
-			$binLength    = 64;
-			$sourceLength = strlen($source);
-			$maxlen       = ($sourceLength > $binLength) ? $binLength : $sourceLength;
+        // Check for binary string
+        if (!$predictedSourceType) {
+            // search first $binLength bytes (at a maximum) for ord<32 characters (binary image data)
+            $binLength    = 64;
+            $sourceLength = strlen($source);
+            $maxlen       = ($sourceLength > $binLength) ? $binLength : $sourceLength;
 			
-			for ($i = 0; $i < $maxlen; $i++) {
-				if (ord($source[$i]) < 32) {
-					$predictedSourceType = 'String';
-					break;
-				}
-			}
-		}
+            for ($i = 0; $i < $maxlen; $i++) {
+                if (ord($source[$i]) < 32) {
+                    $predictedSourceType = 'String';
+                    break;
+                }
+            }
+        }
 		
-		// Uploaded image (array uploads not supported)
-		if (isset($_FILES[$source]) && isset($_FILES[$source]['tmp_name'])) {
-			$predictedSourceType = 'Upload';
-		}
+        // Uploaded image (array uploads not supported)
+        if (isset($_FILES[$source]) && isset($_FILES[$source]['tmp_name'])) {
+            $predictedSourceType = 'Upload';
+        }
 		
-		// Otherwise, must be a file or an URL
-		if (!$predictedSourceType) {
-			$predictedSourceType = 'File';
-		}
+        // Otherwise, must be a file or an URL
+        if (!$predictedSourceType) {
+            $predictedSourceType = 'File';
+        }
 		
-		return call_user_func(array(__CLASS__, 'loadFrom' . $predictedSourceType), $source);
-	}
+        return call_user_func(array(__CLASS__, 'loadFrom' . $predictedSourceType), $source);
+    }
 
-	/**
-	 * Create and load an image from a file or URL. The image format is auto-detected.
-	 * 
-	 * @param string $uri File or url
-	 * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
-	 */
-	public static function loadFromFile($uri)
-	{
-		$data   = file_get_contents($uri);
-		$handle = @imagecreatefromstring($data);
+    /**
+     * Create and load an image from a file or URL. The image format is auto-detected.
+     * 
+     * @param string $uri File or url
+     * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
+     */
+    public static function loadFromFile($uri)
+    {
+        $data   = file_get_contents($uri);
+        $handle = @imagecreatefromstring($data);
 		
-		if (!static::isValidImageHandle($handle)) {
-			try {
-				// try to find a mapper first
-				$mapper = MapperFactory::selectMapper($uri);
+        if (!static::isValidImageHandle($handle)) {
+            try {
+                // try to find a mapper first
+                $mapper = MapperFactory::selectMapper($uri);
 				
-				if ($mapper) {
-					$handle = $mapper->load($uri);
-				}
-			} catch (UnsupportedFormatException $e) {
-				// mapper not found
-			}
+                if ($mapper) {
+                    $handle = $mapper->load($uri);
+                }
+            } catch (UnsupportedFormatException $e) {
+                // mapper not found
+            }
 			
-			// try all custom mappers
-			if (!static::isValidImageHandle($handle)) {
-				$custom_mappers = MapperFactory::getCustomMappers();
+            // try all custom mappers
+            if (!static::isValidImageHandle($handle)) {
+                $custom_mappers = MapperFactory::getCustomMappers();
 				
-				foreach ($custom_mappers as $mime_type => $mapper_class) {
-					$mapper = MapperFactory::selectMapper(null, $mime_type);
-					$handle = $mapper->loadFromString($data);
+                foreach ($custom_mappers as $mime_type => $mapper_class) {
+                    $mapper = MapperFactory::selectMapper(null, $mime_type);
+                    $handle = $mapper->loadFromString($data);
 					
-					if (static::isValidImageHandle($handle)) {
-						break;
-					}
-				}
-			}
-		}
+                    if (static::isValidImageHandle($handle)) {
+                        break;
+                    }
+                }
+            }
+        }
 		
-		if (!static::isValidImageHandle($handle)) {
-			throw new InvalidImageSourceException("File '{$uri}' appears to be an invalid image source.");
-		}
+        if (!static::isValidImageHandle($handle)) {
+            throw new InvalidImageSourceException("File '{$uri}' appears to be an invalid image source.");
+        }
 		
-		return static::loadFromHandle($handle);
-	}
+        return static::loadFromHandle($handle);
+    }
 
-	/**
-	 * Create and load an image from a string. Format is auto-detected.
-	 * 
-	 * @param string $string Binary data, i.e. from BLOB field in the database
-	 * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
-	 */
-	public static function loadFromString($string)
-	{
-		if (strlen($string) < 128) {
-			throw new InvalidImageSourceException("String doesn't contain image data.");
-		}
+    /**
+     * Create and load an image from a string. Format is auto-detected.
+     * 
+     * @param string $string Binary data, i.e. from BLOB field in the database
+     * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
+     */
+    public static function loadFromString($string)
+    {
+        if (strlen($string) < 128) {
+            throw new InvalidImageSourceException("String doesn't contain image data.");
+        }
 		
-		$handle = @imagecreatefromstring($string);
+        $handle = @imagecreatefromstring($string);
 		
-		if (!static::isValidImageHandle($handle)) {
-			$custom_mappers = MapperFactory::getCustomMappers();
+        if (!static::isValidImageHandle($handle)) {
+            $custom_mappers = MapperFactory::getCustomMappers();
 			
-			foreach ($custom_mappers as $mime_type => $mapper_class) {
-				$mapper = MapperFactory::selectMapper(null, $mime_type);
-				$handle = $mapper->loadFromString($string);
+            foreach ($custom_mappers as $mime_type => $mapper_class) {
+                $mapper = MapperFactory::selectMapper(null, $mime_type);
+                $handle = $mapper->loadFromString($string);
 				
-				if (static::isValidImageHandle($handle)) {
-					break;
-				}
-			}
-		}
+                if (static::isValidImageHandle($handle)) {
+                    break;
+                }
+            }
+        }
 		
-		if (!static::isValidImageHandle($handle)) {
-			throw new InvalidImageSourceException("String doesn't contain valid image data.");
-		}
+        if (!static::isValidImageHandle($handle)) {
+            throw new InvalidImageSourceException("String doesn't contain valid image data.");
+        }
 		
-		return static::loadFromHandle($handle);
-	}
+        return static::loadFromHandle($handle);
+    }
 	
-	/**
-	 * Create and load an image from an image handle.
-	 * 
-	 * <b>Note:</b> the resulting image object takes ownership of the passed 
-	 * handle. When the newly-created image object is destroyed, the handle is 
-	 * destroyed too, so it's not a valid image handle anymore. In order to 
-	 * preserve the handle for use after object destruction, you have to call 
-	 * \WideImage\Image::releaseHandle() on the created image instance prior to its
-	 * destruction.
-	 * 
-	 * <code>
-	 * $handle = imagecreatefrompng('file.png');
-	 * $image = WideImage::loadFromHandle($handle);
-	 * </code>
-	 * 
-	 * @param resource $handle A valid GD image resource
-	 * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
-	 */
-	public static function loadFromHandle($handle)
-	{
-		if (!static::isValidImageHandle($handle)) {
-			throw new InvalidImageSourceException("Handle is not a valid GD image resource.");
-		}
+    /**
+     * Create and load an image from an image handle.
+     * 
+     * <b>Note:</b> the resulting image object takes ownership of the passed 
+     * handle. When the newly-created image object is destroyed, the handle is 
+     * destroyed too, so it's not a valid image handle anymore. In order to 
+     * preserve the handle for use after object destruction, you have to call 
+     * \WideImage\Image::releaseHandle() on the created image instance prior to its
+     * destruction.
+     * 
+     * <code>
+     * $handle = imagecreatefrompng('file.png');
+     * $image = WideImage::loadFromHandle($handle);
+     * </code>
+     * 
+     * @param resource $handle A valid GD image resource
+     * @return \WideImage\Image|\WideImage\PaletteImage|\WideImage\TrueColorImage
+     */
+    public static function loadFromHandle($handle)
+    {
+        if (!static::isValidImageHandle($handle)) {
+            throw new InvalidImageSourceException("Handle is not a valid GD image resource.");
+        }
 		
-		if (imageistruecolor($handle)) {
-			return new TrueColorImage($handle);
-		}
+        if (imageistruecolor($handle)) {
+            return new TrueColorImage($handle);
+        }
 		
-		return new PaletteImage($handle);
-	}
+        return new PaletteImage($handle);
+    }
 	
-	/**
-	 * This method loads a file from the $_FILES array. The image format is auto-detected.
-	 * 
-	 * You only have to pass the field name as the parameter. For array fields, this function will
-	 * return an array of image objects, unless you specify the $index parameter, which will
-	 * load the desired image.
-	 * 
-	 * @param $field_name Name of the key in $_FILES array
-	 * @param int $index The index of the file to load (if the input field is an array)
-	 * @return \WideImage\Image The loaded image
-	 */
-	public static function loadFromUpload($field_name, $index = null)
-	{
-		if (!array_key_exists($field_name, $_FILES)) {
-			throw new InvalidImageSourceException("Upload field '{$field_name}' doesn't exist.");
-		}
+    /**
+     * This method loads a file from the $_FILES array. The image format is auto-detected.
+     * 
+     * You only have to pass the field name as the parameter. For array fields, this function will
+     * return an array of image objects, unless you specify the $index parameter, which will
+     * load the desired image.
+     * 
+     * @param $field_name Name of the key in $_FILES array
+     * @param int $index The index of the file to load (if the input field is an array)
+     * @return \WideImage\Image The loaded image
+     */
+    public static function loadFromUpload($field_name, $index = null)
+    {
+        if (!array_key_exists($field_name, $_FILES)) {
+            throw new InvalidImageSourceException("Upload field '{$field_name}' doesn't exist.");
+        }
 		
-		if (is_array($_FILES[$field_name]['tmp_name'])) {
-			if (isset($_FILES[$field_name]['tmp_name'][$index])) {
-				$filename = $_FILES[$field_name]['tmp_name'][$index];
-			} else {
-				$result = array();
+        if (is_array($_FILES[$field_name]['tmp_name'])) {
+            if (isset($_FILES[$field_name]['tmp_name'][$index])) {
+                $filename = $_FILES[$field_name]['tmp_name'][$index];
+            } else {
+                $result = array();
 				
-				foreach ($_FILES[$field_name]['tmp_name'] as $idx => $tmp_name) {
-					$result[$idx] = static::loadFromFile($tmp_name);
-				}
+                foreach ($_FILES[$field_name]['tmp_name'] as $idx => $tmp_name) {
+                    $result[$idx] = static::loadFromFile($tmp_name);
+                }
 				
-				return $result;
-			}
-		} else {
-			$filename = $_FILES[$field_name]['tmp_name'];
-		}
+                return $result;
+            }
+        } else {
+            $filename = $_FILES[$field_name]['tmp_name'];
+        }
 		
-		if (!file_exists($filename)) {
-			throw new InvalidImageSourceException("Uploaded file doesn't exist.");
-		}
+        if (!file_exists($filename)) {
+            throw new InvalidImageSourceException("Uploaded file doesn't exist.");
+        }
 		
-		return static::loadFromFile($filename);
-	}
+        return static::loadFromFile($filename);
+    }
 	
-	/**
-	 * Factory method for creating a palette image
-	 * 
-	 * @param int $width
-	 * @param int $height
-	 * @return \WideImage\PaletteImage
-	 */
-	public static function createPaletteImage($width, $height)
-	{
-		return PaletteImage::create($width, $height);
-	}
+    /**
+     * Factory method for creating a palette image
+     * 
+     * @param int $width
+     * @param int $height
+     * @return \WideImage\PaletteImage
+     */
+    public static function createPaletteImage($width, $height)
+    {
+        return PaletteImage::create($width, $height);
+    }
 	
-	/**
-	 * Factory method for creating a true-color image
-	 * 
-	 * @param int $width
-	 * @param int $height
-	 * @return \WideImage\TrueColorImage
-	 */
-	public static function createTrueColorImage($width, $height)
-	{
-		return TrueColorImage::create($width, $height);
-	}
+    /**
+     * Factory method for creating a true-color image
+     * 
+     * @param int $width
+     * @param int $height
+     * @return \WideImage\TrueColorImage
+     */
+    public static function createTrueColorImage($width, $height)
+    {
+        return TrueColorImage::create($width, $height);
+    }
 	
-	/**
-	 * Check whether the given handle is a valid GD resource
-	 * 
-	 * @param mixed $handle The variable to check
-	 * @return bool
-	 */
-	public static function isValidImageHandle($handle)
-	{
-		return (is_resource($handle) && get_resource_type($handle) == 'gd');
-	}
+    /**
+     * Check whether the given handle is a valid GD resource
+     * 
+     * @param mixed $handle The variable to check
+     * @return bool
+     */
+    public static function isValidImageHandle($handle)
+    {
+        return (is_resource($handle) && get_resource_type($handle) == 'gd');
+    }
 	
-	/**
-	 * Throws exception if the handle isn't a valid GD resource
-	 * 
-	 * @param mixed $handle The variable to check
-	 */
-	public static function assertValidImageHandle($handle)
-	{
-		if (!static::isValidImageHandle($handle)) {
-			throw new InvalidImageHandleException("{$handle} is not a valid image handle.");
-		}
-	}
+    /**
+     * Throws exception if the handle isn't a valid GD resource
+     * 
+     * @param mixed $handle The variable to check
+     */
+    public static function assertValidImageHandle($handle)
+    {
+        if (!static::isValidImageHandle($handle)) {
+            throw new InvalidImageHandleException("{$handle} is not a valid image handle.");
+        }
+    }
 }
 	
 WideImage::checkGD();
 
 WideImage::registerCustomMapper('\\WideImage\\Mapper\\BMP', 'image/bmp', 'bmp');
 WideImage::registerCustomMapper('\\WideImage\\Mapper\\TGA', 'image/tga', 'tga');
-	
\ No newline at end of file
+    
\ No newline at end of file

Spacing +2 added lines, -2 removed lines

@@ -68,7 +68,7 @@ 
 	public static function path()
 	{
 		if (static::$path === null) {
-			static::$path = __DIR__ . DIRECTORY_SEPARATOR;
+			static::$path = __DIR__.DIRECTORY_SEPARATOR;
 		}
 		
 		return static::$path;
@@ -164,7 +164,7 @@ 
 			$predictedSourceType = 'File';
 		}
 		
-		return call_user_func(array(__CLASS__, 'loadFrom' . $predictedSourceType), $source);
+		return call_user_func(array(__CLASS__, 'loadFrom'.$predictedSourceType), $source);
 	}
 
 	/**

htdocs/class/libraries/vendor/smottt/wideimage/lib/WideImage/Font/GDF.php

Indentation +18 added lines, -19 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-	/**
+    /**
 ##DOC-SIGNATURE##
 
     This file is part of WideImage.
@@ -17,9 +17,8 @@ 
     You should have received a copy of the GNU Lesser General Public License
     along with WideImage; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-    
-    * @package WideImage
-  **/
+     * @package WideImage
+     **/
 
 namespace WideImage\Font;
 
@@ -30,22 +29,22 @@ 
  */
 class GDF
 {
-	protected $font;
-	protected $color;
+    protected $font;
+    protected $color;
 	
-	public function __construct($face, $color)
-	{
-		if (is_int($face) && $face >= 1 && $face <= 5) {
-			$this->font = $face;
-		} else {
-			$this->font = imageloadfont($face);
-		}
+    public function __construct($face, $color)
+    {
+        if (is_int($face) && $face >= 1 && $face <= 5) {
+            $this->font = $face;
+        } else {
+            $this->font = imageloadfont($face);
+        }
 		
-		$this->color = $color;
-	}
+        $this->color = $color;
+    }
 	
-	public function writeText($image, $x, $y, $text)
-	{
-		imagestring($image->getHandle(), $this->font, $x, $y, $text, $this->color);
-	}
+    public function writeText($image, $x, $y, $text)
+    {
+        imagestring($image->getHandle(), $this->font, $x, $y, $text, $this->color);
+    }
 }