1. Приветствуем Вас на нашем закрытом форуме для складчиков сайта cmsheaven.org. Если Вы частный вебмастер, фрилансер, владелец малого или среднего бизнеса, представитель студии по разработке сайтов - будем рады видеть Вас в наших рядах экономных людей.
    Регистрация на форуме возможна только после вступления в складчину

Не работает кириллический поиск для расширения Minitek Live Search v3.3.6

Тема в разделе "Русификации расширений для Joomla", создана пользователем zen, 29 июл 2016.

  1. zen

    zen Cкладчик

    Регистрация:
    30 май 2015
    Сообщения:
    5
    Симпатии:
    0
    День добрый.
    Расширение Minitek Live Search v3.3.6 в связке в FAQ Book Pro
    Английский ищет, а вот кирилицу ищет только при контекстной подсказке.
    Т.е. когда начинаешь набирать поисковую фразу, то в ниспадающем списке появляются найденные сообщения (в моем случае Questions)
    А если нажать на поиск, то для кириллической поисковой фразы результат - NO RESULTS FOUND
    Не подскажете, где копать?
    #1
  2. ZuZu

    ZuZu Cкладчик

    Регистрация:
    11 сен 2015
    Сообщения:
    1
    Симпатии:
    2
    В версиях 3.4.7 и 3.4.8 на кириллице находятся слова не более 6 знаков.
    Решение для версии 3.4.8.
    В файле \components\com_miniteklivesearch\helpers\utilities.php следует закомментировать строки с 330 по 333.
    // Limit string length
    /*if (strlen($text) > 50)
    {
    $sanitized_text = substr($text,0,50);
    }*/
    Или изменить 50 на большее число, например 500 .
    #2
    koptevanatoliy и Ali нравится это.
  3. mastakxxx

    mastakxxx Cкладчик

    Регистрация:
    15 мар 2016
    Сообщения:
    2
    Симпатии:
    0
    В моём случае проблема была в том, что компонент видит только картинки формата JPG, PNG и GIF и статьи с этими картинками искались на русском, а с современным форматом WebP не искались. Я отключил отображение картинок при поиске в компоненте и моделе, но результата не появилось. После этого я добавил нужные строки в components/com_miniteklivesearch/helpers/phpthumb/GdThumb.inc.php
    Там поском найдите все строки где есть слово jpg, посмотрите как оформлены форматы и сделайте такие строки для своих форматов изображений. И всё заработало!
    #3
  4. mastakxxx

    mastakxxx Cкладчик

    Регистрация:
    15 мар 2016
    Сообщения:
    2
    Симпатии:
    0
    Код:
    <?php
    
    /**
    
    * @title            Minitek Live Search
    
    * @copyright           Copyright (C) 2011-2014 Minitek, All rights reserved.
    
    * @license           GNU General Public License version 3 or later.
    
    * @author url       http://www.minitek.gr/
    
    * @author email       [email protected]
    
    * @developers       Minitek.gr
    
    */
    
    
    
    /**
    
    * PhpThumb GD Thumb Class Definition File
    
    *
    
    * This file contains the definition for the GdThumb object
    
    *
    
    * PHP Version 5 with GD 2.0+
    
    * PhpThumb : PHP Thumb Library <http://phpthumb.gxdlabs.com>
    
    * Copyright (c) 2009, Ian Selby/Gen X Design
    
    *
    
    * Author(s): Ian Selby <[email protected]>
    
    *
    
    * Licensed under the MIT License
    
    * Redistributions of files must retain the above copyright notice.
    
    *
    
    * @author Ian Selby <[email protected]>
    
    * @copyright Copyright (c) 2009 Gen X Design
    
    * @link http://phpthumb.gxdlabs.com
    
    * @license http://www.opensource.org/licenses/mit-license.php The MIT License
    
    * @version 3.0
    
    * @package PhpThumb
    
    * @filesource
    
    */
    
    
    
    /**
    
    * GdThumb Class Definition
    
    *
    
    * This is the GD Implementation of the PHP Thumb library.
    
    *
    
    * @package PhpThumb
    
    * @subpackage Core
    
    */
    
    
    // no direct access
    
    defined( '_JEXEC' ) or die( 'Restricted access' );
    
    
    
    class GdThumb extends ThumbBase
    
    {
    
        /**
    
         * The prior image (before manipulation)
    
         *
    
         * @var resource
    
         */
    
        protected $oldImage;
    
        /**
    
         * The working image (used during manipulation)
    
         *
    
         * @var resource
    
         */
    
        protected $workingImage;
    
        /**
    
         * The current dimensions of the image
    
         *
    
         * @var array
    
         */
    
        protected $currentDimensions;
    
        /**
    
         * The new, calculated dimensions of the image
    
         *
    
         * @var array
    
         */
    
        protected $newDimensions;
    
        /**
    
         * The options for this class
    
         *
    
         * This array contains various options that determine the behavior in
    
         * various functions throughout the class.  Functions note which specific
    
         * option key / values are used in their documentation
    
         *
    
         * @var array
    
         */
    
        protected $options;
    
        /**
    
         * The maximum width an image can be after resizing (in pixels)
    
         *
    
         * @var int
    
         */
    
        protected $maxWidth;
    
        /**
    
         * The maximum height an image can be after resizing (in pixels)
    
         *
    
         * @var int
    
         */
    
        protected $maxHeight;
    
        /**
    
         * The percentage to resize the image by
    
         *
    
         * @var int
    
         */
    
        protected $percent;
    
       
    
        /**
    
         * Class Constructor
    
         *
    
         * @return GdThumb
    
         * @param string $fileName
    
         */
    
        public function __construct ($fileName, $options = array(), $isDataStream = false)
    
        {
    
            parent::__construct($fileName, $isDataStream);
    
           
    
            $this->determineFormat();
    
           
    
            if ($this->isDataStream === false)
    
            {
    
                $this->verifyFormatCompatiblity();
    
            }
    
           
    
            switch ($this->format)
    
            {
    
                case 'GIF':
    
                    $this->oldImage = imagecreatefromgif($this->fileName);
    
                    break;
    
                case 'JPG':
    
                    $this->oldImage = imagecreatefromjpeg($this->fileName);
    
                    break;
    
                case 'PNG':
    
                    $this->oldImage = imagecreatefrompng($this->fileName);
    
                    break;
    
                case 'STRING':
    
                    $this->oldImage = imagecreatefromstring($this->fileName);
    
                    break;
    
            }
    
       
    
            $this->currentDimensions = array
    
            (
    
                'width'     => imagesx($this->oldImage),
    
                'height'    => imagesy($this->oldImage)
    
            );
    
           
    
            $this->setOptions($options);
    
           
    
            // TODO: Port gatherImageMeta to a separate function that can be called to extract exif data
    
        }
    
       
    
        /**
    
         * Class Destructor
    
         *
    
         */
    
        public function __destruct ()
    
        {
    
            if (is_resource($this->oldImage))
    
            {
    
                imagedestroy($this->oldImage);
    
            }
    
           
    
            if (is_resource($this->workingImage))
    
            {
    
                imagedestroy($this->workingImage);
    
            }
    
        }
    
       
    
        ##############################
    
        # ----- API FUNCTIONS ------ #
    
        ##############################
    
       
    
        /**
    
         * Resizes an image to be no larger than $maxWidth or $maxHeight
    
         *
    
         * If either param is set to zero, then that dimension will not be considered as a part of the resize.
    
         * Additionally, if $this->options['resizeUp'] is set to true (false by default), then this function will
    
         * also scale the image up to the maximum dimensions provided.
    
         *
    
         * @param int $maxWidth The maximum width of the image in pixels
    
         * @param int $maxHeight The maximum height of the image in pixels
    
         * @return GdThumb
    
         */
    
        public function resize ($maxWidth = 0, $maxHeight = 0)
    
        {
    
            // make sure our arguments are valid
    
            if (!is_numeric($maxWidth))
    
            {
    
                throw new InvalidArgumentException('$maxWidth must be numeric');
    
            }
    
           
    
            if (!is_numeric($maxHeight))
    
            {
    
                throw new InvalidArgumentException('$maxHeight must be numeric');
    
            }
    
           
    
            // make sure we're not exceeding our image size if we're not supposed to
    
            if ($this->options['resizeUp'] === false)
    
            {
    
                $this->maxHeight    = (intval($maxHeight) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $maxHeight;
    
                $this->maxWidth        = (intval($maxWidth) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $maxWidth;
    
            }
    
            else
    
            {
    
                $this->maxHeight    = intval($maxHeight);
    
                $this->maxWidth        = intval($maxWidth);
    
            }
    
           
    
            // get the new dimensions...
    
            $this->calcImageSize($this->currentDimensions['width'], $this->currentDimensions['height']);
    
           
    
            // create the working image
    
            if (function_exists('imagecreatetruecolor'))
    
            {
    
                $this->workingImage = imagecreatetruecolor($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
    
            }
    
            else
    
            {
    
                $this->workingImage = imagecreate($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
    
            }
    
           
    
            $this->preserveAlpha();       
    
           
    
            // and create the newly sized image
    
            imagecopyresampled
    
            (
    
                $this->workingImage,
    
                $this->oldImage,
    
                0,
    
                0,
    
                0,
    
                0,
    
                $this->newDimensions['newWidth'],
    
                $this->newDimensions['newHeight'],
    
                $this->currentDimensions['width'],
    
                $this->currentDimensions['height']
    
            );
    
    
    
            // update all the variables and resources to be correct
    
            $this->oldImage                     = $this->workingImage;
    
            $this->currentDimensions['width']     = $this->newDimensions['newWidth'];
    
            $this->currentDimensions['height']     = $this->newDimensions['newHeight'];
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Adaptively Resizes the Image
    
         *
    
         * This function attempts to get the image to as close to the provided dimensions as possible, and then crops the
    
         * remaining overflow (from the center) to get the image to be the size specified
    
         *
    
         * @param int $maxWidth
    
         * @param int $maxHeight
    
         * @return GdThumb
    
         */
    
        public function adaptiveResize ($width, $height)
    
        {
    
            // make sure our arguments are valid
    
            if (!is_numeric($width) || $width  == 0)
    
            {
    
                throw new InvalidArgumentException('$width must be numeric and greater than zero');
    
            }
    
           
    
            if (!is_numeric($height) || $height == 0)
    
            {
    
                throw new InvalidArgumentException('$height must be numeric and greater than zero');
    
            }
    
           
    
            // make sure we're not exceeding our image size if we're not supposed to
    
            if ($this->options['resizeUp'] === false)
    
            {
    
                $this->maxHeight    = (intval($height) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $height;
    
                $this->maxWidth        = (intval($width) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $width;
    
            }
    
            else
    
            {
    
                $this->maxHeight    = intval($height);
    
                $this->maxWidth        = intval($width);
    
            }
    
           
    
            $this->calcImageSizeStrict($this->currentDimensions['width'], $this->currentDimensions['height']);
    
           
    
            // resize the image to be close to our desired dimensions
    
            $this->resize($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
    
           
    
            // reset the max dimensions...
    
            if ($this->options['resizeUp'] === false)
    
            {
    
                $this->maxHeight    = (intval($height) > $this->currentDimensions['height']) ? $this->currentDimensions['height'] : $height;
    
                $this->maxWidth        = (intval($width) > $this->currentDimensions['width']) ? $this->currentDimensions['width'] : $width;
    
            }
    
            else
    
            {
    
                $this->maxHeight    = intval($height);
    
                $this->maxWidth        = intval($width);
    
            }
    
           
    
            // create the working image
    
            if (function_exists('imagecreatetruecolor'))
    
            {
    
                $this->workingImage = imagecreatetruecolor($this->maxWidth, $this->maxHeight);
    
            }
    
            else
    
            {
    
                $this->workingImage = imagecreate($this->maxWidth, $this->maxHeight);
    
            }
    
           
    
            $this->preserveAlpha();
    
           
    
            $cropWidth    = $this->maxWidth;
    
            $cropHeight    = $this->maxHeight;
    
            $cropX         = 0;
    
            $cropY         = 0;
    
           
    
            // now, figure out how to crop the rest of the image...
    
            if ($this->currentDimensions['width'] > $this->maxWidth)
    
            {
    
                $cropX = intval(($this->currentDimensions['width'] - $this->maxWidth) / 2);
    
            }
    
            elseif ($this->currentDimensions['height'] > $this->maxHeight)
    
            {
    
                $cropY = intval(($this->currentDimensions['height'] - $this->maxHeight) / 2);
    
            }
    
           
    
            imagecopyresampled
    
            (
    
                $this->workingImage,
    
                $this->oldImage,
    
                0,
    
                0,
    
                $cropX,
    
                $cropY,
    
                $cropWidth,
    
                $cropHeight,
    
                $cropWidth,
    
                $cropHeight
    
            );
    
           
    
            // update all the variables and resources to be correct
    
            $this->oldImage                     = $this->workingImage;
    
            $this->currentDimensions['width']     = $this->maxWidth;
    
            $this->currentDimensions['height']     = $this->maxHeight;
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Resizes an image by a given percent uniformly
    
         *
    
         * Percentage should be whole number representation (i.e. 1-100)
    
         *
    
         * @param int $percent
    
         * @return GdThumb
    
         */
    
        public function resizePercent ($percent = 0)
    
        {
    
            if (!is_numeric($percent))
    
            {
    
                throw new InvalidArgumentException ('$percent must be numeric');
    
            }
    
           
    
            $this->percent = intval($percent);
    
           
    
            $this->calcImageSizePercent($this->currentDimensions['width'], $this->currentDimensions['height']);
    
           
    
            if (function_exists('imagecreatetruecolor'))
    
            {
    
                $this->workingImage = imagecreatetruecolor($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
    
            }
    
            else
    
            {
    
                $this->workingImage = imagecreate($this->newDimensions['newWidth'], $this->newDimensions['newHeight']);
    
            }
    
           
    
            $this->preserveAlpha();
    
           
    
            ImageCopyResampled(
    
                $this->workingImage,
    
                $this->oldImage,
    
                0,
    
                0,
    
                0,
    
                0,
    
                $this->newDimensions['newWidth'],
    
                $this->newDimensions['newHeight'],
    
                $this->currentDimensions['width'],
    
                $this->currentDimensions['height']
    
            );
    
    
    
            $this->oldImage                     = $this->workingImage;
    
            $this->currentDimensions['width']     = $this->newDimensions['newWidth'];
    
            $this->currentDimensions['height']     = $this->newDimensions['newHeight'];
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Crops an image from the center with provided dimensions
    
         *
    
         * If no height is given, the width will be used as a height, thus creating a square crop
    
         *
    
         * @param int $cropWidth
    
         * @param int $cropHeight
    
         * @return GdThumb
    
         */
    
        public function cropFromCenter ($cropWidth, $cropHeight = null)
    
        {
    
            if (!is_numeric($cropWidth))
    
            {
    
                throw new InvalidArgumentException('$cropWidth must be numeric');
    
            }
    
           
    
            if ($cropHeight !== null && !is_numeric($cropHeight))
    
            {
    
                throw new InvalidArgumentException('$cropHeight must be numeric');
    
            }
    
           
    
            if ($cropHeight === null)
    
            {
    
                $cropHeight = $cropWidth;
    
            }
    
           
    
            $cropWidth    = ($this->currentDimensions['width'] < $cropWidth) ? $this->currentDimensions['width'] : $cropWidth;
    
            $cropHeight = ($this->currentDimensions['height'] < $cropHeight) ? $this->currentDimensions['height'] : $cropHeight;
    
           
    
            $cropX = intval(($this->currentDimensions['width'] - $cropWidth) / 2);
    
            $cropY = intval(($this->currentDimensions['height'] - $cropHeight) / 2);
    
           
    
            $this->crop($cropX, $cropY, $cropWidth, $cropHeight);
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Vanilla Cropping - Crops from x,y with specified width and height
    
         *
    
         * @param int $startX
    
         * @param int $startY
    
         * @param int $cropWidth
    
         * @param int $cropHeight
    
         * @return GdThumb
    
         */
    
        public function crop ($startX, $startY, $cropWidth, $cropHeight)
    
        {
    
            // validate input
    
            if (!is_numeric($startX))
    
            {
    
                throw new InvalidArgumentException('$startX must be numeric');
    
            }
    
           
    
            if (!is_numeric($startY))
    
            {
    
                throw new InvalidArgumentException('$startY must be numeric');
    
            }
    
           
    
            if (!is_numeric($cropWidth))
    
            {
    
                throw new InvalidArgumentException('$cropWidth must be numeric');
    
            }
    
           
    
            if (!is_numeric($cropHeight))
    
            {
    
                throw new InvalidArgumentException('$cropHeight must be numeric');
    
            }
    
           
    
            // do some calculations
    
            $cropWidth    = ($this->currentDimensions['width'] < $cropWidth) ? $this->currentDimensions['width'] : $cropWidth;
    
            $cropHeight = ($this->currentDimensions['height'] < $cropHeight) ? $this->currentDimensions['height'] : $cropHeight;
    
           
    
            // ensure everything's in bounds
    
            if (($startX + $cropWidth) > $this->currentDimensions['width'])
    
            {
    
                $startX = ($this->currentDimensions['width'] - $cropWidth);
    
               
    
            }
    
           
    
            if (($startY + $cropHeight) > $this->currentDimensions['height'])
    
            {
    
                $startY = ($this->currentDimensions['height'] - $cropHeight);
    
            }
    
           
    
            if ($startX < 0)
    
            {
    
                $startX = 0;
    
            }
    
           
    
            if ($startY < 0)
    
            {
    
                $startY = 0;
    
            }
    
           
    
            // create the working image
    
            if (function_exists('imagecreatetruecolor'))
    
            {
    
                $this->workingImage = imagecreatetruecolor($cropWidth, $cropHeight);
    
            }
    
            else
    
            {
    
                $this->workingImage = imagecreate($cropWidth, $cropHeight);
    
            }
    
           
    
            $this->preserveAlpha();
    
           
    
            imagecopyresampled
    
            (
    
                $this->workingImage,
    
                $this->oldImage,
    
                0,
    
                0,
    
                $startX,
    
                $startY,
    
                $cropWidth,
    
                $cropHeight,
    
                $cropWidth,
    
                $cropHeight
    
            );
    
           
    
            $this->oldImage                     = $this->workingImage;
    
            $this->currentDimensions['width']     = $cropWidth;
    
            $this->currentDimensions['height']     = $cropHeight;
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Rotates image either 90 degrees clockwise or counter-clockwise
    
         *
    
         * @param string $direction
    
         * @retunrn GdThumb
    
         */
    
        public function rotateImage ($direction = 'CW')
    
        {
    
            if ($direction == 'CW')
    
            {
    
                $this->rotateImageNDegrees(90);
    
            }
    
            else
    
            {
    
                $this->rotateImageNDegrees(-90);
    
            }
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Rotates image specified number of degrees
    
         *
    
         * @param int $degrees
    
         * @return GdThumb
    
         */
    
        public function rotateImageNDegrees ($degrees)
    
        {
    
            if (!is_numeric($degrees))
    
            {
    
                throw new InvalidArgumentException('$degrees must be numeric');
    
            }
    
           
    
            if (!function_exists('imagerotate'))
    
            {
    
                throw new RuntimeException('Your version of GD does not support image rotation.');
    
            }
    
           
    
            $this->workingImage = imagerotate($this->oldImage, $degrees, 0);
    
           
    
            $newWidth                             = $this->currentDimensions['height'];
    
            $newHeight                             = $this->currentDimensions['width'];
    
            $this->oldImage                     = $this->workingImage;
    
            $this->currentDimensions['width']     = $newWidth;
    
            $this->currentDimensions['height']     = $newHeight;
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Shows an image
    
         *
    
         * This function will show the current image by first sending the appropriate header
    
         * for the format, and then outputting the image data. If headers have already been sent,
    
         * a runtime exception will be thrown
    
         *
    
         * @param bool $rawData Whether or not the raw image stream should be output
    
         * @return GdThumb
    
         */
    
        public function show ($rawData = false)
    
        {
    
            if (headers_sent())
    
            {
    
                throw new RuntimeException('Cannot show image, headers have already been sent');
    
            }
    
           
    
            switch ($this->format)
    
            {
    
                case 'GIF':
    
                    if ($rawData === false)
    
                    {
    
                        header('Content-type: image/gif');
    
                    }
    
                    imagegif($this->oldImage);
    
                    break;
    
                case 'JPG':
    
                    if ($rawData === false)
    
                    {
    
                        header('Content-type: image/jpeg');
    
                    }
    
                    imagejpeg($this->oldImage, null, $this->options['jpegQuality']);
    
                    break;
    
                case 'PNG':
    
                case 'STRING':
    
                    if ($rawData === false)
    
                    {
    
                        header('Content-type: image/png');
    
                    }
    
                    imagepng($this->oldImage);
    
                    break;
    
            }
    
           
    
            return $this;
    
        }
    
       
    
        /**
    
         * Returns the Working Image as a String
    
         *
    
         * This function is useful for getting the raw image data as a string for storage in
    
         * a database, or other similar things.
    
         *
    
         * @return string
    
         */
    
        public function getImageAsString ()
    
        {
    
            $data = null;
    
            ob_start();
    
            $this->show(true);
    
            $data = ob_get_contents();
    
            ob_end_clean();
    
           
    
            return $data;
    
        }
    
       
    
        /**
    
         * Saves an image
    
         *
    
         * This function will make sure the target directory is writeable, and then save the image.
    
         *
    
         * If the target directory is not writeable, the function will try to correct the permissions (if allowed, this
    
         * is set as an option ($this->options['correctPermissions']).  If the target cannot be made writeable, then a
    
         * RuntimeException is thrown.
    
         *
    
         * TODO: Create additional paramter for color matte when saving images with alpha to non-alpha formats (i.e. PNG => JPG)
    
         *
    
         * @param string $fileName The full path and filename of the image to save
    
         * @param string $format The format to save the image in (optional, must be one of [GIF,JPG,PNG]
    
         * @return GdThumb
    
         */
    
        public function save ($fileName, $format = null)
    
        {
    
            $validFormats = array('GIF', 'JPG', 'PNG', 'webp');
    
            $format = ($format !== null) ? strtoupper($format) : $this->format;
    
           
    
            if (!in_array($format, $validFormats))
    
            {
    
                throw new InvalidArgumentException ('Invalid format type specified in save function: ' . $format);
    
            }
    
           
    
            // make sure the directory is writeable
    
            if (!is_writeable(dirname($fileName)))
    
            {
    
                // try to correct the permissions
    
                if ($this->options['correctPermissions'] === true)
    
                {
    
                    @chmod(dirname($fileName), 0777);
    
                   
    
                    // throw an exception if not writeable
    
                    if (!is_writeable(dirname($fileName)))
    
                    {
    
                        throw new RuntimeException ('File is not writeable, and could not correct permissions: ' . $fileName);
    
                    }
    
                }
    
                // throw an exception if not writeable
    
                else
    
                {
    
                    throw new RuntimeException ('File not writeable: ' . $fileName);
    
                }
    
            }
    
           
    
            switch ($format)
    
            {
    
                case 'GIF':
    
                    imagegif($this->oldImage, $fileName);
    
                    break;
    
                case 'JPG':
    
                    imagejpeg($this->oldImage, $fileName, $this->options['jpegQuality']);
    
                    break;
    
                case 'PNG':
    
                    imagepng($this->oldImage, $fileName);
    
                    break;
                   
                        case 'webp':
    
                    imagepng($this->oldImage, $fileName);
    
                    break;
    
            }
    
           
    
            return $this;
    
        }
    
       
    
        #################################
    
        # ----- GETTERS / SETTERS ----- #
    
        #################################
    
       
    
        /**
    
         * Sets $this->options to $options
    
         *
    
         * @param array $options
    
         */
    
        public function setOptions ($options = array())
    
        {
    
            // make sure we've got an array for $this->options (could be null)
    
            if (!is_array($this->options))
    
            {
    
                $this->options = array();
    
            }
    
           
    
            // make sure we've gotten a proper argument
    
            if (!is_array($options))
    
            {
    
                throw new InvalidArgumentException ('setOptions requires an array');
    
            }
    
           
    
            // we've yet to init the default options, so create them here
    
            if (sizeof($this->options) == 0)
    
            {
    
                $defaultOptions = array
    
                (
    
                    'resizeUp'                => true,
    
                    'jpegQuality'            => 100,
    
                    'correctPermissions'    => false,
    
                    'preserveAlpha'            => true,
    
                    'alphaMaskColor'        => array (255, 255, 255),
    
                    'preserveTransparency'    => true,
    
                    'transparencyMaskColor'    => array (0, 0, 0)
    
                );
    
            }
    
            // otherwise, let's use what we've got already
    
            else
    
            {
    
                $defaultOptions = $this->options;
    
            }
    
           
    
            $this->options = array_merge($defaultOptions, $options);
    
        }
    
       
    
        /**
    
         * Returns $currentDimensions.
    
         *
    
         * @see GdThumb::$currentDimensions
    
         */
    
        public function getCurrentDimensions ()
    
        {
    
            return $this->currentDimensions;
    
        }
    
       
    
        /**
    
         * Sets $currentDimensions.
    
         *
    
         * @param object $currentDimensions
    
         * @see GdThumb::$currentDimensions
    
         */
    
        public function setCurrentDimensions ($currentDimensions)
    
        {
    
            $this->currentDimensions = $currentDimensions;
    
        }
    
       
    
        /**
    
         * Returns $maxHeight.
    
         *
    
         * @see GdThumb::$maxHeight
    
         */
    
        public function getMaxHeight ()
    
        {
    
            return $this->maxHeight;
    
        }
    
       
    
        /**
    
         * Sets $maxHeight.
    
         *
    
         * @param object $maxHeight
    
         * @see GdThumb::$maxHeight
    
         */
    
        public function setMaxHeight ($maxHeight)
    
        {
    
            $this->maxHeight = $maxHeight;
    
        }
    
       
    
        /**
    
         * Returns $maxWidth.
    
         *
    
         * @see GdThumb::$maxWidth
    
         */
    
        public function getMaxWidth ()
    
        {
    
            return $this->maxWidth;
    
        }
    
       
    
        /**
    
         * Sets $maxWidth.
    
         *
    
         * @param object $maxWidth
    
         * @see GdThumb::$maxWidth
    
         */
    
        public function setMaxWidth ($maxWidth)
    
        {
    
            $this->maxWidth = $maxWidth;
    
        }
    
       
    
        /**
    
         * Returns $newDimensions.
    
         *
    
         * @see GdThumb::$newDimensions
    
         */
    
        public function getNewDimensions ()
    
        {
    
            return $this->newDimensions;
    
        }
    
       
    
        /**
    
         * Sets $newDimensions.
    
         *
    
         * @param object $newDimensions
    
         * @see GdThumb::$newDimensions
    
         */
    
        public function setNewDimensions ($newDimensions)
    
        {
    
            $this->newDimensions = $newDimensions;
    
        }
    
       
    
        /**
    
         * Returns $options.
    
         *
    
         * @see GdThumb::$options
    
         */
    
        public function getOptions ()
    
        {
    
            return $this->options;
    
        }
    
       
    
        /**
    
         * Returns $percent.
    
         *
    
         * @see GdThumb::$percent
    
         */
    
        public function getPercent ()
    
        {
    
            return $this->percent;
    
        }
    
       
    
        /**
    
         * Sets $percent.
    
         *
    
         * @param object $percent
    
         * @see GdThumb::$percent
    
         */
    
        public function setPercent ($percent)
    
        {
    
            $this->percent = $percent;
    
        }
    
       
    
        /**
    
         * Returns $oldImage.
    
         *
    
         * @see GdThumb::$oldImage
    
         */
    
        public function getOldImage ()
    
        {
    
            return $this->oldImage;
    
        }
    
       
    
        /**
    
         * Sets $oldImage.
    
         *
    
         * @param object $oldImage
    
         * @see GdThumb::$oldImage
    
         */
    
        public function setOldImage ($oldImage)
    
        {
    
            $this->oldImage = $oldImage;
    
        }
    
       
    
        /**
    
         * Returns $workingImage.
    
         *
    
         * @see GdThumb::$workingImage
    
         */
    
        public function getWorkingImage ()
    
        {
    
            return $this->workingImage;
    
        }
    
       
    
        /**
    
         * Sets $workingImage.
    
         *
    
         * @param object $workingImage
    
         * @see GdThumb::$workingImage
    
         */
    
        public function setWorkingImage ($workingImage)
    
        {
    
            $this->workingImage = $workingImage;
    
        }
    
       
    
       
    
        #################################
    
        # ----- UTILITY FUNCTIONS ----- #
    
        #################################
    
       
    
        /**
    
         * Calculates a new width and height for the image based on $this->maxWidth and the provided dimensions
    
         *
    
         * @return array
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcWidth ($width, $height)
    
        {
    
            $newWidthPercentage    = (100 * $this->maxWidth) / $width;
    
            $newHeight            = ($height * $newWidthPercentage) / 100;
    
           
    
            return array
    
            (
    
                'newWidth'    => intval($this->maxWidth),
    
                'newHeight'    => intval($newHeight)
    
            );
    
        }
    
       
    
        /**
    
         * Calculates a new width and height for the image based on $this->maxWidth and the provided dimensions
    
         *
    
         * @return array
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcHeight ($width, $height)
    
        {
    
            $newHeightPercentage    = (100 * $this->maxHeight) / $height;
    
            $newWidth                 = ($width * $newHeightPercentage) / 100;
    
           
    
            return array
    
            (
    
                'newWidth'    => ceil($newWidth),
    
                'newHeight'    => ceil($this->maxHeight)
    
            );
    
        }
    
       
    
        /**
    
         * Calculates a new width and height for the image based on $this->percent and the provided dimensions
    
         *
    
         * @return array
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcPercent ($width, $height)
    
        {
    
            $newWidth    = ($width * $this->percent) / 100;
    
            $newHeight    = ($height * $this->percent) / 100;
    
           
    
            return array
    
            (
    
                'newWidth'    => ceil($newWidth),
    
                'newHeight'    => ceil($newHeight)
    
            );
    
        }
    
       
    
        /**
    
         * Calculates the new image dimensions
    
         *
    
         * These calculations are based on both the provided dimensions and $this->maxWidth and $this->maxHeight
    
         *
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcImageSize ($width, $height)
    
        {
    
            $newSize = array
    
            (
    
                'newWidth'    => $width,
    
                'newHeight'    => $height
    
            );
    
           
    
            if ($this->maxWidth > 0)
    
            {
    
                $newSize = $this->calcWidth($width, $height);
    
               
    
                if ($this->maxHeight > 0 && $newSize['newHeight'] > $this->maxHeight)
    
                {
    
                    $newSize = $this->calcHeight($newSize['newWidth'], $newSize['newHeight']);
    
                }
    
            }
    
           
    
            if ($this->maxHeight > 0)
    
            {
    
                $newSize = $this->calcHeight($width, $height);
    
               
    
                if ($this->maxWidth > 0 && $newSize['newWidth'] > $this->maxWidth)
    
                {
    
                    $newSize = $this->calcWidth($newSize['newWidth'], $newSize['newHeight']);
    
                }
    
            }
    
           
    
            $this->newDimensions = $newSize;
    
        }
    
       
    
        /**
    
         * Calculates new image dimensions, not allowing the width and height to be less than either the max width or height
    
         *
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcImageSizeStrict ($width, $height)
    
        {
    
            // first, we need to determine what the longest resize dimension is..
    
            if ($this->maxWidth >= $this->maxHeight)
    
            {
    
                // and determine the longest original dimension
    
                if ($width > $height)
    
                {
    
                    $newDimensions = $this->calcHeight($width, $height);
    
                   
    
                    if ($newDimensions['newWidth'] < $this->maxWidth)
    
                    {
    
                        $newDimensions = $this->calcWidth($width, $height);
    
                    }
    
                }
    
                elseif ($height >= $width)
    
                {
    
                    $newDimensions = $this->calcWidth($width, $height);
    
                   
    
                    if ($newDimensions['newHeight'] < $this->maxHeight)
    
                    {
    
                        $newDimensions = $this->calcHeight($width, $height);
    
                    }
    
                }
    
            }
    
            elseif ($this->maxHeight > $this->maxWidth)
    
            {
    
                if ($width >= $height)
    
                {
    
                    $newDimensions = $this->calcWidth($width, $height);
    
                   
    
                    if ($newDimensions['newHeight'] < $this->maxHeight)
    
                    {
    
                        $newDimensions = $this->calcHeight($width, $height);
    
                    }
    
                }
    
                elseif ($height > $width)
    
                {
    
                    $newDimensions = $this->calcHeight($width, $height);
    
                   
    
                    if ($newDimensions['newWidth'] < $this->maxWidth)
    
                    {
    
                        $newDimensions = $this->calcWidth($width, $height);
    
                    }
    
                }
    
            }
    
           
    
            $this->newDimensions = $newDimensions;
    
        }
    
       
    
        /**
    
         * Calculates new dimensions based on $this->percent and the provided dimensions
    
         *
    
         * @param int $width
    
         * @param int $height
    
         */
    
        protected function calcImageSizePercent ($width, $height)
    
        {
    
            if ($this->percent > 0)
    
            {
    
                $this->newDimensions = $this->calcPercent($width, $height);
    
            }
    
        }
    
       
    
        /**
    
         * Determines the file format by mime-type
    
         *
    
         * This function will throw exceptions for invalid images / mime-types
    
         *
    
         */
    
        protected function determineFormat ()
    
        {
    
            if ($this->isDataStream === true)
    
            {
    
                $this->format = 'STRING';
    
                return;
    
            }
    
           
    
            $formatInfo = getimagesize($this->fileName);
    
           
    
            // non-image files will return false
    
            if ($formatInfo === false)
    
            {
    
                if ($this->remoteImage)
    
                {
    
                    $this->triggerError('Could not determine format of remote image: ' . $this->fileName);
    
                }
    
                else
    
                {
    
                    $this->triggerError('File is not a valid image: ' . $this->fileName);
    
                }
    
               
    
                // make sure we really stop execution
    
                return;
    
            }
    
           
    
            $mimeType = isset($formatInfo['mime']) ? $formatInfo['mime'] : null;
    
           
    
            switch ($mimeType)
    
            {
    
                case 'image/gif':
    
                    $this->format = 'GIF';
    
                    break;
    
                case 'image/jpeg':
    
                    $this->format = 'JPG';
    
                    break;
    
                case 'image/png':
    
                    $this->format = 'PNG';
    
                    break;
                   
                        case 'image/webp':
    
                    $this->format = 'webp';
    
                    break;
    
                default:
    
                    $this->triggerError('Image format not supported: ' . $mimeType);
    
            }
    
        }
    
       
    
        /**
    
         * Makes sure the correct GD implementation exists for the file type
    
         *
    
         */
    
        protected function verifyFormatCompatiblity ()
    
        {
    
            $isCompatible     = true;
    
            $gdInfo            = gd_info();
    
           
    
            switch ($this->format)
    
            {
    
                case 'GIF':
    
                    $isCompatible = $gdInfo['GIF Create Support'];
    
                    break;
    
                case 'JPG':
    
                    $isCompatible = (isset($gdInfo['JPG Support']) || isset($gdInfo['JPEG Support'])) ? true : false;
    
                    break;
    
                case 'PNG':
    
                    $isCompatible = $gdInfo[$this->format . ' Support'];
    
                    break;
    
                default:
    
                    $isCompatible = false;
    
            }
    
           
    
            if (!$isCompatible)
    
            {
    
                // one last check for "JPEG" instead
    
                $isCompatible = $gdInfo['JPEG Support'];
    
               
    
                if (!$isCompatible)
    
                {
    
                    $this->triggerError('Your GD installation does not support ' . $this->format . ' image types');
    
                }
    
            }
    
        }
    
       
    
        /**
    
         * Preserves the alpha or transparency for PNG and GIF files
    
         *
    
         * Alpha / transparency will not be preserved if the appropriate options are set to false.
    
         * Also, the GIF transparency is pretty skunky (the results aren't awesome), but it works like a
    
         * champ... that's the nature of GIFs tho, so no huge surprise.
    
         *
    
         * This functionality was originally suggested by commenter Aimi (no links / site provided) - Thanks! :)
    
         *  
    
         */
    
        protected function preserveAlpha ()
    
        {
    
            if ($this->format == 'PNG' && $this->options['preserveAlpha'] === true)
    
            {
    
                imagealphablending($this->workingImage, false);
    
               
    
                $colorTransparent = imagecolorallocatealpha
    
                (
    
                    $this->workingImage,
    
                    $this->options['alphaMaskColor'][0],
    
                    $this->options['alphaMaskColor'][1],
    
                    $this->options['alphaMaskColor'][2],
    
                    0
    
                );
    
               
    
                imagefill($this->workingImage, 0, 0, $colorTransparent);
    
                imagesavealpha($this->workingImage, true);
    
            }
    
            // preserve transparency in GIFs... this is usually pretty rough tho
    
            if ($this->format == 'GIF' && $this->options['preserveTransparency'] === true)
    
            {
    
                $colorTransparent = imagecolorallocate
    
                (
    
                    $this->workingImage,
    
                    $this->options['transparencyMaskColor'][0],
    
                    $this->options['transparencyMaskColor'][1],
    
                    $this->options['transparencyMaskColor'][2]
    
                );
    
               
    
                imagecolortransparent($this->workingImage, $colorTransparent);
    
                imagetruecolortopalette($this->workingImage, true, 256);
    
            }
    
        }
    
    }
    #4