Ignore:
Timestamp:
02/24/07 15:47:57 (13 years ago)
Author:
ray
Message:

updated branch

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/ray/plugins/ImageManager/Classes/ImageManager.php

    r761 r762  
    1 <<<<<<< .working 
    21<?php 
    32/** 
     
    87 */ 
    98 
    10 require_once('Files.php'); 
     9require_once('../ImageManager/Classes/Files.php'); 
    1110 
    1211// uncomment to turn on debugging 
     
    664663 
    665664?> 
    666 ======= 
    667 <?php 
    668 /** 
    669  * ImageManager, list images, directories, and thumbnails. 
    670  * @author $Author$ 
    671  * @version $Id$ 
    672  * @package ImageManager 
    673  */ 
    674  
    675 require_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  */ 
    686 class 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 TracChangeset for help on using the changeset viewer.