home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / Cache / Graphics.php < prev    next >
PHP Script  |  2001-03-06  |  12KB  |  311 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP version 4.0                                                      |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  6. // +----------------------------------------------------------------------+
  7. // | This source file is subject to version 2.0 of the PHP license,       |
  8. // | that is bundled with this package in the file LICENSE, and is        |
  9. // | available at through the world-wide-web at                           |
  10. // | http://www.php.net/license/2_02.txt.                                 |
  11. // | If you did not receive a copy of the PHP license and are unable to   |
  12. // | obtain it through the world-wide-web, please send a note to          |
  13. // | license@php.net so we can mail you a copy immediately.               |
  14. // +----------------------------------------------------------------------+
  15. // | Authors: Ulf Wendel <ulf.wendel@phpdoc.de>                           |
  16. // +----------------------------------------------------------------------+
  17. //
  18. // $Id: Graphics.php,v 1.5 2001/03/06 15:27:30 sbergmann Exp $
  19.  
  20. require_once 'Cache.php';
  21.  
  22. /**
  23. * Graphics disk cache.
  24. * 
  25. * The usual way to create images is to pass some arguments that describe the image 
  26. * to a script that dynamically creates an image. For every image of a page 
  27. * a new PHP interpreter gets started. This is a good way to kill your webserver.
  28. * 
  29. * When dealing with dynamically generated images you should not call another script 
  30. * to generate the images but generate the images by the script that produces the page
  31. * that contains the images. This is a major improvement but it's only half the way.
  32. * 
  33. * There's no need to rerender an image on every request. A simple disk cache can reduce
  34. * the computation time dramatically. This is what the class graphics_cache is for. 
  35. * 
  36. * Usage:
  37. * 
  38. * // create an instance of the graphics cache
  39. * $cache = new graphics_cache;
  40. *
  41. * $img = ImageCreate(...);
  42. *
  43. * // compute an ID for your image based on typical parameters
  44. * $id = m5d( $size, $colors, $label);
  45. * 
  46. * // check if it's cached
  47. * if (!($link = $cache->getImageLink($id, "gif"))) {
  48. *  
  49. *   // hmmm, it's not cached, create it
  50. *   ...
  51. *   // cacheImageLink() and cacheImage() make the ImageGIF() call!
  52. *   // cacheImage() returns the value of ImageGIF() [etc.], cacheImageLink() returns a URL
  53. *   $link = $cache->cacheImageLink($id, $img, "gif");
  54. * 
  55. * }
  56. *
  57. * // Ok, let's build the ImageLink
  58. * $size = getImageSize($link[0]);
  59. * printf('<img src="%s" %s>', $link[1], $size[3]);
  60. *
  61. * // for cacheImage():
  62. * // header("Content-type: image/gif"); print $cache->cacheImage($id, $img, "gif");
  63. * 
  64. *
  65. * The class requires PHP 4.0.2+ [ImageType()]. Note that cacheImage() works with
  66. * the output buffer. Modify it if required!
  67. *
  68. * @author   Ulf Wendel <ulf.wendel@phpdoc.de>
  69. * @version  $Id: Graphics.php,v 1.5 2001/03/06 15:27:30 sbergmann Exp $
  70. * @package  Cache
  71. */
  72. class Cache_Graphics extends Cache {
  73.  
  74.     /**
  75.     * Cache URL prefix.
  76.     * 
  77.     * Make sure that the cache URL prefix points to the $cache_dir, otherwise
  78.     * your links will be broken. Use setCacheURL to specify the cache_url and 
  79.     * setCacheDir() for the cache_dir.
  80.     * 
  81.     * @var  string
  82.     * @see  setCacheURL(), setCacheDir()
  83.     */
  84.     var $cache_url = "";
  85.  
  86.     /**
  87.     * Directory where cached files get stored.
  88.     * s
  89.     * Make sure that the cache_dir is writable and offers enough space. Check 
  90.     * also if your cache_url points to the directory. Use setCacheDir() to set
  91.     * the variable.
  92.     * 
  93.     * @var  string
  94.     * @see  setCacheDir(), setCacheURL()
  95.     */
  96.     var $cache_dir = "";
  97.  
  98.     /**
  99.     * Nameprefix of cached files.
  100.     * 
  101.     * Per default the prefix "graphics_" gets used. You might use this 
  102.     * for versioning or to ease (manual) clean ups.
  103.     *
  104.     * @var      string
  105.     */
  106.     var $cache_file_prefix = "graphics_";
  107.  
  108.     /**
  109.     * Mapping from supported image type to a ImageType() constant.
  110.     * 
  111.     * Referr to the PHP manual for more informations on ImageType()
  112.     * 
  113.     * @var  array
  114.     * @link http://www.php.net/ImageType
  115.     */
  116.     var $imagetypes = array(
  117.                                 "gif"   => IMG_GIF, 
  118.                                 "jpg"   => IMG_JPG,
  119.                                 "png"   => IMG_PNG,
  120.                                 "wbmp"  => IMG_WBMP
  121.                             );
  122.  
  123.     /**
  124.     * TODO: add docs
  125.     */
  126.     function graphics_cache() {
  127.         $this->cache("cache_container_file", array("cache_dir" => $this->cache_dir, "filename_prefix" => $this->cache_file_prefix));
  128.     } // end constructor
  129.  
  130.     /**
  131.     * Returns the content of a cached image file.
  132.     * 
  133.     * This function can be used to send the image directly to the browser.
  134.     * Make sure that you send a correspondending header before sending the image itself.
  135.     *
  136.     * Always try to get the image from the cache before you compute it. See 
  137.     * the class docs for an example.
  138.     *
  139.     * @param    string  Image-ID
  140.     * @param    string  Image type: gif, jpg, png, wbmp
  141.     * @return   string  Image file contents if a cached file exists otherwise an empty string
  142.     * @see      cacheImage()
  143.     */                                    
  144.     function getImage($id, $format = "png") {
  145.         $id = $this->generateID(array("id" => $id, "format" => strtolower($format)));
  146.         
  147.         return $this->get($id);
  148.     } // end func getImage
  149.  
  150.     /**
  151.     * Returns an array with a link to the cached image and the image file path.
  152.     * 
  153.     * Always try to get the image from the cache before you compute it. See 
  154.     * the class docs for an example.
  155.     *
  156.     * @param    string  Image-ID
  157.     * @param    string  Image type: gif, jpg, png, wbmp
  158.     * @return   array   [ full path to the image file, image url ]
  159.     * @throw    gerror
  160.     * @see      cacheImageLink()
  161.     */
  162.     function getImageLink($id, $format = "png") {
  163.         $id = $this->generateID(array("id" => $id, "format" => strtolower($format)));
  164.         if (!$this->container->idExists($id)) 
  165.             return array();
  166.  
  167.         $file = $this->cache_url . $this->cache_file_prefix . $id;
  168.  
  169.         return array($this->container->getFilename($id), $file);
  170.     } // end func getImageLink
  171.  
  172.     /**
  173.     * Create an image from the given image handler, cache it and return the file content.
  174.     *
  175.     * Always try to retrive the image from the cache before you compute it.
  176.     * 
  177.     * Warning: this function uses the output buffer. If you expect collisions 
  178.     * modify the code.
  179.     *
  180.     * @param    string  Image-ID. Used as a part of the cache filename.
  181.     *                   Use md5() to generate a "unique" ID for your image
  182.     *                   based on characteristic values such as the color, size etc.
  183.     * @param    string  Image handler to create the image from.
  184.     * @param    string  Image type: gif, jpg, png, wbmp. Also used as filename suffix.
  185.     *                   If an unsupported type is requested the functions tries to 
  186.     *                   fallback to a supported type before throwing an exeption.
  187.     * @return   string  Image content returned by ImageGIF/... 
  188.     * @throws   gerror
  189.     * @access   public
  190.     * @see      getImage()
  191.     */
  192.     function cacheImage($id, &$img, $format = "png") {
  193.         if (!$id)
  194.             return new gerror("You must provide an ID for and image to be cached!");
  195.  
  196.         $id = $this->generateID(array("id" => $id, "format" => strtolower($format)));
  197.         
  198.         // Check if the requested image type is supported by the GD lib.
  199.         // If not, try a callback to the first available image type.
  200.         if (!isset($this->imagetypes[$format]) || !(ImageTypes() & $this->imagetypes[$format])) {
  201.             foreach ($this->imagetypes as $supported => $bitmask) 
  202.                 if (ImageTypes() & $bitmask)
  203.                     new gerror("The build in GD lib does not support the image type $format. Fallback to $supported.");
  204.                 else
  205.                     return new gerror("Hmm, is you PHP build with GD support? Can't find any supported types.");
  206.         }
  207.  
  208.         if ($image = $this->get($id))
  209.             return $image;
  210.  
  211.         // save the image to the output buffer, write it to disk and 
  212.         // return the image.
  213.         ob_end_clean();
  214.         ob_start(); 
  215.  
  216.         // generate the image
  217.         $func = "Image" . strtoupper($format);    
  218.         $func($img);
  219.         ImageDestroy($img);
  220.  
  221.         ob_end();
  222.         $image = ob_get_contents();
  223.         ob_end_clean();
  224.  
  225.         // save the generated image to disk
  226.         $this->save($id, $image, 0);
  227.  
  228.         return $image;
  229.     } // end func cacheImage
  230.  
  231.     /**
  232.     * Create an image from the given image handler, cache it and return a url and the file path of the image.
  233.     *
  234.     * Always try to retrive the image from the cache before you compute it.
  235.     *
  236.     * @param    string  Image-ID. Used as a part of the cache filename.
  237.     *                   Use md5() to generate a "unique" ID for your image
  238.     *                   based on characteristic values such as the color, size etc.
  239.     * @param    string  Image handler to create the image from.
  240.     * @param    string  Image type: gif, jpg, png, wbmp. Also used as filename suffix.
  241.     *                   If an unsupported type is requested the functions tries to 
  242.     *                   fallback to a supported type before throwing an exeption.
  243.     * @return   array  [ full path to the image file, image url ]
  244.     * @throws   gerror
  245.     * @access   public
  246.     */
  247.  
  248.     function cacheImageLink($id, &$img, $format = "png") {
  249.         if (!$id)
  250.             return new gerror("You must provide an ID for and image to be cached!");
  251.  
  252.         $id = $this->generateID(array("id" => $id, "format" => strtolower($format));
  253.  
  254.         // Check if the requested image type is supported by the GD lib.
  255.         // If not, try a callback to the first available image type.
  256.         if (!isset($this->imagetypes[$format]) || !(ImageTypes() & $this->imagetypes[$format])) {
  257.             foreach ($this->imagetypes as $supported => $bitmask) 
  258.                 if (ImageTypes() & $bitmask)
  259.                     new gerror("The build in GD lib does not support the image type $format. Fallback to $supported.");
  260.                 else
  261.                     return new gerror("Hmm, is you PHP build with GD support? Can't find any supported types.");
  262.         }
  263.  
  264.         $url = $this->cache_url . $this->cache_file_prefix . $id;
  265.         $ffile = $this->container->getFilename($id);
  266.  
  267.         if ($this->isCached($id) && !isExpired($id))
  268.             return array($ffile, $url)
  269.  
  270.         $func = "Image" . strtoupper($format);    
  271.         $func($img, $ffile);
  272.  
  273.         ImageDestroy($img);
  274.  
  275.         return array($ffile, $url);
  276.     } // end func cacheImageLink
  277.  
  278.     /**
  279.     * Sets the URL prefix used when rendering HTML Tags. 
  280.     * 
  281.     * Make sure that the URL matches the cache directory, 
  282.     * otherwise you'll get broken links.
  283.     * 
  284.     * @param    string
  285.     * @access   public
  286.     * @see      setCacheDir()
  287.     */
  288.     function setCacheURL($cache_url) {
  289.         if ($cache_url && "/" != substr($cache_url, 1)) 
  290.             $cache_url .= "/";
  291.             
  292.         $this->cache_url = $cache_url;
  293.         
  294.     } // end func setCacheURL
  295.  
  296.     /**
  297.     * Sets the directory where to cache generated Images
  298.     * 
  299.     * @param    string
  300.     * @access   public
  301.     * @see      setCacheURL()
  302.     */
  303.     function setCacheDir($cache_dir) {
  304.         if ($cache_dir && "/" != substr($cache_dir, 1))
  305.             $cache_dir .= "/";
  306.  
  307.         $this->cache_dir = $cache_dir;
  308.         $this->container->cache_dir = $cache_dir;
  309.     } // end func setCacheDir
  310. } // end class Cache_Graphics
  311. ?>