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,

		);

		$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,

		);

		$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');

?>