PageRenderTime 168ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 2ms

/TEMPLATE/Reports/class/pchart2/class/pDraw.class.php

https://bitbucket.org/Lahiru_LCB/sep_wd_07
PHP | 5363 lines | 4329 code | 922 blank | 112 comment | 2009 complexity | 13ffc408e253cc133be311d5c20035d7 MD5 | raw file
Possible License(s): LGPL-3.0, GPL-3.0, LGPL-2.1 
    

  1. <?php
    2. 

  2.  /*
    3. 

  3.      pDraw - class extension with drawing methods
    4. 

    5. 

  5.      Version     : 2.1.1
    6. 

  6.      Made by     : Jean-Damien POGOLOTTI
    7. 

  7.      Last Update : 28/03/11
    8. 

    9. 

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

    11. 

  11.                        http://www.pchart.net/license
    12. 

    13. 

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

  14.  */
    15. 

  15. 

  16.  define("DIRECTION_VERTICAL"		, 690001);
    17. 

  17.  define("DIRECTION_HORIZONTAL"		, 690002);
    18. 

  18. 

  19.  define("SCALE_POS_LEFTRIGHT"		, 690101);
    20. 

  20.  define("SCALE_POS_TOPBOTTOM"		, 690102);
    21. 

  21. 

  22.  define("SCALE_MODE_FLOATING"		, 690201);
    23. 

  23.  define("SCALE_MODE_START0"		, 690202);
    24. 

  24.  define("SCALE_MODE_ADDALL"		, 690203);
    25. 

  25.  define("SCALE_MODE_ADDALL_START0"	, 690204);
    26. 

  26.  define("SCALE_MODE_MANUAL"		, 690205);
    27. 

  27. 

  28.  define("SCALE_SKIP_NONE"		, 690301);
    29. 

  29.  define("SCALE_SKIP_SAME"		, 690302);
    30. 

  30.  define("SCALE_SKIP_NUMBERS"		, 690303);
    31. 

  31. 

  32.  define("TEXT_ALIGN_TOPLEFT"		, 690401);
    33. 

  33.  define("TEXT_ALIGN_TOPMIDDLE"		, 690402);
    34. 

  34.  define("TEXT_ALIGN_TOPRIGHT"		, 690403);
    35. 

  35.  define("TEXT_ALIGN_MIDDLELEFT"		, 690404);
    36. 

  36.  define("TEXT_ALIGN_MIDDLEMIDDLE"	, 690405);
    37. 

  37.  define("TEXT_ALIGN_MIDDLERIGHT"	, 690406);
    38. 

  38.  define("TEXT_ALIGN_BOTTOMLEFT"		, 690407);
    39. 

  39.  define("TEXT_ALIGN_BOTTOMMIDDLE"	, 690408);
    40. 

  40.  define("TEXT_ALIGN_BOTTOMRIGHT"	, 690409);
    41. 

  41. 

  42.  define("POSITION_TOP"                  , 690501);
    43. 

  43.  define("POSITION_BOTTOM"               , 690502);
    44. 

  44. 

  45.  define("LABEL_POS_LEFT"		, 690601);
    46. 

  46.  define("LABEL_POS_CENTER"		, 690602);
    47. 

  47.  define("LABEL_POS_RIGHT"		, 690603);
    48. 

  48.  define("LABEL_POS_TOP"			, 690604);
    49. 

  49.  define("LABEL_POS_BOTTOM"		, 690605);
    50. 

  50.  define("LABEL_POS_INSIDE"		, 690606);
    51. 

  51.  define("LABEL_POS_OUTSIDE"		, 690607);
    52. 

  52. 

  53.  define("ORIENTATION_HORIZONTAL"	, 690701);
    54. 

  54.  define("ORIENTATION_VERTICAL"		, 690702);
    55. 

  55. 

  56.  define("LEGEND_NOBORDER"		, 690800);
    57. 

  57.  define("LEGEND_BOX"			, 690801);
    58. 

  58.  define("LEGEND_ROUND"			, 690802);
    59. 

  59. 

  60.  define("LEGEND_VERTICAL"		, 690901);
    61. 

  61.  define("LEGEND_HORIZONTAL"		, 690902);
    62. 

  62. 

  63.  define("LEGEND_FAMILY_BOX"		, 691051);
    64. 

  64.  define("LEGEND_FAMILY_CIRCLE"		, 691052);
    65. 

  65.  define("LEGEND_FAMILY_LINE"		, 691053);
    66. 

  66. 

  67.  define("DISPLAY_AUTO"			, 691001);
    68. 

  68.  define("DISPLAY_MANUAL"		, 691002);
    69. 

  69. 

  70.  define("LABELING_ALL"			, 691011);
    71. 

  71.  define("LABELING_DIFFERENT"		, 691012);
    72. 

  72. 

  73.  define("BOUND_MIN"			, 691021);
    74. 

  74.  define("BOUND_MAX"			, 691022);
    75. 

  75.  define("BOUND_BOTH"			, 691023);
    76. 

  76. 

  77.  define("BOUND_LABEL_POS_TOP"		, 691031);
    78. 

  78.  define("BOUND_LABEL_POS_BOTTOM"	, 691032);
    79. 

  79.  define("BOUND_LABEL_POS_AUTO"		, 691033);
    80. 

  80. 

  81.  define("CAPTION_LEFT_TOP"		, 691041);
    82. 

  82.  define("CAPTION_RIGHT_BOTTOM"		, 691042);
    83. 

  83. 

  84.  define("GRADIENT_SIMPLE"		, 691051);
    85. 

  85.  define("GRADIENT_EFFECT_CAN"		, 691052);
    86. 

  86. 

  87.  define("LABEL_TITLE_NOBACKGROUND"	, 691061);
    88. 

  88.  define("LABEL_TITLE_BACKGROUND"	, 691062);
    89. 

  89. 

  90.  define("LABEL_POINT_NONE"		, 691071);
    91. 

  91.  define("LABEL_POINT_CIRCLE"		, 691072);
    92. 

  92.  define("LABEL_POINT_BOX"		, 691073);
    93. 

  93. 

  94.  define("PI"		, 3.14159265);
    95. 

  95.  define("ALL"		, 69);
    96. 

  96.  define("NONE"		, 31);
    97. 

  97.  define("AUTO"		, 690000);
    98. 

  98.  define("OUT_OF_SIGHT"	, -10000000000000);
    99. 

  99. 

  100.  class pDraw
    101. 

  101.   {
    102. 

  102.    /* Returns the number of drawable series */
    103. 

  103.    function countDrawableSeries()
    104. 

  104.     {
    105. 

  105.      $Results = 0;
    106. 

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

  107. 

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

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

  110. 

  111.      return($Results);
    112. 

  112.     }
    113. 

  113. 

  114.    /* Fix box coordinates */
    115. 

  115.    function fixBoxCoordinates($Xa,$Ya,$Xb,$Yb)
    116. 

  116.     {
    117. 

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

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

  119. 

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

  121.     }
    122. 

  122. 

  123.    /* Draw a polygon */
    124. 

  124.    function drawPolygon($Points,$Format="")
    125. 

  125.     {
    126. 

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

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

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

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

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

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

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

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

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

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

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

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

  138. 

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

  140.      $Backup = $Points;
    141. 

  141. 

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

  143. 

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

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

  146. 

  147.      $RestoreShadow = $this->Shadow;
    148. 

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

  149.       {
    150. 

  150.        $this->Shadow = FALSE;
    151. 

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

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

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

  154.       }
    155. 

  155. 

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

  157. 

  158.      if ( count($Points) >= 6 )
    159. 

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

  160. 

  161.      if ( !$NoBorder )
    162. 

  162.       {
    163. 

  163.        $Points = $Backup;
    164. 

  164. 

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

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

  167.         {
    168. 

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

  169.           {
    170. 

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

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

  172.           }
    173. 

  173.          else
    174. 

  174.           {
    175. 

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

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

  177.           }
    178. 

  178.         }
    179. 

  179.       }
    180. 

  180. 

  181.      $this->Shadow = $RestoreShadow;
    182. 

  182.     }
    183. 

  183. 

  184.    /* Apply AALias correction to the rounded box boundaries */
    185. 

  185.    function offsetCorrection($Value,$Mode)
    186. 

  186.     {
    187. 

  187.      $Value = round($Value,1);
    188. 

  188. 

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

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

  191. 

  192.      if ( $Mode == 1) 
    193. 

  193.       { 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); }; }
    194. 

  194. 

  195.      if ( $Mode == 2) 
    196. 

  196.       { 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); }; }
    197. 

  197. 

  198.      if ( $Mode == 3) 
    199. 

  199.       { 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); }; }
    200. 

  200. 

  201.      if ( $Mode == 4) 
    202. 

  202.       { 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); }; }
    203. 

  203.     }
    204. 

  204. 

  205.    /* Draw a rectangle with rounded corners */
    206. 

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

  207.     {
    208. 

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

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

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

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

  212. 

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

  214. 

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

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

  217. 

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

  219. 

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

  221. 

  222.      if ( $this->Antialias )
    223. 

  223.       {
    224. 

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

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

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

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

  228.       }
    229. 

  229.      else
    230. 

  230.       {
    231. 

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

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

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

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

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

  236.       }
    237. 

  237. 

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

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

  240.       {
    241. 

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

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

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

  244. 

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

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

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

  248. 

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

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

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

  252. 

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

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

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

  256.       }
    257. 

  257.     }
    258. 

  258. 

  259.    /* Draw a rectangle with rounded corners */
    260. 

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

  261.     {
    262. 

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

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

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

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

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

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

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

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

  270. 

  271.      /* Temporary fix for AA issue */
    272. 

  272.      $Y1 = floor($Y1); $Y2 = floor($Y2); $X1 = floor($X1); $X2 = floor($X2);
    273. 

  273. 

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

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

  276. 

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

  278. 

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

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

  281. 

  282.      $RestoreShadow = $this->Shadow;
    283. 

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

  284.       {
    285. 

  285.        $this->Shadow = FALSE;
    286. 

  286.        $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));
    287. 

  287.       }
    288. 

  288. 

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

  290. 

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

  292. 

  293.      $YTop    = $Y1+$Radius;
    294. 

  294.      $YBottom = $Y2-$Radius;
    295. 

  295. 

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

  297.      $Positions = ""; $Radius--; $MinY = ""; $MaxY = "";
    298. 

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

  299.       {
    300. 

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

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

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

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

  304. 

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

  306.        $Xp1++;
    307. 

  307. 

  308.        if ( !isset($Positions[$Yp]) )
    309. 

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

  310.        else
    311. 

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

  312. 

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

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

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

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

  317. 

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

  319.        $Xp1++;
    320. 

  320. 

  321.        if ( !isset($Positions[$Yp]) )
    322. 

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

  323.        else
    324. 

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

  325.       }
    326. 

  326. 

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

  328.      foreach($Positions as $Yp => $Bounds)
    329. 

  329.       {
    330. 

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

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

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

  333.       }
    334. 

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

  335. 

  336.      $Radius++;
    337. 

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

  338. 

  339.      $this->Shadow = $RestoreShadow;
    340. 

  340.     }
    341. 

  341. 

  342.    /* Draw a rectangle with rounded corners */
    343. 

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

  344.     {
    345. 

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

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

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

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

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

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

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

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

  353. 

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

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

  356. 

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

  358. 

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

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

  361. 

  362.      $RestoreShadow = $this->Shadow;
    363. 

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

  364.       {
    365. 

  365.        $this->Shadow = FALSE;
    366. 

  366.        $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));
    367. 

  367.       }
    368. 

  368. 

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

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

  371. 

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

  373. 

  374.      $YTop    = floor($Y1+$Radius);
    375. 

  375.      $YBottom = floor($Y2-$Radius);
    376. 

  376. 

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

  378. 

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

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

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

  382.      $Drawn = "";
    383. 

  383. 

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

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

  386.      
    387. 

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

  388.       {
    389. 

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

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

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

  392. 

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

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

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

  396. 

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

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

  399. 

  400.        $Drawn[$Yp+$YOffset] = $Xp2;
    401. 

  401. 

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

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

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

  405. 

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

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

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

  409. 

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

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

  412. 

  413.        $Drawn[$Yp+$YOffset] = $Xp2;
    414. 

  414.       }
    415. 

  415. 

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

  417. 

  418.      $this->Shadow = $RestoreShadow;
    419. 

  419.     }
    420. 

  420. 

  421.    /* Draw a rectangle */
    422. 

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

  423.     {
    424. 

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

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

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

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

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

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

  430. 

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

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

  433. 

  434.      if ( $this->Antialias )
    435. 

  435.       {
    436. 

  436.        if ( $NoAngle )
    437. 

  437.         {
    438. 

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

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

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

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

  442.         }
    443. 

  443.        else
    444. 

  444.         {
    445. 

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

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

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

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

  449.         }
    450. 

  450.       }
    451. 

  451.      else
    452. 

  452.       {
    453. 

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

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

  455.       }
    456. 

  456.     }
    457. 

  457. 

  458.    /* Draw a filled rectangle */
    459. 

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

  460.     {
    461. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  478. 

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

  480. 

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

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

  483. 

  484.      $RestoreShadow = $this->Shadow;
    485. 

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

  486.       {
    487. 

  487.        $this->Shadow = FALSE;
    488. 

  488.        $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));
    489. 

  489.       }
    490. 

  490. 

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

  492.      if ( $NoAngle )
    493. 

  493.       {
    494. 

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

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

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

  497.       }
    498. 

  498.      else
    499. 

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

  500. 

  501.      if ( $Dash )
    502. 

  502.       {
    503. 

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

  504. 

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

  506.        $Y=$iY1-$DashStep;
    507. 

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

  508.         {
    509. 

  509.          $Y=$Y+$DashStep;
    510. 

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

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

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

  513.         }
    514. 

  514.       }
    515. 

  515. 

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

  517.       {
    518. 

  518.        if ( $X1 < ceil($X1) )
    519. 

  519.         {
    520. 

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

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

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

  523.         }
    524. 

  524. 

  525.        if ( $Y1 < ceil($Y1) )
    526. 

  526.         {
    527. 

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

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

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

  530.         }
    531. 

  531. 

  532.        if ( $X2 > floor($X2) )
    533. 

  533.         {
    534. 

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

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

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

  537.         } 
    538. 

  538. 

  539.        if ( $Y2 > floor($Y2) )
    540. 

  540.         {
    541. 

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

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

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

  544.         }
    545. 

  545.       }
    546. 

  546. 

  547.      if ( $BorderR != -1 )
    548. 

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

  549. 

  550.      $this->Shadow = $RestoreShadow;
    551. 

  551.     }
    552. 

  552. 

  553.    /* Draw a rectangular marker of the specified size */
    554. 

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

  555.     {
    556. 

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

  557. 

  558.      $HalfSize = floor($Size/2);
    559. 

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

  560.     }
    561. 

  561. 

  562.    /* Drawn a spline based on the bezier function */
    563. 

  563.    function drawSpline($Coordinates,$Format="")
    564. 

  564.     {
    565. 

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

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

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

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

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

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

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

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

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

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

  575. 

  576.      $Cpt = NULL; $Mode = NULL; $Result = "";
    577. 

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

  578.       {
    579. 

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

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

  581. 

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

  583. 

  584.        /* First segment */
    585. 

  585.        if ( $i == 1 )
    586. 

  586.         { $Xv1 = $X1; $Yv1 = $Y1; }
    587. 

  587.        else
    588. 

  588.         {
    589. 

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

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

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

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

  593. 

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

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

  596.         }
    597. 

  597. 

  598.        /* Last segment */
    599. 

  599.        if ( $i == count($Coordinates)-1 )
    600. 

  600.         { $Xv2 = $X2; $Yv2 = $Y2; }
    601. 

  601.        else
    602. 

  602.         {
    603. 

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

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

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

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

  607. 

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

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

  610.         }
    611. 

  611. 

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

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

  614. 

  615.        $XLast = $X1; $YLast = $Y1;
    616. 

  616.       }
    617. 

  617. 

  618.      return($Result);
    619. 

  619.     }
    620. 

  620. 

  621.    /* Draw a bezier curve with two controls points */
    622. 

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

  623.     {
    624. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  638. 

  639.      if ( $Segments == NULL )
    640. 

  640.       {
    641. 

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

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

  643.       }
    644. 

  644.      else
    645. 

  645.       $Precision = $Segments;
    646. 

  646. 

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

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

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

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

  651. 

  652.      /* Compute the bezier points */
    653. 

  653.      $Q = ""; $ID = 0; $Path = "";
    654. 

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

  655.       {
    656. 

  656.        $u = $i / $Precision;
    657. 

  657. 

  658.        $C    = "";
    659. 

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

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

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

  662.        $C[3] = $u * $u * $u;
    663. 

  663. 

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

  665.         {
    666. 

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

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

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

  669. 

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

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

  672.         }
    673. 

  673.        $ID++;
    674. 

  674.       }        
    675. 

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

  676. 

  677.      if ( !$NoDraw )
    678. 

  678.       {
    679. 

  679.        /* Display the control points */
    680. 

  680.        if ( $ShowC && !$PathOnly )
    681. 

  681.         {
    682. 

  682.          $Xv1 = floor($Xv1); $Yv1 = floor($Yv1); $Xv2 = floor($Xv2); $Yv2 = floor($Yv2);
    683. 

  683. 

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

  685. 

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

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

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

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

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

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

  692.         }
    693. 

  693. 

  694.        /* Draw the bezier */
    695. 

  695.        $LastX = NULL; $LastY = NULL; $Cpt = NULL; $Mode = NULL; $ArrowS = NULL;
    696. 

  696.        foreach ($Q as $Key => $Point)
    697. 

  697.         {
    698. 

  698.          $X = $Point["X"]; $Y = $Point["Y"];
    699. 

  699. 

  700.          /* Get the first segment */
    701. 

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

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

  703. 

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

  705.           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));
    706. 

  706. 

  707.          /* Get the last segment */
    708. 

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

  709. 

  710.          $LastX = $X; $LastY = $Y;
    711. 

  711.         }
    712. 

  712. 

  713.        if ( $DrawArrow && !$PathOnly )
    714. 

  714.         {
    715. 

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

  716.          if ( $ArrowTwoHeads )
    717. 

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

  718. 

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

  720.         }
    721. 

  721.       }
    722. 

  722.      return($Q);
    723. 

  723.     }
    724. 

  724. 

  725.    /* Draw a line between two points */
    726. 

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

  727.     {
    728. 

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

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

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

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

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

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

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

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

  736. 

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

  738.       {
    739. 

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

  740.         {
    741. 

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

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

  743.         }
    744. 

  744. 

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

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

  747.        return(0);
    748. 

  748.       }
    749. 

  749. 

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

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

  752. 

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

  754.      if ( $Weight != NULL )
    755. 

  755.       {
    756. 

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

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

  758. 

  759.        if ( $Ticks == NULL )
    760. 

  760.         {
    761. 

  761.          $Points   = ""; 
    762. 

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

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

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

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

  766. 

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

  768.         }
    769. 

  769.        else
    770. 

  770.         {
    771. 

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

  772.           {
    773. 

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

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

  775. 

  776.            $Points   = ""; 
    777. 

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

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

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

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

  781. 

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

  783.           }
    784. 

  784.         }
    785. 

  785. 

  786.        return(1);
    787. 

  787.       }
    788. 

  788. 

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

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

  791. 

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

  793.       {
    794. 

  794.        $X = $i * $XStep + $X1;
    795. 

  795.        $Y = $i * $YStep + $Y1;
    796. 

  796. 

  797.        if ( $Ticks != NULL )
    798. 

  798.         {
    799. 

  799.          if ( $Cpt % $Ticks == 0 )
    800. 

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

  801. 

  802.          if ( $Mode == 1 )
    803. 

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

  804. 

  805.          $Cpt++;
    806. 

  806.         }
    807. 

  807.        else
    808. 

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

  809.       }
    810. 

  810.      return(array($Cpt,$Mode));
    811. 

  811.     }
    812. 

  812. 

  813.    /* Draw a circle */
    814. 

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

  815.     {
    816. 

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

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

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

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

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

  821. 

  822.      $Height	= abs($Height);
    823. 

  823.      $Width	= abs($Width);
    824. 

  824. 

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

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

  827.      $Xc = floor($Xc); $Yc = floor($Yc);
    828. 

  828. 

  829.      $RestoreShadow = $this->Shadow;
    830. 

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

  831.       {
    832. 

  832.        $this->Shadow = FALSE;
    833. 

  833.        $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));
    834. 

  834.       }
    835. 

  835. 

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

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

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

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

  840. 

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

  842.      $Mode = 1; $Cpt = 1;
    843. 

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

  844.       {
    845. 

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

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

  847. 

  848.        if ( $Ticks != NULL )
    849. 

  849.         {
    850. 

  850.          if ( $Cpt % $Ticks == 0 )
    851. 

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

  852. 

  853.          if ( $Mode == 1 )
    854. 

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

  855. 

  856.          $Cpt++;
    857. 

  857.         }
    858. 

  858.        else
    859. 

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

  860. 

  861.       }
    862. 

  862.      $this->Shadow = $RestoreShadow;
    863. 

  863.     }
    864. 

  864. 

  865.    /* Draw a filled circle */
    866. 

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

  867.     {
    868. 

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

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

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

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

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

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

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

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

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

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

  878. 

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

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

  881.      $X = floor($X); $Y = floor($Y);
    882. 

  882. 

  883.      $Radius = abs($Radius);
    884. 

  884. 

  885.      $RestoreShadow = $this->Shadow;
    886. 

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

  887.       {
    888. 

  888.        $this->Shadow = FALSE;
    889. 

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

  890.       }
    891. 

  891. 

  892.      $this->Mask  = "";
    893. 

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

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

  895.       {
    896. 

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

  897.        $XPos   = floor($Slice);
    898. 

  898.        $YPos   = $Y + $i - $Radius;
    899. 

  899.        $AAlias = $Slice - floor($Slice);
    900. 

  900. 

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

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

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

  904.       }
    905. 

  905.      if ( $this->Antialias )
    906. 

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

  907. 

  908.      $this->Mask = "";
    909. 

  909. 

  910.      if ( $BorderR != -1 )
    911. 

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

  912. 

  913.      $this->Shadow	= $RestoreShadow;
    914. 

  914.     }
    915. 

  915. 

  916.    /* Write text */
    917. 

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

  918.     {
    919. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  944. 

  945.      $Shadow = $this->Shadow;
    946. 

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

  947. 

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

  949. 

  950.      if ( $ShowOrigine )
    951. 

  951.       {
    952. 

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

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

  954.       }
    955. 

  955. 

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

  957. 

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

  959.       {
    960. 

  960.        $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;
    961. 

  961.        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; }
    962. 

  962. 

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

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

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

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

  967. 

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

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

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

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

  972. 

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

  974. 

  975.        if ( $BoxRounded )
    976. 

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

  977.        else
    978. 

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

  979.       }
    980. 

  980. 

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

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

  983. 

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

  985.       {
    986. 

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

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

  988.       }
    989. 

  989. 

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

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

  992. 

  993.      $this->Shadow = $Shadow;
    994. 

  994. 

  995.      return($TxtPos);
    996. 

  996.     }
    997. 

  997. 

  998.    /* Draw a gradient within a defined area */
    999. 

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

  1000.     {
    1001. 

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

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

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

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

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

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

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

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

  1009. 

  1010.      $Shadow = $this->Shadow;
    1011. 

  1011.      $this->Shadow = FALSE;
    1012. 

  1012. 

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

  1014.       {
    1015. 

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

  1016.        return(0);
    1017. 

  1017.       }
    1018. 

  1018. 

  1019.      if ( $Levels != NULL )
    1020. 

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

  1021. 

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

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

  1024. 

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

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

  1027. 

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

  1029.      $StepSize = $Width/$Step;
    1030. 

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

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

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

  1033. 

  1034.      $R=$StartR;$G=$StartG;$B=$StartB;
    1035. 

  1035.      switch($Direction)
    1036. 

  1036.       {
    1037. 

  1037.        case DIRECTION_VERTICAL:
    1038. 

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

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

  1040.          {
    1041. 

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

  1042. 

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

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

  1045.            {
    1046. 

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

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

  1048.             $LastY2 = max($LastY2,$Y2);
    1049. 

  1049.             $Y1 = $Y2+1;
    1050. 

  1050.            }
    1051. 

  1051.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep;
    1052. 

  1052.          }
    1053. 

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

  1054.         break;
    1055. 

  1055. 

  1056.        case DIRECTION_HORIZONTAL:
    1057. 

  1057.         $StartX = $X1; $EndX = $X2;
    1058. 

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

  1059.          {
    1060. 

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

  1061. 

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

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

  1064.            {
    1065. 

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

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

  1067.             $X1 = $X2+1;
    1068. 

  1068.            }
    1069. 

  1069.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep; 
    1070. 

  1070.          }
    1071. 

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

  1072.         break;
    1073. 

  1073.       }
    1074. 

  1074. 

  1075.      $this->Shadow = $Shadow;
    1076. 

  1076. 

  1077.     }
    1078. 

  1078. 

  1079.    /* Draw an aliased pixel */
    1080. 

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

  1081.     {
    1082. 

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

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

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

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

  1086. 

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

  1088.       return(-1);
    1089. 

  1089. 

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

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

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

  1093. 

  1094.      if ( !$this->Antialias )
    1095. 

  1095.       {
    1096. 

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

  1097.         {
    1098. 

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

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

  1100.         }
    1101. 

  1101. 

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

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

  1104. 

  1105.        return(0);
    1106. 

  1106.       }
    1107. 

  1107. 

  1108.      $Plot = "";
    1109. 

  1109.      $Xi   = floor($X);
    1110. 

  1110.      $Yi   = floor($Y);
    1111. 

  1111. 

  1112.      if ( $Xi == $X && $Yi == $Y)
    1113. 

  1113.       {
    1114. 

  1114.        if ( $Alpha == 100 )
    1115. 

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

  1116.        else
    1117. 

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

  1118.       }
    1119. 

  1119.      else
    1120. 

  1120.       {
    1121. 

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

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

  1123. 

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

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

  1126. 

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

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

  1129. 

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

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

  1132.       }
    1133. 

  1133.     }
    1134. 

  1134. 

  1135.    /* Draw a semi-transparent pixel */
    1136. 

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

  1137.     {
    1138. 

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

  1139. 

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

  1141.       return(-1);
    1142. 

  1142. 

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

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

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

  1146. 

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

  1148.       {
    1149. 

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

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

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

  1152.       }
    1153. 

  1153. 

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

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

  1156.     }
    1157. 

  1157. 

  1158.    /* Convert apha to base 10 */
    1159. 

  1159.    function convertAlpha($AlphaValue)
    1160. 

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

  1161. 

  1162.    /* Allocate a color with transparency */
    1163. 

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

  1164.     {
    1165. 

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

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

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

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

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

  1170. 

  1171.      $Alpha = $this->convertAlpha($Alpha);
    1172. 

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

  1173.     }
    1174. 

  1174. 

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

  1176.    function drawFromPNG($X,$Y,$FileName)
    1177. 

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

  1178. 

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

  1180.    function drawFromGIF($X,$Y,$FileName)
    1181. 

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

  1182. 

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

  1184.    function drawFromJPG($X,$Y,$FileName)
    1185. 

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

  1186. 

  1187.    function getPicInfo($FileName)
    1188. 

  1188.     {
    1189. 

  1189.      $Infos  = getimagesize($FileName);
    1190. 

  1190.      $Width  = $Infos[0];
    1191. 

  1191.      $Height = $Infos[1];
    1192. 

  1192.      $Type   = $Infos["mime"];
    1193. 

  1193. 

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

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

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

  1197. 

  1198.      return(array($Width,$Height,$Type));
    1199. 

  1199.     }
    1200. 

  1200. 

  1201.    /* Generic loader function for external pictures */
    1202. 

  1202.    function drawFromPicture($PicType,$FileName,$X,$Y)
    1203. 

  1203.     {
    1204. 

  1204.      if ( file_exists($FileName))
    1205. 

  1205.       {
    1206. 

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

  1207. 

  1208.        if ( $PicType == 1 )
    1209. 

  1209.         { $Raster = imagecreatefrompng($FileName); }
    1210. 

  1210.        elseif ( $PicType == 2 )
    1211. 

  1211.         { $Raster = imagecreatefromgif($FileName); }
    1212. 

  1212.        elseif ( $PicType == 3 )
    1213. 

  1213.         { $Raster = imagecreatefromjpeg($FileName); }
    1214. 

  1214.        else
    1215. 

  1215.         { return(0); }
    1216. 

  1216. 

  1217. 

  1218.        $RestoreShadow = $this->Shadow;
    1219. 

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

  1220.         {
    1221. 

  1221.          $this->Shadow = FALSE;
    1222. 

  1222.          if ( $PicType == 3 )
    1223. 

  1223.           $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));
    1224. 

  1224.          else
    1225. 

  1225.           {
    1226. 

  1226.            $TranparentID = imagecolortransparent($Raster);
    1227. 

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

  1228.             {
    1229. 

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

  1230.               {
    1231. 

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

  1232.                $Values = imagecolorsforindex($Raster,$RGBa);
    1233. 

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

  1234.                 {
    1235. 

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

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

  1237.                 }
    1238. 

  1238.               }
    1239. 

  1239.             }
    1240. 

  1240.           }
    1241. 

  1241.         }
    1242. 

  1242.        $this->Shadow = $RestoreShadow;
    1243. 

  1243. 

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

  1245.        imagedestroy($Raster);
    1246. 

  1246.       }
    1247. 

  1247.     }
    1248. 

  1248. 

  1249.    /* Draw an arrow */
    1250. 

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

  1251.     {
    1252. 

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

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

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

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

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

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

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

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

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

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

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

  1263. 

  1264.      /* Calculate the line angle */
    1265. 

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

  1266. 

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

  1268.      $RestoreShadow = $this->Shadow;
    1269. 

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

  1270.       {
    1271. 

  1271.        $this->Shadow = FALSE;
    1272. 

  1272.        $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));
    1273. 

  1273.       }
    1274. 

  1274. 

  1275.      /* Draw the 1st Head */
    1276. 

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

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

  1278. 

  1279.      $Points	= "";
    1280. 

  1280.      $Points[]  = $X2; $Points[]  = $Y2;
    1281. 

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

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

  1283.      $Points[]  = $X2; $Points[]  = $Y2;
    1284. 

  1284. 

  1285.      /* Visual correction */
    1286. 

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

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

  1288. 

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

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

  1291. 

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

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

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

  1295. 

  1296.      /* Draw the second head */
    1297. 

  1297.      if ( $TwoHeads )
    1298. 

  1298.       {
    1299. 

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

  1300. 

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

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

  1303. 

  1304.        $Points   = "";
    1305. 

  1305.        $Points[] = $X1; $Points[]  = $Y1;
    1306. 

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

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

  1308.        $Points[] = $X1; $Points[]  = $Y1;
    1309. 

  1309. 

  1310.        /* Visual correction */
    1311. 

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

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

  1313. 

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

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

  1316. 

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

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

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

  1320. 

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

  1322.       }
    1323. 

  1323.      else
    1324. 

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

  1325. 

  1326.      /* Re-enable shadows */
    1327. 

  1327.      $this->Shadow = $RestoreShadow;
    1328. 

  1328.     }
    1329. 

  1329. 

  1330.    /* Draw a label with associated arrow */
    1331. 

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

  1332.     {
    1333. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1348. 

  1349.      $Angle = $Angle % 360;
    1350. 

  1350. 

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

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

  1353. 

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

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

  1356. 

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

  1358. 

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

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

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

  1362. 

  1363.      if ( $Angle > 0 && $Angle < 180 )
    1364. 

  1364.       {
    1365. 

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

  1366.        if ( $Position == POSITION_TOP )
    1367. 

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

  1368.        else
    1369. 

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

  1370.       }
    1371. 

  1371.      else
    1372. 

  1372.       {
    1373. 

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

  1374.        if ( $Position == POSITION_TOP )
    1375. 

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

  1376.        else
    1377. 

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

  1378.       }
    1379. 

  1379.     }
    1380. 

  1380. 

  1381.    /* Draw a progress bar filled with specified % */
    1382. 

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

  1383.     {
    1384. 

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

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

  1386. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1412. 

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

  1414.       {
    1415. 

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

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

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

  1418.       }
    1419. 

  1419. 

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

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

  1422. 

  1423.      if ( $Orientation == ORIENTATION_VERTICAL )
    1424. 

  1424.       {
    1425. 

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

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

  1427. 

  1428.        $RestoreShadow = $this->Shadow; $this->Shadow  = FALSE;
    1429. 

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

  1430.         {
    1431. 

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

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

  1433. 

  1434.          if ( $Surrounding )
    1435. 

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

  1436.         }
    1437. 

  1437.        else
    1438. 

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

  1439. 

  1440.        $this->Shadow = $RestoreShadow;
    1441. 

  1441. 

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

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

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

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

  1446.       }
    1447. 

  1447.      else
    1448. 

  1448.       {
    1449. 

  1449.        if ( $Percent == 100 )
    1450. 

  1450.         $InnerWidth = $Width-1;
    1451. 

  1451.        else
    1452. 

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

  1453. 

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

  1455. 

  1456.        $RestoreShadow = $this->Shadow; $this->Shadow  = FALSE;
    1457. 

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

  1458.         {
    1459. 

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

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

  1461. 

  1462.          if ( $Surrounding )
    1463. 

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

  1464.         }
    1465. 

  1465.        else
    1466. 

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

  1467.  
    1468. 

  1468.        $this->Shadow = $RestoreShadow;
    1469. 

  1469. 

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

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

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

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

  1474.       }
    1475. 

  1475.     }
    1476. 

  1476. 

  1477.    /* Get the legend box size */
    1478. 

  1478.    function getLegendSize($Format="")
    1479. 

  1479.     {
    1480. 

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

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

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

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

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

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

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

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

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

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

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

  1491. 

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

  1493. 

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

  1495.       {
    1496. 

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

  1497.         {
    1498. 

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

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

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

  1501.         }
    1502. 

  1502.       }
    1503. 

  1503. 

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

  1505.      $XStep = $IconAreaWidth + 5;
    1506. 

  1506.      $XStep = $XSpacing;
    1507. 

  1507. 

  1508.      $X=100; $Y=100;
    1509. 

  1509. 

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

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

  1512.       {
    1513. 

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

  1514.         {
    1515. 

  1515.          if ( $Mode == LEGEND_VERTICAL )
    1516. 

  1516.           {
    1517. 

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

  1518. 

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

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

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

  1522. 

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

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

  1525.           }
    1526. 

  1526.          elseif ( $Mode == LEGEND_HORIZONTAL )
    1527. 

  1527.           {
    1528. 

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

  1529.            $Width = "";
    1530. 

  1530.            foreach($Lines as $Key => $Value)
    1531. 

  1531.             {
    1532. 

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

  1533. 

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

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

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

  1537. 

  1538.              $Width[] = $BoxArray[1]["X"];
    1539. 

  1539.             }
    1540. 

  1540. 

  1541.            $vX=max($Width)+$XStep;
    1542. 

  1542.           }
    1543. 

  1543.         }
    1544. 

  1544.       }
    1545. 

  1545.      $vY=$vY-$YStep; $vX=$vX-$XStep;
    1546. 

  1546. 

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

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

  1549. 

  1550.      $Width  = ($Boundaries["R"]+$Margin) - ($Boundaries["L"]-$Margin);
    1551. 

  1551.      $Height = ($Boundaries["B"]+$Margin) - ($Boundaries["T"]-$Margin);
    1552. 

  1552. 

  1553.      return(array("Width"=>$Width,"Height"=>$Height));
    1554. 

  1554.     }
    1555. 

  1555. 

  1556.    /* Draw the legend of the active series */
    1557. 

  1557.    function drawLegend($X,$Y,$Format="")
    1558. 

  1558.     {
    1559. 

  1559.      $Family	= isset($Format["Family"]) ? $Format["Family"] : LEGEND_FAMILY_BOX;
    1560. 

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

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

  1562.      $FontR	= isset($Format["FontR"]) ? $Format["FontR"] : $this->FontColorR;
    1563. 

  1563.      $FontG	= isset($Format["FontG"]) ? $Format["FontG"] : $this->FontColorG;
    1564. 

  1564.      $FontB	= isset($Format["FontB"]) ? $Format["FontB"] : $this->FontColorB;
    1565. 

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

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

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

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

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

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

  1571.      $R		= isset($Format["R"]) ? $Format["R"] : 200;
    1572. 

  1572.      $G		= isset($Format["G"]) ? $Format["G"] : 200;
    1573. 

  1573.      $B		= isset($Format["B"]) ? $Format["B"] : 200;
    1574. 

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

  1575.      $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;
    1576. 

  1576.      $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;
    1577. 

  1577.      $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;
    1578. 

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

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

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

  1581. 

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

  1583. 

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

  1585. 

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

  1587.       {
    1588. 

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

  1589.         {
    1590. 

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

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

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

  1593.         }
    1594. 

  1594.       }
    1595. 

  1595. 

  1596. 

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

  1598.      $XStep = $IconAreaWidth + 5;
    1599. 

  1599.      $XStep = $XSpacing;
    1600. 

  1600. 

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

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

  1603.       {
    1604. 

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

  1605.         {
    1606. 

  1606.          if ( $Mode == LEGEND_VERTICAL )
    1607. 

  1607.           {
    1608. 

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

  1609. 

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

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

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

  1613. 

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

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

  1616.           }
    1617. 

  1617.          elseif ( $Mode == LEGEND_HORIZONTAL )
    1618. 

  1618.           {
    1619. 

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

  1620.            $Width = "";
    1621. 

  1621.            foreach($Lines as $Key => $Value)
    1622. 

  1622.             {
    1623. 

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

  1624. 

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

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

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

  1628. 

  1629.              $Width[] = $BoxArray[1]["X"];
    1630. 

  1630.             }
    1631. 

  1631. 

  1632.            $vX=max($Width)+$XStep;
    1633. 

  1633.           }
    1634. 

  1634.         }
    1635. 

  1635.       }
    1636. 

  1636.      $vY=$vY-$YStep; $vX=$vX-$XStep;
    1637. 

  1637. 

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

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

  1640. 

  1641.      if ( $Style == LEGEND_ROUND )
    1642. 

  1642.       $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));
    1643. 

  1643.      elseif ( $Style == LEGEND_BOX )
    1644. 

  1644.       $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));
    1645. 

  1645. 

  1646.      $RestoreShadow = $this->Shadow; $this->Shadow = FALSE;
    1647. 

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

  1648.       {
    1649. 

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

  1650.         {
    1651. 

  1651.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"];
    1652. 

  1652.          $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    1653. 

  1653. 

  1654.          if ( isset($Serie["Picture"]) )
    1655. 

  1655.           {
    1656. 

  1656.            $Picture = $Serie["Picture"];
    1657. 

  1657.            list($PicWidth,$PicHeight) = $this->getPicInfo($Picture);
    1658. 

  1658.            $PicX = $X+$IconAreaWidth/2; $PicY = $Y+$IconAreaHeight/2; 
    1659. 

  1659. 

  1660.            $this->drawFromPNG($PicX-$PicWidth/2,$PicY-$PicHeight/2,$Picture);
    1661. 

  1661.           }
    1662. 

  1662.          else
    1663. 

  1663.           {
    1664. 

  1664.            if ( $Family == LEGEND_FAMILY_BOX )
    1665. 

  1665.             {
    1666. 

  1666.              if ( $BoxWidth != $IconAreaWidth ) { $XOffset = floor(($IconAreaWidth-$BoxWidth)/2); } else { $XOffset = 0; }
    1667. 

  1667.              if ( $BoxHeight != $IconAreaHeight ) { $YOffset = floor(($IconAreaHeight-$BoxHeight)/2); } else { $YOffset = 0; }
    1668. 

  1668. 

  1669.              $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));
    1670. 

  1670.              $this->drawFilledRectangle($X+$XOffset,$Y+$YOffset,$X+$BoxWidth+$XOffset,$Y+$BoxHeight+$YOffset,array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));
    1671. 

  1671.             }
    1672. 

  1672.            elseif ( $Family == LEGEND_FAMILY_CIRCLE )
    1673. 

  1673.             {
    1674. 

  1674.              $this->drawFilledCircle($X+1+$IconAreaWidth/2,$Y+1+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20));
    1675. 

  1675.              $this->drawFilledCircle($X+$IconAreaWidth/2,$Y+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));
    1676. 

  1676.             }
    1677. 

  1677.            elseif ( $Family == LEGEND_FAMILY_LINE )
    1678. 

  1678.             {
    1679. 

  1679.              $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));
    1680. 

  1680.              $this->drawLine($X,$Y+$IconAreaHeight/2,$X+$IconAreaWidth,$Y+$IconAreaHeight/2,array("R"=>$R,"G"=>$G,"B"=>$B,"Ticks"=>$Ticks,"Weight"=>$Weight));
    1681. 

  1681.             }
    1682. 

  1682.           }
    1683. 

  1683. 

  1684.          if ( $Mode == LEGEND_VERTICAL )
    1685. 

  1685.           {
    1686. 

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

  1687.            foreach($Lines as $Key => $Value)
    1688. 

  1688.             $this->drawText($X+$IconAreaWidth+4,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT));
    1689. 

  1689. 

  1690.            $Y=$Y+max($this->FontSize*count($Lines),$IconAreaHeight) + 5;
    1691. 

  1691.           }
    1692. 

  1692.          elseif ( $Mode == LEGEND_HORIZONTAL )
    1693. 

  1693.           {
    1694. 

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

  1695.            $Width = "";
    1696. 

  1696.            foreach($Lines as $Key => $Value)
    1697. 

  1697.             {
    1698. 

  1698.              $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));
    1699. 

  1699.              $Width[] = $BoxArray[1]["X"];
    1700. 

  1700.             }
    1701. 

  1701.            $X=max($Width)+2+$XStep;
    1702. 

  1702.           }
    1703. 

  1703.         }
    1704. 

  1704.       }
    1705. 

  1705. 

  1706. 

  1707.      $this->Shadow = $RestoreShadow;
    1708. 

  1708.     }
    1709. 

  1709. 

  1710.    function drawScale($Format="")
    1711. 

  1711.     {
    1712. 

  1712.      $Pos		= isset($Format["Pos"]) ? $Format["Pos"] : SCALE_POS_LEFTRIGHT;
    1713. 

  1713.      $Floating		= isset($Format["Floating"]) ? $Format["Floating"] : FALSE;
    1714. 

  1714.      $Mode		= isset($Format["Mode"]) ? $Format["Mode"] : SCALE_MODE_FLOATING;
    1715. 

  1715.      $MinDivHeight	= isset($Format["MinDivHeight"]) ? $Format["MinDivHeight"] : 20;
    1716. 

  1716.      $Factors		= isset($Format["Factors"]) ? $Format["Factors"] : array(1,2,5);
    1717. 

  1717.      $ManualScale	= isset($Format["ManualScale"]) ? $Format["ManualScale"] : array("0"=>array("Min"=>-100,"Max"=>100));
    1718. 

  1718.      $XMargin		= isset($Format["XMargin"]) ? $Format["XMargin"] : AUTO;
    1719. 

  1719.      $YMargin		= isset($Format["YMargin"]) ? $Format["YMargin"] : 0;
    1720. 

  1720.      $ScaleSpacing	= isset($Format["ScaleSpacing"]) ? $Format["ScaleSpacing"] : 15;
    1721. 

  1721.      $InnerTickWidth	= isset($Format["InnerTickWidth"]) ? $Format["InnerTickWidth"] : 2;
    1722. 

  1722.      $OuterTickWidth	= isset($Format["OuterTickWidth"]) ? $Format["OuterTickWidth"] : 2;
    1723. 

  1723.      $DrawXLines	= isset($Format["DrawXLines"]) ? $Format["DrawXLines"] : TRUE;
    1724. 

  1724.      $DrawYLines	= isset($Format["DrawYLines"]) ? $Format["DrawYLines"] : ALL;
    1725. 

  1725.      $GridTicks		= isset($Format["GridTicks"]) ? $Format["GridTicks"] : 4;
    1726. 

  1726.      $GridR		= isset($Format["GridR"]) ? $Format["GridR"] : 255;
    1727. 

  1727.      $GridG		= isset($Format["GridG"]) ? $Format["GridG"] : 255;
    1728. 

  1728.      $GridB		= isset($Format["GridB"]) ? $Format["GridB"] : 255;
    1729. 

  1729.      $GridAlpha		= isset($Format["GridAlpha"]) ? $Format["GridAlpha"] : 40;
    1730. 

  1730.      $AxisRo		= isset($Format["AxisR"]) ? $Format["AxisR"] : 0;
    1731. 

  1731.      $AxisGo		= isset($Format["AxisG"]) ? $Format["AxisG"] : 0;
    1732. 

  1732.      $AxisBo		= isset($Format["AxisB"]) ? $Format["AxisB"] : 0;
    1733. 

  1733.      $AxisAlpha		= isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 100;
    1734. 

  1734.      $TickRo		= isset($Format["TickR"]) ? $Format["TickR"] : 0;
    1735. 

  1735.      $TickGo		= isset($Format["TickG"]) ? $Format["TickG"] : 0;
    1736. 

  1736.      $TickBo		= isset($Format["TickB"]) ? $Format["TickB"] : 0;
    1737. 

  1737.      $TickAlpha		= isset($Format["TickAlpha"]) ? $Format["TickAlpha"] : 100;
    1738. 

  1738.      $DrawSubTicks	= isset($Format["DrawSubTicks"]) ? $Format["DrawSubTicks"] : FALSE;
    1739. 

  1739.      $InnerSubTickWidth	= isset($Format["InnerSubTickWidth"]) ? $Format["InnerSubTickWidth"] : 0;
    1740. 

  1740.      $OuterSubTickWidth	= isset($Format["OuterSubTickWidth"]) ? $Format["OuterSubTickWidth"] : 2;
    1741. 

  1741.      $SubTickR		= isset($Format["SubTickR"]) ? $Format["SubTickR"] : 255;
    1742. 

  1742.      $SubTickG		= isset($Format["SubTickG"]) ? $Format["SubTickG"] : 0;
    1743. 

  1743.      $SubTickB		= isset($Format["SubTickB"]) ? $Format["SubTickB"] : 0;
    1744. 

  1744.      $SubTickAlpha	= isset($Format["SubTickAlpha"]) ? $Format["SubTickAlpha"] : 100;
    1745. 

  1745.      $AutoAxisLabels	= isset($Format["AutoAxisLabels"]) ? $Format["AutoAxisLabels"] : TRUE;
    1746. 

  1746.      $XReleasePercent	= isset($Format["XReleasePercent"]) ? $Format["XReleasePercent"] : 1;
    1747. 

  1747.      $DrawArrows	= isset($Format["DrawArrows"]) ? $Format["DrawArrows"] : FALSE;
    1748. 

  1748.      $ArrowSize         = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 8;
    1749. 

  1749.      $CycleBackground	= isset($Format["CycleBackground"]) ? $Format["CycleBackground"] : FALSE;
    1750. 

  1750.      $BackgroundR1	= isset($Format["BackgroundR1"]) ? $Format["BackgroundR1"] : 255;
    1751. 

  1751.      $BackgroundG1	= isset($Format["BackgroundG1"]) ? $Format["BackgroundG1"] : 255;
    1752. 

  1752.      $BackgroundB1	= isset($Format["BackgroundB1"]) ? $Format["BackgroundB1"] : 255;
    1753. 

  1753.      $BackgroundAlpha1	= isset($Format["BackgroundAlpha1"]) ? $Format["BackgroundAlpha1"] : 20;
    1754. 

  1754.      $BackgroundR2	= isset($Format["BackgroundR2"]) ? $Format["BackgroundR2"] : 230;
    1755. 

  1755.      $BackgroundG2	= isset($Format["BackgroundG2"]) ? $Format["BackgroundG2"] : 230;
    1756. 

  1756.      $BackgroundB2	= isset($Format["BackgroundB2"]) ? $Format["BackgroundB2"] : 230;
    1757. 

  1757.      $BackgroundAlpha2	= isset($Format["BackgroundAlpha2"]) ? $Format["BackgroundAlpha2"] : 20;
    1758. 

  1758.      $LabelingMethod	= isset($Format["LabelingMethod"]) ? $Format["LabelingMethod"] : LABELING_ALL;
    1759. 

  1759.      $LabelSkip		= isset($Format["LabelSkip"]) ? $Format["LabelSkip"] : 0;
    1760. 

  1760.      $LabelRotation	= isset($Format["LabelRotation"]) ? $Format["LabelRotation"] : 0;
    1761. 

  1761.      $SkippedAxisTicks	= isset($Format["SkippedAxisTicks"]) ? $Format["SkippedAxisTicks"] : $GridTicks+2;
    1762. 

  1762.      $SkippedAxisR	= isset($Format["SkippedAxisR"]) ? $Format["SkippedAxisR"] : $GridR;
    1763. 

  1763.      $SkippedAxisG	= isset($Format["SkippedAxisG"]) ? $Format["SkippedAxisG"] : $GridG;
    1764. 

  1764.      $SkippedAxisB	= isset($Format["SkippedAxisB"]) ? $Format["SkippedAxisB"] : $GridB;
    1765. 

  1765.      $SkippedAxisAlpha	= isset($Format["SkippedAxisAlpha"]) ? $Format["SkippedAxisAlpha"] : $GridAlpha-30;
    1766. 

  1766.      $SkippedTickR	= isset($Format["SkippedTickR"]) ? $Format["SkippedTickR"] : $TickRo;
    1767. 

  1767.      $SkippedTickG	= isset($Format["SkippedTickG"]) ? $Format["SkippedTickG"] : $TickGo;
    1768. 

  1768.      $SkippedTickB	= isset($Format["SkippedTicksB"]) ? $Format["SkippedTickB"] : $TickBo;
    1769. 

  1769.      $SkippedTickAlpha	= isset($Format["SkippedTickAlpha"]) ? $Format["SkippedTickAlpha"] : $TickAlpha-80;
    1770. 

  1770.      $SkippedInnerTickWidth	= isset($Format["SkippedInnerTickWidth"]) ? $Format["SkippedInnerTickWidth"] : 0;
    1771. 

  1771.      $SkippedOuterTickWidth	= isset($Format["SkippedOuterTickWidth"]) ? $Format["SkippedOuterTickWidth"] : 2;
    1772. 

  1772. 

  1773.      /* Floating scale require X & Y margins to be set manually */
    1774. 

  1774.      if ( $Floating && ( $XMargin == AUTO || $YMargin == 0 ) ) { $Floating = FALSE; }
    1775. 

  1775. 

  1776.      /* Skip a NOTICE event in case of an empty array */
    1777. 

  1777.      if ( $DrawYLines == NONE || $DrawYLines == FALSE ) { $DrawYLines = array("zarma"=>"31"); }
    1778. 

  1778. 

  1779.      /* Define the color for the skipped elements */
    1780. 

  1780.      $SkippedAxisColor = array("R"=>$SkippedAxisR,"G"=>$SkippedAxisG,"B"=>$SkippedAxisB,"Alpha"=>$SkippedAxisAlpha,"Ticks"=>$SkippedAxisTicks);
    1781. 

  1781.      $SkippedTickColor = array("R"=>$SkippedTickR,"G"=>$SkippedTickG,"B"=>$SkippedTickB,"Alpha"=>$SkippedTickAlpha);
    1782. 

  1782. 

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

  1784.      if ( isset($Data["Abscissa"]) ) { $Abscissa = $Data["Abscissa"]; } else { $Abscissa = NULL; }
    1785. 

  1785. 

  1786.      /* Unset the abscissa axis, needed if we display multiple charts on the same picture */
    1787. 

  1787.      if ( $Abscissa != NULL )
    1788. 

  1788.       {
    1789. 

  1789.        foreach($Data["Axis"] as $AxisID => $Parameters)
    1790. 

  1790.         { if ($Parameters["Identity"] == AXIS_X) { unset($Data["Axis"][$AxisID]); } }
    1791. 

  1791.       }
    1792. 

  1792. 

  1793.      /* Build the scale settings */
    1794. 

  1794.      $GotXAxis = FALSE;
    1795. 

  1795.      foreach($Data["Axis"] as $AxisID => $AxisParameter)
    1796. 

  1796.       {
    1797. 

  1797.        if ( $AxisParameter["Identity"] == AXIS_X ) { $GotXAxis = TRUE; }
    1798. 

  1798. 

  1799.        if ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_Y)
    1800. 

  1800.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1 - $YMargin*2; }
    1801. 

  1801.        elseif ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_X)
    1802. 

  1802.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }
    1803. 

  1803.        elseif ( $Pos == SCALE_POS_TOPBOTTOM && $AxisParameter["Identity"] == AXIS_Y)
    1804. 

  1804.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1 - $YMargin*2;; }
    1805. 

  1805.        else
    1806. 

  1806.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }
    1807. 

  1807. 

  1808.        $AxisMin = ABSOLUTE_MAX; $AxisMax = OUT_OF_SIGHT;
    1809. 

  1809.        if ( $Mode == SCALE_MODE_FLOATING || $Mode == SCALE_MODE_START0 )
    1810. 

  1810.         {
    1811. 

  1811.          foreach($Data["Series"] as $SerieID => $SerieParameter)
    1812. 

  1812.           {
    1813. 

  1813.            if ( $SerieParameter["Axis"] == $AxisID && $Data["Series"][$SerieID]["isDrawable"] && $Data["Abscissa"] != $SerieID)
    1814. 

  1814.             {
    1815. 

  1815.              $AxisMax = max($AxisMax,$Data["Series"][$SerieID]["Max"]);
    1816. 

  1816.              $AxisMin = min($AxisMin,$Data["Series"][$SerieID]["Min"]);
    1817. 

  1817.             }
    1818. 

  1818.           }
    1819. 

  1819.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;
    1820. 

  1820. 

  1821.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;
    1822. 

  1822.          if ( $Mode == SCALE_MODE_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; }
    1823. 

  1823.         }
    1824. 

  1824.        elseif ( $Mode == SCALE_MODE_MANUAL )
    1825. 

  1825.         {
    1826. 

  1826.          if ( isset($ManualScale[$AxisID]["Min"]) && isset($ManualScale[$AxisID]["Max"]) )
    1827. 

  1827.           {
    1828. 

  1828.            $Data["Axis"][$AxisID]["Min"] = $ManualScale[$AxisID]["Min"];
    1829. 

  1829.            $Data["Axis"][$AxisID]["Max"] = $ManualScale[$AxisID]["Max"];
    1830. 

  1830.           }
    1831. 

  1831.          else
    1832. 

  1832.           { echo "Manual scale boundaries not set."; exit(); }
    1833. 

  1833.         }
    1834. 

  1834.        elseif ( $Mode == SCALE_MODE_ADDALL || $Mode == SCALE_MODE_ADDALL_START0 )
    1835. 

  1835.         {
    1836. 

  1836.          $Series = "";
    1837. 

  1837.          foreach($Data["Series"] as $SerieID => $SerieParameter)
    1838. 

  1838.           { if ( $SerieParameter["Axis"] == $AxisID && $SerieParameter["isDrawable"] && $Data["Abscissa"] != $SerieID ) { $Series[$SerieID] = count($Data["Series"][$SerieID]["Data"]); } }
    1839. 

  1839. 

  1840.          for ($ID=0;$ID<=max($Series)-1;$ID++)
    1841. 

  1841.           {
    1842. 

  1842.            $PointMin = 0; $PointMax = 0;
    1843. 

  1843.            foreach($Series as $SerieID => $ValuesCount )
    1844. 

  1844.             {
    1845. 

  1845.              if (isset($Data["Series"][$SerieID]["Data"][$ID]) && $Data["Series"][$SerieID]["Data"][$ID] != NULL )
    1846. 

  1846.               {
    1847. 

  1847.                $Value = $Data["Series"][$SerieID]["Data"][$ID];
    1848. 

  1848.                if ( $Value > 0 ) { $PointMax = $PointMax + $Value; } else { $PointMin = $PointMin + $Value; }
    1849. 

  1849.               }
    1850. 

  1850.             }
    1851. 

  1851.            $AxisMax = max($AxisMax,$PointMax);
    1852. 

  1852.            $AxisMin = min($AxisMin,$PointMin);
    1853. 

  1853.           }
    1854. 

  1854.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;
    1855. 

  1855.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;
    1856. 

  1856.         }
    1857. 

  1857.        $MaxDivs = floor($Height/$MinDivHeight);
    1858. 

  1858. 

  1859.        if ( $Mode == SCALE_MODE_ADDALL_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; $Data["Axis"][$AxisID]["Max"] =$ManualScale[$AxisID]["Max"];}
    1860. 

  1860. 

  1861.        $Scale   = $this->computeScale($Data["Axis"][$AxisID]["Min"],$Data["Axis"][$AxisID]["Max"],$MaxDivs,$Factors,$AxisID);
    1862. 

  1862. 

  1863.        $Data["Axis"][$AxisID]["Margin"]    = $AxisParameter["Identity"] == AXIS_X ? $XMargin : $YMargin;
    1864. 

  1864.        $Data["Axis"][$AxisID]["ScaleMin"]  = $Scale["XMin"];
    1865. 

  1865.        $Data["Axis"][$AxisID]["ScaleMax"]  = $Scale["XMax"];
    1866. 

  1866.        $Data["Axis"][$AxisID]["Rows"]      = $Scale["Rows"];
    1867. 

  1867.        $Data["Axis"][$AxisID]["RowHeight"] = $Scale["RowHeight"];
    1868. 

  1868. 

  1869.        if ( isset($Scale["Format"]) ) { $Data["Axis"][$AxisID]["Format"] = $Scale["Format"]; }
    1870. 

  1870. 

  1871.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }
    1872. 

  1872.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }
    1873. 

  1873.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }
    1874. 

  1874.       }
    1875. 

  1875. 

  1876.      /* Still no X axis */
    1877. 

  1877.      if ( $GotXAxis == FALSE )
    1878. 

  1878.       {
    1879. 

  1879.        if ( $Abscissa != NULL )
    1880. 

  1880.         {
    1881. 

  1881.          $Points = count($Data["Series"][$Abscissa]["Data"]);
    1882. 

  1882.          if ( $AutoAxisLabels )
    1883. 

  1883.           $AxisName = isset($Data["Series"][$Abscissa]["Description"]) ? $Data["Series"][$Abscissa]["Description"] : NULL;
    1884. 

  1884.          else
    1885. 

  1885.           $AxisName = NULL;
    1886. 

  1886.         }
    1887. 

  1887.        else
    1888. 

  1888.         {
    1889. 

  1889.          $Points = 0;
    1890. 

  1890.          $AxisName = isset($Data["XAxisName"]) ? $Data["XAxisName"] : NULL;
    1891. 

  1891.          foreach($Data["Series"] as $SerieID => $SerieParameter)
    1892. 

  1892.           { if ( $SerieParameter["isDrawable"] ) { $Points = max($Points,count($SerieParameter["Data"])); } }
    1893. 

  1893.         }
    1894. 

  1894. 

  1895.        $AxisID = count($Data["Axis"]);
    1896. 

  1896.        $Data["Axis"][$AxisID]["Identity"] = AXIS_X;
    1897. 

  1897.        if ( $Pos == SCALE_POS_LEFTRIGHT ) { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_BOTTOM; } else { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_LEFT; }
    1898. 

  1898.        if ( isset($Data["AbscissaName"]) ) { $Data["Axis"][$AxisID]["Name"] = $Data["AbscissaName"]; }
    1899. 

  1899.        if ( $XMargin == AUTO )
    1900. 

  1900.         {
    1901. 

  1901.          if ( $Pos == SCALE_POS_LEFTRIGHT )
    1902. 

  1902.           { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }
    1903. 

  1903.          else
    1904. 

  1904.           { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }
    1905. 

  1905. 

  1906.          if ( $Points == 1 )
    1907. 

  1907.           $Data["Axis"][$AxisID]["Margin"] = $Height / 2;
    1908. 

  1908.          else
    1909. 

  1909.           $Data["Axis"][$AxisID]["Margin"] = ($Height/$Points) / 2;
    1910. 

  1910.         }
    1911. 

  1911.        else
    1912. 

  1912.         { $Data["Axis"][$AxisID]["Margin"] = $XMargin; }
    1913. 

  1913.        $Data["Axis"][$AxisID]["Rows"] = $Points-1;
    1914. 

  1914.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }
    1915. 

  1915.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }
    1916. 

  1916.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }
    1917. 

  1917.       }
    1918. 

  1918. 

  1919.      $this->DataSet->saveOrientation($Pos);
    1920. 

  1920.      $this->DataSet->saveAxisConfig($Data["Axis"]);
    1921. 

  1921.      $this->DataSet->saveYMargin($YMargin);
    1922. 

  1922. 

  1923.      $FontColorRo = $this->FontColorR; $FontColorGo = $this->FontColorG; $FontColorBo = $this->FontColorB;
    1924. 

  1924. 

  1925.      $AxisPos["L"] = $this->GraphAreaX1; $AxisPos["R"] = $this->GraphAreaX2; $AxisPos["T"] = $this->GraphAreaY1; $AxisPos["B"] = $this->GraphAreaY2;
    1926. 

  1926.      foreach($Data["Axis"] as $AxisID => $Parameters)
    1927. 

  1927.       {
    1928. 

  1928.        if ( isset($Parameters["Color"]) )
    1929. 

  1929.         {
    1930. 

  1930.          $AxisR = $Parameters["Color"]["R"]; $AxisG = $Parameters["Color"]["G"]; $AxisB = $Parameters["Color"]["B"];
    1931. 

  1931.          $TickR = $Parameters["Color"]["R"]; $TickG = $Parameters["Color"]["G"]; $TickB = $Parameters["Color"]["B"];
    1932. 

  1932.          $this->setFontProperties(array("R"=>$Parameters["Color"]["R"],"G"=>$Parameters["Color"]["G"],"B"=>$Parameters["Color"]["B"]));
    1933. 

  1933.         }
    1934. 

  1934.        else
    1935. 

  1935.         {
    1936. 

  1936.          $AxisR = $AxisRo; $AxisG = $AxisGo; $AxisB = $AxisBo;
    1937. 

  1937.          $TickR = $TickRo; $TickG = $TickGo; $TickB = $TickBo;
    1938. 

  1938.          $this->setFontProperties(array("R"=>$FontColorRo,"G"=>$FontColorGo,"B"=>$FontColorBo));
    1939. 

  1939.         }
    1940. 

  1940. 

  1941.        $LastValue = "w00t"; $ID = 1;
    1942. 

  1942.        if ( $Parameters["Identity"] == AXIS_X )
    1943. 

  1943.         {
    1944. 

  1944.          if ( $Pos == SCALE_POS_LEFTRIGHT )
    1945. 

  1945.           {
    1946. 

  1946.            if ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )
    1947. 

  1947.             {
    1948. 

  1948.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 2; }
    1949. 

  1949.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }
    1950. 

  1950.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 5; }
    1951. 

  1951.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }
    1952. 

  1952. 

  1953.              if ( $Floating )
    1954. 

  1954.               { $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)); }
    1955. 

  1955.              else
    1956. 

  1956.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    1957. 

  1957. 

  1958.              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)); }
    1959. 

  1959. 

  1960.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;
    1961. 

  1961. 

  1962.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / ($Parameters["Rows"]); }
    1963. 

  1963.              
    1964. 

  1964.              $MaxBottom = $AxisPos["B"];
    1965. 

  1965.              for($i=0;$i<=$Parameters["Rows"];$i++)
    1966. 

  1966.               {
    1967. 

  1967.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;
    1968. 

  1968.                $YPos  = $AxisPos["B"];
    1969. 

  1969. 

  1970.                if ( $Abscissa != NULL )
    1971. 

  1971.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }
    1972. 

  1972.                else
    1973. 

  1973.                 {
    1974. 

  1974.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )
    1975. 

  1975.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);
    1976. 

  1976.                  else
    1977. 

  1977.                   $Value = $i;
    1978. 

  1978.                 }
    1979. 

  1979. 

  1980.                $ID++; $Skipped = TRUE;
    1981. 

  1981.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) )
    1982. 

  1982.                 {
    1983. 

  1983.                  $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));
    1984. 

  1984.                  $TxtBottom = $YPos+$OuterTickWidth+2+($Bounds[0]["Y"]-$Bounds[2]["Y"]);
    1985. 

  1985.                  $MaxBottom = max($MaxBottom,$TxtBottom);
    1986. 

  1986.                  $LastValue = $Value;
    1987. 

  1987.                  $Skipped   = FALSE;
    1988. 

  1988.                 }
    1989. 

  1989. 

  1990.                if ( $Skipped )
    1991. 

  1991.                 {
    1992. 

  1992.                  if ( $DrawXLines ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }
    1993. 

  1993.                  if ( $SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0 ) { $this->drawLine($XPos,$YPos-$SkippedInnerTickWidth,$XPos,$YPos+$SkippedOuterTickWidth,$SkippedTickColor); }
    1994. 

  1994.                 }
    1995. 

  1995.                else
    1996. 

  1996.                 {
    1997. 

  1997.                  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)); }
    1998. 

  1998.                  if ( $InnerTickWidth !=0 || $OuterTickWidth != 0 ) { $this->drawLine($XPos,$YPos-$InnerTickWidth,$XPos,$YPos+$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }
    1999. 

  1999.                 }
    2000. 

  2000. 

  2001.               }
    2002. 

  2002.              if ( isset($Parameters["Name"]) )
    2003. 

  2003.               {
    2004. 

  2004.                $YPos   = $MaxBottom+2;
    2005. 

  2005.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;
    2006. 

  2006.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));
    2007. 

  2007.                $MaxBottom = $Bounds[0]["Y"];
    2008. 

  2008. 

  2009.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;
    2010. 

  2010.               }
    2011. 

  2011. 

  2012.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;
    2013. 

  2013.             }
    2014. 

  2014.            elseif ( $Parameters["Position"] == AXIS_POSITION_TOP )
    2015. 

  2015.             {
    2016. 

  2016.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 2; }
    2017. 

  2017.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }
    2018. 

  2018.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 5; }
    2019. 

  2019.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }
    2020. 

  2020. 

  2021.              if ( $Floating )
    2022. 

  2022.               { $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)); }
    2023. 

  2023.              else
    2024. 

  2024.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2025. 

  2025. 

  2026.              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)); }
    2027. 

  2027. 

  2028.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;
    2029. 

  2029. 

  2030.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / $Parameters["Rows"]; }
    2031. 

  2031.              
    2032. 

  2032.              $MinTop = $AxisPos["T"];
    2033. 

  2033.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2034. 

  2034.               {
    2035. 

  2035.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;
    2036. 

  2036.                $YPos  = $AxisPos["T"];
    2037. 

  2037. 

  2038.                if ( $Abscissa != NULL )
    2039. 

  2039.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }
    2040. 

  2040.                else
    2041. 

  2041.                 {
    2042. 

  2042.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )
    2043. 

  2043.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);
    2044. 

  2044.                  else
    2045. 

  2045.                   $Value = $i;
    2046. 

  2046.                 }
    2047. 

  2047. 

  2048.                $ID++; $Skipped = TRUE;
    2049. 

  2049.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) )
    2050. 

  2050.                 {
    2051. 

  2051.                  $Bounds = $this->drawText($XPos,$YPos-$OuterTickWidth-$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));
    2052. 

  2052.                  $TxtBox = $YPos-$OuterTickWidth-2-($Bounds[0]["Y"]-$Bounds[2]["Y"]);
    2053. 

  2053.                  $MinTop = min($MinTop,$TxtBox);
    2054. 

  2054.                  $LastValue = $Value;
    2055. 

  2055.                  $Skipped   = FALSE;
    2056. 

  2056.                 }
    2057. 

  2057. 

  2058.                if ( $Skipped )
    2059. 

  2059.                 {
    2060. 

  2060.                  if ( $DrawXLines ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }
    2061. 

  2061.                  if ( $SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0 ) { $this->drawLine($XPos,$YPos+$SkippedInnerTickWidth,$XPos,$YPos-$SkippedOuterTickWidth,$SkippedTickColor); }
    2062. 

  2062.                 }
    2063. 

  2063.                else
    2064. 

  2064.                 {
    2065. 

  2065.                  if ( $DrawXLines ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }
    2066. 

  2066.                  if ( $InnerTickWidth !=0 || $OuterTickWidth != 0 ) { $this->drawLine($XPos,$YPos+$InnerTickWidth,$XPos,$YPos-$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }
    2067. 

  2067.                 }
    2068. 

  2068. 

  2069.               }
    2070. 

  2070.              if ( isset($Parameters["Name"]) )
    2071. 

  2071.               {
    2072. 

  2072.                $YPos   = $MinTop-2;
    2073. 

  2073.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;
    2074. 

  2074.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    2075. 

  2075.                $MinTop = $Bounds[2]["Y"];
    2076. 

  2076. 

  2077.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;
    2078. 

  2078.               }
    2079. 

  2079. 

  2080.              $AxisPos["T"] = $MinTop - $ScaleSpacing;
    2081. 

  2081.             }
    2082. 

  2082.           }
    2083. 

  2083.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )
    2084. 

  2084.           {
    2085. 

  2085.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )
    2086. 

  2086.             {
    2087. 

  2087.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -2; }
    2088. 

  2088.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -6; }
    2089. 

  2089.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -2; }
    2090. 

  2090.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -5; }
    2091. 

  2091. 

  2092.              if ( $Floating )
    2093. 

  2093.               { $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)); }
    2094. 

  2094.              else
    2095. 

  2095.               { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2096. 

  2096. 

  2097.              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)); }
    2098. 

  2098. 

  2099.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;
    2100. 

  2100. 

  2101.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }
    2102. 

  2102. 

  2103.              $MinLeft = $AxisPos["L"];
    2104. 

  2104.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2105. 

  2105.               {
    2106. 

  2106.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;
    2107. 

  2107.                $XPos  = $AxisPos["L"];
    2108. 

  2108. 

  2109.                if ( $Abscissa != NULL )
    2110. 

  2110.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }
    2111. 

  2111.                else
    2112. 

  2112.                 {
    2113. 

  2113.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )
    2114. 

  2114.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);
    2115. 

  2115.                  else
    2116. 

  2116.                   $Value = $i;
    2117. 

  2117.                 }
    2118. 

  2118. 

  2119.                $ID++; $Skipped = TRUE;
    2120. 

  2120.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) )
    2121. 

  2121.                 {
    2122. 

  2122.                  $Bounds  = $this->drawText($XPos-$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));
    2123. 

  2123.                  $TxtBox  = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);
    2124. 

  2124.                  $MinLeft = min($MinLeft,$TxtBox);
    2125. 

  2125.                  $LastValue = $Value;
    2126. 

  2126.                  $Skipped   = FALSE;
    2127. 

  2127.                 }
    2128. 

  2128. 

  2129.                if ( $Skipped )
    2130. 

  2130.                 {
    2131. 

  2131.                  if ( $DrawXLines ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }
    2132. 

  2132.                  if ( $SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0 ) { $this->drawLine($XPos-$SkippedOuterTickWidth,$YPos,$XPos+$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }
    2133. 

  2133.                 }
    2134. 

  2134.                else
    2135. 

  2135.                 {
    2136. 

  2136.                  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)); }
    2137. 

  2137.                  if ( $InnerTickWidth !=0 || $OuterTickWidth != 0 ) { $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }
    2138. 

  2138.                 }
    2139. 

  2139. 

  2140.               }
    2141. 

  2141.              if ( isset($Parameters["Name"]) )
    2142. 

  2142.               {
    2143. 

  2143.                $XPos   = $MinLeft-2;
    2144. 

  2144.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;
    2145. 

  2145.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));
    2146. 

  2146.                $MinLeft = $Bounds[0]["X"];
    2147. 

  2147. 

  2148.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;
    2149. 

  2149.               }
    2150. 

  2150. 

  2151.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;
    2152. 

  2152.             }
    2153. 

  2153.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )
    2154. 

  2154.             {
    2155. 

  2155.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 2; }
    2156. 

  2156.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 6; }
    2157. 

  2157.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 5; }
    2158. 

  2158.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 7; }
    2159. 

  2159. 

  2160.              if ( $Floating )
    2161. 

  2161.               { $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)); }
    2162. 

  2162.              else
    2163. 

  2163.               { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2164. 

  2164. 

  2165.              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)); }
    2166. 

  2166. 

  2167.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;
    2168. 

  2168. 

  2169.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }
    2170. 

  2170.              
    2171. 

  2171.              $MaxRight = $AxisPos["R"];
    2172. 

  2172.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2173. 

  2173.               {
    2174. 

  2174.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;
    2175. 

  2175.                $XPos  = $AxisPos["R"];
    2176. 

  2176. 

  2177.                if ( $Abscissa != NULL )
    2178. 

  2178.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }
    2179. 

  2179.                else
    2180. 

  2180.                 {
    2181. 

  2181.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )
    2182. 

  2182.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);
    2183. 

  2183.                  else
    2184. 

  2184.                   $Value = $i;
    2185. 

  2185.                 }
    2186. 

  2186. 

  2187.                $ID++; $Skipped = TRUE;
    2188. 

  2188.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) )
    2189. 

  2189.                 {
    2190. 

  2190.                  $Bounds   = $this->drawText($XPos+$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));
    2191. 

  2191.                  $TxtBox   = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);
    2192. 

  2192.                  $MaxRight = max($MaxRight,$TxtBox);
    2193. 

  2193.                  $LastValue = $Value;
    2194. 

  2194.                  $Skipped   = FALSE;
    2195. 

  2195.                 }
    2196. 

  2196. 

  2197.                if ( $Skipped )
    2198. 

  2198.                 {
    2199. 

  2199.                  if ( $DrawXLines ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }
    2200. 

  2200.                  if ( $SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0 ) { $this->drawLine($XPos+$SkippedOuterTickWidth,$YPos,$XPos-$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }
    2201. 

  2201.                 }
    2202. 

  2202.                else
    2203. 

  2203.                 {
    2204. 

  2204.                  if ( $DrawXLines ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }
    2205. 

  2205.                  if ( $InnerTickWidth !=0 || $OuterTickWidth != 0 ) { $this->drawLine($XPos+$OuterTickWidth,$YPos,$XPos-$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }
    2206. 

  2206.                 }
    2207. 

  2207. 

  2208.               }
    2209. 

  2209.              if ( isset($Parameters["Name"]) )
    2210. 

  2210.               {
    2211. 

  2211.                $XPos   = $MaxRight+4;
    2212. 

  2212.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;
    2213. 

  2213.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));
    2214. 

  2214.                $MaxRight = $Bounds[1]["X"];
    2215. 

  2215. 

  2216.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxRight + $this->FontSize;
    2217. 

  2217.               }
    2218. 

  2218. 

  2219.              $AxisPos["R"] = $MaxRight + $ScaleSpacing;
    2220. 

  2220.             }
    2221. 

  2221.           }
    2222. 

  2222.         }
    2223. 

  2223. 

  2224. 

  2225. 

  2226.        if ( $Parameters["Identity"] == AXIS_Y )
    2227. 

  2227.         {
    2228. 

  2228.          if ( $Pos == SCALE_POS_LEFTRIGHT )
    2229. 

  2229.           {
    2230. 

  2230.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )
    2231. 

  2231.             {
    2232. 

  2232. 

  2233.              if ( $Floating )
    2234. 

  2234.               { $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)); }
    2235. 

  2235.              else
    2236. 

  2236.               { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2237. 

  2237. 

  2238.              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)); }
    2239. 

  2239. 

  2240.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;
    2241. 

  2241.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinLeft = $AxisPos["L"];
    2242. 

  2242.              $LastY  = NULL;
    2243. 

  2243.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2244. 

  2244.               {
    2245. 

  2245.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;
    2246. 

  2246.                $XPos  = $AxisPos["L"];
    2247. 

  2247.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);
    2248. 

  2248. 

  2249.                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); }
    2250. 

  2250.                if ( $LastY != NULL && $CycleBackground && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }
    2251. 

  2251. 

  2252.                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)); }
    2253. 

  2253. 

  2254.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )
    2255. 

  2255.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));
    2256. 

  2256. 

  2257.                $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));
    2258. 

  2258.                $Bounds  = $this->drawText($XPos-$OuterTickWidth-2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));
    2259. 

  2259.                $TxtLeft = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);
    2260. 

  2260.                $MinLeft = min($MinLeft,$TxtLeft);
    2261. 

  2261. 

  2262.                $LastY = $YPos;
    2263. 

  2263.               }
    2264. 

  2264. 

  2265.              if ( isset($Parameters["Name"]) )
    2266. 

  2266.               {
    2267. 

  2267.                $XPos    = $MinLeft-2;
    2268. 

  2268.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;
    2269. 

  2269.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));
    2270. 

  2270.                $MinLeft = $Bounds[2]["X"];
    2271. 

  2271. 

  2272.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;
    2273. 

  2273.               }
    2274. 

  2274. 

  2275.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;
    2276. 

  2276.             }
    2277. 

  2277.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )
    2278. 

  2278.             {
    2279. 

  2279.              if ( $Floating )
    2280. 

  2280.               { $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)); }
    2281. 

  2281.              else
    2282. 

  2282.               { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2283. 

  2283. 

  2284.              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)); }
    2285. 

  2285. 

  2286.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;
    2287. 

  2287.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxLeft = $AxisPos["R"];
    2288. 

  2288.              $LastY  = NULL;
    2289. 

  2289.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2290. 

  2290.               {
    2291. 

  2291.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;
    2292. 

  2292.                $XPos  = $AxisPos["R"];
    2293. 

  2293.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);
    2294. 

  2294. 

  2295.                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); }
    2296. 

  2296.                if ( $LastY != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }
    2297. 

  2297. 

  2298.                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)); }
    2299. 

  2299. 

  2300.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )
    2301. 

  2301.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));
    2302. 

  2302. 

  2303.                $this->drawLine($XPos-$InnerTickWidth,$YPos,$XPos+$OuterTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));
    2304. 

  2304.                $Bounds  = $this->drawText($XPos+$OuterTickWidth+2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLELEFT));
    2305. 

  2305.                $TxtLeft = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);
    2306. 

  2306.                $MaxLeft = max($MaxLeft,$TxtLeft);
    2307. 

  2307. 

  2308.                $LastY = $YPos;
    2309. 

  2309.               }
    2310. 

  2310. 

  2311.              if ( isset($Parameters["Name"]) )
    2312. 

  2312.               {
    2313. 

  2313.                $XPos    = $MaxLeft+6;
    2314. 

  2314.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;
    2315. 

  2315.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));
    2316. 

  2316.                $MaxLeft = $Bounds[2]["X"];
    2317. 

  2317. 

  2318.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxLeft + $this->FontSize;
    2319. 

  2319.               }
    2320. 

  2320.              $AxisPos["R"] = $MaxLeft + $ScaleSpacing;
    2321. 

  2321.             }
    2322. 

  2322.           }
    2323. 

  2323.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )
    2324. 

  2324.           {
    2325. 

  2325.            if ( $Parameters["Position"] == AXIS_POSITION_TOP )
    2326. 

  2326.             {
    2327. 

  2327.              if ( $Floating )
    2328. 

  2328.               { $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)); }
    2329. 

  2329.              else
    2330. 

  2330.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2331. 

  2331. 

  2332.              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)); }
    2333. 

  2333. 

  2334.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;
    2335. 

  2335.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinTop = $AxisPos["T"];
    2336. 

  2336.              $LastX  = NULL;
    2337. 

  2337.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2338. 

  2338.               {
    2339. 

  2339.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;
    2340. 

  2340.                $YPos  = $AxisPos["T"];
    2341. 

  2341.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);
    2342. 

  2342. 

  2343.                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); }
    2344. 

  2344.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }
    2345. 

  2345. 

  2346.                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)); }
    2347. 

  2347. 

  2348.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )
    2349. 

  2349.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));
    2350. 

  2350. 

  2351.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));
    2352. 

  2352.                $Bounds    = $this->drawText($XPos,$YPos-$OuterTickWidth-2,$Value,array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    2353. 

  2353.                $TxtHeight = $YPos-$OuterTickWidth-2-($Bounds[1]["Y"]-$Bounds[2]["Y"]);
    2354. 

  2354.                $MinTop    = min($MinTop,$TxtHeight);
    2355. 

  2355. 

  2356.                $LastX = $XPos;
    2357. 

  2357.               }
    2358. 

  2358. 

  2359.              if ( isset($Parameters["Name"]) )
    2360. 

  2360.               {
    2361. 

  2361.                $YPos   = $MinTop-2;
    2362. 

  2362.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;
    2363. 

  2363.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    2364. 

  2364.                $MinTop = $Bounds[2]["Y"];
    2365. 

  2365. 

  2366.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;
    2367. 

  2367.               }
    2368. 

  2368. 

  2369.              $AxisPos["T"] = $MinTop - $ScaleSpacing;
    2370. 

  2370.             }
    2371. 

  2371.            elseif ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )
    2372. 

  2372.             {
    2373. 

  2373.              if ( $Floating )
    2374. 

  2374.               { $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)); }
    2375. 

  2375.              else
    2376. 

  2376.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }
    2377. 

  2377. 

  2378.              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)); }
    2379. 

  2379. 

  2380.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;
    2381. 

  2381.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxBottom = $AxisPos["B"];
    2382. 

  2382.              $LastX  = NULL;
    2383. 

  2383.              for($i=0;$i<=$Parameters["Rows"];$i++)
    2384. 

  2384.               {
    2385. 

  2385.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;
    2386. 

  2386.                $YPos  = $AxisPos["B"];
    2387. 

  2387.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);
    2388. 

  2388. 

  2389.                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); }
    2390. 

  2390.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }
    2391. 

  2391. 

  2392.                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)); }
    2393. 

  2393. 

  2394.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )
    2395. 

  2395.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));
    2396. 

  2396. 

  2397.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));
    2398. 

  2398.                $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+2,$Value,array("Align"=>TEXT_ALIGN_TOPMIDDLE));
    2399. 

  2399.                $TxtHeight = $YPos+$OuterTickWidth+2+($Bounds[1]["Y"]-$Bounds[2]["Y"]);
    2400. 

  2400.                $MaxBottom = max($MaxBottom,$TxtHeight);
    2401. 

  2401. 

  2402.                $LastX = $XPos;
    2403. 

  2403.               }
    2404. 

  2404. 

  2405.              if ( isset($Parameters["Name"]) )
    2406. 

  2406.               {
    2407. 

  2407.                $YPos   = $MaxBottom+2;
    2408. 

  2408.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;
    2409. 

  2409.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));
    2410. 

  2410.                $MaxBottom = $Bounds[0]["Y"];
    2411. 

  2411. 

  2412.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;
    2413. 

  2413.               }
    2414. 

  2414. 

  2415.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;
    2416. 

  2416.             }
    2417. 

  2417.           }
    2418. 

  2418.         }
    2419. 

  2419.       }
    2420. 

  2420.     }
    2421. 

  2421. 

  2422.    function isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip)
    2423. 

  2423.     {
    2424. 

  2424.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value != $LastValue ) { return(TRUE); }
    2425. 

  2425.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value == $LastValue ) { return(FALSE); }
    2426. 

  2426.      if ( $LabelingMethod == LABELING_ALL && $LabelSkip == 0 ) { return(TRUE); }
    2427. 

  2427.      if ( $LabelingMethod == LABELING_ALL && ($ID+$LabelSkip) % ($LabelSkip+1) != 1 ) { return(FALSE); }
    2428. 

  2428. 

  2429.      return(TRUE);
    2430. 

  2430.     }
    2431. 

  2431. 

  2432.    /* Compute the scale, check for the best visual factors */
    2433. 

  2433.    function computeScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID=0)
    2434. 

  2434.     {
    2435. 

  2435.      /* Compute each factors */
    2436. 

  2436.      $Results = "";
    2437. 

  2437.      foreach ($Factors as $Key => $Factor)
    2438. 

  2438.       $Results[$Factor] = $this->processScale($XMin,$XMax,$MaxDivs,array($Factor),$AxisID);
    2439. 

  2439. 

  2440.      /* Remove scales that are creating to much decimals */
    2441. 

  2441.      $GoodScaleFactors = "";
    2442. 

  2442.      foreach ($Results as $Key => $Result)
    2443. 

  2443.       {
    2444. 

  2444.        $Decimals = preg_split("/\./",$Result["RowHeight"]);
    2445. 

  2445.        if ( (!isset($Decimals[1])) || (strlen($Decimals[1]) < 6) ) { $GoodScaleFactors[] = $Key; }
    2446. 

  2446.       }
    2447. 

  2447. 

  2448.      /* Found no correct scale, shame,... returns the 1st one as default */
    2449. 

  2449.      if ( $GoodScaleFactors == "" ) { return($Results[$Factors[0]]); }
    2450. 

  2450. 

  2451.      /* Find the factor that cause the maximum number of Rows */
    2452. 

  2452.      $MaxRows = 0; $BestFactor = 0;
    2453. 

  2453.      foreach($GoodScaleFactors as $Key => $Factor)
    2454. 

  2454.       { if ( $Results[$Factor]["Rows"] > $MaxRows ) { $MaxRows = $Results[$Factor]["Rows"]; $BestFactor = $Factor; } }
    2455. 

  2455. 

  2456.      /* Return the best visual scale */
    2457. 

  2457.      return($Results[$BestFactor]);
    2458. 

  2458.     }
    2459. 

  2459. 

  2460.    /* Compute the best matching scale based on size & factors */
    2461. 

  2461.    function processScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID)
    2462. 

  2462.     {
    2463. 

  2463.      $ScaleHeight = abs(ceil($XMax)-floor($XMin));
    2464. 

  2464. 

  2465.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Format"]) )
    2466. 

  2466.       $Format = $this->DataSet->Data["Axis"][$AxisID]["Format"];
    2467. 

  2467.      else
    2468. 

  2468.       $Format = NULL;
    2469. 

  2469. 

  2470.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Display"]) )
    2471. 

  2471.       $Mode = $this->DataSet->Data["Axis"][$AxisID]["Display"];
    2472. 

  2472.      else
    2473. 

  2473.       $Mode = AXIS_FORMAT_DEFAULT;
    2474. 

  2474. 

  2475.      $Scale = "";
    2476. 

  2476.      if ( $XMin != $XMax )
    2477. 

  2477.       {
    2478. 

  2478.        $Found = FALSE; $Rescaled = FALSE; $Scaled10Factor = .0001; $Result = 0;
    2479. 

  2479.        while(!$Found)
    2480. 

  2480.         {
    2481. 

  2481.          foreach($Factors as $Key => $Factor)
    2482. 

  2482.           {
    2483. 

  2483.            if ( !$Found )
    2484. 

  2484.             {
    2485. 

  2485.              if ( !($this->modulo($XMin,$Factor*$Scaled10Factor) == 0) || ($XMin != floor($XMin))) { $XMinRescaled = floor($XMin/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor; } else { $XMinRescaled = $XMin; }
    2486. 

  2486.              if ( !($this->modulo($XMax,$Factor*$Scaled10Factor) == 0) || ($XMax != floor($XMax))) { $XMaxRescaled = floor($XMax/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor+($Factor*$Scaled10Factor); } else { $XMaxRescaled = $XMax; }
    2487. 

  2487.              $ScaleHeightRescaled = abs($XMaxRescaled-$XMinRescaled);
    2488. 

  2488. 

  2489.              if ( !$Found && floor($ScaleHeightRescaled/($Factor*$Scaled10Factor)) <= $MaxDivs ) { $Found = TRUE; $Rescaled = TRUE; $Result = $Factor * $Scaled10Factor; }
    2490. 

  2490.             }
    2491. 

  2491.           }
    2492. 

  2492.          $Scaled10Factor = $Scaled10Factor * 10;
    2493. 

  2493.         }
    2494. 

  2494. 

  2495.        /* ReCall Min / Max / Height */
    2496. 

  2496.        if ( $Rescaled ) { $XMin = $XMinRescaled; $XMax = $XMaxRescaled; $ScaleHeight = $ScaleHeightRescaled; }
    2497. 

  2497. 

  2498.        /* Compute rows size */
    2499. 

  2499.        $Rows      = floor($ScaleHeight / $Result); if ( $Rows == 0 ) { $Rows = 1; }
    2500. 

  2500.        $RowHeight = $ScaleHeight / $Rows;
    2501. 

  2501. 

  2502.        /* Return the results */
    2503. 

  2503.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;
    2504. 

  2504. 

  2505.        /* Compute the needed decimals for the metric view to avoid repetition of the same X Axis labels */
    2506. 

  2506.        if ( $Mode == AXIS_FORMAT_METRIC && $Format == NULL )
    2507. 

  2507.         {
    2508. 

  2508.          $Done = FALSE; $GoodDecimals = 0;
    2509. 

  2509.          for($Decimals=0;$Decimals<=10;$Decimals++)
    2510. 

  2510.           {
    2511. 

  2511.            if ( !$Done )
    2512. 

  2512.             {
    2513. 

  2513.              $LastLabel = "zob"; $ScaleOK = TRUE;
    2514. 

  2514.              for($i=0;$i<=$Rows;$i++)
    2515. 

  2515.               {
    2516. 

  2516.                $Value = $XMin + $i*$RowHeight;
    2517. 

  2517.                $Label = $this->scaleFormat($Value,AXIS_FORMAT_METRIC,$Decimals);
    2518. 

  2518. 

  2519.                if ( $LastLabel == $Label ) { $ScaleOK = FALSE; }
    2520. 

  2520.                $LastLabel = $Label;
    2521. 

  2521.               }
    2522. 

  2522.              if ( $ScaleOK ) { $Done = TRUE; $GoodDecimals = $Decimals; }
    2523. 

  2523.             }
    2524. 

  2524.           }
    2525. 

  2525. 

  2526.          $Scale["Format"] = $GoodDecimals;
    2527. 

  2527.         }
    2528. 

  2528.       }
    2529. 

  2529.      else
    2530. 

  2530.       {
    2531. 

  2531.        /* If all values are the same we keep a +1/-1 scale */
    2532. 

  2532.        $Rows = 2; $XMin = $XMax-1; $XMax = $XMax+1; $RowHeight = 1;
    2533. 

  2533. 

  2534.        /* Return the results */
    2535. 

  2535.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;
    2536. 

  2536.       }
    2537. 

  2537. 

  2538.      return($Scale);
    2539. 

  2539.     }
    2540. 

  2540. 

  2541.    function modulo($Value1,$Value2)
    2542. 

  2542.     {
    2543. 

  2543.      if (floor($Value2) == 0) { return(0); }
    2544. 

  2544.      if (floor($Value2) != 0) { return($Value1 % $Value2); }
    2545. 

  2545. 

  2546.      $MinValue = min($Value1,$Value2); $Factor = 10;
    2547. 

  2547.      while ( floor($MinValue*$Factor) == 0 )
    2548. 

  2548.       { $Factor = $Factor * 10; }
    2549. 

  2549. 

  2550.      return(($Value1*$Factor) % ($Value2*$Factor));
    2551. 

  2551.     }
    2552. 

  2552. 

  2553.    /* Draw a threshold with the computed scale */
    2554. 

  2554.    function drawThreshold($Value,$Format="")
    2555. 

  2555.     {
    2556. 

  2556.      $AxisID		= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
    2557. 

  2557.      $R			= isset($Format["R"]) ? $Format["R"] : 255;
    2558. 

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

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

  2560.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 50;
    2561. 

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

  2562.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : 6;
    2563. 

  2563.      $Wide		= isset($Format["Wide"]) ? $Format["Wide"] : FALSE;
    2564. 

  2564.      $WideFactor	= isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;
    2565. 

  2565.      $WriteCaption	= isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;
    2566. 

  2566.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : NULL;
    2567. 

  2567.      $CaptionAlign	= isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;
    2568. 

  2568.      $CaptionOffset     = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 10;
    2569. 

  2569.      $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;
    2570. 

  2570.      $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;
    2571. 

  2571.      $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;
    2572. 

  2572.      $CaptionAlpha	= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;
    2573. 

  2573.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;
    2574. 

  2574.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;
    2575. 

  2575.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 3;
    2576. 

  2576.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;
    2577. 

  2577.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
    2578. 

  2578.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    2579. 

  2579.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    2580. 

  2580.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    2581. 

  2581.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 30;
    2582. 

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

  2583.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
    2584. 

  2584.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
    2585. 

  2585.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
    2586. 

  2586.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;
    2587. 

  2587. 

  2588.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,
    2589. 

  2589.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,
    2590. 

  2590.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha,
    2591. 

  2591.                               "R"=>$CaptionR,"G"=>$CaptionG,"B"=>$CaptionB,"Alpha"=>$CaptionAlpha);
    2592. 

  2592. 

  2593.      if ( $Caption == NULL ) { $Caption = $Value; }
    2594. 

  2594. 

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

  2596.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }
    2597. 

  2597. 

  2598.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    2599. 

  2599.       {
    2600. 

  2600.        $YPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));
    2601. 

  2601.        if ( $YPos >= $this->GraphAreaY1 && $YPos <= $this->GraphAreaY2 )
    2602. 

  2602.         {
    2603. 

  2603.          $this->drawLine($this->GraphAreaX1,$YPos,$this->GraphAreaX2,$YPos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    2604. 

  2604. 

  2605.          if ( $Wide )
    2606. 

  2606.           {
    2607. 

  2607.            $this->drawLine($this->GraphAreaX1,$YPos-1,$this->GraphAreaX2,$YPos-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));
    2608. 

  2608.            $this->drawLine($this->GraphAreaX1,$YPos+1,$this->GraphAreaX2,$YPos+1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));
    2609. 

  2609.           }
    2610. 

  2610. 

  2611.          if ( $WriteCaption )
    2612. 

  2612.           {
    2613. 

  2613.            if ( $CaptionAlign == CAPTION_LEFT_TOP )
    2614. 

  2614.             { $X = $this->GraphAreaX1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT; }
    2615. 

  2615.            else 
    2616. 

  2616.             { $X = $this->GraphAreaX2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }
    2617. 

  2617.            
    2618. 

  2618.            $this->drawText($X,$YPos,$Caption,$CaptionSettings);
    2619. 

  2619.           }
    2620. 

  2620.         }
    2621. 

  2621. 

  2622.        return(array("Y"=>$YPos));
    2623. 

  2623.       }
    2624. 

  2624. 

  2625.      if ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )
    2626. 

  2626.       {
    2627. 

  2627.        $XPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));
    2628. 

  2628.        if ( $XPos >= $this->GraphAreaX1 && $XPos <= $this->GraphAreaX2 )
    2629. 

  2629.         {
    2630. 

  2630.          $this->drawLine($XPos,$this->GraphAreaY1,$XPos,$this->GraphAreaY2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    2631. 

  2631. 

  2632.          if ( $Wide )
    2633. 

  2633.           {
    2634. 

  2634.            $this->drawLine($XPos-1,$this->GraphAreaY1,$XPos-1,$this->GraphAreaY2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));
    2635. 

  2635.            $this->drawLine($XPos+1,$this->GraphAreaY1,$XPos+1,$this->GraphAreaY2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));
    2636. 

  2636.           }
    2637. 

  2637. 

  2638.          if ( $WriteCaption )
    2639. 

  2639.           {
    2640. 

  2640.            if ( $CaptionAlign == CAPTION_LEFT_TOP )
    2641. 

  2641.             { $Y = $this->GraphAreaY1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE; }
    2642. 

  2642.            else 
    2643. 

  2643.             { $Y = $this->GraphAreaY2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }
    2644. 

  2644. 

  2645.            $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
    2646. 

  2646.            $this->drawText($XPos,$Y,$Caption,$CaptionSettings);
    2647. 

  2647.           }
    2648. 

  2648.         }
    2649. 

  2649. 

  2650.        return(array("Y"=>$XPos));
    2651. 

  2651.       }
    2652. 

  2652.     }
    2653. 

  2653. 

  2654.    /* Draw a threshold with the computed scale */
    2655. 

  2655.    function drawThresholdArea($Value1,$Value2,$Format="")
    2656. 

  2656.     {
    2657. 

  2657.      $AxisID	= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
    2658. 

  2658.      $R		= isset($Format["R"]) ? $Format["R"] : 255;
    2659. 

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

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

  2661.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 20;
    2662. 

  2662.      $Border    = isset($Format["Border"]) ? $Format["Border"] : TRUE;
    2663. 

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

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

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

  2666.      $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;
    2667. 

  2667.      $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;
    2668. 

  2668. 

  2669.      if ($BorderAlpha >100) { $BorderAlpha = 100;}
    2670. 

  2670. 

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

  2672.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }
    2673. 

  2673. 

  2674.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    2675. 

  2675.       {
    2676. 

  2676.        $YPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));
    2677. 

  2677.        $YPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));
    2678. 

  2678. 

  2679.        if ( $YPos1 > $this->GraphAreaY2 ) { $YPos1 = $this->GraphAreaY2; } if ( $YPos1 < $this->GraphAreaY1 ) { $YPos1 = $this->GraphAreaY1; }
    2680. 

  2680.        if ( $YPos2 > $this->GraphAreaY2 ) { $YPos2 = $this->GraphAreaY2; } if ( $YPos2 < $this->GraphAreaY1 ) { $YPos2 = $this->GraphAreaY1; }
    2681. 

  2681. 

  2682.        $this->drawFilledRectangle($this->GraphAreaX1+1,$YPos1,$this->GraphAreaX2-1,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    2683. 

  2683.        if ( $Border )
    2684. 

  2684.         {
    2685. 

  2685.          $this->drawLine($this->GraphAreaX1+1,$YPos1,$this->GraphAreaX2-1,$YPos1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));
    2686. 

  2686.          $this->drawLine($this->GraphAreaX1+1,$YPos2,$this->GraphAreaX2-1,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));
    2687. 

  2687.         }
    2688. 

  2688.        return(array("Y1"=>$YPos1,"Y2"=>$YPos2));
    2689. 

  2689.       }
    2690. 

  2690. 

  2691.      if ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )
    2692. 

  2692.       {
    2693. 

  2693.        $XPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));
    2694. 

  2694.        $XPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));
    2695. 

  2695. 

  2696.        if ( $XPos1 > $this->GraphAreaX2 ) { $XPos1 = $this->GraphAreaX2; } if ( $XPos1 < $this->GraphAreaX1 ) { $XPos1 = $this->GraphAreaX1; }
    2697. 

  2697.        if ( $XPos2 > $this->GraphAreaX2 ) { $XPos2 = $this->GraphAreaX2; } if ( $XPos2 < $this->GraphAreaX1 ) { $XPos2 = $this->GraphAreaX1; }
    2698. 

  2698. 

  2699.        $this->drawFilledRectangle($XPos1,$this->GraphAreaY1+1,$XPos2,$this->GraphAreaY2-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    2700. 

  2700.        if ( $Border )
    2701. 

  2701.         {
    2702. 

  2702.          $this->drawLine($XPos1,$this->GraphAreaY1+1,$XPos1,$this->GraphAreaY2-1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));
    2703. 

  2703.          $this->drawLine($XPos2,$this->GraphAreaY1+1,$XPos2,$this->GraphAreaY2-1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));
    2704. 

  2704.         }
    2705. 

  2705.        return(array("Y1"=>$XPos1,"Y2"=>$XPos2));
    2706. 

  2706.       }
    2707. 

  2707.     }
    2708. 

  2708. 

  2709.    function scaleGetXSettings()
    2710. 

  2710.     {
    2711. 

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

  2712.      foreach($Data["Axis"] as $AxisID => $Settings)
    2713. 

  2713.       {
    2714. 

  2714.        if ( $Settings["Identity"] == AXIS_X )
    2715. 

  2715.         {
    2716. 

  2716.          $Rows = $Settings["Rows"];
    2717. 

  2717. 

  2718.          return(array($Settings["Margin"],$Rows));
    2719. 

  2719.         }
    2720. 

  2720.       }
    2721. 

  2721.     }
    2722. 

  2722. 

  2723.    function scaleComputeY($Values,$Option="",$ReturnOnly0Height=FALSE)
    2724. 

  2724.     {
    2725. 

  2725.      $AxisID	= isset($Option["AxisID"]) ? $Option["AxisID"] : 0;
    2726. 

  2726.      $SerieName	= isset($Option["SerieName"]) ? $Option["SerieName"] : NULL;
    2727. 

  2727. 

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

  2729.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }
    2730. 

  2730. 

  2731.      if ( $SerieName != NULL ) { $AxisID = $Data["Series"][$SerieName]["Axis"]; }
    2732. 

  2732.      if ( !is_array($Values) ) { $tmp = $Values; $Values = ""; $Values[0] = $tmp; }
    2733. 

  2733. 

  2734.      $Result = "";
    2735. 

  2735.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    2736. 

  2736.       {
    2737. 

  2737.        $Height      = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Data["Axis"][$AxisID]["Margin"]*2;
    2738. 

  2738.        $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
    2739. 

  2739.        $Step        = $Height / $ScaleHeight;
    2740. 

  2740. 

  2741.        if ( $ReturnOnly0Height )
    2742. 

  2742.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }
    2743. 

  2743.        else
    2744. 

  2744.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"] - ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }
    2745. 

  2745.       }
    2746. 

  2746.      else
    2747. 

  2747.       {
    2748. 

  2748.        $Width      = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Data["Axis"][$AxisID]["Margin"]*2;
    2749. 

  2749.        $ScaleWidth = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
    2750. 

  2750.        $Step       = $Width / $ScaleWidth;
    2751. 

  2751. 

  2752.        if ( $ReturnOnly0Height )
    2753. 

  2753.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }
    2754. 

  2754.        else
    2755. 

  2755.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] + ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }
    2756. 

  2756.       }
    2757. 

  2757. 

  2758.      if ( count($Result) == 1 )
    2759. 

  2759.       return($Result[0]);
    2760. 

  2760.      else
    2761. 

  2761.       return($Result);
    2762. 

  2762.     }
    2763. 

  2763. 

  2764.    /* Format the axis values */
    2765. 

  2765.    function scaleFormat($Value,$Mode=NULL,$Format=NULL,$Unit=NULL)
    2766. 

  2766.     {
    2767. 

  2767.      if ( $Value == VOID ) { return(""); }
    2768. 

  2768. 

  2769.      if ( $Mode == AXIS_FORMAT_DATE )
    2770. 

  2770.       { if ( $Format == NULL ) { $Pattern = "d/m/Y"; } else { $Pattern = $Format; } return(date($Pattern,$Value)); }
    2771. 

  2771. 

  2772.      if ( $Mode == AXIS_FORMAT_TIME )
    2773. 

  2773.       { if ( $Format == NULL ) { $Pattern = "H:i:s"; } else { $Pattern = $Format; } return(date($Pattern,$Value)); }
    2774. 

  2774. 

  2775.      if ( $Mode == AXIS_FORMAT_CURRENCY )
    2776. 

  2776.       { return($Format.number_format($Value,2)); }
    2777. 

  2777. 

  2778.      if ( $Mode == AXIS_FORMAT_METRIC )
    2779. 

  2779.       {
    2780. 

  2780.        if (abs($Value) > 1000000000)
    2781. 

  2781.         return(round($Value/1000000000,$Format)."g".$Unit);
    2782. 

  2782.        if (abs($Value) > 1000000)
    2783. 

  2783.         return(round($Value/1000000,$Format)."m".$Unit);
    2784. 

  2784.        elseif (abs($Value) >= 1000)
    2785. 

  2785.         return(round($Value/1000,$Format)."k".$Unit);
    2786. 

  2786.        
    2787. 

  2787.       }
    2788. 

  2788.      return($Value.$Unit);
    2789. 

  2789.     }
    2790. 

  2790. 

  2791.    /* Write Max value on a chart */
    2792. 

  2792.    function writeBounds($Type=BOUND_BOTH,$Format=NULL)
    2793. 

  2793.     {
    2794. 

  2794.      $MaxLabelTxt	= isset($Format["MaxLabelTxt"]) ? $Format["MaxLabelTxt"] : "max=";
    2795. 

  2795.      $MinLabelTxt	= isset($Format["MinLabelTxt"]) ? $Format["MinLabelTxt"] : "min=";
    2796. 

  2796.      $Decimals		= isset($Format["Decimals"]) ? $Format["Decimals"] : 1;
    2797. 

  2797.      $ExcludedSeries	= isset($Format["ExcludedSeries"]) ? $Format["ExcludedSeries"] : "";
    2798. 

  2798.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;
    2799. 

  2799.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    2800. 

  2800.      $MaxDisplayR	= isset($Format["MaxDisplayR"]) ? $Format["MaxDisplayR"] : 0;
    2801. 

  2801.      $MaxDisplayG	= isset($Format["MaxDisplayG"]) ? $Format["MaxDisplayG"] : 0;
    2802. 

  2802.      $MaxDisplayB	= isset($Format["MaxDisplayB"]) ? $Format["MaxDisplayB"] : 0;
    2803. 

  2803.      $MinDisplayR	= isset($Format["MinDisplayR"]) ? $Format["MinDisplayR"] : 255;
    2804. 

  2804.      $MinDisplayG	= isset($Format["MinDisplayG"]) ? $Format["MinDisplayG"] : 255;
    2805. 

  2805.      $MinDisplayB	= isset($Format["MinDisplayB"]) ? $Format["MinDisplayB"] : 255;
    2806. 

  2806.      $MinLabelPos	= isset($Format["MinLabelPos"]) ? $Format["MinLabelPos"] : BOUND_LABEL_POS_AUTO;
    2807. 

  2807.      $MaxLabelPos	= isset($Format["MaxLabelPos"]) ? $Format["MaxLabelPos"] : BOUND_LABEL_POS_AUTO;
    2808. 

  2808.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;
    2809. 

  2809.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;
    2810. 

  2810.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 3;
    2811. 

  2811.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;
    2812. 

  2812.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
    2813. 

  2813.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    2814. 

  2814.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    2815. 

  2815.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    2816. 

  2816.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;
    2817. 

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

  2818.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
    2819. 

  2819.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
    2820. 

  2820.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
    2821. 

  2821.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;
    2822. 

  2822. 

  2823.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,
    2824. 

  2824.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,
    2825. 

  2825.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha);
    2826. 

  2826. 

  2827.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    2828. 

  2828. 

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

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

  2831.       {
    2832. 

  2832.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && !isset($ExcludedSeries[$SerieName]))
    2833. 

  2833.         {
    2834. 

  2834.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    2835. 

  2835.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    2836. 

  2836. 

  2837.          $MinValue = $this->DataSet->getMin($SerieName);
    2838. 

  2838.          $MaxValue = $this->DataSet->getMax($SerieName);
    2839. 

  2839. 

  2840.          $MinPos = VOID; $MaxPos = VOID;
    2841. 

  2841.          foreach($Serie["Data"] as $Key => $Value)
    2842. 

  2842.           { 
    2843. 

  2843.            if ( $Value == $MinValue && $MinPos == VOID ) { $MinPos = $Key; }
    2844. 

  2844.            if ( $Value == $MaxValue ) { $MaxPos = $Key; }
    2845. 

  2845.           }
    2846. 

  2846. 

  2847.          $AxisID	= $Serie["Axis"];
    2848. 

  2848.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    2849. 

  2849.          $Format	= $Data["Axis"][$AxisID]["Format"];
    2850. 

  2850.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    2851. 

  2851. 

  2852.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    2853. 

  2853. 

  2854.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    2855. 

  2855.           {
    2856. 

  2856.            $XStep       = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs;
    2857. 

  2857.            $X           = $this->GraphAreaX1 + $XMargin;
    2858. 

  2858.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;
    2859. 

  2859. 

  2860.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )
    2861. 

  2861.             {
    2862. 

  2862.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }
    2863. 

  2863.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }
    2864. 

  2864. 

  2865.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;
    2866. 

  2866.              $Label = $MaxLabelTxt.$this->scaleFormat(round($MaxValue,$Decimals),$Mode,$Format,$Unit);
    2867. 

  2867. 

  2868.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);
    2869. 

  2869.              $XOffset = 0; $YOffset = 0;
    2870. 

  2870.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }
    2871. 

  2871.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }
    2872. 

  2872.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }
    2873. 

  2873.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }
    2874. 

  2874. 

  2875.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;
    2876. 

  2876.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;
    2877. 

  2877. 

  2878.              $this->drawText($XPos+$XOffset,$YPos+$YOffset,$Label,$CaptionSettings);
    2879. 

  2879.             }
    2880. 

  2880. 

  2881.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )
    2882. 

  2882.             {
    2883. 

  2883.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }
    2884. 

  2884.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }
    2885. 

  2885. 

  2886.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;
    2887. 

  2887.              $Label = $MinLabelTxt.$this->scaleFormat(round($MinValue,$Decimals),$Mode,$Format,$Unit);
    2888. 

  2888. 

  2889.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);
    2890. 

  2890.              $XOffset = 0; $YOffset = 0;
    2891. 

  2891.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }
    2892. 

  2892.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }
    2893. 

  2893.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }
    2894. 

  2894.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }
    2895. 

  2895. 

  2896.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;
    2897. 

  2897.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;
    2898. 

  2898. 

  2899.              $this->drawText($XPos+$XOffset,$YPos-$DisplayOffset+$YOffset,$Label,$CaptionSettings);
    2900. 

  2900.             }
    2901. 

  2901.           }
    2902. 

  2902.          else
    2903. 

  2903.           {
    2904. 

  2904.            $XStep       = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs;
    2905. 

  2905.            $X           = $this->GraphAreaY1 + $XMargin;
    2906. 

  2906.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;
    2907. 

  2907. 

  2908.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )
    2909. 

  2909.             {
    2910. 

  2910.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }
    2911. 

  2911.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }
    2912. 

  2912. 

  2913.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;
    2914. 

  2914.              $Label = $MaxLabelTxt.$this->scaleFormat($MaxValue,$Mode,$Format,$Unit);
    2915. 

  2915. 

  2916.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);
    2917. 

  2917.              $XOffset = 0; $YOffset = 0;
    2918. 

  2918.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }
    2919. 

  2919.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }
    2920. 

  2920.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }
    2921. 

  2921.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}
    2922. 

  2922. 

  2923.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;
    2924. 

  2924.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;
    2925. 

  2925. 

  2926.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);
    2927. 

  2927.             }
    2928. 

  2928. 

  2929.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )
    2930. 

  2930.             {
    2931. 

  2931.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }
    2932. 

  2932.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }
    2933. 

  2933. 

  2934.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;
    2935. 

  2935.              $Label = $MinLabelTxt.$this->scaleFormat($MinValue,$Mode,$Format,$Unit);
    2936. 

  2936. 

  2937.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);
    2938. 

  2938.              $XOffset = 0; $YOffset = 0;
    2939. 

  2939.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }
    2940. 

  2940.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }
    2941. 

  2941.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }
    2942. 

  2942.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}
    2943. 

  2943. 

  2944.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;
    2945. 

  2945.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;
    2946. 

  2946. 

  2947.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);
    2948. 

  2948.             }
    2949. 

  2949.           }
    2950. 

  2950.         }
    2951. 

  2951.       }
    2952. 

  2952.     }
    2953. 

  2953. 

  2954.    /* Draw a plot chart */
    2955. 

  2955.    function drawPlotChart($Format=NULL)
    2956. 

  2956.     {
    2957. 

  2957.      $PlotSize		= isset($Format["PlotSize"]) ? $Format["PlotSize"] : 3;
    2958. 

  2958.      $PlotBorder	= isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : FALSE;
    2959. 

  2959.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 50;
    2960. 

  2960.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 50;
    2961. 

  2961.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 50;
    2962. 

  2962.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;
    2963. 

  2963.      $BorderSize	= isset($Format["BorderSize"]) ? $Format["BorderSize"] : 2;
    2964. 

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

  2965.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    2966. 

  2966.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;
    2967. 

  2967.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    2968. 

  2968.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    2969. 

  2969.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    2970. 

  2970.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    2971. 

  2971. 

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

  2973.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    2974. 

  2974. 

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

  2976.       {
    2977. 

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

  2978.         {
    2979. 

  2979.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    2980. 

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

  2981.          if ( isset($Serie["Picture"]) )
    2982. 

  2982.           { $Picture = $Serie["Picture"]; list($PicWidth,$PicHeight,$PicType) = $this->getPicInfo($Picture); }
    2983. 

  2983.          else { $Picture = NULL; $PicOffset = 0; }
    2984. 

  2984. 

  2985.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    2986. 

  2986. 

  2987.          $AxisID	= $Serie["Axis"];
    2988. 

  2988.          $Shape		= $Serie["Shape"];
    2989. 

  2989.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    2990. 

  2990.          $Format	= $Data["Axis"][$AxisID]["Format"];
    2991. 

  2991.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    2992. 

  2992. 

  2993.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    2994. 

  2994. 

  2995.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    2996. 

  2996. 

  2997.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    2998. 

  2998.           {
    2999. 

  2999.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3000. 

  3000.            if ( $Picture != NULL ) { $PicOffset = $PicHeight / 2; $PlotSize = 0; }
    3001. 

  3001.            $X = $this->GraphAreaX1 + $XMargin;
    3002. 

  3002. 

  3003.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3004. 

  3004.            foreach($PosArray as $Key => $Y)
    3005. 

  3005.             {
    3006. 

  3006.              if ( $DisplayValues ) 
    3007. 

  3007.               $this->drawText($X,$Y-$DisplayOffset-$PlotSize-$BorderSize-$PicOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    3008. 

  3008. 

  3009.              if ( $Y != VOID )
    3010. 

  3010.               {
    3011. 

  3011.                if ( $Picture != NULL )
    3012. 

  3012.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }
    3013. 

  3013.                else
    3014. 

  3014.                 { $this->drawShape($X,$Y,$Shape,$PlotSize,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }
    3015. 

  3015.               }
    3016. 

  3016.              $X = $X + $XStep;
    3017. 

  3017.             }
    3018. 

  3018.           }
    3019. 

  3019.          else
    3020. 

  3020.           {
    3021. 

  3021.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3022. 

  3022.            if ( $Picture != NULL ) { $PicOffset = $PicWidth / 2; $PlotSize = 0; }
    3023. 

  3023.            $Y = $this->GraphAreaY1 + $XMargin;
    3024. 

  3024. 

  3025.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3026. 

  3026.            foreach($PosArray as $Key => $X)
    3027. 

  3027.             {
    3028. 

  3028.              if ( $DisplayValues ) 
    3029. 

  3029.               $this->drawText($X+$DisplayOffset+$PlotSize+$BorderSize+$PicOffset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    3030. 

  3030. 

  3031.              if ( $X != VOID )
    3032. 

  3032.               {
    3033. 

  3033.                if ( $Picture != NULL )
    3034. 

  3034.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }
    3035. 

  3035.                else
    3036. 

  3036.                 { $this->drawShape($X,$Y,$Shape,$PlotSize,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }
    3037. 

  3037.               }
    3038. 

  3038.              $Y = $Y + $YStep;
    3039. 

  3039.             }
    3040. 

  3040.           }
    3041. 

  3041.         }
    3042. 

  3042.       }
    3043. 

  3043.     }
    3044. 

  3044. 

  3045.    /* Draw a spline chart */
    3046. 

  3046.    function drawSplineChart($Format=NULL)
    3047. 

  3047.     {
    3048. 

  3048.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;
    3049. 

  3049.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    3050. 

  3050.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL; // 234
    3051. 

  3051.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL; // 55
    3052. 

  3052.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL; // 26
    3053. 

  3053.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    3054. 

  3054.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3055. 

  3055.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3056. 

  3056.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3057. 

  3057.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3058. 

  3058.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3059. 

  3059. 

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

  3061.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3062. 

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

  3063.       {
    3064. 

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

  3065.         {
    3066. 

  3066.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    3067. 

  3067. 

  3068.          if ( $BreakR == NULL )
    3069. 

  3069.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks);
    3070. 

  3070.          else
    3071. 

  3071.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);
    3072. 

  3072. 

  3073.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3074. 

  3074. 

  3075.          $AxisID	= $Serie["Axis"];
    3076. 

  3076.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3077. 

  3077.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3078. 

  3078.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3079. 

  3079. 

  3080.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3081. 

  3081. 

  3082.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3083. 

  3083. 

  3084.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3085. 

  3085.           {
    3086. 

  3086.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3087. 

  3087.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";
    3088. 

  3088.            $Force = $XStep / 5;
    3089. 

  3089. 

  3090.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3091. 

  3091.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;
    3092. 

  3092.            foreach($PosArray as $Key => $Y)
    3093. 

  3093.             {
    3094. 

  3094.              if ( $DisplayValues ) 
    3095. 

  3095.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    3096. 

  3096. 	
    3097. 

  3097.              if ( $Y == VOID && $LastY != NULL )
    3098. 

  3098.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }
    3099. 

  3099. 

  3100.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )
    3101. 

  3101.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }
    3102. 

  3102. 

  3103.              if ( $Y != VOID )
    3104. 

  3104.               $WayPoints[] = array($X,$Y);
    3105. 

  3105. 

  3106.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3107. 

  3107.              if ( $Y == VOID ) { $Y = NULL; }
    3108. 

  3108. 

  3109.              $LastX = $X; $LastY = $Y;
    3110. 

  3110.              $X = $X + $XStep;
    3111. 

  3111.             }
    3112. 

  3112.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    3113. 

  3113.           }
    3114. 

  3114.          else
    3115. 

  3115.           {
    3116. 

  3116.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3117. 

  3117.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";
    3118. 

  3118.            $Force = $YStep / 5;
    3119. 

  3119. 

  3120.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3121. 

  3121.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;
    3122. 

  3122.            foreach($PosArray as $Key => $X)
    3123. 

  3123.             {
    3124. 

  3124.              if ( $DisplayValues ) 
    3125. 

  3125.               $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));
    3126. 

  3126. 

  3127.              if ( $X == VOID && $LastX != NULL )
    3128. 

  3128.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }
    3129. 

  3129. 

  3130.              if ( $X != VOID && $LastX == NULL && $LastGoodX != NULL && !$BreakVoid )
    3131. 

  3131.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }
    3132. 

  3132. 

  3133.              if ( $X != VOID )
    3134. 

  3134.               $WayPoints[] = array($X,$Y);
    3135. 

  3135. 

  3136.              if ( $X != VOID ) { $LastGoodX = $X; $LastGoodY = $Y; }
    3137. 

  3137.              if ( $X == VOID ) { $X = NULL; }
    3138. 

  3138. 

  3139.              $LastX = $X; $LastY = $Y;
    3140. 

  3140.              $Y = $Y + $YStep;
    3141. 

  3141.             }
    3142. 

  3142.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    3143. 

  3143.           }
    3144. 

  3144.         }
    3145. 

  3145.       }
    3146. 

  3146.     }
    3147. 

  3147. 

  3148.    /* Draw a filled spline chart */
    3149. 

  3149.    function drawFilledSplineChart($Format=NULL)
    3150. 

  3150.     {
    3151. 

  3151.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    3152. 

  3152.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3153. 

  3153.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3154. 

  3154.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3155. 

  3155.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3156. 

  3156.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3157. 

  3157.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    3158. 

  3158. 

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

  3160.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3161. 

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

  3162.       {
    3163. 

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

  3164.         {
    3165. 

  3165.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    3166. 

  3166.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3167. 

  3167. 

  3168.          $AxisID	= $Serie["Axis"];
    3169. 

  3169.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3170. 

  3170.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3171. 

  3171.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3172. 

  3172. 

  3173.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3174. 

  3174.          if ( $AroundZero ) { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }
    3175. 

  3175. 

  3176.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3177. 

  3177. 

  3178.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3179. 

  3179.           {
    3180. 

  3180.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3181. 

  3181.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";
    3182. 

  3182.            $Force = $XStep / 5;
    3183. 

  3183. 

  3184.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }
    3185. 

  3185.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    3186. 

  3186.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }
    3187. 

  3187. 

  3188.            $LastX = ""; $LastY = "";
    3189. 

  3189.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3190. 

  3190.            foreach($PosArray as $Key => $Y)
    3191. 

  3191.             {
    3192. 

  3192.              if ( $DisplayValues ) 
    3193. 

  3193.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
    3194. 

  3194. 

  3195.              if ( $Y == VOID )
    3196. 

  3196.               {
    3197. 

  3197.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));
    3198. 

  3198. 

  3199.                if ( $Area != "" )
    3200. 

  3200.                 {
    3201. 

  3201.                  foreach ($Area as $key => $Points)
    3202. 

  3202.                   {
    3203. 

  3203.                    $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;
    3204. 

  3204.                    foreach($Points as $subKey => $Point)
    3205. 

  3205.                     {
    3206. 

  3206.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }
    3207. 

  3207.                      $Corners[] = $Point["Y"]+1;
    3208. 

  3208.                     }
    3209. 

  3209.                    $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;
    3210. 

  3210. 

  3211.                    $this->drawPolygon($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE));
    3212. 

  3212.                   }
    3213. 

  3213.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    3214. 

  3214.                 }
    3215. 

  3215. 

  3216.                $WayPoints = "";
    3217. 

  3217.               }
    3218. 

  3218.              else
    3219. 

  3219.               $WayPoints[] = array($X,$Y-.5); /* -.5 for AA visual fix */
    3220. 

  3220. 

  3221.              $X = $X + $XStep;
    3222. 

  3222.             }
    3223. 

  3223.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));
    3224. 

  3224. 

  3225.            if ( $Area != "" )
    3226. 

  3226.             {
    3227. 

  3227.              foreach ($Area as $key => $Points)
    3228. 

  3228.               {
    3229. 

  3229.                $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;
    3230. 

  3230.                foreach($Points as $subKey => $Point)
    3231. 

  3231.                 {
    3232. 

  3232.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }
    3233. 

  3233.                  $Corners[] = $Point["Y"]+1;
    3234. 

  3234.                 }
    3235. 

  3235.                $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;
    3236. 

  3236. 

  3237.                $this->drawPolygon($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE));
    3238. 

  3238.               }
    3239. 

  3239.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    3240. 

  3240.             }
    3241. 

  3241.           }
    3242. 

  3242.          else
    3243. 

  3243.           {
    3244. 

  3244.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3245. 

  3245.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";
    3246. 

  3246.            $Force = $YStep / 5;
    3247. 

  3247. 

  3248.            if ( !$AroundZero ) { $YZero = $this->GraphAreaX1+1; }
    3249. 

  3249.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    3250. 

  3250.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    3251. 

  3251. 

  3252.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3253. 

  3253.            foreach($PosArray as $Key => $X)
    3254. 

  3254.             {
    3255. 

  3255.              if ( $DisplayValues ) 
    3256. 

  3256.               $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));
    3257. 

  3257. 

  3258.              if ( $X == VOID )
    3259. 

  3259.               {
    3260. 

  3260.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));
    3261. 

  3261. 

  3262.                if ( $Area != "" )
    3263. 

  3263.                 {
    3264. 

  3264.                  foreach ($Area as $key => $Points)
    3265. 

  3265.                   {
    3266. 

  3266.                    $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];
    3267. 

  3267.                    foreach($Points as $subKey => $Point)
    3268. 

  3268.                     {
    3269. 

  3269.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }
    3270. 

  3270.                      $Corners[] = $Point["Y"];
    3271. 

  3271.                     }
    3272. 

  3272.                    $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;
    3273. 

  3273. 

  3274.                    $this->drawPolygon($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE));
    3275. 

  3275.                   }
    3276. 

  3276.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    3277. 

  3277.                 }
    3278. 

  3278. 

  3279.                $WayPoints = "";
    3280. 

  3280.               }
    3281. 

  3281.              else
    3282. 

  3282.               $WayPoints[] = array($X,$Y);
    3283. 

  3283. 

  3284.              $Y = $Y + $YStep;
    3285. 

  3285.             }
    3286. 

  3286.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));
    3287. 

  3287. 

  3288.            if ( $Area != "" )
    3289. 

  3289.             {
    3290. 

  3290.              foreach ($Area as $key => $Points)
    3291. 

  3291.               {
    3292. 

  3292.                $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];
    3293. 

  3293.                foreach($Points as $subKey => $Point)
    3294. 

  3294.                 {
    3295. 

  3295.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }
    3296. 

  3296.                  $Corners[] = $Point["Y"];
    3297. 

  3297.                 }
    3298. 

  3298.                $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;
    3299. 

  3299. 

  3300.                $this->drawPolygon($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE));
    3301. 

  3301.               }
    3302. 

  3302.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    3303. 

  3303.             }
    3304. 

  3304. 

  3305.           }
    3306. 

  3306.         }
    3307. 

  3307.       }
    3308. 

  3308.     }
    3309. 

  3309. 

  3310.    /* Draw a line chart */
    3311. 

  3311.    function drawLineChart($Format=NULL)
    3312. 

  3312.     {
    3313. 

  3313.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;
    3314. 

  3314.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    3315. 

  3315.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;
    3316. 

  3316.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;
    3317. 

  3317.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;
    3318. 

  3318.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    3319. 

  3319.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3320. 

  3320.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3321. 

  3321.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3322. 

  3322.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3323. 

  3323.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3324. 

  3324. 

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

  3326.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3327. 

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

  3328.       {
    3329. 

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

  3330.         {
    3331. 

  3331.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    3332. 

  3332. 

  3333.          if ( $BreakR == NULL )
    3334. 

  3334.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);
    3335. 

  3335.          else
    3336. 

  3336.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);
    3337. 

  3337. 

  3338.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3339. 

  3339. 

  3340.          $AxisID	= $Serie["Axis"];
    3341. 

  3341.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3342. 

  3342.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3343. 

  3343.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3344. 

  3344. 

  3345.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3346. 

  3346. 

  3347.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3348. 

  3348. 

  3349.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3350. 

  3350.           {
    3351. 

  3351.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3352. 

  3352.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3353. 

  3353. 

  3354.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3355. 

  3355.            $LastGoodY = NULL; $LastGoodX = NULL;
    3356. 

  3356.            foreach($PosArray as $Key => $Y)
    3357. 

  3357.             {
    3358. 

  3358.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 
    3359. 

  3359.               {
    3360. 

  3360.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }
    3361. 

  3361.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));
    3362. 

  3362.               }
    3363. 

  3363. 

  3364.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )
    3365. 

  3365.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    3366. 

  3366. 

  3367.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )
    3368. 

  3368.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }
    3369. 

  3369. 

  3370.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3371. 

  3371.              if ( $Y == VOID ) { $Y = NULL; }
    3372. 

  3372. 

  3373.              $LastX = $X; $LastY = $Y;
    3374. 

  3374.              $X = $X + $XStep;
    3375. 

  3375.             }
    3376. 

  3376.           }
    3377. 

  3377.          else
    3378. 

  3378.           {
    3379. 

  3379.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3380. 

  3380.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3381. 

  3381. 

  3382.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3383. 

  3383.            $LastGoodY = NULL; $LastGoodX = NULL;
    3384. 

  3384.            foreach($PosArray as $Key => $X)
    3385. 

  3385.             {
    3386. 

  3386.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 
    3387. 

  3387.               { $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)); }
    3388. 

  3388. 

  3389.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )
    3390. 

  3390.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));
    3391. 

  3391. 

  3392.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )
    3393. 

  3393.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }
    3394. 

  3394. 

  3395.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3396. 

  3396.              if ( $X == VOID ) { $X = NULL; }
    3397. 

  3397. 

  3398.              $LastX = $X; $LastY = $Y;
    3399. 

  3399.              $Y = $Y + $YStep;
    3400. 

  3400.             }
    3401. 

  3401.           }
    3402. 

  3402.         }
    3403. 

  3403.       }
    3404. 

  3404.     }
    3405. 

  3405. 

  3406.    /* Draw a step chart */
    3407. 

  3407.    function drawStepChart($Format=NULL)
    3408. 

  3408.     {
    3409. 

  3409.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : FALSE;
    3410. 

  3410.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;
    3411. 

  3411.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    3412. 

  3412.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;
    3413. 

  3413.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;
    3414. 

  3414.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;
    3415. 

  3415.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;
    3416. 

  3416.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3417. 

  3417.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3418. 

  3418.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3419. 

  3419.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3420. 

  3420.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3421. 

  3421. 

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

  3423.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3424. 

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

  3425.       {
    3426. 

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

  3427.         {
    3428. 

  3428.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    3429. 

  3429. 

  3430.          if ( $BreakR == NULL )
    3431. 

  3431.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);
    3432. 

  3432.          else
    3433. 

  3433.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);
    3434. 

  3434. 

  3435.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3436. 

  3436. 

  3437.          $AxisID	= $Serie["Axis"];
    3438. 

  3438.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3439. 

  3439.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3440. 

  3440.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3441. 

  3441.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);
    3442. 

  3442. 

  3443.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3444. 

  3444. 

  3445.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3446. 

  3446. 

  3447.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3448. 

  3448.           {
    3449. 

  3449.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3450. 

  3450.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3451. 

  3451. 

  3452.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3453. 

  3453.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;
    3454. 

  3454.            foreach($PosArray as $Key => $Y)
    3455. 

  3455.             {
    3456. 

  3456.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 
    3457. 

  3457.               {
    3458. 

  3458.                if ( $Y <= $LastY ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }
    3459. 

  3459.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));
    3460. 

  3460.               }
    3461. 

  3461. 

  3462.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )
    3463. 

  3463.               {
    3464. 

  3464.                $this->drawLine($LastX,$LastY,$X,$LastY,$Color);
    3465. 

  3465.                $this->drawLine($X,$LastY,$X,$Y,$Color);
    3466. 

  3466.                if ( $ReCenter && $X+$XStep < $this->GraphAreaX2 - $XMargin ) { $this->drawLine($X,$Y,$X+$XStep,$Y,$Color); }
    3467. 

  3467.               }
    3468. 

  3468. 

  3469.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )
    3470. 

  3470.               { 
    3471. 

  3471.                if ( $ReCenter )
    3472. 

  3472.                 $this->drawLine($LastGoodX+$XStep,$LastGoodY,$X,$LastGoodY,$BreakSettings);
    3473. 

  3473.                else
    3474. 

  3474.                 $this->drawLine($LastGoodX,$LastGoodY,$X,$LastGoodY,$BreakSettings);
    3475. 

  3475. 

  3476.                $this->drawLine($X,$LastGoodY,$X,$Y,$BreakSettings);
    3477. 

  3477.                $LastGoodY = NULL;
    3478. 

  3478.               }
    3479. 

  3479.              elseif( !$BreakVoid && $LastGoodY == NULL && $Y != VOID )
    3480. 

  3480.               $this->drawLine($this->GraphAreaX1 + $XMargin,$Y,$X,$Y,$BreakSettings);
    3481. 

  3481. 

  3482.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3483. 

  3483.              if ( $Y == VOID ) { $Y = NULL; }
    3484. 

  3484. 

  3485.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }
    3486. 

  3486.              $LastX = $X; $LastY = $Y;
    3487. 

  3487.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }
    3488. 

  3488.              $X = $X + $XStep;
    3489. 

  3489.             }
    3490. 

  3490.            if ( $ReCenter ) { $this->drawLine($LastX,$LastY,$this->GraphAreaX2 - $XMargin,$LastY,$Color); }
    3491. 

  3491.           }
    3492. 

  3492.          else
    3493. 

  3493.           {
    3494. 

  3494.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3495. 

  3495.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3496. 

  3496. 

  3497.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3498. 

  3498.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;
    3499. 

  3499.            foreach($PosArray as $Key => $X)
    3500. 

  3500.             {
    3501. 

  3501.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 
    3502. 

  3502.               {
    3503. 

  3503.                if ( $X >= $LastX ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }
    3504. 

  3504.                $this->drawText($X+$Offset+$Weight,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));
    3505. 

  3505.               }
    3506. 

  3506. 

  3507.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )
    3508. 

  3508.               {
    3509. 

  3509.                $this->drawLine($LastX,$LastY,$LastX,$Y,$Color);
    3510. 

  3510.                $this->drawLine($LastX,$Y,$X,$Y,$Color);
    3511. 

  3511.               }
    3512. 

  3512. 

  3513.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )
    3514. 

  3514.               {
    3515. 

  3515.                $this->drawLine($LastGoodX,$LastGoodY,$LastGoodX,$LastGoodY+$YStep,$Color);
    3516. 

  3516. 

  3517.                $this->drawLine($LastGoodX,$LastGoodY+$YStep,$LastGoodX,$Y,$BreakSettings);
    3518. 

  3518.                $this->drawLine($LastGoodX,$Y,$X,$Y,$BreakSettings);
    3519. 

  3519.                $LastGoodY = NULL;
    3520. 

  3520.               }
    3521. 

  3521.              elseif ( $X != VOID && $LastGoodY == NULL && !$BreakVoid )
    3522. 

  3522.               $this->drawLine($X,$this->GraphAreaY1 + $XMargin,$X,$Y,$BreakSettings);
    3523. 

  3523. 

  3524.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3525. 

  3525.              if ( $X == VOID ) { $X = NULL; }
    3526. 

  3526. 

  3527.              if ( !$Init && $ReCenter ) { $Y = $Y - $YStep/2; $Init = TRUE; }
    3528. 

  3528.              $LastX = $X; $LastY = $Y;
    3529. 

  3529.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }
    3530. 

  3530.              $Y = $Y + $YStep;
    3531. 

  3531.             }
    3532. 

  3532.            if ( $ReCenter ) { $this->drawLine($LastX,$LastY,$LastX,$this->GraphAreaY2 - $XMargin,$Color); }
    3533. 

  3533.           }
    3534. 

  3534.         }
    3535. 

  3535.       }
    3536. 

  3536.     }
    3537. 

  3537. 

  3538.    /* Draw a step chart */
    3539. 

  3539.    function drawFilledStepChart($Format=NULL)
    3540. 

  3540.     {
    3541. 

  3541.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;
    3542. 

  3542.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;
    3543. 

  3543.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3544. 

  3544.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3545. 

  3545.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;
    3546. 

  3546.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3547. 

  3547.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3548. 

  3548.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3549. 

  3549.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    3550. 

  3550. 

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

  3552.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3553. 

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

  3554.       {
    3555. 

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

  3556.         {
    3557. 

  3557.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    3558. 

  3558. 

  3559.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3560. 

  3560. 

  3561.          $AxisID	= $Serie["Axis"];
    3562. 

  3562.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3563. 

  3563.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3564. 

  3564.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3565. 

  3565. 

  3566.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B);
    3567. 

  3567.          if ( $ForceTransparency != NULL ) { $Color["Alpha"] = $ForceTransparency; } else { $Color["Alpha"] = $Alpha; }
    3568. 

  3568. 

  3569.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3570. 

  3570.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));
    3571. 

  3571. 

  3572.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3573. 

  3573. 

  3574.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3575. 

  3575.           {
    3576. 

  3576.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    3577. 

  3577.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }
    3578. 

  3578. 

  3579.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3580. 

  3580.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3581. 

  3581. 

  3582.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }
    3583. 

  3583. 

  3584.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3585. 

  3585.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = ""; $Init = FALSE;
    3586. 

  3586.            foreach($PosArray as $Key => $Y)
    3587. 

  3587.             {
    3588. 

  3588.              if ( $Y == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )
    3589. 

  3589.               {
    3590. 

  3590.                $Points[] = $LastX; $Points[] = $LastY;
    3591. 

  3591.                $Points[] = $X; $Points[] = $LastY;
    3592. 

  3592.                $Points[] = $X; $Points[] = $YZero;
    3593. 

  3593.                $this->drawPolygon($Points,$Color);
    3594. 

  3594.                $Points = "";
    3595. 

  3595.               }
    3596. 

  3596. 

  3597.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )
    3598. 

  3598.               {
    3599. 

  3599.                if ( $Points == "") { $Points[] = $LastX; $Points[] = $YZero; }
    3600. 

  3600.                $Points[] = $LastX; $Points[] = $LastY;
    3601. 

  3601.                $Points[] = $X; $Points[] = $LastY;
    3602. 

  3602.                $Points[] = $X; $Points[] = $Y;
    3603. 

  3603.               }
    3604. 

  3604. 

  3605.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3606. 

  3606.              if ( $Y == VOID ) { $Y = NULL; }
    3607. 

  3607. 

  3608.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }
    3609. 

  3609.              $LastX = $X; $LastY = $Y;
    3610. 

  3610.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }
    3611. 

  3611.              $X = $X + $XStep;
    3612. 

  3612.             }
    3613. 

  3613. 

  3614.            if ( $ReCenter )
    3615. 

  3615.             {
    3616. 

  3616.              $Points[] = $LastX+$XStep/2; $Points[] = $LastY;
    3617. 

  3617.              $Points[] = $LastX+$XStep/2; $Points[] = $YZero;
    3618. 

  3618.             }
    3619. 

  3619.            else
    3620. 

  3620.             { $Points[] = $LastX; $Points[] = $YZero; }
    3621. 

  3621. 

  3622.            $this->drawPolygon($Points,$Color);
    3623. 

  3623.           }
    3624. 

  3624.          else
    3625. 

  3625.           {
    3626. 

  3626.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    3627. 

  3627.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    3628. 

  3628. 

  3629.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3630. 

  3630.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3631. 

  3631. 

  3632.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3633. 

  3633.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = "";
    3634. 

  3634.            foreach($PosArray as $Key => $X)
    3635. 

  3635.             {
    3636. 

  3636.              if ( $X == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )
    3637. 

  3637.               {
    3638. 

  3638.                $Points[] = $LastX; $Points[] = $LastY;
    3639. 

  3639.                $Points[] = $LastX; $Points[] = $Y;
    3640. 

  3640.                $Points[] = $YZero; $Points[] = $Y;
    3641. 

  3641.                $this->drawPolygon($Points,$Color);
    3642. 

  3642.                $Points = "";
    3643. 

  3643.               }
    3644. 

  3644. 

  3645.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )
    3646. 

  3646.               {
    3647. 

  3647.                if ( $Points == "") { $Points[] = $YZero; $Points[] = $LastY; }
    3648. 

  3648.                $Points[] = $LastX; $Points[] = $LastY;
    3649. 

  3649.                $Points[] = $LastX; $Points[] = $Y;
    3650. 

  3650.                $Points[] = $X; $Points[] = $Y;
    3651. 

  3651.               }
    3652. 

  3652. 

  3653.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }
    3654. 

  3654.              if ( $X == VOID ) { $X = NULL; }
    3655. 

  3655. 

  3656.              if ( $LastX == NULL && $ReCenter ) { $Y = $Y - $YStep/2; }
    3657. 

  3657.              $LastX = $X; $LastY = $Y;
    3658. 

  3658.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }
    3659. 

  3659.              $Y = $Y + $YStep;
    3660. 

  3660.             }
    3661. 

  3661. 

  3662.            if ( $ReCenter )
    3663. 

  3663.             {
    3664. 

  3664.              $Points[] = $LastX; $Points[] = $LastY+$YStep/2;
    3665. 

  3665.              $Points[] = $YZero; $Points[] = $LastY+$YStep/2;
    3666. 

  3666.             }
    3667. 

  3667.            else
    3668. 

  3668.             { $Points[] = $YZero; $Points[] = $LastY; }
    3669. 

  3669. 

  3670.            $this->drawPolygon($Points,$Color);
    3671. 

  3671.           }
    3672. 

  3672.         }
    3673. 

  3673.       }
    3674. 

  3674.     }
    3675. 

  3675. 

  3676.    /* Draw an area chart */
    3677. 

  3677.    function drawAreaChart($Format=NULL)
    3678. 

  3678.     {
    3679. 

  3679.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    3680. 

  3680.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3681. 

  3681.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3682. 

  3682.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3683. 

  3683.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3684. 

  3684.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3685. 

  3685.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : 50;
    3686. 

  3686.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    3687. 

  3687. 

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

  3689.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3690. 

  3690. 

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

  3692.       {
    3693. 

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

  3694.         {
    3695. 

  3695.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    3696. 

  3696.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3697. 

  3697. 

  3698.          $AxisID	= $Serie["Axis"];
    3699. 

  3699.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3700. 

  3700.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3701. 

  3701.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3702. 

  3702. 

  3703.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3704. 

  3704.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));
    3705. 

  3705. 

  3706.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    3707. 

  3707. 

  3708.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3709. 

  3709.           {
    3710. 

  3710.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    3711. 

  3711. 

  3712.            $Areas = ""; $AreaID = 0; 
    3713. 

  3713.            $Areas[$AreaID][] = $this->GraphAreaX1 + $XMargin;
    3714. 

  3714.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }
    3715. 

  3715. 

  3716.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3717. 

  3717.            $X     = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3718. 

  3718. 

  3719.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3720. 

  3720.            foreach($PosArray as $Key => $Y)
    3721. 

  3721.             {
    3722. 

  3722.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )
    3723. 

  3723.               {
    3724. 

  3724.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }
    3725. 

  3725.                $this->drawText($X,$Y-$Offset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));
    3726. 

  3726.               }
    3727. 

  3727. 

  3728.              if ( $Y == VOID && isset($Areas[$AreaID]) )
    3729. 

  3729.               {
    3730. 

  3730.                $Areas[$AreaID][] = $LastX;
    3731. 

  3731.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }
    3732. 

  3732. 

  3733.                $AreaID++;
    3734. 

  3734.               }
    3735. 

  3735.              elseif ($Y != VOID)
    3736. 

  3736.               {
    3737. 

  3737.                if ( !isset($Areas[$AreaID]) )
    3738. 

  3738.                 {
    3739. 

  3739.                  $Areas[$AreaID][] = $X;
    3740. 

  3740.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }
    3741. 

  3741.                 }
    3742. 

  3742. 

  3743.                $Areas[$AreaID][] = $X;
    3744. 

  3744.                $Areas[$AreaID][] = $Y;
    3745. 

  3745.               }
    3746. 

  3746. 

  3747.              $LastX = $X;
    3748. 

  3748.              $X = $X + $XStep;
    3749. 

  3749.             }
    3750. 

  3750.            $Areas[$AreaID][] = $LastX;
    3751. 

  3751.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }
    3752. 

  3752. 

  3753.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;
    3754. 

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

  3755.            foreach($Areas as $Key => $Points)
    3756. 

  3756.             $this->drawPolygon($Points,$Color);
    3757. 

  3757.           }
    3758. 

  3758.          else
    3759. 

  3759.           {
    3760. 

  3760.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    3761. 

  3761.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    3762. 

  3762. 

  3763.            $Areas = ""; $AreaID = 0; 
    3764. 

  3764.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }
    3765. 

  3765.            $Areas[$AreaID][] = $this->GraphAreaY1 + $XMargin;
    3766. 

  3766. 

  3767.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    3768. 

  3768.            $Y     = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;
    3769. 

  3769. 

  3770.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3771. 

  3771.            foreach($PosArray as $Key => $X)
    3772. 

  3772.             {
    3773. 

  3773.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )
    3774. 

  3774.               {
    3775. 

  3775.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }
    3776. 

  3776.                $this->drawText($X+$Offset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));
    3777. 

  3777.               }
    3778. 

  3778. 

  3779. 

  3780.              if ( $X == VOID && isset($Areas[$AreaID]) )
    3781. 

  3781.               {
    3782. 

  3782.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }
    3783. 

  3783.                $Areas[$AreaID][] = $LastY;
    3784. 

  3784. 

  3785.                $AreaID++;
    3786. 

  3786.               }
    3787. 

  3787.              elseif ($X != VOID)
    3788. 

  3788.               {
    3789. 

  3789.                if ( !isset($Areas[$AreaID]) )
    3790. 

  3790.                 {
    3791. 

  3791.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }
    3792. 

  3792.                  $Areas[$AreaID][] = $Y;
    3793. 

  3793.                 }
    3794. 

  3794. 

  3795.                $Areas[$AreaID][] = $X;
    3796. 

  3796.                $Areas[$AreaID][] = $Y;
    3797. 

  3797.               }
    3798. 

  3798. 

  3799.              $LastX = $X; $LastY = $Y;
    3800. 

  3800.              $Y = $Y + $YStep;
    3801. 

  3801.             }
    3802. 

  3802.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }
    3803. 

  3803.            $Areas[$AreaID][] = $LastY;
    3804. 

  3804. 

  3805.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;
    3806. 

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

  3807.            foreach($Areas as $Key => $Points)
    3808. 

  3808.             $this->drawPolygon($Points,$Color);
    3809. 

  3809.           }
    3810. 

  3810.         }
    3811. 

  3811.       }
    3812. 

  3812.     }
    3813. 

  3813. 

  3814. 

  3815.    /* Draw a bar chart */
    3816. 

  3816.    function drawBarChart($Format=NULL)
    3817. 

  3817.     {
    3818. 

  3818.      $Floating0Serie	= isset($Format["Floating0Serie"]) ? $Format["Floating0Serie"] : NULL;
    3819. 

  3819.      $Floating0Value	= isset($Format["Floating0Value"]) ? $Format["Floating0Value"] : NULL;
    3820. 

  3820.      $Draw0Line		= isset($Format["Draw0Line"]) ? $Format["Draw0Line"] : FALSE;
    3821. 

  3821.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    3822. 

  3822.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    3823. 

  3823.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    3824. 

  3824.      $DisplayFont	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontName;
    3825. 

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

  3826.      $DisplayPos	= isset($Format["DisplayPos"]) ? $Format["DisplayPos"] : LABEL_POS_OUTSIDE;
    3827. 

  3827.      $DisplayShadow	= isset($Format["DisplayShadow"]) ? $Format["DisplayShadow"] : TRUE;
    3828. 

  3828.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    3829. 

  3829.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    3830. 

  3830.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    3831. 

  3831.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    3832. 

  3832.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;
    3833. 

  3833.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;
    3834. 

  3834.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;
    3835. 

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

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

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

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

  3839.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;
    3840. 

  3840.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;
    3841. 

  3841.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;
    3842. 

  3842.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    3843. 

  3843.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    3844. 

  3844.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    3845. 

  3845.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;
    3846. 

  3846.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;
    3847. 

  3847.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;
    3848. 

  3848.      $TxtMargin		= isset($Format["TxtMargin"]) ? $Format["TxtMargin"] : 6;
    3849. 

  3849.      $OverrideColors	= isset($Format["OverrideColors"]) ? $Format["OverrideColors"] : NULL;
    3850. 

  3850.      $OverrideSurrounding = isset($Format["OverrideSurrounding"]) ? $Format["OverrideSurrounding"] : 30;
    3851. 

  3851. 

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

  3853.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    3854. 

  3854. 

  3855.      if ( $OverrideColors != NULL )
    3856. 

  3856.       {
    3857. 

  3857.        $OverrideColors = $this->validatePalette($OverrideColors,$OverrideSurrounding);
    3858. 

  3858.        $this->DataSet->saveExtendedData("Palette",$OverrideColors);
    3859. 

  3859.       }
    3860. 

  3860. 

  3861.      $RestoreShadow = $this->Shadow;
    3862. 

  3862. 

  3863.      $SeriesCount  = $this->countDrawableSeries();
    3864. 

  3864.      $CurrentSerie = 0;
    3865. 

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

  3866.       {
    3867. 

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

  3868.         {
    3869. 

  3869.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    3870. 

  3870.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }
    3871. 

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

  3872. 

  3873.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);
    3874. 

  3874. 

  3875.          $AxisID	= $Serie["Axis"];
    3876. 

  3876.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    3877. 

  3877.          $Format	= $Data["Axis"][$AxisID]["Format"];
    3878. 

  3878.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    3879. 

  3879. 

  3880.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    3881. 

  3881. 

  3882.          if ( $Floating0Value != NULL )
    3883. 

  3883.           { $YZero = $this->scaleComputeY($Floating0Value,array("AxisID"=>$Serie["Axis"])); }
    3884. 

  3884.          else
    3885. 

  3885.           { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }
    3886. 

  3886. 

  3887.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    3888. 

  3888.           {
    3889. 

  3889.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    3890. 

  3890.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }
    3891. 

  3891. 

  3892.            if ( $XDivs == 0 ) { $XStep = 0; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    3893. 

  3893.            $X = $this->GraphAreaX1 + $XMargin;
    3894. 

  3894. 

  3895.            if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }
    3896. 

  3896.            if ( $XDivs == 0 ) { $XSize = ($this->GraphAreaX2-$this->GraphAreaX1)/($SeriesCount+$Interleave); } else { $XSize   = ($XStep / ($SeriesCount+$Interleave) ); }
    3897. 

  3897.            
    3898. 

  3898.            $XOffset = -($XSize*$SeriesCount)/2 + $CurrentSerie * $XSize;
    3899. 

  3899.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $XOffset + $XSize / 2;
    3900. 

  3900. 

  3901. 

  3902.            if ( $Rounded || $BorderR != -1) { $XSpace = 1; } else { $XSpace = 0; }
    3903. 

  3903. 

  3904.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    3905. 

  3905. 

  3906.            $ID = 0;
    3907. 

  3907.            foreach($PosArray as $Key => $Y2)
    3908. 

  3908.             {
    3909. 

  3909.              if ( $Floating0Serie != NULL )
    3910. 

  3910.               {
    3911. 

  3911.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )
    3912. 

  3912.                 $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];
    3913. 

  3913.                else { $Value = 0; }
    3914. 

  3914. 

  3915.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));
    3916. 

  3916.                if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    3917. 

  3917.                if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }
    3918. 

  3918. 

  3919.                if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }
    3920. 

  3920.               }
    3921. 

  3921. 

  3922.              if ( $OverrideColors != NULL )
    3923. 

  3923.               { 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(); } }
    3924. 

  3924. 

  3925.              if ( $Y2 != VOID )
    3926. 

  3926.               {
    3927. 

  3927.                $BarHeight = $Y1 - $Y2;
    3928. 

  3928. 

  3929.                if ( $Serie["Data"][$Key] == 0 )
    3930. 

  3930.                 $this->drawLine($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y1,$Color);
    3931. 

  3931.                else
    3932. 

  3932.                 {
    3933. 

  3933.                  if ( $Rounded )
    3934. 

  3934.                   $this->drawRoundedFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$RoundRadius,$Color);
    3935. 

  3935.                  else
    3936. 

  3936.                   {
    3937. 

  3937.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$Color);
    3938. 

  3938. 

  3939.                    if ( $Gradient )
    3940. 

  3940.                     {
    3941. 

  3941.                      $this->Shadow  = FALSE;
    3942. 

  3942. 

  3943.                      if ( $GradientMode == GRADIENT_SIMPLE )
    3944. 

  3944.                       {
    3945. 

  3945.                        if ( $Serie["Data"][$Key] >= 0 )
    3946. 

  3946.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    3947. 

  3947.                        else
    3948. 

  3948.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    3949. 

  3949. 

  3950.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_VERTICAL,$GradienColor);
    3951. 

  3951.                       }
    3952. 

  3952.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )
    3953. 

  3953.                       {
    3954. 

  3954.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    3955. 

  3955.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    3956. 

  3956.                        $XSpan = floor($XSize / 3);
    3957. 

  3957. 

  3958.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSpan-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor1);
    3959. 

  3959.                        $this->drawGradientArea($X+$XOffset+$XSpan+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor2);
    3960. 

  3960.                       }
    3961. 

  3961.                      $this->Shadow = $RestoreShadow;
    3962. 

  3962.                     }
    3963. 

  3963.                   }
    3964. 

  3964. 

  3965.                  if ( $Draw0Line )
    3966. 

  3966.                   {
    3967. 

  3967.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);
    3968. 

  3968. 

  3969.                    if ( abs($Y1 - $Y2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }
    3970. 

  3970.                    if ( $Y1 - $Y2 < 0 ) { $Line0Width = -$Line0Width; }
    3971. 

  3971. 

  3972.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1)-$Line0Width,$Line0Color);
    3973. 

  3973.                    $this->drawLine($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1),$Line0Color);
    3974. 

  3974.                   }
    3975. 

  3975.                 }
    3976. 

  3976. 

  3977.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID )
    3978. 

  3978.                 {
    3979. 

  3979.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }
    3980. 

  3980. 

  3981.                  $Caption    = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);
    3982. 

  3982.                  $TxtPos     = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,90,$Caption);
    3983. 

  3983.                  $TxtHeight  = $TxtPos[0]["Y"] - $TxtPos[1]["Y"] + $TxtMargin;
    3984. 

  3984. 

  3985.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtHeight) < abs($BarHeight) )
    3986. 

  3986.                   {
    3987. 

  3987.                    $CenterX = (($X+$XOffset+$XSize-$XSpace)-($X+$XOffset+$XSpace))/2 + $X+$XOffset+$XSpace;
    3988. 

  3988.                    $CenterY = ($Y2-$Y1)/2 + $Y1;
    3989. 

  3989. 

  3990.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"Angle"=>90));
    3991. 

  3991.                   }
    3992. 

  3992.                  else
    3993. 

  3993.                   {
    3994. 

  3994.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }
    3995. 

  3995.                    $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));
    3996. 

  3996.                   }
    3997. 

  3997. 

  3998.                  $this->Shadow = $RestoreShadow;
    3999. 

  3999.                 }
    4000. 

  4000.               }
    4001. 

  4001. 

  4002.              $X = $X + $XStep;
    4003. 

  4003.              $ID++;
    4004. 

  4004.             }
    4005. 

  4005.           }
    4006. 

  4006.          else
    4007. 

  4007.           {
    4008. 

  4008.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    4009. 

  4009.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    4010. 

  4010. 

  4011.            if ( $XDivs == 0 ) { $YStep = 0; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    4012. 

  4012.            
    4013. 

  4013.            $Y = $this->GraphAreaY1 + $XMargin;
    4014. 

  4014. 

  4015.            if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }
    4016. 

  4016.            if ( $XDivs == 0 ) { $YSize = ($this->GraphAreaY2-$this->GraphAreaY1)/($SeriesCount+$Interleave); } else { $YSize   = ($YStep / ($SeriesCount+$Interleave) ); }
    4017. 

  4017.            
    4018. 

  4018.            $YOffset = -($YSize*$SeriesCount)/2 + $CurrentSerie * $YSize;
    4019. 

  4019.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $YOffset + $YSize / 2;
    4020. 

  4020. 

  4021.            if ( $Rounded || $BorderR != -1 ) { $YSpace = 1; } else { $YSpace = 0; }
    4022. 

  4022. 

  4023.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4024. 

  4024. 

  4025.            $ID = 0 ;
    4026. 

  4026.            foreach($PosArray as $Key => $X2)
    4027. 

  4027.             {
    4028. 

  4028.              if ( $Floating0Serie != NULL )
    4029. 

  4029.               {
    4030. 

  4030.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )
    4031. 

  4031.                 $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];
    4032. 

  4032.                else { $Value = 0; }
    4033. 

  4033. 

  4034.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));
    4035. 

  4035.                if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    4036. 

  4036.                if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    4037. 

  4037.                if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }
    4038. 

  4038.               }
    4039. 

  4039. 

  4040.              if ( $OverrideColors != NULL )
    4041. 

  4041.               { 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(); } }
    4042. 

  4042. 

  4043.              if ( $X2 != VOID )
    4044. 

  4044.               {
    4045. 

  4045.                $BarWidth = $X2 - $X1;
    4046. 

  4046. 

  4047.                if ( $Serie["Data"][$Key] == 0 )
    4048. 

  4048.                 $this->drawLine($X1,$Y+$YOffset+$YSpace,$X1,$Y+$YOffset+$YSize-$YSpace,$Color);
    4049. 

  4049.                else
    4050. 

  4050.                 {
    4051. 

  4051.                  if ( $Rounded )
    4052. 

  4052.                   $this->drawRoundedFilledRectangle($X1+1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$RoundRadius,$Color);
    4053. 

  4053.                  else
    4054. 

  4054.                   {
    4055. 

  4055.                    $this->drawFilledRectangle($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$Color);
    4056. 

  4056. 

  4057.                    if ( $Gradient )
    4058. 

  4058.                     {
    4059. 

  4059.                      $this->Shadow  = FALSE;
    4060. 

  4060. 

  4061.                      if ( $GradientMode == GRADIENT_SIMPLE )
    4062. 

  4062.                       {
    4063. 

  4063.                        if ( $Serie["Data"][$Key] >= 0 )
    4064. 

  4064.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4065. 

  4065.                        else
    4066. 

  4066.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    4067. 

  4067. 

  4068.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_HORIZONTAL,$GradienColor);
    4069. 

  4069.                       }
    4070. 

  4070.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )
    4071. 

  4071.                       {
    4072. 

  4072.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    4073. 

  4073.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4074. 

  4074.                        $YSpan = floor($YSize / 3);
    4075. 

  4075. 

  4076.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSpan-$YSpace,DIRECTION_VERTICAL,$GradienColor1);
    4077. 

  4077.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpan,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_VERTICAL,$GradienColor2);
    4078. 

  4078.                       }
    4079. 

  4079.                      $this->Shadow = $RestoreShadow;
    4080. 

  4080.                     }
    4081. 

  4081.                   }
    4082. 

  4082. 

  4083.                  if ( $Draw0Line )
    4084. 

  4084.                   {
    4085. 

  4085.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);
    4086. 

  4086. 

  4087.                    if ( abs($X1 - $X2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }
    4088. 

  4088.                    if ( $X2 - $X1 < 0 ) { $Line0Width = -$Line0Width; }
    4089. 

  4089. 

  4090.                    $this->drawFilledRectangle(floor($X1),$Y+$YOffset+$YSpace,floor($X1)+$Line0Width,$Y+$YOffset+$YSize-$YSpace,$Line0Color);
    4091. 

  4091.                    $this->drawLine(floor($X1),$Y+$YOffset+$YSpace,floor($X1),$Y+$YOffset+$YSize-$YSpace,$Line0Color);
    4092. 

  4092.                   }
    4093. 

  4093.                 }
    4094. 

  4094. 

  4095.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 
    4096. 

  4096.                 {
    4097. 

  4097.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }
    4098. 

  4098. 

  4099.                  $Caption   = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);
    4100. 

  4100.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4101. 

  4101.                  $TxtWidth  = $TxtPos[1]["X"] - $TxtPos[0]["X"] + $TxtMargin;
    4102. 

  4102. 

  4103.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtWidth) < abs($BarWidth) )
    4104. 

  4104.                   {
    4105. 

  4105.                    $CenterX = ($X2-$X1)/2 + $X1;
    4106. 

  4106.                    $CenterY = (($Y+$YOffset+$YSize-$YSpace)-($Y+$YOffset+$YSpace))/2 + ($Y+$YOffset+$YSpace);
    4107. 

  4107. 

  4108.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize));
    4109. 

  4109.                   }
    4110. 

  4110.                  else
    4111. 

  4111.                   {
    4112. 

  4112.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }
    4113. 

  4113.                    $this->drawText($X2+$Offset,$Y+$YOffset+$YSize/2,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align,"FontSize"=>$DisplaySize));
    4114. 

  4114.                   }
    4115. 

  4115. 

  4116.                  $this->Shadow = $RestoreShadow;
    4117. 

  4117.                 }
    4118. 

  4118.               }
    4119. 

  4119.              $Y = $Y + $YStep;
    4120. 

  4120.              $ID++;
    4121. 

  4121.             }
    4122. 

  4122.           }
    4123. 

  4123.          $CurrentSerie++;
    4124. 

  4124.         }
    4125. 

  4125.       }
    4126. 

  4126.     }
    4127. 

  4127. 

  4128.    /* Draw a bar chart */
    4129. 

  4129.    function drawStackedBarChart($Format=NULL)
    4130. 

  4130.     {
    4131. 

  4131.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    4132. 

  4132.      $DisplayRound      = isset($Format["DisplayRound"]) ? $Format["DisplayRound"] : 0;
    4133. 

  4133.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    4134. 

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

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

  4136.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    4137. 

  4137.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    4138. 

  4138.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    4139. 

  4139.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;
    4140. 

  4140.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;
    4141. 

  4141.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;
    4142. 

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

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

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

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

  4146.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;
    4147. 

  4147.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;
    4148. 

  4148.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;
    4149. 

  4149.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    4150. 

  4150.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    4151. 

  4151.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    4152. 

  4152.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;
    4153. 

  4153.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;
    4154. 

  4154.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;
    4155. 

  4155. 

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

  4157.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    4158. 

  4158. 

  4159.      $RestoreShadow = $this->Shadow;
    4160. 

  4160. 

  4161.      $LastX = ""; $LastY = "";
    4162. 

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

  4163.       {
    4164. 

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

  4165.         {
    4166. 

  4166.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    4167. 

  4167.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = 255; $DisplayG = 255; $DisplayB = 255; }
    4168. 

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

  4169. 

  4170.          $AxisID	= $Serie["Axis"];
    4171. 

  4171.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    4172. 

  4172.          $Format	= $Data["Axis"][$AxisID]["Format"];
    4173. 

  4173.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    4174. 

  4174. 

  4175.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);
    4176. 

  4176.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));
    4177. 

  4177. 

  4178.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    4179. 

  4179. 

  4180.          $Color = array("TransCorner"=>TRUE,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);
    4181. 

  4181. 

  4182.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    4183. 

  4183.           {
    4184. 

  4184.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    4185. 

  4185.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    4186. 

  4186. 

  4187.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    4188. 

  4188.            $X     = $this->GraphAreaX1 + $XMargin;
    4189. 

  4189. 

  4190.            $XSize   = ($XStep / (1+$Interleave) );
    4191. 

  4191.            $XOffset = -($XSize/2);
    4192. 

  4192. 

  4193.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4194. 

  4194.            foreach($PosArray as $Key => $Height)
    4195. 

  4195.             {
    4196. 

  4196.              if ( $Height != VOID && $Serie["Data"][$Key] != 0 )
    4197. 

  4197.               {
    4198. 

  4198.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }
    4199. 

  4199. 

  4200.                if ( !isset($LastY[$Key] ) ) { $LastY[$Key] = ""; }
    4201. 

  4201.                if ( !isset($LastY[$Key][$Pos] ) ) { $LastY[$Key][$Pos] = $YZero; }
    4202. 

  4202. 

  4203.                $Y1 = $LastY[$Key][$Pos];
    4204. 

  4204.                $Y2 = $Y1 - $Height;
    4205. 

  4205. 

  4206.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $Y1 != $YZero) ) { $YSpaceUp = 1; } else { $YSpaceUp = 0; }
    4207. 

  4207.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $Y1 != $YZero) ) { $YSpaceDown = 1; } else { $YSpaceDown = 0; }
    4208. 

  4208. 

  4209.                if ( $Rounded )
    4210. 

  4210.                 $this->drawRoundedFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$RoundRadius,$Color);
    4211. 

  4211.                else
    4212. 

  4212.                 {
    4213. 

  4213.                  $this->drawFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$Color);
    4214. 

  4214. 

  4215.                  if ( $Gradient )
    4216. 

  4216.                   {
    4217. 

  4217.                    $this->Shadow  = FALSE;
    4218. 

  4218. 

  4219.                    if ( $GradientMode == GRADIENT_SIMPLE )
    4220. 

  4220.                     {
    4221. 

  4221.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4222. 

  4222.                      $this->drawGradientArea($X+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+.5,DIRECTION_VERTICAL,$GradientColor);
    4223. 

  4223.                     }
    4224. 

  4224.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )
    4225. 

  4225.                     {
    4226. 

  4226.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    4227. 

  4227.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4228. 

  4228.                      $XSpan = floor($XSize / 3);
    4229. 

  4229. 

  4230.                      $this->drawGradientArea($X+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSpan,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor1);
    4231. 

  4231.                      $this->drawGradientArea($X+$XSpan+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor2);
    4232. 

  4232.                     }
    4233. 

  4233.                    $this->Shadow = $RestoreShadow;
    4234. 

  4234.                   }
    4235. 

  4235.                 }
    4236. 

  4236. 

  4237.                if ( $DisplayValues )
    4238. 

  4238.                 {
    4239. 

  4239.                  $BarHeight = abs($Y2-$Y1);
    4240. 

  4240. 

  4241.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4242. 

  4242.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4243. 

  4243.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);
    4244. 

  4244. 

  4245.                  if ( $BarHeight > $TxtHeight )
    4246. 

  4246.                   {
    4247. 

  4247.                    $XCenter = ( ($X+$XOffset+$XSize) - ($X+$XOffset) ) / 2 + $X+$XOffset;
    4248. 

  4248.                    $YCenter = ( ($Y2) - ($Y1-$YSpaceUp+$YSpaceDown) ) / 2 + $Y1-$YSpaceUp+$YSpaceDown;
    4249. 

  4249. 

  4250.                    $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));
    4251. 

  4251.                   }
    4252. 

  4252.                 }
    4253. 

  4253. 

  4254.                $LastY[$Key][$Pos] = $Y2;
    4255. 

  4255.               }
    4256. 

  4256. 

  4257.              $X = $X + $XStep;
    4258. 

  4258.             }
    4259. 

  4259.           }
    4260. 

  4260.          else
    4261. 

  4261.           {
    4262. 

  4262.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    4263. 

  4263.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    4264. 

  4264. 

  4265.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    4266. 

  4266.            $Y     = $this->GraphAreaY1 + $XMargin;
    4267. 

  4267. 

  4268.            $YSize   = $YStep / (1+$Interleave);
    4269. 

  4269.            $YOffset = -($YSize/2);
    4270. 

  4270. 

  4271.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4272. 

  4272.            foreach($PosArray as $Key => $Width)
    4273. 

  4273.             {
    4274. 

  4274.              if ( $Width != VOID && $Serie["Data"][$Key] != 0 )
    4275. 

  4275.               {
    4276. 

  4276.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }
    4277. 

  4277. 

  4278.                if ( !isset($LastX[$Key] ) ) { $LastX[$Key] = ""; }
    4279. 

  4279.                if ( !isset($LastX[$Key][$Pos] ) ) { $LastX[$Key][$Pos] = $YZero; }
    4280. 

  4280. 

  4281.                $X1 = $LastX[$Key][$Pos];
    4282. 

  4282.                $X2 = $X1 + $Width;
    4283. 

  4283. 

  4284.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $X1 != $YZero) ) { $XSpaceLeft = 2; } else { $XSpaceLeft = 0; }
    4285. 

  4285.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $X1 != $YZero) ) { $XSpaceRight = 2; } else { $XSpaceRight = 0; }
    4286. 

  4286. 

  4287.                if ( $Rounded )
    4288. 

  4288.                 $this->drawRoundedFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$RoundRadius,$Color);
    4289. 

  4289.                else
    4290. 

  4290.                 {
    4291. 

  4291.                  $this->drawFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$Color);
    4292. 

  4292. 

  4293.                  if ( $Gradient )
    4294. 

  4294.                   {
    4295. 

  4295.                    $this->Shadow  = FALSE;
    4296. 

  4296. 

  4297.                    if ( $GradientMode == GRADIENT_SIMPLE )
    4298. 

  4298.                     {
    4299. 

  4299.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4300. 

  4300.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_HORIZONTAL,$GradientColor);
    4301. 

  4301.                     }
    4302. 

  4302.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )
    4303. 

  4303.                     {
    4304. 

  4304.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);
    4305. 

  4305.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);
    4306. 

  4306.                      $YSpan = floor($YSize / 3);
    4307. 

  4307. 

  4308.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSpan,DIRECTION_VERTICAL,$GradientColor1);
    4309. 

  4309.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset+$YSpan,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_VERTICAL,$GradientColor2);
    4310. 

  4310.                     }
    4311. 

  4311.                    $this->Shadow = $RestoreShadow;
    4312. 

  4312.                   }
    4313. 

  4313.                 }
    4314. 

  4314. 

  4315.                if ( $DisplayValues )
    4316. 

  4316.                 {
    4317. 

  4317.                  $BarWidth = abs($X2-$X1);
    4318. 

  4318. 

  4319.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4320. 

  4320.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4321. 

  4321.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);
    4322. 

  4322. 

  4323.                  if ( $BarWidth > $TxtWidth )
    4324. 

  4324.                   {
    4325. 

  4325.                    $XCenter  = ( $X2 - $X1 ) / 2 + $X1;
    4326. 

  4326.                    $YCenter  = ( ($Y+$YOffset+$YSize) - ($Y+$YOffset) ) / 2 + $Y+$YOffset;
    4327. 

  4327. 

  4328.                    $this->drawText($XCenter,$YCenter,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));
    4329. 

  4329.                   }
    4330. 

  4330.                 }
    4331. 

  4331. 

  4332.                $LastX[$Key][$Pos] = $X2;
    4333. 

  4333.               }
    4334. 

  4334. 

  4335.              $Y = $Y + $YStep;
    4336. 

  4336.             }
    4337. 

  4337.           }
    4338. 

  4338.         }
    4339. 

  4339.       }
    4340. 

  4340.     }
    4341. 

  4341. 

  4342.    /* Draw a bar chart */
    4343. 

  4343.    function drawStackedAreaChart($Format=NULL)
    4344. 

  4344.     {
    4345. 

  4345.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    4346. 

  4346.      $DisplayRound      = isset($Format["DisplayRound"]) ? $Format["DisplayRound"] : 0;
    4347. 

  4347.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    4348. 

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

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

  4350.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    4351. 

  4351.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    4352. 

  4352.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    4353. 

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

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

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

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

  4357.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;
    4358. 

  4358. 

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

  4360.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    4361. 

  4361. 

  4362.      $RestoreShadow = $this->Shadow;
    4363. 

  4363. 

  4364.      /* Determine if we only have positive or negatives values */
    4365. 

  4365.      $Sign["+"] = 0; $Sign["-"] = 0;
    4366. 

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

  4367.       {
    4368. 

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

  4369.         { foreach($Serie["Data"] as $Key => $Value) { if ($Value > 0) { $Sign["+"]++; } elseif ($Value < 0) { $Sign["-"]++; } } }
    4370. 

  4370.       } 
    4371. 

  4371.      if ( $Sign["+"] == 0 || $Sign["-"] == 0 ) { $SingleWay = TRUE; } else { $SingleWay = FALSE; }
    4372. 

  4372. 

  4373.      $LastX = ""; $LastY = "";
    4374. 

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

  4375.       {
    4376. 

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

  4377.         {
    4378. 

  4378.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];
    4379. 

  4379. 

  4380.          if ( $ForceTransparency != NULL ) { $Alpha = $ForceTransparency; }
    4381. 

  4381.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = 255; $DisplayG = 255; $DisplayB = 255; }
    4382. 

  4382.          if ( $Surrounding != NULL )
    4383. 

  4383.           { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    4384. 

  4384.          else
    4385. 

  4385.           { $BorderR = $R; $BorderG = $G; $BorderB = $B; }
    4386. 

  4386. 

  4387.          $AxisID	= $Serie["Axis"];
    4388. 

  4388.          $Mode		= $Data["Axis"][$AxisID]["Display"];
    4389. 

  4389.          $Format	= $Data["Axis"][$AxisID]["Format"];
    4390. 

  4390.          $Unit		= $Data["Axis"][$AxisID]["Unit"];
    4391. 

  4391. 

  4392.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);
    4393. 

  4393.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));
    4394. 

  4394. 

  4395.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
    4396. 

  4396. 

  4397.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    4398. 

  4398.           {
    4399. 

  4399.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    4400. 

  4400.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }
    4401. 

  4401. 

  4402.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB,"SkipY"=>$YZero);
    4403. 

  4403. 

  4404.            if ( $SingleWay ) { unset($Color["SkipY"]); }
    4405. 

  4405. 

  4406.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    4407. 

  4407.            $X = $this->GraphAreaX1 + $XMargin;
    4408. 

  4408. 

  4409.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4410. 

  4410. 

  4411.            $PointsTop = ""; $PointsBottom = ""; $Labels = ""; $Pos = "+";
    4412. 

  4412.            foreach($PosArray as $Key => $Height)
    4413. 

  4413.             {
    4414. 

  4414.              if ( !isset($LastY[$Key] ) )       { $LastY[$Key] = ""; }
    4415. 

  4415.              if ( !isset($LastY[$Key][$Pos] ) ) { $LastY[$Key][$Pos] = $YZero; }
    4416. 

  4416. 

  4417.              if ( $Height != VOID && $Serie["Data"][$Key] >= 0)
    4418. 

  4418.               {
    4419. 

  4419.                $Y1 = $LastY[$Key][$Pos];
    4420. 

  4420.                $Y2 = $Y1 - $Height;
    4421. 

  4421. 

  4422.                $PointsTop[]    = $X; $PointsTop[]    = $Y2;
    4423. 

  4423.                $PointsBottom[] = $X; $PointsBottom[] = $Y1;
    4424. 

  4424. 

  4425.                if ( $DisplayValues )
    4426. 

  4426.                 {
    4427. 

  4427.                  $BarHeight = abs($Y2-$Y1);
    4428. 

  4428. 

  4429.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4430. 

  4430.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4431. 

  4431.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);
    4432. 

  4432. 

  4433.                  if ( $BarHeight > $TxtHeight )
    4434. 

  4434.                   {
    4435. 

  4435.                    $XCenter = $X;
    4436. 

  4436.                    $YCenter = $Y1- $BarHeight / 2;
    4437. 

  4437. 

  4438.                    $Labels[] = array($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));
    4439. 

  4439.                   }
    4440. 

  4440.                 }
    4441. 

  4441. 

  4442.                $LastY[$Key][$Pos] = $Y2;
    4443. 

  4443.               }
    4444. 

  4444.              else
    4445. 

  4445.               { $PointsTop[] = $X; $PointsTop[] = $LastY[$Key][$Pos]; $PointsBottom[] = $X; $PointsBottom[] = $LastY[$Key][$Pos]; }
    4446. 

  4446. 

  4447.              $X = $X + $XStep;
    4448. 

  4448.             }
    4449. 

  4449.            $Points = $PointsTop;
    4450. 

  4450.            for($i=count($PointsBottom)-2;$i>=0;$i-=2) { $Points[] = $PointsBottom[$i]; $Points[] = $PointsBottom[$i+1]; }
    4451. 

  4451.            $this->drawPolygon($Points,$Color);
    4452. 

  4452. 

  4453.            /* Reset the X axis parser for the negative values pass */
    4454. 

  4454.            $X = $this->GraphAreaX1 + $XMargin;
    4455. 

  4455. 

  4456.            $PointsTop = ""; $PointsBottom = ""; $Pos = "-";
    4457. 

  4457.            foreach($PosArray as $Key => $Height)
    4458. 

  4458.             {
    4459. 

  4459.              if ( !isset($LastY[$Key] ) )       { $LastY[$Key] = ""; }
    4460. 

  4460.              if ( !isset($LastY[$Key][$Pos] ) ) { $LastY[$Key][$Pos] = $YZero; }
    4461. 

  4461. 

  4462.              if ( $Height != VOID && $Serie["Data"][$Key] < 0)
    4463. 

  4463.               {
    4464. 

  4464.                $Y1 = $LastY[$Key][$Pos];
    4465. 

  4465.                $Y2 = $Y1 - $Height;
    4466. 

  4466. 

  4467.                $PointsTop[]    = $X; $PointsTop[]    = $Y2;
    4468. 

  4468.                $PointsBottom[] = $X; $PointsBottom[] = $Y1;
    4469. 

  4469. 

  4470.                if ( $DisplayValues )
    4471. 

  4471.                 {
    4472. 

  4472.                  $BarHeight = abs($Y2-$Y1);
    4473. 

  4473. 

  4474.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4475. 

  4475.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4476. 

  4476.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);
    4477. 

  4477. 

  4478.                  if ( $BarHeight > $TxtHeight )
    4479. 

  4479.                   {
    4480. 

  4480.                    $XCenter = $X;
    4481. 

  4481.                    $YCenter = $BarHeight / 2 + $Y1;
    4482. 

  4482. 

  4483.                    $Labels[] = array($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));
    4484. 

  4484.                   }
    4485. 

  4485.                 }
    4486. 

  4486. 

  4487.                $LastY[$Key][$Pos] = $Y2;
    4488. 

  4488.               }
    4489. 

  4489.              else
    4490. 

  4490.               { $PointsTop[] = $X; $PointsTop[] = $LastY[$Key][$Pos]; $PointsBottom[] = $X; $PointsBottom[] = $LastY[$Key][$Pos]; }
    4491. 

  4491. 

  4492.              $X = $X + $XStep;
    4493. 

  4493.             }
    4494. 

  4494.            $Points = $PointsTop;
    4495. 

  4495.            for($i=count($PointsBottom)-2;$i>=0;$i-=2) { $Points[] = $PointsBottom[$i]; $Points[] = $PointsBottom[$i+1]; }
    4496. 

  4496.            $this->drawPolygon($Points,$Color);
    4497. 

  4497. 

  4498.            if ( $DisplayValues ) { foreach($Labels as $Key => $Value) { $this->drawText($Value[0],$Value[1],$Value[2],$Value[3]);} }
    4499. 

  4499.           }
    4500. 

  4500.          else
    4501. 

  4501.           {
    4502. 

  4502.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }
    4503. 

  4503.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }
    4504. 

  4504. 

  4505.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB,"SkipX"=>$YZero);
    4506. 

  4506. 

  4507.            if ( $SingleWay ) { unset($Color["SkipX"]); }
    4508. 

  4508. 

  4509.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    4510. 

  4510.            $Y = $this->GraphAreaY1 + $XMargin;
    4511. 

  4511. 

  4512.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4513. 

  4513. 

  4514.            $PointsTop = ""; $PointsBottom = ""; $Labels = ""; $Pos = "+";
    4515. 

  4515.            foreach($PosArray as $Key => $Width)
    4516. 

  4516.             {
    4517. 

  4517.              if ( !isset($LastX[$Key] ) )       { $LastX[$Key] = ""; }
    4518. 

  4518.              if ( !isset($LastX[$Key][$Pos] ) ) { $LastX[$Key][$Pos] = $YZero; }
    4519. 

  4519. 

  4520.              if ( $Width != VOID && $Serie["Data"][$Key] >= 0)
    4521. 

  4521.               {
    4522. 

  4522.                $X1 = $LastX[$Key][$Pos];
    4523. 

  4523.                $X2 = $X1 + $Width;
    4524. 

  4524. 

  4525.                $PointsTop[]    = $X1; $PointsTop[]    = $Y;
    4526. 

  4526.                $PointsBottom[] = $X2; $PointsBottom[] = $Y;
    4527. 

  4527. 

  4528.                if ( $DisplayValues )
    4529. 

  4529.                 {
    4530. 

  4530.                  $BarWidth = abs($X2-$X1);
    4531. 

  4531. 

  4532.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4533. 

  4533.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4534. 

  4534.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);
    4535. 

  4535. 

  4536.                  if ( $BarWidth > $TxtWidth )
    4537. 

  4537.                   {
    4538. 

  4538.                    $XCenter  = $X1 + $BarWidth / 2;
    4539. 

  4539.                    $YCenter  = $Y;
    4540. 

  4540. 

  4541.                    $Labels[] = array($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));
    4542. 

  4542.                   }
    4543. 

  4543.                 }
    4544. 

  4544. 

  4545.                $LastX[$Key][$Pos] = $X2;
    4546. 

  4546.               }
    4547. 

  4547.              else
    4548. 

  4548.               { $PointsTop[] = $LastX[$Key][$Pos]; $PointsTop[] = $Y; $PointsBottom[] = $LastX[$Key][$Pos]; $PointsBottom[] = $Y; }
    4549. 

  4549. 

  4550.              $Y = $Y + $YStep;
    4551. 

  4551.             }
    4552. 

  4552.            $Points = $PointsTop;
    4553. 

  4553.            for($i=count($PointsBottom)-2;$i>=0;$i-=2) { $Points[] = $PointsBottom[$i]; $Points[] = $PointsBottom[$i+1]; }
    4554. 

  4554.            $this->drawPolygon($Points,$Color);
    4555. 

  4555. 

  4556. 

  4557.            /* Reset the X axis parser for the negative values pass */
    4558. 

  4558.            $Y = $this->GraphAreaY1 + $XMargin;
    4559. 

  4559. 

  4560. 

  4561.            $PointsTop = ""; $PointsBottom = ""; $Pos = "-";
    4562. 

  4562.            foreach($PosArray as $Key => $Width)
    4563. 

  4563.             {
    4564. 

  4564.              if ( !isset($LastX[$Key] ) )       { $LastX[$Key] = ""; }
    4565. 

  4565.              if ( !isset($LastX[$Key][$Pos] ) ) { $LastX[$Key][$Pos] = $YZero; }
    4566. 

  4566. 

  4567.              if ( $Width != VOID && $Serie["Data"][$Key] < 0)
    4568. 

  4568.               {
    4569. 

  4569.                $X1 = $LastX[$Key][$Pos];
    4570. 

  4570.                $X2 = $X1 + $Width;
    4571. 

  4571. 

  4572.                $PointsTop[]    = $X1; $PointsTop[]    = $Y;
    4573. 

  4573.                $PointsBottom[] = $X2; $PointsBottom[] = $Y;
    4574. 

  4574. 

  4575.                if ( $DisplayValues )
    4576. 

  4576.                 {
    4577. 

  4577.                  $BarWidth = abs($X2-$X1);
    4578. 

  4578. 

  4579.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);
    4580. 

  4580.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);
    4581. 

  4581.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);
    4582. 

  4582. 

  4583.                  if ( $BarWidth > $TxtWidth )
    4584. 

  4584.                   {
    4585. 

  4585.                    $XCenter  = $X1 - $BarWidth / 2;
    4586. 

  4586.                    $YCenter  = $Y;
    4587. 

  4587. 

  4588.                    $Labels[] = array($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));
    4589. 

  4589.                   }
    4590. 

  4590.                 }
    4591. 

  4591. 

  4592.                $LastX[$Key][$Pos] = $X2;
    4593. 

  4593.               }
    4594. 

  4594.              else
    4595. 

  4595.               { $PointsTop[] = $LastX[$Key][$Pos]; $PointsTop[] = $Y; $PointsBottom[] = $LastX[$Key][$Pos]; $PointsBottom[] = $Y; }
    4596. 

  4596. 

  4597.              $Y = $Y + $YStep;
    4598. 

  4598.             }
    4599. 

  4599.            $Points = $PointsTop;
    4600. 

  4600.            for($i=count($PointsBottom)-2;$i>=0;$i-=2) { $Points[] = $PointsBottom[$i]; $Points[] = $PointsBottom[$i+1]; }
    4601. 

  4601.            $this->drawPolygon($Points,$Color);
    4602. 

  4602. 

  4603.            if ( $DisplayValues ) { foreach($Labels as $Key => $Value) { $this->drawText($Value[0],$Value[1],$Value[2],$Value[3]);} }
    4604. 

  4604.           }
    4605. 

  4605.         }
    4606. 

  4606.       }
    4607. 

  4607.     }
    4608. 

  4608. 

  4609.    /* Returns a random color */
    4610. 

  4610.    function getRandomColor($Alpha=100)
    4611. 

  4611.     { return(array("R"=>rand(0,255),"G"=>rand(0,255),"B"=>rand(0,255),"Alpha"=>$Alpha)); }
    4612. 

  4612.  
    4613. 

  4613.    /* Validate a palette */
    4614. 

  4614.    function validatePalette($Colors,$Surrounding=NULL)
    4615. 

  4615.     {
    4616. 

  4616.      $Result = "";
    4617. 

  4617. 

  4618.      if ( !is_array($Colors) ) { return($this->getRandomColor()); }
    4619. 

  4619. 

  4620.      foreach($Colors as $Key => $Values)
    4621. 

  4621.       {
    4622. 

  4622.        if ( isset($Values["R"]) ) { $Result[$Key]["R"] = $Values["R"]; } else { $Result[$Key]["R"] = rand(0,255); }
    4623. 

  4623.        if ( isset($Values["G"]) ) { $Result[$Key]["G"] = $Values["G"]; } else { $Result[$Key]["G"] = rand(0,255); }
    4624. 

  4624.        if ( isset($Values["B"]) ) { $Result[$Key]["B"] = $Values["B"]; } else { $Result[$Key]["B"] = rand(0,255); }
    4625. 

  4625.        if ( isset($Values["Alpha"]) ) { $Result[$Key]["Alpha"] = $Values["Alpha"]; } else { $Result[$Key]["Alpha"] = 100; }
    4626. 

  4626. 

  4627.        if ( $Surrounding != NULL )
    4628. 

  4628.         {
    4629. 

  4629.          $Result[$Key]["BorderR"] = $Result[$Key]["R"] + $Surrounding;
    4630. 

  4630.          $Result[$Key]["BorderG"] = $Result[$Key]["G"] + $Surrounding;
    4631. 

  4631.          $Result[$Key]["BorderB"] = $Result[$Key]["B"] + $Surrounding;
    4632. 

  4632.         }
    4633. 

  4633.        else
    4634. 

  4634.         {
    4635. 

  4635.          if ( isset($Values["BorderR"]) )     { $Result[$Key]["BorderR"] = $Values["BorderR"]; } else { $Result[$Key]["BorderR"] = $Result[$Key]["R"]; }
    4636. 

  4636.          if ( isset($Values["BorderG"]) )     { $Result[$Key]["BorderG"] = $Values["BorderG"]; } else { $Result[$Key]["BorderG"] = $Result[$Key]["G"]; }
    4637. 

  4637.          if ( isset($Values["BorderB"]) )     { $Result[$Key]["BorderB"] = $Values["BorderB"]; } else { $Result[$Key]["BorderB"] = $Result[$Key]["B"]; }
    4638. 

  4638.          if ( isset($Values["BorderAlpha"]) ) { $Result[$Key]["BorderAlpha"] = $Values["BorderAlpha"]; } else { $Result[$Key]["BorderAlpha"] = $Result[$Key]["Alpha"]; }
    4639. 

  4639.         }
    4640. 

  4640.       }
    4641. 

  4641. 

  4642.      return($Result);
    4643. 

  4643.     }
    4644. 

  4644. 

  4645.    /* Draw the derivative chart associated to the data series */
    4646. 

  4646.    function drawDerivative($Format=NULL)
    4647. 

  4647.     {
    4648. 

  4648.      $Offset		= isset($Format["Offset"]) ? $Format["Offset"] : 10;
    4649. 

  4649.      $SerieSpacing	= isset($Format["SerieSpacing"]) ? $Format["SerieSpacing"] : 3;
    4650. 

  4650.      $DerivativeHeight	= isset($Format["DerivativeHeight"]) ? $Format["DerivativeHeight"] : 4;
    4651. 

  4651.      $ShadedSlopeBox	= isset($Format["ShadedSlopeBox"]) ? $Format["ShadedSlopeBox"] : FALSE;
    4652. 

  4652.      $DrawBackground	= isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : TRUE;
    4653. 

  4653.      $BackgroundR	= isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;
    4654. 

  4654.      $BackgroundG	= isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;
    4655. 

  4655.      $BackgroundB	= isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;
    4656. 

  4656.      $BackgroundAlpha	= isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 20;
    4657. 

  4657.      $DrawBorder	= isset($Format["DrawBorder"]) ? $Format["DrawBorder"] : TRUE;
    4658. 

  4658.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 0;
    4659. 

  4659.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 0;
    4660. 

  4660.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 0;
    4661. 

  4661.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 100;
    4662. 

  4662.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : TRUE;
    4663. 

  4663.      $CaptionHeight	= isset($Format["CaptionHeight"]) ? $Format["CaptionHeight"] : 10;
    4664. 

  4664.      $CaptionWidth	= isset($Format["CaptionWidth"]) ? $Format["CaptionWidth"] : 20;
    4665. 

  4665.      $CaptionMargin	= isset($Format["CaptionMargin"]) ? $Format["CaptionMargin"] : 4;
    4666. 

  4666.      $CaptionLine	= isset($Format["CaptionLine"]) ? $Format["CaptionLine"] : FALSE;
    4667. 

  4667.      $CaptionBox	= isset($Format["CaptionBox"]) ? $Format["CaptionBox"] : FALSE;
    4668. 

  4668.      $CaptionBorderR	= isset($Format["CaptionBorderR"]) ? $Format["CaptionBorderR"] : 0;
    4669. 

  4669.      $CaptionBorderG	= isset($Format["CaptionBorderG"]) ? $Format["CaptionBorderG"] : 0;
    4670. 

  4670.      $CaptionBorderB	= isset($Format["CaptionBorderB"]) ? $Format["CaptionBorderB"] : 0;
    4671. 

  4671.      $CaptionFillR	= isset($Format["CaptionFillR"]) ? $Format["CaptionFillR"] : 255;
    4672. 

  4672.      $CaptionFillG	= isset($Format["CaptionFillG"]) ? $Format["CaptionFillG"] : 255;
    4673. 

  4673.      $CaptionFillB	= isset($Format["CaptionFillB"]) ? $Format["CaptionFillB"] : 255;
    4674. 

  4674.      $CaptionFillAlpha	= isset($Format["CaptionFillAlpha"]) ? $Format["CaptionFillAlpha"] : 80;
    4675. 

  4675.      $PositiveSlopeStartR	= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 184;
    4676. 

  4676.      $PositiveSlopeStartG	= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 234;
    4677. 

  4677.      $PositiveSlopeStartB	= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 88;
    4678. 

  4678.      $PositiveSlopeEndR		= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 239;
    4679. 

  4679.      $PositiveSlopeEndG		= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 31;
    4680. 

  4680.      $PositiveSlopeEndB		= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 36;
    4681. 

  4681.      $NegativeSlopeStartR	= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 184;
    4682. 

  4682.      $NegativeSlopeStartG	= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 234;
    4683. 

  4683.      $NegativeSlopeStartB	= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 88;
    4684. 

  4684.      $NegativeSlopeEndR		= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 67;
    4685. 

  4685.      $NegativeSlopeEndG		= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 124;
    4686. 

  4686.      $NegativeSlopeEndB		= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 227;
    4687. 

  4687. 

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

  4689. 

  4690.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    4691. 

  4691. 

  4692.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    4693. 

  4693.       $YPos = $this->DataSet->Data["GraphArea"]["Y2"] + $Offset;
    4694. 

  4694.      else
    4695. 

  4695.       $XPos = $this->DataSet->Data["GraphArea"]["X2"] + $Offset;
    4696. 

  4696. 

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

  4698.       {
    4699. 

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

  4700.         {
    4701. 

  4701.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];
    4702. 

  4702. 

  4703.          $AxisID   = $Serie["Axis"];
    4704. 

  4704.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    4705. 

  4705. 

  4706.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    4707. 

  4707.           {
    4708. 

  4708.            if ( $Caption )
    4709. 

  4709.             {
    4710. 

  4710.              if ( $CaptionLine ) 
    4711. 

  4711.               {
    4712. 

  4712.                $StartX = floor($this->GraphAreaX1-$CaptionWidth+$XMargin-$CaptionMargin);
    4713. 

  4713.                $EndX   = floor($this->GraphAreaX1-$CaptionMargin+$XMargin);
    4714. 

  4714. 

  4715.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);
    4716. 

  4716.                if ( $CaptionBox ) { $this->drawFilledRectangle($StartX,$YPos,$EndX,$YPos+$CaptionHeight,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }
    4717. 

  4717.                $this->drawLine($StartX+2,$YPos+($CaptionHeight/2),$EndX-2,$YPos+($CaptionHeight/2),$CaptionSettings);
    4718. 

  4718.               }
    4719. 

  4719.              else
    4720. 

  4720.               $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));
    4721. 

  4721.             }
    4722. 

  4722. 

  4723.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    4724. 

  4724.            $X = $this->GraphAreaX1 + $XMargin;
    4725. 

  4725. 

  4726.            $TopY    = $YPos + ($CaptionHeight/2) - ($DerivativeHeight/2);
    4727. 

  4727.            $BottomY = $YPos + ($CaptionHeight/2) + ($DerivativeHeight/2);
    4728. 

  4728. 

  4729.            $StartX  = floor($this->GraphAreaX1+$XMargin);
    4730. 

  4730.            $EndX    = floor($this->GraphAreaX2-$XMargin);
    4731. 

  4731. 

  4732.            if ( $DrawBackground ) { $this->drawFilledRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }
    4733. 

  4733.            if ( $DrawBorder ) { $this->drawRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }
    4734. 

  4734. 

  4735.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4736. 

  4736. 

  4737.            $RestoreShadow = $this->Shadow;
    4738. 

  4738.            $this->Shadow  = FALSE;
    4739. 

  4739. 

  4740.            /* Determine the Max slope index */
    4741. 

  4741.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;
    4742. 

  4742.            foreach($PosArray as $Key => $Y)
    4743. 

  4743.             {
    4744. 

  4744.              if ( $Y != VOID && $LastX != NULL )
    4745. 

  4745.               { $Slope = ($LastY - $Y); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }
    4746. 

  4746. 

  4747.              if ( $Y == VOID )
    4748. 

  4748.               { $LastX = NULL; $LastY = NULL; }
    4749. 

  4749.              else
    4750. 

  4750.               { $LastX = $X; $LastY = $Y; }
    4751. 

  4751.             }
    4752. 

  4752. 

  4753.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;
    4754. 

  4754.            foreach($PosArray as $Key => $Y)
    4755. 

  4755.             {
    4756. 

  4756.              if ( $Y != VOID && $LastY != NULL )
    4757. 

  4757.               {
    4758. 

  4758.                $Slope = ($LastY - $Y);
    4759. 

  4759. 

  4760.                if ( $Slope >= 0 )
    4761. 

  4761.                 {
    4762. 

  4762.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;
    4763. 

  4763.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;
    4764. 

  4764.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;
    4765. 

  4765.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;
    4766. 

  4766.                 }
    4767. 

  4767.                elseif ( $Slope < 0 )
    4768. 

  4768.                 {
    4769. 

  4769.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);
    4770. 

  4770.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;
    4771. 

  4771.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;
    4772. 

  4772.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;
    4773. 

  4773.                 }
    4774. 

  4774. 

  4775.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);
    4776. 

  4776. 

  4777.                if ( $ShadedSlopeBox && $LastColor != NULL ) // && $Slope != 0
    4778. 

  4778.                 {
    4779. 

  4779.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);
    4780. 

  4780.                  $this->drawGradientArea($LastX,$TopY,$X,$BottomY,DIRECTION_HORIZONTAL,$GradientSettings);
    4781. 

  4781.                 }
    4782. 

  4782.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) // || $Slope == 0
    4783. 

  4783.                 $this->drawFilledRectangle(floor($LastX),$TopY,floor($X),$BottomY,$Color);
    4784. 

  4784. 

  4785.                $LastColor = $Color;
    4786. 

  4786.               }
    4787. 

  4787. 

  4788.              if ( $Y == VOID )
    4789. 

  4789.               { $LastY = NULL; }
    4790. 

  4790.              else
    4791. 

  4791.               { $LastX = $X; $LastY = $Y; }
    4792. 

  4792. 

  4793.              $X = $X + $XStep;
    4794. 

  4794.             }
    4795. 

  4795. 

  4796.            $YPos = $YPos + $CaptionHeight + $SerieSpacing;
    4797. 

  4797.           }
    4798. 

  4798.          else
    4799. 

  4799.           {
    4800. 

  4800.            if ( $Caption )
    4801. 

  4801.             {
    4802. 

  4802.              $StartY = floor($this->GraphAreaY1-$CaptionWidth+$XMargin-$CaptionMargin);
    4803. 

  4803.              $EndY   = floor($this->GraphAreaY1-$CaptionMargin+$XMargin);
    4804. 

  4804.              if ( $CaptionLine ) 
    4805. 

  4805.               {
    4806. 

  4806.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);
    4807. 

  4807.                if ( $CaptionBox ) { $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }
    4808. 

  4808.                $this->drawLine($XPos+($CaptionHeight/2),$StartY+2,$XPos+($CaptionHeight/2),$EndY-2,$CaptionSettings);
    4809. 

  4809.               }
    4810. 

  4810.              else
    4811. 

  4811.               $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB));
    4812. 

  4812.             }
    4813. 

  4813. 

  4814. 

  4815.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    4816. 

  4816.            $Y = $this->GraphAreaY1 + $XMargin;
    4817. 

  4817. 

  4818.            $TopX    = $XPos + ($CaptionHeight/2) - ($DerivativeHeight/2);
    4819. 

  4819.            $BottomX = $XPos + ($CaptionHeight/2) + ($DerivativeHeight/2);
    4820. 

  4820. 

  4821.            $StartY  = floor($this->GraphAreaY1+$XMargin);
    4822. 

  4822.            $EndY    = floor($this->GraphAreaY2-$XMargin);
    4823. 

  4823. 

  4824.            if ( $DrawBackground ) { $this->drawFilledRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }
    4825. 

  4825.            if ( $DrawBorder ) { $this->drawRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }
    4826. 

  4826. 

  4827.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4828. 

  4828. 

  4829.            $RestoreShadow = $this->Shadow;
    4830. 

  4830.            $this->Shadow  = FALSE;
    4831. 

  4831. 

  4832.            /* Determine the Max slope index */
    4833. 

  4833.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;
    4834. 

  4834.            foreach($PosArray as $Key => $X)
    4835. 

  4835.             {
    4836. 

  4836.              if ( $X != VOID && $LastX != NULL )
    4837. 

  4837.               { $Slope = ($X - $LastX); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }
    4838. 

  4838. 

  4839.              if ( $X == VOID )
    4840. 

  4840.               { $LastX = NULL; }
    4841. 

  4841.              else
    4842. 

  4842.               { $LastX = $X; }
    4843. 

  4843.             }
    4844. 

  4844. 

  4845.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;
    4846. 

  4846.            foreach($PosArray as $Key => $X)
    4847. 

  4847.             {
    4848. 

  4848.              if ( $X != VOID && $LastX != NULL )
    4849. 

  4849.               {
    4850. 

  4850.                $Slope = ($X - $LastX);
    4851. 

  4851. 

  4852.                if ( $Slope >= 0 )
    4853. 

  4853.                 {
    4854. 

  4854.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;
    4855. 

  4855.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;
    4856. 

  4856.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;
    4857. 

  4857.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;
    4858. 

  4858.                 }
    4859. 

  4859.                elseif ( $Slope < 0 )
    4860. 

  4860.                 {
    4861. 

  4861.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);
    4862. 

  4862.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;
    4863. 

  4863.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;
    4864. 

  4864.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;
    4865. 

  4865.                 }
    4866. 

  4866. 

  4867.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);
    4868. 

  4868. 

  4869.                if ( $ShadedSlopeBox && $LastColor != NULL )
    4870. 

  4870.                 {
    4871. 

  4871.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);
    4872. 

  4872. 

  4873.                  $this->drawGradientArea($TopX,$LastY,$BottomX,$Y,DIRECTION_VERTICAL,$GradientSettings);
    4874. 

  4874.                 }
    4875. 

  4875.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) 
    4876. 

  4876.                 $this->drawFilledRectangle($TopX,floor($LastY),$BottomX,floor($Y),$Color);
    4877. 

  4877. 

  4878.                $LastColor = $Color;
    4879. 

  4879.               }
    4880. 

  4880. 

  4881.              if ( $X == VOID )
    4882. 

  4882.               { $LastX = NULL; }
    4883. 

  4883.              else
    4884. 

  4884.               { $LastX = $X; $LastY = $Y; }
    4885. 

  4885. 

  4886.              $Y = $Y + $XStep;
    4887. 

  4887.             }
    4888. 

  4888. 

  4889.            $XPos = $XPos + $CaptionHeight + $SerieSpacing;
    4890. 

  4890.           }
    4891. 

  4891. 

  4892.          $this->Shadow = $RestoreShadow;
    4893. 

  4893.         }
    4894. 

  4894.       }
    4895. 

  4895.     }
    4896. 

  4896. 

  4897.    /* Draw the line of best fit */
    4898. 

  4898.    function drawBestFit($Format="")
    4899. 

  4899.     {
    4900. 

  4900.      $OverrideTicks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    4901. 

  4901.      $OverrideR		= isset($Format["R"]) ? $Format["R"] : VOID;
    4902. 

  4902.      $OverrideG		= isset($Format["G"]) ? $Format["G"] : VOID;
    4903. 

  4903.      $OverrideB		= isset($Format["B"]) ? $Format["B"] : VOID;
    4904. 

  4904.      $OverrideAlpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : VOID;
    4905. 

  4905. 

  4906.      $Data = $this->DataSet->getData();
    4907. 

  4907.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    4908. 

  4908. 

  4909.      foreach($Data["Series"] as $SerieName => $Serie)
    4910. 

  4910.       {
    4911. 

  4911.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )
    4912. 

  4912.         {
    4913. 

  4913.          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"]; }
    4914. 

  4914.          if ( $OverrideTicks == NULL ) { $Ticks = $Serie["Ticks"]; } else { $Ticks = $OverrideTicks; }
    4915. 

  4915.          if ( $OverrideAlpha == VOID ) { $Alpha = $Serie["Color"]["Alpha"]; } else { $Alpha = $OverrideAlpha; }
    4916. 

  4916. 

  4917.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks);
    4918. 

  4918. 

  4919.          $AxisID   = $Serie["Axis"];
    4920. 

  4920.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));
    4921. 

  4921. 

  4922.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    4923. 

  4923.           {
    4924. 

  4924.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    4925. 

  4925.            $X = $this->GraphAreaX1 + $XMargin;
    4926. 

  4926. 

  4927.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4928. 

  4928.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;
    4929. 

  4929.            foreach($PosArray as $Key => $Y)
    4930. 

  4930.             {
    4931. 

  4931.              $Sxy = $Sxy + $X*$Y;
    4932. 

  4932.              $Sx  = $Sx + $X;
    4933. 

  4933.              $Sy  = $Sy + $Y;
    4934. 

  4934.              $Sxx = $Sxx + $X*$X;
    4935. 

  4935. 

  4936.              $X = $X + $XStep;
    4937. 

  4937.             }
    4938. 

  4938.            $n = count($PosArray);
    4939. 

  4939.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));
    4940. 

  4940.            $B = (($Sy)-($M*$Sx))/($n);
    4941. 

  4941. 

  4942.            $X1 = $this->GraphAreaX1 + $XMargin;
    4943. 

  4943.            $Y1 = $M * $X1 + $B;
    4944. 

  4944.            $X2 = $this->GraphAreaX2 - $XMargin;
    4945. 

  4945.            $Y2 = $M * $X2 + $B;
    4946. 

  4946. 

  4947.            if ( $Y1 < $this->GraphAreaY1 ) { $X1 = $X1 + ($this->GraphAreaY1-$Y1); $Y1 = $this->GraphAreaY1; }
    4948. 

  4948.            if ( $Y1 > $this->GraphAreaY2 ) { $X1 = $X1 + ($Y1-$this->GraphAreaY2); $Y1 = $this->GraphAreaY2; }
    4949. 

  4949.            if ( $Y2 < $this->GraphAreaY1 ) { $X2 = $X2 - ($this->GraphAreaY1-$Y2); $Y2 = $this->GraphAreaY1; }
    4950. 

  4950.            if ( $Y2 > $this->GraphAreaY2 ) { $X2 = $X2 - ($Y2-$this->GraphAreaY2); $Y2 = $this->GraphAreaY2; }
    4951. 

  4951. 

  4952.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);
    4953. 

  4953.           }
    4954. 

  4954.          else
    4955. 

  4955.           {
    4956. 

  4956.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    4957. 

  4957.            $Y = $this->GraphAreaY1 + $XMargin;
    4958. 

  4958. 

  4959.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }
    4960. 

  4960.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;
    4961. 

  4961.            foreach($PosArray as $Key => $X)
    4962. 

  4962.             {
    4963. 

  4963.              $Sxy = $Sxy + $X*$Y;
    4964. 

  4964.              $Sx  = $Sx + $Y;
    4965. 

  4965.              $Sy  = $Sy + $X;
    4966. 

  4966.              $Sxx = $Sxx + $Y*$Y;
    4967. 

  4967. 

  4968.              $Y = $Y + $YStep;
    4969. 

  4969.             }
    4970. 

  4970.            $n = count($PosArray);
    4971. 

  4971.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));
    4972. 

  4972.            $B = (($Sy)-($M*$Sx))/($n);
    4973. 

  4973. 

  4974.            $Y1 = $this->GraphAreaY1 + $XMargin;
    4975. 

  4975.            $X1 = $M * $Y1 + $B;
    4976. 

  4976.            $Y2 = $this->GraphAreaY2 - $XMargin;
    4977. 

  4977.            $X2 = $M * $Y2 + $B;
    4978. 

  4978. 

  4979.            if ( $X1 < $this->GraphAreaX1 ) { $Y1 = $Y1 + ($this->GraphAreaX1-$X1); $X1 = $this->GraphAreaX1; }
    4980. 

  4980.            if ( $X1 > $this->GraphAreaX2 ) { $Y1 = $Y1 + ($X1-$this->GraphAreaX2); $X1 = $this->GraphAreaX2; }
    4981. 

  4981.            if ( $X2 < $this->GraphAreaX1 ) { $Y2 = $Y2 - ($this->GraphAreaY1-$X2); $X2 = $this->GraphAreaX1; }
    4982. 

  4982.            if ( $X2 > $this->GraphAreaX2 ) { $Y2 = $Y2 - ($X2-$this->GraphAreaX2); $X2 = $this->GraphAreaX2; }
    4983. 

  4983. 

  4984.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);
    4985. 

  4985.           }
    4986. 

  4986.         }
    4987. 

  4987.       }
    4988. 

  4988.     }
    4989. 

  4989. 

  4990.    /* Write labels */
    4991. 

  4991.    function writeLabel($SeriesName,$Indexes,$Format="")
    4992. 

  4992.     {
    4993. 

  4993.      $OverrideTitle	= isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : NULL;
    4994. 

  4994.      $ForceLabels	= isset($Format["ForceLabels"]) ? $Format["ForceLabels"] : NULL;
    4995. 

  4995.      $DrawPoint		= isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;
    4996. 

  4996.      $DrawVerticalLine	= isset($Format["DrawVerticalLine"]) ? $Format["DrawVerticalLine"] : FALSE;
    4997. 

  4997.      $VerticalLineR	= isset($Format["VerticalLineR"]) ? $Format["VerticalLineR"] : 0;
    4998. 

  4998.      $VerticalLineG	= isset($Format["VerticalLineG"]) ? $Format["VerticalLineG"] : 0;
    4999. 

  4999.      $VerticalLineB	= isset($Format["VerticalLineB"]) ? $Format["VerticalLineB"] : 0;
    5000. 

  5000.      $VerticalLineAlpha	= isset($Format["VerticalLineAlpha"]) ? $Format["VerticalLineAlpha"] : 40;
    5001. 

  5001.      $VerticalLineTicks	= isset($Format["VerticalLineTicks"]) ? $Format["VerticalLineTicks"] : 2;
    5002. 

  5002. 

  5003.      $Data = $this->DataSet->getData();
    5004. 

  5004.      list($XMargin,$XDivs) = $this->scaleGetXSettings();
    5005. 

  5005. 

  5006.      if ( !is_array($Indexes) )    { $Index = $Indexes; $Indexes = ""; $Indexes[] = $Index; }
    5007. 

  5007.      if ( !is_array($SeriesName) ) { $SerieName = $SeriesName; $SeriesName = ""; $SeriesName[] = $SerieName; }
    5008. 

  5008.      if ( $ForceLabels != NULL && !is_array($ForceLabels) ) { $ForceLabel = $ForceLabels; $ForceLabels = ""; $ForceLabels[] = $ForceLabel; }
    5009. 

  5009. 

  5010.      foreach ($Indexes as $Key => $Index)
    5011. 

  5011.       {
    5012. 

  5012.        $Series = "";
    5013. 

  5013. 

  5014.        if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )
    5015. 

  5015.         {
    5016. 

  5016.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }
    5017. 

  5017.          $X = $this->GraphAreaX1 + $XMargin + $Index * $XStep;
    5018. 

  5018. 

  5019.          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)); }
    5020. 

  5020. 

  5021.          $MinY = $this->GraphAreaY2;
    5022. 

  5022.          foreach ($SeriesName as $iKey => $SerieName)
    5023. 

  5023.           {
    5024. 

  5024.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )
    5025. 

  5025.             {
    5026. 

  5026.              $AxisID      = $Data["Series"][$SerieName]["Axis"];
    5027. 

  5027. 

  5028.              if ( $OverrideTitle != NULL)
    5029. 

  5029.               $Description = $OverrideTitle;
    5030. 

  5030.              elseif ( count($SeriesName) == 1 )
    5031. 

  5031.               {
    5032. 

  5032.                if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )
    5033. 

  5033.                 $Description = $Data["Series"][$SerieName]["Description"]." - ".$Data["Series"][$Data["Abscissa"]]["Data"][$Index];
    5034. 

  5034.                else
    5035. 

  5035.                 $Description = $Data["Series"][$SerieName]["Description"];
    5036. 

  5036.               }
    5037. 

  5037.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )
    5038. 

  5038.               $Description = $Data["Series"][$Data["Abscissa"]]["Data"][$Index];
    5039. 

  5039. 

  5040.              $AxisMode     = $Data["Axis"][$AxisID]["Display"];
    5041. 

  5041.              $AxisFormat   = $Data["Axis"][$AxisID]["Format"];
    5042. 

  5042.              $AxisUnit     = $Data["Axis"][$AxisID]["Unit"];
    5043. 

  5043. 

  5044.              $Serie = "";
    5045. 

  5045.              $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];
    5046. 

  5046.              $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];
    5047. 

  5047.              $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];
    5048. 

  5048.              $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];
    5049. 

  5049. 

  5050.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )
    5051. 

  5051.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
    5052. 

  5052.              else
    5053. 

  5053.               $SerieOffset = 0;
    5054. 

  5054. 

  5055.              $Value = $Data["Series"][$SerieName]["Data"][$Index];
    5056. 

  5056.              if ( $ForceLabels != NULL )
    5057. 

  5057.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
    5058. 

  5058.              else
    5059. 

  5059.               $Caption     = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);
    5060. 

  5060. 

  5061.              $X = floor($this->GraphAreaX1 + $XMargin + $Index * $XStep + $SerieOffset);
    5062. 

  5062.              $Y = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));
    5063. 

  5063. 

  5064.              if ($Y < $MinY) { $MinY = $Y; }
    5065. 

  5065. 

  5066.              if ( $DrawPoint == LABEL_POINT_CIRCLE )
    5067. 

  5067.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));
    5068. 

  5068.              elseif ( $DrawPoint == LABEL_POINT_BOX )
    5069. 

  5069.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));
    5070. 

  5070. 

  5071.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);
    5072. 

  5072.             }
    5073. 

  5073.           }
    5074. 

  5074.          $this->drawLabelBox($X,$MinY-3,$Description,$Series,$Format);
    5075. 

  5075. 

  5076.         }
    5077. 

  5077.        else
    5078. 

  5078.         {
    5079. 

  5079.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }
    5080. 

  5080.          $Y = $this->GraphAreaY1 + $XMargin + $Index * $XStep;
    5081. 

  5081. 

  5082.          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)); }
    5083. 

  5083. 

  5084.          $MinX = $this->GraphAreaX2;
    5085. 

  5085.          foreach ($SeriesName as $Key => $SerieName)
    5086. 

  5086.           {
    5087. 

  5087.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )
    5088. 

  5088.             {
    5089. 

  5089.              $AxisID      = $Data["Series"][$SerieName]["Axis"];
    5090. 

  5090. 

  5091.              if ( $OverrideTitle != NULL)
    5092. 

  5092.               $Description = $OverrideTitle;
    5093. 

  5093.              elseif ( count($SeriesName) == 1 )
    5094. 

  5094.               {
    5095. 

  5095.                if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )
    5096. 

  5096.                 $Description = $Data["Series"][$SerieName]["Description"]." - ".$Data["Series"][$Data["Abscissa"]]["Data"][$Index];
    5097. 

  5097.                else
    5098. 

  5098.                 $Description = $Data["Series"][$SerieName]["Description"];
    5099. 

  5099.               }
    5100. 

  5100.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )
    5101. 

  5101.               $Description = $Data["Series"][$Data["Abscissa"]]["Data"][$Index];
    5102. 

  5102. 

  5103.              $AxisMode     = $Data["Axis"][$AxisID]["Display"];
    5104. 

  5104.              $AxisFormat   = $Data["Axis"][$AxisID]["Format"];
    5105. 

  5105.              $AxisUnit     = $Data["Axis"][$AxisID]["Unit"];
    5106. 

  5106. 

  5107.              $Serie = "";
    5108. 

  5108.              if ( isset($Data["Extended"]["Palette"][$Index] ) )
    5109. 

  5109.               {
    5110. 

  5110.                $Serie["R"] = $Data["Extended"]["Palette"][$Index]["R"];
    5111. 

  5111.                $Serie["G"] = $Data["Extended"]["Palette"][$Index]["G"];
    5112. 

  5112.                $Serie["B"] = $Data["Extended"]["Palette"][$Index]["B"];
    5113. 

  5113.                $Serie["Alpha"] = $Data["Extended"]["Palette"][$Index]["Alpha"];
    5114. 

  5114.               }
    5115. 

  5115.              else
    5116. 

  5116.               {
    5117. 

  5117.                $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];
    5118. 

  5118.                $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];
    5119. 

  5119.                $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];
    5120. 

  5120.                $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];
    5121. 

  5121.               }
    5122. 

  5122. 

  5123.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )
    5124. 

  5124.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
    5125. 

  5125.              else
    5126. 

  5126.               $SerieOffset = 0;
    5127. 

  5127. 

  5128.              $Value = $Data["Series"][$SerieName]["Data"][$Index];
    5129. 

  5129.              if ( $ForceLabels != NULL )
    5130. 

  5130.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
    5131. 

  5131.              else
    5132. 

  5132.               $Caption = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);
    5133. 

  5133. 

  5134.              $X = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));
    5135. 

  5135.              $Y = floor($this->GraphAreaY1 + $XMargin + $Index * $XStep + $SerieOffset);
    5136. 

  5136. 

  5137.              if ($X < $MinX) { $MinX = $X; }
    5138. 

  5138. 

  5139.              if ( $DrawPoint == LABEL_POINT_CIRCLE )
    5140. 

  5140.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));
    5141. 

  5141.              elseif ( $DrawPoint == LABEL_POINT_BOX )
    5142. 

  5142.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));
    5143. 

  5143. 

  5144.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);
    5145. 

  5145.             }
    5146. 

  5146.           }
    5147. 

  5147.          $this->drawLabelBox($MinX,$Y-3,$Description,$Series,$Format);
    5148. 

  5148. 

  5149.         }
    5150. 

  5150.       }
    5151. 

  5151.     }
    5152. 

  5152. 

  5153.    /* Draw a label box */
    5154. 

  5154.    function drawLabelBox($X,$Y,$Title,$Captions,$Format="")
    5155. 

  5155.     {
    5156. 

  5156.      $NoTitle		= isset($Format["NoTitle"]) ? $Format["NoTitle"] : NULL;
    5157. 

  5157.      $BoxWidth		= isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 50;
    5158. 

  5158.      $DrawSerieColor	= isset($Format["DrawSerieColor"]) ? $Format["DrawSerieColor"] : TRUE;
    5159. 

  5159.      $SerieR		= isset($Format["SerieR"]) ? $Format["SerieR"] : NULL;
    5160. 

  5160.      $SerieG		= isset($Format["SerieG"]) ? $Format["SerieG"] : NULL;
    5161. 

  5161.      $SerieB		= isset($Format["SerieB"]) ? $Format["SerieB"] : NULL;
    5162. 

  5162.      $SerieAlpha	= isset($Format["SerieAlpha"]) ? $Format["SerieAlpha"] : NULL;
    5163. 

  5163.      $SerieBoxSize	= isset($Format["SerieBoxSize"]) ? $Format["SerieBoxSize"] : 6;
    5164. 

  5164.      $SerieBoxSpacing	= isset($Format["SerieBoxSpacing"]) ? $Format["SerieBoxSpacing"] : 4;
    5165. 

  5165.      $VerticalMargin	= isset($Format["VerticalMargin"]) ? $Format["VerticalMargin"] : 10;
    5166. 

  5166.      $HorizontalMargin	= isset($Format["HorizontalMargin"]) ? $Format["HorizontalMargin"] : 8;
    5167. 

  5167.      $R			= isset($Format["R"]) ? $Format["R"] : $this->FontColorR;
    5168. 

  5168.      $G			= isset($Format["G"]) ? $Format["G"] : $this->FontColorG;
    5169. 

  5169.      $B			= isset($Format["B"]) ? $Format["B"] : $this->FontColorB;
    5170. 

  5170.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;
    5171. 

  5171.      $FontName		= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    5172. 

  5172.      $FontSize		= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    5173. 

  5173.      $TitleMode		= isset($Format["TitleMode"]) ? $Format["TitleMode"] : LABEL_TITLE_NOBACKGROUND;
    5174. 

  5174.      $TitleR		= isset($Format["TitleR"]) ? $Format["TitleR"] : $R;
    5175. 

  5175.      $TitleG		= isset($Format["TitleG"]) ? $Format["TitleG"] : $G;
    5176. 

  5176.      $TitleB		= isset($Format["TitleB"]) ? $Format["TitleB"] : $B;
    5177. 

  5177.      $TitleBackgroundR	= isset($Format["TitleBackgroundR"]) ? $Format["TitleBackgroundR"] : 0;
    5178. 

  5178.      $TitleBackgroundG	= isset($Format["TitleBackgroundG"]) ? $Format["TitleBackgroundG"] : 0;
    5179. 

  5179.      $TitleBackgroundB	= isset($Format["TitleBackgroundB"]) ? $Format["TitleBackgroundB"] : 0;
    5180. 

  5180.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    5181. 

  5181.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    5182. 

  5182.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    5183. 

  5183.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 220;
    5184. 

  5184.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 220;
    5185. 

  5185.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 220;
    5186. 

  5186. 

  5187.      if ( !$DrawSerieColor ) { $SerieBoxSize = 0; $SerieBoxSpacing = 0; }
    5188. 

  5188. 

  5189.      $TxtPos      = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Title);
    5190. 

  5190.      $TitleWidth  = ($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2;
    5191. 

  5191.      $TitleHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);
    5192. 

  5192. 

  5193.      if ( $NoTitle ) { $TitleWidth = 0; $TitleHeight = 0; }
    5194. 

  5194. 

  5195.      $CaptionWidth = 0; $CaptionHeight = -$HorizontalMargin;
    5196. 

  5196.      foreach($Captions as $Key =>$Caption)
    5197. 

  5197.       {
    5198. 

  5198.        $TxtPos        = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Caption["Caption"]);
    5199. 

  5199.        $CaptionWidth  = max($CaptionWidth,($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2);
    5200. 

  5200.        $CaptionHeight = $CaptionHeight + max(($TxtPos[0]["Y"] - $TxtPos[2]["Y"]),($SerieBoxSize+2)) + $HorizontalMargin;
    5201. 

  5201.       }
    5202. 

  5202. 

  5203.      if ( $CaptionHeight <= 5 ) { $CaptionHeight = $CaptionHeight + $HorizontalMargin/2; }
    5204. 

  5204. 

  5205.      if ( $DrawSerieColor ) { $CaptionWidth = $CaptionWidth + $SerieBoxSize + $SerieBoxSpacing; }
    5206. 

  5206. 

  5207.      $BoxWidth = max($BoxWidth,$TitleWidth,$CaptionWidth);
    5208. 

  5208. 

  5209.      $XMin = $X - 5 - floor(($BoxWidth-10) / 2);
    5210. 

  5210.      $XMax = $X + 5 + floor(($BoxWidth-10) / 2);
    5211. 

  5211. 

  5212.      $RestoreShadow = $this->Shadow;
    5213. 

  5213.      if ( $this->Shadow == TRUE )
    5214. 

  5214.       {
    5215. 

  5215.        $this->Shadow = FALSE;
    5216. 

  5216. 

  5217.        $Poly = "";
    5218. 

  5218.        $Poly[] = $X+$this->ShadowX; $Poly[] = $Y+$this->ShadowX;
    5219. 

  5219.        $Poly[] = $X+5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;
    5220. 

  5220.        $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;
    5221. 

  5221. 

  5222.        if ( $NoTitle )
    5223. 

  5223.         {
    5224. 

  5224.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;
    5225. 

  5225.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;
    5226. 

  5226.         }
    5227. 

  5227.        else
    5228. 

  5228.         {
    5229. 

  5229.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;
    5230. 

  5230.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;
    5231. 

  5231.         }
    5232. 

  5232. 

  5233.        $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;
    5234. 

  5234.        $Poly[] = $X-5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;
    5235. 

  5235.        $this->drawPolygon($Poly,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));
    5236. 

  5236.       }
    5237. 

  5237. 

  5238.      /* Draw the background */
    5239. 

  5239.      $GradientSettings = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB);
    5240. 

  5240.      if ( $NoTitle )
    5241. 

  5241.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);
    5242. 

  5242.      else
    5243. 

  5243.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);
    5244. 

  5244.      $Poly = ""; $Poly[] = $X; $Poly[] = $Y; $Poly[] = $X-5; $Poly[] = $Y-5; $Poly[] = $X+5; $Poly[] = $Y-5;
    5245. 

  5245.      $this->drawPolygon($Poly,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB,"NoBorder"=>TRUE));
    5246. 

  5246. 

  5247.      /* Outer border */
    5248. 

  5248.      $OuterBorderColor = $this->allocateColor($this->Picture,100,100,100,100);
    5249. 

  5249.      imageline($this->Picture,$XMin,$Y-5,$X-5,$Y-5,$OuterBorderColor);
    5250. 

  5250.      imageline($this->Picture,$X,$Y,$X-5,$Y-5,$OuterBorderColor);
    5251. 

  5251.      imageline($this->Picture,$X,$Y,$X+5,$Y-5,$OuterBorderColor);
    5252. 

  5252.      imageline($this->Picture,$X+5,$Y-5,$XMax,$Y-5,$OuterBorderColor);
    5253. 

  5253.      if ( $NoTitle )
    5254. 

  5254.       {
    5255. 

  5255.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin,$Y-5,$OuterBorderColor);
    5256. 

  5256.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5,$OuterBorderColor);
    5257. 

  5257.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$OuterBorderColor);
    5258. 

  5258.       }
    5259. 

  5259.      else
    5260. 

  5260.       {
    5261. 

  5261.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin,$Y-5,$OuterBorderColor);
    5262. 

  5262.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5,$OuterBorderColor);
    5263. 

  5263.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$OuterBorderColor);
    5264. 

  5264.       }
    5265. 

  5265. 

  5266.      /* Inner border */
    5267. 

  5267.      $InnerBorderColor = $this->allocateColor($this->Picture,255,255,255,100);
    5268. 

  5268.      imageline($this->Picture,$XMin+1,$Y-6,$X-5,$Y-6,$InnerBorderColor);
    5269. 

  5269.      imageline($this->Picture,$X,$Y-1,$X-5,$Y-6,$InnerBorderColor);
    5270. 

  5270.      imageline($this->Picture,$X,$Y-1,$X+5,$Y-6,$InnerBorderColor);
    5271. 

  5271.      imageline($this->Picture,$X+5,$Y-6,$XMax-1,$Y-6,$InnerBorderColor);
    5272. 

  5272.      if ( $NoTitle )
    5273. 

  5273.       {
    5274. 

  5274.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin+1,$Y-6,$InnerBorderColor);
    5275. 

  5275.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-6,$InnerBorderColor);
    5276. 

  5276.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$InnerBorderColor);
    5277. 

  5277.       }
    5278. 

  5278.      else
    5279. 

  5279.       {
    5280. 

  5280.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin+1,$Y-6,$InnerBorderColor);
    5281. 

  5281.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-6,$InnerBorderColor);
    5282. 

  5282.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$InnerBorderColor);
    5283. 

  5283.       }
    5284. 

  5284. 

  5285.      /* Draw the separator line */
    5286. 

  5286.      if ( $TitleMode == LABEL_TITLE_NOBACKGROUND && !$NoTitle )
    5287. 

  5287.       {
    5288. 

  5288.        $YPos    = $Y-7-$CaptionHeight-$HorizontalMargin-$HorizontalMargin/2;
    5289. 

  5289.        $XMargin = $VerticalMargin / 2;
    5290. 

  5290.        $this->drawLine($XMin+$XMargin,$YPos+1,$XMax-$XMargin,$YPos+1,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB));
    5291. 

  5291.        $this->drawLine($XMin+$XMargin,$YPos,$XMax-$XMargin,$YPos,array("R"=>$GradientStartR,"G"=>$GradientStartG,"B"=>$GradientStartB));
    5292. 

  5292.       }
    5293. 

  5293.      elseif ( $TitleMode == LABEL_TITLE_BACKGROUND )
    5294. 

  5294.       {
    5295. 

  5295.        $this->drawFilledRectangle($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2,array("R"=>$TitleBackgroundR,"G"=>$TitleBackgroundG,"B"=>$TitleBackgroundB));
    5296. 

  5296.        imageline($this->Picture,$XMin+1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$XMax-1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$InnerBorderColor);
    5297. 

  5297.       }
    5298. 

  5298. 

  5299.      /* Write the description */
    5300. 

  5300.      if ( !$NoTitle )
    5301. 

  5301.       $this->drawText($XMin+$VerticalMargin,$Y-7-$CaptionHeight-$HorizontalMargin*2,$Title,array("Align"=>TEXT_ALIGN_BOTTOMLEFT,"R"=>$TitleR,"G"=>$TitleG,"B"=>$TitleB));
    5302. 

  5302. 

  5303.      /* Write the value */
    5304. 

  5304.      $YPos = $Y-5-$HorizontalMargin; $XPos = $XMin+$VerticalMargin+$SerieBoxSize+$SerieBoxSpacing;
    5305. 

  5305.      foreach($Captions as $Key => $Caption)
    5306. 

  5306.       {
    5307. 

  5307.        $CaptionTxt    = $Caption["Caption"];
    5308. 

  5308.        $TxtPos        = $this->getTextBox($XPos,$YPos,$FontName,$FontSize,0,$CaptionTxt);
    5309. 

  5309.        $CaptionHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);
    5310. 

  5310. 

  5311.        /* Write the serie color if needed */
    5312. 

  5312.        if ( $DrawSerieColor )
    5313. 

  5313.         {
    5314. 

  5314.          $BoxSettings = array("R"=>$Caption["Format"]["R"],"G"=>$Caption["Format"]["G"],"B"=>$Caption["Format"]["B"],"Alpha"=>$Caption["Format"]["Alpha"],"BorderR"=>0,"BorderG"=>0,"BorderB"=>0);
    5315. 

  5315.          $this->drawFilledRectangle($XMin+$VerticalMargin,$YPos-$SerieBoxSize,$XMin+$VerticalMargin+$SerieBoxSize,$YPos,$BoxSettings);
    5316. 

  5316.         }
    5317. 

  5317. 

  5318.        $this->drawText($XPos,$YPos,$CaptionTxt,array("Align"=>TEXT_ALIGN_BOTTOMLEFT));
    5319. 

  5319. 

  5320.        $YPos = $YPos - $CaptionHeight - $HorizontalMargin;
    5321. 

  5321.       }
    5322. 

  5322. 

  5323.      $this->Shadow = $RestoreShadow;
    5324. 

  5324.     }
    5325. 

  5325. 

  5326.    /* Draw a basic shape */
    5327. 

  5327.    function drawShape($X,$Y,$Shape,$PlotSize,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha)
    5328. 

  5328.     {
    5329. 

  5329.      if ( $Shape == SERIE_SHAPE_FILLEDCIRCLE )
    5330. 

  5330.       {
    5331. 

  5331.        if ( $PlotBorder ) { $this->drawFilledCircle($X,$Y,$PlotSize+$BorderSize,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }
    5332. 

  5332.        $this->drawFilledCircle($X,$Y,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5333. 

  5333.       }
    5334. 

  5334.      elseif ( $Shape == SERIE_SHAPE_FILLEDSQUARE )
    5335. 

  5335.       {
    5336. 

  5336.        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)); }
    5337. 

  5337.        $this->drawFilledRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5338. 

  5338.       }
    5339. 

  5339.      elseif ( $Shape == SERIE_SHAPE_FILLEDTRIANGLE )
    5340. 

  5340.       {
    5341. 

  5341.        if ( $PlotBorder )
    5342. 

  5342.         {
    5343. 

  5343.          $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize-$BorderSize; $Pos[]=$X-$PlotSize-$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize; $Pos[]=$X+$PlotSize+$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize;
    5344. 

  5344.          $this->drawPolygon($Pos,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha));
    5345. 

  5345.         }
    5346. 

  5346. 

  5347.        $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X-$PlotSize; $Pos[]=$Y+$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y+$PlotSize;
    5348. 

  5348.        $this->drawPolygon($Pos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5349. 

  5349.       }
    5350. 

  5350.      elseif ( $Shape == SERIE_SHAPE_TRIANGLE )
    5351. 

  5351.       {
    5352. 

  5352.        $this->drawLine($X,$Y-$PlotSize,$X-$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5353. 

  5353.        $this->drawLine($X-$PlotSize,$Y+$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5354. 

  5354.        $this->drawLine($X+$PlotSize,$Y+$PlotSize,$X,$Y-$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5355. 

  5355.       }
    5356. 

  5356.      elseif ( $Shape == SERIE_SHAPE_SQUARE )
    5357. 

  5357.       $this->drawRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5358. 

  5358.      elseif ( $Shape == SERIE_SHAPE_CIRCLE )
    5359. 

  5359.       $this->drawCircle($X,$Y,$PlotSize,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    5360. 

  5360.       
    5361. 

  5361.     }
    5362. 

  5362.   }
    5363. 

  5363. ?>
    5364.