API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 20th, 2012
108
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 49.50 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2. /*******************************************************************************
  3. * FRESHIZER -> WP Image Resizer Script
  4. * =============================================================================
  5. *
  6. * @license GNU version 2
  7. * @author freshace
  8. * @version 1.5
  9. * @link http://github.com/boobslover/freshizer
  10. /*******************************************************************************
  11. * SETTINGS, PLEASE CHANGE ONLE THESE 3 CONSTANTS
  12. ******************************************************************************/
  13. // NOTE
  14. // ====
  15. // please notice, that the time is in SECONDS. There are not allowed math
  16. // operations in the definition. So instead of writing:
  17. // = 60(sec) * 60(min) * 24(hr) * 7(days); you have to write:
  18. // = 604800; // seconds in 7 days
  19.  
  20.  
  21. // CACHE TIME
  22. // ==========
  23. // When the new (cached) file is older than this time, script automatically
  24. // checks, if the old file has been changed. If not, then ve serve cached file
  25. // again. If yes, cached file is deleted and resized again.
  26. define('CACHE_TIME', 604800);
  27.  
  28. // CACHE DELETE FILES AFTER
  29. // ========================
  30. // Hard delete files ( not only compare if the original file has been changed,
  31. // but hardly delete from caching folder ), every X seconds. Please fill a large
  32. // number, because cached files runs much more speedely
  33. define('CACHE_DELETE_FILES_AFTER',10000000);
  34.  
  35. // CACHE DELETE FILES - check every X hits
  36. // =======================================
  37. // How often do we check if there are files which should be hard deleted ?
  38. // Optimal is approx 400 - 500 hits
  39. define('CACHE_DELETE_FILES_check_every_x_hits',150);
  40.  
  41.  
  42.  
  43. class blFile {
  44. CONST POINTER_END = 'pend';
  45.  
  46. private $_handle = null;
  47. private $_fileSize = null;
  48. private $_path = null;
  49. private $_writeBuffer = '';
  50.  
  51. /*----------------------------------------------------------------------------*/
  52. /* FUNCTIONS PUBLIC
  53. /*----------------------------------------------------------------------------*/
  54.  
  55. public function __construct( $handle, $path ) {
  56. $this->_setHandle( $handle );
  57. $this->_setPath( $path );
  58. }
  59.  
  60. public function readAll() {
  61. if( $this->getFileSize() > 0 )
  62. return (fread( $this->getHandle(), $this->getFileSize() ));
  63. else
  64. return null;
  65. }
  66. public function read( $size ) {
  67. if( $this->getFileSize() > 0 )
  68. return fread( $this->getHandle(), $size );
  69. else
  70. return null;
  71. }
  72. public function readAllAndClose() {
  73. $fileContent = $this->readAll();
  74. $this->closeFile();
  75.  
  76. return $fileContent;
  77. }
  78.  
  79. /**
  80. * @param string $content
  81. * @return blFile
  82. */
  83. public function write( $content ) {
  84. fwrite( $this->getHandle(), ( $content ) );
  85. return $this;
  86. }
  87.  
  88. public function writeBuffered( $content ) {
  89. $this->_setWriteBuffer( $content );
  90. return $this;
  91. }
  92.  
  93. /*public function __destruct() {
  94. var_dump($this);
  95. if( $this->_writeBuffer != '' ) {
  96. $this->write( $this->_writeBuffer ) ;
  97. }
  98.  
  99. $this->closeFile();
  100. }*/
  101.  
  102. /**
  103. * @return blFile
  104. */
  105. public function truncate() {
  106. ftruncate( $this->getHandle(), 0);
  107. $this->pointerStart();
  108. return $this;
  109. }
  110.  
  111. public function closeFile() {
  112. if( $this->getHandle() !== null ) {
  113. fclose( $this->getHandle() );
  114. $this->_setHandle(null);
  115. }
  116. }
  117.  
  118. /**
  119. * @return blFile
  120. */
  121. public function pointerStart() {
  122. $this->_movePointer( 0 );
  123. return $this;
  124. }
  125.  
  126. /**
  127. * @return blFile
  128. */
  129. public function pointerEnd() {
  130. $this->_movePointer( self::POINTER_END );
  131. return $this;
  132. }
  133.  
  134. /**
  135. * @param int $where
  136. * @return blFile
  137. */
  138. public function pointerTo( $where ) {
  139. return $this->_movePointer( $where );
  140. return $this;
  141. }
  142.  
  143.  
  144. /*----------------------------------------------------------------------------*/
  145. /* FUNCTIONS PRIVATE
  146. /*----------------------------------------------------------------------------*/
  147. private function _movePointer( $where ) {
  148. if( $where == self::POINTER_END ) {
  149. fseek( $this->getHandle(), 0, SEEK_END);
  150. } else {
  151. fseek( $this->getHandle(), $where, SEEK_SET);
  152. }
  153. }
  154.  
  155. /*----------------------------------------------------------------------------*/
  156. /* SETTERS AND GETTERS
  157. /*----------------------------------------------------------------------------*/
  158.  
  159. private function _setWriteBuffer( $content ) {
  160. $this->_writeBuffer = $content;
  161. }
  162.  
  163. private function _getWriteBuffer() {
  164. return $this->_writeBuffer;
  165. }
  166.  
  167. public function getHandle() {
  168. return $this->_handle;
  169. }
  170.  
  171. private function _setHandle( $handle ) {
  172. $this->_handle = $handle;
  173. }
  174.  
  175. public function getPath() {
  176. return $this->_path;
  177. }
  178.  
  179. private function _setPath( $path ) {
  180. $this->_path = $path;
  181. }
  182.  
  183. public function getFileSize() {
  184. if( $this->_fileSize == null ) {
  185. $this->_fileSize = filesize( $this->getPath() );
  186. }
  187.  
  188. return $this->_fileSize;
  189. }
  190. }
  191.  
  192.  
  193. class blFileSystem {
  194. private $_errors = array();
  195. /*----------------------------------------------------------------------------*/
  196. /* FUNCTIONS PUBLIC
  197. /*----------------------------------------------------------------------------*/
  198.  
  199. /**
  200. * Trying to open file. If neccessary, creates dir and file automatically
  201. *
  202. * @param string $path
  203. * @param bool $writing
  204. * @return blFile
  205. */
  206. public function openFile( $path, $writing = false ) {
  207. if( file_exists( $path ) ) {
  208. $mode = ( $writing ) ? 'r+' : 'r';
  209. } else {
  210. $mode = ( $writing ) ? 'c+' : 'c';
  211. }
  212. return $this->_openFile( $path, $mode );
  213. }
  214.  
  215. /**
  216. * Open file, if exists, truncate
  217. * @param string $path
  218. * @param bool $writing
  219. * @return blFile
  220. */
  221. public function createFile( $path, $writing = false ) {
  222. $mode = ( $writing ) ? 'c+' : 'c';
  223. return $this->_openFile( $path, $mode );
  224. }
  225.  
  226. public function deleteFile( $path ) {}
  227.  
  228. public function createDir( $path ) {
  229. if( mkdir( $path, 0777, true ) === false ) {
  230. $this->_addError( 'Unable to create DIR :'. $path );
  231. }
  232. }
  233.  
  234. public function saveImage( $image, $path ) {
  235. $pinfo = pathinfo( $path );
  236. $ext = $pinfo['extension'];
  237. $return = null;
  238.  
  239. switch( $ext ) {
  240. case 'jpg':
  241. $return = imagejpeg($image, $path, 90 );
  242. break;
  243. case 'jpeg':
  244. $return = imagejpeg($image, $path, 90 );
  245. break;
  246. case 'png':
  247. $return = imagepng( $image, $path, 0 );
  248. break;
  249.  
  250. case 'gif':
  251. $return = imagegif( $image, $path );
  252. break;
  253. }
  254.  
  255. return $return;
  256.  
  257. }
  258.  
  259. /*----------------------------------------------------------------------------*/
  260. /* FUNCTIONS PRIVATE
  261. /*----------------------------------------------------------------------------*/
  262.  
  263. private function _openFile( $path, $mode ) {
  264. $pathInfo = pathinfo( $path );
  265. $dirname = $pathInfo['dirname'];
  266. $file = null;
  267.  
  268. if( !is_dir( $dirname ) ) {
  269. $this->createDir( $dirname );
  270. }
  271.  
  272. $fileHandler = fopen( $path, $mode);
  273. $file = new blFile( $fileHandler, $path);
  274.  
  275. return $file;
  276. }
  277.  
  278. /*----------------------------------------------------------------------------*/
  279. /* SETTERS AND GETTERS
  280. /*----------------------------------------------------------------------------*/
  281. public function getErorrs() {
  282. return $this->_errors;
  283. }
  284.  
  285. private function _addError( $error ) {
  286. $this->_errors[] = $error;
  287. }
  288.  
  289. }
  290.  
  291.  
  292. interface blIConnection {
  293. public function getContent( $url );
  294. }
  295.  
  296.  
  297. class blConnectionAdapteur implements blIConnection {
  298. /**
  299. * @var blIConnection
  300. */
  301. private $_connectionMethod = null;
  302.  
  303. /*----------------------------------------------------------------------------*/
  304. /* PUBLIC FUNCTIONS
  305. /*----------------------------------------------------------------------------*/
  306.  
  307. public function getContent( $url ) {
  308. return $this->_getConnectionMethod()->getContent($url);
  309. }
  310. /*----------------------------------------------------------------------------*/
  311. /* PRIVATE FUNCTIONS
  312. /*----------------------------------------------------------------------------*/
  313.  
  314. private function _createProperConnection() {
  315. if( ini_get('allow_url_fopen') ) {
  316. $this->_setConnectionMethod( new blConnectionFopen() );
  317. } else if( function_exists( 'curl_init') ) {
  318. $this->_setConnectionMethod( new blConnectionCurl() );
  319. }
  320. }
  321.  
  322. /*----------------------------------------------------------------------------*/
  323. /* GETTERS AND SETTERS
  324. /*----------------------------------------------------------------------------*/
  325.  
  326. private function _setConnectionMethod( blIConnection $connectionMethod ) {
  327. $this->_connectionMethod = $connectionMethod;
  328. }
  329.  
  330. /**
  331. * @return blIConnection
  332. */
  333. private function _getConnectionMethod() {
  334. if( $this->_connectionMethod == null ) {
  335. $this->_createProperConnection();
  336. }
  337. return $this->_connectionMethod;
  338. }
  339. }
  340.  
  341.  
  342. class blConnectionCurl implements blIConnection {
  343. public function getContent( $url ) {
  344. $ch = curl_init();
  345. $timeout = 5;
  346. curl_setopt($ch, CURLOPT_URL, $url);
  347. curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  348. curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
  349. $data = curl_exec($ch);
  350. curl_close($ch);
  351.  
  352. return $data;
  353. }
  354. }
  355.  
  356.  
  357. class blConnectionFopen implements blIConnection {
  358. public function getContent( $url ) {
  359.  
  360. $handle = fopen( $url, 'rb' );
  361. $fileContent = '';
  362. if( $handle !== false ) {
  363. while (!feof($handle)) {
  364. $fileContent .= fread($handle, 8192);
  365. }
  366. fclose( $handle );
  367. }
  368. return $fileContent;
  369. }
  370. }
  371.  
  372.  
  373. class blDownloader {
  374. /**
  375. * @var blIConnection
  376. */
  377. private $_connectionMethod = null;
  378.  
  379. public function getContent( $url ) {
  380. return $this->_getConnectionMethod()->getContent($url);
  381.  
  382. }
  383. /**
  384. *
  385. * @param blIConnection $connectionMethod
  386. */
  387. private function _setConnectionMethod( blIConnection $connectionMethod ) {
  388. $this->_connectionMethod = $connectionMethod;
  389. }
  390.  
  391. /**
  392. * @return blIConnection
  393. */
  394. private function _getConnectionMethod() {
  395. if( $this->_connectionMethod == null ) {
  396. $this->_setConnectionMethod( new blConnectionAdapteur() );
  397. }
  398. return $this->_connectionMethod;
  399. }
  400. }
  401.  
  402.  
  403. class blImgCache {
  404. CONST CACHE_FILENAME = 'img_caching_info.frs';
  405.  
  406.  
  407. /**
  408. * @var blFileSystem
  409. */
  410. private $_fileSystem = null;
  411.  
  412. /**
  413. * @var blFile
  414. */
  415. private $_cacheFile = null;
  416.  
  417. private $_cacheFileUnparsed = null;
  418.  
  419. private $_cacheFileParsed = null;
  420.  
  421. private $_cacheFileDir = null;
  422.  
  423. public function __construct( blFileSystem $fileSystem, $cacheFileDir ) {
  424.  
  425. $this->_setFileSystem($fileSystem);
  426. $this->_setCacheFileDir($cacheFileDir . self::CACHE_FILENAME );
  427.  
  428. $this->_loadCacheFile();
  429. $this->_unparseCacheFile();
  430.  
  431. }
  432.  
  433. public function addCachedFileRemote( $urlNew, $pathNew, $urlOld ) {
  434. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  435.  
  436. if( $this->_cacheFileUnparsed == null ) {
  437. $this->_cacheFileUnparsed = new stdClass();
  438. }
  439. if( !isset( $cacheFileUnparsed->remoteDataHolder[ $urlOld ] ) ) {
  440. $cachedFile = new stdClass();
  441. $cachedFile->urlNew = $urlNew;
  442. $cachedFile->pathNew = $pathNew;
  443. $cachedFile->urlOld = $urlOld;
  444. $cachedFile->timestamp = time();
  445.  
  446. $cacheFileUnparsed->remoteDataHolder[ $cachedFile->urlOld] = $cachedFile;
  447. }
  448. }
  449.  
  450. public function addCachedFile( $urlNew, $urlOld, $pathNew, $pathOld, $remote = false ) {
  451. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  452.  
  453. if( $this->_cacheFileUnparsed == null ) {
  454. $this->_cacheFileUnparsed = new stdClass();
  455. }
  456. if( !isset( $cacheFileUnparsed->dataHolder[ $urlNew ] ) ) {
  457. $cachedFile = new stdClass();
  458. $cachedFile->urlNew = $urlNew;
  459. $cachedFile->urlOld = $urlOld;
  460. $cachedFile->pathNew = $pathNew;
  461. $cachedFile->pathOld = $pathOld;
  462. $cachedFile->remote = $remote;
  463. $cachedFile->timestamp = time();
  464.  
  465. $cacheFileUnparsed->dataHolder[ $cachedFile->urlNew] = $cachedFile;
  466. }
  467.  
  468.  
  469. }
  470.  
  471. public function deleteCacheInfo( $urlNew ) {
  472.  
  473.  
  474. unset( $this->_getCacheFileUnparsed()->dataHolder[ $urlNew ] );
  475. }
  476.  
  477. public function deleteRemoteCacheInfo( $url ) {
  478. unset( $this->_getCacheFileUnparsed()->remoteDataHolder[ $url ] );
  479. }
  480.  
  481. public function getCacheInfo( $urlNew ) {
  482. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  483. if( isset( $cacheFileUnparsed->dataHolder[ $urlNew ] ) ) {
  484. $cachedImageInfo = $cacheFileUnparsed->dataHolder[ $urlNew ];
  485. $cachedImageInfo->valid = $this->_checkExpiration($cachedImageInfo);
  486. return $cacheFileUnparsed->dataHolder[ $urlNew ];
  487. } else {
  488. return null;
  489. }
  490. }
  491.  
  492. public function touchCachedFile( $urlNew ) {
  493. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  494. $cacheFileUnparsed->dataHolder[ $urlNew ]->valid = true;
  495. $cacheFileUnparsed->dataHolder[ $urlNew ]->timestamp = time();
  496. }
  497.  
  498. public function getRemoteCacheInfo( $urlOld ) {
  499. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  500. if( isset( $cacheFileUnparsed->remoteDataHolder[ $urlOld ] ) ) {
  501. $cachedImageInfo = $cacheFileUnparsed->remoteDataHolder[ $urlOld ];
  502. $cachedImageInfo->valid = $this->_checkExpiration($cachedImageInfo);
  503. return $cacheFileUnparsed->remoteDataHolder[ $urlOld ];
  504. } else {
  505. return null;
  506. }
  507. }
  508.  
  509. private function _checkExpiration( stdClass $cachedImageInfo ) {
  510. $currentTimestamp = time();
  511. $oldTimestamp = $cachedImageInfo->timestamp;
  512.  
  513. if( ( $oldTimestamp + CACHE_TIME ) < $currentTimestamp ) {
  514. return false;
  515. } else {
  516. return true;
  517. }
  518. }
  519.  
  520. /*public function deleteCacheInfo( $urlNew ) {
  521. $cacheFileUnparsed = $this->_getCacheFileUnparsed();
  522. unset( $cacheFileUnparsed->dataHolder[ $urlNew ] );
  523.  
  524. }*/
  525.  
  526. public function __destruct() {
  527.  
  528. $this->saveCacheFile();
  529. }
  530.  
  531. public function saveCacheFile() {
  532.  
  533. $this->_parseCacheFile();
  534. $this->_saveCacheFile();
  535. }
  536.  
  537. private function _parseCacheFile() {
  538. $cacheFileParsed = serialize( $this->_getCacheFileUnparsed() );
  539. $this->_setCacheFileParsed( $cacheFileParsed );
  540. }
  541.  
  542. private function _saveCacheFile() {
  543. if( $this->_getCacheFile()->getHandle() == null ) return ;
  544. $this->_getCacheFile()
  545. ->truncate()
  546. ->write( $this->_getCacheFileParsed() )
  547. ->closeFile();
  548. }
  549.  
  550.  
  551. private function _loadCacheFile() {
  552. $cacheFile = $this->_getFileSystem()->openFile( $this->_getCacheFileDir(), true);
  553.  
  554. $this->_setCacheFile( $cacheFile );
  555. $this->_setCacheFileParsed( $cacheFile->readAll() );
  556.  
  557. }
  558.  
  559. private function _unparseCacheFile() {
  560. if( $this->_getCacheFileParsed() != '') {
  561. $cacheFileContentUnparsed = unserialize( $this->_getCacheFileParsed() );
  562. $cacheFileContentUnparsed->hitsAfterLastDelete++;
  563.  
  564. $this->_setCacheFileUnparsed( $cacheFileContentUnparsed );
  565. } else {
  566. $cacheFileContentUnparsed = new stdClass();
  567. $cacheFileContentUnparsed->hitsAfterLastDelete = 1;
  568. $this->_setCacheFileUnparsed( $cacheFileContentUnparsed );
  569. }
  570.  
  571. if( $cacheFileContentUnparsed->hitsAfterLastDelete >= CACHE_DELETE_FILES_check_every_x_hits ) {
  572. $this->_hardDeleteCache();
  573. }
  574. }
  575.  
  576. private function _hardDeleteCache() {
  577. //var_dump(CACHE_DELETE_FILES_check_every_x_hits);
  578. $unsetArray = array();
  579. if( !empty( $this->_getCacheFileUnparsed()->dataHolder ) ) {
  580. foreach( $this->_getCacheFileUnparsed()->dataHolder as $url => $fileData ) {
  581. //pathNew, timestamp
  582. if( ( $fileData->timestamp + CACHE_DELETE_FILES_AFTER ) <= time() ) {
  583. $unsetArray[] = $url;
  584. unlink( $fileData->pathNew);
  585. }
  586. }
  587. }
  588. foreach( $unsetArray as $oneUrl ) {
  589. unset ($this->_getCacheFileUnparsed()->dataHolder[ $oneUrl ] );
  590. }
  591.  
  592. $unsetArray = array();
  593. if( !empty( $this->_getCacheFileUnparsed()->remoteDataHolder ) ) {
  594. foreach( $this->_getCacheFileUnparsed()->remoteDataHolder as $url => $fileData ) {
  595. //pathNew, timestamp
  596. if( ( $fileData->timestamp + CACHE_DELETE_FILES_AFTER ) <= time() ) {
  597. $unsetArray[] = $url;
  598. unlink( $fileData->pathNew);
  599. }
  600. }
  601. }
  602. foreach( $unsetArray as $oneUrl ) {
  603. unset ($this->_getCacheFileUnparsed()->remoteData[ $oneUrl ] );
  604. }
  605. $this->_getCacheFileUnparsed()->hitsAfterLastDelete = 0;
  606. }
  607.  
  608.  
  609. private function _setCacheFileParsed( $cacheFileParsed ) {
  610. $this->_cacheFileParsed = $cacheFileParsed;
  611. }
  612.  
  613. private function _getCacheFileParsed() {
  614. return $this->_cacheFileParsed;
  615. }
  616.  
  617. private function _setCacheFileUnparsed( $cacheFileUnparsed ) {
  618. $this->_cacheFileUnparsed = $cacheFileUnparsed;
  619. }
  620.  
  621. private function _getCacheFileUnparsed() {
  622. return $this->_cacheFileUnparsed;
  623. }
  624.  
  625. private function _setCacheFileDir( $cacheFileDir) {
  626. $this->_cacheFileDir = $cacheFileDir;
  627. }
  628.  
  629. private function _getCacheFileDir() {
  630. return $this->_cacheFileDir;
  631. }
  632.  
  633. private function _setCacheFile( blFile $cacheFile ) {
  634. $this->_cacheFile = $cacheFile;
  635. }
  636.  
  637. /**
  638. * @return blFile
  639. */
  640. private function _getCacheFile() {
  641. return $this->_cacheFile;
  642. }
  643.  
  644. private function _setFileSystem( blFileSystem $fileSystem ) {
  645. $this->_fileSystem = $fileSystem;
  646. }
  647.  
  648. /**
  649. *
  650. * @return blFileSystem
  651. */
  652. private function _getFileSystem() {
  653. return $this->_fileSystem;
  654. }
  655. }
  656.  
  657.  
  658. class blImgDownloader {
  659. /**
  660. * @var blFileSystem
  661. */
  662. private $_fileSystem = null;
  663.  
  664. /**
  665. * @var blInputStreamAdapteour
  666. */
  667. private $_inputStream = null;
  668.  
  669. public function __construct( blFileSystem $fileSystem, blInputStreamAdapteour $inputStreamAdapter ) {
  670. $this->_setFileSystem( $fileSystem );
  671. $this->_setInputStream( $inputStreamAdapter );
  672. }
  673.  
  674. public function downloadImage( $originalPath, $newPath ) {
  675. $img = $this->_getInputStream()->open( $originalPath )->readAll();
  676. if( $img != null ) {
  677. $this->_getFileSystem()->createFile( $newPath, true)->write( $img )->closeFile();
  678. }
  679. }
  680.  
  681. private function _setInputStream( blInputStreamAdapteour $inputStreamAdapter ) {
  682. $this->_inputStream = $inputStreamAdapter;
  683. }
  684.  
  685. /**
  686. * @return blInputStreamAdapteour
  687. */
  688. private function _getInputStream() {
  689. return $this->_inputStream;
  690. }
  691.  
  692. private function _setFileSystem( blFileSystem $fileSystem ) {
  693. $this->_fileSystem = $fileSystem;
  694. }
  695. /**
  696. * @return blFileSystem
  697. */
  698. private function _getFileSystem() {
  699. return $this->_fileSystem;
  700. }
  701. }
  702.  
  703.  
  704. interface blIInputStream {
  705. public function open( $path );
  706. public function readAll();
  707.  
  708. }
  709.  
  710.  
  711. class blInputStreamFile implements blIInputStream {
  712. /**
  713. * @var blFileSystem
  714. */
  715. private $_fileSystem = null;
  716.  
  717. /**
  718. * @var blFile
  719. */
  720. private $_openedFile = null;
  721.  
  722. public function __construct() {
  723.  
  724. }
  725.  
  726. /**
  727. * (non-PHPdoc)
  728. * @see blIInputStream::open()
  729. */
  730. public function open( $path ) {
  731. $file = $this->_getFileSystem()->openFile($path);
  732. $this->_setFile( $file );
  733. return $this;
  734. }
  735.  
  736. public function readAll() {
  737. return $this->_getFile()->readAllAndClose();
  738. }
  739.  
  740. /*----------------------------------------------------------------------------*/
  741. /* SETTERS AND GETTERS
  742. /*----------------------------------------------------------------------------*/
  743. private function _setFileSystem( blFileSystem $fileSystem ) {
  744. $this->_fileSystem = $fileSystem;
  745. }
  746.  
  747. /**
  748. * @return blFileSystem
  749. */
  750. private function _getFileSystem() {
  751. if( $this->_fileSystem == null ) {
  752. $this->_setFileSystem( new blFileSystem() );
  753. }
  754.  
  755. return $this->_fileSystem;
  756. }
  757.  
  758. private function _setFile( blFile $file ) {
  759. $this->_openedFile = $file;
  760. }
  761.  
  762. /**
  763. * @return blFile
  764. */
  765. private function _getFile() {
  766. return $this->_openedFile;
  767. }
  768. }
  769.  
  770.  
  771. class blInputStreamHttp implements blIInputStream {
  772. /**
  773. * @var blDownloader
  774. */
  775. private $_downloader = null;
  776. private $_pageContent = '';
  777.  
  778. public function open( $path ) {
  779. $content = $this->_getDownloader()->getContent( $path );
  780. $this->_setPageContent( $content );
  781. }
  782.  
  783. public function readAll() {
  784. return $this->_getPageContent();
  785. }
  786.  
  787. /**
  788. * @return blDownloader
  789. */
  790. private function _getDownloader() {
  791. if( $this->_downloader == null ) {
  792. $this->_downloader = new blDownloader();
  793. }
  794.  
  795. return $this->_downloader;
  796. }
  797.  
  798. private function _setPageContent( $pageContent ) {
  799. $this->_pageContent = $pageContent;
  800. }
  801.  
  802. private function _getPageContent() {
  803. return $this->_pageContent;
  804. }
  805. }
  806.  
  807.  
  808. class blInputStreamAdapteour implements blIInputStream {
  809. /**
  810. *
  811. * @var blIInputStream
  812. */
  813. private $_inputStream = null;
  814.  
  815. /*----------------------------------------------------------------------------*/
  816. /* PUBLIC FUNCTIONS
  817. /*----------------------------------------------------------------------------*/
  818.  
  819. public function open( $path ) {
  820. $this->_createInputStream( $path );
  821. $this->_getInputStream()->open($path);
  822. return $this;
  823. }
  824.  
  825. public function readAll() {
  826. return $this->_getInputStream()->readAll();
  827. }
  828.  
  829. /*----------------------------------------------------------------------------*/
  830. /* PRIVATE FUNCTIONS
  831. /*----------------------------------------------------------------------------*/
  832. private function _createInputStream( $path ) {
  833. if( strpos( $path, 'http://') !== false ) {
  834. $this->_setInputStream( new blInputStreamHttp() );
  835. } else {
  836. $this->_setInputStream( new blInputStreamFile() );
  837. }
  838. }
  839. /*----------------------------------------------------------------------------*/
  840. /* SETTERS AND GETTERS
  841. /*----------------------------------------------------------------------------*/
  842.  
  843. private function _setInputStream( blIInputStream $inputStream ) {
  844. $this->_inputStream = $inputStream;
  845. }
  846.  
  847. private function _getInputStream() {
  848. return $this->_inputStream;
  849. }
  850. }
  851.  
  852.  
  853. class fImgOneData {
  854. public $path = null;
  855. public $url = null;
  856. public $filename = null;
  857. public $width = null;
  858. public $height = null;
  859. public $timestamp = null;
  860. public $crop = null;
  861. }
  862.  
  863. class fImgData {
  864. /**
  865. *
  866. * @var fImgOneData
  867. */
  868. public $new = null;
  869.  
  870. /**
  871. *
  872. * @var fImgOneData
  873. */
  874. public $old = null;
  875.  
  876. public $remote = false;
  877. public $ready = false;
  878.  
  879. public function __construct() {
  880. $this->new = new fImgOneData();
  881. $this->old = new fImgOneData();
  882. }
  883.  
  884. }
  885.  
  886.  
  887.  
  888.  
  889. class fImgDeliverer {
  890. /**
  891. * @var blFileSystem
  892. */
  893. private $_fileSystem = null;
  894.  
  895.  
  896. /**
  897. *
  898. * @var blInputStreamAdapteour
  899. */
  900. private $_inputStream = null;
  901.  
  902. /**
  903. * @var blImgCache
  904. */
  905. private $_imgCache = null;
  906.  
  907. /**
  908. *
  909. * @var fImgPathPredictor
  910. */
  911. private $_imgPredictor = null;
  912.  
  913.  
  914. /**
  915. *
  916. * @var blImgDownloader
  917. */
  918. private $_imgDownloader = null;
  919.  
  920. private $_uploadDir = null;
  921.  
  922. private $_uploadUrl = null;
  923.  
  924. /**
  925. *
  926. * @var fImgNamer
  927. */
  928. private $_imgNamer = null;
  929.  
  930. public function __construct( blFileSystem $fileSystem, $inputStream, blImgCache $imgCache, $uploadDir, $uploadUrl ) {
  931. $this->_setFileSystem( $fileSystem );
  932. $this->_setInputStream( $inputStream );
  933. $this->_setImgCache( $imgCache);
  934. $this->_setUploadDir( $uploadDir );
  935. $this->_setUploadUrl( $uploadUrl );
  936. }
  937.  
  938. /**
  939. *
  940. * @param fImgData $imgData
  941. * @return fImgData
  942. */
  943. public function deliveryImage( fImgData $imgData ) {
  944. $result = $this->_deliveryFromCache( $imgData );
  945. //$result = false;
  946. if( $result === false )
  947. $result = $this->_deliveryFromLocal( $imgData );
  948. if( $result === false )
  949. $result = $this->_deliveryFromRemote( $imgData );
  950.  
  951. return $result;
  952. }
  953.  
  954. private function _deliveryFromCache( fImgData $imgData ) {
  955.  
  956. $cacheInfo = $this->_getImgCache()->getCacheInfo( $imgData->new->url );
  957.  
  958. if( $cacheInfo == null ) return false;
  959.  
  960. $imgData->new->path = $this->_getUploadDirPath( $imgData->new->filename );
  961. $cacheValidity = $this->_checkCacheValidity( $imgData, $cacheInfo );
  962. if( $cacheValidity === false ) return false;
  963.  
  964. $imgData->ready = true;
  965.  
  966. return $imgData;
  967. }
  968.  
  969. private function _checkCacheValidity( fImgData $imgData, $cacheInfo ) {
  970. if( $cacheInfo->valid == true ) return true;
  971.  
  972. if( !file_exists( $cacheInfo->pathOld) ) {
  973. $this->_getImgCache()->deleteCacheInfo( $imgData->new->url );
  974. $this->_getFileSystem()->deleteFile( $imgData->new->path );
  975. return false;
  976. }
  977. $newTS = $cacheInfo->timestamp;
  978. $oldTS = filemtime( $cacheInfo->pathOld );
  979. if( $newTS > $oldTS ) {
  980. $this->_getImgCache()->touchCachedFile( $imgData->new->url );
  981. return true;
  982. } else {
  983. $this->_getImgCache()->deleteCacheInfo( $imgData->new->url );
  984. $this->_getFileSystem()->deleteFile( $imgData->new->path );
  985. return false;
  986. }
  987. }
  988.  
  989. private function _deliveryFromLocal( fImgData $imgData ) {
  990. $path = $this->_getImgPredictor()->predictPath( $imgData->old->url );
  991.  
  992. if( $path != null ) {
  993. $imgData->old->path = $path;
  994. if ($this->_doesntHasAlphaLayer($path) && false ) {
  995. $imgData->new->filename = $this->_getImgNamer()->renameToJpg( $imgData->new->filename );
  996. $imgData->new->url = $this->_getImgNamer()->renameToJpg( $imgData->new->url );
  997. }
  998. $imgData->new->path = $this->_getUploadDirPath( $imgData->new->filename );
  999. $imgData->ready = false;
  1000.  
  1001. return $imgData;
  1002. } else {
  1003. return false;
  1004. }
  1005. }
  1006.  
  1007. private function _doesntHasAlphaLayer( $path ) {
  1008. if( file_exists( $path )) {
  1009. $pathInfo = pathInfo($path);
  1010.  
  1011. if( $pathInfo['extension'] != 'png') {
  1012. return false;
  1013. }
  1014.  
  1015. $firstChars = $this->_getFileSystem()->openFile($path)->read(26);//->pointerTo(25)->read(1);
  1016. //var_dump($firstChars);
  1017. $char = $firstChars[25];
  1018. $pngType = (ord($char));
  1019. // var_dump($pngType);
  1020. }
  1021. if( $pngType == 6 ) {
  1022. return false;
  1023. } else {
  1024. return true;
  1025. }
  1026. }
  1027.  
  1028. private function _deliveryFromRemote( fImgData $imgData ) {
  1029.  
  1030. $remoteFilename = $this->_getImgNamer()->getRemoteImageName( $imgData->old->url );
  1031. $remotePath = $this->_getUploadDirPath('remote/' . $remoteFilename);
  1032. $remoteUrl = $this->_getUploadUrlPath('remote/' . $remoteFilename);
  1033.  
  1034. $remoteFileCacheInfo = $this->_getImgCache()
  1035. ->getRemoteCacheInfo($imgData->old->url);
  1036. //->getCacheInfo( $remotePath);
  1037.  
  1038. if( $remoteFileCacheInfo != null && $remoteCacheInfo->valid == false ) {
  1039.  
  1040. $remoteFileCacheInfo = null;
  1041. $this->_getImgCache()->deleteRemoteCacheInfo( $remoteUrl );
  1042. $this->_getFileSystem()->deleteFile( $remotePath );
  1043. }
  1044.  
  1045. if( $remoteFileCacheInfo == null ) {
  1046.  
  1047. $this->_getImgDownloader()->downloadImage($imgData->old->url, $remotePath );
  1048. if( file_exists( $remotePath) ) {
  1049. $this->_getImgCache()->addCachedFileRemote($remoteUrl, $remotePath, $imgData->old->url);
  1050. //$this->_getImgCache()->addCachedFile($urlNew, $urlOld, $pathNew, $pathOld, $remote)
  1051. }
  1052. }
  1053. $imgData->new->path = $this->_getUploadDirPath( $imgData->new->filename );
  1054. $imgData->old->url = $remoteUrl;
  1055. $imgData->old->path = $remotePath;
  1056. $imgData->ready = false;
  1057. $imgData->remote = true;
  1058.  
  1059. return $imgData;
  1060. }
  1061.  
  1062.  
  1063.  
  1064. /*----------------------------------------------------------------------------*/
  1065. /* SETTERS AND GETTERS
  1066. /*----------------------------------------------------------------------------*/
  1067. private function _getUploadDirPath( $path ) {
  1068. return $this->_getUploadDir() . $path;
  1069. }
  1070.  
  1071. private function _getUploadUrlPath ( $path ) {
  1072. return $this->_getUploadUrl() .'/'. $path;
  1073. }
  1074.  
  1075.  
  1076. private function _getUploadUrl() {
  1077. return $this->_uploadUrl;
  1078. }
  1079.  
  1080. private function _setUploadUrl( $uploadUrl ) {
  1081. $this->_uploadUrl = $uploadUrl;
  1082. }
  1083. private function _getImgDownloader() {
  1084. if( $this->_imgDownloader == null ) {
  1085. $this->_imgDownloader = new blImgDownloader( $this->_getFileSystem(), $this->_getInputStream() );
  1086. }
  1087.  
  1088. return $this->_imgDownloader;
  1089. }
  1090.  
  1091. private function _getImgNamer() {
  1092. if( $this->_imgNamer == null ) {
  1093. $this->_imgNamer = new fImgNamer();
  1094. }
  1095.  
  1096. return $this->_imgNamer;
  1097. }
  1098.  
  1099. private function _setUploadDir( $uploadDir ) {
  1100. $this->_uploadDir = $uploadDir;
  1101. }
  1102.  
  1103. private function _getUploadDir() {
  1104. return $this->_uploadDir;
  1105. }
  1106.  
  1107. /**
  1108. * @return fImgPathPredictor
  1109. */
  1110. private function _getImgPredictor() {
  1111. if( $this->_imgPredictor == null ) {
  1112. $this->_imgPredictor = new fImgPathPredictor();
  1113. }
  1114.  
  1115. return $this->_imgPredictor;
  1116. }
  1117.  
  1118. private function _setImgCache( blImgCache $imgCache ) {
  1119. $this->_imgCache = $imgCache;
  1120. }
  1121.  
  1122. /**
  1123. *
  1124. * @return blImgCache
  1125. */
  1126. private function _getImgCache(){
  1127. return $this->_imgCache;
  1128. }
  1129. private function _setFileSystem( blFileSystem $fileSystem ) {
  1130. $this->_fileSystem = $fileSystem;
  1131. }
  1132.  
  1133. /**
  1134. * @return blFileSystem
  1135. */
  1136. private function _getFileSystem() {
  1137. return $this->_fileSystem;
  1138. }
  1139.  
  1140. private function _setInputStream( blInputStreamAdapteour $inputStream ) {
  1141. $this->_inputStream = $inputStream;
  1142. }
  1143.  
  1144. /**
  1145. * @return blInputStreamAdapteour
  1146. */
  1147. private function _getInputStream() {
  1148. return $this->_inputStream;
  1149. }
  1150. }
  1151.  
  1152.  
  1153. class fImgNamer {
  1154. private $_defaultUrl = null;
  1155. private $_temporaryPathInfo = null;
  1156.  
  1157. public function __construct( $defaultUrl = null ) {
  1158. $this->_setDefaultUrl( $defaultUrl );
  1159. }
  1160. public function getNewImageName( $oldUrl, $width, $height = false, $crop = false, $remote = false) {
  1161. $newUrl = '';
  1162.  
  1163. $partRemote = ( $remote ) ? 'remote/' : '';
  1164. $partWidth = '-'.$width;
  1165. $partHeight = ( $height ) ? '-'.$height : '';
  1166. $partCrop = ( $crop ) ? '-c' : '';
  1167.  
  1168. //$newUrl .= $this->_getDefaultUrl() .'/';
  1169. $newUrl .= $partRemote;
  1170. $newUrl .= $this->_getUrlHash( $oldUrl ) . '_' ;
  1171. $newUrl .= $this->_getImgName( $oldUrl );
  1172. $newUrl .= $partWidth;
  1173. $newUrl .= $partHeight;
  1174. $newUrl .= $partCrop;
  1175. $newUrl .= $this->_getImgExtension();
  1176.  
  1177. return $newUrl;
  1178. }
  1179. public function renameToJpg( $path ) {
  1180. $pathInfo = ( pathinfo($path));
  1181. //var_dump( $pathInfo['dirname'] == '.');
  1182. ( $pathInfo['dirname'] == '.' ) ? $dirname = '' : $dirname = $pathInfo['dirname'] .'/';
  1183. $toReturn =$dirname . $pathInfo['filename'] . '.jpg';
  1184. //var_dump($toReturn);
  1185. return $toReturn;
  1186. }
  1187. public function getNewImageUrl( $oldUrl, $width, $height = false, $crop = false, $remote = false ) {
  1188. /**
  1189. * http://defaulturl(freshizer)/[remote]/$oldUrlHash_imgFilename-width[-height][-c(rop)].ext
  1190. */
  1191. $newUrl = '';
  1192.  
  1193. $partRemote = ( $remote ) ? 'remote/' : '';
  1194. $partWidth = '-'.$width;
  1195. $partHeight = ( $height ) ? '-'.$height : '';
  1196. $partCrop = ( $crop ) ? '-c' : '';
  1197.  
  1198. $newUrl .= $this->_getDefaultUrl() .'/';
  1199. $newUrl .= $partRemote;
  1200. $newUrl .= $this->_getUrlHash( $oldUrl ) . '_' ;
  1201. $newUrl .= $this->_getImgName( $oldUrl );
  1202. $newUrl .= $partWidth;
  1203. $newUrl .= $partHeight;
  1204. $newUrl .= $partCrop;
  1205. $newUrl .= $this->_getImgExtension();
  1206.  
  1207.  
  1208. return $newUrl;
  1209. }
  1210.  
  1211. public function getRemoteImageName( $url ) {
  1212. $pathInfo = pathinfo( $url );
  1213. $newName = '';
  1214. $newName .= $this->_getUrlHash( $url );
  1215. $newName .= '-'.$pathInfo['filename'].'.'.$pathInfo['extension'];
  1216.  
  1217. return $newName;
  1218. }
  1219.  
  1220. private function _getImgExtension() {
  1221. $pathInfo = $this->_getTemporaryPathInfo();
  1222. return '.'.$pathInfo['extension'];
  1223. }
  1224.  
  1225. private function _getImgName( $oldUrl ) {
  1226. $pathInfo = pathinfo( $oldUrl );
  1227. $this->_setTemporaryPathInfo( $pathInfo );
  1228. return $pathInfo['filename'];
  1229. }
  1230.  
  1231. private function _setTemporaryPathInfo( $pathInfo ) {
  1232. $this->_temporaryPathInfo = $pathInfo;
  1233. }
  1234.  
  1235. private function _getTemporaryPathInfo() {
  1236. return $this->_temporaryPathInfo;
  1237. }
  1238.  
  1239. private function _getUrlHash( $url ) {
  1240. return md5($url);
  1241. }
  1242.  
  1243. private function _setDefaultUrl( $defaultUrl ) {
  1244. $this->_defaultUrl = $defaultUrl;
  1245. }
  1246.  
  1247. private function _getDefaultUrl() {
  1248. return $this->_defaultUrl;
  1249. }
  1250. }
  1251.  
  1252.  
  1253. interface fIImgPathPredictor {
  1254. public function predictPath( $url );
  1255.  
  1256. /*private function _predictionJunction();
  1257. private function _predictUploads();
  1258. private function _predictThemes();
  1259. private function _predictPlugins();*/
  1260. }
  1261.  
  1262. class fAImgPathPredictor implements fIImgPathPredictor {
  1263. public function predictPath( $url ) {}
  1264.  
  1265. protected function _predictUploads() {}
  1266. protected function _predictThemes() {}
  1267. protected function _predictPlugins() {}
  1268. }
  1269.  
  1270.  
  1271. class fImgPathPredictor {
  1272.  
  1273. /**
  1274. *
  1275. * @var fIImgPathPredictor
  1276. */
  1277. private $_predictor = null;
  1278.  
  1279. public function predictPath( $url ) {
  1280. return $this->_getPredictor()->predictPath( $url );
  1281. }
  1282.  
  1283.  
  1284. private function _initializePredictor() {
  1285. global $blog_id;
  1286.  
  1287. if( is_multisite() && $blog_id != 1) {
  1288. $this->_setPredictor( new fImgPathPredictor_Multisite() );
  1289. } else {
  1290. $this->_setPredictor( new fImgPathPredictor_Single() );
  1291. }
  1292. }
  1293.  
  1294. private function _setPredictor( fIImgPathPredictor $predictor) {
  1295. $this->_predictor = $predictor;
  1296. }
  1297.  
  1298. /**
  1299. * @return fIImgPathPredictor
  1300. */
  1301. private function _getPredictor() {
  1302. if( $this->_predictor == null ) {
  1303. $this->_initializePredictor();
  1304. }
  1305.  
  1306. return $this->_predictor;
  1307. }
  1308. }
  1309. class fImgPathPredictor_Multisite extends fAImgPathPredictor implements fIImgPathPredictor {
  1310. private $_imgUrl = null;
  1311. private $_predictedPath = null;
  1312.  
  1313. public function predictPath( $url ) {
  1314. $this->_setImgUrl( $url );
  1315. $this->_predictionJunction();
  1316.  
  1317. return $this->_getPredictedPath();
  1318. }
  1319.  
  1320. protected function _predictionJunction() {
  1321. //echo $this->_getImgUrl().'xxxx';
  1322. //return;
  1323. $uploadDir = wp_upload_dir();
  1324.  
  1325. if( strpos( $this->_getImgUrl(), $uploadDir['baseurl']) !== false ) {
  1326. $this->_predictUploads();
  1327. } else if ( strpos( $this->_getImgUrl(), 'wp-content/themes') !== false ) {
  1328. $this->_predictThemes();
  1329. } else if ( strpos( $this->_getImgUrl(), 'wp-content/themes') !== false ) {
  1330. $this->_predictPlugins();
  1331. }
  1332.  
  1333. }
  1334.  
  1335. protected function _predictUploads() {
  1336. $uploadDir = wp_upload_dir();
  1337. $uploadSubpath = str_replace( $uploadDir['baseurl'],'', $this->_getImgUrl());
  1338.  
  1339. $newRelPath = $uploadDir['basedir'].$uploadSubpath;
  1340.  
  1341. if( file_exists( $newRelPath) ) {
  1342. $this->_setPredictedPath( $newRelPath );
  1343. }
  1344.  
  1345.  
  1346. }
  1347. protected function _predictThemes() {
  1348. $splitedUrl = explode('themes/', $this->_getImgUrl() ); //explode() $this->_getImgUrl();
  1349. $splitedPath = explode('themes/', get_template_directory() );
  1350. $newRelPath = $splitedPath[0].'themes/'.$splitedUrl[1];
  1351.  
  1352. if( file_exists( $newRelPath )) {
  1353. $this->_setPredictedPath( $newRelPath );
  1354. }
  1355. }
  1356. protected function _predictPlugins() {
  1357. $imgPluginDirSplitted = explode('wp-content/plugins', $this->_getImgUrl() );
  1358. $imgAfterPluginDir = $imgPluginDirSplited[1];
  1359.  
  1360. $pluginDir = WP_PLUGIN_DIR;
  1361. $newRelPath = $pluginDir . $imgAfterPluginDir;
  1362.  
  1363. if( file_exists( $newRelPath ) ) {
  1364. $this->_setPredictedPath( $newRelPath );
  1365. }
  1366.  
  1367.  
  1368.  
  1369. }
  1370.  
  1371.  
  1372. private function _getPredictedPath() {
  1373. return $this->_predictedPath;
  1374. }
  1375.  
  1376. private function _setPredictedPath( $predictedPath ) {
  1377. $this->_predictedPath = $predictedPath;
  1378. }
  1379.  
  1380. private function _setImgUrl( $imgUrl ) {
  1381. $this->_imgUrl = $imgUrl;
  1382. }
  1383.  
  1384. private function _getImgUrl() {
  1385. return $this->_imgUrl;
  1386. }
  1387. }
  1388.  
  1389. class fImgPathPredictor_Single extends fAImgPathPredictor implements fIImgPathPredictor {
  1390. private $_imgUrl = null;
  1391. private $_predictedPath = null;
  1392.  
  1393. public function predictPath( $url ) {
  1394. $this->_setImgUrl( $url );
  1395. $this->_predictionJunction();
  1396. return $this->_getPredictedPath();
  1397. }
  1398.  
  1399. protected function _predictionJunction() {
  1400. if( strpos( $this->_getImgUrl(), 'wp-content/uploads') !== false ) {
  1401. $this->_predictUploads();
  1402. } else if ( strpos( $this->_getImgUrl(), 'wp-content/themes') !== false ) {
  1403. $this->_predictThemes();
  1404. } else if ( strpos( $this->_getImgUrl(), 'wp-content/themes') !== false ) {
  1405. $this->_predictPlugins();
  1406. }
  1407.  
  1408. }
  1409.  
  1410. protected function _predictUploads() {
  1411. $imgUploadDirSplited = explode('wp-content/uploads', $this->_getImgUrl() );
  1412. $imgAfterUploadDir = $imgUploadDirSplited[1];
  1413. $wpUploadDir = wp_upload_dir();
  1414. $baseDir = $wpUploadDir['basedir'];
  1415.  
  1416. $newRelPath = $baseDir . $imgAfterUploadDir;
  1417.  
  1418. if( file_exists( $newRelPath) ) {
  1419. $this->_setPredictedPath( $newRelPath );
  1420. }
  1421.  
  1422.  
  1423. }
  1424. protected function _predictThemes() {
  1425. $imgThemeDirSplited = explode('wp-content/themes', $this->_getImgUrl() );
  1426. $imgAfterThemeDir = $imgThemeDirSplited[1];
  1427.  
  1428. $currentThemeDirSplited = explode( 'wp-content/themes', get_template_directory());
  1429. $currentThemeFolder = $currentThemeDirSplited[0];
  1430.  
  1431. $newRelPath = $currentThemeFolder . 'wp-content/themes' . $imgAfterThemeDir;
  1432.  
  1433. if( file_exists( $newRelPath )) {
  1434. $this->_setPredictedPath( $newRelPath );
  1435. }
  1436. }
  1437. protected function _predictPlugins() {
  1438. $imgPluginDirSplitted = explode('wp-content/plugins', $this->_getImgUrl() );
  1439. $imgAfterPluginDir = $imgPluginDirSplited[1];
  1440.  
  1441. $pluginDir = WP_PLUGIN_DIR;
  1442. $newRelPath = $pluginDir . $imgAfterPluginDir;
  1443.  
  1444. if( file_exists( $newRelPath ) ) {
  1445. $this->_setPredictedPath( $newRelPath );
  1446. }
  1447.  
  1448. }
  1449.  
  1450.  
  1451. private function _getPredictedPath() {
  1452. return $this->_predictedPath;
  1453. }
  1454.  
  1455. private function _setPredictedPath( $predictedPath ) {
  1456. $this->_predictedPath = $predictedPath;
  1457. }
  1458.  
  1459. private function _setImgUrl( $imgUrl ) {
  1460. $this->_imgUrl = $imgUrl;
  1461. }
  1462.  
  1463. private function _getImgUrl() {
  1464. return $this->_imgUrl;
  1465. }
  1466. }
  1467.  
  1468.  
  1469. class fImgResizer {
  1470.  
  1471. /**
  1472. *
  1473. * @var blFileSystem
  1474. */
  1475. private $_fileSystem = null;
  1476.  
  1477. /**
  1478. * @var fImgResizerCalculator
  1479. */
  1480. private $_imgResizerCalculator = null;
  1481.  
  1482. private $_imgHasAlfaChannel = null;
  1483.  
  1484. public function __construct( blFileSystem $fileSystem ) {
  1485. $this->_setFileSystem($fileSystem);
  1486. }
  1487.  
  1488. public function resize( fImgData $imgData ) {// stdClass $pathInfo, stdClass $imgInfo ) {
  1489. //var_dump($imgData);
  1490. $imageOld = $this->_openImage( $imgData->old->path );
  1491. $orig = $this->_getImgDimensions( $imgData->old->path );
  1492.  
  1493.  
  1494. $newDimensions = $this->_getImgResizerCalculator()->calculateNewDimensions( $orig->width,
  1495. $orig->height,
  1496. $imgData->new->width,
  1497. $imgData->new->height,
  1498. $imgData->new->crop );
  1499.  
  1500. $imageNew = $this->_createImage( $newDimensions['dst']['w'],$newDimensions['dst']['h']);
  1501.  
  1502.  
  1503. imagecopyresampled($imageNew, $imageOld, $newDimensions['dst']['x'],
  1504. $newDimensions['dst']['y'],
  1505. $newDimensions['src']['x'],
  1506. $newDimensions['src']['y'],
  1507. $newDimensions['dst']['w'],
  1508. $newDimensions['dst']['h'],
  1509. $newDimensions['src']['w'],
  1510. $newDimensions['src']['h']);
  1511. if(function_exists('imageantialias') ) {
  1512. imageantialias( $imageNew, true );
  1513. }
  1514. $pathInfo = pathinfo($imgData->old->path);
  1515.  
  1516. if ( $pathInfo['extension'] == 'png' && function_exists('imageistruecolor') && !imageistruecolor( $imageOld ) ) {
  1517. imagetruecolortopalette( $imageNew, false, imagecolorstotal( $imageOld ) );
  1518. }
  1519. $this->_getFileSystem()->saveImage( $imageNew, $imgData->new->path );
  1520.  
  1521. imagedestroy($imageOld);
  1522. imagedestroy($imageNew);
  1523. $this->_imgHasAlfaChannel = null;
  1524. $dimToReturn = array();
  1525.  
  1526. }
  1527.  
  1528. private function _openImage( $path ) {
  1529. $imageString = $this->_getFileSystem()->openFile( $path )->readAllAndClose();
  1530. $pathInfo = pathinfo($path);
  1531. if( $pathInfo['extension'] == 'png' && ord($imageString[25]) == 6 )
  1532. $this->_imgHasAlfaChannel = true;
  1533. //return (ord(@file_get_contents($fn, NULL, NULL, 25, 1)) == 6);
  1534. @ini_set( 'memory_limit', '256M' );
  1535. $image = imagecreatefromstring( $imageString );
  1536. return $image;
  1537. }
  1538.  
  1539.  
  1540. private function _getImgDimensions( $path ) {
  1541. $dim = getimagesize( $path );
  1542. $result = new stdClass();
  1543. $result->width = $dim[0];
  1544. $result->height = $dim[1];
  1545. return $result;
  1546. }
  1547. private function _createImage ($width, $height) {
  1548. $img = imagecreatetruecolor($width, $height);
  1549. if ( is_resource($img) && $this->_imgHasAlfaChannel && function_exists('imagealphablending') && function_exists('imagesavealpha') ) {
  1550. imagealphablending($img, false);
  1551. imagesavealpha($img, true);
  1552. }
  1553. return $img;
  1554. }
  1555.  
  1556. /*----------------------------------------------------------------------------*/
  1557. /* SETTERS AND GETTERS
  1558. /*----------------------------------------------------------------------------*/
  1559. private function _getImgResizerCalculator() {
  1560. if( $this->_imgResizerCalculator == null ) {
  1561. $this->_imgResizerCalculator = new fImgResizerCalculator();
  1562. }
  1563.  
  1564. return $this->_imgResizerCalculator;
  1565. }
  1566.  
  1567. /**
  1568. * @return blFileSystem
  1569. */
  1570. private function _getFileSystem() {
  1571. return $this->_fileSystem;
  1572. }
  1573.  
  1574. private function _setFileSystem( $fileSystem ) {
  1575. $this->_fileSystem = $fileSystem;
  1576. }
  1577. }
  1578.  
  1579.  
  1580. class fImgResizerCalculator {
  1581. public function calculateNewDimensions($orig_w, $orig_h, $dest_w, $dest_h, $crop = false) {
  1582.  
  1583. if ( $crop ) {
  1584.  
  1585. // crop the largest possible portion of the original image that we can size to $dest_w x $dest_h
  1586. $aspect_ratio = $orig_w / $orig_h;
  1587. $new_w =$dest_w;// min($dest_w, $orig_w);
  1588. $new_h =$dest_h;// min($dest_h, $orig_h);
  1589.  
  1590. if ( !$new_w ) {
  1591. $new_w = intval($new_h * $aspect_ratio);
  1592. }
  1593.  
  1594. if ( !$new_h ) {
  1595. $new_h = intval($new_w / $aspect_ratio);
  1596. }
  1597.  
  1598. $size_ratio = max($new_w / $orig_w, $new_h / $orig_h);
  1599.  
  1600. $crop_w = round($new_w / $size_ratio);
  1601. $crop_h = round($new_h / $size_ratio);
  1602.  
  1603. $s_x = floor( ($orig_w - $crop_w) / 2 );
  1604. $s_y = floor( ($orig_h - $crop_h) / 2 );
  1605. } else {
  1606. // don't crop, just resize using $dest_w x $dest_h as a maximum bounding box
  1607.  
  1608. $crop_w = $orig_w;
  1609. $crop_h = $orig_h;
  1610.  
  1611. $s_x = 0;
  1612. $s_y = 0;
  1613.  
  1614.  
  1615. list( $new_w, $new_h ) = $this->constrainNewDimensions( $orig_w, $orig_h, $dest_w, $dest_h );
  1616. }
  1617. $to_return = array();
  1618. $to_return['src']['x'] = (int)$s_x;
  1619. $to_return['src']['y'] = (int)$s_y;
  1620. $to_return['src']['w'] = (int)$crop_w;
  1621. $to_return['src']['h'] = (int)$crop_h;
  1622.  
  1623. $to_return['dst']['x'] = 0;
  1624. $to_return['dst']['y'] = 0;
  1625. $to_return['dst']['w'] = (int)$new_w;
  1626. $to_return['dst']['h'] = (int)$new_h;
  1627.  
  1628. return $to_return;
  1629. }
  1630.  
  1631. /**
  1632. * This function has been take over from wordpress core. It calculate the best proportion to uncropped image
  1633. */
  1634. public function constrainNewDimensions( $current_width, $current_height, $max_width=0, $max_height=0 ) {
  1635.  
  1636. if ( !$max_width and !$max_height )
  1637. return array( $current_width, $current_height );
  1638.  
  1639.  
  1640. $width_ratio = $height_ratio = 1.0;
  1641. $did_width = $did_height = false;
  1642.  
  1643. if ( $max_width > 0 && $current_width > 0 )
  1644. {
  1645. $width_ratio = $max_width / $current_width;
  1646. $did_width = true;
  1647. }
  1648.  
  1649. if ( $max_height > 0 && $current_height > 0 )
  1650. {
  1651. $height_ratio = $max_height / $current_height;
  1652. $did_height = true;
  1653. }
  1654.  
  1655. // Calculate the larger/smaller ratios
  1656. $smaller_ratio = min( $width_ratio, $height_ratio );
  1657. $larger_ratio = max( $width_ratio, $height_ratio );
  1658.  
  1659. if ( intval( $current_width * $larger_ratio ) > $max_width || intval( $current_height * $larger_ratio ) > $max_height )
  1660. // The larger ratio is too big. It would result in an overflow.
  1661. $ratio = $smaller_ratio;
  1662. else
  1663. // The larger ratio fits, and is likely to be a more "snug" fit.
  1664. $ratio = $larger_ratio;
  1665. //echo $current_width;
  1666. if( $max_width > $current_width && $max_height == 0 ) {
  1667. $ratio = $larger_ratio;
  1668. }
  1669.  
  1670. $w = intval( $current_width * $ratio );
  1671. $h = intval( $current_height * $ratio );
  1672.  
  1673. // Sometimes, due to rounding, we'll end up with a result like this: 465x700 in a 177x177 box is 117x176... a pixel short
  1674. // We also have issues with recursive calls resulting in an ever-changing result. Constraining to the result of a constraint should yield the original result.
  1675. // Thus we look for dimensions that are one pixel shy of the max value and bump them up
  1676. if ( $did_width && $w == $max_width - 1 )
  1677. $w = $max_width; // Round it up
  1678. if ( $did_height && $h == $max_height - 1 )
  1679. $h = $max_height; // Round it up
  1680.  
  1681. return array( $w, $h );
  1682. }
  1683. }
  1684.  
  1685. class fImg {
  1686. /**
  1687. * @var fImg
  1688. */
  1689. private static $_instance = null;
  1690.  
  1691. /**
  1692. * @var fImgNamer
  1693. */
  1694. private $_imgNamer = null;
  1695.  
  1696. /**
  1697. * @var blFileSystem
  1698. */
  1699. private $_fileSystem = null;
  1700.  
  1701. /**
  1702. * @var blImgCache
  1703. */
  1704. private $_imgCache = null;
  1705.  
  1706. /**
  1707. * @var fImgDeliverer
  1708. */
  1709. private $_imgDeliverer = null;
  1710.  
  1711. /**
  1712. * @var blInputStreamAdapteour
  1713. */
  1714. private $_inputStream = null;
  1715.  
  1716. /**
  1717. * @var fImgResizer
  1718. */
  1719. private $_imgResizer = null;
  1720.  
  1721.  
  1722. private $_defaultUrl = null;
  1723.  
  1724. private $_defaultDir = null;
  1725.  
  1726. /*----------------------------------------------------------------------------*/
  1727. /* PUBLIC FUNCTIONS
  1728. /*----------------------------------------------------------------------------*/
  1729.  
  1730. public function __construct() {
  1731. $this->_createDefaultUrlAndDir();
  1732. $this->_setImgCache( new blImgCache( $this->_getFileSystem(), $this->_getDefaultDir() ) );
  1733. $this->_setImgDeliverer( new fImgDeliverer( $this->_getFileSystem(), $this->_getInputStream(), $this->_getImgCache(), $this->_getDefaultDir(), $this->_getDefaultUrl() ) );
  1734. $this->_setImgResizer( new fImgResizer( $this->_getFileSystem() ) );
  1735. }
  1736.  
  1737. public function getInstance() {
  1738. if( self::$_instance == null ) {
  1739. self::$_instance = new fImg();
  1740. }
  1741.  
  1742. return self::$_instance;
  1743. }
  1744.  
  1745.  
  1746. public static function ResizeC( $url, $width, $height = false, $crop = false, $returnImgSize = false ) {
  1747. $width = (int)$width;
  1748. $height = (int)$height;
  1749.  
  1750. return self::getInstance()->_resize($url, $width, $height, $crop, $returnImgSize);
  1751. }
  1752.  
  1753.  
  1754. public static function resize( $url, $width, $height = false, $crop = false, $returnImgSize = false ) {
  1755. $width = (int)$width;
  1756. $height = (int)$height;
  1757.  
  1758. return self::getInstance()->_resize($url, $width, $height, $crop, $returnImgSize = false);
  1759. }
  1760.  
  1761. public static function getImgSize( $url ) {
  1762. return self::getInstance()->_getImgSize( $url );
  1763. }
  1764.  
  1765. private function _getImgSize( $url ) {
  1766. $imgData = $this->_getImgData($url, 0, false, false);
  1767. $imgData = $this->_getImgDeliverer()->deliveryImage($imgData);
  1768. return $imgData;
  1769. }
  1770.  
  1771. private function _resize( $url, $width, $height = false, $crop = false, $returnImgSize = false ) {
  1772. if( empty($url) ) return null;
  1773.  
  1774. $imgData = $this->_getImgData($url, $width, $height, $crop);
  1775. $imgData = $this->_getImgDeliverer()->deliveryImage( $imgData );
  1776.  
  1777. if( $imgData == false ) {
  1778. echo 'Image :'.$url.' cannot be opened';
  1779. return false;
  1780. }
  1781.  
  1782. if( $imgData->ready == false ) {
  1783.  
  1784. $this->_getImgResizer()->resize( $imgData );
  1785. $this->_getImgCache()
  1786. ->addCachedFile( $imgData->new->url, $imgData->old->url, $imgData->new->path, $imgData->old->path, $imgData->remote);
  1787. }
  1788. if( $returnImgSize ) {
  1789. $size = getimagesize($imgData->new->path);
  1790.  
  1791. $toReturn = array();
  1792. $toReturn['width'] = $size[0];
  1793. $toReturn['height'] = $size[1];
  1794. $toReturn['url'] = $imgData->new->url;
  1795.  
  1796. return $toReturn;
  1797. } else {
  1798. return $imgData->new->url;
  1799. }
  1800.  
  1801. }
  1802. /*----------------------------------------------------------------------------*/
  1803. /* PRIVATE FUNCTIONS
  1804. /*----------------------------------------------------------------------------*/
  1805. /**
  1806. * @return fImgData
  1807. */
  1808. private function _getImgData( $url, $width, $height, $crop ) {
  1809. $imgData = $this->_getImageInfoAsClass($url, $width, $height, $crop);
  1810. $imgData->new->url = $this->_getImgNamer()->getNewImageUrl( $url, $width, $height, $crop);
  1811. $imgData->new->filename = $this->_getImgNamer()->getNewImageName($url, $width, $height, $crop);
  1812.  
  1813. return $imgData;
  1814. }
  1815.  
  1816. /**
  1817. *
  1818. * @return fImgData
  1819. */
  1820. private function _getImageInfoAsClass( $url, $width, $height,$crop) {
  1821. $imgData = new fImgData();
  1822. $imgData->old->url = $url;
  1823. $imgData->new->width = (int)$width;
  1824. $imgData->new->height = (int)$height;
  1825. $imgData->new->crop = $crop;
  1826.  
  1827. return $imgData;
  1828. }
  1829.  
  1830. private function _createDefaultUrlAndDir() {
  1831. $wpUploadDir = wp_upload_dir();
  1832. $this->_setDefaultUrl( $wpUploadDir['baseurl'].'/freshizer');
  1833. $this->_setDefaultDir( $wpUploadDir['basedir'].'/freshizer/');
  1834. }
  1835.  
  1836. /*----------------------------------------------------------------------------*/
  1837. /* SETTERS AND GETTERS
  1838. /*----------------------------------------------------------------------------*/
  1839. private function _setImgResizer( fImgResizer $imgResizer ) {
  1840. $this->_imgResizer = $imgResizer;
  1841. }
  1842. /**
  1843. * @return fImgResizer
  1844. */
  1845. private function _getImgResizer() {
  1846. return $this->_imgResizer;
  1847. }
  1848.  
  1849. private function _setImgDeliverer( fImgDeliverer $imgDeliverer ) {
  1850. $this->_imgDeliverer = $imgDeliverer;
  1851. }
  1852.  
  1853. /**
  1854. * @return fImgDeliverer
  1855. */
  1856. private function _getImgDeliverer() {
  1857. return $this->_imgDeliverer;
  1858. }
  1859.  
  1860. private function _setInputStream( blInputStreamAdapteour $inputStream ) {
  1861. $this->_inputStream = $inputStream;
  1862. }
  1863.  
  1864. /**
  1865. *
  1866. * @return blInputStreamAdapteour
  1867. */
  1868. private function _getInputStream() {
  1869. if( $this->_inputStream == null ) {
  1870. $this->_inputStream = new blInputStreamAdapteour() ;
  1871. }
  1872. return $this->_inputStream;
  1873. }
  1874.  
  1875. private function _setDefaultUrl( $defaultUrl ) {
  1876. $this->_defaultUrl = $defaultUrl;
  1877. }
  1878. private function _getDefaultUrl() {
  1879. return $this->_defaultUrl;
  1880. }
  1881.  
  1882. private function _getImgNamer() {
  1883. if( $this->_imgNamer == null ) {
  1884. $this->_imgNamer = new fImgNamer($this->_getDefaultUrl());
  1885. }
  1886. return $this->_imgNamer;
  1887. }
  1888.  
  1889. private function _getImgCache() {
  1890. return $this->_imgCache;
  1891. }
  1892.  
  1893. private function _setImgCache( blImgCache $imgCache ) {
  1894. $this->_imgCache = $imgCache;
  1895. }
  1896.  
  1897. private function _getFileSystem() {
  1898. if( $this->_fileSystem == null ) {
  1899. $this->_fileSystem = new blFileSystem();
  1900. }
  1901. return $this->_fileSystem;
  1902. }
  1903.  
  1904. private function _setDefaultDir( $defaultDir) {
  1905. $this->_defaultDir = $defaultDir;
  1906. }
  1907.  
  1908. private function _getDefaultDir() {
  1909. return $this->_defaultDir;
  1910. }
  1911.  
  1912. public static function DeleteCache() {
  1913.  
  1914. }
  1915. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!