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/ImageEditor.php

    r761 r762  
    1 <<<<<<< .working 
    21<?php 
    32/** 
     
    87 */ 
    98 
    10 require_once('Transform.php'); 
     9require_once('../ImageManager/Classes/Transform.php'); 
    1110 
    1211/** 
     
    449448 
    450449?> 
    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  
    460 require_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  */ 
    469 class 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 TracChangeset for help on using the changeset viewer.