pDraw.class.php

File

inc/pchart/pchart/class/pDraw.class.php
View source
  1.  /*

  2.      pDraw - class extension with drawing methods

  3. 

  4.      Version     : 2.1.4

  5.      Made by     : Jean-Damien POGOLOTTI

  6.      Last Update : 19/01/2014

  7. 

  8.      This file can be distributed under the license you can find at :

  9. 

  10.                        http://www.pchart.net/license

  11. 

  12.      You can find the whole class documentation on the pChart web site.

  13.  */

  14. 

  15.  define("DIRECTION_VERTICAL"		, 690001);

  16.  define("DIRECTION_HORIZONTAL"		, 690002);

  17. 

  18.  define("SCALE_POS_LEFTRIGHT"		, 690101);

  19.  define("SCALE_POS_TOPBOTTOM"		, 690102);

  20. 

  21.  define("SCALE_MODE_FLOATING"		, 690201);

  22.  define("SCALE_MODE_START0"		, 690202);

  23.  define("SCALE_MODE_ADDALL"		, 690203);

  24.  define("SCALE_MODE_ADDALL_START0"	, 690204);

  25.  define("SCALE_MODE_MANUAL"		, 690205);

  26. 

  27.  define("SCALE_SKIP_NONE"		, 690301);

  28.  define("SCALE_SKIP_SAME"		, 690302);

  29.  define("SCALE_SKIP_NUMBERS"		, 690303);

  30. 

  31.  define("TEXT_ALIGN_TOPLEFT"		, 690401);

  32.  define("TEXT_ALIGN_TOPMIDDLE"		, 690402);

  33.  define("TEXT_ALIGN_TOPRIGHT"		, 690403);

  34.  define("TEXT_ALIGN_MIDDLELEFT"		, 690404);

  35.  define("TEXT_ALIGN_MIDDLEMIDDLE"	, 690405);

  36.  define("TEXT_ALIGN_MIDDLERIGHT"	, 690406);

  37.  define("TEXT_ALIGN_BOTTOMLEFT"		, 690407);

  38.  define("TEXT_ALIGN_BOTTOMMIDDLE"	, 690408);

  39.  define("TEXT_ALIGN_BOTTOMRIGHT"	, 690409);

  40. 

  41.  define("POSITION_TOP"                  , 690501);

  42.  define("POSITION_BOTTOM"               , 690502);

  43. 

  44.  define("LABEL_POS_LEFT"		, 690601);

  45.  define("LABEL_POS_CENTER"		, 690602);

  46.  define("LABEL_POS_RIGHT"		, 690603);

  47.  define("LABEL_POS_TOP"			, 690604);

  48.  define("LABEL_POS_BOTTOM"		, 690605);

  49.  define("LABEL_POS_INSIDE"		, 690606);

  50.  define("LABEL_POS_OUTSIDE"		, 690607);

  51. 

  52.  define("ORIENTATION_HORIZONTAL"	, 690701);

  53.  define("ORIENTATION_VERTICAL"		, 690702);

  54.  define("ORIENTATION_AUTO"		, 690703);

  55. 

  56.  define("LEGEND_NOBORDER"		, 690800);

  57.  define("LEGEND_BOX"			, 690801);

  58.  define("LEGEND_ROUND"			, 690802);

  59. 

  60.  define("LEGEND_VERTICAL"		, 690901);

  61.  define("LEGEND_HORIZONTAL"		, 690902);

  62. 

  63.  define("LEGEND_FAMILY_BOX"		, 691051);

  64.  define("LEGEND_FAMILY_CIRCLE"		, 691052);

  65.  define("LEGEND_FAMILY_LINE"		, 691053);

  66. 

  67.  define("DISPLAY_AUTO"			, 691001);

  68.  define("DISPLAY_MANUAL"		, 691002);

  69. 

  70.  define("LABELING_ALL"			, 691011);

  71.  define("LABELING_DIFFERENT"		, 691012);

  72. 

  73.  define("BOUND_MIN"			, 691021);

  74.  define("BOUND_MAX"			, 691022);

  75.  define("BOUND_BOTH"			, 691023);

  76. 

  77.  define("BOUND_LABEL_POS_TOP"		, 691031);

  78.  define("BOUND_LABEL_POS_BOTTOM"	, 691032);

  79.  define("BOUND_LABEL_POS_AUTO"		, 691033);

  80. 

  81.  define("CAPTION_LEFT_TOP"		, 691041);

  82.  define("CAPTION_RIGHT_BOTTOM"		, 691042);

  83. 

  84.  define("GRADIENT_SIMPLE"		, 691051);

  85.  define("GRADIENT_EFFECT_CAN"		, 691052);

  86. 

  87.  define("LABEL_TITLE_NOBACKGROUND"	, 691061);

  88.  define("LABEL_TITLE_BACKGROUND"	, 691062);

  89. 

  90.  define("LABEL_POINT_NONE"		, 691071);

  91.  define("LABEL_POINT_CIRCLE"		, 691072);

  92.  define("LABEL_POINT_BOX"		, 691073);

  93. 

  94.  define("ZONE_NAME_ANGLE_AUTO"		, 691081);

  95. 

  96.  define("PI"		, 3.14159265);

  97.  define("ALL"		, 69);

  98.  define("NONE"		, 31);

  99.  define("AUTO"		, 690000);

  100.  define("OUT_OF_SIGHT"	, -10000000000000);

  101. 

  102.  class pDraw

  103.   {

  104.    /* Returns the number of drawable series */

  105.    function countDrawableSeries()

  106.     {

  107.      $Results = 0;

  108.      $Data = $this->DataSet->getData();

  109. 

  110.      foreach($Data["Series"] as $SerieName => $Serie)

  111.       { if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] ) { $Results++; } }

  112. 

  113.      return($Results);

  114.     }

  115. 

  116.    /* Fix box coordinates */

  117.    function fixBoxCoordinates($Xa,$Ya,$Xb,$Yb)

  118.     {

  119.      $X1 = min($Xa,$Xb); $Y1 = min($Ya,$Yb);

  120.      $X2 = max($Xa,$Xb); $Y2 = max($Ya,$Yb);

  121. 

  122.      return(array($X1,$Y1,$X2,$Y2));

  123.     }

  124. 

  125.    /* Draw a polygon */

  126.    function drawPolygon($Points,$Format="")

  127.     {

  128.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  129.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  130.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  131.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  132.      $NoFill		= isset($Format["NoFill"]) ? $Format["NoFill"] : FALSE;

  133.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;

  134.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

  135.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

  136.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

  137.      $BorderAlpha 	= isset($Format["Alpha"]) ? $Format["Alpha"] : $Alpha / 2;

  138.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  139.      $SkipX		= isset($Format["SkipX"]) ? $Format["SkipX"] : OUT_OF_SIGHT;

  140.      $SkipY		= isset($Format["SkipY"]) ? $Format["SkipY"] : OUT_OF_SIGHT;

  141. 

  142.      /* Calling the ImageFilledPolygon() function over the $Points array will round it */ 	

  143.      $Backup = $Points;

  144. 

  145.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  146. 

  147.      if ( $SkipX != OUT_OF_SIGHT ) { $SkipX = floor($SkipX); }

  148.      if ( $SkipY != OUT_OF_SIGHT ) { $SkipY = floor($SkipY); }

  149. 

  150.      $RestoreShadow = $this->Shadow;

  151.      if ( !$NoFill )

  152.       {

  153.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  154.         {

  155.          $this->Shadow = FALSE;

  156.          for($i=0;$i<=count($Points)-1;$i=$i+2)

  157.           { $Shadow[] = $Points[$i] + $this->ShadowX; $Shadow[] = $Points[$i+1] + $this->ShadowY; }

  158.          $this->drawPolygon($Shadow,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"NoBorder"=>TRUE));

  159.         }

  160. 

  161.        $FillColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  162. 

  163.        if ( count($Points) >= 6 )

  164.         { ImageFilledPolygon($this->Picture,$Points,count($Points)/2,$FillColor); }

  165.       }

  166. 

  167.      if ( !$NoBorder )

  168.       {

  169.        $Points = $Backup;

  170. 

  171.        if ( $NoFill )

  172.         $BorderSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

  173.        else

  174.         $BorderSettings = array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha);

  175. 

  176.        for($i=0;$i<=count($Points)-1;$i=$i+2)

  177.         {

  178.          if ( isset($Points[$i+2]) )

  179.           {

  180.            if ( !($Points[$i] == $Points[$i+2] && $Points[$i] == $SkipX ) && !($Points[$i+1] == $Points[$i+3] && $Points[$i+1] == $SkipY ) )

  181.             $this->drawLine($Points[$i],$Points[$i+1],$Points[$i+2],$Points[$i+3],$BorderSettings);

  182.           }

  183.          else

  184.           {

  185.            if ( !($Points[$i] == $Points[0] && $Points[$i] == $SkipX ) && !($Points[$i+1] == $Points[1] && $Points[$i+1] == $SkipY ) )

  186.             $this->drawLine($Points[$i],$Points[$i+1],$Points[0],$Points[1],$BorderSettings);

  187.           }

  188.         }

  189.       }

  190. 

  191.      $this->Shadow = $RestoreShadow;

  192.     }

  193. 

  194.    /* Apply AALias correction to the rounded box boundaries */

  195.    function offsetCorrection($Value,$Mode)

  196.     {

  197.      $Value = round($Value,1);

  198. 

  199.      if ( $Value == 0 && $Mode == 1 ) { return(.9); }

  200.      if ( $Value == 0 ) { return(0); }

  201. 

  202.      if ( $Mode == 1) 

  203.       { if ( $Value == 1 ) { return(.9); }; if ( $Value == .1 ) { return(.9); }; if ( $Value == .2 ) { return(.8); }; if ( $Value == .3 ) { return(.8); }; if ( $Value == .4 ) { return(.7); }; if ( $Value == .5 ) { return(.5); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.6); }; if ( $Value == .9 ) { return(.9); }; }

  204. 

  205.      if ( $Mode == 2) 

  206.       { if ( $Value == 1 ) { return(.9); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.4); }; if ( $Value == .5 ) { return(.5); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.8); }; if ( $Value == .9 ) { return(.9); }; }

  207. 

  208.      if ( $Mode == 3) 

  209.       { if ( $Value == 1 ) { return(.1); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.4); }; if ( $Value == .5 ) { return(.9); }; if ( $Value == .6 ) { return(.6); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.4); }; if ( $Value == .9 ) { return(.5); }; }

  210. 

  211.      if ( $Mode == 4) 

  212.       { if ( $Value == 1 ) { return(-1); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.1); }; if ( $Value == .5 ) { return(-.1); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.1); }; if ( $Value == .8 ) { return(.1); }; if ( $Value == .9 ) { return(.1); }; }

  213.     }

  214. 

  215.    /* Draw a rectangle with rounded corners */

  216.    function drawRoundedRectangle($X1,$Y1,$X2,$Y2,$Radius,$Format="")

  217.     {

  218.      $R	    = isset($Format["R"]) ? $Format["R"] : 0;

  219.      $G	    = isset($Format["G"]) ? $Format["G"] : 0;

  220.      $B	    = isset($Format["B"]) ? $Format["B"] : 0;

  221.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  222. 

  223.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);

  224. 

  225.      if ( $X2 - $X1 < $Radius ) { $Radius = floor((($X2-$X1))/2); }

  226.      if ( $Y2 - $Y1 < $Radius ) { $Radius = floor((($Y2-$Y1))/2); }

  227. 

  228.      $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE);

  229. 

  230.      if ( $Radius <= 0 ) { $this->drawRectangle($X1,$Y1,$X2,$Y2,$Color); return(0); }

  231. 

  232.      if ( $this->Antialias )

  233.       {

  234.        $this->drawLine($X1+$Radius,$Y1,$X2-$Radius,$Y1,$Color);

  235.        $this->drawLine($X2,$Y1+$Radius,$X2,$Y2-$Radius,$Color);

  236.        $this->drawLine($X2-$Radius,$Y2,$X1+$Radius,$Y2,$Color);

  237.        $this->drawLine($X1,$Y1+$Radius,$X1,$Y2-$Radius,$Color);

  238.       }

  239.      else

  240.       {

  241.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  242.        imageline($this->Picture,$X1+$Radius,$Y1,$X2-$Radius,$Y1,$Color);

  243.        imageline($this->Picture,$X2,$Y1+$Radius,$X2,$Y2-$Radius,$Color);

  244.        imageline($this->Picture,$X2-$Radius,$Y2,$X1+$Radius,$Y2,$Color);

  245.        imageline($this->Picture,$X1,$Y1+$Radius,$X1,$Y2-$Radius,$Color);

  246.       }

  247. 

  248.      $Step = 360 / (2 * PI * $Radius);

  249.      for($i=0;$i<=90;$i=$i+$Step)

  250.       {

  251.        $X = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;

  252.        $Y = sin(($i+180)*PI/180) * $Radius + $Y1 + $Radius;

  253.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  254. 

  255.        $X = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;

  256.        $Y = sin(($i+90)*PI/180) * $Radius + $Y2 - $Radius;

  257.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  258. 

  259.        $X = cos($i*PI/180) * $Radius + $X2 - $Radius;

  260.        $Y = sin($i*PI/180) * $Radius + $Y2 - $Radius;

  261.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  262. 

  263.        $X = cos(($i+270)*PI/180) * $Radius + $X2 - $Radius;

  264.        $Y = sin(($i+270)*PI/180) * $Radius + $Y1 + $Radius;

  265.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  266.       }

  267.     }

  268. 

  269.    /* Draw a rectangle with rounded corners */

  270.    function drawRoundedFilledRectangle($X1,$Y1,$X2,$Y2,$Radius,$Format="")

  271.     {

  272.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  273.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  274.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  275.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  276.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  277.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  278.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  279.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  280. 

  281.      /* Temporary fix for AA issue */

  282.      $Y1 = floor($Y1); $Y2 = floor($Y2); $X1 = floor($X1); $X2 = floor($X2);

  283. 

  284.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  285.      if ( $BorderR == -1 ) { $BorderR = $R; $BorderG = $G; $BorderB = $B; }

  286. 

  287.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);

  288. 

  289.      if ( $X2 - $X1 < $Radius*2 ) { $Radius = floor((($X2-$X1))/4); }

  290.      if ( $Y2 - $Y1 < $Radius*2 ) { $Radius = floor((($Y2-$Y1))/4); }

  291. 

  292.      $RestoreShadow = $this->Shadow;

  293.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  294.       {

  295.        $this->Shadow = FALSE;

  296.        $this->drawRoundedFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  297.       }

  298. 

  299.      $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE);

  300. 

  301.      if ( $Radius <= 0 ) { $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color); return(0); }

  302. 

  303.      $YTop    = $Y1+$Radius;

  304.      $YBottom = $Y2-$Radius;

  305. 

  306.      $Step = 360 / (2 * PI * $Radius);

  307.      $Positions = ""; $Radius--; $MinY = ""; $MaxY = "";

  308.      for($i=0;$i<=90;$i=$i+$Step)

  309.       {

  310.        $Xp1 = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;

  311.        $Xp2 = cos(((90-$i)+270)*PI/180) * $Radius + $X2 - $Radius;

  312.        $Yp  = floor(sin(($i+180)*PI/180) * $Radius + $YTop);

  313.        if ( $MinY == "" || $Yp > $MinY ) { $MinY = $Yp; }

  314. 

  315.        if ( $Xp1 <= floor($X1) )  { $Xp1++; }

  316.        if ( $Xp2 >= floor($X2) )  { $Xp2--; }

  317.        $Xp1++;

  318. 

  319.        if ( !isset($Positions[$Yp]) )

  320.         { $Positions[$Yp]["X1"] = $Xp1; $Positions[$Yp]["X2"] = $Xp2; }

  321.        else

  322.         { $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"]+$Xp1)/2; $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"]+$Xp2)/2; }

  323. 

  324.        $Xp1 = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;

  325.        $Xp2 = cos((90-$i)*PI/180) * $Radius + $X2 - $Radius;

  326.        $Yp  = floor(sin(($i+90)*PI/180) * $Radius + $YBottom);

  327.        if ( $MaxY == "" || $Yp < $MaxY ) { $MaxY = $Yp; }

  328. 

  329.        if ( $Xp1 <= floor($X1) ) { $Xp1++; }

  330.        if ( $Xp2 >= floor($X2) ) { $Xp2--; }

  331.        $Xp1++;

  332. 

  333.        if ( !isset($Positions[$Yp]) )

  334.         { $Positions[$Yp]["X1"] = $Xp1; $Positions[$Yp]["X2"] = $Xp2; }

  335.        else

  336.         { $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"]+$Xp1)/2; $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"]+$Xp2)/2; }

  337.       }

  338. 

  339.      $ManualColor  = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  340.      foreach($Positions as $Yp => $Bounds)

  341.       {

  342.        $X1 = $Bounds["X1"]; $X1Dec = $this->getFirstDecimal($X1); if ( $X1Dec != 0 ) { $X1 = floor($X1)+1; }

  343.        $X2 = $Bounds["X2"]; $X2Dec = $this->getFirstDecimal($X2); if ( $X2Dec != 0 ) { $X2 = floor($X2)-1; }

  344.        imageline($this->Picture,$X1,$Yp,$X2,$Yp,$ManualColor);

  345.       }

  346.      $this->drawFilledRectangle($X1,$MinY+1,floor($X2),$MaxY-1,$Color);

  347. 

  348.      $Radius++;

  349.      $this->drawRoundedRectangle($X1,$Y1,$X2+1,$Y2-1,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  350. 

  351.      $this->Shadow = $RestoreShadow;

  352.     }

  353. 

  354.    /* Draw a rectangle with rounded corners */

  355.    function drawRoundedFilledRectangle_deprecated($X1,$Y1,$X2,$Y2,$Radius,$Format="")

  356.     {

  357.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  358.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  359.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  360.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  361.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  362.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  363.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  364.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  365. 

  366.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  367.      if ( $BorderR == -1 ) { $BorderR = $R; $BorderG = $G; $BorderB = $B; }

  368. 

  369.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);

  370. 

  371.      if ( $X2 - $X1 < $Radius ) { $Radius = floor((($X2-$X1)+2)/2); }

  372.      if ( $Y2 - $Y1 < $Radius ) { $Radius = floor((($Y2-$Y1)+2)/2); }

  373. 

  374.      $RestoreShadow = $this->Shadow;

  375.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  376.       {

  377.        $this->Shadow = FALSE;

  378.        $this->drawRoundedFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  379.       }

  380. 

  381.      if ( $this->getFirstDecimal($X2) >= 5 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }

  382.      if ( $this->getFirstDecimal($X1) <= 5 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }

  383. 

  384.      if ( !$this->Antialias ) { $XOffset1 = 1; $XOffset2 = 1; }

  385. 

  386.      $YTop    = floor($Y1+$Radius);

  387.      $YBottom = floor($Y2-$Radius);

  388. 

  389.      $this->drawFilledRectangle($X1-$XOffset1,$YTop,$X2+$XOffset2,$YBottom,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE));

  390. 

  391.      $Step = 360 / (2 * PI * $Radius);

  392.      $Color  = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  393.      $Color2 = $this->allocateColor($this->Picture,255,0,0,$Alpha);

  394.      $Drawn = "";

  395. 

  396.      if ( $Alpha < 100 )  { $Drawn[$YTop] = FALSE; }

  397.      if ( $Alpha < 100 )  { $Drawn[$YBottom] = TRUE; }

  398.      

  399.      for($i=0;$i<=90;$i=$i+$Step)

  400.       {

  401.        $Xp1 = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;

  402.        $Xp2 = cos(((90-$i)+270)*PI/180) * $Radius + $X2 - $Radius;

  403.        $Yp  = sin(($i+180)*PI/180) * $Radius + $YTop;

  404. 

  405.        if ( $this->getFirstDecimal($Xp1) > 5 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }

  406.        if ( $this->getFirstDecimal($Xp2) > 5 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }

  407.        if ( $this->getFirstDecimal($Yp) > 5 )  { $YOffset = 1; } else { $YOffset = 0; }

  408. 

  409.        if ( !isset($Drawn[$Yp+$YOffset]) || $Alpha == 100 )

  410.         imageline($this->Picture,$Xp1+$XOffset1,$Yp+$YOffset,$Xp2+$XOffset2,$Yp+$YOffset,$Color);

  411. 

  412.        $Drawn[$Yp+$YOffset] = $Xp2;

  413. 

  414.        $Xp1 = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;

  415.        $Xp2 = cos((90-$i)*PI/180) * $Radius + $X2 - $Radius;

  416.        $Yp  = sin(($i+90)*PI/180) * $Radius + $YBottom;

  417. 

  418.        if ( $this->getFirstDecimal($Xp1) > 7 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }

  419.        if ( $this->getFirstDecimal($Xp2) > 7 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }

  420.        if ( $this->getFirstDecimal($Yp) > 5 )  { $YOffset = 1; } else { $YOffset = 0; }

  421. 

  422.        if ( !isset($Drawn[$Yp+$YOffset]) || $Alpha == 100 )

  423.         imageline($this->Picture,$Xp1+$XOffset1,$Yp+$YOffset,$Xp2+$XOffset2,$Yp+$YOffset,$Color);

  424. 

  425.        $Drawn[$Yp+$YOffset] = $Xp2;

  426.       }

  427. 

  428.      $this->drawRoundedRectangle($X1,$Y1,$X2,$Y2,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  429. 

  430.      $this->Shadow = $RestoreShadow;

  431.     }

  432. 

  433.    /* Draw a rectangle */

  434.    function drawRectangle($X1,$Y1,$X2,$Y2,$Format="")

  435.     {

  436.      $R		= isset($Format["R"]) ? $Format["R"] : 0;

  437.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  438.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  439.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  440.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  441.      $NoAngle	= isset($Format["NoAngle"]) ? $Format["NoAngle"] : FALSE;

  442. 

  443.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }

  444.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }

  445. 

  446.      if ( $this->Antialias )

  447.       {

  448.        if ( $NoAngle )

  449.         {

  450.          $this->drawLine($X1+1,$Y1,$X2-1,$Y1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  451.          $this->drawLine($X2,$Y1+1,$X2,$Y2-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  452.          $this->drawLine($X2-1,$Y2,$X1+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  453.          $this->drawLine($X1,$Y1+1,$X1,$Y2-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  454.         }

  455.        else

  456.         {

  457.          $this->drawLine($X1+1,$Y1,$X2-1,$Y1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  458.          $this->drawLine($X2,$Y1,$X2,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  459.          $this->drawLine($X2-1,$Y2,$X1+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  460.          $this->drawLine($X1,$Y1,$X1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  461.         }

  462.       }

  463.      else

  464.       {

  465.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  466.        imagerectangle($this->Picture,$X1,$Y1,$X2,$Y2,$Color);

  467.       }

  468.     }

  469. 

  470.    /* Draw a filled rectangle */

  471.    function drawFilledRectangle($X1,$Y1,$X2,$Y2,$Format="")

  472.     {

  473.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  474.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  475.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  476.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  477.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  478.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  479.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  480.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;

  481.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  482.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  483.      $NoAngle		= isset($Format["NoAngle"]) ? $Format["NoAngle"] : NULL;

  484.      $Dash		= isset($Format["Dash"]) ? $Format["Dash"] : FALSE;

  485.      $DashStep		= isset($Format["DashStep"]) ? $Format["DashStep"] : 4;

  486.      $DashR		= isset($Format["DashR"]) ? $Format["DashR"] : 0;

  487.      $DashG		= isset($Format["DashG"]) ? $Format["DashG"] : 0;

  488.      $DashB		= isset($Format["DashB"]) ? $Format["DashB"] : 0;

  489.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;

  490. 

  491.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  492. 

  493.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }

  494.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }

  495. 

  496.      $RestoreShadow = $this->Shadow;

  497.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  498.       {

  499.        $this->Shadow = FALSE;

  500.        $this->drawFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks,"NoAngle"=>$NoAngle));

  501.       }

  502. 

  503.      $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  504.      if ( $NoAngle )

  505.       {

  506.        imagefilledrectangle($this->Picture,ceil($X1)+1,ceil($Y1),floor($X2)-1,floor($Y2),$Color);

  507.        imageline($this->Picture,ceil($X1),ceil($Y1)+1,ceil($X1),floor($Y2)-1,$Color);

  508.        imageline($this->Picture,floor($X2),ceil($Y1)+1,floor($X2),floor($Y2)-1,$Color);

  509.       }

  510.      else

  511.       imagefilledrectangle($this->Picture,ceil($X1),ceil($Y1),floor($X2),floor($Y2),$Color);

  512. 

  513.      if ( $Dash )

  514.       {

  515.        if ( $BorderR != -1 ) { $iX1=$X1+1; $iY1=$Y1+1; $iX2=$X2-1; $iY2=$Y2-1; } else { $iX1=$X1; $iY1=$Y1; $iX2=$X2; $iY2=$Y2; }

  516. 

  517.        $Color = $this->allocateColor($this->Picture,$DashR,$DashG,$DashB,$Alpha);

  518.        $Y=$iY1-$DashStep;

  519.        for($X=$iX1; $X<=$iX2+($iY2-$iY1); $X=$X+$DashStep)

  520.         {

  521.          $Y=$Y+$DashStep;

  522.          if ( $X > $iX2 ) { $Xa = $X-($X-$iX2); $Ya = $iY1+($X-$iX2); } else { $Xa = $X; $Ya = $iY1; }

  523.          if ( $Y > $iY2 ) { $Xb = $iX1+($Y-$iY2); $Yb = $Y-($Y-$iY2); } else { $Xb = $iX1; $Yb = $Y; }

  524.          imageline($this->Picture,$Xa,$Ya,$Xb,$Yb,$Color);

  525.         }

  526.       }

  527. 

  528.      if ( $this->Antialias && !$NoBorder )

  529.       {

  530.        if ( $X1 < ceil($X1) )

  531.         {

  532.          $AlphaA = $Alpha * (ceil($X1) - $X1);

  533.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);

  534.          imageline($this->Picture,ceil($X1)-1,ceil($Y1),ceil($X1)-1,floor($Y2),$Color);

  535.         }

  536. 

  537.        if ( $Y1 < ceil($Y1) )

  538.         {

  539.          $AlphaA = $Alpha * (ceil($Y1) - $Y1);

  540.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);

  541.          imageline($this->Picture,ceil($X1),ceil($Y1)-1,floor($X2),ceil($Y1)-1,$Color);

  542.         }

  543. 

  544.        if ( $X2 > floor($X2) )

  545.         {

  546.          $AlphaA = $Alpha * (.5-($X2 - floor($X2)));

  547.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);

  548.          imageline($this->Picture,floor($X2)+1,ceil($Y1),floor($X2)+1,floor($Y2),$Color);

  549.         } 

  550. 

  551.        if ( $Y2 > floor($Y2) )

  552.         {

  553.          $AlphaA = $Alpha * (.5-($Y2 - floor($Y2)));

  554.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);

  555.          imageline($this->Picture,ceil($X1),floor($Y2)+1,floor($X2),floor($Y2)+1,$Color);

  556.         }

  557.       }

  558. 

  559.      if ( $BorderR != -1 )

  560.       $this->drawRectangle($X1,$Y1,$X2,$Y2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$Ticks,"NoAngle"=>$NoAngle));

  561. 

  562.      $this->Shadow = $RestoreShadow;

  563.     }

  564. 

  565.    /* Draw a rectangular marker of the specified size */

  566.    function drawRectangleMarker($X,$Y,$Format="")

  567.     {

  568.      $Size = isset($Format["Size"]) ? $Format["Size"] : 4;

  569. 

  570.      $HalfSize = floor($Size/2);

  571.      $this->drawFilledRectangle($X-$HalfSize,$Y-$HalfSize,$X+$HalfSize,$Y+$HalfSize,$Format);

  572.     }

  573. 

  574.    /* Drawn a spline based on the bezier function */

  575.    function drawSpline($Coordinates,$Format="")

  576.     {

  577.      $R		= isset($Format["R"]) ? $Format["R"] : 0;

  578.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  579.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  580.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  581.      $Force	= isset($Format["Force"]) ? $Format["Force"] : 30;

  582.      $Forces	= isset($Format["Forces"]) ? $Format["Forces"] : NULL;

  583.      $ShowC	= isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;

  584.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  585.      $PathOnly	= isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;

  586.      $Weight	= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

  587. 

  588.      $Cpt = NULL; $Mode = NULL; $Result = "";

  589.      for($i=1;$i<=count($Coordinates)-1;$i++)

  590.       {

  591.        $X1 = $Coordinates[$i-1][0]; $Y1 = $Coordinates[$i-1][1];

  592.        $X2 = $Coordinates[$i][0];   $Y2 = $Coordinates[$i][1];

  593. 

  594.        if ( $Forces != NULL ) { $Force = $Forces[$i]; }

  595. 

  596.        /* First segment */

  597.        if ( $i == 1 )

  598.         { $Xv1 = $X1; $Yv1 = $Y1; }

  599.        else

  600.         {

  601.          $Angle1 = $this->getAngle($XLast,$YLast,$X1,$Y1);

  602.          $Angle2 = $this->getAngle($X1,$Y1,$X2,$Y2);

  603.          $XOff = cos($Angle2 * PI / 180) * $Force + $X1;

  604.          $YOff = sin($Angle2 * PI / 180) * $Force + $Y1;

  605. 

  606.          $Xv1 = cos($Angle1 * PI / 180) * $Force + $XOff;

  607.          $Yv1 = sin($Angle1 * PI / 180) * $Force + $YOff;

  608.         }

  609. 

  610.        /* Last segment */

  611.        if ( $i == count($Coordinates)-1 )

  612.         { $Xv2 = $X2; $Yv2 = $Y2; }

  613.        else

  614.         {

  615.          $Angle1 = $this->getAngle($X2,$Y2,$Coordinates[$i+1][0],$Coordinates[$i+1][1]);

  616.          $Angle2 = $this->getAngle($X1,$Y1,$X2,$Y2);

  617.          $XOff = cos(($Angle2+180) * PI / 180) * $Force + $X2;

  618.          $YOff = sin(($Angle2+180) * PI / 180) * $Force + $Y2;

  619. 

  620.          $Xv2 = cos(($Angle1+180) * PI / 180) * $Force + $XOff;

  621.          $Yv2 = sin(($Angle1+180) * PI / 180) * $Force + $YOff;

  622.         }

  623. 

  624.        $Path = $this->drawBezier($X1,$Y1,$X2,$Y2,$Xv1,$Yv1,$Xv2,$Yv2,$Format);

  625.        if ($PathOnly) { $Result[] = $Path; }

  626. 

  627.        $XLast = $X1; $YLast = $Y1;

  628.       }

  629. 

  630.      return($Result);

  631.     }

  632. 

  633.    /* Draw a bezier curve with two controls points */

  634.    function drawBezier($X1,$Y1,$X2,$Y2,$Xv1,$Yv1,$Xv2,$Yv2,$Format="")

  635.     {

  636.      $R		= isset($Format["R"]) ? $Format["R"] : 0;

  637.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  638.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  639.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  640.      $ShowC	= isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;

  641.      $Segments	= isset($Format["Segments"]) ? $Format["Segments"] : NULL;

  642.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  643.      $NoDraw    = isset($Format["NoDraw"]) ? $Format["NoDraw"] : FALSE;

  644.      $PathOnly  = isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;

  645.      $Weight    = isset($Format["Weight"]) ? $Format["Weight"] : NULL;

  646.      $DrawArrow		= isset($Format["DrawArrow"]) ? $Format["DrawArrow"] : FALSE;

  647.      $ArrowSize		= isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 10;

  648.      $ArrowRatio	= isset($Format["ArrowRatio"]) ? $Format["ArrowRatio"] : .5;

  649.      $ArrowTwoHeads	= isset($Format["ArrowTwoHeads"]) ? $Format["ArrowTwoHeads"] : FALSE;

  650. 

  651.      if ( $Segments == NULL )

  652.       {

  653.        $Length    = $this->getLength($X1,$Y1,$X2,$Y2);

  654.        $Precision = ($Length*125)/1000;

  655.       }

  656.      else

  657.       $Precision = $Segments;

  658. 

  659.      $P[0]["X"] = $X1;  $P[0]["Y"] = $Y1;

  660.      $P[1]["X"] = $Xv1; $P[1]["Y"] = $Yv1;

  661.      $P[2]["X"] = $Xv2; $P[2]["Y"] = $Yv2;

  662.      $P[3]["X"] = $X2;  $P[3]["Y"] = $Y2;

  663. 

  664.      /* Compute the bezier points */

  665.      $Q = ""; $ID = 0; $Path = "";

  666.      for($i=0;$i<=$Precision;$i=$i+1)

  667.       {

  668.        $u = $i / $Precision;

  669. 

  670.        $C    = "";

  671.        $C[0] = (1 - $u) * (1 - $u) * (1 - $u);

  672.        $C[1] = ($u * 3) * (1 - $u) * (1 - $u);

  673.        $C[2] = 3 * $u * $u * (1 - $u);

  674.        $C[3] = $u * $u * $u;

  675. 

  676.        for($j=0;$j<=3;$j++)

  677.         {

  678.          if ( !isset($Q[$ID]) ) { $Q[$ID] = ""; }

  679.          if ( !isset($Q[$ID]["X"]) ) { $Q[$ID]["X"] = 0; }

  680.          if ( !isset($Q[$ID]["Y"]) ) { $Q[$ID]["Y"] = 0; }

  681. 

  682.          $Q[$ID]["X"] = $Q[$ID]["X"] + $P[$j]["X"] * $C[$j];

  683.          $Q[$ID]["Y"] = $Q[$ID]["Y"] + $P[$j]["Y"] * $C[$j];

  684.         }

  685.        $ID++;

  686.       }        

  687.      $Q[$ID]["X"] = $X2; $Q[$ID]["Y"] = $Y2;

  688. 

  689.      if ( !$NoDraw )

  690.       {

  691.        /* Display the control points */

  692.        if ( $ShowC && !$PathOnly )

  693.         {

  694.          $Xv1 = floor($Xv1); $Yv1 = floor($Yv1); $Xv2 = floor($Xv2); $Yv2 = floor($Yv2);

  695. 

  696.          $this->drawLine($X1,$Y1,$X2,$Y2,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>30));

  697. 

  698.          $MyMarkerSettings = array("R"=>255,"G"=>0,"B"=>0,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);

  699.          $this->drawRectangleMarker($Xv1,$Yv1,$MyMarkerSettings);

  700.          $this->drawText($Xv1+4,$Yv1,"v1");

  701.          $MyMarkerSettings = array("R"=>0,"G"=>0,"B"=>255,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);

  702.          $this->drawRectangleMarker($Xv2,$Yv2,$MyMarkerSettings);

  703.          $this->drawText($Xv2+4,$Yv2,"v2");

  704.         }

  705. 

  706.        /* Draw the bezier */

  707.        $LastX = NULL; $LastY = NULL; $Cpt = NULL; $Mode = NULL; $ArrowS = NULL;

  708.        foreach ($Q as $Key => $Point)

  709.         {

  710.          $X = $Point["X"]; $Y = $Point["Y"];

  711. 

  712.          /* Get the first segment */

  713.          if ( $ArrowS == NULL && $LastX != NULL && $LastY != NULL )

  714.           { $ArrowS["X2"] = $LastX; $ArrowS["Y2"] = $LastY; $ArrowS["X1"] = $X; $ArrowS["Y1"] = $Y; }

  715. 

  716.          if ( $LastX != NULL && $LastY != NULL && !$PathOnly)

  717.           list($Cpt,$Mode) = $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Cpt"=>$Cpt,"Mode"=>$Mode,"Weight"=>$Weight));

  718. 

  719.          /* Get the last segment */

  720.          $ArrowE["X1"] = $LastX; $ArrowE["Y1"] = $LastY; $ArrowE["X2"] = $X; $ArrowE["Y2"] = $Y;

  721. 

  722.          $LastX = $X; $LastY = $Y;

  723.         }

  724. 

  725.        if ( $DrawArrow && !$PathOnly )

  726.         {

  727.          $ArrowSettings = array("FillR"=>$R,"FillG"=>$G,"FillB"=>$B,"Alpha"=>$Alpha,"Size"=>$ArrowSize,"Ratio"=>$ArrowRatio);

  728.          if ( $ArrowTwoHeads )

  729.           $this->drawArrow($ArrowS["X1"],$ArrowS["Y1"],$ArrowS["X2"],$ArrowS["Y2"],$ArrowSettings);

  730. 

  731.          $this->drawArrow($ArrowE["X1"],$ArrowE["Y1"],$ArrowE["X2"],$ArrowE["Y2"],$ArrowSettings);

  732.         }

  733.       }

  734.      return($Q);

  735.     }

  736. 

  737.    /* Draw a line between two points */

  738.    function drawLine($X1,$Y1,$X2,$Y2,$Format="")

  739.     {

  740.      $R		= isset($Format["R"]) ? $Format["R"] : 0;

  741.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  742.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  743.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  744.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  745.      $Cpt	= isset($Format["Cpt"]) ? $Format["Cpt"] : 1;

  746.      $Mode	= isset($Format["Mode"]) ? $Format["Mode"] : 1;

  747.      $Weight	= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

  748.      $Threshold	= isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

  749. 

  750.      if ( $this->Antialias == FALSE && $Ticks == NULL )

  751.       {

  752.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  753.         {

  754.          $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);

  755.          imageline($this->Picture,$X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$ShadowColor);

  756.         }

  757. 

  758.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  759.        imageline($this->Picture,$X1,$Y1,$X2,$Y2,$Color);

  760.        return(0);

  761.       }

  762. 

  763.      $Distance = sqrt(($X2-$X1)*($X2-$X1)+($Y2-$Y1)*($Y2-$Y1));  

  764.      if ( $Distance == 0 ) { return(-1); }

  765. 

  766.      /* Derivative algorithm for overweighted lines, re-route to polygons primitives */

  767.      if ( $Weight != NULL )

  768.       {

  769.        $Angle        = $this->getAngle($X1,$Y1,$X2,$Y2);

  770.        $PolySettings = array ("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderAlpha"=>$Alpha);

  771. 

  772.        if ( $Ticks == NULL )

  773.         {

  774.          $Points   = ""; 

  775.          $Points[] = cos(deg2rad($Angle-90)) * $Weight + $X1; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Y1;

  776.          $Points[] = cos(deg2rad($Angle+90)) * $Weight + $X1; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Y1;

  777.          $Points[] = cos(deg2rad($Angle+90)) * $Weight + $X2; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Y2;

  778.          $Points[] = cos(deg2rad($Angle-90)) * $Weight + $X2; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Y2;

  779. 

  780.          $this->drawPolygon($Points,$PolySettings);

  781.         }

  782.        else

  783.         {

  784.          for($i=0;$i<=$Distance;$i=$i+$Ticks*2)

  785.           {

  786.            $Xa = (($X2-$X1)/$Distance) * $i + $X1; $Ya = (($Y2-$Y1)/$Distance) * $i + $Y1;

  787.            $Xb = (($X2-$X1)/$Distance) * ($i+$Ticks) + $X1; $Yb = (($Y2-$Y1)/$Distance) * ($i+$Ticks) + $Y1;

  788. 

  789.            $Points   = ""; 

  790.            $Points[] = cos(deg2rad($Angle-90)) * $Weight + $Xa; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Ya;

  791.            $Points[] = cos(deg2rad($Angle+90)) * $Weight + $Xa; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Ya;

  792.            $Points[] = cos(deg2rad($Angle+90)) * $Weight + $Xb; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Yb;

  793.            $Points[] = cos(deg2rad($Angle-90)) * $Weight + $Xb; $Points[] = sin(deg2rad($Angle-90)) * $Weight 	+ $Yb;

  794. 

  795.            $this->drawPolygon($Points,$PolySettings);

  796.           }

  797.         }

  798. 

  799.        return(1);

  800.       }

  801. 

  802.      $XStep = ($X2-$X1) / $Distance;

  803.      $YStep = ($Y2-$Y1) / $Distance;

  804. 

  805.      for($i=0;$i<=$Distance;$i++)

  806.       {

  807.        $X = $i * $XStep + $X1;

  808.        $Y = $i * $YStep + $Y1;

  809. 

  810.        $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

  811. 

  812.        if ( $Threshold != NULL )

  813.         {

  814.          foreach($Threshold as $Key => $Parameters)

  815.           {

  816.            if ( $Y <= $Parameters["MinX"] && $Y >= $Parameters["MaxX"])

  817.             {

  818.              if ( isset($Parameters["R"]) ) { $RT = $Parameters["R"]; } else { $RT = 0; }

  819.              if ( isset($Parameters["G"]) ) { $GT = $Parameters["G"]; } else { $GT = 0; }

  820.              if ( isset($Parameters["B"]) ) { $BT = $Parameters["B"]; } else { $BT = 0; }

  821.              if ( isset($Parameters["Alpha"]) ) { $AlphaT = $Parameters["Alpha"]; } else { $AlphaT = 0; }

  822.              $Color = array("R"=>$RT,"G"=>$GT,"B"=>$BT,"Alpha"=>$AlphaT);

  823.             }

  824.           }

  825.         }

  826. 

  827.        if ( $Ticks != NULL )

  828.         {

  829.          if ( $Cpt % $Ticks == 0 )

  830.           { $Cpt = 0; if ( $Mode == 1 ) { $Mode = 0; } else { $Mode = 1; } }

  831. 

  832.          if ( $Mode == 1 )

  833.           $this->drawAntialiasPixel($X,$Y,$Color);

  834. 

  835.          $Cpt++;

  836.         }

  837.        else

  838.         $this->drawAntialiasPixel($X,$Y,$Color);

  839.       }

  840. 

  841.      return(array($Cpt,$Mode));

  842.     }

  843. 

  844.    /* Draw a circle */

  845.    function drawCircle($Xc,$Yc,$Height,$Width,$Format="")

  846.     {

  847.      $R	    = isset($Format["R"]) ? $Format["R"] : 0;

  848.      $G	    = isset($Format["G"]) ? $Format["G"] : 0;

  849.      $B	    = isset($Format["B"]) ? $Format["B"] : 0;

  850.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  851.      $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  852. 

  853.      $Height	= abs($Height);

  854.      $Width	= abs($Width);

  855. 

  856.      if ( $Height == 0 ) { $Height = 1; }

  857.      if ( $Width == 0 )  { $Width = 1; }

  858.      $Xc = floor($Xc); $Yc = floor($Yc);

  859. 

  860.      $RestoreShadow = $this->Shadow;

  861.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  862.       {

  863.        $this->Shadow = FALSE;

  864.        $this->drawCircle($Xc+$this->ShadowX,$Yc+$this->ShadowY,$Height,$Width,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks));

  865.       }

  866. 

  867.      if ( $Width == 0 ) { $Width = $Height; }

  868.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }

  869.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }

  870.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }

  871. 

  872.      $Step = 360 / (2 * PI * max($Width,$Height));

  873.      $Mode = 1; $Cpt = 1;

  874.      for($i=0;$i<=360;$i=$i+$Step)

  875.       {

  876.        $X = cos($i*PI/180) * $Height + $Xc;

  877.        $Y = sin($i*PI/180) * $Width + $Yc;

  878. 

  879.        if ( $Ticks != NULL )

  880.         {

  881.          if ( $Cpt % $Ticks == 0 )

  882.           { $Cpt = 0; if ( $Mode == 1 ) { $Mode = 0; } else { $Mode = 1; } }

  883. 

  884.          if ( $Mode == 1 )

  885.           $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  886. 

  887.          $Cpt++;

  888.         }

  889.        else

  890.         $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  891. 

  892.       }

  893.      $this->Shadow = $RestoreShadow;

  894.     }

  895. 

  896.    /* Draw a filled circle */

  897.    function drawFilledCircle($X,$Y,$Radius,$Format="")

  898.     {

  899.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  900.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  901.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  902.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  903.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  904.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  905.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  906.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;

  907.      $Ticks     	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  908.      $Surrounding 	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  909. 

  910.      if ( $Radius == 0 ) { $Radius = 1; }

  911.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  912.      $X = floor($X); $Y = floor($Y);

  913. 

  914.      $Radius = abs($Radius);

  915. 

  916.      $RestoreShadow = $this->Shadow;

  917.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  918.       {

  919.        $this->Shadow = FALSE;

  920.        $this->drawFilledCircle($X+$this->ShadowX,$Y+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks));

  921.       }

  922. 

  923.      $this->Mask  = "";

  924.      $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  925.      for ($i=0; $i<=$Radius*2; $i++)

  926.       {

  927.        $Slice  = sqrt($Radius * $Radius - ($Radius - $i) * ($Radius - $i));

  928.        $XPos   = floor($Slice);

  929.        $YPos   = $Y + $i - $Radius;

  930.        $AAlias = $Slice - floor($Slice);

  931. 

  932.        $this->Mask[$X-$XPos][$YPos] = TRUE;

  933.        $this->Mask[$X+$XPos][$YPos] = TRUE;

  934.        imageline($this->Picture,$X-$XPos,$YPos,$X+$XPos,$YPos,$Color);

  935.       }

  936.      if ( $this->Antialias )

  937.       $this->drawCircle($X,$Y,$Radius,$Radius,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  938. 

  939.      $this->Mask = "";

  940. 

  941.      if ( $BorderR != -1 )

  942.       $this->drawCircle($X,$Y,$Radius,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$Ticks));

  943. 

  944.      $this->Shadow	= $RestoreShadow;

  945.     }

  946. 

  947.    /* Write text */

  948.    function drawText($X,$Y,$Text,$Format="")

  949.     {

  950.      $R			= isset($Format["R"]) ? $Format["R"] : $this->FontColorR;

  951.      $G			= isset($Format["G"]) ? $Format["G"] : $this->FontColorG;

  952.      $B			= isset($Format["B"]) ? $Format["B"] : $this->FontColorB;

  953.      $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;

  954.      $Align		= isset($Format["Align"]) ? $Format["Align"] : TEXT_ALIGN_BOTTOMLEFT;

  955.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;

  956.      $FontName		= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

  957.      $FontSize		= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

  958.      $ShowOrigine	= isset($Format["ShowOrigine"]) ? $Format["ShowOrigine"] : FALSE;

  959.      $TOffset		= isset($Format["TOffset"]) ? $Format["TOffset"] : 2;

  960.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : FALSE;

  961.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : TRUE;

  962.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 6;

  963.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : FALSE;

  964.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 6;

  965.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 255;

  966.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 255;

  967.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 255;

  968.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;

  969.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

  970.      $BoxBorderR	= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

  971.      $BoxBorderG	= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

  972.      $BoxBorderB	= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

  973.      $BoxBorderAlpha	= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;

  974.      $NoShadow		= isset($Format["NoShadow"]) ? $Format["NoShadow"] : FALSE;

  975. 

  976.      $Shadow = $this->Shadow;

  977.      if ( $NoShadow ) { $this->Shadow = FALSE; }

  978. 

  979.      if ( $BoxSurrounding != "" ) { $BoxBorderR = $BoxR - $BoxSurrounding; $BoxBorderG = $BoxG - $BoxSurrounding; $BoxBorderB = $BoxB - $BoxSurrounding; $BoxBorderAlpha = $BoxAlpha; }

  980. 

  981.      if ( $ShowOrigine )

  982.       {

  983.        $MyMarkerSettings = array("R"=>255,"G"=>0,"B"=>0,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);

  984.        $this->drawRectangleMarker($X,$Y,$MyMarkerSettings);

  985.       }

  986. 

  987.      $TxtPos = $this->getTextBox($X,$Y,$FontName,$FontSize,$Angle,$Text);

  988. 

  989.      if ( $DrawBox && ($Angle == 0 || $Angle == 90 || $Angle == 180 || $Angle == 270))

  990.       {

  991.        $T[0]["X"]=0;$T[0]["Y"]=0;$T[1]["X"]=0;$T[1]["Y"]=0;$T[2]["X"]=0;$T[2]["Y"]=0;$T[3]["X"]=0;$T[3]["Y"]=0;

  992.        if ( $Angle == 0 ) { $T[0]["X"]=-$TOffset;$T[0]["Y"]=$TOffset;$T[1]["X"]=$TOffset;$T[1]["Y"]=$TOffset;$T[2]["X"]=$TOffset;$T[2]["Y"]=-$TOffset;$T[3]["X"]=-$TOffset;$T[3]["Y"]=-$TOffset; }

  993. 

  994.        $X1 = min($TxtPos[0]["X"],$TxtPos[1]["X"],$TxtPos[2]["X"],$TxtPos[3]["X"]) - $BorderOffset + 3;

  995.        $Y1 = min($TxtPos[0]["Y"],$TxtPos[1]["Y"],$TxtPos[2]["Y"],$TxtPos[3]["Y"]) - $BorderOffset;

  996.        $X2 = max($TxtPos[0]["X"],$TxtPos[1]["X"],$TxtPos[2]["X"],$TxtPos[3]["X"]) + $BorderOffset + 3;

  997.        $Y2 = max($TxtPos[0]["Y"],$TxtPos[1]["Y"],$TxtPos[2]["Y"],$TxtPos[3]["Y"]) + $BorderOffset - 3;

  998. 

  999.        $X1 = $X1 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];

  1000.        $Y1 = $Y1 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];

  1001.        $X2 = $X2 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];

  1002.        $Y2 = $Y2 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];

  1003. 

  1004.        $Settings = array("R"=>$BoxR,"G"=>$BoxG,"B"=>$BoxB,"Alpha"=>$BoxAlpha,"BorderR"=>$BoxBorderR,"BorderG"=>$BoxBorderG,"BorderB"=>$BoxBorderB,"BorderAlpha"=>$BoxBorderAlpha);

  1005. 

  1006.        if ( $BoxRounded )

  1007.         { $this->drawRoundedFilledRectangle($X1,$Y1,$X2,$Y2,$RoundedRadius,$Settings); }

  1008.        else

  1009.         { $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Settings); }

  1010.       }

  1011. 

  1012.      $X = $X - $TxtPos[$Align]["X"] + $X;

  1013.      $Y = $Y - $TxtPos[$Align]["Y"] + $Y;

  1014. 

  1015.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  1016.       {

  1017.        $C_ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);

  1018.        imagettftext($this->Picture,$FontSize,$Angle,$X+$this->ShadowX,$Y+$this->ShadowY,$C_ShadowColor,$FontName,$Text);

  1019.       }

  1020. 

  1021.      $C_TextColor = $this->AllocateColor($this->Picture,$R,$G,$B,$Alpha);

  1022.      imagettftext($this->Picture,$FontSize,$Angle,$X,$Y,$C_TextColor,$FontName,$Text);

  1023. 

  1024.      $this->Shadow = $Shadow;

  1025. 

  1026.      return($TxtPos);

  1027.     }

  1028. 

  1029.    /* Draw a gradient within a defined area */

  1030.    function drawGradientArea($X1,$Y1,$X2,$Y2,$Direction,$Format="")

  1031.     {

  1032.      $StartR	= isset($Format["StartR"]) ? $Format["StartR"] : 90;

  1033.      $StartG	= isset($Format["StartG"]) ? $Format["StartG"] : 90;

  1034.      $StartB	= isset($Format["StartB"]) ? $Format["StartB"] : 90;

  1035.      $EndR	= isset($Format["EndR"]) ? $Format["EndR"] : 0;

  1036.      $EndG	= isset($Format["EndG"]) ? $Format["EndG"] : 0;

  1037.      $EndB	= isset($Format["EndB"]) ? $Format["EndB"] : 0;

  1038.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1039.      $Levels	= isset($Format["Levels"]) ? $Format["Levels"] : NULL;

  1040. 

  1041.      $Shadow = $this->Shadow;

  1042.      $this->Shadow = FALSE;

  1043. 

  1044.      if ( $StartR == $EndR && $StartG == $EndG && $StartB == $EndB )

  1045.       {

  1046.        $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,array("R"=>$StartR,"G"=>$StartG,"B"=>$StartB,"Alpha"=>$Alpha));

  1047.        return(0);

  1048.       }

  1049. 

  1050.      if ( $Levels != NULL )

  1051.       { $EndR=$StartR+$Levels; $EndG=$StartG+$Levels; $EndB=$StartB+$Levels; }

  1052. 

  1053.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }

  1054.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }

  1055. 

  1056.      if ( $Direction == DIRECTION_VERTICAL )   { $Width = abs($Y2-$Y1); }

  1057.      if ( $Direction == DIRECTION_HORIZONTAL ) { $Width = abs($X2-$X1); }

  1058. 

  1059.      $Step     = max(abs($EndR-$StartR),abs($EndG-$StartG),abs($EndB-$StartB));

  1060.      $StepSize = $Width/$Step;

  1061.      $RStep    = ($EndR-$StartR)/$Step;

  1062.      $GStep    = ($EndG-$StartG)/$Step;

  1063.      $BStep    = ($EndB-$StartB)/$Step;

  1064. 

  1065.      $R=$StartR;$G=$StartG;$B=$StartB;

  1066.      switch($Direction)

  1067.       {

  1068.        case DIRECTION_VERTICAL:

  1069.         $StartY = $Y1; $EndY = floor($Y2)+1; $LastY2 = $StartY;

  1070.         for($i=0;$i<=$Step;$i++)

  1071.          {

  1072.           $Y2 = floor($StartY + ($i * $StepSize));

  1073. 

  1074.           if ($Y2 > $EndY) { $Y2 = $EndY; }

  1075.           if (($Y1 != $Y2 && $Y1 < $Y2) || $Y2 == $EndY)

  1076.            {

  1077.             $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

  1078.             $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color);

  1079.             $LastY2 = max($LastY2,$Y2);

  1080.             $Y1 = $Y2+1;

  1081.            }

  1082.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep;

  1083.          }

  1084.         if ( $LastY2 < $EndY && isset($Color)) { for ($i=$LastY2+1;$i<=$EndY;$i++) { $this->drawLine($X1,$i,$X2,$i,$Color); } }

  1085.         break;

  1086. 

  1087.        case DIRECTION_HORIZONTAL:

  1088.         $StartX = $X1; $EndX = $X2;

  1089.         for($i=0;$i<=$Step;$i++)

  1090.          {

  1091.           $X2 = floor($StartX + ($i * $StepSize));

  1092. 

  1093.           if ($X2 > $EndX) { $X2 = $EndX; }

  1094.           if (($X1 != $X2 && $X1 < $X2) || $X2 == $EndX)

  1095.            {

  1096.             $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

  1097.             $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color);

  1098.             $X1 = $X2+1;

  1099.            }

  1100.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep; 

  1101.          }

  1102.         if ( $X2 < $EndX && isset($Color)) { $this->drawFilledRectangle($X2,$Y1,$EndX,$Y2,$Color); }

  1103.         break;

  1104.       }

  1105. 

  1106.      $this->Shadow = $Shadow;

  1107. 

  1108.     }

  1109. 

  1110.    /* Draw an aliased pixel */

  1111.    function drawAntialiasPixel($X,$Y,$Format="")

  1112.     {

  1113.      $R     = isset($Format["R"]) ? $Format["R"] : 0;

  1114.      $G     = isset($Format["G"]) ? $Format["G"] : 0;

  1115.      $B     = isset($Format["B"]) ? $Format["B"] : 0;

  1116.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1117. 

  1118.      if ( $X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize )

  1119.       return(-1);

  1120. 

  1121.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }

  1122.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }

  1123.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }

  1124. 

  1125.      if ( !$this->Antialias )

  1126.       {

  1127.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  1128.         {

  1129.          $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);

  1130.          imagesetpixel($this->Picture,$X+$this->ShadowX,$Y+$this->ShadowY,$ShadowColor);

  1131.         }

  1132. 

  1133.        $PlotColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  1134.        imagesetpixel($this->Picture,$X,$Y,$PlotColor);

  1135. 

  1136.        return(0);

  1137.       }

  1138. 

  1139.      $Plot = "";

  1140.      $Xi   = floor($X);

  1141.      $Yi   = floor($Y);

  1142. 

  1143.      if ( $Xi == $X && $Yi == $Y)

  1144.       {

  1145.        if ( $Alpha == 100 )

  1146.         $this->drawAlphaPixel($X,$Y,100,$R,$G,$B);

  1147.        else

  1148.         $this->drawAlphaPixel($X,$Y,$Alpha,$R,$G,$B);

  1149.       }

  1150.      else

  1151.       {

  1152.        $Alpha1 = (((1 - ($X - floor($X))) * (1 - ($Y - floor($Y))) * 100) / 100) * $Alpha;

  1153.        if ( $Alpha1 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi,$Yi,$Alpha1,$R,$G,$B); }

  1154. 

  1155.        $Alpha2 = ((($X - floor($X)) * (1 - ($Y - floor($Y))) * 100) / 100) * $Alpha;

  1156.        if ( $Alpha2 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi+1,$Yi,$Alpha2,$R,$G,$B); }

  1157. 

  1158.        $Alpha3 = (((1 - ($X - floor($X))) * ($Y - floor($Y)) * 100) / 100) * $Alpha;

  1159.        if ( $Alpha3 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi,$Yi+1,$Alpha3,$R,$G,$B); }

  1160. 

  1161.        $Alpha4 = ((($X - floor($X)) * ($Y - floor($Y)) * 100) / 100) * $Alpha;

  1162.        if ( $Alpha4 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi+1,$Yi+1,$Alpha4,$R,$G,$B); }

  1163.       }

  1164.     }

  1165. 

  1166.    /* Draw a semi-transparent pixel */

  1167.    function drawAlphaPixel($X,$Y,$Alpha,$R,$G,$B)

  1168.     {

  1169.      if ( isset($this->Mask[$X])) { if ( isset($this->Mask[$X][$Y]) ) { return(0); } }

  1170. 

  1171.      if ( $X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize )

  1172.       return(-1);

  1173. 

  1174.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }

  1175.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }

  1176.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }

  1177. 

  1178.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  1179.       {

  1180.        $AlphaFactor = floor(($Alpha / 100) * $this->Shadowa);

  1181.        $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$AlphaFactor);

  1182.        imagesetpixel($this->Picture,$X+$this->ShadowX,$Y+$this->ShadowY,$ShadowColor);

  1183.       }

  1184. 

  1185.      $C_Aliased = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  1186.      imagesetpixel($this->Picture,$X,$Y,$C_Aliased);

  1187.     }

  1188. 

  1189.    /* Convert apha to base 10 */

  1190.    function convertAlpha($AlphaValue)

  1191.     { return((127/100)*(100-$AlphaValue)); }

  1192. 

  1193.    /* Allocate a color with transparency */

  1194.    function allocateColor($Picture,$R,$G,$B,$Alpha=100)

  1195.     {

  1196.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }

  1197.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }

  1198.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }

  1199.      if ( $Alpha < 0 )  { $Alpha = 0; }

  1200.      if ( $Alpha > 100) { $Alpha = 100; }

  1201. 

  1202.      $Alpha = $this->convertAlpha($Alpha);

  1203.      return(imagecolorallocatealpha($Picture,$R,$G,$B,$Alpha));

  1204.     }

  1205. 

  1206.    /* Load a PNG file and draw it over the chart */

  1207.    function drawFromPNG($X,$Y,$FileName)

  1208.     { $this->drawFromPicture(1,$FileName,$X,$Y); }

  1209. 

  1210.    /* Load a GIF file and draw it over the chart */

  1211.    function drawFromGIF($X,$Y,$FileName)

  1212.     { $this->drawFromPicture(2,$FileName,$X,$Y); }

  1213. 

  1214.    /* Load a JPEG file and draw it over the chart */

  1215.    function drawFromJPG($X,$Y,$FileName)

  1216.     { $this->drawFromPicture(3,$FileName,$X,$Y); }

  1217. 

  1218.    function getPicInfo($FileName)

  1219.     {

  1220.      $Infos  = getimagesize($FileName);

  1221.      $Width  = $Infos[0];

  1222.      $Height = $Infos[1];

  1223.      $Type   = $Infos["mime"];

  1224. 

  1225.      if ( $Type == "image/png") { $Type = 1; }

  1226.      if ( $Type == "image/gif") { $Type = 2; }

  1227.      if ( $Type == "image/jpeg ") { $Type = 3; }

  1228. 

  1229.      return(array($Width,$Height,$Type));

  1230.     }

  1231. 

  1232.    /* Generic loader function for external pictures */

  1233.    function drawFromPicture($PicType,$FileName,$X,$Y)

  1234.     {

  1235.      if ( file_exists($FileName))

  1236.       {

  1237.        list($Width,$Height) = $this->getPicInfo($FileName);

  1238. 

  1239.        if ( $PicType == 1 )

  1240.         { $Raster = imagecreatefrompng($FileName); }

  1241.        elseif ( $PicType == 2 )

  1242.         { $Raster = imagecreatefromgif($FileName); }

  1243.        elseif ( $PicType == 3 )

  1244.         { $Raster = imagecreatefromjpeg($FileName); }

  1245.        else

  1246.         { return(0); }

  1247. 

  1248. 

  1249.        $RestoreShadow = $this->Shadow;

  1250.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  1251.         {

  1252.          $this->Shadow = FALSE;

  1253.          if ( $PicType == 3 )

  1254.           $this->drawFilledRectangle($X+$this->ShadowX,$Y+$this->ShadowY,$X+$Width+$this->ShadowX,$Y+$Height+$this->ShadowY,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  1255.          else

  1256.           {

  1257.            $TranparentID = imagecolortransparent($Raster);

  1258.            for ($Xc=0;$Xc<=$Width-1;$Xc++)

  1259.             {

  1260.              for ($Yc=0;$Yc<=$Height-1;$Yc++)

  1261.               {

  1262.                $RGBa   = imagecolorat($Raster,$Xc,$Yc);

  1263.                $Values = imagecolorsforindex($Raster,$RGBa);

  1264.                if ( $Values["alpha"] < 120 )

  1265.                 {

  1266.                  $AlphaFactor = floor(($this->Shadowa / 100) * ((100 / 127) * (127-$Values["alpha"])));

  1267.                  $this->drawAlphaPixel($X+$Xc+$this->ShadowX,$Y+$Yc+$this->ShadowY,$AlphaFactor,$this->ShadowR,$this->ShadowG,$this->ShadowB);

  1268.                 }

  1269.               }

  1270.             }

  1271.           }

  1272.         }

  1273.        $this->Shadow = $RestoreShadow;

  1274. 

  1275.        imagecopy($this->Picture,$Raster,$X,$Y,0,0,$Width,$Height);

  1276.        imagedestroy($Raster);

  1277.       }

  1278.     }

  1279. 

  1280.    /* Draw an arrow */

  1281.    function drawArrow($X1,$Y1,$X2,$Y2,$Format="")

  1282.     {

  1283.      $FillR	= isset($Format["FillR"]) ? $Format["FillR"] : 0;

  1284.      $FillG	= isset($Format["FillG"]) ? $Format["FillG"] : 0;

  1285.      $FillB	= isset($Format["FillB"]) ? $Format["FillB"] : 0;

  1286.      $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : $FillR;

  1287.      $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : $FillG;

  1288.      $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : $FillB;

  1289.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1290.      $Size	= isset($Format["Size"]) ? $Format["Size"] : 10;

  1291.      $Ratio	= isset($Format["Ratio"]) ? $Format["Ratio"] : .5;

  1292.      $TwoHeads	= isset($Format["TwoHeads"]) ? $Format["TwoHeads"] : FALSE;

  1293.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : FALSE;

  1294. 

  1295.      /* Calculate the line angle */

  1296.      $Angle = $this->getAngle($X1,$Y1,$X2,$Y2);

  1297. 

  1298.      /* Override Shadow support, this will be managed internally */

  1299.      $RestoreShadow = $this->Shadow;

  1300.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )

  1301.       {

  1302.        $this->Shadow = FALSE;

  1303.        $this->drawArrow($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,array("FillR"=>$this->ShadowR,"FillG"=>$this->ShadowG,"FillB"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Size"=>$Size,"Ratio"=>$Ratio,"TwoHeads"=>$TwoHeads,"Ticks"=>$Ticks));

  1304.       }

  1305. 

  1306.      /* Draw the 1st Head */

  1307.      $TailX = cos(($Angle-180)*PI/180)*$Size+$X2;

  1308.      $TailY = sin(($Angle-180)*PI/180)*$Size+$Y2;

  1309. 

  1310.      $Points	= "";

  1311.      $Points[]  = $X2; $Points[]  = $Y2;

  1312.      $Points[]	= cos(($Angle-90)*PI/180)*$Size*$Ratio+$TailX; $Points[] = sin(($Angle-90)*PI/180)*$Size*$Ratio+$TailY;

  1313.      $Points[]	= cos(($Angle-270)*PI/180)*$Size*$Ratio+$TailX; $Points[] = sin(($Angle-270)*PI/180)*$Size*$Ratio+$TailY;

  1314.      $Points[]  = $X2; $Points[]  = $Y2;

  1315. 

  1316.      /* Visual correction */

  1317.      if ($Angle == 180 || $Angle == 360 ) { $Points[4] = $Points[2]; }

  1318.      if ($Angle == 90 || $Angle == 270 ) { $Points[5] = $Points[3]; }

  1319. 

  1320.      $ArrowColor = $this->allocateColor($this->Picture,$FillR,$FillG,$FillB,$Alpha);

  1321.      ImageFilledPolygon($this->Picture,$Points,4,$ArrowColor);

  1322. 

  1323.      $this->drawLine($Points[0],$Points[1],$Points[2],$Points[3],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1324.      $this->drawLine($Points[2],$Points[3],$Points[4],$Points[5],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1325.      $this->drawLine($Points[0],$Points[1],$Points[4],$Points[5],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1326. 

  1327.      /* Draw the second head */

  1328.      if ( $TwoHeads )

  1329.       {

  1330.        $Angle = $this->getAngle($X2,$Y2,$X1,$Y1);

  1331. 

  1332.        $TailX2 = cos(($Angle-180)*PI/180)*$Size+$X1;

  1333.        $TailY2 = sin(($Angle-180)*PI/180)*$Size+$Y1;

  1334. 

  1335.        $Points   = "";

  1336.        $Points[] = $X1; $Points[]  = $Y1;

  1337.        $Points[] = cos(($Angle-90)*PI/180)*$Size*$Ratio+$TailX2; $Points[] = sin(($Angle-90)*PI/180)*$Size*$Ratio+$TailY2;

  1338.        $Points[] = cos(($Angle-270)*PI/180)*$Size*$Ratio+$TailX2; $Points[] = sin(($Angle-270)*PI/180)*$Size*$Ratio+$TailY2;

  1339.        $Points[] = $X1; $Points[]  = $Y1;

  1340. 

  1341.        /* Visual correction */

  1342.        if ($Angle == 180 || $Angle == 360 ) { $Points[4] = $Points[2]; }

  1343.        if ($Angle == 90 || $Angle == 270 ) { $Points[5] = $Points[3]; }

  1344. 

  1345.        $ArrowColor = $this->allocateColor($this->Picture,$FillR,$FillG,$FillB,$Alpha);

  1346.        ImageFilledPolygon($this->Picture,$Points,4,$ArrowColor);

  1347. 

  1348.        $this->drawLine($Points[0],$Points[1],$Points[2],$Points[3],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1349.        $this->drawLine($Points[2],$Points[3],$Points[4],$Points[5],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1350.        $this->drawLine($Points[0],$Points[1],$Points[4],$Points[5],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1351. 

  1352.        $this->drawLine($TailX,$TailY,$TailX2,$TailY2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  1353.       }

  1354.      else

  1355.       $this->drawLine($X1,$Y1,$TailX,$TailY,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  1356. 

  1357.      /* Re-enable shadows */

  1358.      $this->Shadow = $RestoreShadow;

  1359.     }

  1360. 

  1361.    /* Draw a label with associated arrow */

  1362.    function drawArrowLabel($X1,$Y1,$Text,$Format="")

  1363.     {

  1364.      $FillR    = isset($Format["FillR"]) ? $Format["FillR"] : 0;

  1365.      $FillG    = isset($Format["FillG"]) ? $Format["FillG"] : 0;

  1366.      $FillB    = isset($Format["FillB"]) ? $Format["FillB"] : 0;

  1367.      $BorderR  = isset($Format["BorderR"]) ? $Format["BorderR"] : $FillR;

  1368.      $BorderG  = isset($Format["BorderG"]) ? $Format["BorderG"] : $FillG;

  1369.      $BorderB  = isset($Format["BorderB"]) ? $Format["BorderB"] : $FillB;

  1370.      $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

  1371.      $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

  1372.      $Alpha    = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1373.      $Length   = isset($Format["Length"]) ? $Format["Length"] : 50;

  1374.      $Angle    = isset($Format["Angle"]) ? $Format["Angle"] : 315;

  1375.      $Size     = isset($Format["Size"]) ? $Format["Size"] : 10;

  1376.      $Position = isset($Format["Position"]) ? $Format["Position"] : POSITION_TOP;

  1377.      $RoundPos = isset($Format["RoundPos"]) ? $Format["RoundPos"] : FALSE;

  1378.      $Ticks    = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  1379. 

  1380.      $Angle = $Angle % 360;

  1381. 

  1382.      $X2 = sin(($Angle+180)*PI/180)*$Length+$X1;

  1383.      $Y2 = cos(($Angle+180)*PI/180)*$Length+$Y1;

  1384. 

  1385.      if ( $RoundPos && $Angle > 0 && $Angle < 180 ) { $Y2 = ceil($Y2); }

  1386.      if ( $RoundPos && $Angle > 180 ) { $Y2 = floor($Y2); }

  1387. 

  1388.      $this->drawArrow($X2,$Y2,$X1,$Y1,$Format);

  1389. 

  1390.      $Size	= imagettfbbox($FontSize,0,$FontName,$Text);

  1391.      $TxtWidth	= max(abs($Size[2]-$Size[0]),abs($Size[0]-$Size[6]));

  1392.      $TxtHeight	= max(abs($Size[1]-$Size[7]),abs($Size[3]-$Size[1]));

  1393. 

  1394.      if ( $Angle > 0 && $Angle < 180 )

  1395.       {

  1396.        $this->drawLine($X2,$Y2,$X2-$TxtWidth,$Y2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  1397.        if ( $Position == POSITION_TOP )

  1398.         $this->drawText($X2,$Y2-2,$Text,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Align"=>TEXT_ALIGN_BOTTOMRIGHT));

  1399.        else

  1400.         $this->drawText($X2,$Y2+4,$Text,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Align"=>TEXT_ALIGN_TOPRIGHT));

  1401.       }

  1402.      else

  1403.       {

  1404.        $this->drawLine($X2,$Y2,$X2+$TxtWidth,$Y2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  1405.        if ( $Position == POSITION_TOP )

  1406.         $this->drawText($X2,$Y2-2,$Text,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));

  1407.        else

  1408.         $this->drawText($X2,$Y2+4,$Text,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha,"Align"=>TEXT_ALIGN_TOPLEFT));

  1409.       }

  1410.     }

  1411. 

  1412.    /* Draw a progress bar filled with specified % */

  1413.    function drawProgress($X,$Y,$Percent,$Format="")

  1414.     {

  1415.      if ( $Percent > 100 ) { $Percent = 100; }

  1416.      if ( $Percent < 0 ) { $Percent = 0; }

  1417. 

  1418.      $Width	= isset($Format["Width"]) ? $Format["Width"] : 200;

  1419.      $Height	= isset($Format["Height"]) ? $Format["Height"] : 20;

  1420.      $Orientation = isset($Format["Orientation"]) ? $Format["Orientation"] : ORIENTATION_HORIZONTAL;

  1421.      $ShowLabel = isset($Format["ShowLabel"]) ? $Format["ShowLabel"] : FALSE;

  1422.      $LabelPos	= isset($Format["LabelPos"]) ? $Format["LabelPos"] : LABEL_POS_INSIDE;

  1423.      $Margin    = isset($Format["Margin"]) ? $Format["Margin"] : 10;

  1424.      $R		= isset($Format["R"]) ? $Format["R"] : 130;

  1425.      $G		= isset($Format["G"]) ? $Format["G"] : 130;

  1426.      $B		= isset($Format["B"]) ? $Format["B"] : 130;

  1427.      $RFade	= isset($Format["RFade"]) ? $Format["RFade"] : -1;

  1428.      $GFade	= isset($Format["GFade"]) ? $Format["GFade"] : -1;

  1429.      $BFade	= isset($Format["BFade"]) ? $Format["BFade"] : -1;

  1430.      $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

  1431.      $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

  1432.      $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

  1433.      $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 0;

  1434.      $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 0;

  1435.      $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 0;

  1436.      $BoxBackR	= isset($Format["BoxBackR"]) ? $Format["BoxBackR"] : 255;

  1437.      $BoxBackG	= isset($Format["BoxBackG"]) ? $Format["BoxBackG"] : 255;

  1438.      $BoxBackB	= isset($Format["BoxBackB"]) ? $Format["BoxBackB"] : 255;

  1439.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1440.      $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  1441.      $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : NULL;

  1442.      $NoAngle	= isset($Format["NoAngle"]) ? $Format["NoAngle"] : FALSE;

  1443. 

  1444.      if ( $RFade != -1 && $GFade != -1 && $BFade != -1 )

  1445.       {

  1446.        $RFade = (($RFade-$R)/100)*$Percent+$R;

  1447.        $GFade = (($GFade-$G)/100)*$Percent+$G;

  1448.        $BFade = (($BFade-$B)/100)*$Percent+$B;

  1449.       }

  1450. 

  1451.      if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }

  1452.      if ( $BoxSurrounding != NULL ) { $BoxBorderR = $BoxBackR + $Surrounding; $BoxBorderG = $BoxBackG + $Surrounding; $BoxBorderB = $BoxBackB + $Surrounding; }

  1453. 

  1454.      if ( $Orientation == ORIENTATION_VERTICAL )

  1455.       {

  1456.        $InnerHeight = (($Height-2)/100)*$Percent;

  1457.        $this->drawFilledRectangle($X,$Y,$X+$Width,$Y-$Height,array("R"=>$BoxBackR,"G"=>$BoxBackG,"B"=>$BoxBackB,"BorderR"=>$BoxBorderR,"BorderG"=>$BoxBorderG,"BorderB"=>$BoxBorderB,"NoAngle"=>$NoAngle));

  1458. 

  1459.        $RestoreShadow = $this->Shadow; $this->Shadow  = FALSE;

  1460.        if ( $RFade != -1 && $GFade != -1 && $BFade != -1 )

  1461.         {

  1462.          $GradientOptions = array("StartR"=>$RFade,"StartG"=>$GFade,"StartB"=>$BFade,"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);

  1463.          $this->drawGradientArea($X+1,$Y-1,$X+$Width-1,$Y-$InnerHeight,DIRECTION_VERTICAL,$GradientOptions);

  1464. 

  1465.          if ( $Surrounding )

  1466.           $this->drawRectangle($X+1,$Y-1,$X+$Width-1,$Y-$InnerHeight,array("R"=>255,"G"=>255,"B"=>255,"Alpha"=>$Surrounding));

  1467.         }

  1468.        else

  1469.         $this->drawFilledRectangle($X+1,$Y-1,$X+$Width-1,$Y-$InnerHeight,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

  1470. 

  1471.        $this->Shadow = $RestoreShadow;

  1472. 

  1473.        if ( $ShowLabel && $LabelPos == LABEL_POS_BOTTOM )	{ $this->drawText($X+($Width/2),$Y+$Margin,$Percent."%",array("Align"=>TEXT_ALIGN_TOPMIDDLE)); }

  1474.        if ( $ShowLabel && $LabelPos == LABEL_POS_TOP )		{ $this->drawText($X+($Width/2),$Y-$Height-$Margin,$Percent."%",array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE)); }

  1475.        if ( $ShowLabel && $LabelPos == LABEL_POS_INSIDE )	{ $this->drawText($X+($Width/2),$Y-$InnerHeight-$Margin,$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLELEFT,"Angle"=>90)); }

  1476.        if ( $ShowLabel && $LabelPos == LABEL_POS_CENTER )	{ $this->drawText($X+($Width/2),$Y-($Height/2),$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"Angle"=>90)); }

  1477.       }

  1478.      else

  1479.       {

  1480.        if ( $Percent == 100 )

  1481.         $InnerWidth = $Width-1;

  1482.        else

  1483.         $InnerWidth = (($Width-2)/100)*$Percent;

  1484. 

  1485.        $this->drawFilledRectangle($X,$Y,$X+$Width,$Y+$Height,array("R"=>$BoxBackR,"G"=>$BoxBackG,"B"=>$BoxBackB,"BorderR"=>$BoxBorderR,"BorderG"=>$BoxBorderG,"BorderB"=>$BoxBorderB,"NoAngle"=>$NoAngle));

  1486. 

  1487.        $RestoreShadow = $this->Shadow; $this->Shadow  = FALSE;

  1488.        if ( $RFade != -1 && $GFade != -1 && $BFade != -1 )

  1489.         {

  1490.          $GradientOptions = array("StartR"=>$R,"StartG"=>$G,"StartB"=>$B,"EndR"=>$RFade,"EndG"=>$GFade,"EndB"=>$BFade);

  1491.          $this->drawGradientArea($X+1,$Y+1,$X+$InnerWidth,$Y+$Height-1,DIRECTION_HORIZONTAL,$GradientOptions);

  1492. 

  1493.          if ( $Surrounding )

  1494.           $this->drawRectangle($X+1,$Y+1,$X+$InnerWidth,$Y+$Height-1,array("R"=>255,"G"=>255,"B"=>255,"Alpha"=>$Surrounding));

  1495.         }

  1496.        else

  1497.         $this->drawFilledRectangle($X+1,$Y+1,$X+$InnerWidth,$Y+$Height-1,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

  1498.  

  1499.        $this->Shadow = $RestoreShadow;

  1500. 

  1501.        if ( $ShowLabel && $LabelPos == LABEL_POS_LEFT )		{ $this->drawText($X-$Margin,$Y+($Height/2),$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLERIGHT)); }

  1502.        if ( $ShowLabel && $LabelPos == LABEL_POS_RIGHT )	{ $this->drawText($X+$Width+$Margin,$Y+($Height/2),$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLELEFT)); }

  1503.        if ( $ShowLabel && $LabelPos == LABEL_POS_CENTER )	{ $this->drawText($X+($Width/2),$Y+($Height/2),$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE)); }

  1504.        if ( $ShowLabel && $LabelPos == LABEL_POS_INSIDE )	{ $this->drawText($X+$InnerWidth+$Margin,$Y+($Height/2),$Percent."%",array("Align"=>TEXT_ALIGN_MIDDLELEFT)); }

  1505.       }

  1506.     }

  1507. 

  1508.    /* Get the legend box size */

  1509.    function getLegendSize($Format="")

  1510.     {

  1511.      $FontName		= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

  1512.      $FontSize		= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

  1513.      $BoxSize		= isset($Format["BoxSize"]) ? $Format["BoxSize"] : 5;

  1514.      $Margin		= isset($Format["Margin"]) ? $Format["Margin"] : 5;

  1515.      $Style		= isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;

  1516.      $Mode		= isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;

  1517.      $BoxWidth		= isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;

  1518.      $BoxHeight		= isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;

  1519.      $IconAreaWidth	= isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;

  1520.      $IconAreaHeight	= isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;

  1521.      $XSpacing		= isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;

  1522. 

  1523.      $Data = $this->DataSet->getData();

  1524. 

  1525.      foreach($Data["Series"] as $SerieName => $Serie)

  1526.       {

  1527.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && isset($Serie["Picture"]))

  1528.         {

  1529.          list($PicWidth,$PicHeight) = $this->getPicInfo($Serie["Picture"]);

  1530.          if ( $IconAreaWidth < $PicWidth ) { $IconAreaWidth = $PicWidth; }

  1531.          if ( $IconAreaHeight < $PicHeight ) { $IconAreaHeight = $PicHeight; }

  1532.         }

  1533.       }

  1534. 

  1535.      $YStep = max($this->FontSize,$IconAreaHeight) + 5;

  1536.      $XStep = $IconAreaWidth + 5;

  1537.      $XStep = $XSpacing;

  1538. 

  1539.      $X=100; $Y=100;

  1540. 

  1541.      $Boundaries = ""; $Boundaries["L"] = $X; $Boundaries["T"] = $Y; $Boundaries["R"] = 0; $Boundaries["B"] = 0; $vY = $Y; $vX = $X;

  1542.      foreach($Data["Series"] as $SerieName => $Serie)

  1543.       {

  1544.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  1545.         {

  1546.          if ( $Mode == LEGEND_VERTICAL )

  1547.           {

  1548.            $BoxArray = $this->getTextBox($vX+$IconAreaWidth+4,$vY+$IconAreaHeight/2,$FontName,$FontSize,0,$Serie["Description"]);

  1549. 

  1550.            if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

  1551.            if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

  1552.            if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

  1553. 

  1554.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1555.            $vY = $vY + max($this->FontSize*count($Lines),$IconAreaHeight) + 5;

  1556.           }

  1557.          elseif ( $Mode == LEGEND_HORIZONTAL )

  1558.           {

  1559.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1560.            $Width = "";

  1561.            foreach($Lines as $Key => $Value)

  1562.             {

  1563.              $BoxArray = $this->getTextBox($vX+$IconAreaWidth+6,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$FontName,$FontSize,0,$Value);

  1564. 

  1565.              if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

  1566.              if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

  1567.              if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

  1568. 

  1569.              $Width[] = $BoxArray[1]["X"];

  1570.             }

  1571. 

  1572.            $vX=max($Width)+$XStep;

  1573.           }

  1574.         }

  1575.       }

  1576.      $vY=$vY-$YStep; $vX=$vX-$XStep;

  1577. 

  1578.      $TopOffset  = $Y - $Boundaries["T"];

  1579.      if ( $Boundaries["B"]-($vY+$IconAreaHeight) < $TopOffset ) { $Boundaries["B"] = $vY+$IconAreaHeight+$TopOffset; }

  1580. 

  1581.      $Width  = ($Boundaries["R"]+$Margin) - ($Boundaries["L"]-$Margin);

  1582.      $Height = ($Boundaries["B"]+$Margin) - ($Boundaries["T"]-$Margin);

  1583. 

  1584.      return(array("Width"=>$Width,"Height"=>$Height));

  1585.     }

  1586. 

  1587.    /* Draw the legend of the active series */

  1588.    function drawLegend($X,$Y,$Format="")

  1589.     {

  1590.      $Family	= isset($Format["Family"]) ? $Format["Family"] : LEGEND_FAMILY_BOX;

  1591.      $FontName	= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

  1592.      $FontSize	= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

  1593.      $FontR	= isset($Format["FontR"]) ? $Format["FontR"] : $this->FontColorR;

  1594.      $FontG	= isset($Format["FontG"]) ? $Format["FontG"] : $this->FontColorG;

  1595.      $FontB	= isset($Format["FontB"]) ? $Format["FontB"] : $this->FontColorB;

  1596.      $BoxWidth	= isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;

  1597.      $BoxHeight	= isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;

  1598.      $IconAreaWidth	= isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;

  1599.      $IconAreaHeight	= isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;

  1600.      $XSpacing	= isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;

  1601.      $Margin	= isset($Format["Margin"]) ? $Format["Margin"] : 5;

  1602.      $R		= isset($Format["R"]) ? $Format["R"] : 200;

  1603.      $G		= isset($Format["G"]) ? $Format["G"] : 200;

  1604.      $B		= isset($Format["B"]) ? $Format["B"] : 200;

  1605.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  1606.      $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;

  1607.      $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;

  1608.      $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;

  1609.      $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  1610.      $Style	= isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;

  1611.      $Mode	= isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;

  1612. 

  1613.      if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }

  1614. 

  1615.      $Data = $this->DataSet->getData();

  1616. 

  1617.      foreach($Data["Series"] as $SerieName => $Serie)

  1618.       {

  1619.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && isset($Serie["Picture"]))

  1620.         {

  1621.          list($PicWidth,$PicHeight) = $this->getPicInfo($Serie["Picture"]);

  1622.          if ( $IconAreaWidth < $PicWidth ) { $IconAreaWidth = $PicWidth; }

  1623.          if ( $IconAreaHeight < $PicHeight ) { $IconAreaHeight = $PicHeight; }

  1624.         }

  1625.       }

  1626. 

  1627.      $YStep = max($this->FontSize,$IconAreaHeight) + 5;

  1628.      $XStep = $IconAreaWidth + 5;

  1629.      $XStep = $XSpacing;

  1630. 

  1631.      $Boundaries = ""; $Boundaries["L"] = $X; $Boundaries["T"] = $Y; $Boundaries["R"] = 0; $Boundaries["B"] = 0; $vY = $Y; $vX = $X;

  1632.      foreach($Data["Series"] as $SerieName => $Serie)

  1633.       {

  1634.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  1635.         {

  1636.          if ( $Mode == LEGEND_VERTICAL )

  1637.           {

  1638.            $BoxArray = $this->getTextBox($vX+$IconAreaWidth+4,$vY+$IconAreaHeight/2,$FontName,$FontSize,0,$Serie["Description"]);

  1639. 

  1640.            if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

  1641.            if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

  1642.            if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

  1643. 

  1644.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1645.            $vY = $vY + max($this->FontSize*count($Lines),$IconAreaHeight) + 5;

  1646.           }

  1647.          elseif ( $Mode == LEGEND_HORIZONTAL )

  1648.           {

  1649.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1650.            $Width = "";

  1651.            foreach($Lines as $Key => $Value)

  1652.             {

  1653.              $BoxArray = $this->getTextBox($vX+$IconAreaWidth+6,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$FontName,$FontSize,0,$Value);

  1654. 

  1655.              if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

  1656.              if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

  1657.              if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

  1658. 

  1659.              $Width[] = $BoxArray[1]["X"];

  1660.             }

  1661. 

  1662.            $vX=max($Width)+$XStep;

  1663.           }

  1664.         }

  1665.       }

  1666.      $vY=$vY-$YStep; $vX=$vX-$XStep;

  1667. 

  1668.      $TopOffset  = $Y - $Boundaries["T"];

  1669.      if ( $Boundaries["B"]-($vY+$IconAreaHeight) < $TopOffset ) { $Boundaries["B"] = $vY+$IconAreaHeight+$TopOffset; }

  1670. 

  1671.      if ( $Style == LEGEND_ROUND )

  1672.       $this->drawRoundedFilledRectangle($Boundaries["L"]-$Margin,$Boundaries["T"]-$Margin,$Boundaries["R"]+$Margin,$Boundaries["B"]+$Margin,$Margin,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

  1673.      elseif ( $Style == LEGEND_BOX )

  1674.       $this->drawFilledRectangle($Boundaries["L"]-$Margin,$Boundaries["T"]-$Margin,$Boundaries["R"]+$Margin,$Boundaries["B"]+$Margin,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

  1675. 

  1676.      $RestoreShadow = $this->Shadow; $this->Shadow = FALSE;

  1677.      foreach($Data["Series"] as $SerieName => $Serie)

  1678.       {

  1679.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  1680.         {

  1681.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"];

  1682.          $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  1683. 

  1684.          if ( isset($Serie["Picture"]) )

  1685.           {

  1686.            $Picture = $Serie["Picture"];

  1687.            list($PicWidth,$PicHeight) = $this->getPicInfo($Picture);

  1688.            $PicX = $X+$IconAreaWidth/2; $PicY = $Y+$IconAreaHeight/2; 

  1689. 

  1690.            $this->drawFromPNG($PicX-$PicWidth/2,$PicY-$PicHeight/2,$Picture);

  1691.           }

  1692.          else

  1693.           {

  1694.            if ( $Family == LEGEND_FAMILY_BOX )

  1695.             {

  1696.              if ( $BoxWidth != $IconAreaWidth ) { $XOffset = floor(($IconAreaWidth-$BoxWidth)/2); } else { $XOffset = 0; }

  1697.              if ( $BoxHeight != $IconAreaHeight ) { $YOffset = floor(($IconAreaHeight-$BoxHeight)/2); } else { $YOffset = 0; }

  1698. 

  1699.              $this->drawFilledRectangle($X+1+$XOffset,$Y+1+$YOffset,$X+$BoxWidth+$XOffset+1,$Y+$BoxHeight+1+$YOffset,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20));

  1700.              $this->drawFilledRectangle($X+$XOffset,$Y+$YOffset,$X+$BoxWidth+$XOffset,$Y+$BoxHeight+$YOffset,array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));

  1701.             }

  1702.            elseif ( $Family == LEGEND_FAMILY_CIRCLE )

  1703.             {

  1704.              $this->drawFilledCircle($X+1+$IconAreaWidth/2,$Y+1+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20));

  1705.              $this->drawFilledCircle($X+$IconAreaWidth/2,$Y+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));

  1706.             }

  1707.            elseif ( $Family == LEGEND_FAMILY_LINE )

  1708.             {

  1709.              $this->drawLine($X+1,$Y+1+$IconAreaHeight/2,$X+1+$IconAreaWidth,$Y+1+$IconAreaHeight/2,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20,"Ticks"=>$Ticks,"Weight"=>$Weight));

  1710.              $this->drawLine($X,$Y+$IconAreaHeight/2,$X+$IconAreaWidth,$Y+$IconAreaHeight/2,array("R"=>$R,"G"=>$G,"B"=>$B,"Ticks"=>$Ticks,"Weight"=>$Weight));

  1711.             }

  1712.           }

  1713. 

  1714.          if ( $Mode == LEGEND_VERTICAL )

  1715.           {

  1716.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1717.            foreach($Lines as $Key => $Value)

  1718.             $this->drawText($X+$IconAreaWidth+4,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontSize"=>$FontSize,"FontName"=>$FontName));

  1719. 

  1720.            $Y=$Y+max($this->FontSize*count($Lines),$IconAreaHeight) + 5;

  1721.           }

  1722.          elseif ( $Mode == LEGEND_HORIZONTAL )

  1723.           {

  1724.            $Lines = preg_split("/\n/",$Serie["Description"]);

  1725.            $Width = "";

  1726.            foreach($Lines as $Key => $Value)

  1727.             {

  1728.              $BoxArray = $this->drawText($X+$IconAreaWidth+4,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontSize"=>$FontSize,"FontName"=>$FontName));

  1729.              $Width[] = $BoxArray[1]["X"];

  1730.             }

  1731.            $X=max($Width)+2+$XStep;

  1732.           }

  1733.         }

  1734.       }

  1735. 

  1736. 

  1737.      $this->Shadow = $RestoreShadow;

  1738.     }

  1739. 

  1740.    function drawScale($Format="")

  1741.     {

  1742.      $Pos		= isset($Format["Pos"]) ? $Format["Pos"] : SCALE_POS_LEFTRIGHT;

  1743.      $Floating		= isset($Format["Floating"]) ? $Format["Floating"] : FALSE;

  1744.      $Mode		= isset($Format["Mode"]) ? $Format["Mode"] : SCALE_MODE_FLOATING;

  1745.      $RemoveXAxis	= isset($Format["RemoveXAxis"]) ? $Format["RemoveXAxis"] : FALSE;

  1746.      $MinDivHeight	= isset($Format["MinDivHeight"]) ? $Format["MinDivHeight"] : 20;

  1747.      $Factors		= isset($Format["Factors"]) ? $Format["Factors"] : array(1,2,5);

  1748.      $ManualScale	= isset($Format["ManualScale"]) ? $Format["ManualScale"] : array("0"=>array("Min"=>-100,"Max"=>100));

  1749.      $XMargin		= isset($Format["XMargin"]) ? $Format["XMargin"] : AUTO;

  1750.      $YMargin		= isset($Format["YMargin"]) ? $Format["YMargin"] : 0;

  1751.      $ScaleSpacing	= isset($Format["ScaleSpacing"]) ? $Format["ScaleSpacing"] : 15;

  1752.      $InnerTickWidth	= isset($Format["InnerTickWidth"]) ? $Format["InnerTickWidth"] : 2;

  1753.      $OuterTickWidth	= isset($Format["OuterTickWidth"]) ? $Format["OuterTickWidth"] : 2;

  1754.      $DrawXLines	= isset($Format["DrawXLines"]) ? $Format["DrawXLines"] : TRUE;

  1755.      $DrawYLines	= isset($Format["DrawYLines"]) ? $Format["DrawYLines"] : ALL;

  1756.      $GridTicks		= isset($Format["GridTicks"]) ? $Format["GridTicks"] : 4;

  1757.      $GridR		= isset($Format["GridR"]) ? $Format["GridR"] : 255;

  1758.      $GridG		= isset($Format["GridG"]) ? $Format["GridG"] : 255;

  1759.      $GridB		= isset($Format["GridB"]) ? $Format["GridB"] : 255;

  1760.      $GridAlpha		= isset($Format["GridAlpha"]) ? $Format["GridAlpha"] : 40;

  1761.      $AxisRo		= isset($Format["AxisR"]) ? $Format["AxisR"] : 0;

  1762.      $AxisGo		= isset($Format["AxisG"]) ? $Format["AxisG"] : 0;

  1763.      $AxisBo		= isset($Format["AxisB"]) ? $Format["AxisB"] : 0;

  1764.      $AxisAlpha		= isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 100;

  1765.      $TickRo		= isset($Format["TickR"]) ? $Format["TickR"] : 0;

  1766.      $TickGo		= isset($Format["TickG"]) ? $Format["TickG"] : 0;

  1767.      $TickBo		= isset($Format["TickB"]) ? $Format["TickB"] : 0;

  1768.      $TickAlpha		= isset($Format["TickAlpha"]) ? $Format["TickAlpha"] : 100;

  1769.      $DrawSubTicks	= isset($Format["DrawSubTicks"]) ? $Format["DrawSubTicks"] : FALSE;

  1770.      $InnerSubTickWidth	= isset($Format["InnerSubTickWidth"]) ? $Format["InnerSubTickWidth"] : 0;

  1771.      $OuterSubTickWidth	= isset($Format["OuterSubTickWidth"]) ? $Format["OuterSubTickWidth"] : 2;

  1772.      $SubTickR		= isset($Format["SubTickR"]) ? $Format["SubTickR"] : 255;

  1773.      $SubTickG		= isset($Format["SubTickG"]) ? $Format["SubTickG"] : 0;

  1774.      $SubTickB		= isset($Format["SubTickB"]) ? $Format["SubTickB"] : 0;

  1775.      $SubTickAlpha	= isset($Format["SubTickAlpha"]) ? $Format["SubTickAlpha"] : 100;

  1776.      $AutoAxisLabels	= isset($Format["AutoAxisLabels"]) ? $Format["AutoAxisLabels"] : TRUE;

  1777.      $XReleasePercent	= isset($Format["XReleasePercent"]) ? $Format["XReleasePercent"] : 1;

  1778.      $DrawArrows	= isset($Format["DrawArrows"]) ? $Format["DrawArrows"] : FALSE;

  1779.      $ArrowSize         = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 8;

  1780.      $CycleBackground	= isset($Format["CycleBackground"]) ? $Format["CycleBackground"] : FALSE;

  1781.      $BackgroundR1	= isset($Format["BackgroundR1"]) ? $Format["BackgroundR1"] : 255;

  1782.      $BackgroundG1	= isset($Format["BackgroundG1"]) ? $Format["BackgroundG1"] : 255;

  1783.      $BackgroundB1	= isset($Format["BackgroundB1"]) ? $Format["BackgroundB1"] : 255;

  1784.      $BackgroundAlpha1	= isset($Format["BackgroundAlpha1"]) ? $Format["BackgroundAlpha1"] : 20;

  1785.      $BackgroundR2	= isset($Format["BackgroundR2"]) ? $Format["BackgroundR2"] : 230;

  1786.      $BackgroundG2	= isset($Format["BackgroundG2"]) ? $Format["BackgroundG2"] : 230;

  1787.      $BackgroundB2	= isset($Format["BackgroundB2"]) ? $Format["BackgroundB2"] : 230;

  1788.      $BackgroundAlpha2	= isset($Format["BackgroundAlpha2"]) ? $Format["BackgroundAlpha2"] : 20;

  1789.      $LabelingMethod	= isset($Format["LabelingMethod"]) ? $Format["LabelingMethod"] : LABELING_ALL;

  1790.      $LabelSkip		= isset($Format["LabelSkip"]) ? $Format["LabelSkip"] : 0;

  1791.      $LabelRotation	= isset($Format["LabelRotation"]) ? $Format["LabelRotation"] : 0;

  1792.      $RemoveSkippedAxis	= isset($Format["RemoveSkippedAxis"]) ? $Format["RemoveSkippedAxis"] : FALSE;

  1793.      $SkippedAxisTicks	= isset($Format["SkippedAxisTicks"]) ? $Format["SkippedAxisTicks"] : $GridTicks+2;

  1794.      $SkippedAxisR	= isset($Format["SkippedAxisR"]) ? $Format["SkippedAxisR"] : $GridR;

  1795.      $SkippedAxisG	= isset($Format["SkippedAxisG"]) ? $Format["SkippedAxisG"] : $GridG;

  1796.      $SkippedAxisB	= isset($Format["SkippedAxisB"]) ? $Format["SkippedAxisB"] : $GridB;

  1797.      $SkippedAxisAlpha	= isset($Format["SkippedAxisAlpha"]) ? $Format["SkippedAxisAlpha"] : $GridAlpha-30;

  1798.      $SkippedTickR	= isset($Format["SkippedTickR"]) ? $Format["SkippedTickR"] : $TickRo;

  1799.      $SkippedTickG	= isset($Format["SkippedTickG"]) ? $Format["SkippedTickG"] : $TickGo;

  1800.      $SkippedTickB	= isset($Format["SkippedTicksB"]) ? $Format["SkippedTickB"] : $TickBo;

  1801.      $SkippedTickAlpha	= isset($Format["SkippedTickAlpha"]) ? $Format["SkippedTickAlpha"] : $TickAlpha-80;

  1802.      $SkippedInnerTickWidth	= isset($Format["SkippedInnerTickWidth"]) ? $Format["SkippedInnerTickWidth"] : 0;

  1803.      $SkippedOuterTickWidth	= isset($Format["SkippedOuterTickWidth"]) ? $Format["SkippedOuterTickWidth"] : 2;

  1804. 

  1805.      /* Floating scale require X & Y margins to be set manually */

  1806.      if ( $Floating && ( $XMargin == AUTO || $YMargin == 0 ) ) { $Floating = FALSE; }

  1807. 

  1808.      /* Skip a NOTICE event in case of an empty array */

  1809.      if ( $DrawYLines == NONE || $DrawYLines == FALSE ) { $DrawYLines = array("zarma"=>"31"); }

  1810. 

  1811.      /* Define the color for the skipped elements */

  1812.      $SkippedAxisColor = array("R"=>$SkippedAxisR,"G"=>$SkippedAxisG,"B"=>$SkippedAxisB,"Alpha"=>$SkippedAxisAlpha,"Ticks"=>$SkippedAxisTicks);

  1813.      $SkippedTickColor = array("R"=>$SkippedTickR,"G"=>$SkippedTickG,"B"=>$SkippedTickB,"Alpha"=>$SkippedTickAlpha);

  1814. 

  1815.      $Data = $this->DataSet->getData();

  1816.      if ( isset($Data["Abscissa"]) ) { $Abscissa = $Data["Abscissa"]; } else { $Abscissa = NULL; }

  1817. 

  1818.      /* Unset the abscissa axis, needed if we display multiple charts on the same picture */

  1819.      if ( $Abscissa != NULL )

  1820.       {

  1821.        foreach($Data["Axis"] as $AxisID => $Parameters)

  1822.         { if ($Parameters["Identity"] == AXIS_X) { unset($Data["Axis"][$AxisID]); } }

  1823.       }

  1824. 

  1825.      /* Build the scale settings */

  1826.      $GotXAxis = FALSE;

  1827.      foreach($Data["Axis"] as $AxisID => $AxisParameter)

  1828.       {

  1829.        if ( $AxisParameter["Identity"] == AXIS_X ) { $GotXAxis = TRUE; }

  1830. 

  1831.        if ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_Y)

  1832.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1 - $YMargin*2; }

  1833.        elseif ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_X)

  1834.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }

  1835.        elseif ( $Pos == SCALE_POS_TOPBOTTOM && $AxisParameter["Identity"] == AXIS_Y)

  1836.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1 - $YMargin*2;; }

  1837.        else

  1838.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }

  1839. 

  1840.        $AxisMin = ABSOLUTE_MAX; $AxisMax = OUT_OF_SIGHT;

  1841.        if ( $Mode == SCALE_MODE_FLOATING || $Mode == SCALE_MODE_START0 )

  1842.         {

  1843.          foreach($Data["Series"] as $SerieID => $SerieParameter)

  1844.           {

  1845.            if ( $SerieParameter["Axis"] == $AxisID && $Data["Series"][$SerieID]["isDrawable"] && $Data["Abscissa"] != $SerieID)

  1846.             {

  1847.              $AxisMax = max($AxisMax,$Data["Series"][$SerieID]["Max"]);

  1848.              $AxisMin = min($AxisMin,$Data["Series"][$SerieID]["Min"]);

  1849.             }

  1850.           }

  1851.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;

  1852. 

  1853.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;

  1854.          if ( $Mode == SCALE_MODE_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; }

  1855.         }

  1856.        elseif ( $Mode == SCALE_MODE_MANUAL )

  1857.         {

  1858.          if ( isset($ManualScale[$AxisID]["Min"]) && isset($ManualScale[$AxisID]["Max"]) )

  1859.           {

  1860.            $Data["Axis"][$AxisID]["Min"] = $ManualScale[$AxisID]["Min"];

  1861.            $Data["Axis"][$AxisID]["Max"] = $ManualScale[$AxisID]["Max"];

  1862.           }

  1863.          else

  1864.           { echo "Manual scale boundaries not set."; exit(); }

  1865.         }

  1866.        elseif ( $Mode == SCALE_MODE_ADDALL || $Mode == SCALE_MODE_ADDALL_START0 )

  1867.         {

  1868.          $Series = "";

  1869.          foreach($Data["Series"] as $SerieID => $SerieParameter)

  1870.           { if ( $SerieParameter["Axis"] == $AxisID && $SerieParameter["isDrawable"] && $Data["Abscissa"] != $SerieID ) { $Series[$SerieID] = count($Data["Series"][$SerieID]["Data"]); } }

  1871. 

  1872.          for ($ID=0;$ID<=max($Series)-1;$ID++)

  1873.           {

  1874.            $PointMin = 0; $PointMax = 0;

  1875.            foreach($Series as $SerieID => $ValuesCount )

  1876.             {

  1877.              if (isset($Data["Series"][$SerieID]["Data"][$ID]) && $Data["Series"][$SerieID]["Data"][$ID] != NULL )

  1878.               {

  1879.                $Value = $Data["Series"][$SerieID]["Data"][$ID];

  1880.                if ( $Value > 0 ) { $PointMax = $PointMax + $Value; } else { $PointMin = $PointMin + $Value; }

  1881.               }

  1882.             }

  1883.            $AxisMax = max($AxisMax,$PointMax);

  1884.            $AxisMin = min($AxisMin,$PointMin);

  1885.           }

  1886.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;

  1887.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;

  1888.         }

  1889.        $MaxDivs = floor($Height/$MinDivHeight);

  1890. 

  1891.        if ( $Mode == SCALE_MODE_ADDALL_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; }

  1892. 

  1893.        $Scale   = $this->computeScale($Data["Axis"][$AxisID]["Min"],$Data["Axis"][$AxisID]["Max"],$MaxDivs,$Factors,$AxisID);

  1894. 

  1895.        $Data["Axis"][$AxisID]["Margin"]    = $AxisParameter["Identity"] == AXIS_X ? $XMargin : $YMargin;

  1896.        $Data["Axis"][$AxisID]["ScaleMin"]  = $Scale["XMin"];

  1897.        $Data["Axis"][$AxisID]["ScaleMax"]  = $Scale["XMax"];

  1898.        $Data["Axis"][$AxisID]["Rows"]      = $Scale["Rows"];

  1899.        $Data["Axis"][$AxisID]["RowHeight"] = $Scale["RowHeight"];

  1900. 

  1901.        if ( isset($Scale["Format"]) ) { $Data["Axis"][$AxisID]["Format"] = $Scale["Format"]; }

  1902. 

  1903.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }

  1904.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }

  1905.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }

  1906.       }

  1907. 

  1908.      /* Still no X axis */

  1909.      if ( $GotXAxis == FALSE )

  1910.       {

  1911.        if ( $Abscissa != NULL )

  1912.         {

  1913.          $Points = count($Data["Series"][$Abscissa]["Data"]);

  1914.          if ( $AutoAxisLabels )

  1915.           $AxisName = isset($Data["Series"][$Abscissa]["Description"]) ? $Data["Series"][$Abscissa]["Description"] : NULL;

  1916.          else

  1917.           $AxisName = NULL;

  1918.         }

  1919.        else

  1920.         {

  1921.          $Points = 0;

  1922.          $AxisName = isset($Data["XAxisName"]) ? $Data["XAxisName"] : NULL;

  1923.          foreach($Data["Series"] as $SerieID => $SerieParameter)

  1924.           { if ( $SerieParameter["isDrawable"] ) { $Points = max($Points,count($SerieParameter["Data"])); } }

  1925.         }

  1926. 

  1927.        $AxisID = count($Data["Axis"]);

  1928.        $Data["Axis"][$AxisID]["Identity"] = AXIS_X;

  1929.        if ( $Pos == SCALE_POS_LEFTRIGHT ) { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_BOTTOM; } else { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_LEFT; }

  1930.        if ( isset($Data["AbscissaName"]) ) { $Data["Axis"][$AxisID]["Name"] = $Data["AbscissaName"]; }

  1931.        if ( $XMargin == AUTO )

  1932.         {

  1933.          if ( $Pos == SCALE_POS_LEFTRIGHT )

  1934.           { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }

  1935.          else

  1936.           { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }

  1937. 

  1938.          if ( $Points == 1 )

  1939.           $Data["Axis"][$AxisID]["Margin"] = $Height / 2;

  1940.          else

  1941.           $Data["Axis"][$AxisID]["Margin"] = ($Height/$Points) / 2;

  1942.         }

  1943.        else

  1944.         { $Data["Axis"][$AxisID]["Margin"] = $XMargin; }

  1945.        $Data["Axis"][$AxisID]["Rows"] = $Points-1;

  1946.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }

  1947.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }

  1948.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }

  1949.       }

  1950. 

  1951.      /* Do we need to reverse the abscissa position? */

  1952.      if ( $Pos != SCALE_POS_LEFTRIGHT )

  1953.       {

  1954.        if ( $Data["AbsicssaPosition"] == AXIS_POSITION_BOTTOM )

  1955.         { $Data["AbsicssaPosition"] = AXIS_POSITION_LEFT; }

  1956.        else

  1957.         { $Data["AbsicssaPosition"] = AXIS_POSITION_RIGHT; }

  1958.       }

  1959.      $Data["Axis"][$AxisID]["Position"] = $Data["AbsicssaPosition"];

  1960. 

  1961.      $this->DataSet->saveOrientation($Pos);

  1962.      $this->DataSet->saveAxisConfig($Data["Axis"]);

  1963.      $this->DataSet->saveYMargin($YMargin);

  1964. 

  1965.      $FontColorRo = $this->FontColorR; $FontColorGo = $this->FontColorG; $FontColorBo = $this->FontColorB;

  1966. 

  1967.      $AxisPos["L"] = $this->GraphAreaX1; $AxisPos["R"] = $this->GraphAreaX2; $AxisPos["T"] = $this->GraphAreaY1; $AxisPos["B"] = $this->GraphAreaY2;

  1968.      foreach($Data["Axis"] as $AxisID => $Parameters)

  1969.       {

  1970.        if ( isset($Parameters["Color"]) )

  1971.         {

  1972.          $AxisR = $Parameters["Color"]["R"]; $AxisG = $Parameters["Color"]["G"]; $AxisB = $Parameters["Color"]["B"];

  1973.          $TickR = $Parameters["Color"]["R"]; $TickG = $Parameters["Color"]["G"]; $TickB = $Parameters["Color"]["B"];

  1974.          $this->setFontProperties(array("R"=>$Parameters["Color"]["R"],"G"=>$Parameters["Color"]["G"],"B"=>$Parameters["Color"]["B"]));

  1975.         }

  1976.        else

  1977.         {

  1978.          $AxisR = $AxisRo; $AxisG = $AxisGo; $AxisB = $AxisBo;

  1979.          $TickR = $TickRo; $TickG = $TickGo; $TickB = $TickBo;

  1980.          $this->setFontProperties(array("R"=>$FontColorRo,"G"=>$FontColorGo,"B"=>$FontColorBo));

  1981.         }

  1982. 

  1983.        $LastValue = "w00t"; $ID = 1;

  1984.        if ( $Parameters["Identity"] == AXIS_X )

  1985.         {

  1986.          if ( $Pos == SCALE_POS_LEFTRIGHT )

  1987.           {

  1988.            if ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )

  1989.             {

  1990.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 2; }

  1991.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }

  1992.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 5; }

  1993.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }

  1994. 

  1995.              if ( !$RemoveXAxis )

  1996.               {

  1997.                if ( $Floating )

  1998.                 { $FloatingOffset = $YMargin; $this->drawLine($this->GraphAreaX1+$Parameters["Margin"],$AxisPos["B"],$this->GraphAreaX2-$Parameters["Margin"],$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  1999.                else

  2000.                 { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2001. 

  2002.                if ( $DrawArrows ) { $this->drawArrow($this->GraphAreaX2-$Parameters["Margin"],$AxisPos["B"],$this->GraphAreaX2+($ArrowSize*2),$AxisPos["B"],array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2003.               }

  2004. 

  2005.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

  2006. 

  2007.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / ($Parameters["Rows"]); }

  2008.              

  2009.              $MaxBottom = $AxisPos["B"];

  2010.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2011.               {

  2012.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

  2013.                $YPos  = $AxisPos["B"];

  2014. 

  2015.                if ( $Abscissa != NULL )

  2016.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

  2017.                else

  2018.                 {

  2019.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

  2020.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

  2021.                  else

  2022.                   $Value = $i;

  2023.                 }

  2024. 

  2025.                $ID++; $Skipped = TRUE;

  2026.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

  2027.                 {

  2028.                  $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

  2029.                  $TxtBottom = $YPos+$OuterTickWidth+2+($Bounds[0]["Y"]-$Bounds[2]["Y"]);

  2030.                  $MaxBottom = max($MaxBottom,$TxtBottom);

  2031.                  $LastValue = $Value;

  2032.                  $Skipped   = FALSE;

  2033.                 }

  2034. 

  2035.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

  2036. 

  2037.                if ( $Skipped )

  2038.                 {

  2039.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }

  2040.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) { $this->drawLine($XPos,$YPos-$SkippedInnerTickWidth,$XPos,$YPos+$SkippedOuterTickWidth,$SkippedTickColor); }

  2041.                 }

  2042.                else

  2043.                 {

  2044.                  if ( $DrawXLines && ($XPos != $this->GraphAreaX1 && $XPos != $this->GraphAreaX2) ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2045.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos,$YPos-$InnerTickWidth,$XPos,$YPos+$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

  2046.                 }

  2047.               }

  2048. 

  2049.              if ( isset($Parameters["Name"]) && !$RemoveXAxis)

  2050.               {

  2051.                $YPos   = $MaxBottom+2;

  2052.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

  2053.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));

  2054.                $MaxBottom = $Bounds[0]["Y"];

  2055. 

  2056.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;

  2057.               }

  2058. 

  2059.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;

  2060.             }

  2061.            elseif ( $Parameters["Position"] == AXIS_POSITION_TOP )

  2062.             {

  2063.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 2; }

  2064.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }

  2065.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 5; }

  2066.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }

  2067. 

  2068.              if ( !$RemoveXAxis )

  2069.               {

  2070.                if ( $Floating )

  2071.                 { $FloatingOffset = $YMargin; $this->drawLine($this->GraphAreaX1+$Parameters["Margin"],$AxisPos["T"],$this->GraphAreaX2-$Parameters["Margin"],$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2072.                else

  2073.                 { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2074. 

  2075.                if ( $DrawArrows ) { $this->drawArrow($this->GraphAreaX2-$Parameters["Margin"],$AxisPos["T"],$this->GraphAreaX2+($ArrowSize*2),$AxisPos["T"],array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2076.               }

  2077. 

  2078.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

  2079. 

  2080.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / $Parameters["Rows"]; }

  2081.              

  2082.              $MinTop = $AxisPos["T"];

  2083.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2084.               {

  2085.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

  2086.                $YPos  = $AxisPos["T"];

  2087. 

  2088.                if ( $Abscissa != NULL )

  2089.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

  2090.                else

  2091.                 {

  2092.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

  2093.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

  2094.                  else

  2095.                   $Value = $i;

  2096.                 }

  2097. 

  2098.                $ID++; $Skipped = TRUE;

  2099.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

  2100.                 {

  2101.                  $Bounds = $this->drawText($XPos,$YPos-$OuterTickWidth-$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

  2102.                  $TxtBox = $YPos-$OuterTickWidth-2-($Bounds[0]["Y"]-$Bounds[2]["Y"]);

  2103.                  $MinTop = min($MinTop,$TxtBox);

  2104.                  $LastValue = $Value;

  2105.                  $Skipped   = FALSE;

  2106.                 }

  2107. 

  2108.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

  2109. 

  2110.                if ( $Skipped )

  2111.                 {

  2112.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }

  2113.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$YPos+$SkippedInnerTickWidth,$XPos,$YPos-$SkippedOuterTickWidth,$SkippedTickColor); }

  2114.                 }

  2115.                else

  2116.                 {

  2117.                  if ( $DrawXLines ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2118.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos,$YPos+$InnerTickWidth,$XPos,$YPos-$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

  2119.                 }

  2120. 

  2121.               }

  2122. 

  2123.              if ( isset($Parameters["Name"]) && !$RemoveXAxis )

  2124.               {

  2125.                $YPos   = $MinTop-2;

  2126.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

  2127.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  2128.                $MinTop = $Bounds[2]["Y"];

  2129. 

  2130.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;

  2131.               }

  2132. 

  2133.              $AxisPos["T"] = $MinTop - $ScaleSpacing;

  2134.             }

  2135.           }

  2136.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )

  2137.           {

  2138.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )

  2139.             {

  2140.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -2; }

  2141.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -6; }

  2142.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -2; }

  2143.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -5; }

  2144. 

  2145.              if ( !$RemoveXAxis )

  2146.               {

  2147.                if ( $Floating )

  2148.                 { $FloatingOffset = $YMargin; $this->drawLine($AxisPos["L"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["L"],$this->GraphAreaY2-$Parameters["Margin"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2149.                else

  2150.                 { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2151. 

  2152.                if ( $DrawArrows ) { $this->drawArrow($AxisPos["L"],$this->GraphAreaY2-$Parameters["Margin"],$AxisPos["L"],$this->GraphAreaY2+($ArrowSize*2),array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2153.               }

  2154. 

  2155.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

  2156. 

  2157.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }

  2158. 

  2159.              $MinLeft = $AxisPos["L"];

  2160.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2161.               {

  2162.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;

  2163.                $XPos  = $AxisPos["L"];

  2164. 

  2165.                if ( $Abscissa != NULL )

  2166.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

  2167.                else

  2168.                 {

  2169.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

  2170.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

  2171.                  else

  2172.                   $Value = $i;

  2173.                 }

  2174. 

  2175.                $ID++; $Skipped = TRUE;

  2176.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

  2177.                 {

  2178.                  $Bounds  = $this->drawText($XPos-$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

  2179.                  $TxtBox  = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);

  2180.                  $MinLeft = min($MinLeft,$TxtBox);

  2181.                  $LastValue = $Value;

  2182.                  $Skipped   = FALSE;

  2183.                 }

  2184. 

  2185.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

  2186. 

  2187.                if ( $Skipped )

  2188.                 {

  2189.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }

  2190.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos-$SkippedOuterTickWidth,$YPos,$XPos+$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }

  2191.                 }

  2192.                else

  2193.                 {

  2194.                  if ( $DrawXLines && ($YPos != $this->GraphAreaY1 && $YPos != $this->GraphAreaY2) ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2195.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

  2196.                 }

  2197. 

  2198.               }

  2199.              if ( isset($Parameters["Name"]) && !$RemoveXAxis )

  2200.               {

  2201.                $XPos   = $MinLeft-2;

  2202.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

  2203.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));

  2204.                $MinLeft = $Bounds[0]["X"];

  2205. 

  2206.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;

  2207.               }

  2208. 

  2209.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;

  2210.             }

  2211.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )

  2212.             {

  2213.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 2; }

  2214.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 6; }

  2215.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 5; }

  2216.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 7; }

  2217. 

  2218.              if ( !$RemoveXAxis )

  2219.               {

  2220.                if ( $Floating )

  2221.                 { $FloatingOffset = $YMargin; $this->drawLine($AxisPos["R"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["R"],$this->GraphAreaY2-$Parameters["Margin"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2222.                else

  2223.                 { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2224. 

  2225.                if ( $DrawArrows ) { $this->drawArrow($AxisPos["R"],$this->GraphAreaY2-$Parameters["Margin"],$AxisPos["R"],$this->GraphAreaY2+($ArrowSize*2),array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2226.               }

  2227. 

  2228.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

  2229. 

  2230.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }

  2231.              

  2232.              $MaxRight = $AxisPos["R"];

  2233.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2234.               {

  2235.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;

  2236.                $XPos  = $AxisPos["R"];

  2237. 

  2238.                if ( $Abscissa != NULL )

  2239.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

  2240.                else

  2241.                 {

  2242.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

  2243.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

  2244.                  else

  2245.                   $Value = $i;

  2246.                 }

  2247. 

  2248.                $ID++; $Skipped = TRUE;

  2249.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

  2250.                 {

  2251.                  $Bounds   = $this->drawText($XPos+$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

  2252.                  $TxtBox   = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);

  2253.                  $MaxRight = max($MaxRight,$TxtBox);

  2254.                  $LastValue = $Value;

  2255.                  $Skipped   = FALSE;

  2256.                 }

  2257. 

  2258.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

  2259. 

  2260.                if ( $Skipped )

  2261.                 {

  2262.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }

  2263.                  if ( ($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos+$SkippedOuterTickWidth,$YPos,$XPos-$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }

  2264.                 }

  2265.                else

  2266.                 {

  2267.                  if ( $DrawXLines ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2268.                  if ( ($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos+$OuterTickWidth,$YPos,$XPos-$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

  2269.                 }

  2270. 

  2271.               }

  2272. 

  2273.              if ( isset($Parameters["Name"]) && !$RemoveXAxis)

  2274.               {

  2275.                $XPos   = $MaxRight+4;

  2276.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

  2277.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));

  2278.                $MaxRight = $Bounds[1]["X"];

  2279. 

  2280.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxRight + $this->FontSize;

  2281.               }

  2282. 

  2283.              $AxisPos["R"] = $MaxRight + $ScaleSpacing;

  2284.             }

  2285.           }

  2286.         }

  2287. 

  2288. 

  2289. 

  2290.        if ( $Parameters["Identity"] == AXIS_Y )

  2291.         {

  2292.          if ( $Pos == SCALE_POS_LEFTRIGHT )

  2293.           {

  2294.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )

  2295.             {

  2296. 

  2297.              if ( $Floating )

  2298.               { $FloatingOffset = $XMargin; $this->drawLine($AxisPos["L"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["L"],$this->GraphAreaY2-$Parameters["Margin"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2299.              else

  2300.               { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2301. 

  2302.              if ( $DrawArrows ) { $this->drawArrow($AxisPos["L"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["L"],$this->GraphAreaY1-($ArrowSize*2),array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2303. 

  2304.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

  2305.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinLeft = $AxisPos["L"];

  2306.              $LastY  = NULL;

  2307.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2308.               {

  2309.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;

  2310.                $XPos  = $AxisPos["L"];

  2311.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

  2312. 

  2313.                if ( $i%2 == 1 ) { $BGColor = array("R"=>$BackgroundR1,"G"=>$BackgroundG1,"B"=>$BackgroundB1,"Alpha"=>$BackgroundAlpha1); } else { $BGColor = array("R"=>$BackgroundR2,"G"=>$BackgroundG2,"B"=>$BackgroundB2,"Alpha"=>$BackgroundAlpha2); }

  2314.                if ( $LastY != NULL && $CycleBackground && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }

  2315. 

  2316.                if ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2317. 

  2318.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

  2319.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

  2320. 

  2321.                $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

  2322.                $Bounds  = $this->drawText($XPos-$OuterTickWidth-2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));

  2323.                $TxtLeft = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);

  2324.                $MinLeft = min($MinLeft,$TxtLeft);

  2325. 

  2326.                $LastY = $YPos;

  2327.               }

  2328. 

  2329.              if ( isset($Parameters["Name"]) )

  2330.               {

  2331.                $XPos    = $MinLeft-2;

  2332.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

  2333.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));

  2334.                $MinLeft = $Bounds[2]["X"];

  2335. 

  2336.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;

  2337.               }

  2338. 

  2339.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;

  2340.             }

  2341.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )

  2342.             {

  2343.              if ( $Floating )

  2344.               { $FloatingOffset = $XMargin; $this->drawLine($AxisPos["R"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["R"],$this->GraphAreaY2-$Parameters["Margin"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2345.              else

  2346.               { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2347. 

  2348.              if ( $DrawArrows ) { $this->drawArrow($AxisPos["R"],$this->GraphAreaY1+$Parameters["Margin"],$AxisPos["R"],$this->GraphAreaY1-($ArrowSize*2),array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2349. 

  2350.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

  2351.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxLeft = $AxisPos["R"];

  2352.              $LastY  = NULL;

  2353.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2354.               {

  2355.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;

  2356.                $XPos  = $AxisPos["R"];

  2357.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

  2358. 

  2359.                if ( $i%2 == 1 ) { $BGColor = array("R"=>$BackgroundR1,"G"=>$BackgroundG1,"B"=>$BackgroundB1,"Alpha"=>$BackgroundAlpha1); } else { $BGColor = array("R"=>$BackgroundR2,"G"=>$BackgroundG2,"B"=>$BackgroundB2,"Alpha"=>$BackgroundAlpha2); }

  2360.                if ( $LastY != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }

  2361. 

  2362.                if ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2363. 

  2364.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

  2365.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

  2366. 

  2367.                $this->drawLine($XPos-$InnerTickWidth,$YPos,$XPos+$OuterTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

  2368.                $Bounds  = $this->drawText($XPos+$OuterTickWidth+2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLELEFT));

  2369.                $TxtLeft = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);

  2370.                $MaxLeft = max($MaxLeft,$TxtLeft);

  2371. 

  2372.                $LastY = $YPos;

  2373.               }

  2374. 

  2375.              if ( isset($Parameters["Name"]) )

  2376.               {

  2377.                $XPos    = $MaxLeft+6;

  2378.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

  2379.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));

  2380.                $MaxLeft = $Bounds[2]["X"];

  2381. 

  2382.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxLeft + $this->FontSize;

  2383.               }

  2384.              $AxisPos["R"] = $MaxLeft + $ScaleSpacing;

  2385.             }

  2386.           }

  2387.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )

  2388.           {

  2389.            if ( $Parameters["Position"] == AXIS_POSITION_TOP )

  2390.             {

  2391.              if ( $Floating )

  2392.               { $FloatingOffset = $XMargin; $this->drawLine($this->GraphAreaX1+$Parameters["Margin"],$AxisPos["T"],$this->GraphAreaX2-$Parameters["Margin"],$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2393.              else

  2394.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2395. 

  2396.              if ( $DrawArrows ) { $this->drawArrow($this->GraphAreaX2-$Parameters["Margin"],$AxisPos["T"],$this->GraphAreaX2+($ArrowSize*2),$AxisPos["T"],array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2397. 

  2398.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

  2399.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinTop = $AxisPos["T"];

  2400.              $LastX  = NULL;

  2401.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2402.               {

  2403.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

  2404.                $YPos  = $AxisPos["T"];

  2405.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

  2406. 

  2407.                if ( $i%2 == 1 ) { $BGColor = array("R"=>$BackgroundR1,"G"=>$BackgroundG1,"B"=>$BackgroundB1,"Alpha"=>$BackgroundAlpha1); } else { $BGColor = array("R"=>$BackgroundR2,"G"=>$BackgroundG2,"B"=>$BackgroundB2,"Alpha"=>$BackgroundAlpha2); }

  2408.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }

  2409. 

  2410.                if ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2411. 

  2412.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

  2413.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

  2414. 

  2415.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

  2416.                $Bounds    = $this->drawText($XPos,$YPos-$OuterTickWidth-2,$Value,array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  2417.                $TxtHeight = $YPos-$OuterTickWidth-2-($Bounds[1]["Y"]-$Bounds[2]["Y"]);

  2418.                $MinTop    = min($MinTop,$TxtHeight);

  2419. 

  2420.                $LastX = $XPos;

  2421.               }

  2422. 

  2423.              if ( isset($Parameters["Name"]) )

  2424.               {

  2425.                $YPos   = $MinTop-2;

  2426.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

  2427.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  2428.                $MinTop = $Bounds[2]["Y"];

  2429. 

  2430.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;

  2431.               }

  2432. 

  2433.              $AxisPos["T"] = $MinTop - $ScaleSpacing;

  2434.             }

  2435.            elseif ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )

  2436.             {

  2437.              if ( $Floating )

  2438.               { $FloatingOffset = $XMargin; $this->drawLine($this->GraphAreaX1+$Parameters["Margin"],$AxisPos["B"],$this->GraphAreaX2-$Parameters["Margin"],$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2439.              else

  2440.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

  2441. 

  2442.              if ( $DrawArrows ) { $this->drawArrow($this->GraphAreaX2-$Parameters["Margin"],$AxisPos["B"],$this->GraphAreaX2+($ArrowSize*2),$AxisPos["B"],array("FillR"=>$AxisR,"FillG"=>$AxisG,"FillB"=>$AxisB,"Size"=>$ArrowSize)); }

  2443. 

  2444.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

  2445.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxBottom = $AxisPos["B"];

  2446.              $LastX  = NULL;

  2447.              for($i=0;$i<=$Parameters["Rows"];$i++)

  2448.               {

  2449.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

  2450.                $YPos  = $AxisPos["B"];

  2451.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

  2452. 

  2453.                if ( $i%2 == 1 ) { $BGColor = array("R"=>$BackgroundR1,"G"=>$BackgroundG1,"B"=>$BackgroundB1,"Alpha"=>$BackgroundAlpha1); } else { $BGColor = array("R"=>$BackgroundR2,"G"=>$BackgroundG2,"B"=>$BackgroundB2,"Alpha"=>$BackgroundAlpha2); }

  2454.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }

  2455. 

  2456.                if ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

  2457. 

  2458.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

  2459.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

  2460. 

  2461.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

  2462.                $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+2,$Value,array("Align"=>TEXT_ALIGN_TOPMIDDLE));

  2463.                $TxtHeight = $YPos+$OuterTickWidth+2+($Bounds[1]["Y"]-$Bounds[2]["Y"]);

  2464.                $MaxBottom = max($MaxBottom,$TxtHeight);

  2465. 

  2466.                $LastX = $XPos;

  2467.               }

  2468. 

  2469.              if ( isset($Parameters["Name"]) )

  2470.               {

  2471.                $YPos   = $MaxBottom+2;

  2472.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

  2473.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));

  2474.                $MaxBottom = $Bounds[0]["Y"];

  2475. 

  2476.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;

  2477.               }

  2478. 

  2479.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;

  2480.             }

  2481.           }

  2482.         }

  2483.       }

  2484.     }

  2485. 

  2486.    function isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip)

  2487.     {

  2488.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value != $LastValue ) { return(TRUE); }

  2489.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value == $LastValue ) { return(FALSE); }

  2490.      if ( $LabelingMethod == LABELING_ALL && $LabelSkip == 0 ) { return(TRUE); }

  2491.      if ( $LabelingMethod == LABELING_ALL && ($ID+$LabelSkip) % ($LabelSkip+1) != 1 ) { return(FALSE); }

  2492. 

  2493.      return(TRUE);

  2494.     }

  2495. 

  2496.    /* Compute the scale, check for the best visual factors */

  2497.    function computeScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID=0)

  2498.     {

  2499.      /* Compute each factors */

  2500.      $Results = "";

  2501.      foreach ($Factors as $Key => $Factor)

  2502.       $Results[$Factor] = $this->processScale($XMin,$XMax,$MaxDivs,array($Factor),$AxisID);

  2503. 

  2504.      /* Remove scales that are creating to much decimals */

  2505.      $GoodScaleFactors = "";

  2506.      foreach ($Results as $Key => $Result)

  2507.       {

  2508.        $Decimals = preg_split("/\./",$Result["RowHeight"]);

  2509.        if ( (!isset($Decimals[1])) || (strlen($Decimals[1]) < 6) ) { $GoodScaleFactors[] = $Key; }

  2510.       }

  2511. 

  2512.      /* Found no correct scale, shame,... returns the 1st one as default */

  2513.      if ( $GoodScaleFactors == "" ) { return($Results[$Factors[0]]); }

  2514. 

  2515.      /* Find the factor that cause the maximum number of Rows */

  2516.      $MaxRows = 0; $BestFactor = 0;

  2517.      foreach($GoodScaleFactors as $Key => $Factor)

  2518.       { if ( $Results[$Factor]["Rows"] > $MaxRows ) { $MaxRows = $Results[$Factor]["Rows"]; $BestFactor = $Factor; } }

  2519. 

  2520.      /* Return the best visual scale */

  2521.      return($Results[$BestFactor]);

  2522.     }

  2523. 

  2524.    /* Compute the best matching scale based on size & factors */

  2525.    function processScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID)

  2526.     {

  2527.      $ScaleHeight = abs(ceil($XMax)-floor($XMin));

  2528. 

  2529.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Format"]) )

  2530.       $Format = $this->DataSet->Data["Axis"][$AxisID]["Format"];

  2531.      else

  2532.       $Format = NULL;

  2533. 

  2534.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Display"]) )

  2535.       $Mode = $this->DataSet->Data["Axis"][$AxisID]["Display"];

  2536.      else

  2537.       $Mode = AXIS_FORMAT_DEFAULT;

  2538. 

  2539.      $Scale = "";

  2540.      if ( $XMin != $XMax )

  2541.       {

  2542.        $Found = FALSE; $Rescaled = FALSE; $Scaled10Factor = .0001; $Result = 0;

  2543.        while(!$Found)

  2544.         {

  2545.          foreach($Factors as $Key => $Factor)

  2546.           {

  2547.            if ( !$Found )

  2548.             {

  2549.              if ( !($this->modulo($XMin,$Factor*$Scaled10Factor) == 0) || ($XMin != floor($XMin))) { $XMinRescaled = floor($XMin/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor; } else { $XMinRescaled = $XMin; }

  2550.              if ( !($this->modulo($XMax,$Factor*$Scaled10Factor) == 0) || ($XMax != floor($XMax))) { $XMaxRescaled = floor($XMax/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor+($Factor*$Scaled10Factor); } else { $XMaxRescaled = $XMax; }

  2551.              $ScaleHeightRescaled = abs($XMaxRescaled-$XMinRescaled);

  2552. 

  2553.              if ( !$Found && floor($ScaleHeightRescaled/($Factor*$Scaled10Factor)) <= $MaxDivs ) { $Found = TRUE; $Rescaled = TRUE; $Result = $Factor * $Scaled10Factor; }

  2554.             }

  2555.           }

  2556.          $Scaled10Factor = $Scaled10Factor * 10;

  2557.         }

  2558. 

  2559.        /* ReCall Min / Max / Height */

  2560.        if ( $Rescaled ) { $XMin = $XMinRescaled; $XMax = $XMaxRescaled; $ScaleHeight = $ScaleHeightRescaled; }

  2561. 

  2562.        /* Compute rows size */

  2563.        $Rows      = floor($ScaleHeight / $Result); if ( $Rows == 0 ) { $Rows = 1; }

  2564.        $RowHeight = $ScaleHeight / $Rows;

  2565. 

  2566.        /* Return the results */

  2567.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;

  2568. 

  2569.        /* Compute the needed decimals for the metric view to avoid repetition of the same X Axis labels */

  2570.        if ( $Mode == AXIS_FORMAT_METRIC && $Format == NULL )

  2571.         {

  2572.          $Done = FALSE; $GoodDecimals = 0;

  2573.          for($Decimals=0;$Decimals<=10;$Decimals++)

  2574.           {

  2575.            if ( !$Done )

  2576.             {

  2577.              $LastLabel = "zob"; $ScaleOK = TRUE;

  2578.              for($i=0;$i<=$Rows;$i++)

  2579.               {

  2580.                $Value = $XMin + $i*$RowHeight;

  2581.                $Label = $this->scaleFormat($Value,AXIS_FORMAT_METRIC,$Decimals);

  2582. 

  2583.                if ( $LastLabel == $Label ) { $ScaleOK = FALSE; }

  2584.                $LastLabel = $Label;

  2585.               }

  2586.              if ( $ScaleOK ) { $Done = TRUE; $GoodDecimals = $Decimals; }

  2587.             }

  2588.           }

  2589. 

  2590.          $Scale["Format"] = $GoodDecimals;

  2591.         }

  2592.       }

  2593.      else

  2594.       {

  2595.        /* If all values are the same we keep a +1/-1 scale */

  2596.        $Rows = 2; $XMin = $XMax-1; $XMax = $XMax+1; $RowHeight = 1;

  2597. 

  2598.        /* Return the results */

  2599.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;

  2600.       }

  2601. 

  2602.      return($Scale);

  2603.     }

  2604. 

  2605.    function modulo($Value1,$Value2)

  2606.     {

  2607.      if (floor($Value2) == 0) { return(0); }

  2608.      if (floor($Value2) != 0) { return($Value1 % $Value2); }

  2609. 

  2610.      $MinValue = min($Value1,$Value2); $Factor = 10;

  2611.      while ( floor($MinValue*$Factor) == 0 )

  2612.       { $Factor = $Factor * 10; }

  2613. 

  2614.      return(($Value1*$Factor) % ($Value2*$Factor));

  2615.     }

  2616. 

  2617.    /* Draw an X threshold */

  2618.    function drawXThreshold($Value,$Format="")

  2619.     {

  2620.      $R			= isset($Format["R"]) ? $Format["R"] : 255;

  2621.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  2622.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  2623.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 50;

  2624.      $Weight		= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

  2625.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : 6;

  2626.      $Wide		= isset($Format["Wide"]) ? $Format["Wide"] : FALSE;

  2627.      $WideFactor	= isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;

  2628.      $WriteCaption	= isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;

  2629.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : NULL;

  2630.      $CaptionAlign	= isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;

  2631.      $CaptionOffset     = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 5;

  2632.      $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;

  2633.      $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;

  2634.      $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;

  2635.      $CaptionAlpha	= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;

  2636.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

  2637.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

  2638.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 3;

  2639.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

  2640.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

  2641.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

  2642.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

  2643.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

  2644.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 30;

  2645.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

  2646.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

  2647.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

  2648.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

  2649.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

  2650.      $ValueIsLabel	= isset($Format["ValueIsLabel"]) ? $Format["ValueIsLabel"] : FALSE;

  2651. 

  2652.      $Data           = $this->DataSet->getData();

  2653.      $AbscissaMargin = $this->getAbscissaMargin($Data);

  2654.      $XScale         = $this->scaleGetXSettings();

  2655. 

  2656.      if ( is_array($Value) ) { foreach ($Value as $Key => $ID) { $this->drawXThreshold($ID,$Format); } return(0); }

  2657. 

  2658.      if ( $ValueIsLabel )

  2659.       {

  2660.        $Format["ValueIsLabel"] = FALSE;

  2661.        foreach($Data["Series"][$Data["Abscissa"]]["Data"] as $Key => $SerieValue)

  2662.         { if ( $SerieValue == $Value ) { $this->drawXThreshold($Key,$Format); } }

  2663. 

  2664.        return(0);

  2665.       }

  2666. 

  2667.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

  2668.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

  2669.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha,

  2670.                               "R"=>$CaptionR,"G"=>$CaptionG,"B"=>$CaptionB,"Alpha"=>$CaptionAlpha);

  2671. 

  2672.      if ( $Caption == NULL )

  2673.       {

  2674.        if ( isset($Data["Abscissa"]) )

  2675.         {

  2676.          if ( isset($Data["Series"][$Data["Abscissa"]]["Data"][$Value]) )

  2677.           $Caption = $Data["Series"][$Data["Abscissa"]]["Data"][$Value];

  2678.          else

  2679.           $Caption = $Value;

  2680.         }

  2681.        else

  2682.         $Caption = $Value;

  2683.       }

  2684. 

  2685.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  2686.       {

  2687.        $XStep = (($this->GraphAreaX2 - $this->GraphAreaX1) - $XScale[0] *2 ) / $XScale[1];

  2688.        $XPos  = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value;

  2689.        $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];

  2690.        $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];

  2691. 

  2692.        if ( $XPos >= $this->GraphAreaX1 + $AbscissaMargin && $XPos <= $this->GraphAreaX2 - $AbscissaMargin )

  2693.         {

  2694.          $this->drawLine($XPos,$YPos1,$XPos,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  2695. 

  2696.          if ( $Wide )

  2697.           {

  2698.            $this->drawLine($XPos-1,$YPos1,$XPos-1,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2699.            $this->drawLine($XPos+1,$YPos1,$XPos+1,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2700.           }

  2701. 

  2702.          if ( $WriteCaption )

  2703.           {

  2704.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

  2705.             { $Y = $YPos1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE; }

  2706.            else 

  2707.             { $Y = $YPos2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }

  2708.            

  2709.            $this->drawText($XPos,$Y,$Caption,$CaptionSettings);

  2710.           }

  2711. 

  2712.          return(array("X"=>$XPos));

  2713.         }

  2714.       }

  2715.      elseif( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

  2716.       {

  2717.        $XStep = (($this->GraphAreaY2 - $this->GraphAreaY1) - $XScale[0] *2 ) / $XScale[1];

  2718.        $XPos  = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value;

  2719.        $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];

  2720.        $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];

  2721. 

  2722.        if ( $XPos >= $this->GraphAreaY1 + $AbscissaMargin && $XPos <= $this->GraphAreaY2 - $AbscissaMargin )

  2723.         {

  2724.          $this->drawLine($YPos1,$XPos,$YPos2,$XPos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  2725. 

  2726.          if ( $Wide )

  2727.           {

  2728.            $this->drawLine($YPos1,$XPos-1,$YPos2,$XPos-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2729.            $this->drawLine($YPos1,$XPos+1,$YPos2,$XPos+1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2730.           }

  2731. 

  2732.          if ( $WriteCaption )

  2733.           {

  2734.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

  2735.             { $Y = $YPos1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT; }

  2736.            else 

  2737.             { $Y = $YPos2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }

  2738.            

  2739.            $this->drawText($Y,$XPos,$Caption,$CaptionSettings);

  2740.           }

  2741. 

  2742.          return(array("X"=>$XPos));

  2743.         }

  2744.       }

  2745.     }

  2746. 

  2747.    /* Draw an X threshold area */

  2748.    function drawXThresholdArea($Value1,$Value2,$Format="")

  2749.     {

  2750.      $R		= isset($Format["R"]) ? $Format["R"] : 255;

  2751.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  2752.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  2753.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 20;

  2754.      $Border    = isset($Format["Border"]) ? $Format["Border"] : TRUE;

  2755.      $BorderR   = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

  2756.      $BorderG   = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

  2757.      $BorderB   = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

  2758.      $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;

  2759.      $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;

  2760.      $AreaName 	= isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;

  2761.      $NameAngle	= isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;

  2762.      $NameR	= isset($Format["NameR"]) ? $Format["NameR"] : 255;

  2763.      $NameG	= isset($Format["NameG"]) ? $Format["NameG"] : 255;

  2764.      $NameB	= isset($Format["NameB"]) ? $Format["NameB"] : 255;

  2765.      $NameAlpha	= isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;

  2766.      $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;

  2767. 

  2768.      $RestoreShadow = $this->Shadow;

  2769.      if ( $DisableShadowOnArea && $this->Shadow ) { $this->Shadow = FALSE; }

  2770. 

  2771.      if ($BorderAlpha >100) { $BorderAlpha = 100;}

  2772. 

  2773.      $Data           = $this->DataSet->getData();

  2774.      $XScale         = $this->scaleGetXSettings();

  2775.      $AbscissaMargin = $this->getAbscissaMargin($Data);

  2776. 

  2777.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  2778.       {

  2779.        $XStep = (($this->GraphAreaX2 - $this->GraphAreaX1) - $XScale[0] *2 ) / $XScale[1];

  2780.        $XPos1 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value1;

  2781.        $XPos2 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value2;

  2782.        $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];

  2783.        $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];

  2784. 

  2785.        if ( $XPos1 < $this->GraphAreaX1 + $XScale[0] ) { $XPos1 = $this->GraphAreaX1 + $XScale[0]; }

  2786.        if ( $XPos1 > $this->GraphAreaX2 - $XScale[0] ) { $XPos1 = $this->GraphAreaX2 - $XScale[0]; }

  2787.        if ( $XPos2 < $this->GraphAreaX1 + $XScale[0] ) { $XPos2 = $this->GraphAreaX1 + $XScale[0]; }

  2788.        if ( $XPos2 > $this->GraphAreaX2 - $XScale[0] ) { $XPos2 = $this->GraphAreaX2 - $XScale[0]; }

  2789. 

  2790.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  2791. 

  2792.        if ( $Border )

  2793.         {

  2794.          $this->drawLine($XPos1,$YPos1,$XPos1,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  2795.          $this->drawLine($XPos2,$YPos1,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  2796.         }

  2797. 

  2798.        if ( $AreaName != NULL )

  2799.         {

  2800.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

  2801.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

  2802. 

  2803.          if ( $NameAngle == ZONE_NAME_ANGLE_AUTO )

  2804.           {

  2805.            $TxtPos   = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$AreaName);

  2806.            $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];

  2807.            if ( abs($XPos2 - $XPos1) > $TxtWidth ) { $NameAngle = 0; } else { $NameAngle = 90; }

  2808.           }

  2809.          $this->Shadow = $RestoreShadow;

  2810.          $this->drawText($XPos,$YPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>$NameAngle,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

  2811.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

  2812.         }

  2813. 

  2814.        $this->Shadow = $RestoreShadow;

  2815.        return(array("X1"=>$XPos1,"X2"=>$XPos2));

  2816.       }

  2817.      elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

  2818.       {

  2819.        $XStep = (($this->GraphAreaY2 - $this->GraphAreaY1) - $XScale[0] *2 ) / $XScale[1];

  2820.        $XPos1 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value1;

  2821.        $XPos2 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value2;

  2822.        $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];

  2823.        $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];

  2824. 

  2825.        if ( $XPos1 < $this->GraphAreaY1 + $XScale[0] ) { $XPos1 = $this->GraphAreaY1 + $XScale[0]; }

  2826.        if ( $XPos1 > $this->GraphAreaY2 - $XScale[0] ) { $XPos1 = $this->GraphAreaY2 - $XScale[0]; }

  2827.        if ( $XPos2 < $this->GraphAreaY1 + $XScale[0] ) { $XPos2 = $this->GraphAreaY1 + $XScale[0]; }

  2828.        if ( $XPos2 > $this->GraphAreaY2 - $XScale[0] ) { $XPos2 = $this->GraphAreaY2 - $XScale[0]; }

  2829. 

  2830.        $this->drawFilledRectangle($YPos1,$XPos1,$YPos2,$XPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  2831. 

  2832.        if ( $Border )

  2833.         {

  2834.          $this->drawLine($YPos1,$XPos1,$YPos2,$XPos1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  2835.          $this->drawLine($YPos1,$XPos2,$YPos2,$XPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  2836.         }

  2837. 

  2838.        if ( $AreaName != NULL )

  2839.         {

  2840.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

  2841.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

  2842. 

  2843.          $this->Shadow = $RestoreShadow;

  2844.          $this->drawText($YPos,$XPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>0,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

  2845.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

  2846.         }

  2847. 

  2848.        $this->Shadow = $RestoreShadow;

  2849.        return(array("X1"=>$XPos1,"X2"=>$XPos2));

  2850.       }

  2851.     }

  2852. 

  2853.    /* Draw an Y threshold with the computed scale */

  2854.    function drawThreshold($Value,$Format="")

  2855.     {

  2856.      $AxisID		= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

  2857.      $R			= isset($Format["R"]) ? $Format["R"] : 255;

  2858.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  2859.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  2860.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 50;

  2861.      $Weight		= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

  2862.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : 6;

  2863.      $Wide		= isset($Format["Wide"]) ? $Format["Wide"] : FALSE;

  2864.      $WideFactor	= isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;

  2865.      $WriteCaption	= isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;

  2866.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : NULL;

  2867.      $CaptionAlign	= isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;

  2868.      $CaptionOffset     = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 10;

  2869.      $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;

  2870.      $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;

  2871.      $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;

  2872.      $CaptionAlpha	= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;

  2873.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

  2874.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

  2875.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;

  2876.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

  2877.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

  2878.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

  2879.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

  2880.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

  2881.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;

  2882.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

  2883.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

  2884.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

  2885.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

  2886.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

  2887.      $NoMargin		= isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;

  2888. 

  2889.      if ( is_array($Value) ) { foreach ($Value as $Key => $ID) { $this->drawThreshold($ID,$Format); } return(0); }

  2890. 

  2891.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

  2892.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

  2893.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha,

  2894.                               "R"=>$CaptionR,"G"=>$CaptionG,"B"=>$CaptionB,"Alpha"=>$CaptionAlpha);

  2895. 

  2896.      $Data           = $this->DataSet->getData();

  2897.      $AbscissaMargin = $this->getAbscissaMargin($Data);

  2898. 

  2899.      if ( $NoMargin ) { $AbscissaMargin = 0; }

  2900.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

  2901.      if ( $Caption == NULL ) { $Caption = $Value; }

  2902. 

  2903.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  2904.       {

  2905.        $YPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));

  2906.        if ( $YPos >= $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] && $YPos <= $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] )

  2907.         {

  2908.          $X1 = $this->GraphAreaX1 + $AbscissaMargin;

  2909.          $X2 = $this->GraphAreaX2 - $AbscissaMargin;

  2910. 

  2911.          $this->drawLine($X1,$YPos,$X2,$YPos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  2912. 

  2913.          if ( $Wide )

  2914.           {

  2915.            $this->drawLine($X1,$YPos-1,$X2,$YPos-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2916.            $this->drawLine($X1,$YPos+1,$X2,$YPos+1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2917.           }

  2918. 

  2919.          if ( $WriteCaption )

  2920.           {

  2921.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

  2922.             { $X = $X1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT; }

  2923.            else 

  2924.             { $X = $X2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }

  2925.            

  2926.            $this->drawText($X,$YPos,$Caption,$CaptionSettings);

  2927.           }

  2928.         }

  2929. 

  2930.        return(array("Y"=>$YPos));

  2931.       }

  2932. 

  2933.      if ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

  2934.       {

  2935.        $XPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));

  2936.        if ( $XPos >= $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] && $XPos <= $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] )

  2937.         {

  2938.          $Y1 = $this->GraphAreaY1 + $AbscissaMargin;

  2939.          $Y2 = $this->GraphAreaY2 - $AbscissaMargin;

  2940. 

  2941.          $this->drawLine($XPos,$Y1,$XPos,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  2942. 

  2943.          if ( $Wide )

  2944.           {

  2945.            $this->drawLine($XPos-1,$Y1,$XPos-1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2946.            $this->drawLine($XPos+1,$Y1,$XPos+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

  2947.           }

  2948. 

  2949.          if ( $WriteCaption )

  2950.           {

  2951.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

  2952.             { $Y = $Y1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE; }

  2953.            else 

  2954.             { $Y = $Y2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }

  2955. 

  2956.            $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;

  2957.            $this->drawText($XPos,$Y,$Caption,$CaptionSettings);

  2958.           }

  2959.         }

  2960. 

  2961.        return(array("Y"=>$XPos));

  2962.       }

  2963.     }

  2964. 

  2965.    /* Draw a threshold with the computed scale */

  2966.    function drawThresholdArea($Value1,$Value2,$Format="")

  2967.     {

  2968.      $AxisID	= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

  2969.      $R		= isset($Format["R"]) ? $Format["R"] : 255;

  2970.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

  2971.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

  2972.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 20;

  2973.      $Border    = isset($Format["Border"]) ? $Format["Border"] : TRUE;

  2974.      $BorderR   = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

  2975.      $BorderG   = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

  2976.      $BorderB   = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

  2977.      $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;

  2978.      $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;

  2979.      $AreaName 	= isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;

  2980.      $NameAngle	= isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;

  2981.      $NameR	= isset($Format["NameR"]) ? $Format["NameR"] : 255;

  2982.      $NameG	= isset($Format["NameG"]) ? $Format["NameG"] : 255;

  2983.      $NameB	= isset($Format["NameB"]) ? $Format["NameB"] : 255;

  2984.      $NameAlpha	= isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;

  2985.      $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;

  2986.      $NoMargin	= isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;

  2987. 

  2988.      if ($Value1 > $Value2) { list($Value1, $Value2) = array($Value2, $Value1); }

  2989. 

  2990.      $RestoreShadow = $this->Shadow;

  2991.      if ( $DisableShadowOnArea && $this->Shadow ) { $this->Shadow = FALSE; }

  2992. 

  2993.      if ($BorderAlpha >100) { $BorderAlpha = 100;}

  2994. 

  2995.      $Data           = $this->DataSet->getData();

  2996.      $AbscissaMargin = $this->getAbscissaMargin($Data);

  2997. 

  2998.      if ( $NoMargin ) { $AbscissaMargin = 0; }

  2999.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

  3000. 

  3001.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3002.       {

  3003.        $XPos1 = $this->GraphAreaX1 + $AbscissaMargin;

  3004.        $XPos2 = $this->GraphAreaX2 - $AbscissaMargin;

  3005.        $YPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));

  3006.        $YPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));

  3007. 

  3008.        if ( $YPos1 < $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] ) { $YPos1 = $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"]; }

  3009.        if ( $YPos1 > $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] ) { $YPos1 = $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"]; }

  3010.        if ( $YPos2 < $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] ) { $YPos2 = $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"]; }

  3011.        if ( $YPos2 > $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] ) { $YPos2 = $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"]; }

  3012. 

  3013.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  3014.        if ( $Border )

  3015.         {

  3016.          $this->drawLine($XPos1,$YPos1,$XPos2,$YPos1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  3017.          $this->drawLine($XPos1,$YPos2,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  3018.         }

  3019. 

  3020.        if ( $AreaName != NULL )

  3021.         {

  3022.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

  3023.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

  3024.          $this->Shadow = $RestoreShadow;

  3025.          $this->drawText($XPos,$YPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>0,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

  3026.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

  3027.         }

  3028. 

  3029.        $this->Shadow = $RestoreShadow;

  3030.        return(array("Y1"=>$YPos1,"Y2"=>$YPos2));

  3031.       }

  3032.      elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

  3033.       {

  3034.        $YPos1 = $this->GraphAreaY1 + $AbscissaMargin;

  3035.        $YPos2 = $this->GraphAreaY2 - $AbscissaMargin;

  3036.        $XPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));

  3037.        $XPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));

  3038. 

  3039.        if ( $XPos1 < $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] ) { $XPos1 = $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"]; }

  3040.        if ( $XPos1 > $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] ) { $XPos1 = $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"]; }

  3041.        if ( $XPos2 < $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] ) { $XPos2 = $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"]; }

  3042.        if ( $XPos2 > $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] ) { $XPos2 = $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"]; }

  3043. 

  3044.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  3045.        if ( $Border )

  3046.         {

  3047.          $this->drawLine($XPos1,$YPos1,$XPos1,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  3048.          $this->drawLine($XPos2,$YPos1,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

  3049.         }

  3050. 

  3051.        if ( $AreaName != NULL )

  3052.         {

  3053.          $XPos = ($YPos2-$YPos1)/2 + $YPos1;

  3054.          $YPos = ($XPos2-$XPos1)/2 + $XPos1;

  3055. 

  3056.          if ( $NameAngle == ZONE_NAME_ANGLE_AUTO )

  3057.           {

  3058.            $TxtPos   = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$AreaName);

  3059.            $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];

  3060.            if ( abs($XPos2 - $XPos1) > $TxtWidth ) { $NameAngle = 0; } else { $NameAngle = 90; }

  3061.           }

  3062.          $this->Shadow = $RestoreShadow;

  3063.          $this->drawText($YPos,$XPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>$NameAngle,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

  3064.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

  3065.         }

  3066. 

  3067.        $this->Shadow = $RestoreShadow;

  3068.        return(array("Y1"=>$XPos1,"Y2"=>$XPos2));

  3069.       }

  3070.     }

  3071. 

  3072.    function scaleGetXSettings()

  3073.     {

  3074.      $Data = $this->DataSet->getData();

  3075.      foreach($Data["Axis"] as $AxisID => $Settings)

  3076.       {

  3077.        if ( $Settings["Identity"] == AXIS_X )

  3078.         {

  3079.          $Rows = $Settings["Rows"];

  3080. 

  3081.          return(array($Settings["Margin"],$Rows));

  3082.         }

  3083.       }

  3084.     }

  3085. 

  3086.    function scaleComputeY($Values,$Option="",$ReturnOnly0Height=FALSE)

  3087.     {

  3088.      $AxisID	= isset($Option["AxisID"]) ? $Option["AxisID"] : 0;

  3089.      $SerieName	= isset($Option["SerieName"]) ? $Option["SerieName"] : NULL;

  3090. 

  3091.      $Data = $this->DataSet->getData();

  3092.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

  3093. 

  3094.      if ( $SerieName != NULL ) { $AxisID = $Data["Series"][$SerieName]["Axis"]; }

  3095.      if ( !is_array($Values) ) { $tmp = $Values; $Values = ""; $Values[0] = $tmp; }

  3096. 

  3097.      $Result = "";

  3098.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3099.       {

  3100.        $Height      = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Data["Axis"][$AxisID]["Margin"]*2;

  3101.        $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];

  3102.        $Step        = $Height / $ScaleHeight;

  3103. 

  3104.        if ( $ReturnOnly0Height )

  3105.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }

  3106.        else

  3107.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"] - ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }

  3108.       }

  3109.      else

  3110.       {

  3111.        $Width      = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Data["Axis"][$AxisID]["Margin"]*2;

  3112.        $ScaleWidth = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];

  3113.        $Step       = $Width / $ScaleWidth;

  3114. 

  3115.        if ( $ReturnOnly0Height )

  3116.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }

  3117.        else

  3118.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] + ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }

  3119.       }

  3120. 

  3121.      if ( count($Result) == 1 )

  3122.       return($Result[0]);

  3123.      else

  3124.       return($Result);

  3125.     }

  3126. 

  3127.    /* Format the axis values */

  3128.    function scaleFormat($Value,$Mode=NULL,$Format=NULL,$Unit=NULL)

  3129.     {

  3130.      if ( $Value == VOID ) { return(""); }

  3131. 

  3132.      if ( $Mode == AXIS_FORMAT_TRAFFIC )

  3133.       {

  3134.        if ( $Value == 0 ) { return("0B"); }

  3135.        $Units = array("B","KB","MB","GB","TB","PB");

  3136.        $Sign = ""; if ( $Value < 0 ) { $Value = abs($Value); $Sign = "-"; }

  3137. 

  3138.        $Value = number_format($Value/pow(1024,($Scale=floor(log($Value,1024)))),2,",",".");

  3139.        return($Sign.$Value." ".$Units[$Scale]);

  3140.       }

  3141. 

  3142.      if ( $Mode == AXIS_FORMAT_CUSTOM )

  3143.       { if ( function_exists($Format) ) { return(call_user_func($Format,$Value)); } }

  3144. 

  3145.      if ( $Mode == AXIS_FORMAT_DATE )

  3146.       { if ( $Format == NULL ) { $Pattern = "d/m/Y"; } else { $Pattern = $Format; } return(gmdate($Pattern,$Value)); }

  3147. 

  3148.      if ( $Mode == AXIS_FORMAT_TIME )

  3149.       { if ( $Format == NULL ) { $Pattern = "H:i:s"; } else { $Pattern = $Format; } return(gmdate($Pattern,$Value)); }

  3150. 

  3151.      if ( $Mode == AXIS_FORMAT_CURRENCY )

  3152.       { return($Format.number_format($Value,2)); }

  3153. 

  3154.      if ( $Mode == AXIS_FORMAT_METRIC )

  3155.       {

  3156.        if (abs($Value) > 1000000000)

  3157.         return(round($Value/1000000000,$Format)."g".$Unit);

  3158.        if (abs($Value) > 1000000)

  3159.         return(round($Value/1000000,$Format)."m".$Unit);

  3160.        elseif (abs($Value) >= 1000)

  3161.         return(round($Value/1000,$Format)."k".$Unit);

  3162.        

  3163.       }

  3164.      return($Value.$Unit);

  3165.     }

  3166. 

  3167.    /* Write Max value on a chart */

  3168.    function writeBounds($Type=BOUND_BOTH,$Format=NULL)

  3169.     {

  3170.      $MaxLabelTxt	= isset($Format["MaxLabelTxt"]) ? $Format["MaxLabelTxt"] : "max=";

  3171.      $MinLabelTxt	= isset($Format["MinLabelTxt"]) ? $Format["MinLabelTxt"] : "min=";

  3172.      $Decimals		= isset($Format["Decimals"]) ? $Format["Decimals"] : 1;

  3173.      $ExcludedSeries	= isset($Format["ExcludedSeries"]) ? $Format["ExcludedSeries"] : "";

  3174.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;

  3175.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3176.      $MaxDisplayR	= isset($Format["MaxDisplayR"]) ? $Format["MaxDisplayR"] : 0;

  3177.      $MaxDisplayG	= isset($Format["MaxDisplayG"]) ? $Format["MaxDisplayG"] : 0;

  3178.      $MaxDisplayB	= isset($Format["MaxDisplayB"]) ? $Format["MaxDisplayB"] : 0;

  3179.      $MinDisplayR	= isset($Format["MinDisplayR"]) ? $Format["MinDisplayR"] : 255;

  3180.      $MinDisplayG	= isset($Format["MinDisplayG"]) ? $Format["MinDisplayG"] : 255;

  3181.      $MinDisplayB	= isset($Format["MinDisplayB"]) ? $Format["MinDisplayB"] : 255;

  3182.      $MinLabelPos	= isset($Format["MinLabelPos"]) ? $Format["MinLabelPos"] : BOUND_LABEL_POS_AUTO;

  3183.      $MaxLabelPos	= isset($Format["MaxLabelPos"]) ? $Format["MaxLabelPos"] : BOUND_LABEL_POS_AUTO;

  3184.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

  3185.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

  3186.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;

  3187.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

  3188.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

  3189.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

  3190.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

  3191.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

  3192.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;

  3193.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

  3194.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

  3195.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

  3196.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

  3197.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

  3198. 

  3199.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

  3200.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

  3201.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha);

  3202. 

  3203.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3204. 

  3205.      $Data = $this->DataSet->getData();

  3206.      foreach($Data["Series"] as $SerieName => $Serie)

  3207.       {

  3208.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && !isset($ExcludedSeries[$SerieName]))

  3209.         {

  3210.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  3211.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3212. 

  3213.          $MinValue = $this->DataSet->getMin($SerieName);

  3214.          $MaxValue = $this->DataSet->getMax($SerieName);

  3215. 

  3216.          $MinPos = VOID; $MaxPos = VOID;

  3217.          foreach($Serie["Data"] as $Key => $Value)

  3218.           { 

  3219.            if ( $Value == $MinValue && $MinPos == VOID ) { $MinPos = $Key; }

  3220.            if ( $Value == $MaxValue ) { $MaxPos = $Key; }

  3221.           }

  3222. 

  3223.          $AxisID	= $Serie["Axis"];

  3224.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3225.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3226.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3227. 

  3228.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3229. 

  3230.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3231.           {

  3232.            $XStep       = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs;

  3233.            $X           = $this->GraphAreaX1 + $XMargin;

  3234.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

  3235. 

  3236.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )

  3237.             {

  3238.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }

  3239.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }

  3240. 

  3241.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;

  3242.              $Label = $MaxLabelTxt.$this->scaleFormat(round($MaxValue,$Decimals),$Mode,$Format,$Unit);

  3243. 

  3244.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);

  3245.              $XOffset = 0; $YOffset = 0;

  3246.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }

  3247.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }

  3248.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }

  3249.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }

  3250. 

  3251.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;

  3252.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;

  3253. 

  3254.              $this->drawText($XPos+$XOffset,$YPos+$YOffset,$Label,$CaptionSettings);

  3255.             }

  3256. 

  3257.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )

  3258.             {

  3259.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }

  3260.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }

  3261. 

  3262.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;

  3263.              $Label = $MinLabelTxt.$this->scaleFormat(round($MinValue,$Decimals),$Mode,$Format,$Unit);

  3264. 

  3265.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);

  3266.              $XOffset = 0; $YOffset = 0;

  3267.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }

  3268.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }

  3269.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }

  3270.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }

  3271. 

  3272.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;

  3273.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;

  3274. 

  3275.              $this->drawText($XPos+$XOffset,$YPos-$DisplayOffset+$YOffset,$Label,$CaptionSettings);

  3276.             }

  3277.           }

  3278.          else

  3279.           {

  3280.            $XStep       = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs;

  3281.            $X           = $this->GraphAreaY1 + $XMargin;

  3282.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

  3283. 

  3284.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )

  3285.             {

  3286.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }

  3287.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }

  3288. 

  3289.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;

  3290.              $Label = $MaxLabelTxt.$this->scaleFormat($MaxValue,$Mode,$Format,$Unit);

  3291. 

  3292.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);

  3293.              $XOffset = 0; $YOffset = 0;

  3294.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }

  3295.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }

  3296.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }

  3297.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}

  3298. 

  3299.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;

  3300.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;

  3301. 

  3302.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);

  3303.             }

  3304. 

  3305.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )

  3306.             {

  3307.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }

  3308.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }

  3309. 

  3310.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;

  3311.              $Label = $MinLabelTxt.$this->scaleFormat($MinValue,$Mode,$Format,$Unit);

  3312. 

  3313.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);

  3314.              $XOffset = 0; $YOffset = 0;

  3315.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }

  3316.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }

  3317.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }

  3318.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}

  3319. 

  3320.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;

  3321.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;

  3322. 

  3323.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);

  3324.             }

  3325.           }

  3326.         }

  3327.       }

  3328.     }

  3329. 

  3330.    /* Draw a plot chart */

  3331.    function drawPlotChart($Format=NULL)

  3332.     {

  3333.      $PlotSize		= isset($Format["PlotSize"]) ? $Format["PlotSize"] : NULL;

  3334.      $PlotBorder	= isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : FALSE;

  3335.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 50;

  3336.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 50;

  3337.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 50;

  3338.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;

  3339.      $BorderSize	= isset($Format["BorderSize"]) ? $Format["BorderSize"] : 2;

  3340.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  3341.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  3342.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;

  3343.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3344.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  3345.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  3346.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  3347.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  3348. 

  3349.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3350. 

  3351.      $Data = $this->DataSet->getData();

  3352.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3353. 

  3354.      foreach($Data["Series"] as $SerieName => $Serie)

  3355.       {

  3356.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  3357.         {

  3358.          if ( isset($Serie["Weight"]) ) { $SerieWeight = $Serie["Weight"] + 2; } else { $SerieWeight = 2; }

  3359.          if ( $PlotSize != NULL ) { $SerieWeight = $PlotSize; }

  3360. 

  3361.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  3362.          if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }

  3363.          if ( isset($Serie["Picture"]) )

  3364.           { $Picture = $Serie["Picture"]; list($PicWidth,$PicHeight,$PicType) = $this->getPicInfo($Picture); }

  3365.          else { $Picture = NULL; $PicOffset = 0; }

  3366. 

  3367.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3368. 

  3369.          $AxisID	= $Serie["Axis"];

  3370.          $Shape		= $Serie["Shape"];

  3371.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3372.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3373.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3374. 

  3375.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  3376. 

  3377.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3378. 

  3379.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  3380. 

  3381.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3382.           {

  3383.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3384.            if ( $Picture != NULL ) { $PicOffset = $PicHeight / 2; $SerieWeight = 0; }

  3385.            $X = $this->GraphAreaX1 + $XMargin;

  3386. 

  3387.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3388.            foreach($PosArray as $Key => $Y)

  3389.             {

  3390.              if ( $DisplayValues ) 

  3391.               $this->drawText($X,$Y-$DisplayOffset-$SerieWeight-$BorderSize-$PicOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3392. 

  3393.              if ( $Y != VOID )

  3394.               {

  3395.                if ( $RecordImageMap ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$SerieWeight,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3396. 

  3397.                if ( $Picture != NULL )

  3398.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }

  3399.                else

  3400.                 { $this->drawShape($X,$Y,$Shape,$SerieWeight,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }

  3401.               }

  3402.              $X = $X + $XStep;

  3403.             }

  3404.           }

  3405.          else

  3406.           {

  3407.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  3408.            if ( $Picture != NULL ) { $PicOffset = $PicWidth / 2; $SerieWeight = 0; }

  3409.            $Y = $this->GraphAreaY1 + $XMargin;

  3410. 

  3411.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3412.            foreach($PosArray as $Key => $X)

  3413.             {

  3414.              if ( $DisplayValues ) 

  3415.               $this->drawText($X+$DisplayOffset+$SerieWeight+$BorderSize+$PicOffset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3416. 

  3417.              if ( $X != VOID )

  3418.               {

  3419.                if ( $RecordImageMap ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$SerieWeight,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3420. 

  3421.                if ( $Picture != NULL )

  3422.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }

  3423.                else

  3424.                 { $this->drawShape($X,$Y,$Shape,$SerieWeight,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }

  3425.               }

  3426.              $Y = $Y + $YStep;

  3427.             }

  3428.           }

  3429.         }

  3430.       }

  3431.     }

  3432. 

  3433.    /* Draw a spline chart */

  3434.    function drawSplineChart($Format=NULL)

  3435.     {

  3436.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;

  3437.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

  3438.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL; // 234

  3439.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL; // 55

  3440.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL; // 26

  3441.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  3442.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  3443.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3444.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  3445.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  3446.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  3447.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  3448.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

  3449. 

  3450.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3451. 

  3452.      $Data = $this->DataSet->getData();

  3453.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3454.      foreach($Data["Series"] as $SerieName => $Serie)

  3455.       {

  3456.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  3457.         {

  3458.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  3459. 

  3460.          if ( $BreakR == NULL )

  3461.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks);

  3462.          else

  3463.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

  3464. 

  3465.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3466. 

  3467.          $AxisID	= $Serie["Axis"];

  3468.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3469.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3470.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3471. 

  3472.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  3473. 

  3474.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3475. 

  3476.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  3477. 

  3478.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3479.           {

  3480.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3481.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";

  3482.            $Force = $XStep / 5;

  3483. 

  3484.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3485.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;

  3486.            foreach($PosArray as $Key => $Y)

  3487.             {

  3488.              if ( $DisplayValues ) 

  3489.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3490. 	

  3491.              if ( $RecordImageMap && $Y != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3492. 

  3493.              if ( $Y == VOID && $LastY != NULL )

  3494.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }

  3495. 

  3496.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

  3497.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }

  3498. 

  3499.              if ( $Y != VOID )

  3500.               $WayPoints[] = array($X,$Y);

  3501. 

  3502.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  3503.              if ( $Y == VOID ) { $Y = NULL; }

  3504. 

  3505.              $LastX = $X; $LastY = $Y;

  3506.              $X = $X + $XStep;

  3507.             }

  3508.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  3509.           }

  3510.          else

  3511.           {

  3512.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  3513.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";

  3514.            $Force = $YStep / 5;

  3515. 

  3516.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3517.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;

  3518.            foreach($PosArray as $Key => $X)

  3519.             {

  3520.              if ( $DisplayValues ) 

  3521.               $this->drawText($X+$DisplayOffset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3522. 

  3523.              if ( $RecordImageMap && $X != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3524. 

  3525.              if ( $X == VOID && $LastX != NULL )

  3526.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }

  3527. 

  3528.              if ( $X != VOID && $LastX == NULL && $LastGoodX != NULL && !$BreakVoid )

  3529.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }

  3530. 

  3531.              if ( $X != VOID )

  3532.               $WayPoints[] = array($X,$Y);

  3533. 

  3534.              if ( $X != VOID ) { $LastGoodX = $X; $LastGoodY = $Y; }

  3535.              if ( $X == VOID ) { $X = NULL; }

  3536. 

  3537.              $LastX = $X; $LastY = $Y;

  3538.              $Y = $Y + $YStep;

  3539.             }

  3540.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  3541.           }

  3542.         }

  3543.       }

  3544.     }

  3545. 

  3546.    /* Draw a filled spline chart */

  3547.    function drawFilledSplineChart($Format=NULL)

  3548.     {

  3549.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  3550.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  3551.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3552.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  3553.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  3554.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  3555.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

  3556.      $Threshold		= isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

  3557. 

  3558.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3559. 

  3560.      $Data = $this->DataSet->getData();

  3561.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3562.      foreach($Data["Series"] as $SerieName => $Serie)

  3563.       {

  3564.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  3565.         {

  3566.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  3567.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3568. 

  3569.          $AxisID	= $Serie["Axis"];

  3570.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3571.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3572.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3573. 

  3574.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3575.          if ( $AroundZero ) { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }

  3576. 

  3577.          if ( $Threshold != NULL )

  3578.           {

  3579.            foreach($Threshold as $Key => $Params)

  3580.             {

  3581.              $Threshold[$Key]["MinX"] = $this->scaleComputeY($Params["Min"],array("AxisID"=>$Serie["Axis"]));

  3582.              $Threshold[$Key]["MaxX"] = $this->scaleComputeY($Params["Max"],array("AxisID"=>$Serie["Axis"]));

  3583.             }

  3584.           }

  3585. 

  3586.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  3587. 

  3588.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3589.           {

  3590.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3591.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";

  3592.            $Force = $XStep / 5;

  3593. 

  3594.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }

  3595.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  3596.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

  3597. 

  3598.            $LastX = ""; $LastY = "";

  3599.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3600.            foreach($PosArray as $Key => $Y)

  3601.             {

  3602.              if ( $DisplayValues ) 

  3603.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3604. 

  3605.              if ( $Y == VOID )

  3606.               {

  3607.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

  3608. 

  3609.                if ( $Area != "" )

  3610.                 {

  3611.                  foreach ($Area as $key => $Points)

  3612.                   {

  3613.                    $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;

  3614.                    foreach($Points as $subKey => $Point)

  3615.                     {

  3616.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

  3617.                      $Corners[] = $Point["Y"]+1;

  3618.                     }

  3619.                    $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;

  3620. 

  3621.                    $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

  3622.                   }

  3623.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  3624.                 }

  3625. 

  3626.                $WayPoints = "";

  3627.               }

  3628.              else

  3629.               $WayPoints[] = array($X,$Y-.5); /* -.5 for AA visual fix */

  3630. 

  3631.              $X = $X + $XStep;

  3632.             }

  3633.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

  3634. 

  3635.            if ( $Area != "" )

  3636.             {

  3637.              foreach ($Area as $key => $Points)

  3638.               {

  3639.                $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;

  3640.                foreach($Points as $subKey => $Point)

  3641.                 {

  3642.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

  3643.                  $Corners[] = $Point["Y"]+1;

  3644.                 }

  3645.                $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;

  3646. 

  3647.                $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

  3648.               }

  3649.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  3650.             }

  3651.           }

  3652.          else

  3653.           {

  3654.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  3655.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";

  3656.            $Force = $YStep / 5;

  3657. 

  3658.            if ( !$AroundZero ) { $YZero = $this->GraphAreaX1+1; }

  3659.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  3660.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  3661. 

  3662.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3663.            foreach($PosArray as $Key => $X)

  3664.             {

  3665.              if ( $DisplayValues ) 

  3666.               $this->drawText($X+$DisplayOffset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

  3667. 

  3668.              if ( $X == VOID )

  3669.               {

  3670.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

  3671. 

  3672.                if ( $Area != "" )

  3673.                 {

  3674.                  foreach ($Area as $key => $Points)

  3675.                   {

  3676.                    $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];

  3677.                    foreach($Points as $subKey => $Point)

  3678.                     {

  3679.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

  3680.                      $Corners[] = $Point["Y"];

  3681.                     }

  3682.                    $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;

  3683. 

  3684.                    $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

  3685.                   }

  3686.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  3687.                 }

  3688. 

  3689.                $WayPoints = "";

  3690.               }

  3691.              else

  3692.               $WayPoints[] = array($X,$Y);

  3693. 

  3694.              $Y = $Y + $YStep;

  3695.             }

  3696.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

  3697. 

  3698.            if ( $Area != "" )

  3699.             {

  3700.              foreach ($Area as $key => $Points)

  3701.               {

  3702.                $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];

  3703.                foreach($Points as $subKey => $Point)

  3704.                 {

  3705.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

  3706.                  $Corners[] = $Point["Y"];

  3707.                 }

  3708.                $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;

  3709. 

  3710.                $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

  3711.               }

  3712.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

  3713.             }

  3714. 

  3715.           }

  3716.         }

  3717.       }

  3718.     }

  3719. 

  3720.    /* Draw a line chart */

  3721.    function drawLineChart($Format=NULL)

  3722.     {

  3723.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;

  3724.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

  3725.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;

  3726.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;

  3727.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;

  3728.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  3729.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  3730.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3731.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  3732.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  3733.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  3734.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  3735.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

  3736.      $ForceColor	= isset($Format["ForceColor"]) ? $Format["ForceColor"] : FALSE;

  3737.      $ForceR		= isset($Format["ForceR"]) ? $Format["ForceR"] : 0;

  3738.      $ForceG		= isset($Format["ForceG"]) ? $Format["ForceG"] : 0;

  3739.      $ForceB		= isset($Format["ForceB"]) ? $Format["ForceB"] : 0;

  3740.      $ForceAlpha	= isset($Format["ForceAlpha"]) ? $Format["ForceAlpha"] : 100;

  3741. 

  3742.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3743. 

  3744.      $Data = $this->DataSet->getData();

  3745.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3746.      foreach($Data["Series"] as $SerieName => $Serie)

  3747.       {

  3748.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  3749.         {

  3750.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  3751. 

  3752.          if ( $ForceColor )

  3753.           { $R = $ForceR; $G = $ForceG; $B = $ForceB; $Alpha = $ForceAlpha; }

  3754. 

  3755.          if ( $BreakR == NULL )

  3756.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

  3757.          else

  3758.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

  3759. 

  3760.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3761. 

  3762.          $AxisID	= $Serie["Axis"];

  3763.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3764.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3765.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3766. 

  3767.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  3768. 

  3769.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3770. 

  3771.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  3772. 

  3773.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3774.           {

  3775.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3776.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

  3777. 

  3778.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3779.            $LastGoodY = NULL; $LastGoodX = NULL;

  3780.            foreach($PosArray as $Key => $Y)

  3781.             {

  3782.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

  3783.               {

  3784.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

  3785.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

  3786.               }

  3787. 

  3788.              if ( $RecordImageMap && $Y != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3789. 

  3790.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

  3791.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  3792. 

  3793.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

  3794.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }

  3795. 

  3796.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  3797.              if ( $Y == VOID ) { $Y = NULL; }

  3798. 

  3799.              $LastX = $X; $LastY = $Y;

  3800.              $X = $X + $XStep;

  3801.             }

  3802.           }

  3803.          else

  3804.           {

  3805.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  3806.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

  3807. 

  3808.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3809.            $LastGoodY = NULL; $LastGoodX = NULL;

  3810.            foreach($PosArray as $Key => $X)

  3811.             {

  3812.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

  3813.               { $this->drawText($X+$DisplayOffset+$Weight,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE)); }

  3814. 

  3815.              if ( $RecordImageMap && $X != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3816. 

  3817.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

  3818.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

  3819. 

  3820.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )

  3821.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }

  3822. 

  3823.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  3824.              if ( $X == VOID ) { $X = NULL; }

  3825. 

  3826.              $LastX = $X; $LastY = $Y;

  3827.              $Y = $Y + $YStep;

  3828.             }

  3829.           }

  3830.         }

  3831.       }

  3832.     }

  3833. 

  3834.    /* Draw a line chart */

  3835.    function drawZoneChart($SerieA,$SerieB,$Format=NULL)

  3836.     {

  3837.      $AxisID	= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

  3838.      $LineR	= isset($Format["LineR"]) ? $Format["LineR"] : 150;

  3839.      $LineG	= isset($Format["LineG"]) ? $Format["LineG"] : 150;

  3840.      $LineB	= isset($Format["LineB"]) ? $Format["LineB"] : 150;

  3841.      $LineAlpha	= isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 50;

  3842.      $LineTicks	= isset($Format["LineTicks"]) ? $Format["LineTicks"] : 1;

  3843.      $AreaR	= isset($Format["AreaR"]) ? $Format["AreaR"] : 150;

  3844.      $AreaG	= isset($Format["AreaG"]) ? $Format["AreaG"] : 150;

  3845.      $AreaB	= isset($Format["AreaB"]) ? $Format["AreaB"] : 150;

  3846.      $AreaAlpha	= isset($Format["AreaAlpha"]) ? $Format["AreaAlpha"] : 5;

  3847. 

  3848.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3849. 

  3850.      $Data	 = $this->DataSet->getData();

  3851.      if ( !isset($Data["Series"][$SerieA]["Data"]) || !isset($Data["Series"][$SerieB]["Data"]) ) { return(0); }

  3852.      $SerieAData = $Data["Series"][$SerieA]["Data"];

  3853.      $SerieBData = $Data["Series"][$SerieB]["Data"];

  3854. 

  3855.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3856. 

  3857.      $Mode	= $Data["Axis"][$AxisID]["Display"];

  3858.      $Format	= $Data["Axis"][$AxisID]["Format"];

  3859.      $Unit	= $Data["Axis"][$AxisID]["Unit"];

  3860. 

  3861.      $PosArrayA = $this->scaleComputeY($SerieAData,array("AxisID"=>$AxisID));

  3862.      $PosArrayB = $this->scaleComputeY($SerieBData,array("AxisID"=>$AxisID));

  3863.      if ( count($PosArrayA) != count($PosArrayB) ) { return(0); }

  3864. 

  3865.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3866.       {

  3867.        if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3868.        $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

  3869. 

  3870.        $LastX = NULL; $LastY1 = NULL; $LastY2 = NULL;

  3871.        $BoundsA = ""; $BoundsB = "";

  3872.        foreach($PosArrayA as $Key => $Y1)

  3873.         {

  3874.          $Y2 = $PosArrayB[$Key];

  3875. 

  3876.          $BoundsA[] = $X; $BoundsA[] = $Y1;

  3877.          $BoundsB[] = $X; $BoundsB[] = $Y2;

  3878. 

  3879.          $LastX = $X;

  3880.          $LastY1 = $Y1; $LastY2 = $Y2;

  3881. 

  3882.          $X = $X + $XStep;

  3883.         }

  3884.        $Bounds = array_merge($BoundsA,$this->reversePlots($BoundsB));

  3885.        $this->drawPolygonChart($Bounds,array("R"=>$AreaR,"G"=>$AreaG,"B"=>$AreaB,"Alpha"=>$AreaAlpha));

  3886. 

  3887.        for($i=0;$i<=count($BoundsA)-4;$i=$i+2)

  3888.         {

  3889.          $this->drawLine($BoundsA[$i],$BoundsA[$i+1],$BoundsA[$i+2],$BoundsA[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

  3890.          $this->drawLine($BoundsB[$i],$BoundsB[$i+1],$BoundsB[$i+2],$BoundsB[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

  3891.         }

  3892.       }

  3893.      else

  3894.       {

  3895.        if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  3896.        $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

  3897. 

  3898.        $LastY = NULL; $LastX1 = NULL; $LastX2 = NULL;

  3899.        $BoundsA = ""; $BoundsB = "";

  3900.        foreach($PosArrayA as $Key => $X1)

  3901.         {

  3902.          $X2 = $PosArrayB[$Key];

  3903. 

  3904.          $BoundsA[] = $X1; $BoundsA[] = $Y;

  3905.          $BoundsB[] = $X2; $BoundsB[] = $Y;

  3906. 

  3907.          $LastY = $Y;

  3908.          $LastX1 = $X1; $LastX2 = $X2;

  3909. 

  3910.          $Y = $Y + $YStep;

  3911.         }

  3912.        $Bounds = array_merge($BoundsA,$this->reversePlots($BoundsB));

  3913.        $this->drawPolygonChart($Bounds,array("R"=>$AreaR,"G"=>$AreaG,"B"=>$AreaB,"Alpha"=>$AreaAlpha));

  3914. 

  3915.        for($i=0;$i<=count($BoundsA)-4;$i=$i+2)

  3916.         {

  3917.          $this->drawLine($BoundsA[$i],$BoundsA[$i+1],$BoundsA[$i+2],$BoundsA[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

  3918.          $this->drawLine($BoundsB[$i],$BoundsB[$i+1],$BoundsB[$i+2],$BoundsB[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

  3919.         }

  3920.       }

  3921.     }

  3922. 

  3923.    /* Draw a step chart */

  3924.    function drawStepChart($Format=NULL)

  3925.     {

  3926.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : FALSE;

  3927.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;

  3928.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

  3929.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;

  3930.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;

  3931.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;

  3932.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;

  3933.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  3934.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  3935.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  3936.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  3937.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  3938.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  3939.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

  3940. 

  3941.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  3942. 

  3943.      $Data = $this->DataSet->getData();

  3944.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  3945.      foreach($Data["Series"] as $SerieName => $Serie)

  3946.       {

  3947.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  3948.         {

  3949.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  3950. 

  3951.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  3952. 

  3953.          if ( $BreakR == NULL )

  3954.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

  3955.          else

  3956.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

  3957. 

  3958.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  3959. 

  3960.          $AxisID	= $Serie["Axis"];

  3961.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  3962.          $Format	= $Data["Axis"][$AxisID]["Format"];

  3963.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  3964.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

  3965. 

  3966.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  3967. 

  3968.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  3969. 

  3970.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  3971.           {

  3972.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  3973.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

  3974. 

  3975.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  3976.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;

  3977.            foreach($PosArray as $Key => $Y)

  3978.             {

  3979.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

  3980.               {

  3981.                if ( $Y <= $LastY ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

  3982.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

  3983.               }

  3984. 

  3985.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

  3986.               {

  3987.                $this->drawLine($LastX,$LastY,$X,$LastY,$Color);

  3988.                $this->drawLine($X,$LastY,$X,$Y,$Color);

  3989.                if ( $ReCenter && $X+$XStep < $this->GraphAreaX2 - $XMargin )

  3990.                 {

  3991.                  $this->drawLine($X,$Y,$X+$XStep,$Y,$Color);

  3992.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X-$ImageMapPlotSize).",".floor($Y-$ImageMapPlotSize).",".floor($X+$XStep+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  3993.                 }

  3994.                else

  3995.                 { if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); } }

  3996.               }

  3997. 

  3998.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

  3999.               { 

  4000.                if ( $ReCenter )

  4001.                 {

  4002.                  $this->drawLine($LastGoodX+$XStep,$LastGoodY,$X,$LastGoodY,$BreakSettings);

  4003.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX+$XStep-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastGoodY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4004.                 }

  4005.                else

  4006.                 {

  4007.                  $this->drawLine($LastGoodX,$LastGoodY,$X,$LastGoodY,$BreakSettings);

  4008.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastGoodY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4009.                 }

  4010. 

  4011.                $this->drawLine($X,$LastGoodY,$X,$Y,$BreakSettings);

  4012.                $LastGoodY = NULL;

  4013.               }

  4014.              elseif( !$BreakVoid && $LastGoodY == NULL && $Y != VOID )

  4015.               {

  4016.               $this->drawLine($this->GraphAreaX1 + $XMargin,$Y,$X,$Y,$BreakSettings);

  4017.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($this->GraphAreaX1+$XMargin-$ImageMapPlotSize).",".floor($Y-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4018.               }

  4019. 

  4020.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  4021.              if ( $Y == VOID ) { $Y = NULL; }

  4022. 

  4023.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }

  4024.              $LastX = $X; $LastY = $Y;

  4025.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }

  4026.              $X = $X + $XStep;

  4027.             }

  4028.            if ( $ReCenter )

  4029.             {

  4030.              $this->drawLine($LastX,$LastY,$this->GraphAreaX2 - $XMargin,$LastY,$Color);

  4031.              if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($this->GraphAreaX2-$XMargin+$ImageMapPlotSize).",".floor($LastY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4032.             }

  4033.           }

  4034.          else

  4035.           {

  4036.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  4037.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

  4038. 

  4039.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4040.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;

  4041.            foreach($PosArray as $Key => $X)

  4042.             {

  4043.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

  4044.               {

  4045.                if ( $X >= $LastX ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }

  4046.                $this->drawText($X+$Offset+$Weight,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

  4047.               }

  4048. 

  4049.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

  4050.               {

  4051.                $this->drawLine($LastX,$LastY,$LastX,$Y,$Color);

  4052.                $this->drawLine($LastX,$Y,$X,$Y,$Color);

  4053. 

  4054.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($LastX+$XStep+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4055.               }

  4056. 

  4057.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )

  4058.               {

  4059.                $this->drawLine($LastGoodX,$LastGoodY,$LastGoodX,$LastGoodY+$YStep,$Color);

  4060.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($LastGoodX+$ImageMapPlotSize).",".floor($LastGoodY+$YStep+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4061. 

  4062.                $this->drawLine($LastGoodX,$LastGoodY+$YStep,$LastGoodX,$Y,$BreakSettings);

  4063.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY+$YStep-$ImageMapPlotSize).",".floor($LastGoodX+$ImageMapPlotSize).",".floor($YStep+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4064. 

  4065.                $this->drawLine($LastGoodX,$Y,$X,$Y,$BreakSettings);

  4066.                $LastGoodY = NULL;

  4067.               }

  4068.              elseif ( $X != VOID && $LastGoodY == NULL && !$BreakVoid )

  4069.               {

  4070.                $this->drawLine($X,$this->GraphAreaY1 + $XMargin,$X,$Y,$BreakSettings);

  4071.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X-$ImageMapPlotSize).",".floor($this->GraphAreaY1+$XMargin-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4072.               }

  4073. 

  4074.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  4075.              if ( $X == VOID ) { $X = NULL; }

  4076. 

  4077.              if ( !$Init && $ReCenter ) { $Y = $Y - $YStep/2; $Init = TRUE; }

  4078.              $LastX = $X; $LastY = $Y;

  4079.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }

  4080.              $Y = $Y + $YStep;

  4081.             }

  4082.            if ( $ReCenter )

  4083.             {

  4084.              $this->drawLine($LastX,$LastY,$LastX,$this->GraphAreaY2 - $XMargin,$Color);

  4085.              if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($LastX+$ImageMapPlotSize).",".floor($this->GraphAreaY2-$XMargin+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4086.             }

  4087.           }

  4088.         }

  4089.       }

  4090.     }

  4091. 

  4092.    /* Draw a step chart */

  4093.    function drawFilledStepChart($Format=NULL)

  4094.     {

  4095.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;

  4096.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;

  4097.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  4098.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  4099.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;

  4100.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  4101.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  4102.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  4103.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

  4104. 

  4105.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  4106. 

  4107.      $Data = $this->DataSet->getData();

  4108.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  4109.      foreach($Data["Series"] as $SerieName => $Serie)

  4110.       {

  4111.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  4112.         {

  4113.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  4114. 

  4115.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  4116. 

  4117.          $AxisID	= $Serie["Axis"];

  4118.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  4119.          $Format	= $Data["Axis"][$AxisID]["Format"];

  4120.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  4121. 

  4122.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B);

  4123.          if ( $ForceTransparency != NULL ) { $Color["Alpha"] = $ForceTransparency; } else { $Color["Alpha"] = $Alpha; }

  4124. 

  4125.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  4126.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

  4127. 

  4128.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  4129. 

  4130.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  4131.           {

  4132.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4133.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

  4134. 

  4135.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  4136.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

  4137. 

  4138.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }

  4139. 

  4140.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4141.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = ""; $Init = FALSE;

  4142.            foreach($PosArray as $Key => $Y)

  4143.             {

  4144.              if ( $Y == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )

  4145.               {

  4146.                $Points[] = $LastX; $Points[] = $LastY;

  4147.                $Points[] = $X; $Points[] = $LastY;

  4148.                $Points[] = $X; $Points[] = $YZero;

  4149.                $this->drawPolygon($Points,$Color);

  4150.                $Points = "";

  4151.               }

  4152. 

  4153.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

  4154.               {

  4155.                if ( $Points == "") { $Points[] = $LastX; $Points[] = $YZero; }

  4156.                $Points[] = $LastX; $Points[] = $LastY;

  4157.                $Points[] = $X; $Points[] = $LastY;

  4158.                $Points[] = $X; $Points[] = $Y;

  4159.               }

  4160. 

  4161.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  4162.              if ( $Y == VOID ) { $Y = NULL; }

  4163. 

  4164.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }

  4165.              $LastX = $X; $LastY = $Y;

  4166.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }

  4167.              $X = $X + $XStep;

  4168.             }

  4169. 

  4170.            if ( $ReCenter )

  4171.             {

  4172.              $Points[] = $LastX+$XStep/2; $Points[] = $LastY;

  4173.              $Points[] = $LastX+$XStep/2; $Points[] = $YZero;

  4174.             }

  4175.            else

  4176.             { $Points[] = $LastX; $Points[] = $YZero; }

  4177. 

  4178.            $this->drawPolygon($Points,$Color);

  4179.           }

  4180.          else

  4181.           {

  4182.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  4183.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  4184. 

  4185.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  4186.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

  4187. 

  4188.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4189.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = "";

  4190.            foreach($PosArray as $Key => $X)

  4191.             {

  4192.              if ( $X == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )

  4193.               {

  4194.                $Points[] = $LastX; $Points[] = $LastY;

  4195.                $Points[] = $LastX; $Points[] = $Y;

  4196.                $Points[] = $YZero; $Points[] = $Y;

  4197.                $this->drawPolygon($Points,$Color);

  4198.                $Points = "";

  4199.               }

  4200. 

  4201.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

  4202.               {

  4203.                if ( $Points == "") { $Points[] = $YZero; $Points[] = $LastY; }

  4204.                $Points[] = $LastX; $Points[] = $LastY;

  4205.                $Points[] = $LastX; $Points[] = $Y;

  4206.                $Points[] = $X; $Points[] = $Y;

  4207.               }

  4208. 

  4209.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

  4210.              if ( $X == VOID ) { $X = NULL; }

  4211. 

  4212.              if ( $LastX == NULL && $ReCenter ) { $Y = $Y - $YStep/2; }

  4213.              $LastX = $X; $LastY = $Y;

  4214.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }

  4215.              $Y = $Y + $YStep;

  4216.             }

  4217. 

  4218.            if ( $ReCenter )

  4219.             {

  4220.              $Points[] = $LastX; $Points[] = $LastY+$YStep/2;

  4221.              $Points[] = $YZero; $Points[] = $LastY+$YStep/2;

  4222.             }

  4223.            else

  4224.             { $Points[] = $YZero; $Points[] = $LastY; }

  4225. 

  4226.            $this->drawPolygon($Points,$Color);

  4227.           }

  4228.         }

  4229.       }

  4230.     }

  4231. 

  4232.    /* Draw an area chart */

  4233.    function drawAreaChart($Format=NULL)

  4234.     {

  4235.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  4236.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  4237.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  4238.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  4239.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  4240.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  4241.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : 25;

  4242.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

  4243.      $Threshold		= isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

  4244. 

  4245.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  4246. 

  4247.      $Data  = $this->DataSet->getData();

  4248.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  4249. 

  4250.      foreach($Data["Series"] as $SerieName => $Serie)

  4251.       {

  4252.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  4253.         {

  4254.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  4255.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  4256. 

  4257.          $AxisID	= $Serie["Axis"];

  4258.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  4259.          $Format	= $Data["Axis"][$AxisID]["Format"];

  4260.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  4261. 

  4262.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  4263.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

  4264. 

  4265.          if ( $Threshold != NULL )

  4266.           {

  4267.            foreach($Threshold as $Key => $Params)

  4268.             {

  4269.              $Threshold[$Key]["MinX"] = $this->scaleComputeY($Params["Min"],array("AxisID"=>$Serie["Axis"]));

  4270.              $Threshold[$Key]["MaxX"] = $this->scaleComputeY($Params["Max"],array("AxisID"=>$Serie["Axis"]));

  4271.             }

  4272.           }

  4273. 

  4274.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  4275. 

  4276.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  4277.           {

  4278.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4279. 

  4280.            $Areas = ""; $AreaID = 0; 

  4281.            $Areas[$AreaID][] = $this->GraphAreaX1 + $XMargin;

  4282.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

  4283. 

  4284.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  4285.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

  4286. 

  4287.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4288.            foreach($PosArray as $Key => $Y)

  4289.             {

  4290.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

  4291.               {

  4292.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

  4293.                $this->drawText($X,$Y-$Offset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

  4294.               }

  4295. 

  4296.              if ( $Y == VOID && isset($Areas[$AreaID]) )

  4297.               {

  4298.                if($LastX == NULL)

  4299.                 { $Areas[$AreaID][] = $X; }

  4300.                else

  4301.                 { $Areas[$AreaID][] = $LastX; }

  4302. 

  4303.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

  4304.                $AreaID++;

  4305.               }

  4306.              elseif ($Y != VOID)

  4307.               {

  4308.                if ( !isset($Areas[$AreaID]) )

  4309.                 {

  4310.                  $Areas[$AreaID][] = $X;

  4311.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

  4312.                 }

  4313. 

  4314.                $Areas[$AreaID][] = $X;

  4315.                $Areas[$AreaID][] = $Y;

  4316.               }

  4317. 

  4318.              $LastX = $X;

  4319.              $X = $X + $XStep;

  4320.             }

  4321.            $Areas[$AreaID][] = $LastX;

  4322.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

  4323. 

  4324.            /* Handle shadows in the areas */

  4325.            if ( $this->Shadow )

  4326.             {

  4327.              $ShadowArea = "";

  4328.              foreach($Areas as $Key => $Points)

  4329.               {

  4330.                $ShadowArea[$Key] = "";

  4331.                foreach($Points as $Key2 => $Value)

  4332.                 {

  4333.                  if ( $Key2 % 2 == 0 )

  4334.                   { $ShadowArea[$Key][] = $Value + $this->ShadowX; }

  4335.                  else

  4336.                   { $ShadowArea[$Key][] = $Value + $this->ShadowY; }

  4337.                 }

  4338.               }              

  4339. 

  4340.              foreach($ShadowArea as $Key => $Points)

  4341.               $this->drawPolygonChart($Points,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  4342.             }

  4343. 

  4344.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;

  4345.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Threshold"=>$Threshold);

  4346. 

  4347.            foreach($Areas as $Key => $Points)

  4348.             $this->drawPolygonChart($Points,$Color);

  4349.           }

  4350.          else

  4351.           {

  4352.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  4353.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  4354. 

  4355.            $Areas = ""; $AreaID = 0; 

  4356.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

  4357.            $Areas[$AreaID][] = $this->GraphAreaY1 + $XMargin;

  4358. 

  4359.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  4360.            $Y     = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

  4361. 

  4362.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4363.            foreach($PosArray as $Key => $X)

  4364.             {

  4365.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

  4366.               {

  4367.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

  4368.                $this->drawText($X+$Offset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

  4369.               }

  4370. 

  4371.              if ( $X == VOID && isset($Areas[$AreaID]) )

  4372.               {

  4373.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

  4374. 

  4375.                if($LastY == NULL)

  4376.                 { $Areas[$AreaID][] = $Y; }

  4377.                else

  4378.                 { $Areas[$AreaID][] = $LastY; }

  4379. 

  4380.                $AreaID++;

  4381.               }

  4382.              elseif ($X != VOID)

  4383.               {

  4384.                if ( !isset($Areas[$AreaID]) )

  4385.                 {

  4386.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

  4387.                  $Areas[$AreaID][] = $Y;

  4388.                 }

  4389. 

  4390.                $Areas[$AreaID][] = $X;

  4391.                $Areas[$AreaID][] = $Y;

  4392.               }

  4393. 

  4394.              $LastX = $X; $LastY = $Y;

  4395.              $Y = $Y + $YStep;

  4396.             }

  4397.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

  4398.            $Areas[$AreaID][] = $LastY;

  4399. 

  4400.            /* Handle shadows in the areas */

  4401.            if ( $this->Shadow )

  4402.             {

  4403.              $ShadowArea = "";

  4404.              foreach($Areas as $Key => $Points)

  4405.               {

  4406.                $ShadowArea[$Key] = "";

  4407.                foreach($Points as $Key2 => $Value)

  4408.                 {

  4409.                  if ( $Key2 % 2 == 0 )

  4410.                   { $ShadowArea[$Key][] = $Value + $this->ShadowX; }

  4411.                  else

  4412.                   { $ShadowArea[$Key][] = $Value + $this->ShadowY; }

  4413.                 }

  4414.               }              

  4415. 

  4416.              foreach($ShadowArea as $Key => $Points)

  4417.               $this->drawPolygonChart($Points,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  4418.             }

  4419. 

  4420.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;

  4421.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Threshold"=>$Threshold);

  4422. 

  4423.            foreach($Areas as $Key => $Points)

  4424.             $this->drawPolygonChart($Points,$Color);

  4425.           }

  4426.         }

  4427.       }

  4428.     }

  4429. 

  4430. 

  4431.    /* Draw a bar chart */

  4432.    function drawBarChart($Format=NULL)

  4433.     {

  4434.      $Floating0Serie	= isset($Format["Floating0Serie"]) ? $Format["Floating0Serie"] : NULL;

  4435.      $Floating0Value	= isset($Format["Floating0Value"]) ? $Format["Floating0Value"] : NULL;

  4436.      $Draw0Line		= isset($Format["Draw0Line"]) ? $Format["Draw0Line"] : FALSE;

  4437.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  4438.      $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_HORIZONTAL;

  4439.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

  4440.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  4441.      $DisplayFont	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontName;

  4442.      $DisplaySize	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;

  4443.      $DisplayPos	= isset($Format["DisplayPos"]) ? $Format["DisplayPos"] : LABEL_POS_OUTSIDE;

  4444.      $DisplayShadow	= isset($Format["DisplayShadow"]) ? $Format["DisplayShadow"] : TRUE;

  4445.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  4446.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  4447.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  4448.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

  4449.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;

  4450.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;

  4451.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;

  4452.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  4453.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  4454.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  4455.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  4456.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;

  4457.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;

  4458.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;

  4459.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

  4460.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

  4461.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

  4462.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;

  4463.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;

  4464.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;

  4465.      $TxtMargin		= isset($Format["TxtMargin"]) ? $Format["TxtMargin"] : 6;

  4466.      $OverrideColors	= isset($Format["OverrideColors"]) ? $Format["OverrideColors"] : NULL;

  4467.      $OverrideSurrounding = isset($Format["OverrideSurrounding"]) ? $Format["OverrideSurrounding"] : 30;

  4468.      $InnerSurrounding	= isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;

  4469.      $InnerBorderR	= isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;

  4470.      $InnerBorderG	= isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;

  4471.      $InnerBorderB	= isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;

  4472.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  4473. 

  4474.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

  4475. 

  4476.      $Data = $this->DataSet->getData();

  4477.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  4478. 

  4479.      if ( $OverrideColors != NULL )

  4480.       {

  4481.        $OverrideColors = $this->validatePalette($OverrideColors,$OverrideSurrounding);

  4482.        $this->DataSet->saveExtendedData("Palette",$OverrideColors);

  4483.       }

  4484. 

  4485.      $RestoreShadow = $this->Shadow;

  4486. 

  4487.      $SeriesCount  = $this->countDrawableSeries();

  4488.      $CurrentSerie = 0;

  4489.      foreach($Data["Series"] as $SerieName => $Serie)

  4490.       {

  4491.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  4492.         {

  4493.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  4494.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

  4495.          if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  4496.          if ( $InnerSurrounding != NULL ) { $InnerBorderR = $R+$InnerSurrounding; $InnerBorderG = $G+$InnerSurrounding; $InnerBorderB = $B+$InnerSurrounding; }

  4497.          if ( $InnerBorderR == -1 ) { $InnerColor = NULL; } else { $InnerColor = array("R"=>$InnerBorderR,"G"=>$InnerBorderG,"B"=>$InnerBorderB); }

  4498.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);

  4499. 

  4500.          $AxisID	= $Serie["Axis"];

  4501.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  4502.          $Format	= $Data["Axis"][$AxisID]["Format"];

  4503.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  4504. 

  4505.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  4506. 

  4507.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  4508. 

  4509.          if ( $Floating0Value != NULL )

  4510.           { $YZero = $this->scaleComputeY($Floating0Value,array("AxisID"=>$Serie["Axis"])); }

  4511.          else

  4512.           { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }

  4513. 

  4514.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  4515.           {

  4516.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4517.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

  4518. 

  4519.            if ( $XDivs == 0 ) { $XStep = 0; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  4520.            $X = $this->GraphAreaX1 + $XMargin;

  4521. 

  4522.            if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }

  4523.            if ( $XDivs == 0 ) { $XSize = ($this->GraphAreaX2-$this->GraphAreaX1)/($SeriesCount+$Interleave); } else { $XSize   = ($XStep / ($SeriesCount+$Interleave) ); }

  4524. 

  4525.            $XOffset = -($XSize*$SeriesCount)/2 + $CurrentSerie * $XSize;

  4526.            if ( $X + $XOffset <= $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $X + 1 ; }

  4527. 

  4528.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $XOffset + $XSize / 2;

  4529. 

  4530.            if ( $Rounded || $BorderR != -1) { $XSpace = 1; } else { $XSpace = 0; }

  4531. 

  4532.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4533. 

  4534.            $ID = 0;

  4535.            foreach($PosArray as $Key => $Y2)

  4536.             {

  4537.              if ( $Floating0Serie != NULL )

  4538.               {

  4539.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )

  4540.                 { $Value = $Data["Series"][$Floating0Serie]["Data"][$Key]; }

  4541.                else

  4542.                 { $Value = 0; }

  4543. 

  4544.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));

  4545.                if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4546.                if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

  4547. 

  4548.                if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }

  4549.               }

  4550. 

  4551.              if ( $OverrideColors != NULL )

  4552.               { if ( isset($OverrideColors[$ID]) ) { $Color = array("R"=>$OverrideColors[$ID]["R"],"G"=>$OverrideColors[$ID]["G"],"B"=>$OverrideColors[$ID]["B"],"Alpha"=>$OverrideColors[$ID]["Alpha"],"BorderR"=>$OverrideColors[$ID]["BorderR"],"BorderG"=>$OverrideColors[$ID]["BorderG"],"BorderB"=>$OverrideColors[$ID]["BorderB"]); } else { $Color = $this->getRandomColor(); } }

  4553. 

  4554.              if ( $Y2 != VOID )

  4555.               {

  4556.                $BarHeight = $Y1 - $Y2;

  4557. 

  4558.                if ( $Serie["Data"][$Key] == 0 )

  4559.                 {

  4560.                  $this->drawLine($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y1,$Color);

  4561.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset+$XSpace).",".floor($Y1-1).",".floor($X+$XOffset+$XSize-$XSpace).",".floor($Y1+1),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4562.                 }

  4563.                else

  4564.                 {

  4565.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset+$XSpace).",".floor($Y1).",".floor($X+$XOffset+$XSize-$XSpace).",".floor($Y2),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4566. 

  4567.                  if ( $Rounded )

  4568.                   $this->drawRoundedFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$RoundRadius,$Color);

  4569.                  else

  4570.                   {

  4571.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$Color);

  4572. 

  4573.                    if ( $InnerColor != NULL ) { $this->drawRectangle($X+$XOffset+$XSpace+1,min($Y1,$Y2)+1,$X+$XOffset+$XSize-$XSpace-1,max($Y1,$Y2)-1,$InnerColor); }

  4574. 

  4575.                    if ( $Gradient )

  4576.                     {

  4577.                      $this->Shadow  = FALSE;

  4578. 

  4579.                      if ( $GradientMode == GRADIENT_SIMPLE )

  4580.                       {

  4581.                        if ( $Serie["Data"][$Key] >= 0 )

  4582.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4583.                        else

  4584.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4585. 

  4586.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_VERTICAL,$GradienColor);

  4587.                       }

  4588.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

  4589.                       {

  4590.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4591.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4592.                        $XSpan = floor($XSize / 3);

  4593. 

  4594.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSpan-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor1);

  4595.                        $this->drawGradientArea($X+$XOffset+$XSpan+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor2);

  4596.                       }

  4597.                      $this->Shadow = $RestoreShadow;

  4598.                     }

  4599.                   }

  4600. 

  4601.                  if ( $Draw0Line )

  4602.                   {

  4603.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);

  4604. 

  4605.                    if ( abs($Y1 - $Y2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }

  4606.                    if ( $Y1 - $Y2 < 0 ) { $Line0Width = -$Line0Width; }

  4607. 

  4608.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1)-$Line0Width,$Line0Color);

  4609.                    $this->drawLine($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1),$Line0Color);

  4610.                   }

  4611.                 }

  4612. 

  4613.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

  4614.                 {

  4615.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }

  4616. 

  4617.                  $Caption    = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);

  4618.                  $TxtPos     = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,90,$Caption);

  4619.                  $TxtHeight  = $TxtPos[0]["Y"] - $TxtPos[1]["Y"] + $TxtMargin;

  4620. 

  4621.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtHeight) < abs($BarHeight) )

  4622.                   {

  4623.                    $CenterX = (($X+$XOffset+$XSize-$XSpace)-($X+$XOffset+$XSpace))/2 + $X+$XOffset+$XSpace;

  4624.                    $CenterY = ($Y2-$Y1)/2 + $Y1;

  4625. 

  4626.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"Angle"=>90));

  4627.                   }

  4628.                  else

  4629.                   {

  4630.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

  4631.                    $this->drawText($X+$XOffset+$XSize/2,$Y2-$Offset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align,"FontSize"=>$DisplaySize));

  4632.                   }

  4633. 

  4634.                  $this->Shadow = $RestoreShadow;

  4635.                 }

  4636.               }

  4637. 

  4638.              $X = $X + $XStep;

  4639.              $ID++;

  4640.             }

  4641.           }

  4642.          else

  4643.           {

  4644.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  4645.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  4646. 

  4647.            if ( $XDivs == 0 ) { $YStep = 0; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  4648.            

  4649.            $Y = $this->GraphAreaY1 + $XMargin;

  4650. 

  4651.            if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }

  4652.            if ( $XDivs == 0 ) { $YSize = ($this->GraphAreaY2-$this->GraphAreaY1)/($SeriesCount+$Interleave); } else { $YSize   = ($YStep / ($SeriesCount+$Interleave) ); }

  4653.            

  4654.            $YOffset = -($YSize*$SeriesCount)/2 + $CurrentSerie * $YSize;

  4655.            if ( $Y + $YOffset <= $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $Y + 1 ; }

  4656. 

  4657.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $YOffset + $YSize / 2;

  4658. 

  4659.            if ( $Rounded || $BorderR != -1 ) { $YSpace = 1; } else { $YSpace = 0; }

  4660. 

  4661.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4662. 

  4663.            $ID = 0 ;

  4664.            foreach($PosArray as $Key => $X2)

  4665.             {

  4666.              if ( $Floating0Serie != NULL )

  4667.               {

  4668.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )

  4669.                 $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];

  4670.                else { $Value = 0; }

  4671. 

  4672.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));

  4673.                if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  4674.                if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  4675.                if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }

  4676.               }

  4677. 

  4678.              if ( $OverrideColors != NULL )

  4679.               { if ( isset($OverrideColors[$ID]) ) { $Color = array("R"=>$OverrideColors[$ID]["R"],"G"=>$OverrideColors[$ID]["G"],"B"=>$OverrideColors[$ID]["B"],"Alpha"=>$OverrideColors[$ID]["Alpha"],"BorderR"=>$OverrideColors[$ID]["BorderR"],"BorderG"=>$OverrideColors[$ID]["BorderG"],"BorderB"=>$OverrideColors[$ID]["BorderB"]); } else { $Color = $this->getRandomColor(); } }

  4680. 

  4681.              if ( $X2 != VOID )

  4682.               {

  4683.                $BarWidth = $X2 - $X1;

  4684. 

  4685.                if ( $Serie["Data"][$Key] == 0 )

  4686.                 {

  4687.                  $this->drawLine($X1,$Y+$YOffset+$YSpace,$X1,$Y+$YOffset+$YSize-$YSpace,$Color);

  4688.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1-1).",".floor($Y+$YOffset+$YSpace).",".floor($X1+1).",".floor($Y+$YOffset+$YSize-$YSpace),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4689.                 }

  4690.                else

  4691.                 {

  4692.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1).",".floor($Y+$YOffset+$YSpace).",".floor($X2).",".floor($Y+$YOffset+$YSize-$YSpace),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4693. 

  4694.                  if ( $Rounded )

  4695.                   $this->drawRoundedFilledRectangle($X1+1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$RoundRadius,$Color);

  4696.                  else

  4697.                   {

  4698.                    $this->drawFilledRectangle($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$Color);

  4699. 

  4700.                    if ( $InnerColor != NULL ) { $this->drawRectangle(min($X1,$X2)+1,$Y+$YOffset+$YSpace+1,max($X1,$X2)-1,$Y+$YOffset+$YSize-$YSpace-1,$InnerColor); }

  4701. 

  4702.                    if ( $Gradient )

  4703.                     {

  4704.                      $this->Shadow  = FALSE;

  4705. 

  4706.                      if ( $GradientMode == GRADIENT_SIMPLE )

  4707.                       {

  4708.                        if ( $Serie["Data"][$Key] >= 0 )

  4709.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4710.                        else

  4711.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4712. 

  4713.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_HORIZONTAL,$GradienColor);

  4714.                       }

  4715.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

  4716.                       {

  4717.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4718.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4719.                        $YSpan = floor($YSize / 3);

  4720. 

  4721.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSpan-$YSpace,DIRECTION_VERTICAL,$GradienColor1);

  4722.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpan,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_VERTICAL,$GradienColor2);

  4723.                       }

  4724.                      $this->Shadow = $RestoreShadow;

  4725.                     }

  4726.                   }

  4727. 

  4728.                  if ( $Draw0Line )

  4729.                   {

  4730.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);

  4731. 

  4732.                    if ( abs($X1 - $X2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }

  4733.                    if ( $X2 - $X1 < 0 ) { $Line0Width = -$Line0Width; }

  4734. 

  4735.                    $this->drawFilledRectangle(floor($X1),$Y+$YOffset+$YSpace,floor($X1)+$Line0Width,$Y+$YOffset+$YSize-$YSpace,$Line0Color);

  4736.                    $this->drawLine(floor($X1),$Y+$YOffset+$YSpace,floor($X1),$Y+$YOffset+$YSize-$YSpace,$Line0Color);

  4737.                   }

  4738.                 }

  4739. 

  4740.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

  4741.                 {

  4742.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }

  4743. 

  4744.                  $Caption   = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);

  4745.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

  4746.                  $TxtWidth  = $TxtPos[1]["X"] - $TxtPos[0]["X"] + $TxtMargin;

  4747. 

  4748.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtWidth) < abs($BarWidth) )

  4749.                   {

  4750.                    $CenterX = ($X2-$X1)/2 + $X1;

  4751.                    $CenterY = (($Y+$YOffset+$YSize-$YSpace)-($Y+$YOffset+$YSpace))/2 + ($Y+$YOffset+$YSpace);

  4752. 

  4753.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize));

  4754.                   }

  4755.                  else

  4756.                   {

  4757.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }

  4758.                    $this->drawText($X2+$Offset,$Y+$YOffset+$YSize/2,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align,"FontSize"=>$DisplaySize));

  4759.                   }

  4760. 

  4761.                  $this->Shadow = $RestoreShadow;

  4762.                 }

  4763.               }

  4764.              $Y = $Y + $YStep;

  4765.              $ID++;

  4766.             }

  4767.           }

  4768.          $CurrentSerie++;

  4769.         }

  4770.       }

  4771.     }

  4772. 

  4773.    /* Draw a bar chart */

  4774.    function drawStackedBarChart($Format=NULL)

  4775.     {

  4776.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

  4777.      $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_AUTO;

  4778.      $DisplayRound      = isset($Format["DisplayRound"]) ? $Format["DisplayRound"] : 0;

  4779.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

  4780.      $DisplayFont	= isset($Format["DisplayFont"]) ? $Format["DisplayFont"] : $this->FontName;

  4781.      $DisplaySize	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;

  4782.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

  4783.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

  4784.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

  4785.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;

  4786.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;

  4787.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;

  4788.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  4789.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

  4790.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

  4791.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

  4792.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;

  4793.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;

  4794.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;

  4795.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

  4796.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

  4797.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

  4798.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;

  4799.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;

  4800.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;

  4801.      $InnerSurrounding	= isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;

  4802.      $InnerBorderR	= isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;

  4803.      $InnerBorderG	= isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;

  4804.      $InnerBorderB	= isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;

  4805.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

  4806.      $FontFactor	= isset($Format["FontFactor"]) ? $Format["FontFactor"] : 8;

  4807. 

  4808.      $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;

  4809. 

  4810.      $Data = $this->DataSet->getData();

  4811.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  4812. 

  4813.      $RestoreShadow = $this->Shadow;

  4814. 

  4815.      $LastX = ""; $LastY = "";

  4816.      foreach($Data["Series"] as $SerieName => $Serie)

  4817.       {

  4818.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  4819.         {

  4820.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  4821.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = 255; $DisplayG = 255; $DisplayB = 255; }

  4822.          if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  4823.          if ( $InnerSurrounding != NULL ) { $InnerBorderR = $R+$InnerSurrounding; $InnerBorderG = $G+$InnerSurrounding; $InnerBorderB = $B+$InnerSurrounding; }

  4824.          if ( $InnerBorderR == -1 ) { $InnerColor = NULL; } else { $InnerColor = array("R"=>$InnerBorderR,"G"=>$InnerBorderG,"B"=>$InnerBorderB); }

  4825. 

  4826.          $AxisID	= $Serie["Axis"];

  4827.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  4828.          $Format	= $Data["Axis"][$AxisID]["Format"];

  4829.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  4830. 

  4831.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

  4832. 

  4833.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);

  4834.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

  4835. 

  4836.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  4837. 

  4838.          $Color = array("TransCorner"=>TRUE,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);

  4839. 

  4840.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  4841.           {

  4842.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4843.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  4844. 

  4845.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  4846.            $X     = $this->GraphAreaX1 + $XMargin;

  4847. 

  4848.            $XSize   = ($XStep / (1+$Interleave) );

  4849.            $XOffset = -($XSize/2);

  4850. 

  4851.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4852.            foreach($PosArray as $Key => $Height)

  4853.             {

  4854.              if ( $Height != VOID && $Serie["Data"][$Key] != 0 )

  4855.               {

  4856.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }

  4857. 

  4858.                if ( !isset($LastY[$Key] ) ) { $LastY[$Key] = ""; }

  4859.                if ( !isset($LastY[$Key][$Pos] ) ) { $LastY[$Key][$Pos] = $YZero; }

  4860. 

  4861.                $Y1 = $LastY[$Key][$Pos];

  4862.                $Y2 = $Y1 - $Height;

  4863. 

  4864.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $Y1 != $YZero) ) { $YSpaceUp = 1; } else { $YSpaceUp = 0; }

  4865.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $Y1 != $YZero) ) { $YSpaceDown = 1; } else { $YSpaceDown = 0; }

  4866. 

  4867.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset).",".floor($Y1-$YSpaceUp+$YSpaceDown).",".floor($X+$XOffset+$XSize).",".floor($Y2),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4868. 

  4869.                if ( $Rounded )

  4870.                 $this->drawRoundedFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$RoundRadius,$Color);

  4871.                else

  4872.                 {

  4873.                  $this->drawFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$Color);

  4874. 

  4875.                  if ( $InnerColor != NULL ) { $RestoreShadow = $this->Shadow; $this->Shadow = FALSE; $this->drawRectangle(min($X+$XOffset+1,$X+$XOffset+$XSize),min($Y1-$YSpaceUp+$YSpaceDown,$Y2)+1,max($X+$XOffset+1,$X+$XOffset+$XSize)-1,max($Y1-$YSpaceUp+$YSpaceDown,$Y2)-1,$InnerColor); $this->Shadow = $RestoreShadow;}

  4876. 

  4877.                  if ( $Gradient )

  4878.                   {

  4879.                    $this->Shadow  = FALSE;

  4880. 

  4881.                    if ( $GradientMode == GRADIENT_SIMPLE )

  4882.                     {

  4883.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4884.                      $this->drawGradientArea($X+$XOffset,$Y1-1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+1,DIRECTION_VERTICAL,$GradientColor);

  4885.                     }

  4886.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

  4887.                     {

  4888.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4889.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4890.                      $XSpan = floor($XSize / 3);

  4891. 

  4892.                      $this->drawGradientArea($X+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSpan,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor1);

  4893.                      $this->drawGradientArea($X+$XSpan+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor2);

  4894.                     }

  4895.                    $this->Shadow = $RestoreShadow;

  4896.                   }

  4897.                 }

  4898. 

  4899.                if ( $DisplayValues )

  4900.                 {

  4901.                  $BarHeight = abs($Y2-$Y1)-2;

  4902.                  $BarWidth  = $XSize+($XOffset/2)-$FontFactor;

  4903. 

  4904.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);

  4905.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

  4906.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);

  4907.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);

  4908. 

  4909.                  $XCenter = ( ($X+$XOffset+$XSize) - ($X+$XOffset) ) / 2 + $X+$XOffset;

  4910.                  $YCenter = ( ($Y2) - ($Y1-$YSpaceUp+$YSpaceDown) ) / 2 + $Y1-$YSpaceUp+$YSpaceDown;

  4911. 

  4912.                  $Done = FALSE;

  4913.                  if ( $DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO )

  4914.                   {

  4915.                    if ( $TxtHeight < $BarHeight && $TxtWidth < $BarWidth  )

  4916.                     {

  4917.                      $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

  4918.                      $Done = TRUE;

  4919.                     }

  4920.                   }

  4921. 

  4922.                  if ( $DisplayOrientation == ORIENTATION_VERTICAL || ( $DisplayOrientation == ORIENTATION_AUTO && !$Done) )

  4923.                   {

  4924.                    if ( $TxtHeight < $BarWidth && $TxtWidth < $BarHeight  )

  4925.                     $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Angle"=>90,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

  4926.                   }

  4927.                 }

  4928. 

  4929.                $LastY[$Key][$Pos] = $Y2;

  4930.               }

  4931. 

  4932.              $X = $X + $XStep;

  4933.             }

  4934.           }

  4935.          else

  4936.           {

  4937.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  4938.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  4939. 

  4940.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  4941.            $Y     = $this->GraphAreaY1 + $XMargin;

  4942. 

  4943.            $YSize   = $YStep / (1+$Interleave);

  4944.            $YOffset = -($YSize/2);

  4945. 

  4946.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  4947.            foreach($PosArray as $Key => $Width)

  4948.             {

  4949.              if ( $Width != VOID && $Serie["Data"][$Key] != 0 )

  4950.               {

  4951.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }

  4952. 

  4953.                if ( !isset($LastX[$Key] ) ) { $LastX[$Key] = ""; }

  4954.                if ( !isset($LastX[$Key][$Pos] ) ) { $LastX[$Key][$Pos] = $YZero; }

  4955. 

  4956.                $X1 = $LastX[$Key][$Pos];

  4957.                $X2 = $X1 + $Width;

  4958. 

  4959.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $X1 != $YZero) ) { $XSpaceLeft = 2; } else { $XSpaceLeft = 0; }

  4960.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $X1 != $YZero) ) { $XSpaceRight = 2; } else { $XSpaceRight = 0; }

  4961. 

  4962.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1+$XSpaceLeft).",".floor($Y+$YOffset).",".floor($X2-$XSpaceRight).",".floor($Y+$YOffset+$YSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

  4963. 

  4964.                if ( $Rounded )

  4965.                 $this->drawRoundedFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$RoundRadius,$Color);

  4966.                else

  4967.                 {

  4968.                  $this->drawFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$Color);

  4969. 

  4970.                  if ( $InnerColor != NULL ) { $RestoreShadow = $this->Shadow; $this->Shadow = FALSE; $this->drawRectangle(min($X1+$XSpaceLeft,$X2-$XSpaceRight)+1,min($Y+$YOffset,$Y+$YOffset+$YSize)+1,max($X1+$XSpaceLeft,$X2-$XSpaceRight)-1,max($Y+$YOffset,$Y+$YOffset+$YSize)-1,$InnerColor); $this->Shadow = $RestoreShadow;}

  4971. 

  4972.                  if ( $Gradient )

  4973.                   {

  4974.                    $this->Shadow  = FALSE;

  4975. 

  4976.                    if ( $GradientMode == GRADIENT_SIMPLE )

  4977.                     {

  4978.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4979.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_HORIZONTAL,$GradientColor);

  4980.                     }

  4981.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

  4982.                     {

  4983.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

  4984.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

  4985.                      $YSpan = floor($YSize / 3);

  4986. 

  4987.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSpan,DIRECTION_VERTICAL,$GradientColor1);

  4988.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset+$YSpan,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_VERTICAL,$GradientColor2);

  4989.                     }

  4990.                    $this->Shadow = $RestoreShadow;

  4991.                   }

  4992.                 }

  4993. 

  4994.                if ( $DisplayValues )

  4995.                 {

  4996.                  $BarWidth = abs($X2-$X1)-$FontFactor;

  4997.                  $BarHeight = $YSize+($YOffset/2)-$FontFactor/2;

  4998.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);

  4999.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

  5000.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);

  5001.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);

  5002. 

  5003.                  $XCenter  = ( $X2 - $X1 ) / 2 + $X1;

  5004.                  $YCenter  = ( ($Y+$YOffset+$YSize) - ($Y+$YOffset) ) / 2 + $Y+$YOffset;

  5005. 

  5006.                  $Done = FALSE;

  5007.                  if ( $DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO )

  5008.                   {

  5009.                    if ( $TxtHeight < $BarHeight && $TxtWidth < $BarWidth  )

  5010.                     {

  5011.                      $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

  5012.                      $Done = TRUE;

  5013.                     }

  5014.                   }

  5015. 

  5016.                  if ( $DisplayOrientation == ORIENTATION_VERTICAL || ( $DisplayOrientation == ORIENTATION_AUTO && !$Done) )

  5017.                   {

  5018.                    if ( $TxtHeight < $BarWidth && $TxtWidth < $BarHeight  )

  5019.                     $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Angle"=>90,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

  5020.                   }

  5021.                 }

  5022. 

  5023.                $LastX[$Key][$Pos] = $X2;

  5024.               }

  5025. 

  5026.              $Y = $Y + $YStep;

  5027.             }

  5028.           }

  5029.         }

  5030.       }

  5031.     }

  5032. 

  5033.    /* Draw a stacked area chart */

  5034.    function drawStackedAreaChart($Format=NULL)

  5035.     {

  5036.      $DrawLine		= isset($Format["DrawLine"]) ? $Format["DrawLine"] : FALSE;

  5037.      $LineSurrounding	= isset($Format["LineSurrounding"]) ? $Format["LineSurrounding"] : NULL;

  5038.      $LineR		= isset($Format["LineR"]) ? $Format["LineR"] : VOID;

  5039.      $LineG		= isset($Format["LineG"]) ? $Format["LineG"] : VOID;

  5040.      $LineB		= isset($Format["LineB"]) ? $Format["LineB"] : VOID;

  5041.      $LineAlpha		= isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 100;

  5042.      $DrawPlot		= isset($Format["DrawPlot"]) ? $Format["DrawPlot"] : FALSE;

  5043.      $PlotRadius	= isset($Format["PlotRadius"]) ? $Format["PlotRadius"] : 2;

  5044.      $PlotBorder	= isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : 1;

  5045.      $PlotBorderSurrounding = isset($Format["PlotBorderSurrounding"]) ? $Format["PlotBorderSurrounding"] : NULL;

  5046.      $PlotBorderR	= isset($Format["PlotBorderR"]) ? $Format["PlotBorderR"] : 0;

  5047.      $PlotBorderG	= isset($Format["PlotBorderG"]) ? $Format["PlotBorderG"] : 0;

  5048.      $PlotBorderB	= isset($Format["PlotBorderB"]) ? $Format["PlotBorderB"] : 0;

  5049.      $PlotBorderAlpha	= isset($Format["PlotBorderAlpha"]) ? $Format["PlotBorderAlpha"] : 50;

  5050.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;

  5051. 

  5052.      $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;

  5053. 

  5054.      $Data = $this->DataSet->getData();

  5055.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  5056. 

  5057.      $RestoreShadow = $this->Shadow;

  5058.      $this->Shadow  = FALSE;

  5059. 

  5060.      /* Build the offset data series */

  5061.      $OffsetData    = "";

  5062.      $OverallOffset = "";

  5063.      $SerieOrder    = "";

  5064.      foreach($Data["Series"] as $SerieName => $Serie)

  5065.       {

  5066.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  5067.         {

  5068.          $SerieOrder[] = $SerieName;

  5069. 

  5070.          foreach($Serie["Data"] as $Key => $Value)

  5071.           {

  5072.            if ( $Value == VOID ) { $Value = 0; }

  5073.            if ($Value >= 0) { $Sign = "+"; } else { $Sign = "-"; }

  5074.            if ( !isset($OverallOffset[$Key]) || !isset($OverallOffset[$Key][$Sign]) ) { $OverallOffset[$Key][$Sign] = 0; }

  5075. 

  5076.            if ( $Sign == "+" )

  5077.             { $Data["Series"][$SerieName]["Data"][$Key] = $Value + $OverallOffset[$Key][$Sign]; }

  5078.            else

  5079.             { $Data["Series"][$SerieName]["Data"][$Key] = $Value - $OverallOffset[$Key][$Sign]; }

  5080. 

  5081.            $OverallOffset[$Key][$Sign] = $OverallOffset[$Key][$Sign] + abs($Value);

  5082.           }

  5083.         } 

  5084.       }

  5085.      $SerieOrder = array_reverse($SerieOrder);

  5086. 

  5087.      $LastX = ""; $LastY = "";

  5088.      foreach($SerieOrder as $Key => $SerieName)

  5089.       {

  5090.        $Serie = $Data["Series"][$SerieName];

  5091.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  5092.         {

  5093.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

  5094.          if ( $ForceTransparency != NULL ) { $Alpha = $ForceTransparency; }

  5095. 

  5096.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

  5097. 

  5098.          if ( $LineSurrounding != NULL )

  5099.           $LineColor = array("R"=>$R+$LineSurrounding,"G"=>$G+$LineSurrounding,"B"=>$B+$LineSurrounding,"Alpha"=>$Alpha);

  5100.          elseif ( $LineR != VOID )

  5101.           $LineColor = array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha);

  5102.          else

  5103.           $LineColor = $Color;

  5104. 

  5105.          if ( $PlotBorderSurrounding != NULL )

  5106.           $PlotBorderColor = array("R"=>$R+$PlotBorderSurrounding,"G"=>$G+$PlotBorderSurrounding,"B"=>$B+$PlotBorderSurrounding,"Alpha"=>$PlotBorderAlpha);

  5107.          else

  5108.           $PlotBorderColor = array("R"=>$PlotBorderR,"G"=>$PlotBorderG,"B"=>$PlotBorderB,"Alpha"=>$PlotBorderAlpha);

  5109. 

  5110.          $AxisID	= $Serie["Axis"];

  5111.          $Mode		= $Data["Axis"][$AxisID]["Display"];

  5112.          $Format	= $Data["Axis"][$AxisID]["Format"];

  5113.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

  5114. 

  5115.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);

  5116.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

  5117. 

  5118.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

  5119. 

  5120.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  5121.           {

  5122.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

  5123.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

  5124. 

  5125.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  5126.            $X = $this->GraphAreaX1 + $XMargin;

  5127. 

  5128.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5129. 

  5130.            $Plots = ""; $Plots[] = $X; $Plots[] = $YZero;

  5131.            foreach($PosArray as $Key => $Height)

  5132.             {

  5133.              if ( $Height != VOID ) { $Plots[] = $X; $Plots[] = $YZero-$Height; }

  5134.              $X = $X + $XStep;

  5135.             }

  5136.            $Plots[] = $X-$XStep; $Plots[] = $YZero;

  5137. 

  5138.            $this->drawPolygon($Plots,$Color);

  5139. 

  5140.            $this->Shadow = $RestoreShadow;

  5141.            if ( $DrawLine ) { for($i=2; $i<=count($Plots)-6; $i=$i+2) { $this->drawLine($Plots[$i],$Plots[$i+1],$Plots[$i+2],$Plots[$i+3],$LineColor); } }

  5142.            if ( $DrawPlot )

  5143.             {

  5144.              for($i=2; $i<=count($Plots)-4; $i=$i+2)

  5145.               {

  5146.                if ( $PlotBorder != 0 )

  5147.                 { $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius+$PlotBorder,$PlotBorderColor); }

  5148. 

  5149.                $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius,$Color);

  5150.               }

  5151.             }

  5152.            $this->Shadow = FALSE;

  5153.           }

  5154.          elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

  5155.           {

  5156.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

  5157.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

  5158. 

  5159.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  5160.            $Y = $this->GraphAreaY1 + $XMargin;

  5161. 

  5162.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5163. 

  5164.            $Plots = ""; $Plots[] = $YZero; $Plots[] = $Y;

  5165.            foreach($PosArray as $Key => $Height)

  5166.             {

  5167.              if ( $Height != VOID ) { $Plots[] = $YZero+$Height; $Plots[] = $Y; }

  5168.              $Y = $Y + $YStep;

  5169.             }

  5170.            $Plots[] = $YZero; $Plots[] = $Y-$YStep;

  5171. 

  5172.            $this->drawPolygon($Plots,$Color);

  5173. 

  5174.            $this->Shadow = $RestoreShadow;

  5175.            if ( $DrawLine ) { for($i=2; $i<=count($Plots)-6; $i=$i+2) { $this->drawLine($Plots[$i],$Plots[$i+1],$Plots[$i+2],$Plots[$i+3],$LineColor); } }

  5176.            if ( $DrawPlot )

  5177.             {

  5178.              for($i=2; $i<=count($Plots)-4; $i=$i+2)

  5179.               {

  5180.                if ( $PlotBorder != 0 )

  5181.                 { $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius+$PlotBorder,$PlotBorderColor); }

  5182. 

  5183.                $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius,$Color);

  5184.               }

  5185.             }

  5186.            $this->Shadow = FALSE;

  5187.           }

  5188.         }

  5189.       }

  5190.      $this->Shadow = $RestoreShadow;

  5191.     }

  5192. 

  5193.    /* Returns a random color */

  5194.    function getRandomColor($Alpha=100)

  5195.     { return(array("R"=>rand(0,255),"G"=>rand(0,255),"B"=>rand(0,255),"Alpha"=>$Alpha)); }

  5196.  

  5197.    /* Validate a palette */

  5198.    function validatePalette($Colors,$Surrounding=NULL)

  5199.     {

  5200.      $Result = "";

  5201. 

  5202.      if ( !is_array($Colors) ) { return($this->getRandomColor()); }

  5203. 

  5204.      foreach($Colors as $Key => $Values)

  5205.       {

  5206.        if ( isset($Values["R"]) ) { $Result[$Key]["R"] = $Values["R"]; } else { $Result[$Key]["R"] = rand(0,255); }

  5207.        if ( isset($Values["G"]) ) { $Result[$Key]["G"] = $Values["G"]; } else { $Result[$Key]["G"] = rand(0,255); }

  5208.        if ( isset($Values["B"]) ) { $Result[$Key]["B"] = $Values["B"]; } else { $Result[$Key]["B"] = rand(0,255); }

  5209.        if ( isset($Values["Alpha"]) ) { $Result[$Key]["Alpha"] = $Values["Alpha"]; } else { $Result[$Key]["Alpha"] = 100; }

  5210. 

  5211.        if ( $Surrounding != NULL )

  5212.         {

  5213.          $Result[$Key]["BorderR"] = $Result[$Key]["R"] + $Surrounding;

  5214.          $Result[$Key]["BorderG"] = $Result[$Key]["G"] + $Surrounding;

  5215.          $Result[$Key]["BorderB"] = $Result[$Key]["B"] + $Surrounding;

  5216.         }

  5217.        else

  5218.         {

  5219.          if ( isset($Values["BorderR"]) )     { $Result[$Key]["BorderR"] = $Values["BorderR"]; } else { $Result[$Key]["BorderR"] = $Result[$Key]["R"]; }

  5220.          if ( isset($Values["BorderG"]) )     { $Result[$Key]["BorderG"] = $Values["BorderG"]; } else { $Result[$Key]["BorderG"] = $Result[$Key]["G"]; }

  5221.          if ( isset($Values["BorderB"]) )     { $Result[$Key]["BorderB"] = $Values["BorderB"]; } else { $Result[$Key]["BorderB"] = $Result[$Key]["B"]; }

  5222.          if ( isset($Values["BorderAlpha"]) ) { $Result[$Key]["BorderAlpha"] = $Values["BorderAlpha"]; } else { $Result[$Key]["BorderAlpha"] = $Result[$Key]["Alpha"]; }

  5223.         }

  5224.       }

  5225. 

  5226.      return($Result);

  5227.     }

  5228. 

  5229.    /* Draw the derivative chart associated to the data series */

  5230.    function drawDerivative($Format=NULL)

  5231.     {

  5232.      $Offset		= isset($Format["Offset"]) ? $Format["Offset"] : 10;

  5233.      $SerieSpacing	= isset($Format["SerieSpacing"]) ? $Format["SerieSpacing"] : 3;

  5234.      $DerivativeHeight	= isset($Format["DerivativeHeight"]) ? $Format["DerivativeHeight"] : 4;

  5235.      $ShadedSlopeBox	= isset($Format["ShadedSlopeBox"]) ? $Format["ShadedSlopeBox"] : FALSE;

  5236.      $DrawBackground	= isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : TRUE;

  5237.      $BackgroundR	= isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;

  5238.      $BackgroundG	= isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;

  5239.      $BackgroundB	= isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;

  5240.      $BackgroundAlpha	= isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 20;

  5241.      $DrawBorder	= isset($Format["DrawBorder"]) ? $Format["DrawBorder"] : TRUE;

  5242.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 0;

  5243.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 0;

  5244.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 0;

  5245.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 100;

  5246.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : TRUE;

  5247.      $CaptionHeight	= isset($Format["CaptionHeight"]) ? $Format["CaptionHeight"] : 10;

  5248.      $CaptionWidth	= isset($Format["CaptionWidth"]) ? $Format["CaptionWidth"] : 20;

  5249.      $CaptionMargin	= isset($Format["CaptionMargin"]) ? $Format["CaptionMargin"] : 4;

  5250.      $CaptionLine	= isset($Format["CaptionLine"]) ? $Format["CaptionLine"] : FALSE;

  5251.      $CaptionBox	= isset($Format["CaptionBox"]) ? $Format["CaptionBox"] : FALSE;

  5252.      $CaptionBorderR	= isset($Format["CaptionBorderR"]) ? $Format["CaptionBorderR"] : 0;

  5253.      $CaptionBorderG	= isset($Format["CaptionBorderG"]) ? $Format["CaptionBorderG"] : 0;

  5254.      $CaptionBorderB	= isset($Format["CaptionBorderB"]) ? $Format["CaptionBorderB"] : 0;

  5255.      $CaptionFillR	= isset($Format["CaptionFillR"]) ? $Format["CaptionFillR"] : 255;

  5256.      $CaptionFillG	= isset($Format["CaptionFillG"]) ? $Format["CaptionFillG"] : 255;

  5257.      $CaptionFillB	= isset($Format["CaptionFillB"]) ? $Format["CaptionFillB"] : 255;

  5258.      $CaptionFillAlpha	= isset($Format["CaptionFillAlpha"]) ? $Format["CaptionFillAlpha"] : 80;

  5259.      $PositiveSlopeStartR	= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 184;

  5260.      $PositiveSlopeStartG	= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 234;

  5261.      $PositiveSlopeStartB	= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 88;

  5262.      $PositiveSlopeEndR		= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 239;

  5263.      $PositiveSlopeEndG		= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 31;

  5264.      $PositiveSlopeEndB		= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 36;

  5265.      $NegativeSlopeStartR	= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 184;

  5266.      $NegativeSlopeStartG	= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 234;

  5267.      $NegativeSlopeStartB	= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 88;

  5268.      $NegativeSlopeEndR		= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 67;

  5269.      $NegativeSlopeEndG		= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 124;

  5270.      $NegativeSlopeEndB		= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 227;

  5271. 

  5272.      $Data = $this->DataSet->getData();

  5273. 

  5274.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  5275. 

  5276.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  5277.       $YPos = $this->DataSet->Data["GraphArea"]["Y2"] + $Offset;

  5278.      else

  5279.       $XPos = $this->DataSet->Data["GraphArea"]["X2"] + $Offset;

  5280. 

  5281.      foreach($Data["Series"] as $SerieName => $Serie)

  5282.       {

  5283.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  5284.         {

  5285.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

  5286. 

  5287.          $AxisID   = $Serie["Axis"];

  5288.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  5289. 

  5290.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  5291.           {

  5292.            if ( $Caption )

  5293.             {

  5294.              if ( $CaptionLine ) 

  5295.               {

  5296.                $StartX = floor($this->GraphAreaX1-$CaptionWidth+$XMargin-$CaptionMargin);

  5297.                $EndX   = floor($this->GraphAreaX1-$CaptionMargin+$XMargin);

  5298. 

  5299.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

  5300.                if ( $CaptionBox ) { $this->drawFilledRectangle($StartX,$YPos,$EndX,$YPos+$CaptionHeight,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }

  5301.                $this->drawLine($StartX+2,$YPos+($CaptionHeight/2),$EndX-2,$YPos+($CaptionHeight/2),$CaptionSettings);

  5302.               }

  5303.              else

  5304.               $this->drawFilledRectangle($this->GraphAreaX1-$CaptionWidth+$XMargin-$CaptionMargin,$YPos,$this->GraphAreaX1-$CaptionMargin+$XMargin,$YPos+$CaptionHeight,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB));

  5305.             }

  5306. 

  5307.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  5308.            $X = $this->GraphAreaX1 + $XMargin;

  5309. 

  5310.            $TopY    = $YPos + ($CaptionHeight/2) - ($DerivativeHeight/2);

  5311.            $BottomY = $YPos + ($CaptionHeight/2) + ($DerivativeHeight/2);

  5312. 

  5313.            $StartX  = floor($this->GraphAreaX1+$XMargin);

  5314.            $EndX    = floor($this->GraphAreaX2-$XMargin);

  5315. 

  5316.            if ( $DrawBackground ) { $this->drawFilledRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }

  5317.            if ( $DrawBorder ) { $this->drawRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

  5318. 

  5319.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5320. 

  5321.            $RestoreShadow = $this->Shadow;

  5322.            $this->Shadow  = FALSE;

  5323. 

  5324.            /* Determine the Max slope index */

  5325.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;

  5326.            foreach($PosArray as $Key => $Y)

  5327.             {

  5328.              if ( $Y != VOID && $LastX != NULL )

  5329.               { $Slope = ($LastY - $Y); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }

  5330. 

  5331.              if ( $Y == VOID )

  5332.               { $LastX = NULL; $LastY = NULL; }

  5333.              else

  5334.               { $LastX = $X; $LastY = $Y; }

  5335.             }

  5336. 

  5337.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;

  5338.            foreach($PosArray as $Key => $Y)

  5339.             {

  5340.              if ( $Y != VOID && $LastY != NULL )

  5341.               {

  5342.                $Slope = ($LastY - $Y);

  5343. 

  5344.                if ( $Slope >= 0 )

  5345.                 {

  5346.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;

  5347.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;

  5348.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;

  5349.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;

  5350.                 }

  5351.                elseif ( $Slope < 0 )

  5352.                 {

  5353.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);

  5354.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;

  5355.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;

  5356.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;

  5357.                 }

  5358. 

  5359.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);

  5360. 

  5361.                if ( $ShadedSlopeBox && $LastColor != NULL ) // && $Slope != 0

  5362.                 {

  5363.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);

  5364.                  $this->drawGradientArea($LastX,$TopY,$X,$BottomY,DIRECTION_HORIZONTAL,$GradientSettings);

  5365.                 }

  5366.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) // || $Slope == 0

  5367.                 $this->drawFilledRectangle(floor($LastX),$TopY,floor($X),$BottomY,$Color);

  5368. 

  5369.                $LastColor = $Color;

  5370.               }

  5371. 

  5372.              if ( $Y == VOID )

  5373.               { $LastY = NULL; }

  5374.              else

  5375.               { $LastX = $X; $LastY = $Y; }

  5376. 

  5377.              $X = $X + $XStep;

  5378.             }

  5379. 

  5380.            $YPos = $YPos + $CaptionHeight + $SerieSpacing;

  5381.           }

  5382.          else

  5383.           {

  5384.            if ( $Caption )

  5385.             {

  5386.              $StartY = floor($this->GraphAreaY1-$CaptionWidth+$XMargin-$CaptionMargin);

  5387.              $EndY   = floor($this->GraphAreaY1-$CaptionMargin+$XMargin);

  5388.              if ( $CaptionLine ) 

  5389.               {

  5390.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

  5391.                if ( $CaptionBox ) { $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }

  5392.                $this->drawLine($XPos+($CaptionHeight/2),$StartY+2,$XPos+($CaptionHeight/2),$EndY-2,$CaptionSettings);

  5393.               }

  5394.              else

  5395.               $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB));

  5396.             }

  5397. 

  5398. 

  5399.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  5400.            $Y = $this->GraphAreaY1 + $XMargin;

  5401. 

  5402.            $TopX    = $XPos + ($CaptionHeight/2) - ($DerivativeHeight/2);

  5403.            $BottomX = $XPos + ($CaptionHeight/2) + ($DerivativeHeight/2);

  5404. 

  5405.            $StartY  = floor($this->GraphAreaY1+$XMargin);

  5406.            $EndY    = floor($this->GraphAreaY2-$XMargin);

  5407. 

  5408.            if ( $DrawBackground ) { $this->drawFilledRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }

  5409.            if ( $DrawBorder ) { $this->drawRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

  5410. 

  5411.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5412. 

  5413.            $RestoreShadow = $this->Shadow;

  5414.            $this->Shadow  = FALSE;

  5415. 

  5416.            /* Determine the Max slope index */

  5417.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;

  5418.            foreach($PosArray as $Key => $X)

  5419.             {

  5420.              if ( $X != VOID && $LastX != NULL )

  5421.               { $Slope = ($X - $LastX); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }

  5422. 

  5423.              if ( $X == VOID )

  5424.               { $LastX = NULL; }

  5425.              else

  5426.               { $LastX = $X; }

  5427.             }

  5428. 

  5429.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;

  5430.            foreach($PosArray as $Key => $X)

  5431.             {

  5432.              if ( $X != VOID && $LastX != NULL )

  5433.               {

  5434.                $Slope = ($X - $LastX);

  5435. 

  5436.                if ( $Slope >= 0 )

  5437.                 {

  5438.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;

  5439.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;

  5440.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;

  5441.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;

  5442.                 }

  5443.                elseif ( $Slope < 0 )

  5444.                 {

  5445.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);

  5446.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;

  5447.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;

  5448.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;

  5449.                 }

  5450. 

  5451.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);

  5452. 

  5453.                if ( $ShadedSlopeBox && $LastColor != NULL )

  5454.                 {

  5455.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);

  5456. 

  5457.                  $this->drawGradientArea($TopX,$LastY,$BottomX,$Y,DIRECTION_VERTICAL,$GradientSettings);

  5458.                 }

  5459.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) 

  5460.                 $this->drawFilledRectangle($TopX,floor($LastY),$BottomX,floor($Y),$Color);

  5461. 

  5462.                $LastColor = $Color;

  5463.               }

  5464. 

  5465.              if ( $X == VOID )

  5466.               { $LastX = NULL; }

  5467.              else

  5468.               { $LastX = $X; $LastY = $Y; }

  5469. 

  5470.              $Y = $Y + $XStep;

  5471.             }

  5472. 

  5473.            $XPos = $XPos + $CaptionHeight + $SerieSpacing;

  5474.           }

  5475. 

  5476.          $this->Shadow = $RestoreShadow;

  5477.         }

  5478.       }

  5479.     }

  5480. 

  5481.    /* Draw the line of best fit */

  5482.    function drawBestFit($Format="")

  5483.     {

  5484.      $OverrideTicks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

  5485.      $OverrideR		= isset($Format["R"]) ? $Format["R"] : VOID;

  5486.      $OverrideG		= isset($Format["G"]) ? $Format["G"] : VOID;

  5487.      $OverrideB		= isset($Format["B"]) ? $Format["B"] : VOID;

  5488.      $OverrideAlpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : VOID;

  5489. 

  5490.      $Data = $this->DataSet->getData();

  5491.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  5492. 

  5493.      foreach($Data["Series"] as $SerieName => $Serie)

  5494.       {

  5495.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

  5496.         {

  5497.          if ( $OverrideR != VOID && $OverrideG != VOID && $OverrideB != VOID ) { $R = $OverrideR; $G = $OverrideG; $B = $OverrideB; } else { $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; }

  5498.          if ( $OverrideTicks == NULL ) { $Ticks = $Serie["Ticks"]; } else { $Ticks = $OverrideTicks; }

  5499.          if ( $OverrideAlpha == VOID ) { $Alpha = $Serie["Color"]["Alpha"]; } else { $Alpha = $OverrideAlpha; }

  5500. 

  5501.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks);

  5502. 

  5503.          $AxisID   = $Serie["Axis"];

  5504.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

  5505. 

  5506.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  5507.           {

  5508.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  5509.            $X = $this->GraphAreaX1 + $XMargin;

  5510. 

  5511.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5512.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;

  5513.            foreach($PosArray as $Key => $Y)

  5514.             {

  5515.              if ( $Y != VOID )

  5516.               {

  5517.                $Sxy = $Sxy + $X*$Y;

  5518.                $Sx  = $Sx + $X;

  5519.                $Sy  = $Sy + $Y;

  5520.                $Sxx = $Sxx + $X*$X;

  5521.               }

  5522. 

  5523.              $X = $X + $XStep;

  5524.             }

  5525.            $n = count($this->DataSet->stripVOID($PosArray)); //$n = count($PosArray);

  5526.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));

  5527.            $B = (($Sy)-($M*$Sx))/($n);

  5528. 

  5529.            $X1 = $this->GraphAreaX1 + $XMargin;

  5530.            $Y1 = $M * $X1 + $B;

  5531.            $X2 = $this->GraphAreaX2 - $XMargin;

  5532.            $Y2 = $M * $X2 + $B;

  5533. 

  5534.            if ( $Y1 < $this->GraphAreaY1 ) { $X1 = $X1 + ($this->GraphAreaY1-$Y1); $Y1 = $this->GraphAreaY1; }

  5535.            if ( $Y1 > $this->GraphAreaY2 ) { $X1 = $X1 + ($Y1-$this->GraphAreaY2); $Y1 = $this->GraphAreaY2; }

  5536.            if ( $Y2 < $this->GraphAreaY1 ) { $X2 = $X2 - ($this->GraphAreaY1-$Y2); $Y2 = $this->GraphAreaY1; }

  5537.            if ( $Y2 > $this->GraphAreaY2 ) { $X2 = $X2 - ($Y2-$this->GraphAreaY2); $Y2 = $this->GraphAreaY2; }

  5538. 

  5539.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);

  5540.           }

  5541.          else

  5542.           {

  5543.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  5544.            $Y = $this->GraphAreaY1 + $XMargin;

  5545. 

  5546.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

  5547.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;

  5548.            foreach($PosArray as $Key => $X)

  5549.             {

  5550.              if ( $X != VOID )

  5551.               {

  5552.                $Sxy = $Sxy + $X*$Y;

  5553.                $Sx  = $Sx + $Y;

  5554.                $Sy  = $Sy + $X;

  5555.                $Sxx = $Sxx + $Y*$Y;

  5556.               }

  5557. 

  5558.              $Y = $Y + $YStep;

  5559.             }

  5560.            $n = count($this->DataSet->stripVOID($PosArray)); //$n = count($PosArray);

  5561.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));

  5562.            $B = (($Sy)-($M*$Sx))/($n);

  5563. 

  5564.            $Y1 = $this->GraphAreaY1 + $XMargin;

  5565.            $X1 = $M * $Y1 + $B;

  5566.            $Y2 = $this->GraphAreaY2 - $XMargin;

  5567.            $X2 = $M * $Y2 + $B;

  5568. 

  5569.            if ( $X1 < $this->GraphAreaX1 ) { $Y1 = $Y1 + ($this->GraphAreaX1-$X1); $X1 = $this->GraphAreaX1; }

  5570.            if ( $X1 > $this->GraphAreaX2 ) { $Y1 = $Y1 + ($X1-$this->GraphAreaX2); $X1 = $this->GraphAreaX2; }

  5571.            if ( $X2 < $this->GraphAreaX1 ) { $Y2 = $Y2 - ($this->GraphAreaY1-$X2); $X2 = $this->GraphAreaX1; }

  5572.            if ( $X2 > $this->GraphAreaX2 ) { $Y2 = $Y2 - ($X2-$this->GraphAreaX2); $X2 = $this->GraphAreaX2; }

  5573. 

  5574.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);

  5575.           }

  5576.         }

  5577.       }

  5578.     }

  5579. 

  5580.    /* Write labels */

  5581.    function writeLabel($SeriesName,$Indexes,$Format="")

  5582.     {

  5583.      $OverrideTitle	= isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : NULL;

  5584.      $ForceLabels	= isset($Format["ForceLabels"]) ? $Format["ForceLabels"] : NULL;

  5585.      $DrawPoint		= isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;

  5586.      $DrawVerticalLine	= isset($Format["DrawVerticalLine"]) ? $Format["DrawVerticalLine"] : FALSE;

  5587.      $VerticalLineR	= isset($Format["VerticalLineR"]) ? $Format["VerticalLineR"] : 0;

  5588.      $VerticalLineG	= isset($Format["VerticalLineG"]) ? $Format["VerticalLineG"] : 0;

  5589.      $VerticalLineB	= isset($Format["VerticalLineB"]) ? $Format["VerticalLineB"] : 0;

  5590.      $VerticalLineAlpha	= isset($Format["VerticalLineAlpha"]) ? $Format["VerticalLineAlpha"] : 40;

  5591.      $VerticalLineTicks	= isset($Format["VerticalLineTicks"]) ? $Format["VerticalLineTicks"] : 2;

  5592. 

  5593.      $Data = $this->DataSet->getData();

  5594.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

  5595. 

  5596.      if ( !is_array($Indexes) )    { $Index = $Indexes; $Indexes = ""; $Indexes[] = $Index; }

  5597.      if ( !is_array($SeriesName) ) { $SerieName = $SeriesName; $SeriesName = ""; $SeriesName[] = $SerieName; }

  5598.      if ( $ForceLabels != NULL && !is_array($ForceLabels) ) { $ForceLabel = $ForceLabels; $ForceLabels = ""; $ForceLabels[] = $ForceLabel; }

  5599. 

  5600.      foreach ($Indexes as $Key => $Index)

  5601.       {

  5602.        $Series = "";

  5603. 

  5604.        if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

  5605.         {

  5606.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

  5607.          $X = $this->GraphAreaX1 + $XMargin + $Index * $XStep;

  5608. 

  5609.          if ( $DrawVerticalLine ) { $this->drawLine($X,$this->GraphAreaY1+$Data["YMargin"],$X,$this->GraphAreaY2-$Data["YMargin"],array("R"=>$VerticalLineR,"G"=>$VerticalLineG,"B"=>$VerticalLineB,"Alpha"=>$VerticalLineAlpha,"Ticks"=>$VerticalLineTicks)); }

  5610. 

  5611.          $MinY = $this->GraphAreaY2;

  5612.          foreach ($SeriesName as $iKey => $SerieName)

  5613.           {

  5614.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )

  5615.             {

  5616.              $AxisID       = $Data["Series"][$SerieName]["Axis"];

  5617.              $XAxisMode    = $Data["XAxisDisplay"];

  5618.              $XAxisFormat  = $Data["XAxisFormat"];

  5619.              $XAxisUnit    = $Data["XAxisUnit"];

  5620.              $AxisMode     = $Data["Axis"][$AxisID]["Display"];

  5621.              $AxisFormat   = $Data["Axis"][$AxisID]["Format"];

  5622.              $AxisUnit     = $Data["Axis"][$AxisID]["Unit"];

  5623. 

  5624.              if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

  5625.               $XLabel = $this->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index],$XAxisMode,$XAxisFormat,$XAxisUnit);

  5626.              else

  5627.               $XLabel = "";

  5628. 

  5629.              if ( $OverrideTitle != NULL)

  5630.               $Description = $OverrideTitle;

  5631.              elseif ( count($SeriesName) == 1 )

  5632.               {

  5633.                $Description = $Data["Series"][$SerieName]["Description"]." - ".$XLabel;

  5634.               }

  5635.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

  5636.               $Description = $XLabel;

  5637. 

  5638.              $Serie = "";

  5639.              $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];

  5640.              $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];

  5641.              $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];

  5642.              $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];

  5643. 

  5644.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )

  5645.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];

  5646.              else

  5647.               $SerieOffset = 0;

  5648. 

  5649.              $Value = $Data["Series"][$SerieName]["Data"][$Index];

  5650.              if ( $Value == VOID ) { $Value = "NaN"; }

  5651. 

  5652.              if ( $ForceLabels != NULL )

  5653.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";

  5654.              else

  5655.               $Caption = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);

  5656. 

  5657.              if ( $this->LastChartLayout == CHART_LAST_LAYOUT_STACKED )

  5658.               {

  5659.                if ( $Value >=0 ) { $LookFor = "+"; } else { $LookFor = "-"; }

  5660. 

  5661.                $Value = 0; $Done = FALSE;

  5662.                foreach($Data["Series"] as $Name => $SerieLookup)

  5663.                 {

  5664.                  if ( $SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done )

  5665.                   {

  5666.                    if ( isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID )

  5667.                     {

  5668.                      if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+" ) { $Value = $Value + $Data["Series"][$Name]["Data"][$Index]; }

  5669.                      if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-" )  { $Value = $Value - $Data["Series"][$Name]["Data"][$Index]; }

  5670.                      if ($Name == $SerieName ) { $Done = TRUE; }

  5671.                     }

  5672.                   }

  5673.                 }

  5674.               }

  5675. 

  5676.              $X = floor($this->GraphAreaX1 + $XMargin + $Index * $XStep + $SerieOffset);

  5677.              $Y = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));

  5678. 

  5679.              if ($Y < $MinY) { $MinY = $Y; }

  5680. 

  5681.              if ( $DrawPoint == LABEL_POINT_CIRCLE )

  5682.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

  5683.              elseif ( $DrawPoint == LABEL_POINT_BOX )

  5684.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

  5685. 

  5686.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);

  5687.             }

  5688.           }

  5689.          $this->drawLabelBox($X,$MinY-3,$Description,$Series,$Format);

  5690. 

  5691.         }

  5692.        else

  5693.         {

  5694.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

  5695.          $Y = $this->GraphAreaY1 + $XMargin + $Index * $XStep;

  5696. 

  5697.          if ( $DrawVerticalLine ) { $this->drawLine($this->GraphAreaX1+$Data["YMargin"],$Y,$this->GraphAreaX2-$Data["YMargin"],$Y,array("R"=>$VerticalLineR,"G"=>$VerticalLineG,"B"=>$VerticalLineB,"Alpha"=>$VerticalLineAlpha,"Ticks"=>$VerticalLineTicks)); }

  5698. 

  5699.          $MinX = $this->GraphAreaX2;

  5700.          foreach ($SeriesName as $Key => $SerieName)

  5701.           {

  5702.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )

  5703.             {

  5704.              $AxisID      = $Data["Series"][$SerieName]["Axis"];

  5705.              $XAxisMode   = $Data["XAxisDisplay"];

  5706.              $XAxisFormat = $Data["XAxisFormat"];

  5707.              $XAxisUnit   = $Data["XAxisUnit"];

  5708.              $AxisMode    = $Data["Axis"][$AxisID]["Display"];

  5709.              $AxisFormat  = $Data["Axis"][$AxisID]["Format"];

  5710.              $AxisUnit    = $Data["Axis"][$AxisID]["Unit"];

  5711. 

  5712.              if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

  5713.               $XLabel = $this->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index],$XAxisMode,$XAxisFormat,$XAxisUnit);

  5714.              else

  5715.               $XLabel = "";

  5716. 

  5717.              if ( $OverrideTitle != NULL)

  5718.               $Description = $OverrideTitle;

  5719.              elseif ( count($SeriesName) == 1 )

  5720.               {

  5721.                if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

  5722.                 $Description = $Data["Series"][$SerieName]["Description"]." - ".$XLabel;

  5723.               }

  5724.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

  5725.               $Description = $XLabel;

  5726. 

  5727.              $Serie = "";

  5728.              if ( isset($Data["Extended"]["Palette"][$Index] ) )

  5729.               {

  5730.                $Serie["R"] = $Data["Extended"]["Palette"][$Index]["R"];

  5731.                $Serie["G"] = $Data["Extended"]["Palette"][$Index]["G"];

  5732.                $Serie["B"] = $Data["Extended"]["Palette"][$Index]["B"];

  5733.                $Serie["Alpha"] = $Data["Extended"]["Palette"][$Index]["Alpha"];

  5734.               }

  5735.              else

  5736.               {

  5737.                $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];

  5738.                $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];

  5739.                $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];

  5740.                $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];

  5741.               }

  5742. 

  5743.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )

  5744.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];

  5745.              else

  5746.               $SerieOffset = 0;

  5747. 

  5748.              $Value = $Data["Series"][$SerieName]["Data"][$Index];

  5749.              if ( $ForceLabels != NULL )

  5750.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";

  5751.              else

  5752.               $Caption = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);

  5753.              if ( $Value == VOID ) { $Value = "NaN"; }

  5754. 

  5755.              if ( $this->LastChartLayout == CHART_LAST_LAYOUT_STACKED )

  5756.               {

  5757.                if ( $Value >=0 ) { $LookFor = "+"; } else { $LookFor = "-"; }

  5758. 

  5759.                $Value = 0; $Done = FALSE;

  5760.                foreach($Data["Series"] as $Name => $SerieLookup)

  5761.                 {

  5762.                  if ( $SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done )

  5763.                   {

  5764.                    if ( isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID )

  5765.                     {

  5766.                      if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+" ) { $Value = $Value + $Data["Series"][$Name]["Data"][$Index]; }

  5767.                      if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-" )  { $Value = $Value - $Data["Series"][$Name]["Data"][$Index]; }

  5768.                      if ($Name == $SerieName ) { $Done = TRUE; }

  5769.                     }

  5770.                   }

  5771.                 }

  5772.               }

  5773. 

  5774.              $X = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));

  5775.              $Y = floor($this->GraphAreaY1 + $XMargin + $Index * $XStep + $SerieOffset);

  5776. 

  5777.              if ($X < $MinX) { $MinX = $X; }

  5778. 

  5779.              if ( $DrawPoint == LABEL_POINT_CIRCLE )

  5780.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

  5781.              elseif ( $DrawPoint == LABEL_POINT_BOX )

  5782.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

  5783. 

  5784.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);

  5785.             }

  5786.           }

  5787.          $this->drawLabelBox($MinX,$Y-3,$Description,$Series,$Format);

  5788. 

  5789.         }

  5790.       }

  5791.     }

  5792. 

  5793.    /* Draw a label box */

  5794.    function drawLabelBox($X,$Y,$Title,$Captions,$Format="")

  5795.     {

  5796.      $NoTitle			= isset($Format["NoTitle"]) ? $Format["NoTitle"] : NULL;

  5797.      $BoxWidth			= isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 50;

  5798.      $DrawSerieColor		= isset($Format["DrawSerieColor"]) ? $Format["DrawSerieColor"] : TRUE;

  5799.      $SerieR			= isset($Format["SerieR"]) ? $Format["SerieR"] : NULL;

  5800.      $SerieG			= isset($Format["SerieG"]) ? $Format["SerieG"] : NULL;

  5801.      $SerieB			= isset($Format["SerieB"]) ? $Format["SerieB"] : NULL;

  5802.      $SerieAlpha		= isset($Format["SerieAlpha"]) ? $Format["SerieAlpha"] : NULL;

  5803.      $SerieBoxSize		= isset($Format["SerieBoxSize"]) ? $Format["SerieBoxSize"] : 6;

  5804.      $SerieBoxSpacing		= isset($Format["SerieBoxSpacing"]) ? $Format["SerieBoxSpacing"] : 4;

  5805.      $VerticalMargin		= isset($Format["VerticalMargin"]) ? $Format["VerticalMargin"] : 10;

  5806.      $HorizontalMargin		= isset($Format["HorizontalMargin"]) ? $Format["HorizontalMargin"] : 8;

  5807.      $R				= isset($Format["R"]) ? $Format["R"] : $this->FontColorR;

  5808.      $G				= isset($Format["G"]) ? $Format["G"] : $this->FontColorG;

  5809.      $B				= isset($Format["B"]) ? $Format["B"] : $this->FontColorB;

  5810.      $Alpha			= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;

  5811.      $FontName			= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

  5812.      $FontSize			= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

  5813.      $TitleMode			= isset($Format["TitleMode"]) ? $Format["TitleMode"] : LABEL_TITLE_NOBACKGROUND;

  5814.      $TitleR			= isset($Format["TitleR"]) ? $Format["TitleR"] : $R;

  5815.      $TitleG			= isset($Format["TitleG"]) ? $Format["TitleG"] : $G;

  5816.      $TitleB			= isset($Format["TitleB"]) ? $Format["TitleB"] : $B;

  5817.      $TitleAlpha		= isset($Format["TitleAlpha"]) ? $Format["TitleAlpha"] : 100;

  5818.      $TitleBackgroundR		= isset($Format["TitleBackgroundR"]) ? $Format["TitleBackgroundR"] : 0;

  5819.      $TitleBackgroundG		= isset($Format["TitleBackgroundG"]) ? $Format["TitleBackgroundG"] : 0;

  5820.      $TitleBackgroundB		= isset($Format["TitleBackgroundB"]) ? $Format["TitleBackgroundB"] : 0;

  5821.      $TitleBackgroundAlpha	= isset($Format["TitleBackgroundAlpha"]) ? $Format["TitleBackgroundAlpha"] : 100;

  5822.      $GradientStartR		= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

  5823.      $GradientStartG		= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

  5824.      $GradientStartB		= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

  5825.      $GradientEndR		= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 220;

  5826.      $GradientEndG		= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 220;

  5827.      $GradientEndB		= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 220;

  5828.      $BoxAlpha			= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 100;

  5829. 

  5830.      if ( !$DrawSerieColor ) { $SerieBoxSize = 0; $SerieBoxSpacing = 0; }

  5831. 

  5832.      $TxtPos      = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Title);

  5833.      $TitleWidth  = ($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2;

  5834.      $TitleHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);

  5835. 

  5836.      if ( $NoTitle ) { $TitleWidth = 0; $TitleHeight = 0; }

  5837. 

  5838.      $CaptionWidth = 0; $CaptionHeight = -$HorizontalMargin;

  5839.      foreach($Captions as $Key =>$Caption)

  5840.       {

  5841.        $TxtPos        = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Caption["Caption"]);

  5842.        $CaptionWidth  = max($CaptionWidth,($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2);

  5843.        $CaptionHeight = $CaptionHeight + max(($TxtPos[0]["Y"] - $TxtPos[2]["Y"]),($SerieBoxSize+2)) + $HorizontalMargin;

  5844.       }

  5845. 

  5846.      if ( $CaptionHeight <= 5 ) { $CaptionHeight = $CaptionHeight + $HorizontalMargin/2; }

  5847. 

  5848.      if ( $DrawSerieColor ) { $CaptionWidth = $CaptionWidth + $SerieBoxSize + $SerieBoxSpacing; }

  5849. 

  5850.      $BoxWidth = max($BoxWidth,$TitleWidth,$CaptionWidth);

  5851. 

  5852.      $XMin = $X - 5 - floor(($BoxWidth-10) / 2);

  5853.      $XMax = $X + 5 + floor(($BoxWidth-10) / 2);

  5854. 

  5855.      $RestoreShadow = $this->Shadow;

  5856.      if ( $this->Shadow == TRUE )

  5857.       {

  5858.        $this->Shadow = FALSE;

  5859. 

  5860.        $Poly = "";

  5861.        $Poly[] = $X+$this->ShadowX; $Poly[] = $Y+$this->ShadowX;

  5862.        $Poly[] = $X+5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

  5863.        $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

  5864. 

  5865.        if ( $NoTitle )

  5866.         {

  5867.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;

  5868.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;

  5869.         }

  5870.        else

  5871.         {

  5872.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;

  5873.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;

  5874.         }

  5875. 

  5876.        $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

  5877.        $Poly[] = $X-5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

  5878.        $this->drawPolygon($Poly,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

  5879.       }

  5880. 

  5881.      /* Draw the background */

  5882.      $GradientSettings = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$BoxAlpha);

  5883.      if ( $NoTitle )

  5884.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);

  5885.      else

  5886.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);

  5887.      $Poly = ""; $Poly[] = $X; $Poly[] = $Y; $Poly[] = $X-5; $Poly[] = $Y-5; $Poly[] = $X+5; $Poly[] = $Y-5;

  5888.      $this->drawPolygon($Poly,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB,"Alpha"=>$BoxAlpha,"NoBorder"=>TRUE));

  5889. 

  5890.      /* Outer border */

  5891.      $OuterBorderColor = $this->allocateColor($this->Picture,100,100,100,$BoxAlpha);

  5892.      imageline($this->Picture,$XMin,$Y-5,$X-5,$Y-5,$OuterBorderColor);

  5893.      imageline($this->Picture,$X,$Y,$X-5,$Y-5,$OuterBorderColor);

  5894.      imageline($this->Picture,$X,$Y,$X+5,$Y-5,$OuterBorderColor);

  5895.      imageline($this->Picture,$X+5,$Y-5,$XMax,$Y-5,$OuterBorderColor);

  5896.      if ( $NoTitle )

  5897.       {

  5898.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin,$Y-5,$OuterBorderColor);

  5899.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5,$OuterBorderColor);

  5900.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$OuterBorderColor);

  5901.       }

  5902.      else

  5903.       {

  5904.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin,$Y-5,$OuterBorderColor);

  5905.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5,$OuterBorderColor);

  5906.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$OuterBorderColor);

  5907.       }

  5908. 

  5909.      /* Inner border */

  5910.      $InnerBorderColor = $this->allocateColor($this->Picture,255,255,255,$BoxAlpha);

  5911.      imageline($this->Picture,$XMin+1,$Y-6,$X-5,$Y-6,$InnerBorderColor);

  5912.      imageline($this->Picture,$X,$Y-1,$X-5,$Y-6,$InnerBorderColor);

  5913.      imageline($this->Picture,$X,$Y-1,$X+5,$Y-6,$InnerBorderColor);

  5914.      imageline($this->Picture,$X+5,$Y-6,$XMax-1,$Y-6,$InnerBorderColor);

  5915.      if ( $NoTitle )

  5916.       {

  5917.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin+1,$Y-6,$InnerBorderColor);

  5918.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-6,$InnerBorderColor);

  5919.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$InnerBorderColor);

  5920.       }

  5921.      else

  5922.       {

  5923.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin+1,$Y-6,$InnerBorderColor);

  5924.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-6,$InnerBorderColor);

  5925.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$InnerBorderColor);

  5926.       }

  5927. 

  5928.      /* Draw the separator line */

  5929.      if ( $TitleMode == LABEL_TITLE_NOBACKGROUND && !$NoTitle )

  5930.       {

  5931.        $YPos    = $Y-7-$CaptionHeight-$HorizontalMargin-$HorizontalMargin/2;

  5932.        $XMargin = $VerticalMargin / 2;

  5933.        $this->drawLine($XMin+$XMargin,$YPos+1,$XMax-$XMargin,$YPos+1,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB,"Alpha"=>$BoxAlpha));

  5934.        $this->drawLine($XMin+$XMargin,$YPos,$XMax-$XMargin,$YPos,array("R"=>$GradientStartR,"G"=>$GradientStartG,"B"=>$GradientStartB,"Alpha"=>$BoxAlpha));

  5935.       }

  5936.      elseif ( $TitleMode == LABEL_TITLE_BACKGROUND )

  5937.       {

  5938.        $this->drawFilledRectangle($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2,array("R"=>$TitleBackgroundR,"G"=>$TitleBackgroundG,"B"=>$TitleBackgroundB,"Alpha"=>$BoxAlpha));

  5939.        imageline($this->Picture,$XMin+1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$XMax-1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$InnerBorderColor);

  5940.       }

  5941. 

  5942.      /* Write the description */

  5943.      if ( !$NoTitle )

  5944.       $this->drawText($XMin+$VerticalMargin,$Y-7-$CaptionHeight-$HorizontalMargin*2,$Title,array("Align"=>TEXT_ALIGN_BOTTOMLEFT,"R"=>$TitleR,"G"=>$TitleG,"B"=>$TitleB));

  5945. 

  5946.      /* Write the value */

  5947.      $YPos = $Y-5-$HorizontalMargin; $XPos = $XMin+$VerticalMargin+$SerieBoxSize+$SerieBoxSpacing;

  5948.      foreach($Captions as $Key => $Caption)

  5949.       {

  5950.        $CaptionTxt    = $Caption["Caption"];

  5951.        $TxtPos        = $this->getTextBox($XPos,$YPos,$FontName,$FontSize,0,$CaptionTxt);

  5952.        $CaptionHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);

  5953. 

  5954.        /* Write the serie color if needed */

  5955.        if ( $DrawSerieColor )

  5956.         {

  5957.          $BoxSettings = array("R"=>$Caption["Format"]["R"],"G"=>$Caption["Format"]["G"],"B"=>$Caption["Format"]["B"],"Alpha"=>$Caption["Format"]["Alpha"],"BorderR"=>0,"BorderG"=>0,"BorderB"=>0);

  5958.          $this->drawFilledRectangle($XMin+$VerticalMargin,$YPos-$SerieBoxSize,$XMin+$VerticalMargin+$SerieBoxSize,$YPos,$BoxSettings);

  5959.         }

  5960. 

  5961.        $this->drawText($XPos,$YPos,$CaptionTxt,array("Align"=>TEXT_ALIGN_BOTTOMLEFT));

  5962. 

  5963.        $YPos = $YPos - $CaptionHeight - $HorizontalMargin;

  5964.       }

  5965. 

  5966.      $this->Shadow = $RestoreShadow;

  5967.     }

  5968. 

  5969.    /* Draw a basic shape */

  5970.    function drawShape($X,$Y,$Shape,$PlotSize,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha)

  5971.     {

  5972.      if ( $Shape == SERIE_SHAPE_FILLEDCIRCLE )

  5973.       {

  5974.        if ( $PlotBorder ) { $this->drawFilledCircle($X,$Y,$PlotSize+$BorderSize,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

  5975.        $this->drawFilledCircle($X,$Y,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5976.       }

  5977.      elseif ( $Shape == SERIE_SHAPE_FILLEDSQUARE )

  5978.       {

  5979.        if ( $PlotBorder ) { $this->drawFilledRectangle($X-$PlotSize-$BorderSize,$Y-$PlotSize-$BorderSize,$X+$PlotSize+$BorderSize,$Y+$PlotSize+$BorderSize,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

  5980.        $this->drawFilledRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5981.       }

  5982.      elseif ( $Shape == SERIE_SHAPE_FILLEDTRIANGLE )

  5983.       {

  5984.        if ( $PlotBorder )

  5985.         {

  5986.          $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize-$BorderSize; $Pos[]=$X-$PlotSize-$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize; $Pos[]=$X+$PlotSize+$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize;

  5987.          $this->drawPolygon($Pos,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha));

  5988.         }

  5989. 

  5990.        $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X-$PlotSize; $Pos[]=$Y+$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y+$PlotSize;

  5991.        $this->drawPolygon($Pos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5992.       }

  5993.      elseif ( $Shape == SERIE_SHAPE_TRIANGLE )

  5994.       {

  5995.        $this->drawLine($X,$Y-$PlotSize,$X-$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5996.        $this->drawLine($X-$PlotSize,$Y+$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5997.        $this->drawLine($X+$PlotSize,$Y+$PlotSize,$X,$Y-$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  5998.       }

  5999.      elseif ( $Shape == SERIE_SHAPE_SQUARE )

  6000.       $this->drawRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  6001.      elseif ( $Shape == SERIE_SHAPE_CIRCLE )

  6002.       $this->drawCircle($X,$Y,$PlotSize,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  6003.      elseif ( $Shape == SERIE_SHAPE_DIAMOND )

  6004.       {

  6005.        $Pos = ""; $Pos[]=$X-$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize;

  6006.        $this->drawPolygon($Pos,array("NoFill"=>TRUE,"BorderR"=>$R,"BorderG"=>$G,"BorderB"=>$B,"BorderAlpha"=>$Alpha));

  6007.       }      

  6008.      elseif ( $Shape == SERIE_SHAPE_FILLEDDIAMOND )

  6009.       {

  6010.        if ( $PlotBorder )

  6011.         {

  6012.          $Pos = ""; $Pos[]=$X-$PlotSize-$BorderSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize-$BorderSize; $Pos[]=$X+$PlotSize+$BorderSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize+$BorderSize;

  6013.          $this->drawPolygon($Pos,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha));

  6014.         }

  6015. 

  6016.        $Pos = ""; $Pos[]=$X-$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize;

  6017.        $this->drawPolygon($Pos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

  6018.       }      

  6019.     }

  6020. 

  6021.    function drawPolygonChart($Points,$Format="")

  6022.     {

  6023.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

  6024.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

  6025.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

  6026.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

  6027.      $NoFill		= isset($Format["NoFill"]) ? $Format["NoFill"] : FALSE;

  6028.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;

  6029.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

  6030.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

  6031.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

  6032.      $BorderAlpha 	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha / 2;

  6033.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

  6034.      $Threshold         = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

  6035. 

  6036.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

  6037. 

  6038.      $RestoreShadow = $this->Shadow;

  6039.      $this->Shadow = FALSE;

  6040. 

  6041.      $AllIntegers = TRUE;

  6042.      for($i=0;$i<=count($Points)-2;$i=$i+2)

  6043.       { if ( $this->getFirstDecimal($Points[$i+1]) != 0 ) { $AllIntegers = FALSE; } }

  6044. 

  6045.      /* Convert polygon to segments */

  6046.      $Segments = "";

  6047.      for($i=2;$i<=count($Points)-2;$i=$i+2)

  6048.       { $Segments[] = array("X1"=>$Points[$i-2],"Y1"=>$Points[$i-1],"X2"=>$Points[$i],"Y2"=>$Points[$i+1]); }

  6049.      $Segments[] = array("X1"=>$Points[$i-2],"Y1"=>$Points[$i-1],"X2"=>$Points[0],"Y2"=>$Points[1]);

  6050. 

  6051.      /* Simplify straight lines */

  6052.      $Result = ""; $inHorizon = FALSE; $LastX = VOID;

  6053.      foreach($Segments as $Key => $Pos)

  6054.       {

  6055.        if ( $Pos["Y1"] != $Pos["Y2"] )

  6056.         {

  6057.          if ( $inHorizon ) { $inHorizon = FALSE; $Result[] = array("X1"=>$LastX,"Y1"=>$Pos["Y1"],"X2"=>$Pos["X1"],"Y2"=>$Pos["Y1"]); }

  6058. 

  6059.          $Result[] = array("X1"=>$Pos["X1"],"Y1"=>$Pos["Y1"],"X2"=>$Pos["X2"],"Y2"=>$Pos["Y2"]);

  6060.         }

  6061.        else { if ( !$inHorizon ) { $inHorizon = TRUE; $LastX = $Pos["X1"];} }

  6062.       }

  6063.      $Segments = $Result;

  6064. 

  6065.      /* Do we have something to draw */

  6066.      if ( $Segments == "" ) { return(0); }

  6067. 

  6068.      /* For segments debugging purpose */

  6069.      //foreach($Segments as $Key => $Pos)

  6070.      // echo $Pos["X1"].",".$Pos["Y1"].",".$Pos["X2"].",".$Pos["Y2"]."\r\n";

  6071. 

  6072.      /* Find out the min & max Y boundaries */

  6073.      $MinY = OUT_OF_SIGHT; $MaxY = OUT_OF_SIGHT;

  6074.      foreach($Segments as $Key => $Coords)

  6075.       {

  6076.        if ( $MinY == OUT_OF_SIGHT || $MinY > min($Coords["Y1"],$Coords["Y2"]) ) { $MinY = min($Coords["Y1"],$Coords["Y2"]); }

  6077.        if ( $MaxY == OUT_OF_SIGHT || $MaxY < max($Coords["Y1"],$Coords["Y2"]) ) { $MaxY = max($Coords["Y1"],$Coords["Y2"]); }

  6078.       }

  6079. 

  6080.      if ( $AllIntegers ) { $YStep = 1; } else { $YStep = .5; }

  6081. 

  6082.      $MinY = floor($MinY); $MaxY = floor($MaxY);

  6083. 

  6084.      /* Scan each Y lines */

  6085.      $DefaultColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  6086.      $DebugLine = 0; $DebugColor = $this->allocateColor($this->Picture,255,0,0,100);

  6087. 

  6088.      $MinY = floor($MinY); $MaxY = floor($MaxY); $YStep = 1; 

  6089. 

  6090.      if ( !$NoFill )

  6091.       {

  6092.        //if ( $DebugLine ) { $MinY = $DebugLine; $MaxY = $DebugLine; }

  6093.        for($Y=$MinY;$Y<=$MaxY;$Y=$Y+$YStep)

  6094.         {

  6095.          $Intersections = ""; $LastSlope = NULL; $RestoreLast = "-";

  6096.          foreach($Segments as $Key => $Coords)

  6097.           {

  6098.            $X1 = $Coords["X1"]; $X2 = $Coords["X2"]; $Y1 = $Coords["Y1"]; $Y2 = $Coords["Y2"];

  6099. 

  6100.            if ( min($Y1,$Y2) <= $Y && max($Y1,$Y2) >= $Y )

  6101.             {

  6102.              if ( $Y1 == $Y2 )

  6103.               { $X = $X1; }

  6104.              else

  6105.               { $X = $X1 + ( ($Y-$Y1)*$X2 - ($Y-$Y1)*$X1 ) / ($Y2-$Y1); }

  6106. 

  6107.              $X = floor($X);

  6108. 

  6109.              if ( $X2 == $X1 )

  6110.               { $Slope = "!"; }

  6111.              else

  6112.               {

  6113.                $SlopeC = ($Y2 - $Y1) / ($X2 - $X1);

  6114.                if( $SlopeC == 0 )

  6115.                 { $Slope = "="; }

  6116.                elseif( $SlopeC > 0 )

  6117.                 { $Slope = "+"; }

  6118.                elseif ( $SlopeC < 0 )

  6119.                 { $Slope = "-"; }

  6120.               }

  6121. 

  6122.              if ( !is_array($Intersections) )

  6123.               { $Intersections[] = $X; }

  6124.              elseif( !in_array($X,$Intersections) )

  6125.               { $Intersections[] = $X; }

  6126.              elseif( in_array($X,$Intersections) )

  6127.               {

  6128.                if ($Y == $DebugLine) { echo $Slope."/".$LastSlope."(".$X.") "; }

  6129. 

  6130.                if ( $Slope == "=" && $LastSlope == "-"  )                             { $Intersections[] = $X; }

  6131.                if ( $Slope != $LastSlope && $LastSlope != "!" && $LastSlope != "=" )  { $Intersections[] = $X; }

  6132.                if ( $Slope != $LastSlope && $LastSlope == "!" && $Slope == "+" )      { $Intersections[] = $X; }

  6133.               }

  6134. 

  6135.              if ( is_array($Intersections) && in_array($X,$Intersections) && $LastSlope == "=" && ($Slope == "-" )) { $Intersections[] = $X; }

  6136. 

  6137.              $LastSlope = $Slope;

  6138.             }

  6139.           }

  6140.          if ( $RestoreLast != "-" ) { $Intersections[] = $RestoreLast; echo "@".$Y."\r\n"; }

  6141. 

  6142.          if ( is_array($Intersections) )

  6143.           {

  6144.            sort($Intersections);

  6145. 

  6146.            if ($Y == $DebugLine) { print_r($Intersections); }

  6147. 

  6148.            /* Remove NULL plots */

  6149.            $Result = "";

  6150.            for($i=0;$i<=count($Intersections)-1;$i=$i+2)

  6151.             {

  6152.              if ( isset($Intersections[$i+1]) )

  6153.               { if ( $Intersections[$i] != $Intersections[$i+1] ) { $Result[] = $Intersections[$i]; $Result[] = $Intersections[$i+1]; } }

  6154.             }

  6155. 

  6156.            if ( is_array($Result) )

  6157.             {

  6158.              $Intersections = $Result;

  6159. 

  6160.              $LastX = OUT_OF_SIGHT;

  6161.              foreach($Intersections as $Key => $X)

  6162.               {

  6163.                if ( $LastX == OUT_OF_SIGHT )

  6164.                 $LastX = $X;

  6165.                elseif ( $LastX != OUT_OF_SIGHT )

  6166.                 {

  6167.                  if ( $this->getFirstDecimal($LastX) > 1 ) { $LastX++; }

  6168. 

  6169.                  $Color = $DefaultColor;

  6170.                  if ( $Threshold != NULL )

  6171.                   {

  6172.                    foreach($Threshold as $Key => $Parameters)

  6173.                     {

  6174.                      if ( $Y <= $Parameters["MinX"] && $Y >= $Parameters["MaxX"])

  6175.                       {

  6176.                        if ( isset($Parameters["R"]) ) { $R = $Parameters["R"]; } else { $R = 0; }

  6177.                        if ( isset($Parameters["G"]) ) { $G = $Parameters["G"]; } else { $G = 0; }

  6178.                        if ( isset($Parameters["B"]) ) { $B = $Parameters["B"]; } else { $B = 0; }

  6179.                        if ( isset($Parameters["Alpha"]) ) { $Alpha = $Parameters["Alpha"]; } else { $Alpha = 100; }

  6180.                        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

  6181.                       }

  6182.                     }

  6183.                   }

  6184. 

  6185.                  imageline($this->Picture,$LastX,$Y,$X,$Y,$Color);

  6186. 

  6187.                  if ( $Y == $DebugLine) { imageline($this->Picture,$LastX,$Y,$X,$Y,$DebugColor); }

  6188. 

  6189.                  $LastX = OUT_OF_SIGHT;

  6190.                 }

  6191.               }

  6192.             }

  6193.           }

  6194.         }

  6195.       }

  6196. 

  6197.      /* Draw the polygon border, if required */

  6198.      if ( !$NoBorder)

  6199.       {

  6200.        foreach($Segments as $Key => $Coords)

  6201.         $this->drawLine($Coords["X1"],$Coords["Y1"],$Coords["X2"],$Coords["Y2"],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Threshold"=>$Threshold));

  6202.       }

  6203. 

  6204.      $this->Shadow = $RestoreShadow;

  6205.     }

  6206. 

  6207.    /* Return the abscissa margin */

  6208.    function getAbscissaMargin($Data)

  6209.     {

  6210.      foreach($Data["Axis"] as $AxisID => $Values) { if ( $Values["Identity"] == AXIS_X ) { return($Values["Margin"]); } }

  6211.      return(0);

  6212.     }

  6213. 

  6214.   }

Constants

Namesort descending Description
ALL
AUTO
BOUND_BOTH
BOUND_LABEL_POS_AUTO
BOUND_LABEL_POS_BOTTOM
BOUND_LABEL_POS_TOP
BOUND_MAX
BOUND_MIN
CAPTION_LEFT_TOP
CAPTION_RIGHT_BOTTOM
DIRECTION_HORIZONTAL
DIRECTION_VERTICAL
DISPLAY_AUTO
DISPLAY_MANUAL
GRADIENT_EFFECT_CAN
GRADIENT_SIMPLE
LABELING_ALL
LABELING_DIFFERENT
LABEL_POINT_BOX
LABEL_POINT_CIRCLE
LABEL_POINT_NONE
LABEL_POS_BOTTOM
LABEL_POS_CENTER
LABEL_POS_INSIDE
LABEL_POS_LEFT
LABEL_POS_OUTSIDE
LABEL_POS_RIGHT
LABEL_POS_TOP
LABEL_TITLE_BACKGROUND
LABEL_TITLE_NOBACKGROUND
LEGEND_BOX
LEGEND_FAMILY_BOX
LEGEND_FAMILY_CIRCLE
LEGEND_FAMILY_LINE
LEGEND_HORIZONTAL
LEGEND_NOBORDER
LEGEND_ROUND
LEGEND_VERTICAL
NONE
ORIENTATION_AUTO
ORIENTATION_HORIZONTAL
ORIENTATION_VERTICAL
OUT_OF_SIGHT
PI
POSITION_BOTTOM
POSITION_TOP
SCALE_MODE_ADDALL
SCALE_MODE_ADDALL_START0
SCALE_MODE_FLOATING
SCALE_MODE_MANUAL
SCALE_MODE_START0
SCALE_POS_LEFTRIGHT
SCALE_POS_TOPBOTTOM
SCALE_SKIP_NONE
SCALE_SKIP_NUMBERS
SCALE_SKIP_SAME
TEXT_ALIGN_BOTTOMLEFT
TEXT_ALIGN_BOTTOMMIDDLE
TEXT_ALIGN_BOTTOMRIGHT
TEXT_ALIGN_MIDDLELEFT
TEXT_ALIGN_MIDDLEMIDDLE
TEXT_ALIGN_MIDDLERIGHT
TEXT_ALIGN_TOPLEFT
TEXT_ALIGN_TOPMIDDLE
TEXT_ALIGN_TOPRIGHT
ZONE_NAME_ANGLE_AUTO

Classes

Namesort descending Description
pDraw