Subversion Repositories Applications.gtt

<?php
/*
 * This work is hereby released into the Public Domain.
 * To view a copy of the public domain dedication,
 * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
 * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
 *
 */

require_once dirname(__FILE__)."/Image.class.php";
 

/**
 * A graph 
 *
 * @package Artichow
 */
class awGraph extends awImage {

        /**
         * Graph name
         *
         * @var string
         */
        protected $name;

        /**
         * Cache timeout
         *
         * @var int
         */
        protected $timeout = 0;
        
        /**
         * Graph timing ?
         *
         * @var bool
         */
        protected $timing;
        
        /**
         * Components
         *
         * @var array
         */
        private $components = array();
        
        /**
         * Some labels to add to the component
         *
         * @var array
         */
        protected $labels = array();
        
        /**
         * Graph title
         *
         * @var Label
         */
        public $title;
        
        /**
         * File cache location
         *
         * @var string
         */
        private $fileCache;
        
        /**
         * Time file cache location
         *
         * @var string
         */
        private $fileCacheTime;
        
        /** 
         * Drawing mode to return the graph
         *
         * @var int
         */
        const DRAW_RETURN = 1;
        
        /** 
         * Drawing mode to display the graph
         *
         * @var int
         */
        const DRAW_DISPLAY = 2;
        
        /**
         * Construct a new graph
         *
         * @param int $width Graph width
         * @param int $height Graph height
         * @param string $name Graph name for the cache (must be unique). Let it null to not use the cache.
         * @param int $timeout Cache timeout (unix timestamp)
         */
        public function __construct($width = NULL, $height = NULL, $name = NULL, $timeout = 0) {
                
                parent::__construct();
        
                $this->setSize($width, $height);

                if(ARTICHOW_CACHE) {
        
                        $this->name = $name;
                        $this->timeout = $timeout;
                        
                        // Clean sometimes all the cache
                        if(mt_rand(0, 5000) ===  0) {
                                awGraph::cleanCache();
                        }
                
                        // Take the graph from the cache if possible
                        if($this->name !== NULL) {
                        
                                $this->fileCache = ARTICHOW_CACHE_DIRECTORY."/".$this->name;
                                $this->fileCacheTime = $this->fileCache."-time";
                                
                                if(is_file($this->fileCache)) {
                                
                                        $type = awGraph::cleanGraphCache($this->fileCacheTime);
                                        
                                        if($type === NULL) {
                                                awGraph::deleteFromCache($this->name);
                                        } else {
                                                header("Content-Type: image/".$type);
                                                echo file_get_contents($this->fileCache);
                                                exit;
                                        }
                                        
                                }
                        
                        }
                
                }
                
                $this->title = new awLabel(
                        NULL,
                        new awTuffy(16),
                        NULL,
                        0
                );
                $this->title->setAlign(awLabel::CENTER, awLabel::BOTTOM);
        
        }
        
        /**
         * Delete a graph from the cache
         *
         * @param string $name Graph name
         * @return bool TRUE on success, FALSE on failure
         */
        public static function deleteFromCache($name) {

                if(ARTICHOW_CACHE) {
                
                        if(is_file(ARTICHOW_CACHE_DIRECTORY."/".$name."-time")) {
                                unlink(ARTICHOW_CACHE_DIRECTORY."/".$name."");
                                unlink(ARTICHOW_CACHE_DIRECTORY."/".$name."-time");
                        }
                        
                }
                
        }
        
        /**
         * Delete all graphs from the cache
         */
        public static function deleteAllCache() {

                if(ARTICHOW_CACHE) {
        
                        $dp = opendir(ARTICHOW_CACHE_DIRECTORY);
                        
                        while($file = readdir($dp)) {
                                if($file !== '.' and $file != '..') {
                                        unlink(ARTICHOW_CACHE_DIRECTORY."/".$file);
                                }
                        }
                        
                }
        
        }
        
        /**
         * Clean cache
         */
        public static function cleanCache() {

                if(ARTICHOW_CACHE) {
        
                        $glob = glob(ARTICHOW_CACHE_DIRECTORY."/*-time");
                        
                        foreach($glob as $file) {
                                
                                $type = awGraph::cleanGraphCache($file);
                                
                                if($type === NULL) {
                                        $name = ereg_replace(".*/(.*)\-time", "\\1", $file);
                                        awGraph::deleteFromCache($name);
                                }
                        
                        }
                        
                }
                
        }
        
