| <?php |
| /** |
| * File containing the ezcGraphFlashDriver class |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| * @package Graph |
| * @version //autogentag// |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 |
| */ |
| /** |
| * Driver to create Flash4 (SWF) files as graph output. The options of this |
| * class are defined in The options of this class are defined in the option |
| * class {@link ezcGraphFlashDriverOptions} extending the basic |
| * {@link ezcGraphDriverOptions}. |
| * |
| * <code> |
| * $graph = new ezcGraphPieChart(); |
| * $graph->title = 'Access statistics'; |
| * $graph->legend = false; |
| * |
| * $graph->driver = new ezcGraphFlashDriver(); |
| * $graph->options->font = 'tutorial_font.fdb'; |
| * |
| * $graph->driver->options->compression = 7; |
| * |
| * $graph->data['Access statistics'] = new ezcGraphArrayDataSet( array( |
| * 'Mozilla' => 19113, |
| * 'Explorer' => 10917, |
| * 'Opera' => 1464, |
| * 'Safari' => 652, |
| * 'Konqueror' => 474, |
| * ) ); |
| * |
| * $graph->render( 400, 200, 'tutorial_driver_flash.swf' ); |
| * </code> |
| * |
| * |
| * @version //autogentag// |
| * @package Graph |
| * @mainclass |
| */ |
| class ezcGraphFlashDriver extends ezcGraphDriver |
| { |
| /** |
| * Flash movie |
| * |
| * @var SWFMovie |
| */ |
| protected $movie; |
| |
| /** |
| * Unique element id |
| * |
| * @var int |
| */ |
| protected $id = 1; |
| |
| /** |
| * Array with strings to draw later |
| * |
| * @var array |
| */ |
| protected $strings = array(); |
| |
| /** |
| * Constructor |
| * |
| * @param array $options Default option array |
| * @return void |
| * @ignore |
| */ |
| public function __construct( array $options = array() ) |
| { |
| ezcBase::checkDependency( 'Graph', ezcBase::DEP_PHP_EXTENSION, 'ming' ); |
| $this->options = new ezcGraphFlashDriverOptions( $options ); |
| } |
| |
| /** |
| * Returns unique movie object as a parent canvas for all swf objects. |
| * |
| * @return SWFMovie |
| */ |
| public function getDocument() |
| { |
| if ( $this->movie === null ) |
| { |
| ming_setscale( 1.0 ); |
| $this->movie = new SWFMovie(); |
| $this->movie->setDimension( $this->modifyCoordinate( $this->options->width ), $this->modifyCoordinate( $this->options->height ) ); |
| $this->movie->setRate( 1 ); |
| $this->movie->setBackground( 255, 255, 255 ); |
| } |
| |
| return $this->movie; |
| } |
| |
| /** |
| * Set the fill and line properties for a SWWFShape according to the |
| * given parameters. |
| * |
| * @param SWFShape $shape |
| * @param ezcGraphColor $color |
| * @param mixed $thickness |
| * @param mixed $filled |
| * @return void |
| */ |
| protected function setShapeColor( SWFShape $shape, ezcGraphColor $color, $thickness, $filled ) |
| { |
| if ( $filled ) |
| { |
| switch ( true ) |
| { |
| case ( $color instanceof ezcGraphLinearGradient ): |
| $gradient = new SWFGradient(); |
| $gradient->addEntry( |
| 0, |
| $color->startColor->red, |
| $color->startColor->green, |
| $color->startColor->blue, |
| 255 - $color->startColor->alpha |
| ); |
| $gradient->addEntry( |
| 1, |
| $color->endColor->red, |
| $color->endColor->green, |
| $color->endColor->blue, |
| 255 - $color->endColor->alpha |
| ); |
| |
| $fill = $shape->addFill( $gradient, SWFFILL_LINEAR_GRADIENT ); |
| |
| // Calculate desired length of gradient |
| $length = sqrt( |
| pow( $color->endPoint->x - $color->startPoint->x, 2 ) + |
| pow( $color->endPoint->y - $color->startPoint->y, 2 ) |
| ); |
| |
| $fill->scaleTo( $this->modifyCoordinate( $length ) / 32768 , $this->modifyCoordinate( $length ) / 32768 ); |
| $fill->rotateTo( |
| rad2deg( asin( |
| ( $color->endPoint->x - $color->startPoint->x ) / $length |
| ) + 180 ) |
| ); |
| $fill->moveTo( |
| $this->modifyCoordinate( |
| ( $color->startPoint->x + $color->endPoint->x ) / 2 |
| ), |
| $this->modifyCoordinate( |
| ( $color->startPoint->y + $color->endPoint->y ) / 2 |
| ) |
| ); |
| |
| $shape->setLeftFill( $fill ); |
| break; |
| case ( $color instanceof ezcGraphRadialGradient ): |
| $gradient = new SWFGradient(); |
| $gradient->addEntry( |
| 0, |
| $color->startColor->red, |
| $color->startColor->green, |
| $color->startColor->blue, |
| 255 - $color->startColor->alpha |
| ); |
| $gradient->addEntry( |
| 1, |
| $color->endColor->red, |
| $color->endColor->green, |
| $color->endColor->blue, |
| 255 - $color->endColor->alpha |
| ); |
| |
| $fill = $shape->addFill( $gradient, SWFFILL_RADIAL_GRADIENT ); |
| |
| $fill->scaleTo( $this->modifyCoordinate( $color->width ) / 32768, $this->modifyCoordinate( $color->height ) / 32768 ); |
| $fill->moveTo( $this->modifyCoordinate( $color->center->x ), $this->modifyCoordinate( $color->center->y ) ); |
| |
| $shape->setLeftFill( $fill ); |
| break; |
| default: |
| $fill = $shape->addFill( $color->red, $color->green, $color->blue, 255 - $color->alpha ); |
| $shape->setLeftFill( $fill ); |
| break; |
| } |
| } |
| else |
| { |
| $shape->setLine( $this->modifyCoordinate( $thickness ), $color->red, $color->green, $color->blue, 255 - $color->alpha ); |
| } |
| } |
| |
| /** |
| * Modifies a coordinate value, as flash usally uses twips instead of |
| * pixels for a higher solution, as it only accepts integer values. |
| * |
| * @param float $pointValue |
| * @return float |
| */ |
| protected function modifyCoordinate( $pointValue ) |
| { |
| return $pointValue * 10; |
| } |
| |
| /** |
| * Demodifies a coordinate value, as flash usally uses twips instead of |
| * pixels for a higher solution, as it only accepts integer values. |
| * |
| * @param float $pointValue |
| * @return float |
| */ |
| protected function deModifyCoordinate( $pointValue ) |
| { |
| return $pointValue / 10; |
| } |
| |
| /** |
| * Draws a single polygon. |
| * |
| * @param array $points Point array |
| * @param ezcGraphColor $color Polygon color |
| * @param mixed $filled Filled |
| * @param float $thickness Line thickness |
| * @return void |
| */ |
| public function drawPolygon( array $points, ezcGraphColor $color, $filled = true, $thickness = 1. ) |
| { |
| $movie = $this->getDocument(); |
| |
| if ( !$filled ) |
| { |
| // The middle of the border is on the outline of a polygon in ming, |
| // fix that: |
| try |
| { |
| $points = $this->reducePolygonSize( $points, $thickness / 2 ); |
| } |
| catch ( ezcGraphReducementFailedException $e ) |
| { |
| return false; |
| } |
| } |
| |
| $shape = new SWFShape(); |
| |
| $this->setShapeColor( $shape, $color, $thickness, $filled ); |
| |
| $lastPoint = end( $points ); |
| $shape->movePenTo( $this->modifyCoordinate( $lastPoint->x ), $this->modifyCoordinate( $lastPoint->y ) ); |
| |
| foreach ( $points as $point ) |
| { |
| $shape->drawLineTo( $this->modifyCoordinate( $point->x ), $this->modifyCoordinate( $point->y ) ); |
| } |
| |
| $object = $movie->add( $shape ); |
| $object->setName( $id = 'ezcGraphPolygon_' . $this->id++ ); |
| |
| return $id; |
| } |
| |
| /** |
| * Draws a line |
| * |
| * @param ezcGraphCoordinate $start Start point |
| * @param ezcGraphCoordinate $end End point |
| * @param ezcGraphColor $color Line color |
| * @param float $thickness Line thickness |
| * @return void |
| */ |
| public function drawLine( ezcGraphCoordinate $start, ezcGraphCoordinate $end, ezcGraphColor $color, $thickness = 1. ) |
| { |
| $movie = $this->getDocument(); |
| |
| $shape = new SWFShape(); |
| |
| $this->setShapeColor( $shape, $color, $thickness, false ); |
| |
| $shape->movePenTo( $this->modifyCoordinate( $start->x ), $this->modifyCoordinate( $start->y ) ); |
| $shape->drawLineTo( $this->modifyCoordinate( $end->x ), $this->modifyCoordinate( $end->y ) ); |
| |
| $object = $movie->add( $shape ); |
| $object->setName( $id = 'ezcGraphLine_' . $this->id++ ); |
| |
| return $id; |
| } |
| |
| /** |
| * Returns boundings of text depending on the available font extension |
| * |
| * @param float $size Textsize |
| * @param ezcGraphFontOptions $font Font |
| * @param string $text Text |
| * @return ezcGraphBoundings Boundings of text |
| */ |
| protected function getTextBoundings( $size, ezcGraphFontOptions $font, $text ) |
| { |
| $t = new SWFText(); |
| $t->setFont( new SWFFont( $font->path ) ); |
| $t->setHeight( $size ); |
| |
| $boundings = new ezcGraphBoundings( 0, 0, $t->getWidth( $text ), $size ); |
| |
| return $boundings; |
| } |
| |
| /** |
| * Writes text in a box of desired size |
| * |
| * @param string $string Text |
| * @param ezcGraphCoordinate $position Top left position |
| * @param float $width Width of text box |
| * @param float $height Height of text box |
| * @param int $align Alignement of text |
| * @param ezcGraphRotation $rotation |
| * @return void |
| */ |
| public function drawTextBox( $string, ezcGraphCoordinate $position, $width, $height, $align, ezcGraphRotation $rotation = null ) |
| { |
| $padding = $this->options->font->padding + ( $this->options->font->border !== false ? $this->options->font->borderWidth : 0 ); |
| |
| $width = $this->modifyCoordinate( $width - $padding * 2 ); |
| $height = $this->modifyCoordinate( $height - $padding * 2 ); |
| $position = new ezcGraphCoordinate( |
| $this->modifyCoordinate( $position->x + $padding ), |
| $this->modifyCoordinate( $position->y + $padding ) |
| ); |
| |
| // Try to get a font size for the text to fit into the box |
| $maxSize = $this->modifyCoordinate( min( $height, $this->options->font->maxFontSize ) ); |
| $minSize = $this->modifyCoordinate( $this->options->font->minFontSize ); |
| $result = false; |
| for ( $size = $maxSize; $size >= $minSize; ) |
| { |
| $result = $this->testFitStringInTextBox( $string, $position, $width, $height, $size ); |
| if ( is_array( $result ) ) |
| { |
| break; |
| } |
| $size = $this->deModifyCoordinate( $size ); |
| $size = $this->modifyCoordinate( floor( ( $newsize = $size * ( $result ) ) >= $size ? $size - 1 : $newsize ) ); |
| } |
| |
| if ( !is_array( $result ) ) |
| { |
| if ( ( $height >= $this->options->font->minFontSize ) && |
| ( $this->options->autoShortenString ) ) |
| { |
| $result = $this->tryFitShortenedString( $string, $position, $width, $height, $size = $this->modifyCoordinate( $this->options->font->minFontSize ) ); |
| } |
| else |
| { |
| throw new ezcGraphFontRenderingException( $string, $this->options->font->minFontSize, $width, $height ); |
| } |
| } |
| |
| |
| $this->options->font->minimalUsedFont = $this->deModifyCoordinate( $size ); |
| |
| $this->strings[] = array( |
| 'text' => $result, |
| 'id' => $id = 'ezcGraphTextBox_' . $this->id++, |
| 'position' => $position, |
| 'width' => $width, |
| 'height' => $height, |
| 'align' => $align, |
| 'font' => $this->options->font, |
| 'rotation' => $rotation, |
| ); |
| |
| return $id; |
| } |
| |
| /** |
| * Render text depending of font type and available font extensions |
| * |
| * @param string $id |
| * @param string $text |
| * @param string $chars |
| * @param int $type |
| * @param string $path |
| * @param ezcGraphColor $color |
| * @param ezcGraphCoordinate $position |
| * @param float $size |
| * @param float $rotation |
| * @return void |
| */ |
| protected function renderText( $id, $text, $chars, $type, $path, ezcGraphColor $color, ezcGraphCoordinate $position, $size, $rotation = null ) |
| { |
| $movie = $this->getDocument(); |
| |
| $tb = new SWFTextField( SWFTEXTFIELD_NOEDIT ); |
| $tb->setFont( new SWFFont( $path ) ); |
| $tb->setHeight( $size ); |
| $tb->setColor( $color->red, $color->green, $color->blue, 255 - $color->alpha ); |
| $tb->addString( $text ); |
| $tb->addChars( $chars ); |
| |
| $object = $movie->add( $tb ); |
| $object->rotate( |
| ( $rotation !== null ? -$rotation->getRotation() : 0 ) |
| ); |
| $object->moveTo( |
| $position->x + |
| ( $rotation === null ? 0 : $this->modifyCoordinate( $rotation->get( 0, 2 ) ) ), |
| $position->y - |
| $size * ( 1 + $this->options->lineSpacing ) + |
| ( $rotation === null ? 0 : $this->modifyCoordinate( $rotation->get( 1, 2 ) ) ) |
| ); |
| $object->setName( $id ); |
| } |
| |
| /** |
| * Draw all collected texts |
| * |
| * The texts are collected and their maximum possible font size is |
| * calculated. This function finally draws the texts on the image, this |
| * delayed drawing has two reasons: |
| * |
| * 1) This way the text strings are always on top of the image, what |
| * results in better readable texts |
| * 2) The maximum possible font size can be calculated for a set of texts |
| * with the same font configuration. Strings belonging to one chart |
| * element normally have the same font configuration, so that all texts |
| * belonging to one element will have the same font size. |
| * |
| * @access protected |
| * @return void |
| */ |
| protected function drawAllTexts() |
| { |
| // Iterate over all strings to collect used chars per font |
| $chars = array(); |
| foreach ( $this->strings as $text ) |
| { |
| $completeString = ''; |
| foreach ( $text['text'] as $line ) |
| { |
| $completeString .= implode( ' ', $line ); |
| } |
| |
| // Collect chars for each font |
| if ( !isset( $chars[$text['font']->path] ) ) |
| { |
| $chars[$text['font']->path] = $completeString; |
| } |
| else |
| { |
| $chars[$text['font']->path] .= $completeString; |
| } |
| } |
| |
| foreach ( $this->strings as $text ) |
| { |
| $size = $this->modifyCoordinate( $text['font']->minimalUsedFont ); |
| |
| $completeHeight = count( $text['text'] ) * $size + ( count( $text['text'] ) - 1 ) * $this->options->lineSpacing; |
| |
| // Calculate y offset for vertical alignement |
| switch ( true ) |
| { |
| case ( $text['align'] & ezcGraph::BOTTOM ): |
| $yOffset = $text['height'] - $completeHeight; |
| break; |
| case ( $text['align'] & ezcGraph::MIDDLE ): |
| $yOffset = ( $text['height'] - $completeHeight ) / 2; |
| break; |
| case ( $text['align'] & ezcGraph::TOP ): |
| default: |
| $yOffset = 0; |
| break; |
| } |
| |
| $padding = $text['font']->padding + $text['font']->borderWidth / 2; |
| if ( $this->options->font->minimizeBorder === true ) |
| { |
| // Calculate maximum width of text rows |
| $width = false; |
| foreach ( $text['text'] as $line ) |
| { |
| $string = implode( ' ', $line ); |
| $boundings = $this->getTextBoundings( $size, $text['font'], $string ); |
| if ( ( $width === false) || ( $boundings->width > $width ) ) |
| { |
| $width = $boundings->width; |
| } |
| } |
| |
| switch ( true ) |
| { |
| case ( $text['align'] & ezcGraph::LEFT ): |
| $xOffset = 0; |
| break; |
| case ( $text['align'] & ezcGraph::CENTER ): |
| $xOffset = ( $text['width'] - $width ) / 2; |
| break; |
| case ( $text['align'] & ezcGraph::RIGHT ): |
| $xOffset = $text['width'] - $width; |
| break; |
| } |
| |
| $borderPolygonArray = array( |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x - $padding + $xOffset ), |
| $this->deModifyCoordinate( $text['position']->y - $padding + $yOffset ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x + $padding * 2 + $xOffset + $width ), |
| $this->deModifyCoordinate( $text['position']->y - $padding + $yOffset ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x + $padding * 2 + $xOffset + $width ), |
| $this->deModifyCoordinate( $text['position']->y + $padding * 2 + $yOffset + $completeHeight ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x - $padding + $xOffset ), |
| $this->deModifyCoordinate( $text['position']->y + $padding * 2 + $yOffset + $completeHeight ) |
| ), |
| ); |
| } |
| else |
| { |
| $borderPolygonArray = array( |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x - $padding ), |
| $this->deModifyCoordinate( $text['position']->y - $padding ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x + $padding * 2 + $text['width'] ), |
| $this->deModifyCoordinate( $text['position']->y - $padding ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x + $padding * 2 + $text['width'] ), |
| $this->deModifyCoordinate( $text['position']->y + $padding * 2 + $text['height'] ) |
| ), |
| new ezcGraphCoordinate( |
| $this->deModifyCoordinate( $text['position']->x - $padding ), |
| $this->deModifyCoordinate( $text['position']->y + $padding * 2 + $text['height'] ) |
| ), |
| ); |
| } |
| |
| if ( $text['rotation'] !== null ) |
| { |
| foreach ( $borderPolygonArray as $nr => $point ) |
| { |
| $borderPolygonArray[$nr] = $text['rotation']->transformCoordinate( $point ); |
| } |
| } |
| |
| if ( $text['font']->background !== false ) |
| { |
| $this->drawPolygon( |
| $borderPolygonArray, |
| $text['font']->background, |
| true |
| ); |
| } |
| |
| if ( $text['font']->border !== false ) |
| { |
| $this->drawPolygon( |
| $borderPolygonArray, |
| $text['font']->border, |
| false, |
| $text['font']->borderWidth |
| ); |
| } |
| |
| // Render text with evaluated font size |
| $completeString = ''; |
| foreach ( $text['text'] as $line ) |
| { |
| $string = implode( ' ', $line ); |
| $completeString .= $string; |
| $boundings = $this->getTextBoundings( $size, $text['font'], $string ); |
| $text['position']->y += $size; |
| |
| switch ( true ) |
| { |
| case ( $text['align'] & ezcGraph::LEFT ): |
| $position = new ezcGraphCoordinate( |
| $text['position']->x, |
| $text['position']->y + $yOffset |
| ); |
| break; |
| case ( $text['align'] & ezcGraph::RIGHT ): |
| $position = new ezcGraphCoordinate( |
| $text['position']->x + ( $text['width'] - $boundings->width ), |
| $text['position']->y + $yOffset |
| ); |
| break; |
| case ( $text['align'] & ezcGraph::CENTER ): |
| $position = new ezcGraphCoordinate( |
| $text['position']->x + ( ( $text['width'] - $boundings->width ) / 2 ), |
| $text['position']->y + $yOffset |
| ); |
| break; |
| } |
| |
| // Optionally draw text shadow |
| if ( $text['font']->textShadow === true ) |
| { |
| $this->renderText( |
| $text['id'], |
| $string, |
| $chars[$text['font']->path], |
| $text['font']->type, |
| $text['font']->path, |
| $text['font']->textShadowColor, |
| new ezcGraphCoordinate( |
| $position->x + $this->modifyCoordinate( $text['font']->textShadowOffset ), |
| $position->y + $this->modifyCoordinate( $text['font']->textShadowOffset ) |
| ), |
| $size, |
| $text['rotation'] |
| ); |
| } |
| |
| // Finally draw text |
| $this->renderText( |
| $text['id'], |
| $string, |
| $chars[$text['font']->path], |
| $text['font']->type, |
| $text['font']->path, |
| $text['font']->color, |
| $position, |
| $size, |
| $text['rotation'] |
| ); |
| |
| $text['position']->y += $size * $this->options->lineSpacing; |
| } |
| } |
| } |
| |
| /** |
| * Draws a sector of cirlce |
| * |
| * @param ezcGraphCoordinate $center Center of circle |
| * @param mixed $width Width |
| * @param mixed $height Height |
| * @param mixed $startAngle Start angle of circle sector |
| * @param mixed $endAngle End angle of circle sector |
| * @param ezcGraphColor $color Color |
| * @param mixed $filled Filled |
| * @return void |
| */ |
| public function drawCircleSector( ezcGraphCoordinate $center, $width, $height, $startAngle, $endAngle, ezcGraphColor $color, $filled = true ) |
| { |
| if ( $startAngle > $endAngle ) |
| { |
| $tmp = $startAngle; |
| $startAngle = $endAngle; |
| $endAngle = $tmp; |
| } |
| |
| $movie = $this->getDocument(); |
| |
| $shape = new SWFShape(); |
| $this->setShapeColor( $shape, $color, 1, $filled ); |
| |
| if ( !$filled ) |
| { |
| try |
| { |
| $reduced = $this->reduceEllipseSize( $center, $width, $height, $startAngle, $endAngle, .5 ); |
| } |
| catch ( ezcGraphReducementFailedException $e ) |
| { |
| return false; |
| } |
| |
| $startAngle = $reduced['startAngle']; |
| $endAngle = $reduced['endAngle']; |
| |
| $width -= 1; |
| $height -= 1; |
| } |
| |
| $shape->movePenTo( $this->modifyCoordinate( $center->x ), $this->modifyCoordinate( $center->y ) ); |
| |
| // @TODO: User SWFShape::curveTo |
| for( |
| $angle = $startAngle; |
| $angle <= $endAngle; |
| $angle = min( $angle + $this->options->circleResolution, $endAngle ) ) |
| { |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x + cos( deg2rad( $angle ) ) * $width / 2 ), |
| $this->modifyCoordinate( $center->y + sin( deg2rad( $angle ) ) * $height / 2 ) |
| ); |
| |
| if ( $angle === $endAngle ) |
| { |
| break; |
| } |
| } |
| |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x ), |
| $this->modifyCoordinate( $center->y ) |
| ); |
| |
| $object = $movie->add( $shape ); |
| $object->setName( $id = 'ezcGraphCircleSector_' . $this->id++ ); |
| |
| return $id; |
| } |
| |
| /** |
| * Draws a circular arc consisting of several minor steps on the bounding |
| * lines. |
| * |
| * @param ezcGraphCoordinate $center |
| * @param mixed $width |
| * @param mixed $height |
| * @param mixed $size |
| * @param mixed $startAngle |
| * @param mixed $endAngle |
| * @param ezcGraphColor $color |
| * @param bool $filled |
| * @return string Element id |
| */ |
| protected function simulateCircularArc( ezcGraphCoordinate $center, $width, $height, $size, $startAngle, $endAngle, ezcGraphColor $color, $filled ) |
| { |
| $movie = $this->getDocument(); |
| $id = 'ezcGraphCircularArc_' . $this->id++; |
| |
| for ( |
| $tmpAngle = min( ceil ( $startAngle / 180 ) * 180, $endAngle ); |
| $tmpAngle <= $endAngle; |
| $tmpAngle = min( ceil ( $startAngle / 180 + 1 ) * 180, $endAngle ) ) |
| { |
| $shape = new SWFShape(); |
| $this->setShapeColor( $shape, $color, 1, $filled ); |
| |
| $shape->movePenTo( |
| $this->modifyCoordinate( $center->x + cos( deg2rad( $startAngle ) ) * $width / 2 ), |
| $this->modifyCoordinate( $center->y + sin( deg2rad( $startAngle ) ) * $height / 2 ) |
| ); |
| |
| // @TODO: Use SWFShape::curveTo |
| for( |
| $angle = $startAngle; |
| $angle <= $tmpAngle; |
| $angle = min( $angle + $this->options->circleResolution, $tmpAngle ) ) |
| { |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x + cos( deg2rad( $angle ) ) * $width / 2 ), |
| $this->modifyCoordinate( $center->y + sin( deg2rad( $angle ) ) * $height / 2 + $size ) |
| ); |
| |
| if ( $angle === $tmpAngle ) |
| { |
| break; |
| } |
| } |
| |
| for( |
| $angle = $tmpAngle; |
| $angle >= $startAngle; |
| $angle = max( $angle - $this->options->circleResolution, $startAngle ) ) |
| { |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x + cos( deg2rad( $angle ) ) * $width / 2 ), |
| $this->modifyCoordinate( $center->y + sin( deg2rad( $angle ) ) * $height / 2 ) |
| ); |
| |
| if ( $angle === $startAngle ) |
| { |
| break; |
| } |
| } |
| |
| $object = $movie->add( $shape ); |
| $object->setName( $id ); |
| |
| $startAngle = $tmpAngle; |
| if ( $tmpAngle === $endAngle ) |
| { |
| break; |
| } |
| } |
| |
| return $id; |
| } |
| |
| /** |
| * Draws a circular arc |
| * |
| * @param ezcGraphCoordinate $center Center of ellipse |
| * @param integer $width Width of ellipse |
| * @param integer $height Height of ellipse |
| * @param integer $size Height of border |
| * @param float $startAngle Starting angle of circle sector |
| * @param float $endAngle Ending angle of circle sector |
| * @param ezcGraphColor $color Color of Border |
| * @param bool $filled |
| * @return void |
| */ |
| public function drawCircularArc( ezcGraphCoordinate $center, $width, $height, $size, $startAngle, $endAngle, ezcGraphColor $color, $filled = true ) |
| { |
| if ( $startAngle > $endAngle ) |
| { |
| $tmp = $startAngle; |
| $startAngle = $endAngle; |
| $endAngle = $tmp; |
| } |
| |
| $id = $this->simulateCircularArc( $center, $width, $height, $size, $startAngle, $endAngle, $color, $filled ); |
| |
| if ( ( $this->options->shadeCircularArc !== false ) && |
| $filled ) |
| { |
| $gradient = new ezcGraphLinearGradient( |
| new ezcGraphCoordinate( |
| $center->x - $width, |
| $center->y |
| ), |
| new ezcGraphCoordinate( |
| $center->x + $width, |
| $center->y |
| ), |
| ezcGraphColor::fromHex( '#FFFFFF' )->transparent( $this->options->shadeCircularArc * 1.5 ), |
| ezcGraphColor::fromHex( '#000000' )->transparent( $this->options->shadeCircularArc * 1.5 ) |
| ); |
| |
| $this->simulateCircularArc( $center, $width, $height, $size, $startAngle, $endAngle, $gradient, $filled ); |
| } |
| |
| return $id; |
| } |
| |
| /** |
| * Draw circle |
| * |
| * @param ezcGraphCoordinate $center Center of ellipse |
| * @param mixed $width Width of ellipse |
| * @param mixed $height height of ellipse |
| * @param ezcGraphColor $color Color |
| * @param mixed $filled Filled |
| * @return void |
| */ |
| public function drawCircle( ezcGraphCoordinate $center, $width, $height, ezcGraphColor $color, $filled = true ) |
| { |
| $movie = $this->getDocument(); |
| |
| $shape = new SWFShape(); |
| $this->setShapeColor( $shape, $color, 1, $filled ); |
| |
| // Reduce size |
| if ( !$filled ) |
| { |
| $width -= 1; |
| $height -= 1; |
| } |
| |
| $shape->movePenTo( |
| $this->modifyCoordinate( $center->x + $width / 2 ), |
| $this->modifyCoordinate( $center->y ) |
| ); |
| |
| // @TODO: User SWFShape::curveTo |
| for ( $angle = $this->options->circleResolution; $angle < 360; $angle += $this->options->circleResolution ) |
| { |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x + cos( deg2rad( $angle ) ) * $width / 2 ), |
| $this->modifyCoordinate( $center->y + sin( deg2rad( $angle ) ) * $height / 2 ) |
| ); |
| } |
| |
| $shape->drawLineTo( |
| $this->modifyCoordinate( $center->x + $width / 2 ), |
| $this->modifyCoordinate( $center->y ) |
| ); |
| |
| $object = $movie->add( $shape ); |
| $object->setName( $id = 'ezcGraphCircle_' . $this->id++ ); |
| |
| return $id; |
| } |
| |
| /** |
| * Draw an image |
| * |
| * The image will be inlined in the SVG document using data URL scheme. For |
| * this the mime type and base64 encoded file content will be merged to |
| * URL. |
| * |
| * @param mixed $file Image file |
| * @param ezcGraphCoordinate $position Top left position |
| * @param float $width Width of image in destination image |
| * @param float $height Height of image in destination image |
| * @return void |
| */ |
| public function drawImage( $file, ezcGraphCoordinate $position, $width, $height ) |
| { |
| $movie = $this->getDocument(); |
| |
| $imageData = getimagesize( $file ); |
| if ( ( $imageData[2] !== IMAGETYPE_JPEG ) && ( $imageData[2] !== IMAGETYPE_PNG ) ) |
| { |
| throw new ezcGraphFlashBitmapTypeException( $imageData[2] ); |
| } |
| |
| // Try to create a new SWFBitmap object from provided file |
| $bitmap = new SWFBitmap( fopen( $file, 'rb' ) ); |
| |
| // Add the image to the movie |
| $object = $this->movie->add( $bitmap ); |
| |
| // Image size is calculated on the base of a tick size of 20, so |
| // that we need to transform this, to our tick size. |
| $factor = $this->modifyCoordinate( 1 ) / 20; |
| $object->scale( $factor, $factor ); |
| |
| // Scale by ratio of requested and original image size |
| $object->scale( |
| $width / $imageData[0], |
| $height / $imageData[1] |
| ); |
| |
| // Move object to the right position |
| $object->moveTo( |
| $this->modifyCoordinate( $position->x ), |
| $this->modifyCoordinate( $position->y ) |
| ); |
| |
| // Create, set and return unique ID |
| $object->setName( $id = 'ezcGraphImage_'. $this->id++ ); |
| return $id; |
| } |
| |
| /** |
| * Return mime type for current image format |
| * |
| * @return string |
| */ |
| public function getMimeType() |
| { |
| return 'application/x-shockwave-flash'; |
| } |
| |
| /** |
| * Finally save image |
| * |
| * @param string $file Destination filename |
| * @return void |
| */ |
| public function render( $file ) |
| { |
| $this->drawAllTexts(); |
| $movie = $this->getDocument(); |
| $movie->save( $file, $this->options->compression ); |
| } |
| |
| /** |
| * Get resource of rendered result |
| * |
| * Return the resource of the rendered result. You should not use this |
| * method before you called either renderToOutput() or render(), as the |
| * image may not be completely rendered until then. |
| * |
| * @return SWFMovie |
| */ |
| public function getResource() |
| { |
| return $this->movie; |
| } |
| } |
| |
| ?> |
