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.
 *
 */
 

if(is_file(dirname(__FILE__)."/Artichow.cfg.php")) { // For PHP 4+5 version
        require_once dirname(__FILE__)."/Artichow.cfg.php";
}




/*
 * Register a class with the prefix in configuration file
 */
function registerClass($class, $abstract = FALSE) {

        if(ARTICHOW_PREFIX === 'aw') {
                return;
        }
        
        
        if($abstract) {
                $abstract = 'abstract';
        } else {
                $abstract = '';
        }
        
        
        eval($abstract." class ".ARTICHOW_PREFIX.$class." extends aw".$class." { }");

}

/*
 * Register an interface with the prefix in configuration file
 */
function registerInterface($interface) {

        if(ARTICHOW_PREFIX === 'aw') {
                return;
        }

        
        eval("interface ".ARTICHOW_PREFIX.$interface." extends aw".$interface." { }");
        

}

// Some useful files
require_once ARTICHOW."/Component.class.php";

require_once ARTICHOW."/inc/Grid.class.php";
require_once ARTICHOW."/inc/Tools.class.php";
require_once ARTICHOW."/inc/Driver.class.php";
require_once ARTICHOW."/inc/Math.class.php";
require_once ARTICHOW."/inc/Tick.class.php";
require_once ARTICHOW."/inc/Axis.class.php";
require_once ARTICHOW."/inc/Legend.class.php";
require_once ARTICHOW."/inc/Mark.class.php";
require_once ARTICHOW."/inc/Label.class.php";
require_once ARTICHOW."/inc/Text.class.php";
require_once ARTICHOW."/inc/Color.class.php";
require_once ARTICHOW."/inc/Font.class.php";
require_once ARTICHOW."/inc/Gradient.class.php";
require_once ARTICHOW."/inc/Shadow.class.php";
require_once ARTICHOW."/inc/Border.class.php";

require_once ARTICHOW."/common.php";
 
/**
 * An image for a graph
 *
 * @package Artichow
 */
class awImage {

        /**
         * Graph width
         *
         * @var int
         */
        public $width;

        /**
         * Graph height
         *
         * @var int
         */
        public $height;
        
        /**
         * Use anti-aliasing ?
         *
         * @var bool
         */
        protected $antiAliasing = FALSE;
        
        /**
         * Image format
         *
         * @var int
         */
        protected $format = awImage::PNG;
        
        /**
         * Image background color
         *
         * @var Color
         */
        protected $background;
        
        /**
         * GD resource
         *
         * @var resource
         */
        protected $resource;
        
        /**
         * A Driver object
         *
         * @var Driver
         */
        protected $driver;
        
        /**
         * Driver string
         * 
         * @var string
         */
        protected $driverString;
                
        /**
         * Shadow
         *
         * @var Shadow
         */
        public $shadow;
        
        /**
         * Image border
         *
         * @var Border
         */
        public $border;
        
        /**
         * Use JPEG for image
         *
         * @var int
         */
        const JPEG = IMG_JPG;
        
        /**
         * Use PNG for image
         *
         * @var int
         */
        const PNG = IMG_PNG;
        
        /**
         * Use GIF for image
         *
         * @var int
         */
        const GIF = IMG_GIF;
        
        /**
         * Build the image
         */
        public function __construct() {
                
                $this->background = new awColor(255, 255, 255);
                $this->shadow = new awShadow(awShadow::RIGHT_BOTTOM);
                $this->border = new awBorder;
                
        }
        
        /**
         * Get driver of the image
         *
         * @param int $w Driver width (from 0 to 1) (default to 1)
         * @param int $h Driver height (from 0 to 1) (default to 1)
         * @param float $x Position on X axis of the center of the driver (default to 0.5)
         * @param float $y Position on Y axis of the center of the driver (default to 0.5)
         * @return Driver
         */
        public function getDriver($w = 1, $h = 1, $x = 0.5, $y = 0.5) {
                $this->create();
                $this->driver->setSize($w, $h);
                $this->driver->setPosition($x, $y);
                return $this->driver;
        }
        
        /**
         * Sets the driver that will be used to draw the graph
         * 
         * @param string $driverString
         */
        public function setDriver($driverString) {
                $this->driver = $this->selectDriver($driverString);
                
                $this->driver->init($this);
        }
        