        /**
         * Enable/Disable Graph timing
         *
         * @param bool $timing
         */
        public function setTiming($timing) {
                $this->timing = (bool)$timing;
        }
         
        /**
         * Add a component to the graph
         *
         * @param awComponent $component
         */
        public function add(awComponent $component) {
        
                $this->components[] = $component;
        
        }
        
        /**
         * Add a label to the component
         *
         * @param awLabel $label
         * @param int $x Position on X axis of the center of the text
         * @param int $y Position on Y axis of the center of the text
         */
        public function addLabel(awLabel $label, $x, $y) {
        
                $this->labels[] = array(
                        $label, $x, $y
                );
                
        }
        
        /**
         * Add a label to the component with absolute position
         *
         * @param awLabel $label
         * @param awPoint $point Text position
         */
        public function addAbsLabel(awLabel $label, awPoint $point) {
        
                $this->labels[] = array(
                        $label, $point
                );
                
        }
        
        /**
         * Build the graph and draw component on it
         *
         * @param string $mode Display mode (can be a file name)
         */
        public function draw($mode = Graph::DRAW_DISPLAY) {
                
                if($this->timing) {
                        $time = microtimeFloat();
                }
        
                $this->create();
                
                foreach($this->components as $component) {
                
                        $this->drawComponent($component);
                
                }
                
                $this->drawTitle();
                $this->drawShadow();
                $this->drawLabels();
                
                if($this->timing) {
                        $this->drawTiming(microtimeFloat() - $time);
                }
                
                // Create graph
                $data = $this->get();
                                
                // Put the graph in the cache if needed
                $this->cache($data);
                
                switch($mode) {
                
                        case Graph::DRAW_DISPLAY :
                                $this->sendHeaders();
                                echo $data;
                                break;
                
                        case Graph::DRAW_RETURN :
                                return $data;
                        
                        default :
                                if(is_string($mode)) {
                                        file_put_contents($mode, $data);
                                } else {
                                        awImage::drawError("Class Graph: Unable to draw the graph.");
                                }
                
                }

        }
        
        private function drawLabels() {
        
                $driver = $this->getDriver();
        
                foreach($this->labels as $array) {
                
                        if(count($array) === 3) {
                        
                                // Text in relative position
                                list($label, $x, $y) = $array;
                                
                                $point = new awPoint(
                                        $x * $this->width,
                                        $y * $this->height
                                );
                                
                        } else {
                        
                                // Text in absolute position
                                list($label, $point) = $array;
                        
                        }
                                
                        $label->draw($driver, $point);
                
                }
                
        }
                
        private function drawTitle() {
        
                $driver = $this->getDriver();
        
                $point = new awPoint(
                        $this->width / 2,
                        10
                );
                
                $this->title->draw($driver, $point);
        
        }
        
        private function drawTiming($time) {
        
                $driver = $this->getDriver();
                
                $label = new awLabel;
                $label->set("(".sprintf("%.3f", $time)." s)");
                $label->setAlign(awLabel::LEFT, awLabel::TOP);
                $label->border->show();
                $label->setPadding(1, 0, 0, 0);
                $label->setBackgroundColor(new awColor(230, 230, 230, 25));
                
                $label->draw($driver, new awPoint(5, $driver->imageHeight - 5));
        
        }
        
        private function cache($data) {
                if(ARTICHOW_CACHE and $this->name !== NULL) {
                        
                        if(is_writable(ARTICHOW_CACHE_DIRECTORY) === FALSE) {
                                awImage::drawError("Class Graph: Cache directory is not writable.");
                        }
                
                        file_put_contents($this->fileCache, $data);
                        file_put_contents($this->fileCacheTime, $this->timeout."\n".$this->getFormatString());
                        
                }
        }
        
        private static function cleanGraphCache($file) {
        
                list(
                        $time,
                        $type
                ) = explode("\n", file_get_contents($file));
                
                $time = (int)$time;
                
                if($time !== 0 and $time < time()) {
                        return NULL;
                } else {
                        return $type;
                }
                
                
        }

}

registerClass('Graph');

/*
 * To preserve PHP 4 compatibility
 */
function microtimeFloat() { 
        list($usec, $sec) = explode(" ", microtime()); 
        return (float)$usec + (float)$sec; 
}
?>