Source for file SvgDocumentRenderer.php

Documentation is available at SvgDocumentRenderer.php

  1. <?php
  2. /**
  3.  * $Source: /cvsroot/svggrapher/svggrapher/mains/SvgDocumentRenderer.php,v $
  4.  *
  5.  * SvgGrapher graph pane
  6.  *
  7.  * @version CVS: $Id: SvgDocumentRenderer.php,v 1.10 2007/10/23 09:22:53 geelweb Exp $
  8.  * @filesource
  9.  * @author Guillaume Luchet. <guillaume@geelweb.org>
  10.  * @copyright Copyright (c) 2007, Guillaume Luchet.
  11.  * @license http://opensource.org/licenses/bsd-license.php BSD License
  12.  * @package SvgGrapher
  13.  */
  14.  
  15. /**#@+
  16.  * include svg elements 
  17.  */
  18. require_once SVGGRAPHER_ELEMENTS_PATH . '/GElement.php';
  19. require_once SVGGRAPHER_ELEMENTS_PATH . '/TextElement.php';
  20. require_once SVGGRAPHER_ELEMENTS_PATH . '/LineElement.php';
  21. require_once SVGGRAPHER_ELEMENTS_PATH . '/RectElement.php';
  22. require_once SVGGRAPHER_ELEMENTS_PATH . '/AElement.php';
  23. require_once SVGGRAPHER_ELEMENTS_PATH . '/ImageElement.php';
  24. /**#@-*/
  25.  
  26. /**
  27.  * SvgDocumentRenderer
  28.  * 
  29.  * @version $Id: SvgDocumentRenderer.php,v 1.10 2007/10/23 09:22:53 geelweb Exp $
  30.  * @copyright Copyright (c) 2007, Guillaume Luchet
  31.  * @author guillaume luchet <guillaume@geelweb.org>
  32.  * @license http://opensource.org/licenses/bsd-license.php BSD License
  33.  * @package SvgGrapher
  34.  */
  35. class SvgDocumentRenderer 
  36. {
  37.     // SvgDocumentRenderer::render() {{{
  38.  
  39.     /**
  40.      * render
  41.      *
  42.      * Render the svg document.
  43.      * 
  44.      * @param mixed $forceBackground if true, the elements will be added on the
  45.      *  back of the existing elements.
  46.      * @static
  47.      * @access public
  48.      * @return void 
  49.      */
  50.     public static function render($forceBackground=true) 
  51.     {
  52.         $svgGrapher = SvgGrapher::singleton();
  53.         /*$forceBackground = $forceBackground && $svgGrapher->svgGraphPane->haveChild();
  54.         if($forceBackground) {
  55.             $tmp = $svgGrapher->svgGraphPane->removeChildren();
  56.         }*/
  57.         SvgDocumentRenderer::renderTitle();
  58.         SvgDocumentRenderer::renderLabelX();
  59.         SvgDocumentRenderer::renderLabelY();
  60.         SvgDocumentRenderer::renderGridX();
  61.         SvgDocumentRenderer::renderGridY();
  62.         SvgDocumentRenderer::renderStepX();
  63.         SvgDocumentRenderer::renderStepY();
  64.         SvgDocumentRenderer::renderTagsX();
  65.         SvgDocumentRenderer::renderTagsY();
  66.         SvgDocumentRenderer::renderLegend();
  67.         SvgDocumentRenderer::renderGraphPane();
  68.         /*if($forceBackground) {
  69.             $svgGrapher->svgGraphPane->appendChildren($tmp);
  70.         }*/
  71.         SvgDocumentRenderer::renderCurves();
  72.         SvgDocumentRenderer::renderLimits();
  73.         SvgDocumentRenderer::renderW3cValidatorLink();
  74.     }
  75.  
  76.     // }}}
  77.     // SvgDocumentRenderer::renderTitle() {{{
  78.  
  79.     /**
  80.      * renderTitle
  81.      *
  82.      * Render the graph title.
  83.      *
  84.      * @static
  85.      * @access public
  86.      * @return void 
  87.      */
  88.     public static function renderTitle() 
  89.     {
  90.         $svgGrapher = SvgGrapher::singleton();
  91.         $display = $svgGrapher->display;
  92.         if(empty($display['title']) || !$display['title']) {
  93.             return false;
  94.         }
  95.         $text = new TextElement($svgGrapher->title, array(
  96.             'x' => $svgGrapher->boxTitle->padding['left'], 
  97.             'y' => $svgGrapher->boxTitle->padding['top'],
  98.             'style' => TITLE_STYLE));
  99.         if($svgGrapher->boxTitle->x > 0 || $svgGrapher->boxTitle->y > 0) {
  100.             $translate = sprintf('translate(%s,%s)', $svgGrapher->boxTitle->x, $svgGrapher->boxTitle->y);
  101.             $text->setAttribute('transform',$translate);
  102.         }
  103.         $svgGrapher->svgTitles->appendChild($text);
  104.     }
  105.  
  106.     // }}}
  107.     // SvgDocumentRenderer::renderGridX() {{{
  108.  
  109.     /**
  110.      * renderGridX
  111.      *
  112.      * Render the abscisses lines of the grid
  113.      * 
  114.      * @static
  115.      * @access public
  116.      * @return void 
  117.      */
  118.     public static function renderGridX() 
  119.     {
  120.         $svgGrapher = SvgGrapher::singleton();
  121.         $display = $svgGrapher->display;
  122.         if(empty($display['gridX']) || !$display['gridX']) {
  123.             return false;
  124.         }
  125.         $x = 0;
  126.         $group = new GElement();
  127.         $group->setAttribute('style', GRID_LINES_X_STYLE);
  128.  
  129.         $top = 0;
  130.         $bottom = $svgGrapher->boxGraphPane->height - 1;
  131.  
  132.         foreach ($svgGrapher->tagsX as $i => $u) {
  133.             $x = $svgGrapher->gridLineXDelta * ($i +  $svgGrapher->plotOffsetX);
  134.             $group->appendChild(new LineElement(array(
  135.                 'x1' => $x, 'y1' => $top, 'x2' => $x, 'y2' => $bottom)));
  136.         }
  137.  
  138.         $svgGrapher->svgGraphPane->appendChild($group);
  139.     }
  140.  
  141.     // }}}
  142.     // SvgDocumentRenderer::renderGridY() {{{
  143.  
  144.     /**
  145.      * renderGridY
  146.      *
  147.      * Render the ordinates lines of the grid
  148.      * 
  149.      * @static
  150.      * @access public
  151.      * @return void 
  152.      */
  153.     public static function renderGridY() 
  154.     {
  155.         $svgGrapher = SvgGrapher::singleton();
  156.         $display = $svgGrapher->display;
  157.         if(empty($display['gridX']) || !$display['gridX']) {
  158.             return false;
  159.         }
  160.         
  161.         $group = new GElement();
  162.         $group->setAttribute('style', GRID_LINES_Y_STYLE);
  163.  
  164.         $left = 0;
  165.         $right = $svgGrapher->boxGraphPane->width - 1;
  166.  
  167.         for($i = 0; $i < $svgGrapher->gridLineY; $i++) {
  168.             $v = $svgGrapher->gridLineYDelta * ($i + $svgGrapher->plotOffsetY);
  169.             $group->appendChild(new LineElement(array(
  170.                 'x1' => $left, 'y1' => $v, 'x2' => $right, 'y2' => $v)));
  171.         }
  172.         // display 0 if in range
  173.         $range = $svgGrapher->range;
  174.         if(($range['min'] < 0 && $range['max'] > 0) || ($range['min'] > 0 && $range['max'] < 0)) {
  175.             $v = $svgGrapher->boxGraphPane->height - ($svgGrapher->factorY * (0 - $range['min']));
  176.             $group->appendChild(new LineElement(array(
  177.                 'x1' => $left, 'y1' => $v, 'x2' => $right, 'y2' => $v)));
  178.         }
  179.         $svgGrapher->svgGraphPane->appendChild($group);
  180.     }
  181.  
  182.     // }}}
  183.     // SvgDocumentRenderer::renderStepX() {{{
  184.  
  185.     /**
  186.      * renderStepX
  187.      * 
  188.      * @static
  189.      * @access public
  190.      * @return void 
  191.      */
  192.     public static function renderStepX() 
  193.     {
  194.         $svgGrapher = SvgGrapher::singleton();
  195.         $display = $svgGrapher->display;
  196.         if(empty($display['stepX']) || !$display['stepX']) {
  197.             return false;
  198.         }
  199.         $x = 0;
  200.         $group = new GElement();
  201.         $group->setAttribute('style', STEP_X_STYLE);
  202.  
  203.         $top = $svgGrapher->boxGraphPane->height - 3;
  204.         $bottom = $svgGrapher->boxGraphPane->height + 3;
  205.  
  206.         foreach ($svgGrapher->tagsX as $i => $u) {
  207.             $x = $svgGrapher->gridLineXDelta * ($i +  $svgGrapher->plotOffsetX);
  208.             $group->appendChild(new LineElement(array(
  209.                 'x1' => $x, 'y1' => $top, 'x2' => $x, 'y2' => $bottom)));
  210.         }
  211.         $svgGrapher->svgGraphPane->appendChild($group);
  212.     }
  213.  
  214.     // }}}
  215.     // SvgDocumentRenderer::renderStepY() {{{
  216.  
  217.     /**
  218.      * renderStepY
  219.      * 
  220.      * @static
  221.      * @access public
  222.      * @return void 
  223.      */
  224.     public static function renderStepY() 
  225.     {
  226.         $svgGrapher = SvgGrapher::singleton();
  227.         $display = $svgGrapher->display;
  228.         if(empty($display['stepY']) || !$display['stepY']) {
  229.             return false;
  230.         }
  231.         $group = new GElement();
  232.         $group->setAttribute('style', STEP_Y_STYLE);
  233.  
  234.         $minorStep = NULL;
  235.         $left = -3;
  236.         $right = 3;
  237.  
  238.         for($i = 0; $i < $svgGrapher->gridLineY; $i++) {
  239.             $v = $svgGrapher->gridLineYDelta * ($i + $svgGrapher->plotOffsetY);
  240.             $group->appendChild(new LineElement(
  241.                 array('x1' => $left, 'y1' => $v, 'x2' => $right, 'y2' => $v)));
  242.  
  243.             if(isset($display['minorStepY']) && $display['minorStepY']) {
  244.                 if($i < $svgGrapher->gridLineY - 1 ) {
  245.                     for($mstep = 0; $mstep < $svgGrapher->minorStepY; $mstep++) {
  246.                         $m = $v + $mstep * $svgGrapher->minorStepYDelta;
  247.                         $minorStep = new LineElement(array(
  248.                             'x1' => $left, 'y1' => $m, 'x2' => 0, 'y2' => $m));
  249.                         $minorStep->setAttribute('style', MINOR_STEP_Y_STYLE);
  250.                         $group->appendChild($minorStep);
  251.                     }
  252.                 }
  253.             }
  254.         }
  255.  
  256.         $svgGrapher->svgGraphPane->appendChild($group);
  257.     }
  258.  
  259.     // }}}
  260.     // SvgDocumentRenderer::renderTagsX() {{{
  261.  
  262.     /**
  263.      * renderTagsX
  264.      *
  265.      * Render the abscisses tags
  266.      * 
  267.      * @static
  268.      * @access public
  269.      * @return void 
  270.      */
  271.     public static function renderTagsX() 
  272.     {
  273.         $svgGrapher = SvgGrapher::singleton();
  274.         $display = $svgGrapher->display;
  275.         if(empty($display['tagsX']) || !$display['tagsX']) {
  276.             return false;
  277.         }
  278.         $freqCnt = 0;
  279.         $group = new GElement(array('id'=>'tagsX', 'style'=>TAGS_X_STYLE));
  280.  
  281.         $y = $svgGrapher->boxTagsX->y;
  282.  
  283.         foreach ($svgGrapher->tagsX as $i => $text) {
  284.             if(isset($svgGrapher->rendererCallBacks['tagsX'])) {
  285.                 $text = call_user_func($svgGrapher->rendererCallBacks['tagsX'], $text);
  286.             }
  287.             $x = $svgGrapher->gridLineXDelta * ($i + $svgGrapher->plotOffsetX) + $svgGrapher->boxGraphPane->x;
  288.  
  289.             if($i > 0) {
  290.                 $freqCnt++;
  291.                 if($freqCnt == $svgGrapher->tagXGapFrequency) {
  292.                     $freqCnt = 0;
  293.                 } else { 
  294.                     continue; 
  295.                 }
  296.             }
  297.  
  298.             if ($svgGrapher->tagXRotation == 0) {
  299.                 $text = new TextElement($text, 
  300.                     array('x' => $x, 'y' => $y, 'dy' => '1em', 
  301.                     'style' => 'text-anchor: middle;'));
  302.                 $group->appendChild($text);
  303.             } else if($svgGrapher->tagXRotation > 0) {
  304.                 $text = new TextElement($text, array(
  305.                     'x' => $x, 'y' => $y, 'dy' => '1em', 
  306.                     'style' => 'text-anchor: start;'));
  307.                 $text->setAttribute('transform',"rotate({$svgGrapher->tagXRotation} $x $y)");
  308.                 $group->appendChild($text);
  309.             } else {
  310.                 $text = new TextElement($text, array(
  311.                     'x'=>$x, 'y'=>$y, 'dy'=>'1em', 
  312.                     'style'=>'text-anchor: end;'));
  313.                 $text->setAttribute('transform',"rotate({$svgGrapher->tagXRotation} $x $y)");
  314.                 $group->appendChild($text);
  315.             }
  316.         }
  317.  
  318.         $svgGrapher->svgTitles->appendChild($group);
  319.     }
  320.  
  321.     // }}}
  322.     // SvgDocumentRenderer::renderTagsY() {{{
  323.  
  324.     /**
  325.      * renderTagsY
  326.      *
  327.      * Render the ordinates tags
  328.      * 
  329.      * @static
  330.      * @access public
  331.      * @return void 
  332.      */
  333.     public static function renderTagsY() 
  334.     {
  335.         $svgGrapher = SvgGrapher::singleton();
  336.         $display = $svgGrapher->display;
  337.         if(empty($display['tagsY']) || !$display['tagsY']) {
  338.             return false;
  339.         }
  340.         $group = new GElement(array('id'=>'tagsY', 'style'=>TAGS_Y_STYLE));
  341.  
  342.         foreach ($svgGrapher->tagsY as $i => $text) {
  343.             if(isset($svgGrapher->rendererCallBacks['tagsY'])) {
  344.                 $text = call_user_func($svgGrapher->rendererCallBacks['tagsY'], $text);
  345.             }
  346.             $y = $svgGrapher->gridLineYDelta * ($i + $svgGrapher->plotOffsetY) + $svgGrapher->boxGraphPane->y;
  347.  
  348.             $text = new TextElement($text, array(
  349.                 'x'=>$svgGrapher->boxTagsY->x, 'y'=>$y));
  350.             $group->appendChild($text);
  351.         }
  352.         // display 0 if in range
  353.         $range = $svgGrapher->range;
  354.         if(($range['min'] < 0 && $range['max'] > 0) || ($range['min'] > 0 && $range['max'] < 0)) {
  355.             $text = 0;
  356.             $i=0;
  357.             if(isset($svgGrapher->rendererCallBacks['tagsY'])) {
  358.                 $text = call_user_func($svgGrapher->rendererCallBacks['tagsY'], $text);
  359.             }
  360.             $y = $svgGrapher->boxGraphPane->height - ($svgGrapher->factorY * (0 - $range['min'])) + $svgGrapher->boxGraphPane->y;
  361.             $text = new TextElement($text, array(
  362.                 'x'=>$svgGrapher->boxTagsY->x, 'y'=>$y));
  363.             $group->appendChild($text);
  364.         }
  365.  
  366.         $svgGrapher->svgTitles->appendChild($group);
  367.     }
  368.  
  369.     // }}}
  370.     // SvgDocumentRenderer::renderLabelX() {{{
  371.     
  372.     /**
  373.      * renderLabelX
  374.      * 
  375.      * Render the abscisses label
  376.      * 
  377.      * @static
  378.      * @access public
  379.      * @return void 
  380.      */
  381.     public static function renderLabelX() 
  382.     {
  383.         $svgGrapher = SvgGrapher::singleton();
  384.         $display = $svgGrapher->display;
  385.         if(empty($display['labelX']) || !$display['labelX']) {
  386.             return false;
  387.         }
  388.         $text = new TextElement($svgGrapher->labelX, array(
  389.             'x' => $svgGrapher->boxLabelX->x, 
  390.             'y' => $svgGrapher->boxLabelX->y,
  391.             'style' => LABEL_X_STYLE));
  392.         $svgGrapher->svgTitles->appendChild($text);
  393.     }
  394.     
  395.     // }}}
  396.     // SvgDocumentRenderer::renderLabelY() {{{
  397.     
  398.     /**
  399.      * renderLabelY
  400.      *
  401.      * Render the ordinates label
  402.      * 
  403.      * @static
  404.      * @access public
  405.      * @return void 
  406.      */
  407.     public static function renderLabelY() 
  408.     {
  409.         $svgGrapher = SvgGrapher::singleton();
  410.         $display = $svgGrapher->display;
  411.         if(empty($display['labelY']) || !$display['labelY']) {
  412.             return false;
  413.         }
  414.         $text = new TextElement($svgGrapher->labelY, array(
  415.             'x' => $svgGrapher->boxLabelY->x, 
  416.             'y' => $svgGrapher->boxLabelY->y,
  417.             'style'=>LABEL_Y_STYLE));
  418.         $text->setAttribute('transform',sprintf('rotate(%s %s %s)', 
  419.             $svgGrapher->labelYRotation, $svgGrapher->boxLabelY->x, $svgGrapher->boxLabelY->y));
  420.         $svgGrapher->svgTitles->appendChild($text);
  421.     }
  422.     
  423.     // }}}
  424.     // SvgDocumentRenderer::renderLimits() {{{
  425.  
  426.     /**
  427.      * renderLimits
  428.      *
  429.      * Render the limits lines (limits are only horizontals lines).
  430.      * 
  431.      * @static
  432.      * @access public
  433.      * @return void 
  434.      */
  435.     public static function renderLimits() 
  436.     {
  437.         $svgGrapher = SvgGrapher::singleton();
  438.         $display = $svgGrapher->display;
  439.         if(empty($display['limits']) || !$display['limits']) {
  440.             return false;
  441.         }
  442.         $left = 1;
  443.         $right = $svgGrapher->boxGraphPane->width - 2;
  444.  
  445.         foreach($svgGrapher->limitsLines as $name=>$params) {
  446.             if($params['value'] !== false) {
  447.                 $svgGrapher->drawHLine($params['value'], $params['color'], $name . 'limit');
  448.             }
  449.         }
  450.     }
  451.  
  452.     // }}}
  453.     // SvgDocumentRenderer::renderLegend() {{{
  454.  
  455.     /**
  456.      * renderLegend
  457.      *
  458.      * Render the legend
  459.      * 
  460.      * @static
  461.      * @access public
  462.      * @return void 
  463.      */
  464.     public static function renderLegend() 
  465.     {
  466.         $svgGrapher = SvgGrapher::singleton();
  467.         $display = $svgGrapher->display;
  468.         if(empty($display['legend']) || !$display['legend']) {
  469.             return false;
  470.         }
  471.         $width = $svgGrapher->boxLegend->width - 1;
  472.         $height = $svgGrapher->boxGraphPane->height - 1;
  473.         $separator = $svgGrapher->legendTextHeight >> 2;
  474.         $lineX = 2;
  475.         $lineY = 4;
  476.         $lineRectHeight = $svgGrapher->legendTextHeight;
  477.         $lineRectWidth = 10;
  478.         $lineTextX = $lineX + $lineRectWidth + 2;
  479.         $lineTextY = $lineY + $lineRectHeight;
  480.  
  481.         $rect = new RectElement(array('x'=>0, 'y'=>0, 'width'=>$width, 
  482.             'height'=>$height));
  483.         $rect->setAttribute('style', LEGEND_BOX_STYLE);
  484.         $svgGrapher->svgLegend->appendChild($rect);
  485.  
  486.         $legends = array();
  487.         foreach($svgGrapher->curves as $curve) {
  488.             if(!is_array($curve->legend)) {
  489.                 $legends[$curve->legend] = $curve->color;
  490.                 continue;
  491.             }
  492.             foreach($curve->legend as $key=>$text) {
  493.                 $legends[$text] = $curve->color[$key];
  494.             }
  495.         }
  496.         foreach($legends as $text=>$color) {
  497.             $legendRectStyle = sprintf(
  498.                 'stroke-width:1; stroke: #000000; fill: %s; shape-rendering:crispEdges;',
  499.                 $color);
  500.             $legendRect = new RectElement(array('x'=>$lineX, 'y'=>$lineY, 
  501.                 'width'=>$lineRectWidth, 'height'=>$lineRectHeight, 
  502.                 'style'=>$legendRectStyle));
  503.             $svgGrapher->svgLegend->appendChild($legendRect);
  504.             $legendText = new TextElement($text, array(
  505.                 'x'=>$lineTextX, 'y'=>$lineTextY, 'style'=>LEGEND_TEXT_STYLE));
  506.             $svgGrapher->svgLegend->appendChild($legendText);
  507.             
  508.             $lineY += $svgGrapher->legendTextHeight + $separator;
  509.             $lineTextY = $lineY + $lineRectHeight;
  510.         }
  511.  
  512.         $translate = sprintf('translate(%s,%s)', $svgGrapher->boxLegend->x, $svgGrapher->boxLegend->y);
  513.         $svgGrapher->svgLegend->setAttribute('transform',$translate);
  514.     }
  515.  
  516.     // }}}
  517.     // SvgDocumentRenderer::renderGraphPane() {{{
  518.  
  519.     /**
  520.      * renderGraphPane
  521.      *
  522.      * Render the graph pane
  523.      * 
  524.      * @static
  525.      * @access public
  526.      * @return void 
  527.      */
  528.     public static function renderGraphPane() 
  529.     {
  530.         $svgGrapher = SvgGrapher::singleton();
  531.         SvgDocumentRenderer::renderGraphPaneBox();
  532.         $svgGrapher->svgGraphPane->setAttribute('transform',sprintf(
  533.             'translate(%s,%s)', $svgGrapher->boxGraphPane->x, 
  534.             $svgGrapher->boxGraphPane->y));
  535.     }
  536.  
  537.     // }}}
  538.     // SvgDocumentRenderer::renderGraphPaneBox() {{{
  539.     
  540.     /**
  541.      * renderGraphPaneBox
  542.      *
  543.      * Render the graph pane box
  544.      * 
  545.      * @access public
  546.      * @return void 
  547.      */
  548.     public static function renderGraphPaneBox() 
  549.     {
  550.         $svgGrapher = SvgGrapher::singleton();
  551.         $display = $svgGrapher->display;
  552.         if(empty($display['box']) || !$display['box']) {
  553.             return false;
  554.         }
  555.         $width = $svgGrapher->boxGraphPane->width - 1;
  556.         $height = $svgGrapher->boxGraphPane->height - 1;
  557.  
  558.         $rect = new RectElement(array('x'=>0, 'y'=>0, 'width'=>$width, 
  559.             'height'=>$height, 'style'=>BOX_STYLE));
  560.         $svgGrapher->svgGraphPane->appendChild($rect);
  561.     }
  562.     
  563.     // }}}
  564.     // SvgDocumentRenderer::renderCurves() {{{
  565.     
  566.     /**
  567.      * renderCurves
  568.      *
  569.      * Render the curves
  570.      * 
  571.      * @static
  572.      * @access public
  573.      * @return void 
  574.      */
  575.     public static function renderCurves() 
  576.     {
  577.         $svgGrapher = SvgGrapher::singleton();
  578.         foreach($svgGrapher->curves as $id=>$curve) {
  579.             $curve->render();
  580.         }
  581.     } 
  582.     
  583.     // }}}
  584.     // SvgDocumentRenderer::renderW3cValidatorLink() {{{
  585.     
  586.     /**
  587.      * renderW3cValidatorLink
  588.      * 
  589.      * @static
  590.      * @access public
  591.      * @return bool 
  592.      */
  593.     public static function renderW3cValidatorLink() 
  594.     {
  595.         $svgGrapher = SvgGrapher::singleton();
  596.         if(!$svgGrapher->display['w3link']) {
  597.             return false;
  598.         }
  599.         $g = new GElement(array('id'=>'w3validatorlink'));
  600.         $a = new AElement(NULL,
  601.             array('xlink:href'=> 'http://validator.w3.org/check?uri=referer')
  602.         );
  603.         $img = new ImageElement(array(
  604.             'xlink:href'=>'http://www.w3.org/Icons/valid-svg11.png', 
  605.             'x' => $svgGrapher->boxLegend->x, 
  606.             'y' => ($svgGrapher->boxLegend->y + $svgGrapher->boxLegend->height), 
  607.             'width' => 88, 
  608.             'height' => 31));
  609.         $g->appendChild($a);
  610.         $a->appendChild($img);
  611.         $svgGrapher->svgDocument->appendChild($g);
  612.         return true;
  613.     }
  614.     
  615.     // }}}
  616. }
  617.  
  618. ?>

Documentation generated on Tue, 23 Oct 2007 11:32:08 +0200 by phpDocumentor 1.4.0