        /**
         * Change the image size
         *
         * @var int $width Image width
         * @var int $height Image height
         */
        public function setSize($width, $height) {
        
                if($width !== NULL) {
                        $this->width = (int)$width;
                }
                if($height !== NULL) {
                        $this->height = (int)$height;
                }
        
        }
        
        /**
         * Change image background
         * 
         * @param mixed $background
         */
        public function setBackground($background) {
                if($background instanceof awColor) {
                        $this->setBackgroundColor($background);
                } elseif($background instanceof awGradient) {
                        $this->setBackgroundGradient($background);
                }
        }
        
        /**
         * Change image background color
         *
         * @param awColor $color
         */
        public function setBackgroundColor(awColor $color) {
                $this->background = $color;
        }
        
        /**
         * Change image background gradient
         *
         * @param awGradient $gradient
         */
        public function setBackgroundGradient(awGradient $gradient) {
                $this->background = $gradient;
        }
        
        /**
         * Return image background, whether a Color or a Gradient
         * 
         * @return mixed
         */
        public function getBackground() {
                return $this->background;
        }
        
        /**
         * Turn antialiasing on or off
         *
         * @var bool $bool
         */
        public function setAntiAliasing($bool) {
                $this->antiAliasing = (bool)$bool;
        }
        
        /**
         * Return the antialiasing setting
         *
         * @return bool
         */
        public function getAntiAliasing() {
                return $this->antiAliasing;
        }
        
        /**
         * Change image format
         *
         * @var int $format New image format
         */
        public function setFormat($format) {
                if($format === awImage::JPEG or $format === awImage::PNG or $format === awImage::GIF) {
                        $this->format = $format;
                }
        }
        
        /**
         * Returns the image format as an integer
         *
         * @return unknown
         */
        public function getFormat() {
                return $this->format;
        }
        
        /**
         * Returns the image format as a string
         *
         * @return string
         */
        public function getFormatString() {
                
                switch($this->format) {
                        case awImage::JPEG :
                                return 'jpeg';
                        case awImage::PNG :
                                return 'png';
                        case awImage::GIF :
                                return 'gif';
                }
                
        }

        /**
         * Create a new awimage
         */
        public function create() {

                if($this->driver === NULL) {
                        $driver = $this->selectDriver($this->driverString);

                        $driver->init($this);
                        
                        $this->driver = $driver;
                }

        }
        
        /**
         * Select the correct driver
         *
         * @param string $driver The desired driver
         * @return mixed
         */
        protected function selectDriver($driver) {
                $drivers = array('gd');
                $driver = strtolower((string)$driver);

                if(in_array($driver, $drivers, TRUE)) {
                        $string = $driver;
                } else {
                        $string = ARTICHOW_DRIVER;
                }

                switch ($string) {
                                case 'gd':
                                        require_once ARTICHOW.'/inc/drivers/gd.class.php';
                                        $this->driverString = $string;
                                        return new awGDDriver();
                                        
                                default:
                                        // We should never get here, unless the wrong string is used AND the ARTICHOW_DRIVER
                                        // global has been messed with.
                                        awImage::drawError('Class Image: Unknown driver type (\''.$string.'\')');
                                        break;
                        }
        }
        
        /**
         * Draw a component on the image
         *
         * @var awComponent $component A component
         */
        public function drawComponent(awComponent $component) {
                
                $shadow = $this->shadow->getSpace(); // Image shadow
                $border = $this->border->visible() ? 1 : 0; // Image border size
        
                $driver = clone $this->driver;
                $driver->setImageSize(
                        $this->width - $shadow->left - $shadow->right - $border * 2,
                        $this->height - $shadow->top - $shadow->bottom - $border * 2
                );
        
                // No absolute size specified
                if($component->w === NULL and $component->h === NULL) {
                
                        list($width, $height) = $driver->setSize($component->width, $component->height);
        
                        // Set component size in pixels
                        $component->setAbsSize($width, $height);
                        
                } else {
                
                        $driver->setAbsSize($component->w, $component->h);
                
                }
                
                if($component->top !== NULL and $component->left !== NULL) {
                        $driver->setAbsPosition(
                                $border + $shadow->left + $component->left,
                                $border + $shadow->top + $component->top
                        );
                } else {
                        $driver->setPosition($component->x, $component->y);
                }
                
                $driver->movePosition($border + $shadow->left, $border + $shadow->top);
                
                list($x1, $y1, $x2, $y2) = $component->getPosition();
                
                $component->init($driver);
                
                $component->drawComponent($driver, $x1, $y1, $x2, $y2, $this->antiAliasing);
                $component->drawEnvelope($driver, $x1, $y1, $x2, $y2);
                
                $component->finalize($driver);
        
        }
        
