source: branches/ray/plugins/ImageManager/Classes/ImageManager.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: 32.7 KB
Line 
1<<<<<<< .working
2<?php
3/**
4 * ImageManager, list images, directories, and thumbnails.
5 * @author $Author$
6 * @version $Id$
7 * @package ImageManager
8 */
9
10require_once('Files.php');
11
12// uncomment to turn on debugging
13
14// _ddtOn();
15
16/**
17 * ImageManager Class.
18 * @author $Author$
19 * @version $Id$
20 */
21class ImageManager
22{
23        /**
24         * Configuration array.
25         */
26        var $config;
27
28        /**
29         * Array of directory information.
30         */
31        var $dirs;
32
33        /**
34         * Constructor. Create a new Image Manager instance.
35         * @param array $config configuration array, see config.inc.php
36         */
37        function ImageManager($config)
38        {
39                $this->config = $config;
40        }
41
42        /**
43         * Get the images base directory.
44         * @return string base dir, see config.inc.php
45         */
46        function getImagesDir()
47        {
48                Return $this->config['images_dir'];
49        }
50
51        /**
52         * Get the images base URL.
53         * @return string base url, see config.inc.php
54         */
55        function getImagesURL()
56        {
57                Return $this->config['images_url'];
58        }
59
60        function isValidBase()
61        {
62                return is_dir($this->getImagesDir());
63        }
64
65        /**
66         * Get the tmp file prefix.
67         * @return string tmp file prefix.
68         */
69        function getTmpPrefix()
70        {
71                Return $this->config['tmp_prefix'];
72        }
73
74        /**
75         * Get the sub directories in the base dir.
76         * Each array element contain
77         * the relative path (relative to the base dir) as key and the
78         * full path as value.
79         * @return array of sub directries
80         * <code>array('path name' => 'full directory path', ...)</code>
81         */
82        function getDirs()
83        {
84                if(is_null($this->dirs))
85                {
86                        $dirs = $this->_dirs($this->getImagesDir(),'/');
87                        ksort($dirs);
88                        $this->dirs = $dirs;
89                }
90                return $this->dirs;
91        }
92
93        /**
94         * Recursively travese the directories to get a list
95         * of accessable directories.
96         * @param string $base the full path to the current directory
97         * @param string $path the relative path name
98         * @return array of accessiable sub-directories
99         * <code>array('path name' => 'full directory path', ...)</code>
100         */
101        function _dirs($base, $path)
102        {
103                $base = Files::fixPath($base);
104                $dirs = array();
105
106                if($this->isValidBase() == false)
107                        return $dirs;
108
109                $d = @dir($base);
110               
111                while (false !== ($entry = $d->read()))
112                {
113                        //If it is a directory, and it doesn't start with
114                        // a dot, and if is it not the thumbnail directory
115                        if(is_dir($base.$entry)
116                                && substr($entry,0,1) != '.'
117                                && $this->isThumbDir($entry) == false)
118                        {
119                                $relative = Files::fixPath($path.$entry);
120                                $fullpath = Files::fixPath($base.$entry);
121                                $dirs[$relative] = $fullpath;
122                                $dirs = array_merge($dirs, $this->_dirs($fullpath, $relative));
123                        }
124                }
125                $d->close();
126
127                Return $dirs;
128        }
129
130        /**
131         * Get all the files and directories of a relative path.
132         * @param string $path relative path to be base path.
133         * @return array of file and path information.
134         * <code>array(0=>array('relative'=>'fullpath',...), 1=>array('filename'=>fileinfo array(),...)</code>
135         * fileinfo array: <code>array('url'=>'full url',
136         *                       'relative'=>'relative to base',
137         *                        'fullpath'=>'full file path',
138         *                        'image'=>imageInfo array() false if not image,
139         *                        'stat' => filestat)</code>
140         */
141        function getFiles($path)
142        {
143                $files = array();
144                $dirs = array();
145
146                if($this->isValidBase() == false)
147                        return array($files,$dirs);
148
149                $path = Files::fixPath($path);
150                $base = Files::fixPath($this->getImagesDir());
151                $fullpath = Files::makePath($base,$path);
152
153
154                $d = @dir($fullpath);
155               
156                while (false !== ($entry = $d->read()))
157                {
158                        //not a dot file or directory
159                        if(substr($entry,0,1) != '.')
160                        {
161                                if(is_dir($fullpath.$entry)
162                                        && $this->isThumbDir($entry) == false)
163                                {
164                                        $relative = Files::fixPath($path.$entry);
165                                        $full = Files::fixPath($fullpath.$entry);
166                                        $count = $this->countFiles($full);
167                                        $dirs[$relative] = array('fullpath'=>$full,'entry'=>$entry,'count'=>$count);
168                                }
169                                else if(is_file($fullpath.$entry) && $this->isThumb($entry)==false && $this->isTmpFile($entry) == false)
170                                {
171                                        $img = $this->getImageInfo($fullpath.$entry);
172
173                                        if(!(!is_array($img)&&$this->config['validate_images']))
174                                        {
175                                                $file['url'] = Files::makePath($this->config['base_url'],$path).$entry;
176                                                $file['relative'] = $path.$entry;
177                                                $file['fullpath'] = $fullpath.$entry;
178                                                $file['image'] = $img;
179                                                $file['stat'] = stat($fullpath.$entry);
180                                                $files[$entry] = $file;
181                                        }
182                                }
183                        }
184                }
185                $d->close();
186                ksort($dirs);
187                ksort($files);
188               
189                Return array($dirs, $files);
190        }       
191
192        /**
193         * Count the number of files and directories in a given folder
194         * minus the thumbnail folders and thumbnails.
195         */
196        function countFiles($path)
197        {
198                $total = 0;
199
200                if(is_dir($path))
201                {
202                        $d = @dir($path);
203
204                        while (false !== ($entry = $d->read()))
205                        {
206                                //echo $entry."<br>";
207                                if(substr($entry,0,1) != '.'
208                                        && $this->isThumbDir($entry) == false
209                                        && $this->isTmpFile($entry) == false
210                                        && $this->isThumb($entry) == false)
211                                {
212                                        $total++;
213                                }
214                        }
215                        $d->close();
216                }
217                return $total;
218        }
219
220        /**
221         * Get image size information.
222         * @param string $file the image file
223         * @return array of getImageSize information,
224         *  false if the file is not an image.
225         */
226        function getImageInfo($file)
227        {
228                Return @getImageSize($file);
229        }
230
231        /**
232         * Check if the file contains the thumbnail prefix.
233         * @param string $file filename to be checked
234         * @return true if the file contains the thumbnail prefix, false otherwise.
235         */
236        function isThumb($file)
237        {
238                $len = strlen($this->config['thumbnail_prefix']);
239                if(substr($file,0,$len)==$this->config['thumbnail_prefix'])
240                        Return true;
241                else
242                        Return false;
243        }
244
245        /**
246         * Check if the given directory is a thumbnail directory.
247         * @param string $entry directory name
248         * @return true if it is a thumbnail directory, false otherwise
249         */
250        function isThumbDir($entry)
251        {
252                if($this->config['thumbnail_dir'] == false
253                        || strlen(trim($this->config['thumbnail_dir'])) == 0)
254                        Return false;           
255                else
256                        Return ($entry == $this->config['thumbnail_dir']);
257        }
258
259        /**
260         * Check if the given file is a tmp file.
261         * @param string $file file name
262         * @return boolean true if it is a tmp file, false otherwise
263         */
264        function isTmpFile($file)
265        {
266                $len = strlen($this->config['tmp_prefix']);
267                if(substr($file,0,$len)==$this->config['tmp_prefix'])
268                        Return true;
269                else
270                        Return false;           
271        }
272
273        /**
274         * For a given image file, get the respective thumbnail filename
275         * no file existence check is done.
276         * @param string $fullpathfile the full path to the image file
277         * @return string of the thumbnail file
278         */
279        function getThumbName($fullpathfile)
280        {
281                $path_parts = pathinfo($fullpathfile);
282               
283                $thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];
284
285                if( strlen(trim($this->config['thumbnail_dir'])) == 0 || $this->config['safe_mode'] == true)
286                {
287                        Return Files::makeFile($path_parts['dirname'],$thumbnail);
288                }
289                else
290                {
291                                $path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
292                                if(!is_dir($path))
293                                        Files::createFolder($path);
294                                Return Files::makeFile($path,$thumbnail);
295                }
296        }
297       
298        /**
299         * Similar to getThumbName, but returns the URL, base on the
300         * given base_url in config.inc.php
301         * @param string $relative the relative image file name,
302         * relative to the base_dir path
303         * @return string the url of the thumbnail
304         */
305        function getThumbURL($relative)
306        {
307
308                _ddt( __FILE__, __LINE__, "getThumbURL(): relative is '$relative'" );
309
310                $path_parts = pathinfo($relative);
311                $thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];
312                if($path_parts['dirname']=='\\') $path_parts['dirname']='/';
313
314                if($this->config['safe_mode'] == true
315                        || strlen(trim($this->config['thumbnail_dir'])) == 0)
316                {
317                        Return Files::makeFile($this->getImagesURL(),$thumbnail);
318                }
319                else
320                {
321                        if(strlen(trim($this->config['thumbnail_dir'])) > 0)
322                        {
323                                $path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
324                                $url_path = Files::makePath($this->getImagesURL(), $path);
325
326                                _ddt( __FILE__, __LINE__, "getThumbURL(): url_path is '$url_path'" );
327
328                                Return Files::makeFile($url_path,$thumbnail);
329                        }
330                        else //should this ever happen?
331                        {
332                                //error_log('ImageManager: Error in creating thumbnail url');
333                        }
334
335                }
336        }
337
338
339        /**
340         * For a given image file, get the respective resized filename
341         * no file existence check is done.
342         * @param string $fullpathfile the full path to the image file
343         * @param integer $width the intended width
344         * @param integer $height the intended height
345         * @param boolean $mkDir whether to attempt to make the resized_dir if it doesn't exist
346         * @return string of the resized filename
347         */
348        function getResizedName($fullpathfile, $width, $height, $mkDir = TRUE)
349        {
350                $path_parts = pathinfo($fullpathfile);
351
352                $thumbnail = $this->config['resized_prefix']."_{$width}x{$height}_{$path_parts['basename']}";
353
354                if( strlen(trim($this->config['resized_dir'])) == 0 || $this->config['safe_mode'] == true )
355                {
356                        Return Files::makeFile($path_parts['dirname'],$thumbnail);
357                }
358                else
359                {
360                        $path = Files::makePath($path_parts['dirname'],$this->config['resized_dir']);
361                        if($mkDir && !is_dir($path))
362                                Files::createFolder($path);
363                        Return Files::makeFile($path,$thumbnail);
364                }
365        }
366
367        /**
368         * Check if the given path is part of the subdirectories
369         * under the base_dir.
370         * @param string $path the relative path to be checked
371         * @return boolean true if the path exists, false otherwise
372         */
373        function validRelativePath($path)
374        {
375                $dirs = $this->getDirs();
376                if($path == '/')
377                        Return true;
378                //check the path given in the url against the
379                //list of paths in the system.
380                for($i = 0; $i < count($dirs); $i++)
381                {
382                        $key = key($dirs);
383                        //we found the path
384                        if($key == $path)
385                                Return true;
386               
387                        next($dirs);
388                }               
389                Return false;
390        }
391
392        /**
393         * Process uploaded files, assumes the file is in
394         * $_FILES['upload'] and $_POST['dir'] is set.
395         * The dir must be relative to the base_dir and exists.
396         * If 'validate_images' is set to true, only file with
397         * image dimensions will be accepted.
398         * @return null
399         */
400        function processUploads()
401        {
402                if($this->isValidBase() == false)
403                        return;
404
405                $relative = null;
406
407                if(isset($_POST['dir']))
408                        $relative = rawurldecode($_POST['dir']);
409                else
410                        return;
411
412                //check for the file, and must have valid relative path
413                if(isset($_FILES['upload']) && $this->validRelativePath($relative))
414                {
415                        $this->_processFiles($relative, $_FILES['upload']);
416                }
417        }
418
419        /**
420         * Process upload files. The file must be an
421         * uploaded file. If 'validate_images' is set to
422         * true, only images will be processed. Any duplicate
423         * file will be renamed. See Files::copyFile for details
424         * on renaming.
425         * @param string $relative the relative path where the file
426         * should be copied to.
427         * @param array $file the uploaded file from $_FILES
428         * @return boolean true if the file was processed successfully,
429         * false otherwise
430         */
431        function _processFiles($relative, $file)
432        {
433               
434                if($file['error']!=0)
435                {
436                        Return false;
437                }
438
439                if(!is_file($file['tmp_name']))
440                {
441                        Return false;
442                }
443
444                if(!is_uploaded_file($file['tmp_name']))
445                {
446                        Files::delFile($file['tmp_name']);
447                        Return false;
448                }
449               
450
451                if($this->config['validate_images'] == true)
452                {
453                        $imgInfo = @getImageSize($file['tmp_name']);
454                        if(!is_array($imgInfo))
455                        {
456                                Files::delFile($file['tmp_name']);
457                                Return false;
458                        }
459                }
460
461                //now copy the file
462                $path = Files::makePath($this->getImagesDir(),$relative);
463                $result = Files::copyFile($file['tmp_name'], $path, $file['name']);
464
465                //no copy error
466                if(!is_int($result))
467                {
468                        Files::delFile($file['tmp_name']);
469                        Return true;
470                }
471
472                //delete tmp files.
473                Files::delFile($file['tmp_name']);
474                Return false;
475        }
476
477        /**
478         * Get the URL of the relative file.
479         * basically appends the relative file to the
480         * base_url given in config.inc.php
481         * @param string $relative a file the relative to the base_dir
482         * @return string the URL of the relative file.
483         */
484        function getFileURL($relative)
485        {
486                Return Files::makeFile($this->getImagesURL(),$relative);
487        }
488
489        /**
490         * Get the fullpath to a relative file.
491         * @param string $relative the relative file.
492         * @return string the full path, .ie. the base_dir + relative.
493         */
494        function getFullPath($relative)
495        {
496                Return Files::makeFile($this->getImagesDir(),$relative);;
497        }
498
499        /**
500         * Get the default thumbnail.
501         * @return string default thumbnail, empty string if
502         * the thumbnail doesn't exist.
503         */
504        function getDefaultThumb()
505        {
506
507                // FIXME: hack
508
509                Return $this->config['default_thumbnail'];
510
511                if(is_file($this->config['default_thumbnail']))
512                        {
513                        Return $this->config['default_thumbnail'];
514                        }
515                else
516                        Return '';
517        }
518
519
520        /**
521         * Get the thumbnail url to be displayed.
522         * If the thumbnail exists, and it is up-to-date
523         * the thumbnail url will be returns. If the
524         * file is not an image, a default image will be returned.
525         * If it is an image file, and no thumbnail exists or
526         * the thumbnail is out-of-date (i.e. the thumbnail
527         * modified time is less than the original file)
528         * then a thumbs.php?img=filename.jpg is returned.
529         * The thumbs.php url will generate a new thumbnail
530         * on the fly. If the image is less than the dimensions
531         * of the thumbnails, the image will be display instead.
532         * @param string $relative the relative image file.
533         * @return string the url of the thumbnail, be it
534         * actually thumbnail or a script to generate the
535         * thumbnail on the fly.
536         */
537        function getThumbnail($relative)
538        {
539
540                global $IMConfig;
541
542                _ddt( __FILE__, __LINE__, "getThumbnail(): top with '$relative'" );
543
544                $fullpath = Files::makeFile($this->getImagesDir(),$relative);
545
546                //not a file???
547                if(!is_file($fullpath))
548                        Return $this->getDefaultThumb();
549
550                $imgInfo = @getImageSize($fullpath);
551               
552                //not an image
553                if(!is_array($imgInfo))
554                        Return $this->getDefaultThumb();
555
556                //the original image is smaller than thumbnails,
557                //so just return the url to the original image.
558                if ($imgInfo[0] <= $this->config['thumbnail_width']
559                 && $imgInfo[1] <= $this->config['thumbnail_height'])
560                        Return $this->getFileURL($relative);
561
562                $thumbnail = $this->getThumbName($fullpath);
563               
564                //check for thumbnails, if exists and
565                // it is up-to-date, return the thumbnail url
566                if(is_file($thumbnail))
567                {
568                        if(filemtime($thumbnail) >= filemtime($fullpath))
569                                {
570                                _ddt( __FILE__, __LINE__, "getThumbnail(): returning url '" . $this->getThumbURL($relative) . "'" );
571
572                                Return $this->getThumbURL($relative);
573                                }
574                }
575
576                //well, no thumbnail was found, so ask the thumbs.php
577                //to generate the thumbnail on the fly.
578                Return $IMConfig['backend_url'] . '__function=thumbs&img='.rawurlencode($relative);
579        }
580
581        /**
582         * Delete and specified files.
583         * @return boolean true if delete, false otherwise
584         */
585        function deleteFiles()
586        {
587                if(isset($_GET['delf']))
588                        $this->_delFile(rawurldecode($_GET['delf']));
589        }
590
591        /**
592         * Delete and specified directories.
593         * @return boolean true if delete, false otherwise
594         */
595        function deleteDirs()
596        {
597                 if(isset($_GET['deld']))
598                        return $this->_delDir(rawurldecode($_GET['deld']));             
599                 else
600                         Return false;
601        }
602
603        /**
604         * Delete the relative file, and any thumbnails.
605         * @param string $relative the relative file.
606         * @return boolean true if deleted, false otherwise.
607         */
608        function _delFile($relative)
609        {
610                $fullpath = Files::makeFile($this->getImagesDir(),$relative);
611               
612                //check that the file is an image
613                if($this->config['validate_images'] == true)
614                {
615                        if(!is_array($this->getImageInfo($fullpath)))
616                                return false; //hmmm not an Image!!???
617                }
618
619                $thumbnail = $this->getThumbName($fullpath);
620
621                if(Files::delFile($fullpath))
622                        Return Files::delFile($thumbnail);
623                else
624                        Return false;
625        }
626
627        /**
628         * Delete directories recursively.
629         * @param string $relative the relative path to be deleted.
630         * @return boolean true if deleted, false otherwise.
631         */
632        function _delDir($relative)
633        {
634                $fullpath = Files::makePath($this->getImagesDir(),$relative);
635                if($this->countFiles($fullpath) <= 0)
636                        return Files::delFolder($fullpath,true); //delete recursively.
637                else
638                        Return false;
639        }
640
641        /**
642         * Create new directories.
643         * If in safe_mode, nothing happens.
644         * @return boolean true if created, false otherwise.
645         */
646        function processNewDir()
647        {
648                if($this->config['safe_mode'] == true)
649                        Return false;
650
651                if(isset($_GET['newDir']) && isset($_GET['dir']))
652                {
653                        $newDir = rawurldecode($_GET['newDir']);
654                        $dir = rawurldecode($_GET['dir']);
655                        $path = Files::makePath($this->getImagesDir(),$dir);
656                        $fullpath = Files::makePath($path, Files::escape($newDir));
657                        if(is_dir($fullpath))
658                                Return false;
659
660                        Return Files::createFolder($fullpath);
661                }
662        }
663}
664
665?>
666=======
667<?php
668/**
669 * ImageManager, list images, directories, and thumbnails.
670 * @author $Author$
671 * @version $Id$
672 * @package ImageManager
673 */
674
675require_once('../ImageManager/Classes/Files.php');
676
677// uncomment to turn on debugging
678
679// _ddtOn();
680
681/**
682 * ImageManager Class.
683 * @author $Author$
684 * @version $Id$
685 */
686class ImageManager
687{
688        /**
689         * Configuration array.
690         */
691        var $config;
692
693        /**
694         * Array of directory information.
695         */
696        var $dirs;
697
698        /**
699         * Constructor. Create a new Image Manager instance.
700         * @param array $config configuration array, see config.inc.php
701         */
702        function ImageManager($config)
703        {
704                $this->config = $config;
705        }
706
707        /**
708         * Get the images base directory.
709         * @return string base dir, see config.inc.php
710         */
711        function getImagesDir()
712        {
713                Return $this->config['images_dir'];
714        }
715
716        /**
717         * Get the images base URL.
718         * @return string base url, see config.inc.php
719         */
720        function getImagesURL()
721        {
722                Return $this->config['images_url'];
723        }
724
725        function isValidBase()
726        {
727                return is_dir($this->getImagesDir());
728        }
729
730        /**
731         * Get the tmp file prefix.
732         * @return string tmp file prefix.
733         */
734        function getTmpPrefix()
735        {
736                Return $this->config['tmp_prefix'];
737        }
738
739        /**
740         * Get the sub directories in the base dir.
741         * Each array element contain
742         * the relative path (relative to the base dir) as key and the
743         * full path as value.
744         * @return array of sub directries
745         * <code>array('path name' => 'full directory path', ...)</code>
746         */
747        function getDirs()
748        {
749                if(is_null($this->dirs))
750                {
751                        $dirs = $this->_dirs($this->getImagesDir(),'/');
752                        ksort($dirs);
753                        $this->dirs = $dirs;
754                }
755                return $this->dirs;
756        }
757
758        /**
759         * Recursively travese the directories to get a list
760         * of accessable directories.
761         * @param string $base the full path to the current directory
762         * @param string $path the relative path name
763         * @return array of accessiable sub-directories
764         * <code>array('path name' => 'full directory path', ...)</code>
765         */
766        function _dirs($base, $path)
767        {
768                $base = Files::fixPath($base);
769                $dirs = array();
770
771                if($this->isValidBase() == false)
772                        return $dirs;
773
774                $d = @dir($base);
775               
776                while (false !== ($entry = $d->read()))
777                {
778                        //If it is a directory, and it doesn't start with
779                        // a dot, and if is it not the thumbnail directory
780                        if(is_dir($base.$entry)
781                                && substr($entry,0,1) != '.'
782                                && $this->isThumbDir($entry) == false)
783                        {
784                                $relative = Files::fixPath($path.$entry);
785                                $fullpath = Files::fixPath($base.$entry);
786                                $dirs[$relative] = $fullpath;
787                                $dirs = array_merge($dirs, $this->_dirs($fullpath, $relative));
788                        }
789                }
790                $d->close();
791
792                Return $dirs;
793        }
794
795        /**
796         * Get all the files and directories of a relative path.
797         * @param string $path relative path to be base path.
798         * @return array of file and path information.
799         * <code>array(0=>array('relative'=>'fullpath',...), 1=>array('filename'=>fileinfo array(),...)</code>
800         * fileinfo array: <code>array('url'=>'full url',
801         *                       'relative'=>'relative to base',
802         *                        'fullpath'=>'full file path',
803         *                        'image'=>imageInfo array() false if not image,
804         *                        'stat' => filestat)</code>
805         */
806        function getFiles($path)
807        {
808                $files = array();
809                $dirs = array();
810
811                if($this->isValidBase() == false)
812                        return array($files,$dirs);
813
814                $path = Files::fixPath($path);
815                $base = Files::fixPath($this->getImagesDir());
816                $fullpath = Files::makePath($base,$path);
817
818
819                $d = @dir($fullpath);
820               
821                while (false !== ($entry = $d->read()))
822                {
823                        //not a dot file or directory
824                        if(substr($entry,0,1) != '.')
825                        {
826                                if(is_dir($fullpath.$entry)
827                                        && $this->isThumbDir($entry) == false)
828                                {
829                                        $relative = Files::fixPath($path.$entry);
830                                        $full = Files::fixPath($fullpath.$entry);
831                                        $count = $this->countFiles($full);
832                                        $dirs[$relative] = array('fullpath'=>$full,'entry'=>$entry,'count'=>$count);
833                                }
834                                else if(is_file($fullpath.$entry) && $this->isThumb($entry)==false && $this->isTmpFile($entry) == false)
835                                {
836                                        $img = $this->getImageInfo($fullpath.$entry);
837
838                                        if(!(!is_array($img)&&$this->config['validate_images']))
839                                        {
840                                                $file['url'] = Files::makePath($this->config['base_url'],$path).$entry;
841                                                $file['relative'] = $path.$entry;
842                                                $file['fullpath'] = $fullpath.$entry;
843                                                $file['image'] = $img;
844                                                $file['stat'] = stat($fullpath.$entry);
845                                                $files[$entry] = $file;
846                                        }
847                                }
848                        }
849                }
850                $d->close();
851                ksort($dirs);
852                ksort($files);
853               
854                Return array($dirs, $files);
855        }       
856
857        /**
858         * Count the number of files and directories in a given folder
859         * minus the thumbnail folders and thumbnails.
860         */
861        function countFiles($path)
862        {
863                $total = 0;
864
865                if(is_dir($path))
866                {
867                        $d = @dir($path);
868
869                        while (false !== ($entry = $d->read()))
870                        {
871                                //echo $entry."<br>";
872                                if(substr($entry,0,1) != '.'
873                                        && $this->isThumbDir($entry) == false
874                                        && $this->isTmpFile($entry) == false
875                                        && $this->isThumb($entry) == false)
876                                {
877                                        $total++;
878                                }
879                        }
880                        $d->close();
881                }
882                return $total;
883        }
884
885        /**
886         * Get image size information.
887         * @param string $file the image file
888         * @return array of getImageSize information,
889         *  false if the file is not an image.
890         */
891        function getImageInfo($file)
892        {
893                Return @getImageSize($file);
894        }
895
896        /**
897         * Check if the file contains the thumbnail prefix.
898         * @param string $file filename to be checked
899         * @return true if the file contains the thumbnail prefix, false otherwise.
900         */
901        function isThumb($file)
902        {
903                $len = strlen($this->config['thumbnail_prefix']);
904                if(substr($file,0,$len)==$this->config['thumbnail_prefix'])
905                        Return true;
906                else
907                        Return false;
908        }
909
910        /**
911         * Check if the given directory is a thumbnail directory.
912         * @param string $entry directory name
913         * @return true if it is a thumbnail directory, false otherwise
914         */
915        function isThumbDir($entry)
916        {
917                if($this->config['thumbnail_dir'] == false
918                        || strlen(trim($this->config['thumbnail_dir'])) == 0)
919                        Return false;           
920                else
921                        Return ($entry == $this->config['thumbnail_dir']);
922        }
923
924        /**
925         * Check if the given file is a tmp file.
926         * @param string $file file name
927         * @return boolean true if it is a tmp file, false otherwise
928         */
929        function isTmpFile($file)
930        {
931                $len = strlen($this->config['tmp_prefix']);
932                if(substr($file,0,$len)==$this->config['tmp_prefix'])
933                        Return true;
934                else
935                        Return false;           
936        }
937
938        /**
939         * For a given image file, get the respective thumbnail filename
940         * no file existence check is done.
941         * @param string $fullpathfile the full path to the image file
942         * @return string of the thumbnail file
943         */
944        function getThumbName($fullpathfile)
945        {
946                $path_parts = pathinfo($fullpathfile);
947               
948                $thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];
949
950                if( strlen(trim($this->config['thumbnail_dir'])) == 0 || $this->config['safe_mode'] == true)
951                {
952                        Return Files::makeFile($path_parts['dirname'],$thumbnail);
953                }
954                else
955                {
956                                $path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
957                                if(!is_dir($path))
958                                        Files::createFolder($path);
959                                Return Files::makeFile($path,$thumbnail);
960                }
961        }
962       
963        /**
964         * Similar to getThumbName, but returns the URL, base on the
965         * given base_url in config.inc.php
966         * @param string $relative the relative image file name,
967         * relative to the base_dir path
968         * @return string the url of the thumbnail
969         */
970        function getThumbURL($relative)
971        {
972
973                _ddt( __FILE__, __LINE__, "getThumbURL(): relative is '$relative'" );
974
975                $path_parts = pathinfo($relative);
976                $thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];
977                if($path_parts['dirname']=='\\') $path_parts['dirname']='/';
978
979                if($this->config['safe_mode'] == true
980                        || strlen(trim($this->config['thumbnail_dir'])) == 0)
981                {
982                        Return Files::makeFile($this->getImagesURL(),$thumbnail);
983                }
984                else
985                {
986                        if(strlen(trim($this->config['thumbnail_dir'])) > 0)
987                        {
988                                $path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
989                                $url_path = Files::makePath($this->getImagesURL(), $path);
990
991                                _ddt( __FILE__, __LINE__, "getThumbURL(): url_path is '$url_path'" );
992
993                                Return Files::makeFile($url_path,$thumbnail);
994                        }
995                        else //should this ever happen?
996                        {
997                                //error_log('ImageManager: Error in creating thumbnail url');
998                        }
999
1000                }
1001        }
1002
1003
1004        /**
1005         * For a given image file, get the respective resized filename
1006         * no file existence check is done.
1007         * @param string $fullpathfile the full path to the image file
1008         * @param integer $width the intended width
1009         * @param integer $height the intended height
1010         * @param boolean $mkDir whether to attempt to make the resized_dir if it doesn't exist
1011         * @return string of the resized filename
1012         */
1013        function getResizedName($fullpathfile, $width, $height, $mkDir = TRUE)
1014        {
1015                $path_parts = pathinfo($fullpathfile);
1016
1017                $thumbnail = $this->config['resized_prefix']."_{$width}x{$height}_{$path_parts['basename']}";
1018
1019                if( strlen(trim($this->config['resized_dir'])) == 0 || $this->config['safe_mode'] == true )
1020                {
1021                        Return Files::makeFile($path_parts['dirname'],$thumbnail);
1022                }
1023                else
1024                {
1025                        $path = Files::makePath($path_parts['dirname'],$this->config['resized_dir']);
1026                        if($mkDir && !is_dir($path))
1027                                Files::createFolder($path);
1028                        Return Files::makeFile($path,$thumbnail);
1029                }
1030        }
1031
1032        /**
1033         * Check if the given path is part of the subdirectories
1034         * under the base_dir.
1035         * @param string $path the relative path to be checked
1036         * @return boolean true if the path exists, false otherwise
1037         */
1038        function validRelativePath($path)
1039        {
1040                $dirs = $this->getDirs();
1041                if($path == '/')
1042                        Return true;
1043                //check the path given in the url against the
1044                //list of paths in the system.
1045                for($i = 0; $i < count($dirs); $i++)
1046                {
1047                        $key = key($dirs);
1048                        //we found the path
1049                        if($key == $path)
1050                                Return true;
1051               
1052                        next($dirs);
1053                }               
1054                Return false;
1055        }
1056
1057        /**
1058         * Process uploaded files, assumes the file is in
1059         * $_FILES['upload'] and $_POST['dir'] is set.
1060         * The dir must be relative to the base_dir and exists.
1061         * If 'validate_images' is set to true, only file with
1062         * image dimensions will be accepted.
1063         * @return null
1064         */
1065        function processUploads()
1066        {
1067                if($this->isValidBase() == false)
1068                        return;
1069
1070                $relative = null;
1071
1072                if(isset($_POST['dir']))
1073                        $relative = rawurldecode($_POST['dir']);
1074                else
1075                        return;
1076
1077                //check for the file, and must have valid relative path
1078                if(isset($_FILES['upload']) && $this->validRelativePath($relative))
1079                {
1080                        $this->_processFiles($relative, $_FILES['upload']);
1081                }
1082        }
1083
1084        /**
1085         * Process upload files. The file must be an
1086         * uploaded file. If 'validate_images' is set to
1087         * true, only images will be processed. Any duplicate
1088         * file will be renamed. See Files::copyFile for details
1089         * on renaming.
1090         * @param string $relative the relative path where the file
1091         * should be copied to.
1092         * @param array $file the uploaded file from $_FILES
1093         * @return boolean true if the file was processed successfully,
1094         * false otherwise
1095         */
1096        function _processFiles($relative, $file)
1097        {
1098               
1099                if($file['error']!=0)
1100                {
1101                        Return false;
1102                }
1103
1104                if(!is_file($file['tmp_name']))
1105                {
1106                        Return false;
1107                }
1108
1109                if(!is_uploaded_file($file['tmp_name']))
1110                {
1111                        Files::delFile($file['tmp_name']);
1112                        Return false;
1113                }
1114               
1115
1116                if($this->config['validate_images'] == true)
1117                {
1118                        $imgInfo = @getImageSize($file['tmp_name']);
1119                        if(!is_array($imgInfo))
1120                        {
1121                                Files::delFile($file['tmp_name']);
1122                                Return false;
1123                        }
1124                }
1125
1126                //now copy the file
1127                $path = Files::makePath($this->getImagesDir(),$relative);
1128                $result = Files::copyFile($file['tmp_name'], $path, $file['name']);
1129
1130                //no copy error
1131                if(!is_int($result))
1132                {
1133                        Files::delFile($file['tmp_name']);
1134                        Return true;
1135                }
1136
1137                //delete tmp files.
1138                Files::delFile($file['tmp_name']);
1139                Return false;
1140        }
1141
1142        /**
1143         * Get the URL of the relative file.
1144         * basically appends the relative file to the
1145         * base_url given in config.inc.php
1146         * @param string $relative a file the relative to the base_dir
1147         * @return string the URL of the relative file.
1148         */
1149        function getFileURL($relative)
1150        {
1151                Return Files::makeFile($this->getImagesURL(),$relative);
1152        }
1153
1154        /**
1155         * Get the fullpath to a relative file.
1156         * @param string $relative the relative file.
1157         * @return string the full path, .ie. the base_dir + relative.
1158         */
1159        function getFullPath($relative)
1160        {
1161                Return Files::makeFile($this->getImagesDir(),$relative);;
1162        }
1163
1164        /**
1165         * Get the default thumbnail.
1166         * @return string default thumbnail, empty string if
1167         * the thumbnail doesn't exist.
1168         */
1169        function getDefaultThumb()
1170        {
1171
1172                // FIXME: hack
1173
1174                Return $this->config['default_thumbnail'];
1175
1176                if(is_file($this->config['default_thumbnail']))
1177                        {
1178                        Return $this->config['default_thumbnail'];
1179                        }
1180                else
1181                        Return '';
1182        }
1183
1184
1185        /**
1186         * Get the thumbnail url to be displayed.
1187         * If the thumbnail exists, and it is up-to-date
1188         * the thumbnail url will be returns. If the
1189         * file is not an image, a default image will be returned.
1190         * If it is an image file, and no thumbnail exists or
1191         * the thumbnail is out-of-date (i.e. the thumbnail
1192         * modified time is less than the original file)
1193         * then a thumbs.php?img=filename.jpg is returned.
1194         * The thumbs.php url will generate a new thumbnail
1195         * on the fly. If the image is less than the dimensions
1196         * of the thumbnails, the image will be display instead.
1197         * @param string $relative the relative image file.
1198         * @return string the url of the thumbnail, be it
1199         * actually thumbnail or a script to generate the
1200         * thumbnail on the fly.
1201         */
1202        function getThumbnail($relative)
1203        {
1204
1205                global $IMConfig;
1206
1207                _ddt( __FILE__, __LINE__, "getThumbnail(): top with '$relative'" );
1208
1209                $fullpath = Files::makeFile($this->getImagesDir(),$relative);
1210
1211                //not a file???
1212                if(!is_file($fullpath))
1213                        Return $this->getDefaultThumb();
1214
1215                $imgInfo = @getImageSize($fullpath);
1216               
1217                //not an image
1218                if(!is_array($imgInfo))
1219                        Return $this->getDefaultThumb();
1220
1221                //the original image is smaller than thumbnails,
1222                //so just return the url to the original image.
1223                if ($imgInfo[0] <= $this->config['thumbnail_width']
1224                 && $imgInfo[1] <= $this->config['thumbnail_height'])
1225                        Return $this->getFileURL($relative);
1226
1227                $thumbnail = $this->getThumbName($fullpath);
1228               
1229                //check for thumbnails, if exists and
1230                // it is up-to-date, return the thumbnail url
1231                if(is_file($thumbnail))
1232                {
1233                        if(filemtime($thumbnail) >= filemtime($fullpath))
1234                                {
1235                                _ddt( __FILE__, __LINE__, "getThumbnail(): returning url '" . $this->getThumbURL($relative) . "'" );
1236
1237                                Return $this->getThumbURL($relative);
1238                                }
1239                }
1240
1241                //well, no thumbnail was found, so ask the thumbs.php
1242                //to generate the thumbnail on the fly.
1243                Return $IMConfig['backend_url'] . '__function=thumbs&img='.rawurlencode($relative);
1244        }
1245
1246        /**
1247         * Delete and specified files.
1248         * @return boolean true if delete, false otherwise
1249         */
1250        function deleteFiles()
1251        {
1252                if(isset($_GET['delf']))
1253                        $this->_delFile(rawurldecode($_GET['delf']));
1254        }
1255
1256        /**
1257         * Delete and specified directories.
1258         * @return boolean true if delete, false otherwise
1259         */
1260        function deleteDirs()
1261        {
1262                 if(isset($_GET['deld']))
1263                        return $this->_delDir(rawurldecode($_GET['deld']));             
1264                 else
1265                         Return false;
1266        }
1267
1268        /**
1269         * Delete the relative file, and any thumbnails.
1270         * @param string $relative the relative file.
1271         * @return boolean true if deleted, false otherwise.
1272         */
1273        function _delFile($relative)
1274        {
1275                $fullpath = Files::makeFile($this->getImagesDir(),$relative);
1276               
1277                //check that the file is an image
1278                if($this->config['validate_images'] == true)
1279                {
1280                        if(!is_array($this->getImageInfo($fullpath)))
1281                                return false; //hmmm not an Image!!???
1282                }
1283
1284                $thumbnail = $this->getThumbName($fullpath);
1285
1286                if(Files::delFile($fullpath))
1287                        Return Files::delFile($thumbnail);
1288                else
1289                        Return false;
1290        }
1291
1292        /**
1293         * Delete directories recursively.
1294         * @param string $relative the relative path to be deleted.
1295         * @return boolean true if deleted, false otherwise.
1296         */
1297        function _delDir($relative)
1298        {
1299                $fullpath = Files::makePath($this->getImagesDir(),$relative);
1300                if($this->countFiles($fullpath) <= 0)
1301                        return Files::delFolder($fullpath,true); //delete recursively.
1302                else
1303                        Return false;
1304        }
1305
1306        /**
1307         * Create new directories.
1308         * If in safe_mode, nothing happens.
1309         * @return boolean true if created, false otherwise.
1310         */
1311        function processNewDir()
1312        {
1313                if($this->config['safe_mode'] == true)
1314                        Return false;
1315
1316                if(isset($_GET['newDir']) && isset($_GET['dir']))
1317                {
1318                        $newDir = rawurldecode($_GET['newDir']);
1319                        $dir = rawurldecode($_GET['dir']);
1320                        $path = Files::makePath($this->getImagesDir(),$dir);
1321                        $fullpath = Files::makePath($path, Files::escape($newDir));
1322                        if(is_dir($fullpath))
1323                                Return false;
1324
1325                        Return Files::createFolder($fullpath);
1326                }
1327        }
1328}
1329
1330?>
1331>>>>>>> .merge-right.r760
Note: See TracBrowser for help on using the repository browser.