| New file |
|---|
| 0,0 → 1,774 |
|---|
| <?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'); |
| } |
| |
| ?> |