source: branches/ray/plugins/ImageManager/Classes/ImageEditor.php @ 761

Last change on this file since 761 was 761, checked in by ray, 13 years ago

updated branch

  • Property svn:keywords set to LastChangedDate LastChangedRevision LastChangedBy HeadURL Id
File size: 22.1 KB
Line 
1<<<<<<< .working
2<?php
3/**
4 * Image Editor. Editing tools, crop, rotate, scale and save.
5 * @author $Author$
6 * @version $Id$
7 * @package ImageManager
8 */
9
10require_once('Transform.php');
11
12/**
13 * Handles the basic image editing capbabilities.
14 * @author $Author$
15 * @version $Id$
16 * @package ImageManager
17 * @subpackage Editor
18 */
19class ImageEditor
20{
21        /**
22         * ImageManager instance.
23         */
24        var $manager;
25
26        /**
27         * user based on IP address
28         */
29        var $_uid;
30
31        /**
32         * tmp file storage time.
33         */
34        var $lapse_time =900; //15 mins
35
36        var $filesaved = 0;
37
38        /**
39         * Create a new ImageEditor instance. Editing requires a
40         * tmp file, which is saved in the current directory where the
41         * image is edited. The tmp file is assigned by md5 hash of the
42         * user IP address. This hashed is used as an ID for cleaning up
43         * the tmp files. In addition, any tmp files older than the
44         * the specified period will be deleted.
45         * @param ImageManager $manager the image manager, we need this
46         * for some file and path handling functions.
47         */
48        function ImageEditor($manager)
49        {
50                $this->manager = $manager;
51                $this->_uid = md5($_SERVER['REMOTE_ADDR']);
52        }
53       
54        /**
55         * Did we save a file?
56         * @return int 1 if the file was saved sucessfully,
57         * 0 no save operation, -1 file save error.
58         */
59        function isFileSaved()
60        {
61                Return $this->filesaved;
62        }
63
64        /**
65         * Process the image, if not action, just display the image.
66         * @return array with image information, empty array if not an image.
67         * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
68         * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
69         */
70        function processImage()
71        {
72                if(isset($_GET['img']))
73                        $relative = rawurldecode($_GET['img']);
74                else
75                        Return array();
76               
77                //$relative = '/Series2004NoteFront.jpg';
78
79                $imgURL = $this->manager->getFileURL($relative);
80                $fullpath = $this->manager->getFullPath($relative);
81               
82                $imgInfo = @getImageSize($fullpath);
83                if(!is_array($imgInfo))
84                        Return array();
85
86                $action = $this->getAction();
87
88                if(!is_null($action))
89                {
90                        $image = $this->processAction($action, $relative, $fullpath);
91                }
92                else
93                {
94                        $image['src'] = $imgURL;
95                        $image['dimensions'] = $imgInfo[3];
96                        $image['file'] = $relative;
97                        $image['fullpath'] = $fullpath;
98                }
99
100                Return $image;
101        }
102
103        /**
104         * Process the actions, crop, scale(resize), rotate, flip, and save.
105         * When ever an action is performed, the result is save into a
106         * temporary image file, see createUnique on the filename specs.
107         * It does not return the saved file, alway returning the tmp file.
108         * @param string $action, should be 'crop', 'scale', 'rotate','flip', or 'save'
109         * @param string $relative the relative image filename
110         * @param string $fullpath the fullpath to the image file
111         * @return array with image information
112         * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
113         * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
114         */
115        function processAction($action, $relative, $fullpath)
116        {
117                $params = '';
118               
119                if(isset($_GET['params']))
120                        $params = $_GET['params'];
121
122                $values =  explode(',',$params,4);
123                $saveFile = $this->getSaveFileName($values[0]);
124
125                $img = Image_Transform::factory(IMAGE_CLASS);
126                $img->load($fullpath);
127
128                switch ($action)
129                {
130                        case 'crop':
131                                $img->crop(intval($values[0]),intval($values[1]),
132                                                        intval($values[2]),intval($values[3]));
133                        break;
134                        case 'scale':
135                                $img->resize(intval($values[0]),intval($values[1]));
136                                break;
137                        case 'rotate':
138                                $img->rotate(floatval($values[0]));
139                                break;
140                        case 'flip':
141                                if ($values[0] == 'hoz')
142                                        $img->flip(true);
143                                else if($values[0] == 'ver')
144                                        $img->flip(false);
145                                break;
146                        case 'save':
147                                if(!is_null($saveFile))
148                                {
149                                        $quality = intval($values[1]);
150                            if($quality <0) $quality = 85;
151                                        $newSaveFile = $this->makeRelative($relative, $saveFile);
152                                        $newSaveFile = $this->getUniqueFilename($newSaveFile);
153                                       
154                                        //get unique filename just returns the filename, so
155                                        //we need to make the relative path once more.
156                                        $newSaveFile = $this->makeRelative($relative, $newSaveFile);
157          $image['saveFile'] = $newSaveFile;
158                                        $newSaveFullpath = $this->manager->getFullPath($newSaveFile);
159                                        $img->save($newSaveFullpath, $values[0], $quality);
160                                        if(is_file($newSaveFullpath))
161                                                $this->filesaved = 1;
162                                        else
163                                                $this->filesaved = -1;
164                                }
165                                break;
166                }
167               
168                //create the tmp image file
169                $filename = $this->createUnique($fullpath);
170                $newRelative = $this->makeRelative($relative, $filename);
171                $newFullpath = $this->manager->getFullPath($newRelative);
172                $newURL = $this->manager->getFileURL($newRelative);
173               
174                //save the file.
175                $img->save($newFullpath);
176                $img->free();
177
178                //get the image information
179                $imgInfo = @getimagesize($newFullpath);
180
181                $image['src'] = $newURL;
182    $image['width'] = $imgInfo[0];
183    $image['height'] = $imgInfo[1];
184                $image['dimensions'] = $imgInfo[3];
185                $image['file'] = $newRelative;
186                $image['fullpath'] = $newFullpath;
187
188                Return $image;
189       
190        }
191
192        /**
193         * Get the file name base on the save name
194         * and the save type.
195         * @param string $type image type, 'jpeg', 'png', or 'gif'
196         * @return string the filename according to save type
197         */
198        function getSaveFileName($type)
199        {
200                if(!isset($_GET['file']))
201                        Return null;
202
203                $filename = Files::escape(rawurldecode($_GET['file']));
204                $index = strrpos($filename,'.');
205                $base = substr($filename,0,$index);
206                $ext = strtolower(substr($filename,$index+1,strlen($filename)));
207
208                if($type == 'jpeg' && !($ext=='jpeg' || $ext=='jpg'))
209                {
210                        Return $base.'.jpeg';
211                }
212                if($type=='png' && $ext != 'png')
213                        Return $base.'.png';
214                if($type=='gif' && $ext != 'gif')
215                        Return $base.'.gif';
216
217                Return $filename;
218        }
219
220        /**
221         * Get the default save file name, used by editor.php.
222         * @return string a suggestive filename, this should be unique
223         */
224        function getDefaultSaveFile()
225        {
226                if(isset($_GET['img']))
227                        $relative = rawurldecode($_GET['img']);
228                else
229                        Return null;
230
231                Return $this->getUniqueFilename($relative);
232        }
233
234        /**
235         * Get a unique filename. If the file exists, the filename
236         * base is appended with an increasing integer.
237         * @param string $relative the relative filename to the base_dir
238         * @return string a unique filename in the current path
239         */
240        function getUniqueFilename($relative)
241        {
242                $fullpath = $this->manager->getFullPath($relative);
243               
244                $pathinfo = pathinfo($fullpath);
245
246                $path = Files::fixPath($pathinfo['dirname']);
247                $file = Files::escape($pathinfo['basename']);
248               
249                $filename = $file;
250
251                $dotIndex = strrpos($file, '.');
252                $ext = '';
253
254                if(is_int($dotIndex))
255                {
256                        $ext = substr($file, $dotIndex);
257                        $base = substr($file, 0, $dotIndex);
258                }
259
260                $counter = 0;
261                while(is_file($path.$filename))
262                {
263                        $counter++;
264                        $filename = $base.'_'.$counter.$ext;
265                }
266               
267                Return $filename;
268               
269        }
270
271        /**
272         * Specifiy the original relative path, a new filename
273         * and return the new filename with relative path.
274         * i.e. $pathA (-filename) + $file
275         * @param string $pathA the relative file
276         * @param string $file the new filename
277         * @return string relative path with the new filename
278         */
279        function makeRelative($pathA, $file)
280        {
281                $index = strrpos($pathA,'/');
282                if(!is_int($index))
283                        Return $file;
284
285                $path = substr($pathA, 0, $index);
286                Return Files::fixPath($path).$file;
287        }
288
289        /**
290         * Get the action GET parameter
291         * @return string action parameter
292         */
293        function getAction()
294        {
295                $action = null;
296                if(isset($_GET['action']))
297                        $action = $_GET['action'];
298                Return $action;
299        }
300
301        /**
302         * Generate a unique string based on md5(microtime()).
303         * Well not so uniqe, as it is limited to 6 characters
304         * @return string unique string.
305         */
306    function uniqueStr()
307    {
308      return substr(md5(microtime()),0,6);
309    }
310
311        /**
312         * Create unique tmp image file name.
313         * The filename is based on the tmp file prefix
314         * specified in config.inc.php plus
315         * the UID (basically a md5 of the remote IP)
316         * and some random 6 character string.
317         * This function also calls to clean up the tmp files.
318         * @param string $file the fullpath to a file
319         * @return string a unique filename for that path
320         * NOTE: it only returns the filename, path no included.
321         */
322        function createUnique($file)
323        {
324                $pathinfo = pathinfo($file);
325                $path = Files::fixPath($pathinfo['dirname']);
326                $imgType = $this->getImageType($file);
327
328                $unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;
329
330           //make sure the the unique temp file does not exists
331        while (file_exists($path.$unique_str))
332        {
333            $unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;
334        }
335
336                $this->cleanUp($path,$pathinfo['basename']);
337
338                Return $unique_str;
339        }
340
341        /**
342         * Delete any tmp image files.
343         * @param string $path the full path
344         * where the clean should take place.
345         */
346        function cleanUp($path,$file)
347        {
348                $path = Files::fixPath($path);
349
350                if(!is_dir($path))
351                        Return false;
352
353                $d = @dir($path);
354               
355                $tmp = $this->manager->getTmpPrefix();
356                $tmpLen = strlen($tmp);
357
358                $prefix = $tmp.$this->_uid;
359                $len = strlen($prefix);
360
361                while (false !== ($entry = $d->read()))
362                {
363                        //echo $entry."<br>";
364                        if(is_file($path.$entry) && $this->manager->isTmpFile($entry))
365                        {
366                                if(substr($entry,0,$len)==$prefix && $entry != $file)
367                                        Files::delFile($path.$entry);
368                                else if(substr($entry,0,$tmpLen)==$tmp && $entry != $file)
369                                {
370                                        if(filemtime($path.$entry)+$this->lapse_time < time())
371                                                Files::delFile($path.$entry);
372                                }
373                        }
374                }
375                $d->close();
376        }
377
378        /**
379         * Get the image type base on an image file.
380         * @param string $file the full path to the image file.
381         * @return string of either 'gif', 'jpeg', 'png' or 'bmp'
382         * otherwise it will return null.
383         */
384        function getImageType($file)
385        {
386                $imageInfo = @getImageSize($file);
387
388                if(!is_array($imageInfo))
389                        Return null;
390
391                switch($imageInfo[2])
392                {
393                        case 1:
394                                Return 'gif';
395                        case 2:
396                                Return 'jpeg';
397                        case 3:
398                                Return 'png';
399                        case 6:
400                                Return 'bmp';
401                }
402
403                Return null;
404        }
405
406        /**
407         * Check if the specified image can be edit by GD
408         * mainly to check that GD can read and save GIFs
409         * @return int 0 if it is not a GIF file, 1 is GIF is editable, -1 if not editable.
410         */
411        function isGDEditable()
412        {
413                if(isset($_GET['img']))
414                        $relative = rawurldecode($_GET['img']);
415                else
416                        Return 0;
417                if(IMAGE_CLASS != 'GD')
418                        Return 0;
419
420                $fullpath = $this->manager->getFullPath($relative);
421
422                $type = $this->getImageType($fullpath);
423                if($type != 'gif')
424                        Return 0;
425
426                if(function_exists('ImageCreateFrom'+$type)
427                        && function_exists('image'+$type))
428                        Return 1;
429                else
430                        Return -1;
431        }
432
433        /**
434         * Check if GIF can be edit by GD.
435         * @return int 0 if it is not using the GD library, 1 is GIF is editable, -1 if not editable.
436         */
437        function isGDGIFAble()
438        {
439                if(IMAGE_CLASS != 'GD')
440                        Return 0;
441
442                if(function_exists('ImageCreateFromGif')
443                        && function_exists('imagegif'))
444                        Return 1;
445                else
446                        Return -1;
447        }
448}
449
450?>
451=======
452<?php
453/**
454 * Image Editor. Editing tools, crop, rotate, scale and save.
455 * @author $Author$
456 * @version $Id$
457 * @package ImageManager
458 */
459
460require_once('../ImageManager/Classes/Transform.php');
461
462/**
463 * Handles the basic image editing capbabilities.
464 * @author $Author$
465 * @version $Id$
466 * @package ImageManager
467 * @subpackage Editor
468 */
469class ImageEditor
470{
471        /**
472         * ImageManager instance.
473         */
474        var $manager;
475
476        /**
477         * user based on IP address
478         */
479        var $_uid;
480
481        /**
482         * tmp file storage time.
483         */
484        var $lapse_time =900; //15 mins
485
486        var $filesaved = 0;
487
488        /**
489         * Create a new ImageEditor instance. Editing requires a
490         * tmp file, which is saved in the current directory where the
491         * image is edited. The tmp file is assigned by md5 hash of the
492         * user IP address. This hashed is used as an ID for cleaning up
493         * the tmp files. In addition, any tmp files older than the
494         * the specified period will be deleted.
495         * @param ImageManager $manager the image manager, we need this
496         * for some file and path handling functions.
497         */
498        function ImageEditor($manager)
499        {
500                $this->manager = $manager;
501                $this->_uid = md5($_SERVER['REMOTE_ADDR']);
502        }
503       
504        /**
505         * Did we save a file?
506         * @return int 1 if the file was saved sucessfully,
507         * 0 no save operation, -1 file save error.
508         */
509        function isFileSaved()
510        {
511                Return $this->filesaved;
512        }
513
514        /**
515         * Process the image, if not action, just display the image.
516         * @return array with image information, empty array if not an image.
517         * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
518         * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
519         */
520        function processImage()
521        {
522                if(isset($_GET['img']))
523                        $relative = rawurldecode($_GET['img']);
524                else
525                        Return array();
526               
527                //$relative = '/Series2004NoteFront.jpg';
528
529                $imgURL = $this->manager->getFileURL($relative);
530                $fullpath = $this->manager->getFullPath($relative);
531               
532                $imgInfo = @getImageSize($fullpath);
533                if(!is_array($imgInfo))
534                        Return array();
535
536                $action = $this->getAction();
537
538                if(!is_null($action))
539                {
540                        $image = $this->processAction($action, $relative, $fullpath);
541                }
542                else
543                {
544                        $image['src'] = $imgURL;
545                        $image['dimensions'] = $imgInfo[3];
546                        $image['file'] = $relative;
547                        $image['fullpath'] = $fullpath;
548                }
549
550                Return $image;
551        }
552
553        /**
554         * Process the actions, crop, scale(resize), rotate, flip, and save.
555         * When ever an action is performed, the result is save into a
556         * temporary image file, see createUnique on the filename specs.
557         * It does not return the saved file, alway returning the tmp file.
558         * @param string $action, should be 'crop', 'scale', 'rotate','flip', or 'save'
559         * @param string $relative the relative image filename
560         * @param string $fullpath the fullpath to the image file
561         * @return array with image information
562         * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
563         * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
564         */
565        function processAction($action, $relative, $fullpath)
566        {
567                $params = '';
568               
569                if(isset($_GET['params']))
570                        $params = $_GET['params'];
571
572                $values =  explode(',',$params,4);
573                $saveFile = $this->getSaveFileName($values[0]);
574
575                $img = Image_Transform::factory(IMAGE_CLASS);
576                $img->load($fullpath);
577
578                switch ($action)
579                {
580                        case 'crop':
581                                $img->crop(intval($values[0]),intval($values[1]),
582                                                        intval($values[2]),intval($values[3]));
583                        break;
584                        case 'scale':
585                                $img->resize(intval($values[0]),intval($values[1]));
586                                break;
587                        case 'rotate':
588                                $img->rotate(floatval($values[0]));
589                                break;
590                        case 'flip':
591                                if ($values[0] == 'hoz')
592                                        $img->flip(true);
593                                else if($values[0] == 'ver')
594                                        $img->flip(false);
595                                break;
596                        case 'save':
597                                if(!is_null($saveFile))
598                                {
599                                        $quality = intval($values[1]);
600                            if($quality <0) $quality = 85;
601                                        $newSaveFile = $this->makeRelative($relative, $saveFile);
602                                        $newSaveFile = $this->getUniqueFilename($newSaveFile);
603                                       
604                                        //get unique filename just returns the filename, so
605                                        //we need to make the relative path once more.
606                                        $newSaveFile = $this->makeRelative($relative, $newSaveFile);
607          $image['saveFile'] = $newSaveFile;
608                                        $newSaveFullpath = $this->manager->getFullPath($newSaveFile);
609                                        $img->save($newSaveFullpath, $values[0], $quality);
610                                        if(is_file($newSaveFullpath))
611                                                $this->filesaved = 1;
612                                        else
613                                                $this->filesaved = -1;
614                                }
615                                break;
616                }
617               
618                //create the tmp image file
619                $filename = $this->createUnique($fullpath);
620                $newRelative = $this->makeRelative($relative, $filename);
621                $newFullpath = $this->manager->getFullPath($newRelative);
622                $newURL = $this->manager->getFileURL($newRelative);
623               
624                //save the file.
625                $img->save($newFullpath);
626                $img->free();
627
628                //get the image information
629                $imgInfo = @getimagesize($newFullpath);
630
631                $image['src'] = $newURL;
632    $image['width'] = $imgInfo[0];
633    $image['height'] = $imgInfo[1];
634                $image['dimensions'] = $imgInfo[3];
635                $image['file'] = $newRelative;
636                $image['fullpath'] = $newFullpath;
637
638                Return $image;
639       
640        }
641
642        /**
643         * Get the file name base on the save name
644         * and the save type.
645         * @param string $type image type, 'jpeg', 'png', or 'gif'
646         * @return string the filename according to save type
647         */
648        function getSaveFileName($type)
649        {
650                if(!isset($_GET['file']))
651                        Return null;
652
653                $filename = Files::escape(rawurldecode($_GET['file']));
654                $index = strrpos($filename,'.');
655                $base = substr($filename,0,$index);
656                $ext = strtolower(substr($filename,$index+1,strlen($filename)));
657
658                if($type == 'jpeg' && !($ext=='jpeg' || $ext=='jpg'))
659                {
660                        Return $base.'.jpeg';
661                }
662                if($type=='png' && $ext != 'png')
663                        Return $base.'.png';
664                if($type=='gif' && $ext != 'gif')
665                        Return $base.'.gif';
666
667                Return $filename;
668        }
669
670        /**
671         * Get the default save file name, used by editor.php.
672         * @return string a suggestive filename, this should be unique
673         */
674        function getDefaultSaveFile()
675        {
676                if(isset($_GET['img']))
677                        $relative = rawurldecode($_GET['img']);
678                else
679                        Return null;
680
681                Return $this->getUniqueFilename($relative);
682        }
683
684        /**
685         * Get a unique filename. If the file exists, the filename
686         * base is appended with an increasing integer.
687         * @param string $relative the relative filename to the base_dir
688         * @return string a unique filename in the current path
689         */
690        function getUniqueFilename($relative)
691        {
692                $fullpath = $this->manager->getFullPath($relative);
693               
694                $pathinfo = pathinfo($fullpath);
695
696                $path = Files::fixPath($pathinfo['dirname']);
697                $file = Files::escape($pathinfo['basename']);
698               
699                $filename = $file;
700
701                $dotIndex = strrpos($file, '.');
702                $ext = '';
703
704                if(is_int($dotIndex))
705                {
706                        $ext = substr($file, $dotIndex);
707                        $base = substr($file, 0, $dotIndex);
708                }
709
710                $counter = 0;
711                while(is_file($path.$filename))
712                {
713                        $counter++;
714                        $filename = $base.'_'.$counter.$ext;
715                }
716               
717                Return $filename;
718               
719        }
720
721        /**
722         * Specifiy the original relative path, a new filename
723         * and return the new filename with relative path.
724         * i.e. $pathA (-filename) + $file
725         * @param string $pathA the relative file
726         * @param string $file the new filename
727         * @return string relative path with the new filename
728         */
729        function makeRelative($pathA, $file)
730        {
731                $index = strrpos($pathA,'/');
732                if(!is_int($index))
733                        Return $file;
734
735                $path = substr($pathA, 0, $index);
736                Return Files::fixPath($path).$file;
737        }
738
739        /**
740         * Get the action GET parameter
741         * @return string action parameter
742         */
743        function getAction()
744        {
745                $action = null;
746                if(isset($_GET['action']))
747                        $action = $_GET['action'];
748                Return $action;
749        }
750
751        /**
752         * Generate a unique string based on md5(microtime()).
753         * Well not so uniqe, as it is limited to 6 characters
754         * @return string unique string.
755         */
756    function uniqueStr()
757    {
758      return substr(md5(microtime()),0,6);
759    }
760
761        /**
762         * Create unique tmp image file name.
763         * The filename is based on the tmp file prefix
764         * specified in config.inc.php plus
765         * the UID (basically a md5 of the remote IP)
766         * and some random 6 character string.
767         * This function also calls to clean up the tmp files.
768         * @param string $file the fullpath to a file
769         * @return string a unique filename for that path
770         * NOTE: it only returns the filename, path no included.
771         */
772        function createUnique($file)
773        {
774                $pathinfo = pathinfo($file);
775                $path = Files::fixPath($pathinfo['dirname']);
776                $imgType = $this->getImageType($file);
777
778                $unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;
779
780           //make sure the the unique temp file does not exists
781        while (file_exists($path.$unique_str))
782        {
783            $unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;
784        }
785
786                $this->cleanUp($path,$pathinfo['basename']);
787
788                Return $unique_str;
789        }
790
791        /**
792         * Delete any tmp image files.
793         * @param string $path the full path
794         * where the clean should take place.
795         */
796        function cleanUp($path,$file)
797        {
798                $path = Files::fixPath($path);
799
800                if(!is_dir($path))
801                        Return false;
802
803                $d = @dir($path);
804               
805                $tmp = $this->manager->getTmpPrefix();
806                $tmpLen = strlen($tmp);
807
808                $prefix = $tmp.$this->_uid;
809                $len = strlen($prefix);
810
811                while (false !== ($entry = $d->read()))
812                {
813                        //echo $entry."<br>";
814                        if(is_file($path.$entry) && $this->manager->isTmpFile($entry))
815                        {
816                                if(substr($entry,0,$len)==$prefix && $entry != $file)
817                                        Files::delFile($path.$entry);
818                                else if(substr($entry,0,$tmpLen)==$tmp && $entry != $file)
819                                {
820                                        if(filemtime($path.$entry)+$this->lapse_time < time())
821                                                Files::delFile($path.$entry);
822                                }
823                        }
824                }
825                $d->close();
826        }
827
828        /**
829         * Get the image type base on an image file.
830         * @param string $file the full path to the image file.
831         * @return string of either 'gif', 'jpeg', 'png' or 'bmp'
832         * otherwise it will return null.
833         */
834        function getImageType($file)
835        {
836                $imageInfo = @getImageSize($file);
837
838                if(!is_array($imageInfo))
839                        Return null;
840
841                switch($imageInfo[2])
842                {
843                        case 1:
844                                Return 'gif';
845                        case 2:
846                                Return 'jpeg';
847                        case 3:
848                                Return 'png';
849                        case 6:
850                                Return 'bmp';
851                }
852
853                Return null;
854        }
855
856        /**
857         * Check if the specified image can be edit by GD
858         * mainly to check that GD can read and save GIFs
859         * @return int 0 if it is not a GIF file, 1 is GIF is editable, -1 if not editable.
860         */
861        function isGDEditable()
862        {
863                if(isset($_GET['img']))
864                        $relative = rawurldecode($_GET['img']);
865                else
866                        Return 0;
867                if(IMAGE_CLASS != 'GD')
868                        Return 0;
869
870                $fullpath = $this->manager->getFullPath($relative);
871
872                $type = $this->getImageType($fullpath);
873                if($type != 'gif')
874                        Return 0;
875
876                if(function_exists('ImageCreateFrom'+$type)
877                        && function_exists('image'+$type))
878                        Return 1;
879                else
880                        Return -1;
881        }
882
883        /**
884         * Check if GIF can be edit by GD.
885         * @return int 0 if it is not using the GD library, 1 is GIF is editable, -1 if not editable.
886         */
887        function isGDGIFAble()
888        {
889                if(IMAGE_CLASS != 'GD')
890                        Return 0;
891
892                if(function_exists('ImageCreateFromGif')
893                        && function_exists('imagegif'))
894                        Return 1;
895                else
896                        Return -1;
897        }
898}
899
900?>
901>>>>>>> .merge-right.r760
Note: See TracBrowser for help on using the repository browser.