774 lines
19 KiB
PHP
774 lines
19 KiB
PHP
|
<?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__)."/../Driver.class.php";
|
||
|
|
||
|
/**
|
||
|
* Draw your objects
|
||
|
*
|
||
|
* @package Artichow
|
||
|
*/
|
||
|
class awMingDriver extends awDriver {
|
||
|
|
||
|
/**
|
||
|
* The Flash movie
|
||
|
*
|
||
|
* @var $movie
|
||
|
*/
|
||
|
public $movie;
|
||
|
|
||
|
public function __construct() {
|
||
|
|
||
|
parent::__construct();
|
||
|
|
||
|
$this->driverString = 'ming';
|
||
|
|
||
|
// Nice defaults
|
||
|
ming_setScale(20.0);
|
||
|
ming_useswfversion(6);
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Initialize the driver for a particular awImage object
|
||
|
*
|
||
|
* @param awImage $image
|
||
|
*/
|
||
|
public function init(awImage $image) {
|
||
|
|
||
|
if($this->movie === NULL) {
|
||
|
$this->setImageSize($image->width, $image->height);
|
||
|
|
||
|
// Create movie
|
||
|
$this->movie = new SWFMovie();
|
||
|
if(!$this->movie) {
|
||
|
awImage::drawError("Class Image: Unable to create a graph.");
|
||
|
}
|
||
|
|
||
|
$this->movie->setDimension($image->width, $image->height);
|
||
|
|
||
|
$this->setAntiAliasing($image->getAntiAliasing());
|
||
|
|
||
|
// Original color
|
||
|
$this->filledRectangle(
|
||
|
new awWhite,
|
||
|
new awLine(
|
||
|
new awPoint(0, 0),
|
||
|
new awPoint($this->imageWidth, $this->imageHeight)
|
||
|
)
|
||
|
);
|
||
|
|
||
|
$shadow = $image->shadow;
|
||
|
if($shadow !== NULL) {
|
||
|
$shadow = $shadow->getSpace();
|
||
|
$p1 = new awPoint($shadow->left, $shadow->top);
|
||
|
$p2 = new awPoint($this->imageWidth - $shadow->right - 1, $this->imageHeight - $shadow->bottom - 1);
|
||
|
|
||
|
// Draw image background
|
||
|
$this->filledRectangle($image->getBackground(), new awLine($p1, $p2));
|
||
|
|
||
|
// Draw image border
|
||
|
$image->border->rectangle($this, $p1, $p2);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Initialize the Driver for a particular FileImage object
|
||
|
*
|
||
|
* @param awFileImage $fileImage The FileImage object to work on
|
||
|
* @param string $file Image filename
|
||
|
*/
|
||
|
public function initFromFile(awFileImage $fileImage, $file) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Change the image size
|
||
|
*
|
||
|
* @param int $width Image width
|
||
|
* @param int $height Image height
|
||
|
*/
|
||
|
public function setImageSize($width, $height) {
|
||
|
$this->imageWidth = $width;
|
||
|
$this->imageHeight = $height;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Inform the driver of the position of your image
|
||
|
*
|
||
|
* @param float $x Position on X axis of the center of the component
|
||
|
* @param float $y Position on Y axis of the center of the component
|
||
|
*/
|
||
|
public function setPosition($x, $y) {
|
||
|
// Calculate absolute position
|
||
|
$this->x = round($x * $this->imageWidth - $this->w / 2);
|
||
|
$this->y = round($y * $this->imageHeight - $this->h / 2);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Inform the driver of the position of your image
|
||
|
* This method need absolutes values
|
||
|
*
|
||
|
* @param int $x Left-top corner X position
|
||
|
* @param int $y Left-top corner Y position
|
||
|
*/
|
||
|
public function setAbsPosition($x, $y) {
|
||
|
$this->x = $x;
|
||
|
$this->y = $y;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Move the position of the image
|
||
|
*
|
||
|
* @param int $x Add this value to X axis
|
||
|
* @param int $y Add this value to Y axis
|
||
|
*/
|
||
|
public function movePosition($x, $y) {
|
||
|
$this->x += (int)$x;
|
||
|
$this->y += (int)$y;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Inform the driver of the size of your image
|
||
|
* Height and width must be between 0 and 1.
|
||
|
*
|
||
|
* @param int $w Image width
|
||
|
* @param int $h Image height
|
||
|
* @return array Absolute width and height of the image
|
||
|
*/
|
||
|
public function setSize($w, $h) {
|
||
|
|
||
|
// Calcul absolute size
|
||
|
$this->w = round($w * $this->imageWidth);
|
||
|
$this->h = round($h * $this->imageHeight);
|
||
|
|
||
|
return $this->getSize();
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Inform the driver of the size of your image
|
||
|
* You can set absolute size with this method.
|
||
|
*
|
||
|
* @param int $w Image width
|
||
|
* @param int $h Image height
|
||
|
*/
|
||
|
public function setAbsSize($w, $h) {
|
||
|
$this->w = $w;
|
||
|
$this->h = $h;
|
||
|
|
||
|
return $this->getSize();
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Get the size of the component handled by the driver
|
||
|
*
|
||
|
* @return array Absolute width and height of the component
|
||
|
*/
|
||
|
public function getSize() {
|
||
|
return array($this->w, $this->h);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Turn antialiasing on or off
|
||
|
*
|
||
|
* @var bool $bool
|
||
|
*/
|
||
|
public function setAntiAliasing($bool) {
|
||
|
if($this->movie !== NULL) {
|
||
|
|
||
|
$actionscript = '
|
||
|
_quality = "%s";
|
||
|
';
|
||
|
|
||
|
if((bool)$bool) {
|
||
|
$actionscript = sprintf($actionscript, 'high');
|
||
|
} else {
|
||
|
$actionscript = sprintf($actionscript, 'low');
|
||
|
}
|
||
|
|
||
|
$this->movie->add(new SWFAction(str_replace("\r", "", $actionscript)));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* When passed a Color object, returns the corresponding
|
||
|
* color identifier (driver dependant).
|
||
|
*
|
||
|
* @param awColor $color A Color object
|
||
|
* @return array $rgba A color identifier representing the color composed of the given RGB components
|
||
|
*/
|
||
|
public function getColor(awColor $color) {
|
||
|
|
||
|
// Ming simply works with R, G, B and Alpha values.
|
||
|
list($red, $green, $blue, $alpha) = $color->rgba();
|
||
|
|
||
|
// However, the Ming alpha channel ranges from 255 (opaque) to 0 (transparent),
|
||
|
// while the awColor alpha channel ranges from 0 (opaque) to 100 (transparent).
|
||
|
// First, we convert from 0-100 to 0-255.
|
||
|
$alpha = (int)($alpha * 255 / 100);
|
||
|
|
||
|
// Then from 0-255 to 255-0.
|
||
|
$alpha = abs($alpha - 255);
|
||
|
|
||
|
return array($red, $green, $blue, $alpha);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw an image here
|
||
|
*
|
||
|
* @param awImage $image Image
|
||
|
* @param int $p1 Image top-left point
|
||
|
* @param int $p2 Image bottom-right point
|
||
|
*/
|
||
|
public function copyImage(awImage $image, awPoint $p1, awPoint $p2) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw an image here
|
||
|
*
|
||
|
* @param awImage $image Image
|
||
|
* @param int $d1 Destination top-left position
|
||
|
* @param int $d2 Destination bottom-right position
|
||
|
* @param int $s1 Source top-left position
|
||
|
* @param int $s2 Source bottom-right position
|
||
|
* @param bool $resample Resample image ? (default to TRUE)
|
||
|
*/
|
||
|
public function copyResizeImage(awImage $image, awPoint $d1, awPoint $d2, awPoint $s1, awPoint $s2, $resample = TRUE) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a string
|
||
|
*
|
||
|
* @var awText $text Text to print
|
||
|
* @param awPoint $point Draw the text at this point
|
||
|
* @param int $width Text max width
|
||
|
*/
|
||
|
public function string(awText $text, awPoint $point, $width = NULL) {
|
||
|
$font = $text->getFont();
|
||
|
|
||
|
// Can we deal with that font?
|
||
|
if($this->isCompatibleWithFont($font) === FALSE) {
|
||
|
awImage::drawError('Class MingDriver: Incompatible font type (\''.get_class($font).'\')');
|
||
|
}
|
||
|
|
||
|
// Ming can only work with awFileFont objects for now
|
||
|
// (i.e. awFDBFont, or awTuffy et al.)
|
||
|
$fontDriver = $this->fileFontDriver;
|
||
|
|
||
|
if($text->getBackground() !== NULL or $text->border->visible()) {
|
||
|
|
||
|
list($left, $right, $top, $bottom) = $text->getPadding();
|
||
|
|
||
|
$textWidth = $fontDriver->getTextWidth($text, $this);
|
||
|
$textHeight = $fontDriver->getTextHeight($text, $this);
|
||
|
|
||
|
$x1 = floor($point->x - $left);
|
||
|
$y1 = floor($point->y - $top);
|
||
|
$x2 = $x1 + $textWidth + $left + $right;
|
||
|
$y2 = $y1 + $textHeight + $top + $bottom;
|
||
|
|
||
|
$this->filledRectangle(
|
||
|
$text->getBackground(),
|
||
|
awLine::build($x1, $y1, $x2, $y2)
|
||
|
);
|
||
|
|
||
|
$text->border->rectangle(
|
||
|
$this,
|
||
|
new awPoint($x1 - 1, $y1 - 1),
|
||
|
new awPoint($x2 + 1, $y2 + 1)
|
||
|
);
|
||
|
|
||
|
}
|
||
|
|
||
|
$fontDriver->string($this, $text, $point, $width);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a pixel
|
||
|
*
|
||
|
* @param awColor $color Pixel color
|
||
|
* @param awPoint $p
|
||
|
*/
|
||
|
public function point(awColor $color, awPoint $p) {
|
||
|
if($p->isHidden() === FALSE) {
|
||
|
list($red, $green, $blue, $alpha) = $this->getColor($color);
|
||
|
|
||
|
$point = new SWFShape();
|
||
|
$point->setLine(1, $red, $green, $blue, $alpha);
|
||
|
$point->movePenTo($this->x + round($p->x), $this->y + round($p->y));
|
||
|
$point->drawLine(0.5, 0.5);
|
||
|
$point->movePen(-0.5, 0);
|
||
|
$point->drawLine(0.5, -0.5);
|
||
|
|
||
|
$this->movie->add($point);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a colored line
|
||
|
*
|
||
|
* @param awColor $color Line color
|
||
|
* @param awLine $line
|
||
|
* @param int $thickness Line tickness
|
||
|
*/
|
||
|
public function line(awColor $color, awLine $line) {
|
||
|
if($line->getThickness() > 0 and $line->isHidden() === FALSE) {
|
||
|
|
||
|
list($red, $green, $blue, $alpha) = $this->getColor($color);
|
||
|
|
||
|
$mingLine = new SWFShape();
|
||
|
$mingLine->setLine($line->getThickness(), $red, $green, $blue, $alpha);
|
||
|
|
||
|
list($p1, $p2) = $line->getLocation();
|
||
|
|
||
|
$mingLine->movePenTo($this->x + round($p1->x), $this->y + round($p1->y));
|
||
|
|
||
|
switch($line->getStyle()) {
|
||
|
|
||
|
case awLine::SOLID :
|
||
|
$mingLine->drawLineTo($this->x + round($p2->x), $this->y + round($p2->y));
|
||
|
$this->movie->add($mingLine);
|
||
|
break;
|
||
|
|
||
|
case awLine::DOTTED :
|
||
|
$size = sqrt(pow($p2->y - $p1->y, 2) + pow($p2->x - $p1->x, 2));
|
||
|
$cos = ($p2->x - $p1->x) / $size;
|
||
|
$sin = ($p2->y - $p1->y) / $size;
|
||
|
|
||
|
for($i = 0; $i <= $size; $i += 2) {
|
||
|
$p = new awPoint(
|
||
|
round($i * $cos + $p1->x),
|
||
|
round($i * $sin + $p1->y)
|
||
|
);
|
||
|
$this->point($color, $p);
|
||
|
}
|
||
|
|
||
|
break;
|
||
|
|
||
|
case awLine::DASHED :
|
||
|
$width = $p2->x - $p1->x;
|
||
|
$height = $p2->y - $p1->y;
|
||
|
$size = sqrt(pow($height, 2) + pow($width, 2));
|
||
|
|
||
|
if($size == 0) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
$cos = $width / $size;
|
||
|
$sin = $height / $size;
|
||
|
|
||
|
$functionX = ($width > 0) ? 'min' : 'max';
|
||
|
$functionY = ($height > 0) ? 'min' : 'max';
|
||
|
|
||
|
for($i = 0; $i <= $size; $i += 6) {
|
||
|
|
||
|
$t1 = new awPoint(
|
||
|
round($i * $cos + $p1->x),
|
||
|
round($i * $sin + $p1->y)
|
||
|
);
|
||
|
|
||
|
$t2 = new awPoint(
|
||
|
round($functionX(($i + 3) * $cos, $width) + $p1->x),
|
||
|
round($functionY(($i + 3) * $sin, $height) + $p1->y)
|
||
|
);
|
||
|
|
||
|
$this->line($color, new awLine($t1, $t2));
|
||
|
|
||
|
}
|
||
|
|
||
|
break;
|
||
|
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a color arc
|
||
|
|
||
|
* @param awColor $color Arc color
|
||
|
* @param awPoint $center Point center
|
||
|
* @param int $width Ellipse width
|
||
|
* @param int $height Ellipse height
|
||
|
* @param int $from Start angle
|
||
|
* @param int $to End angle
|
||
|
*/
|
||
|
public function arc(awColor $color, awPoint $center, $width, $height, $from, $to) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw an arc with a background color
|
||
|
*
|
||
|
* @param awColor $color Arc background color
|
||
|
* @param awPoint $center Point center
|
||
|
* @param int $width Ellipse width
|
||
|
* @param int $height Ellipse height
|
||
|
* @param int $from Start angle
|
||
|
* @param int $to End angle
|
||
|
*/
|
||
|
public function filledArc(awColor $color, awPoint $center, $width, $height, $from, $to) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a colored ellipse
|
||
|
*
|
||
|
* @param awColor $color Ellipse color
|
||
|
* @param awPoint $center Ellipse center
|
||
|
* @param int $width Ellipse width
|
||
|
* @param int $height Ellipse height
|
||
|
*/
|
||
|
public function ellipse(awColor $color, awPoint $center, $width, $height) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw an ellipse with a background
|
||
|
*
|
||
|
* @param mixed $background Background (can be a color or a gradient)
|
||
|
* @param awPoint $center Ellipse center
|
||
|
* @param int $width Ellipse width
|
||
|
* @param int $height Ellipse height
|
||
|
*/
|
||
|
public function filledEllipse($background, awPoint $center, $width, $height) {
|
||
|
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a colored rectangle
|
||
|
*
|
||
|
* @param awColor $color Rectangle color
|
||
|
* @param awLine $line Rectangle diagonale
|
||
|
* @param awPoint $p2
|
||
|
*/
|
||
|
public function rectangle(awColor $color, awLine $line) {
|
||
|
list($p1, $p2) = $line->getLocation();
|
||
|
|
||
|
// Get Red, Green, Blue and Alpha values for the line
|
||
|
list($r, $g, $b, $a) = $this->getColor($color);
|
||
|
|
||
|
// Calculate the coordinates of the two other points of the rectangle
|
||
|
$p3 = new Point($p1->x, $p2->y);
|
||
|
$p4 = new Point($p2->x, $p1->y);
|
||
|
|
||
|
|
||
|
$side = clone $line;
|
||
|
|
||
|
|
||
|
|
||
|
// Draw the four sides of the rectangle, clockwise
|
||
|
if(
|
||
|
($p1->x <= $p2->x and $p1->y <= $p2->y)
|
||
|
or
|
||
|
($p1->x >= $p2->x and $p1->y >= $p2->y)
|
||
|
) {
|
||
|
$side->setLocation($p1, $p4);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p4, $p2);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p2, $p3);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p3, $p1);
|
||
|
$this->line($color, $side);
|
||
|
} else {
|
||
|
$side->setLocation($p1, $p3);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p3, $p2);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p2, $p4);
|
||
|
$this->line($color, $side);
|
||
|
|
||
|
$side->setLocation($p4, $p1);
|
||
|
$this->line($color, $side);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a rectangle with a background
|
||
|
*
|
||
|
* @param mixed $background Background (can be a color or a gradient)
|
||
|
* @param awLine $line Rectangle diagonale
|
||
|
*/
|
||
|
public function filledRectangle($background, awLine $line) {
|
||
|
list($p1, $p2) = $line->getLocation();
|
||
|
|
||
|
// Common shape settings
|
||
|
$shape = new SWFShape();
|
||
|
$shape->setLine(0);
|
||
|
|
||
|
if($background instanceof awColor) {
|
||
|
|
||
|
// Get the Red, Green, Blue and Alpha values
|
||
|
list($r, $g, $b, $a) = $this->getColor($background);
|
||
|
$shape->setRightFill($r, $g, $b, $a);
|
||
|
|
||
|
} else if($background instanceof awGradient) {
|
||
|
|
||
|
// Get the Gradient object as an SWFGradient one
|
||
|
list($flashGradient, $style) = $this->getGradient($background);
|
||
|
|
||
|
$fill = $shape->addFill($flashGradient, $style);
|
||
|
|
||
|
// Angles between Artichow and Ming don't match.
|
||
|
// Don't use abs() or vertical gradients get inverted.
|
||
|
$angle = $background->angle - 90;
|
||
|
$fill->rotateTo($angle);
|
||
|
|
||
|
// Move the gradient based on the position of the rectangle we're drawing
|
||
|
$centerX = min($p1->x, $p2->y) + abs($p1->x - $p2->x) / 2;
|
||
|
$centerY = min($p1->y, $p2->y) + abs($p1->y - $p2->y) / 2;
|
||
|
$fill->moveTo($centerX, $centerY);
|
||
|
|
||
|
// Ming draws its gradients on a 1600x1600 image,
|
||
|
// so we have to resize it.
|
||
|
if($angle === -90) {
|
||
|
$ratio = abs($p1->y - $p2->y) / 1600;
|
||
|
} else {
|
||
|
$ratio = abs($p1->x - $p2->x) / 1600;
|
||
|
}
|
||
|
$fill->scaleTo($ratio);
|
||
|
|
||
|
$shape->setRightFill($fill);
|
||
|
|
||
|
}
|
||
|
|
||
|
// Set starting position
|
||
|
$shape->movePenTo($this->x + round($p1->x), $this->y + round($p1->y));
|
||
|
|
||
|
// Depending on the points' relative positions,
|
||
|
// we have two drawing possibilities
|
||
|
if(
|
||
|
($p1->x <= $p2->x and $p1->y <= $p2->y)
|
||
|
or
|
||
|
($p1->x >= $p2->x and $p1->y >= $p2->y)
|
||
|
) {
|
||
|
$shape->drawLineTo($this->x + round($p2->x), $this->y + round($p1->y));
|
||
|
$shape->drawLineTo($this->x + round($p2->x), $this->y + round($p2->y));
|
||
|
$shape->drawLineTo($this->x + round($p1->x), $this->y + round($p2->y));
|
||
|
$shape->drawLineTo($this->x + round($p1->x), $this->y + round($p1->y));
|
||
|
} else {
|
||
|
$shape->drawLineTo($this->x + round($p1->x), $this->y + round($p2->y));
|
||
|
$shape->drawLineTo($this->x + round($p2->x), $this->y + round($p2->y));
|
||
|
$shape->drawLineTo($this->x + round($p2->x), $this->y + round($p1->y));
|
||
|
$shape->drawLineTo($this->x + round($p1->x), $this->y + round($p1->y));
|
||
|
}
|
||
|
|
||
|
$this->movie->add($shape);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a polygon
|
||
|
*
|
||
|
* @param awColor $color Polygon color
|
||
|
* @param Polygon A polygon
|
||
|
*/
|
||
|
public function polygon(awColor $color, awPolygon $polygon) {
|
||
|
$points = $polygon->all();
|
||
|
$count = count($points);
|
||
|
|
||
|
if($count > 1) {
|
||
|
|
||
|
$side = new awLine;
|
||
|
$side->setStyle($polygon->getStyle());
|
||
|
$side->setThickness($polygon->getThickness());
|
||
|
|
||
|
$prev = $points[0];
|
||
|
|
||
|
for($i = 1; $i < $count; $i++) {
|
||
|
$current = $points[$i];
|
||
|
$side->setLocation($prev, $current);
|
||
|
$this->line($color, $side);
|
||
|
$prev = $current;
|
||
|
}
|
||
|
|
||
|
// Close the polygon
|
||
|
$side->setLocation($prev, $points[0]);
|
||
|
$this->line($color, $side);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Draw a polygon with a background
|
||
|
*
|
||
|
* @param mixed $background Background (can be a color or a gradient)
|
||
|
* @param Polygon A polygon
|
||
|
*/
|
||
|
public function filledPolygon($background, awPolygon $polygon) {
|
||
|
$shape = new SWFShape();
|
||
|
|
||
|
if($background instanceof awColor) {
|
||
|
list($red, $green, $blue, $alpha) = $this->getColor($background);
|
||
|
|
||
|
$shape->setRightFill($red, $green, $blue, $alpha);
|
||
|
} elseif($background instanceof awGradient) {
|
||
|
list($flashGradient, $style) = $this->getGradient($background);
|
||
|
|
||
|
$fill = $shape->addFill($flashGradient, $style);
|
||
|
|
||
|
list($xMin, $xMax) = $polygon->getBoxXRange();
|
||
|
list($yMin, $yMax) = $polygon->getBoxYRange();
|
||
|
|
||
|
if($background->angle === 0) {
|
||
|
$fill->scaleTo(($yMax - $yMin) / 1600);
|
||
|
} else {
|
||
|
$fill->scaleTo(($xMax - $xMin) / 1600);
|
||
|
}
|
||
|
$fill->moveTo($xMin + ($xMax - $xMin) / 2, $yMin + ($yMax - $yMin) / 2);
|
||
|
|
||
|
$shape->setRightFill($fill);
|
||
|
}
|
||
|
|
||
|
$points = $polygon->all();
|
||
|
$count = count($points);
|
||
|
|
||
|
if($count > 1) {
|
||
|
|
||
|
$prev = $points[0];
|
||
|
|
||
|
$shape->movePenTo($prev->x, $prev->y);
|
||
|
|
||
|
for($i = 1; $i < $count; $i++) {
|
||
|
$current = $points[$i];
|
||
|
$shape->drawLineTo($current->x, $current->y);
|
||
|
}
|
||
|
|
||
|
// Close the polygon
|
||
|
$shape->drawLineTo($prev->x, $prev->y);
|
||
|
|
||
|
$this->movie->add($shape);
|
||
|
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Sends the image, as well as the correct HTTP headers, to the browser
|
||
|
*
|
||
|
* @param awImage $image The Image object to send
|
||
|
*/
|
||
|
public function send(awImage $image) {
|
||
|
$this->drawImage($image);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Get the image as binary data
|
||
|
*
|
||
|
* @param awImage $image
|
||
|
*/
|
||
|
public function get(awImage $image) {
|
||
|
return $this->drawImage($image, TRUE, FALSE);
|
||
|
}
|
||
|
|
||
|
public function getTextWidth(awText $text) {
|
||
|
$font = $text->getFont();
|
||
|
if($this->isCompatibleWithFont($font) === FALSE) {
|
||
|
awImage::drawError('Class MingDriver: Incompatible font type (\''.get_class($font).'\')');
|
||
|
}
|
||
|
|
||
|
// Ming only supports FileFont
|
||
|
$fontDriver = $this->fileFontDriver;
|
||
|
|
||
|
return $fontDriver->getTextWidth($text, $this);
|
||
|
}
|
||
|
|
||
|
public function getTextHeight(awText $text) {
|
||
|
$font = $text->getFont();
|
||
|
if($this->isCompatibleWithFont($font) === FALSE) {
|
||
|
awImage::drawError('Class MingDriver: Incompatible font type (\''.get_class($font).'\')');
|
||
|
}
|
||
|
|
||
|
// Ming only supports FileFont
|
||
|
$fontDriver = $this->fileFontDriver;
|
||
|
|
||
|
return $fontDriver->getTextHeight($text, $this);
|
||
|
}
|
||
|
|
||
|
protected function isCompatibleWithFont(awFont $font) {
|
||
|
if($font instanceof awTTFFont or $font instanceof awPHPFont) {
|
||
|
return FALSE;
|
||
|
} else {
|
||
|
return TRUE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private function drawImage(awImage $image, $return = FALSE, $header = TRUE) {
|
||
|
|
||
|
// Send headers to the browser
|
||
|
if($header === TRUE) {
|
||
|
$image->sendHeaders();
|
||
|
}
|
||
|
|
||
|
if($return) {
|
||
|
ob_start();
|
||
|
}
|
||
|
|
||
|
$this->movie->output();
|
||
|
|
||
|
if($return) {
|
||
|
return ob_get_clean();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Convert an awGradient object to an SWFGradient one.
|
||
|
* Returns an object as well as the style of the Flash gradient.
|
||
|
*
|
||
|
* @param awGradient $gradient The awGradient object to convert
|
||
|
* @return array
|
||
|
*/
|
||
|
private function getGradient(awGradient $gradient) {
|
||
|
$flashGradient = new SWFGradient();
|
||
|
|
||
|
// Get RGBA values for the gradient boundaries
|
||
|
list($r1, $g1, $b1, $a1) = $this->getColor($gradient->from);
|
||
|
list($r2, $g2, $b2, $a2) = $this->getColor($gradient->to);
|
||
|
|
||
|
$flashGradient->addEntry(0, $r1, $g1, $b1, $a1);
|
||
|
|
||
|
if($gradient instanceof awBilinearGradient) {
|
||
|
|
||
|
$flashGradient->addEntry($gradient->center, $r2, $g2, $b2, $a2);
|
||
|
$flashGradient->addEntry(1, $r1, $g1, $b1, $a1);
|
||
|
|
||
|
return array($flashGradient, SWFFILL_LINEAR_GRADIENT);
|
||
|
} else {
|
||
|
|
||
|
$flashGradient->addEntry(1, $r2, $g2, $b2, $a2);
|
||
|
|
||
|
if($gradient instanceof awLinearGradient) {
|
||
|
return array($flashGradient, SWFFILL_LINEAR_GRADIENT);
|
||
|
} else {
|
||
|
return array($flashGradient, SWFFILL_RADIAL_GRADIENT);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
// abstract private function getPolygonPoints(awPolygon $polygon);
|
||
|
|
||
|
}
|
||
|
|
||
|
registerClass('MingDriver');
|
||
|
|
||
|
/*
|
||
|
* Check for ming presence
|
||
|
*/
|
||
|
if(function_exists('ming_useswfversion') === FALSE) {
|
||
|
awImage::drawErrorFile('missing-ming');
|
||
|
}
|
||
|
|
||
|
?>
|