        protected function drawShadow() {
        
                $driver = $this->getDriver();
                
                $this->shadow->draw(
                        $driver,
                        new awPoint(0, 0),
                        new awPoint($this->width, $this->height),
                        awShadow::IN
                );
        
        }
        
        /**
         * Send the image into a file or to the user browser
         *
         */
        public function send() {
                $this->driver->send($this);
        }
        
        /**
         * Return the image content as binary data
         *
         */     
        public function get() {
                return $this->driver->get($this);
        }
        
        /**
         * Send the correct HTTP header according to the image type
         *
         */
        public function sendHeaders() {

                if(headers_sent() === FALSE) {
                        
                        switch ($this->driverString) {
                                case 'gd' :
                                        header('Content-type: image/'.$this->getFormatString());
                                        break;
                                
                        }

                }
        
        }
        
        
        private static $errorWriting = FALSE;
        

        /*
         * Display an error image and exit
         *
         * @param string $message Error message
         */
        public static function drawError($message) {
        
                        
                if(self::$errorWriting) {
                        return;
                }
        
                self::$errorWriting = TRUE;
        
                $message = wordwrap($message, 40, "\n", TRUE);
                
                $width = 400;
                $height = max(100, 40 + 22.5 * (substr_count($message, "\n") + 1));
                
                $image = new awImage();
                $image->setSize($width, $height);
                $image->setDriver('gd');
                
                $driver = $image->getDriver();
                $driver->init($image);
                
                // Display title
                $driver->filledRectangle(
                        new awWhite,
                        new awLine(
                                new awPoint(0, 0),
                                new awPoint($width, $height)
                        )
                );
                
                $driver->filledRectangle(
                        new awRed,
                        new awLine(
                                new awPoint(0, 0),
                                new awPoint(110, 25)
                        )
                );
                
                $text = new awText(
                        "Artichow error",
                        new awFont3,
                        new awWhite,
                        0
                );
                
                $driver->string($text, new awPoint(5, 6));
                
                // Display red box
                $driver->rectangle(
                        new awRed,
                        new awLine(
                                new awPoint(0, 25),
                                new awPoint($width - 90, $height - 1)
                        )
                );
                
                // Display error image
                $file = ARTICHOW_IMAGE.DIRECTORY_SEPARATOR.'error.png';
                
                $imageError = new awFileImage($file);
                $driver->copyImage(
                        $imageError,
                        new awPoint($width - 81, $height - 81),
                        new awPoint($width - 1, $height - 1)
                );
                
                // Draw message
                $text = new awText(
                        strip_tags($message),
                        new awFont2,
                        new awBlack,
                        0
                );
                
                $driver->string($text, new awPoint(10, 40));
                
                $image->send();
                
                exit;
        
        }
        
        /*
         * Display an error image located in a file and exit
         *
         * @param string $error Error name
         */
        public static function drawErrorFile($error) {
        
                $file = ARTICHOW_IMAGE.DIRECTORY_SEPARATOR.'errors'.DIRECTORY_SEPARATOR.$error.'.png';
                
                header("Content-Type: image/png");
                readfile($file);
                exit;
        
        }

}

registerClass('Image');

 
/**
 * Load an image from a file
 *
 * @package Artichow
 */
class awFileImage extends awImage {

        /**
         * Build a new awimage
         *
         * @param string $file Image file name
         */
        public function __construct($file) {
        
                $driver = $this->selectDriver($this->driverString);
                
                $driver->initFromFile($this, $file);
                
                $this->driver = $driver;
        
        }

}

registerClass('FileImage');

?>