PageRenderTime 142ms CodeModel.GetById 38ms RepoModel.GetById 1ms app.codeStats 1ms

/lib/pChart2.1.4/class/pDraw.class.php

https://bitbucket.org/aditsaxena/php_grossing_film_chart
PHP | 6216 lines | 5040 code | 1048 blank | 128 comment | 2380 complexity | 0b9bbffe4c457652343862347e1357ef MD5 | raw file
    

  1. <?php

    2. 

  2.  /*

    3. 

  3.      pDraw - class extension with drawing methods

    4. 

  4. 

    5. 

  5.      Version     : 2.1.4

    6. 

  6.      Made by     : Jean-Damien POGOLOTTI

    7. 

  7.      Last Update : 19/01/2014

    8. 

  8. 

    9. 

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

    10. 

  10. 

    11. 

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

    12. 

  12. 

    13. 

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

    14. 

  14.  */

    15. 

  15. 

    16. 

  16.  define("DIRECTION_VERTICAL"		, 690001);

    17. 

  17.  define("DIRECTION_HORIZONTAL"		, 690002);

    18. 

  18. 

    19. 

  19.  define("SCALE_POS_LEFTRIGHT"		, 690101);

    20. 

  20.  define("SCALE_POS_TOPBOTTOM"		, 690102);

    21. 

  21. 

    22. 

  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. 

  28.  define("SCALE_SKIP_NONE"		, 690301);

    29. 

  29.  define("SCALE_SKIP_SAME"		, 690302);

    30. 

  30.  define("SCALE_SKIP_NUMBERS"		, 690303);

    31. 

  31. 

    32. 

  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. 

  42.  define("POSITION_TOP"                  , 690501);

    43. 

  43.  define("POSITION_BOTTOM"               , 690502);

    44. 

  44. 

    45. 

  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. 

  53.  define("ORIENTATION_HORIZONTAL"	, 690701);

    54. 

  54.  define("ORIENTATION_VERTICAL"		, 690702);

    55. 

  55.  define("ORIENTATION_AUTO"		, 690703);

    56. 

  56. 

    57. 

  57.  define("LEGEND_NOBORDER"		, 690800);

    58. 

  58.  define("LEGEND_BOX"			, 690801);

    59. 

  59.  define("LEGEND_ROUND"			, 690802);

    60. 

  60. 

    61. 

  61.  define("LEGEND_VERTICAL"		, 690901);

    62. 

  62.  define("LEGEND_HORIZONTAL"		, 690902);

    63. 

  63. 

    64. 

  64.  define("LEGEND_FAMILY_BOX"		, 691051);

    65. 

  65.  define("LEGEND_FAMILY_CIRCLE"		, 691052);

    66. 

  66.  define("LEGEND_FAMILY_LINE"		, 691053);

    67. 

  67. 

    68. 

  68.  define("DISPLAY_AUTO"			, 691001);

    69. 

  69.  define("DISPLAY_MANUAL"		, 691002);

    70. 

  70. 

    71. 

  71.  define("LABELING_ALL"			, 691011);

    72. 

  72.  define("LABELING_DIFFERENT"		, 691012);

    73. 

  73. 

    74. 

  74.  define("BOUND_MIN"			, 691021);

    75. 

  75.  define("BOUND_MAX"			, 691022);

    76. 

  76.  define("BOUND_BOTH"			, 691023);

    77. 

  77. 

    78. 

  78.  define("BOUND_LABEL_POS_TOP"		, 691031);

    79. 

  79.  define("BOUND_LABEL_POS_BOTTOM"	, 691032);

    80. 

  80.  define("BOUND_LABEL_POS_AUTO"		, 691033);

    81. 

  81. 

    82. 

  82.  define("CAPTION_LEFT_TOP"		, 691041);

    83. 

  83.  define("CAPTION_RIGHT_BOTTOM"		, 691042);

    84. 

  84. 

    85. 

  85.  define("GRADIENT_SIMPLE"		, 691051);

    86. 

  86.  define("GRADIENT_EFFECT_CAN"		, 691052);

    87. 

  87. 

    88. 

  88.  define("LABEL_TITLE_NOBACKGROUND"	, 691061);

    89. 

  89.  define("LABEL_TITLE_BACKGROUND"	, 691062);

    90. 

  90. 

    91. 

  91.  define("LABEL_POINT_NONE"		, 691071);

    92. 

  92.  define("LABEL_POINT_CIRCLE"		, 691072);

    93. 

  93.  define("LABEL_POINT_BOX"		, 691073);

    94. 

  94. 

    95. 

  95.  define("ZONE_NAME_ANGLE_AUTO"		, 691081);

    96. 

  96. 

    97. 

  97.  define("PI"		, 3.14159265);

    98. 

  98.  define("ALL"		, 69);

    99. 

  99.  define("NONE"		, 31);

    100. 

  100.  define("AUTO"		, 690000);

    101. 

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

    102. 

  102. 

    103. 

  103.  class pDraw

    104. 

  104.   {

    105. 

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

    106. 

  106.    function countDrawableSeries()

    107. 

  107.     {

    108. 

  108.      $Results = 0;

    109. 

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

    110. 

  110. 

    111. 

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

    112. 

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

    113. 

  113. 

    114. 

  114.      return($Results);

    115. 

  115.     }

    116. 

  116. 

    117. 

  117.    /* Fix box coordinates */

    118. 

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

    119. 

  119.     {

    120. 

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

    121. 

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

    122. 

  122. 

    123. 

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

    124. 

  124.     }

    125. 

  125. 

    126. 

  126.    /* Draw a polygon */

    127. 

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

    128. 

  128.     {

    129. 

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

    130. 

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

    131. 

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

    132. 

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

    133. 

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

    134. 

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

    135. 

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

    136. 

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

    137. 

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

    138. 

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

    139. 

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

    140. 

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

    141. 

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

    142. 

  142. 

    143. 

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

    144. 

  144.      $Backup = $Points;

    145. 

  145. 

    146. 

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

    147. 

  147. 

    148. 

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

    149. 

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

    150. 

  150. 

    151. 

  151.      $RestoreShadow = $this->Shadow;

    152. 

  152.      if ( !$NoFill )

    153. 

  153.       {

    154. 

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

    155. 

  155.         {

    156. 

  156.          $this->Shadow = FALSE;

    157. 

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

    158. 

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

    159. 

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

    160. 

  160.         }

    161. 

  161. 

    162. 

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

    163. 

  163. 

    164. 

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

    165. 

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

    166. 

  166.       }

    167. 

  167. 

    168. 

  168.      if ( !$NoBorder )

    169. 

  169.       {

    170. 

  170.        $Points = $Backup;

    171. 

  171. 

    172. 

  172.        if ( $NoFill )

    173. 

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

    174. 

  174.        else

    175. 

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

    176. 

  176. 

    177. 

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

    178. 

  178.         {

    179. 

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

    180. 

  180.           {

    181. 

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

    182. 

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

    183. 

  183.           }

    184. 

  184.          else

    185. 

  185.           {

    186. 

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

    187. 

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

    188. 

  188.           }

    189. 

  189.         }

    190. 

  190.       }

    191. 

  191. 

    192. 

  192.      $this->Shadow = $RestoreShadow;

    193. 

  193.     }

    194. 

  194. 

    195. 

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

    196. 

  196.    function offsetCorrection($Value,$Mode)

    197. 

  197.     {

    198. 

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

    199. 

  199. 

    200. 

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

    201. 

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

    202. 

  202. 

    203. 

  203.      if ( $Mode == 1) 

    204. 

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

    205. 

  205. 

    206. 

  206.      if ( $Mode == 2) 

    207. 

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

    208. 

  208. 

    209. 

  209.      if ( $Mode == 3) 

    210. 

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

    211. 

  211. 

    212. 

  212.      if ( $Mode == 4) 

    213. 

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

    214. 

  214.     }

    215. 

  215. 

    216. 

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

    217. 

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

    218. 

  218.     {

    219. 

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

    220. 

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

    221. 

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

    222. 

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

    223. 

  223. 

    224. 

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

    225. 

  225. 

    226. 

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

    227. 

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

    228. 

  228. 

    229. 

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

    230. 

  230. 

    231. 

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

    232. 

  232. 

    233. 

  233.      if ( $this->Antialias )

    234. 

  234.       {

    235. 

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

    236. 

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

    237. 

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

    238. 

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

    239. 

  239.       }

    240. 

  240.      else

    241. 

  241.       {

    242. 

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

    243. 

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

    244. 

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

    245. 

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

    246. 

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

    247. 

  247.       }

    248. 

  248. 

    249. 

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

    250. 

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

    251. 

  251.       {

    252. 

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

    253. 

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

    254. 

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

    255. 

  255. 

    256. 

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

    257. 

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

    258. 

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

    259. 

  259. 

    260. 

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

    261. 

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

    262. 

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

    263. 

  263. 

    264. 

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

    265. 

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

    266. 

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

    267. 

  267.       }

    268. 

  268.     }

    269. 

  269. 

    270. 

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

    271. 

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

    272. 

  272.     {

    273. 

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

    274. 

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

    275. 

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

    276. 

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

    277. 

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

    278. 

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

    279. 

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

    280. 

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

    281. 

  281. 

    282. 

  282.      /* Temporary fix for AA issue */

    283. 

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

    284. 

  284. 

    285. 

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

    286. 

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

    287. 

  287. 

    288. 

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

    289. 

  289. 

    290. 

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

    291. 

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

    292. 

  292. 

    293. 

  293.      $RestoreShadow = $this->Shadow;

    294. 

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

    295. 

  295.       {

    296. 

  296.        $this->Shadow = FALSE;

    297. 

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

    298. 

  298.       }

    299. 

  299. 

    300. 

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

    301. 

  301. 

    302. 

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

    303. 

  303. 

    304. 

  304.      $YTop    = $Y1+$Radius;

    305. 

  305.      $YBottom = $Y2-$Radius;

    306. 

  306. 

    307. 

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

    308. 

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

    309. 

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

    310. 

  310.       {

    311. 

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

    312. 

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

    313. 

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

    314. 

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

    315. 

  315. 

    316. 

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

    317. 

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

    318. 

  318.        $Xp1++;

    319. 

  319. 

    320. 

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

    321. 

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

    322. 

  322.        else

    323. 

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

    324. 

  324. 

    325. 

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

    326. 

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

    327. 

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

    328. 

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

    329. 

  329. 

    330. 

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

    331. 

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

    332. 

  332.        $Xp1++;

    333. 

  333. 

    334. 

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

    335. 

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

    336. 

  336.        else

    337. 

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

    338. 

  338.       }

    339. 

  339. 

    340. 

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

    341. 

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

    342. 

  342.       {

    343. 

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

    344. 

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

    345. 

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

    346. 

  346.       }

    347. 

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

    348. 

  348. 

    349. 

  349.      $Radius++;

    350. 

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

    351. 

  351. 

    352. 

  352.      $this->Shadow = $RestoreShadow;

    353. 

  353.     }

    354. 

  354. 

    355. 

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

    356. 

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

    357. 

  357.     {

    358. 

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

    359. 

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

    360. 

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

    361. 

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

    362. 

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

    363. 

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

    364. 

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

    365. 

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

    366. 

  366. 

    367. 

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

    368. 

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

    369. 

  369. 

    370. 

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

    371. 

  371. 

    372. 

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

    373. 

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

    374. 

  374. 

    375. 

  375.      $RestoreShadow = $this->Shadow;

    376. 

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

    377. 

  377.       {

    378. 

  378.        $this->Shadow = FALSE;

    379. 

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

    380. 

  380.       }

    381. 

  381. 

    382. 

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

    383. 

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

    384. 

  384. 

    385. 

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

    386. 

  386. 

    387. 

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

    388. 

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

    389. 

  389. 

    390. 

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

    391. 

  391. 

    392. 

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

    393. 

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

    394. 

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

    395. 

  395.      $Drawn = "";

    396. 

  396. 

    397. 

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

    398. 

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

    399. 

  399.      

    400. 

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

    401. 

  401.       {

    402. 

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

    403. 

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

    404. 

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

    405. 

  405. 

    406. 

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

    407. 

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

    408. 

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

    409. 

  409. 

    410. 

  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. 

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

    414. 

  414. 

    415. 

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

    416. 

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

    417. 

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

    418. 

  418. 

    419. 

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

    420. 

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

    421. 

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

    422. 

  422. 

    423. 

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

    424. 

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

    425. 

  425. 

    426. 

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

    427. 

  427.       }

    428. 

  428. 

    429. 

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

    430. 

  430. 

    431. 

  431.      $this->Shadow = $RestoreShadow;

    432. 

  432.     }

    433. 

  433. 

    434. 

  434.    /* Draw a rectangle */

    435. 

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

    436. 

  436.     {

    437. 

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

    438. 

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

    439. 

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

    440. 

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

    441. 

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

    442. 

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

    443. 

  443. 

    444. 

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

    445. 

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

    446. 

  446. 

    447. 

  447.      if ( $this->Antialias )

    448. 

  448.       {

    449. 

  449.        if ( $NoAngle )

    450. 

  450.         {

    451. 

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

    452. 

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

    453. 

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

    454. 

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

    455. 

  455.         }

    456. 

  456.        else

    457. 

  457.         {

    458. 

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

    459. 

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

    460. 

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

    461. 

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

    462. 

  462.         }

    463. 

  463.       }

    464. 

  464.      else

    465. 

  465.       {

    466. 

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

    467. 

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

    468. 

  468.       }

    469. 

  469.     }

    470. 

  470. 

    471. 

  471.    /* Draw a filled rectangle */

    472. 

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

    473. 

  473.     {

    474. 

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

    475. 

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

    476. 

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

    477. 

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

    478. 

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

    479. 

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

    480. 

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

    481. 

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

    482. 

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

    483. 

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

    484. 

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

    485. 

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

    486. 

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

    487. 

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

    488. 

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

    489. 

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

    490. 

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

    491. 

  491. 

    492. 

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

    493. 

  493. 

    494. 

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

    495. 

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

    496. 

  496. 

    497. 

  497.      $RestoreShadow = $this->Shadow;

    498. 

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

    499. 

  499.       {

    500. 

  500.        $this->Shadow = FALSE;

    501. 

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

    502. 

  502.       }

    503. 

  503. 

    504. 

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

    505. 

  505.      if ( $NoAngle )

    506. 

  506.       {

    507. 

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

    508. 

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

    509. 

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

    510. 

  510.       }

    511. 

  511.      else

    512. 

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

    513. 

  513. 

    514. 

  514.      if ( $Dash )

    515. 

  515.       {

    516. 

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

    517. 

  517. 

    518. 

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

    519. 

  519.        $Y=$iY1-$DashStep;

    520. 

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

    521. 

  521.         {

    522. 

  522.          $Y=$Y+$DashStep;

    523. 

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

    524. 

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

    525. 

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

    526. 

  526.         }

    527. 

  527.       }

    528. 

  528. 

    529. 

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

    530. 

  530.       {

    531. 

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

    532. 

  532.         {

    533. 

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

    534. 

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

    535. 

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

    536. 

  536.         }

    537. 

  537. 

    538. 

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

    539. 

  539.         {

    540. 

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

    541. 

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

    542. 

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

    543. 

  543.         }

    544. 

  544. 

    545. 

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

    546. 

  546.         {

    547. 

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

    548. 

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

    549. 

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

    550. 

  550.         } 

    551. 

  551. 

    552. 

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

    553. 

  553.         {

    554. 

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

    555. 

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

    556. 

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

    557. 

  557.         }

    558. 

  558.       }

    559. 

  559. 

    560. 

  560.      if ( $BorderR != -1 )

    561. 

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

    562. 

  562. 

    563. 

  563.      $this->Shadow = $RestoreShadow;

    564. 

  564.     }

    565. 

  565. 

    566. 

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

    567. 

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

    568. 

  568.     {

    569. 

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

    570. 

  570. 

    571. 

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

    572. 

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

    573. 

  573.     }

    574. 

  574. 

    575. 

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

    576. 

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

    577. 

  577.     {

    578. 

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

    579. 

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

    580. 

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

    581. 

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

    582. 

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

    583. 

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

    584. 

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

    585. 

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

    586. 

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

    587. 

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

    588. 

  588. 

    589. 

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

    590. 

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

    591. 

  591.       {

    592. 

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

    593. 

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

    594. 

  594. 

    595. 

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

    596. 

  596. 

    597. 

  597.        /* First segment */

    598. 

  598.        if ( $i == 1 )

    599. 

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

    600. 

  600.        else

    601. 

  601.         {

    602. 

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

    603. 

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

    604. 

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

    605. 

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

    606. 

  606. 

    607. 

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

    608. 

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

    609. 

  609.         }

    610. 

  610. 

    611. 

  611.        /* Last segment */

    612. 

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

    613. 

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

    614. 

  614.        else

    615. 

  615.         {

    616. 

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

    617. 

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

    618. 

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

    619. 

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

    620. 

  620. 

    621. 

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

    622. 

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

    623. 

  623.         }

    624. 

  624. 

    625. 

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

    626. 

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

    627. 

  627. 

    628. 

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

    629. 

  629.       }

    630. 

  630. 

    631. 

  631.      return($Result);

    632. 

  632.     }

    633. 

  633. 

    634. 

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

    635. 

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

    636. 

  636.     {

    637. 

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

    638. 

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

    639. 

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

    640. 

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

    641. 

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

    642. 

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

    643. 

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

    644. 

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

    645. 

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

    646. 

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

    647. 

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

    648. 

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

    649. 

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

    650. 

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

    651. 

  651. 

    652. 

  652.      if ( $Segments == NULL )

    653. 

  653.       {

    654. 

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

    655. 

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

    656. 

  656.       }

    657. 

  657.      else

    658. 

  658.       $Precision = $Segments;

    659. 

  659. 

    660. 

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

    661. 

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

    662. 

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

    663. 

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

    664. 

  664. 

    665. 

  665.      /* Compute the bezier points */

    666. 

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

    667. 

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

    668. 

  668.       {

    669. 

  669.        $u = $i / $Precision;

    670. 

  670. 

    671. 

  671.        $C    = "";

    672. 

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

    673. 

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

    674. 

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

    675. 

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

    676. 

  676. 

    677. 

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

    678. 

  678.         {

    679. 

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

    680. 

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

    681. 

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

    682. 

  682. 

    683. 

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

    684. 

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

    685. 

  685.         }

    686. 

  686.        $ID++;

    687. 

  687.       }        

    688. 

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

    689. 

  689. 

    690. 

  690.      if ( !$NoDraw )

    691. 

  691.       {

    692. 

  692.        /* Display the control points */

    693. 

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

    694. 

  694.         {

    695. 

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

    696. 

  696. 

    697. 

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

    698. 

  698. 

    699. 

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

    700. 

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

    701. 

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

    702. 

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

    703. 

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

    704. 

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

    705. 

  705.         }

    706. 

  706. 

    707. 

  707.        /* Draw the bezier */

    708. 

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

    709. 

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

    710. 

  710.         {

    711. 

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

    712. 

  712. 

    713. 

  713.          /* Get the first segment */

    714. 

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

    715. 

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

    716. 

  716. 

    717. 

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

    718. 

  718.           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));

    719. 

  719. 

    720. 

  720.          /* Get the last segment */

    721. 

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

    722. 

  722. 

    723. 

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

    724. 

  724.         }

    725. 

  725. 

    726. 

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

    727. 

  727.         {

    728. 

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

    729. 

  729.          if ( $ArrowTwoHeads )

    730. 

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

    731. 

  731. 

    732. 

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

    733. 

  733.         }

    734. 

  734.       }

    735. 

  735.      return($Q);

    736. 

  736.     }

    737. 

  737. 

    738. 

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

    739. 

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

    740. 

  740.     {

    741. 

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

    742. 

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

    743. 

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

    744. 

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

    745. 

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

    746. 

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

    747. 

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

    748. 

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

    749. 

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

    750. 

  750. 

    751. 

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

    752. 

  752.       {

    753. 

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

    754. 

  754.         {

    755. 

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

    756. 

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

    757. 

  757.         }

    758. 

  758. 

    759. 

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

    760. 

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

    761. 

  761.        return(0);

    762. 

  762.       }

    763. 

  763. 

    764. 

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

    765. 

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

    766. 

  766. 

    767. 

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

    768. 

  768.      if ( $Weight != NULL )

    769. 

  769.       {

    770. 

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

    771. 

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

    772. 

  772. 

    773. 

  773.        if ( $Ticks == NULL )

    774. 

  774.         {

    775. 

  775.          $Points   = ""; 

    776. 

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

    777. 

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

    778. 

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

    779. 

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

    780. 

  780. 

    781. 

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

    782. 

  782.         }

    783. 

  783.        else

    784. 

  784.         {

    785. 

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

    786. 

  786.           {

    787. 

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

    788. 

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

    789. 

  789. 

    790. 

  790.            $Points   = ""; 

    791. 

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

    792. 

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

    793. 

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

    794. 

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

    795. 

  795. 

    796. 

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

    797. 

  797.           }

    798. 

  798.         }

    799. 

  799. 

    800. 

  800.        return(1);

    801. 

  801.       }

    802. 

  802. 

    803. 

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

    804. 

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

    805. 

  805. 

    806. 

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

    807. 

  807.       {

    808. 

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

    809. 

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

    810. 

  810. 

    811. 

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

    812. 

  812. 

    813. 

  813.        if ( $Threshold != NULL )

    814. 

  814.         {

    815. 

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

    816. 

  816.           {

    817. 

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

    818. 

  818.             {

    819. 

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

    820. 

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

    821. 

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

    822. 

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

    823. 

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

    824. 

  824.             }

    825. 

  825.           }

    826. 

  826.         }

    827. 

  827. 

    828. 

  828.        if ( $Ticks != NULL )

    829. 

  829.         {

    830. 

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

    831. 

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

    832. 

  832. 

    833. 

  833.          if ( $Mode == 1 )

    834. 

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

    835. 

  835. 

    836. 

  836.          $Cpt++;

    837. 

  837.         }

    838. 

  838.        else

    839. 

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

    840. 

  840.       }

    841. 

  841. 

    842. 

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

    843. 

  843.     }

    844. 

  844. 

    845. 

  845.    /* Draw a circle */

    846. 

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

    847. 

  847.     {

    848. 

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

    849. 

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

    850. 

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

    851. 

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

    852. 

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

    853. 

  853. 

    854. 

  854.      $Height	= abs($Height);

    855. 

  855.      $Width	= abs($Width);

    856. 

  856. 

    857. 

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

    858. 

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

    859. 

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

    860. 

  860. 

    861. 

  861.      $RestoreShadow = $this->Shadow;

    862. 

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

    863. 

  863.       {

    864. 

  864.        $this->Shadow = FALSE;

    865. 

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

    866. 

  866.       }

    867. 

  867. 

    868. 

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

    869. 

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

    870. 

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

    871. 

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

    872. 

  872. 

    873. 

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

    874. 

  874.      $Mode = 1; $Cpt = 1;

    875. 

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

    876. 

  876.       {

    877. 

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

    878. 

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

    879. 

  879. 

    880. 

  880.        if ( $Ticks != NULL )

    881. 

  881.         {

    882. 

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

    883. 

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

    884. 

  884. 

    885. 

  885.          if ( $Mode == 1 )

    886. 

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

    887. 

  887. 

    888. 

  888.          $Cpt++;

    889. 

  889.         }

    890. 

  890.        else

    891. 

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

    892. 

  892. 

    893. 

  893.       }

    894. 

  894.      $this->Shadow = $RestoreShadow;

    895. 

  895.     }

    896. 

  896. 

    897. 

  897.    /* Draw a filled circle */

    898. 

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

    899. 

  899.     {

    900. 

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

    901. 

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

    902. 

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

    903. 

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

    904. 

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

    905. 

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

    906. 

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

    907. 

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

    908. 

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

    909. 

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

    910. 

  910. 

    911. 

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

    912. 

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

    913. 

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

    914. 

  914. 

    915. 

  915.      $Radius = abs($Radius);

    916. 

  916. 

    917. 

  917.      $RestoreShadow = $this->Shadow;

    918. 

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

    919. 

  919.       {

    920. 

  920.        $this->Shadow = FALSE;

    921. 

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

    922. 

  922.       }

    923. 

  923. 

    924. 

  924.      $this->Mask  = "";

    925. 

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

    926. 

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

    927. 

  927.       {

    928. 

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

    929. 

  929.        $XPos   = floor($Slice);

    930. 

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

    931. 

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

    932. 

  932. 

    933. 

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

    934. 

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

    935. 

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

    936. 

  936.       }

    937. 

  937.      if ( $this->Antialias )

    938. 

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

    939. 

  939. 

    940. 

  940.      $this->Mask = "";

    941. 

  941. 

    942. 

  942.      if ( $BorderR != -1 )

    943. 

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

    944. 

  944. 

    945. 

  945.      $this->Shadow	= $RestoreShadow;

    946. 

  946.     }

    947. 

  947. 

    948. 

  948.    /* Write text */

    949. 

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

    950. 

  950.     {

    951. 

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

    952. 

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

    953. 

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

    954. 

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

    955. 

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

    956. 

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

    957. 

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

    958. 

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

    959. 

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

    960. 

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

    961. 

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

    962. 

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

    963. 

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

    964. 

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

    965. 

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

    966. 

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

    967. 

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

    968. 

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

    969. 

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

    970. 

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

    971. 

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

    972. 

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

    973. 

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

    974. 

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

    975. 

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

    976. 

  976. 

    977. 

  977.      $Shadow = $this->Shadow;

    978. 

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

    979. 

  979. 

    980. 

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

    981. 

  981. 

    982. 

  982.      if ( $ShowOrigine )

    983. 

  983.       {

    984. 

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

    985. 

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

    986. 

  986.       }

    987. 

  987. 

    988. 

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

    989. 

  989. 

    990. 

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

    991. 

  991.       {

    992. 

  992.        $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;

    993. 

  993.        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; }

    994. 

  994. 

    995. 

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

    996. 

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

    997. 

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

    998. 

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

    999. 

  999. 

    1000. 

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

    1001. 

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

    1002. 

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

    1003. 

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

    1004. 

  1004. 

    1005. 

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

    1006. 

  1006. 

    1007. 

  1007.        if ( $BoxRounded )

    1008. 

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

    1009. 

  1009.        else

    1010. 

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

    1011. 

  1011.       }

    1012. 

  1012. 

    1013. 

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

    1014. 

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

    1015. 

  1015. 

    1016. 

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

    1017. 

  1017.       {

    1018. 

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

    1019. 

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

    1020. 

  1020.       }

    1021. 

  1021. 

    1022. 

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

    1023. 

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

    1024. 

  1024. 

    1025. 

  1025.      $this->Shadow = $Shadow;

    1026. 

  1026. 

    1027. 

  1027.      return($TxtPos);

    1028. 

  1028.     }

    1029. 

  1029. 

    1030. 

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

    1031. 

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

    1032. 

  1032.     {

    1033. 

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

    1034. 

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

    1035. 

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

    1036. 

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

    1037. 

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

    1038. 

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

    1039. 

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

    1040. 

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

    1041. 

  1041. 

    1042. 

  1042.      $Shadow = $this->Shadow;

    1043. 

  1043.      $this->Shadow = FALSE;

    1044. 

  1044. 

    1045. 

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

    1046. 

  1046.       {

    1047. 

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

    1048. 

  1048.        return(0);

    1049. 

  1049.       }

    1050. 

  1050. 

    1051. 

  1051.      if ( $Levels != NULL )

    1052. 

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

    1053. 

  1053. 

    1054. 

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

    1055. 

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

    1056. 

  1056. 

    1057. 

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

    1058. 

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

    1059. 

  1059. 

    1060. 

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

    1061. 

  1061.      $StepSize = $Width/$Step;

    1062. 

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

    1063. 

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

    1064. 

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

    1065. 

  1065. 

    1066. 

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

    1067. 

  1067.      switch($Direction)

    1068. 

  1068.       {

    1069. 

  1069.        case DIRECTION_VERTICAL:

    1070. 

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

    1071. 

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

    1072. 

  1072.          {

    1073. 

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

    1074. 

  1074. 

    1075. 

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

    1076. 

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

    1077. 

  1077.            {

    1078. 

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

    1079. 

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

    1080. 

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

    1081. 

  1081.             $Y1 = $Y2+1;

    1082. 

  1082.            }

    1083. 

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

    1084. 

  1084.          }

    1085. 

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

    1086. 

  1086.         break;

    1087. 

  1087. 

    1088. 

  1088.        case DIRECTION_HORIZONTAL:

    1089. 

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

    1090. 

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

    1091. 

  1091.          {

    1092. 

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

    1093. 

  1093. 

    1094. 

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

    1095. 

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

    1096. 

  1096.            {

    1097. 

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

    1098. 

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

    1099. 

  1099.             $X1 = $X2+1;

    1100. 

  1100.            }

    1101. 

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

    1102. 

  1102.          }

    1103. 

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

    1104. 

  1104.         break;

    1105. 

  1105.       }

    1106. 

  1106. 

    1107. 

  1107.      $this->Shadow = $Shadow;

    1108. 

  1108. 

    1109. 

  1109.     }

    1110. 

  1110. 

    1111. 

  1111.    /* Draw an aliased pixel */

    1112. 

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

    1113. 

  1113.     {

    1114. 

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

    1115. 

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

    1116. 

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

    1117. 

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

    1118. 

  1118. 

    1119. 

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

    1120. 

  1120.       return(-1);

    1121. 

  1121. 

    1122. 

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

    1123. 

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

    1124. 

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

    1125. 

  1125. 

    1126. 

  1126.      if ( !$this->Antialias )

    1127. 

  1127.       {

    1128. 

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

    1129. 

  1129.         {

    1130. 

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

    1131. 

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

    1132. 

  1132.         }

    1133. 

  1133. 

    1134. 

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

    1135. 

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

    1136. 

  1136. 

    1137. 

  1137.        return(0);

    1138. 

  1138.       }

    1139. 

  1139. 

    1140. 

  1140.      $Plot = "";

    1141. 

  1141.      $Xi   = floor($X);

    1142. 

  1142.      $Yi   = floor($Y);

    1143. 

  1143. 

    1144. 

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

    1145. 

  1145.       {

    1146. 

  1146.        if ( $Alpha == 100 )

    1147. 

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

    1148. 

  1148.        else

    1149. 

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

    1150. 

  1150.       }

    1151. 

  1151.      else

    1152. 

  1152.       {

    1153. 

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

    1154. 

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

    1155. 

  1155. 

    1156. 

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

    1157. 

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

    1158. 

  1158. 

    1159. 

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

    1160. 

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

    1161. 

  1161. 

    1162. 

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

    1163. 

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

    1164. 

  1164.       }

    1165. 

  1165.     }

    1166. 

  1166. 

    1167. 

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

    1168. 

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

    1169. 

  1169.     {

    1170. 

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

    1171. 

  1171. 

    1172. 

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

    1173. 

  1173.       return(-1);

    1174. 

  1174. 

    1175. 

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

    1176. 

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

    1177. 

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

    1178. 

  1178. 

    1179. 

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

    1180. 

  1180.       {

    1181. 

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

    1182. 

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

    1183. 

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

    1184. 

  1184.       }

    1185. 

  1185. 

    1186. 

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

    1187. 

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

    1188. 

  1188.     }

    1189. 

  1189. 

    1190. 

  1190.    /* Convert apha to base 10 */

    1191. 

  1191.    function convertAlpha($AlphaValue)

    1192. 

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

    1193. 

  1193. 

    1194. 

  1194.    /* Allocate a color with transparency */

    1195. 

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

    1196. 

  1196.     {

    1197. 

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

    1198. 

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

    1199. 

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

    1200. 

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

    1201. 

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

    1202. 

  1202. 

    1203. 

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

    1204. 

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

    1205. 

  1205.     }

    1206. 

  1206. 

    1207. 

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

    1208. 

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

    1209. 

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

    1210. 

  1210. 

    1211. 

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

    1212. 

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

    1213. 

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

    1214. 

  1214. 

    1215. 

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

    1216. 

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

    1217. 

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

    1218. 

  1218. 

    1219. 

  1219.    function getPicInfo($FileName)

    1220. 

  1220.     {

    1221. 

  1221.      $Infos  = getimagesize($FileName);

    1222. 

  1222.      $Width  = $Infos[0];

    1223. 

  1223.      $Height = $Infos[1];

    1224. 

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

    1225. 

  1225. 

    1226. 

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

    1227. 

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

    1228. 

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

    1229. 

  1229. 

    1230. 

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

    1231. 

  1231.     }

    1232. 

  1232. 

    1233. 

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

    1234. 

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

    1235. 

  1235.     {

    1236. 

  1236.      if ( file_exists($FileName))

    1237. 

  1237.       {

    1238. 

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

    1239. 

  1239. 

    1240. 

  1240.        if ( $PicType == 1 )

    1241. 

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

    1242. 

  1242.        elseif ( $PicType == 2 )

    1243. 

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

    1244. 

  1244.        elseif ( $PicType == 3 )

    1245. 

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

    1246. 

  1246.        else

    1247. 

  1247.         { return(0); }

    1248. 

  1248. 

    1249. 

  1249. 

    1250. 

  1250.        $RestoreShadow = $this->Shadow;

    1251. 

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

    1252. 

  1252.         {

    1253. 

  1253.          $this->Shadow = FALSE;

    1254. 

  1254.          if ( $PicType == 3 )

    1255. 

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

    1256. 

  1256.          else

    1257. 

  1257.           {

    1258. 

  1258.            $TranparentID = imagecolortransparent($Raster);

    1259. 

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

    1260. 

  1260.             {

    1261. 

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

    1262. 

  1262.               {

    1263. 

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

    1264. 

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

    1265. 

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

    1266. 

  1266.                 {

    1267. 

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

    1268. 

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

    1269. 

  1269.                 }

    1270. 

  1270.               }

    1271. 

  1271.             }

    1272. 

  1272.           }

    1273. 

  1273.         }

    1274. 

  1274.        $this->Shadow = $RestoreShadow;

    1275. 

  1275. 

    1276. 

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

    1277. 

  1277.        imagedestroy($Raster);

    1278. 

  1278.       }

    1279. 

  1279.     }

    1280. 

  1280. 

    1281. 

  1281.    /* Draw an arrow */

    1282. 

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

    1283. 

  1283.     {

    1284. 

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

    1285. 

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

    1286. 

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

    1287. 

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

    1288. 

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

    1289. 

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

    1290. 

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

    1291. 

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

    1292. 

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

    1293. 

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

    1294. 

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

    1295. 

  1295. 

    1296. 

  1296.      /* Calculate the line angle */

    1297. 

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

    1298. 

  1298. 

    1299. 

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

    1300. 

  1300.      $RestoreShadow = $this->Shadow;

    1301. 

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

    1302. 

  1302.       {

    1303. 

  1303.        $this->Shadow = FALSE;

    1304. 

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

    1305. 

  1305.       }

    1306. 

  1306. 

    1307. 

  1307.      /* Draw the 1st Head */

    1308. 

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

    1309. 

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

    1310. 

  1310. 

    1311. 

  1311.      $Points	= "";

    1312. 

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

    1313. 

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

    1314. 

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

    1315. 

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

    1316. 

  1316. 

    1317. 

  1317.      /* Visual correction */

    1318. 

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

    1319. 

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

    1320. 

  1320. 

    1321. 

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

    1322. 

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

    1323. 

  1323. 

    1324. 

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

    1325. 

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

    1326. 

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

    1327. 

  1327. 

    1328. 

  1328.      /* Draw the second head */

    1329. 

  1329.      if ( $TwoHeads )

    1330. 

  1330.       {

    1331. 

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

    1332. 

  1332. 

    1333. 

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

    1334. 

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

    1335. 

  1335. 

    1336. 

  1336.        $Points   = "";

    1337. 

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

    1338. 

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

    1339. 

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

    1340. 

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

    1341. 

  1341. 

    1342. 

  1342.        /* Visual correction */

    1343. 

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

    1344. 

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

    1345. 

  1345. 

    1346. 

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

    1347. 

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

    1348. 

  1348. 

    1349. 

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

    1350. 

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

    1351. 

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

    1352. 

  1352. 

    1353. 

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

    1354. 

  1354.       }

    1355. 

  1355.      else

    1356. 

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

    1357. 

  1357. 

    1358. 

  1358.      /* Re-enable shadows */

    1359. 

  1359.      $this->Shadow = $RestoreShadow;

    1360. 

  1360.     }

    1361. 

  1361. 

    1362. 

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

    1363. 

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

    1364. 

  1364.     {

    1365. 

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

    1366. 

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

    1367. 

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

    1368. 

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

    1369. 

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

    1370. 

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

    1371. 

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

    1372. 

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

    1373. 

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

    1374. 

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

    1375. 

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

    1376. 

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

    1377. 

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

    1378. 

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

    1379. 

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

    1380. 

  1380. 

    1381. 

  1381.      $Angle = $Angle % 360;

    1382. 

  1382. 

    1383. 

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

    1384. 

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

    1385. 

  1385. 

    1386. 

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

    1387. 

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

    1388. 

  1388. 

    1389. 

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

    1390. 

  1390. 

    1391. 

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

    1392. 

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

    1393. 

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

    1394. 

  1394. 

    1395. 

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

    1396. 

  1396.       {

    1397. 

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

    1398. 

  1398.        if ( $Position == POSITION_TOP )

    1399. 

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

    1400. 

  1400.        else

    1401. 

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

    1402. 

  1402.       }

    1403. 

  1403.      else

    1404. 

  1404.       {

    1405. 

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

    1406. 

  1406.        if ( $Position == POSITION_TOP )

    1407. 

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

    1408. 

  1408.        else

    1409. 

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

    1410. 

  1410.       }

    1411. 

  1411.     }

    1412. 

  1412. 

    1413. 

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

    1414. 

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

    1415. 

  1415.     {

    1416. 

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

    1417. 

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

    1418. 

  1418. 

    1419. 

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

    1420. 

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

    1421. 

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

    1422. 

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

    1423. 

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

    1424. 

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

    1425. 

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

    1426. 

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

    1427. 

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

    1428. 

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

    1429. 

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

    1430. 

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

    1431. 

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

    1432. 

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

    1433. 

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

    1434. 

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

    1435. 

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

    1436. 

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

    1437. 

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

    1438. 

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

    1439. 

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

    1440. 

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

    1441. 

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

    1442. 

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

    1443. 

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

    1444. 

  1444. 

    1445. 

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

    1446. 

  1446.       {

    1447. 

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

    1448. 

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

    1449. 

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

    1450. 

  1450.       }

    1451. 

  1451. 

    1452. 

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

    1453. 

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

    1454. 

  1454. 

    1455. 

  1455.      if ( $Orientation == ORIENTATION_VERTICAL )

    1456. 

  1456.       {

    1457. 

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

    1458. 

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

    1459. 

  1459. 

    1460. 

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

    1461. 

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

    1462. 

  1462.         {

    1463. 

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

    1464. 

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

    1465. 

  1465. 

    1466. 

  1466.          if ( $Surrounding )

    1467. 

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

    1468. 

  1468.         }

    1469. 

  1469.        else

    1470. 

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

    1471. 

  1471. 

    1472. 

  1472.        $this->Shadow = $RestoreShadow;

    1473. 

  1473. 

    1474. 

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

    1475. 

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

    1476. 

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

    1477. 

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

    1478. 

  1478.       }

    1479. 

  1479.      else

    1480. 

  1480.       {

    1481. 

  1481.        if ( $Percent == 100 )

    1482. 

  1482.         $InnerWidth = $Width-1;

    1483. 

  1483.        else

    1484. 

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

    1485. 

  1485. 

    1486. 

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

    1487. 

  1487. 

    1488. 

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

    1489. 

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

    1490. 

  1490.         {

    1491. 

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

    1492. 

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

    1493. 

  1493. 

    1494. 

  1494.          if ( $Surrounding )

    1495. 

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

    1496. 

  1496.         }

    1497. 

  1497.        else

    1498. 

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

    1499. 

  1499.  

    1500. 

  1500.        $this->Shadow = $RestoreShadow;

    1501. 

  1501. 

    1502. 

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

    1503. 

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

    1504. 

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

    1505. 

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

    1506. 

  1506.       }

    1507. 

  1507.     }

    1508. 

  1508. 

    1509. 

  1509.    /* Get the legend box size */

    1510. 

  1510.    function getLegendSize($Format="")

    1511. 

  1511.     {

    1512. 

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

    1513. 

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

    1514. 

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

    1515. 

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

    1516. 

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

    1517. 

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

    1518. 

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

    1519. 

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

    1520. 

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

    1521. 

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

    1522. 

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

    1523. 

  1523. 

    1524. 

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

    1525. 

  1525. 

    1526. 

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

    1527. 

  1527.       {

    1528. 

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

    1529. 

  1529.         {

    1530. 

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

    1531. 

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

    1532. 

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

    1533. 

  1533.         }

    1534. 

  1534.       }

    1535. 

  1535. 

    1536. 

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

    1537. 

  1537.      $XStep = $IconAreaWidth + 5;

    1538. 

  1538.      $XStep = $XSpacing;

    1539. 

  1539. 

    1540. 

  1540.      $X=100; $Y=100;

    1541. 

  1541. 

    1542. 

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

    1543. 

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

    1544. 

  1544.       {

    1545. 

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

    1546. 

  1546.         {

    1547. 

  1547.          if ( $Mode == LEGEND_VERTICAL )

    1548. 

  1548.           {

    1549. 

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

    1550. 

  1550. 

    1551. 

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

    1552. 

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

    1553. 

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

    1554. 

  1554. 

    1555. 

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

    1556. 

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

    1557. 

  1557.           }

    1558. 

  1558.          elseif ( $Mode == LEGEND_HORIZONTAL )

    1559. 

  1559.           {

    1560. 

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

    1561. 

  1561.            $Width = "";

    1562. 

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

    1563. 

  1563.             {

    1564. 

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

    1565. 

  1565. 

    1566. 

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

    1567. 

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

    1568. 

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

    1569. 

  1569. 

    1570. 

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

    1571. 

  1571.             }

    1572. 

  1572. 

    1573. 

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

    1574. 

  1574.           }

    1575. 

  1575.         }

    1576. 

  1576.       }

    1577. 

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

    1578. 

  1578. 

    1579. 

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

    1580. 

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

    1581. 

  1581. 

    1582. 

  1582.      $Width  = ($Boundaries["R"]+$Margin) - ($Boundaries["L"]-$Margin);

    1583. 

  1583.      $Height = ($Boundaries["B"]+$Margin) - ($Boundaries["T"]-$Margin);

    1584. 

  1584. 

    1585. 

  1585.      return(array("Width"=>$Width,"Height"=>$Height));

    1586. 

  1586.     }

    1587. 

  1587. 

    1588. 

  1588.    /* Draw the legend of the active series */

    1589. 

  1589.    function drawLegend($X,$Y,$Format="")

    1590. 

  1590.     {

    1591. 

  1591.      $Family	= isset($Format["Family"]) ? $Format["Family"] : LEGEND_FAMILY_BOX;

    1592. 

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

    1593. 

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

    1594. 

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

    1595. 

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

    1596. 

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

    1597. 

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

    1598. 

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

    1599. 

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

    1600. 

  1600.      $IconAreaHeight	= isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;

    1601. 

  1601.      $XSpacing	= isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;

    1602. 

  1602.      $Margin	= isset($Format["Margin"]) ? $Format["Margin"] : 5;

    1603. 

  1603.      $R		= isset($Format["R"]) ? $Format["R"] : 200;

    1604. 

  1604.      $G		= isset($Format["G"]) ? $Format["G"] : 200;

    1605. 

  1605.      $B		= isset($Format["B"]) ? $Format["B"] : 200;

    1606. 

  1606.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

    1607. 

  1607.      $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;

    1608. 

  1608.      $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;

    1609. 

  1609.      $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;

    1610. 

  1610.      $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    1611. 

  1611.      $Style	= isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;

    1612. 

  1612.      $Mode	= isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;

    1613. 

  1613. 

    1614. 

  1614.      if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }

    1615. 

  1615. 

    1616. 

  1616.      $Data = $this->DataSet->getData();

    1617. 

  1617. 

    1618. 

  1618.      foreach($Data["Series"] as $SerieName => $Serie)

    1619. 

  1619.       {

    1620. 

  1620.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && isset($Serie["Picture"]))

    1621. 

  1621.         {

    1622. 

  1622.          list($PicWidth,$PicHeight) = $this->getPicInfo($Serie["Picture"]);

    1623. 

  1623.          if ( $IconAreaWidth < $PicWidth ) { $IconAreaWidth = $PicWidth; }

    1624. 

  1624.          if ( $IconAreaHeight < $PicHeight ) { $IconAreaHeight = $PicHeight; }

    1625. 

  1625.         }

    1626. 

  1626.       }

    1627. 

  1627. 

    1628. 

  1628.      $YStep = max($this->FontSize,$IconAreaHeight) + 5;

    1629. 

  1629.      $XStep = $IconAreaWidth + 5;

    1630. 

  1630.      $XStep = $XSpacing;

    1631. 

  1631. 

    1632. 

  1632.      $Boundaries = ""; $Boundaries["L"] = $X; $Boundaries["T"] = $Y; $Boundaries["R"] = 0; $Boundaries["B"] = 0; $vY = $Y; $vX = $X;

    1633. 

  1633.      foreach($Data["Series"] as $SerieName => $Serie)

    1634. 

  1634.       {

    1635. 

  1635.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    1636. 

  1636.         {

    1637. 

  1637.          if ( $Mode == LEGEND_VERTICAL )

    1638. 

  1638.           {

    1639. 

  1639.            $BoxArray = $this->getTextBox($vX+$IconAreaWidth+4,$vY+$IconAreaHeight/2,$FontName,$FontSize,0,$Serie["Description"]);

    1640. 

  1640. 

    1641. 

  1641.            if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

    1642. 

  1642.            if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

    1643. 

  1643.            if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

    1644. 

  1644. 

    1645. 

  1645.            $Lines = preg_split("/\n/",$Serie["Description"]);

    1646. 

  1646.            $vY = $vY + max($this->FontSize*count($Lines),$IconAreaHeight) + 5;

    1647. 

  1647.           }

    1648. 

  1648.          elseif ( $Mode == LEGEND_HORIZONTAL )

    1649. 

  1649.           {

    1650. 

  1650.            $Lines = preg_split("/\n/",$Serie["Description"]);

    1651. 

  1651.            $Width = "";

    1652. 

  1652.            foreach($Lines as $Key => $Value)

    1653. 

  1653.             {

    1654. 

  1654.              $BoxArray = $this->getTextBox($vX+$IconAreaWidth+6,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$FontName,$FontSize,0,$Value);

    1655. 

  1655. 

    1656. 

  1656.              if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$IconAreaHeight/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$IconAreaHeight/2; }

    1657. 

  1657.              if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

    1658. 

  1658.              if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$IconAreaHeight/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$IconAreaHeight/2; }

    1659. 

  1659. 

    1660. 

  1660.              $Width[] = $BoxArray[1]["X"];

    1661. 

  1661.             }

    1662. 

  1662. 

    1663. 

  1663.            $vX=max($Width)+$XStep;

    1664. 

  1664.           }

    1665. 

  1665.         }

    1666. 

  1666.       }

    1667. 

  1667.      $vY=$vY-$YStep; $vX=$vX-$XStep;

    1668. 

  1668. 

    1669. 

  1669.      $TopOffset  = $Y - $Boundaries["T"];

    1670. 

  1670.      if ( $Boundaries["B"]-($vY+$IconAreaHeight) < $TopOffset ) { $Boundaries["B"] = $vY+$IconAreaHeight+$TopOffset; }

    1671. 

  1671. 

    1672. 

  1672.      if ( $Style == LEGEND_ROUND )

    1673. 

  1673.       $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));

    1674. 

  1674.      elseif ( $Style == LEGEND_BOX )

    1675. 

  1675.       $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));

    1676. 

  1676. 

    1677. 

  1677.      $RestoreShadow = $this->Shadow; $this->Shadow = FALSE;

    1678. 

  1678.      foreach($Data["Series"] as $SerieName => $Serie)

    1679. 

  1679.       {

    1680. 

  1680.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    1681. 

  1681.         {

    1682. 

  1682.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"];

    1683. 

  1683.          $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    1684. 

  1684. 

    1685. 

  1685.          if ( isset($Serie["Picture"]) )

    1686. 

  1686.           {

    1687. 

  1687.            $Picture = $Serie["Picture"];

    1688. 

  1688.            list($PicWidth,$PicHeight) = $this->getPicInfo($Picture);

    1689. 

  1689.            $PicX = $X+$IconAreaWidth/2; $PicY = $Y+$IconAreaHeight/2; 

    1690. 

  1690. 

    1691. 

  1691.            $this->drawFromPNG($PicX-$PicWidth/2,$PicY-$PicHeight/2,$Picture);

    1692. 

  1692.           }

    1693. 

  1693.          else

    1694. 

  1694.           {

    1695. 

  1695.            if ( $Family == LEGEND_FAMILY_BOX )

    1696. 

  1696.             {

    1697. 

  1697.              if ( $BoxWidth != $IconAreaWidth ) { $XOffset = floor(($IconAreaWidth-$BoxWidth)/2); } else { $XOffset = 0; }

    1698. 

  1698.              if ( $BoxHeight != $IconAreaHeight ) { $YOffset = floor(($IconAreaHeight-$BoxHeight)/2); } else { $YOffset = 0; }

    1699. 

  1699. 

    1700. 

  1700.              $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));

    1701. 

  1701.              $this->drawFilledRectangle($X+$XOffset,$Y+$YOffset,$X+$BoxWidth+$XOffset,$Y+$BoxHeight+$YOffset,array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));

    1702. 

  1702.             }

    1703. 

  1703.            elseif ( $Family == LEGEND_FAMILY_CIRCLE )

    1704. 

  1704.             {

    1705. 

  1705.              $this->drawFilledCircle($X+1+$IconAreaWidth/2,$Y+1+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20));

    1706. 

  1706.              $this->drawFilledCircle($X+$IconAreaWidth/2,$Y+$IconAreaHeight/2,min($IconAreaHeight/2,$IconAreaWidth/2),array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));

    1707. 

  1707.             }

    1708. 

  1708.            elseif ( $Family == LEGEND_FAMILY_LINE )

    1709. 

  1709.             {

    1710. 

  1710.              $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));

    1711. 

  1711.              $this->drawLine($X,$Y+$IconAreaHeight/2,$X+$IconAreaWidth,$Y+$IconAreaHeight/2,array("R"=>$R,"G"=>$G,"B"=>$B,"Ticks"=>$Ticks,"Weight"=>$Weight));

    1712. 

  1712.             }

    1713. 

  1713.           }

    1714. 

  1714. 

    1715. 

  1715.          if ( $Mode == LEGEND_VERTICAL )

    1716. 

  1716.           {

    1717. 

  1717.            $Lines = preg_split("/\n/",$Serie["Description"]);

    1718. 

  1718.            foreach($Lines as $Key => $Value)

    1719. 

  1719.             $this->drawText($X+$IconAreaWidth+4,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontSize"=>$FontSize,"FontName"=>$FontName));

    1720. 

  1720. 

    1721. 

  1721.            $Y=$Y+max($this->FontSize*count($Lines),$IconAreaHeight) + 5;

    1722. 

  1722.           }

    1723. 

  1723.          elseif ( $Mode == LEGEND_HORIZONTAL )

    1724. 

  1724.           {

    1725. 

  1725.            $Lines = preg_split("/\n/",$Serie["Description"]);

    1726. 

  1726.            $Width = "";

    1727. 

  1727.            foreach($Lines as $Key => $Value)

    1728. 

  1728.             {

    1729. 

  1729.              $BoxArray = $this->drawText($X+$IconAreaWidth+4,$Y+$IconAreaHeight/2+(($this->FontSize+3)*$Key),$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontSize"=>$FontSize,"FontName"=>$FontName));

    1730. 

  1730.              $Width[] = $BoxArray[1]["X"];

    1731. 

  1731.             }

    1732. 

  1732.            $X=max($Width)+2+$XStep;

    1733. 

  1733.           }

    1734. 

  1734.         }

    1735. 

  1735.       }

    1736. 

  1736. 

    1737. 

  1737. 

    1738. 

  1738.      $this->Shadow = $RestoreShadow;

    1739. 

  1739.     }

    1740. 

  1740. 

    1741. 

  1741.    function drawScale($Format="")

    1742. 

  1742.     {

    1743. 

  1743.      $Pos		= isset($Format["Pos"]) ? $Format["Pos"] : SCALE_POS_LEFTRIGHT;

    1744. 

  1744.      $Floating		= isset($Format["Floating"]) ? $Format["Floating"] : FALSE;

    1745. 

  1745.      $Mode		= isset($Format["Mode"]) ? $Format["Mode"] : SCALE_MODE_FLOATING;

    1746. 

  1746.      $RemoveXAxis	= isset($Format["RemoveXAxis"]) ? $Format["RemoveXAxis"] : FALSE;

    1747. 

  1747.      $MinDivHeight	= isset($Format["MinDivHeight"]) ? $Format["MinDivHeight"] : 20;

    1748. 

  1748.      $Factors		= isset($Format["Factors"]) ? $Format["Factors"] : array(1,2,5);

    1749. 

  1749.      $ManualScale	= isset($Format["ManualScale"]) ? $Format["ManualScale"] : array("0"=>array("Min"=>-100,"Max"=>100));

    1750. 

  1750.      $XMargin		= isset($Format["XMargin"]) ? $Format["XMargin"] : AUTO;

    1751. 

  1751.      $YMargin		= isset($Format["YMargin"]) ? $Format["YMargin"] : 0;

    1752. 

  1752.      $ScaleSpacing	= isset($Format["ScaleSpacing"]) ? $Format["ScaleSpacing"] : 15;

    1753. 

  1753.      $InnerTickWidth	= isset($Format["InnerTickWidth"]) ? $Format["InnerTickWidth"] : 2;

    1754. 

  1754.      $OuterTickWidth	= isset($Format["OuterTickWidth"]) ? $Format["OuterTickWidth"] : 2;

    1755. 

  1755.      $DrawXLines	= isset($Format["DrawXLines"]) ? $Format["DrawXLines"] : TRUE;

    1756. 

  1756.      $DrawYLines	= isset($Format["DrawYLines"]) ? $Format["DrawYLines"] : ALL;

    1757. 

  1757.      $GridTicks		= isset($Format["GridTicks"]) ? $Format["GridTicks"] : 4;

    1758. 

  1758.      $GridR		= isset($Format["GridR"]) ? $Format["GridR"] : 255;

    1759. 

  1759.      $GridG		= isset($Format["GridG"]) ? $Format["GridG"] : 255;

    1760. 

  1760.      $GridB		= isset($Format["GridB"]) ? $Format["GridB"] : 255;

    1761. 

  1761.      $GridAlpha		= isset($Format["GridAlpha"]) ? $Format["GridAlpha"] : 40;

    1762. 

  1762.      $AxisRo		= isset($Format["AxisR"]) ? $Format["AxisR"] : 0;

    1763. 

  1763.      $AxisGo		= isset($Format["AxisG"]) ? $Format["AxisG"] : 0;

    1764. 

  1764.      $AxisBo		= isset($Format["AxisB"]) ? $Format["AxisB"] : 0;

    1765. 

  1765.      $AxisAlpha		= isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 100;

    1766. 

  1766.      $TickRo		= isset($Format["TickR"]) ? $Format["TickR"] : 0;

    1767. 

  1767.      $TickGo		= isset($Format["TickG"]) ? $Format["TickG"] : 0;

    1768. 

  1768.      $TickBo		= isset($Format["TickB"]) ? $Format["TickB"] : 0;

    1769. 

  1769.      $TickAlpha		= isset($Format["TickAlpha"]) ? $Format["TickAlpha"] : 100;

    1770. 

  1770.      $DrawSubTicks	= isset($Format["DrawSubTicks"]) ? $Format["DrawSubTicks"] : FALSE;

    1771. 

  1771.      $InnerSubTickWidth	= isset($Format["InnerSubTickWidth"]) ? $Format["InnerSubTickWidth"] : 0;

    1772. 

  1772.      $OuterSubTickWidth	= isset($Format["OuterSubTickWidth"]) ? $Format["OuterSubTickWidth"] : 2;

    1773. 

  1773.      $SubTickR		= isset($Format["SubTickR"]) ? $Format["SubTickR"] : 255;

    1774. 

  1774.      $SubTickG		= isset($Format["SubTickG"]) ? $Format["SubTickG"] : 0;

    1775. 

  1775.      $SubTickB		= isset($Format["SubTickB"]) ? $Format["SubTickB"] : 0;

    1776. 

  1776.      $SubTickAlpha	= isset($Format["SubTickAlpha"]) ? $Format["SubTickAlpha"] : 100;

    1777. 

  1777.      $AutoAxisLabels	= isset($Format["AutoAxisLabels"]) ? $Format["AutoAxisLabels"] : TRUE;

    1778. 

  1778.      $XReleasePercent	= isset($Format["XReleasePercent"]) ? $Format["XReleasePercent"] : 1;

    1779. 

  1779.      $DrawArrows	= isset($Format["DrawArrows"]) ? $Format["DrawArrows"] : FALSE;

    1780. 

  1780.      $ArrowSize         = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 8;

    1781. 

  1781.      $CycleBackground	= isset($Format["CycleBackground"]) ? $Format["CycleBackground"] : FALSE;

    1782. 

  1782.      $BackgroundR1	= isset($Format["BackgroundR1"]) ? $Format["BackgroundR1"] : 255;

    1783. 

  1783.      $BackgroundG1	= isset($Format["BackgroundG1"]) ? $Format["BackgroundG1"] : 255;

    1784. 

  1784.      $BackgroundB1	= isset($Format["BackgroundB1"]) ? $Format["BackgroundB1"] : 255;

    1785. 

  1785.      $BackgroundAlpha1	= isset($Format["BackgroundAlpha1"]) ? $Format["BackgroundAlpha1"] : 20;

    1786. 

  1786.      $BackgroundR2	= isset($Format["BackgroundR2"]) ? $Format["BackgroundR2"] : 230;

    1787. 

  1787.      $BackgroundG2	= isset($Format["BackgroundG2"]) ? $Format["BackgroundG2"] : 230;

    1788. 

  1788.      $BackgroundB2	= isset($Format["BackgroundB2"]) ? $Format["BackgroundB2"] : 230;

    1789. 

  1789.      $BackgroundAlpha2	= isset($Format["BackgroundAlpha2"]) ? $Format["BackgroundAlpha2"] : 20;

    1790. 

  1790.      $LabelingMethod	= isset($Format["LabelingMethod"]) ? $Format["LabelingMethod"] : LABELING_ALL;

    1791. 

  1791.      $LabelSkip		= isset($Format["LabelSkip"]) ? $Format["LabelSkip"] : 0;

    1792. 

  1792.      $LabelRotation	= isset($Format["LabelRotation"]) ? $Format["LabelRotation"] : 0;

    1793. 

  1793.      $RemoveSkippedAxis	= isset($Format["RemoveSkippedAxis"]) ? $Format["RemoveSkippedAxis"] : FALSE;

    1794. 

  1794.      $SkippedAxisTicks	= isset($Format["SkippedAxisTicks"]) ? $Format["SkippedAxisTicks"] : $GridTicks+2;

    1795. 

  1795.      $SkippedAxisR	= isset($Format["SkippedAxisR"]) ? $Format["SkippedAxisR"] : $GridR;

    1796. 

  1796.      $SkippedAxisG	= isset($Format["SkippedAxisG"]) ? $Format["SkippedAxisG"] : $GridG;

    1797. 

  1797.      $SkippedAxisB	= isset($Format["SkippedAxisB"]) ? $Format["SkippedAxisB"] : $GridB;

    1798. 

  1798.      $SkippedAxisAlpha	= isset($Format["SkippedAxisAlpha"]) ? $Format["SkippedAxisAlpha"] : $GridAlpha-30;

    1799. 

  1799.      $SkippedTickR	= isset($Format["SkippedTickR"]) ? $Format["SkippedTickR"] : $TickRo;

    1800. 

  1800.      $SkippedTickG	= isset($Format["SkippedTickG"]) ? $Format["SkippedTickG"] : $TickGo;

    1801. 

  1801.      $SkippedTickB	= isset($Format["SkippedTicksB"]) ? $Format["SkippedTickB"] : $TickBo;

    1802. 

  1802.      $SkippedTickAlpha	= isset($Format["SkippedTickAlpha"]) ? $Format["SkippedTickAlpha"] : $TickAlpha-80;

    1803. 

  1803.      $SkippedInnerTickWidth	= isset($Format["SkippedInnerTickWidth"]) ? $Format["SkippedInnerTickWidth"] : 0;

    1804. 

  1804.      $SkippedOuterTickWidth	= isset($Format["SkippedOuterTickWidth"]) ? $Format["SkippedOuterTickWidth"] : 2;

    1805. 

  1805. 

    1806. 

  1806.      /* Floating scale require X & Y margins to be set manually */

    1807. 

  1807.      if ( $Floating && ( $XMargin == AUTO || $YMargin == 0 ) ) { $Floating = FALSE; }

    1808. 

  1808. 

    1809. 

  1809.      /* Skip a NOTICE event in case of an empty array */

    1810. 

  1810.      if ( $DrawYLines == NONE || $DrawYLines == FALSE ) { $DrawYLines = array("zarma"=>"31"); }

    1811. 

  1811. 

    1812. 

  1812.      /* Define the color for the skipped elements */

    1813. 

  1813.      $SkippedAxisColor = array("R"=>$SkippedAxisR,"G"=>$SkippedAxisG,"B"=>$SkippedAxisB,"Alpha"=>$SkippedAxisAlpha,"Ticks"=>$SkippedAxisTicks);

    1814. 

  1814.      $SkippedTickColor = array("R"=>$SkippedTickR,"G"=>$SkippedTickG,"B"=>$SkippedTickB,"Alpha"=>$SkippedTickAlpha);

    1815. 

  1815. 

    1816. 

  1816.      $Data = $this->DataSet->getData();

    1817. 

  1817.      if ( isset($Data["Abscissa"]) ) { $Abscissa = $Data["Abscissa"]; } else { $Abscissa = NULL; }

    1818. 

  1818. 

    1819. 

  1819.      /* Unset the abscissa axis, needed if we display multiple charts on the same picture */

    1820. 

  1820.      if ( $Abscissa != NULL )

    1821. 

  1821.       {

    1822. 

  1822.        foreach($Data["Axis"] as $AxisID => $Parameters)

    1823. 

  1823.         { if ($Parameters["Identity"] == AXIS_X) { unset($Data["Axis"][$AxisID]); } }

    1824. 

  1824.       }

    1825. 

  1825. 

    1826. 

  1826.      /* Build the scale settings */

    1827. 

  1827.      $GotXAxis = FALSE;

    1828. 

  1828.      foreach($Data["Axis"] as $AxisID => $AxisParameter)

    1829. 

  1829.       {

    1830. 

  1830.        if ( $AxisParameter["Identity"] == AXIS_X ) { $GotXAxis = TRUE; }

    1831. 

  1831. 

    1832. 

  1832.        if ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_Y)

    1833. 

  1833.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1 - $YMargin*2; }

    1834. 

  1834.        elseif ( $Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_X)

    1835. 

  1835.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }

    1836. 

  1836.        elseif ( $Pos == SCALE_POS_TOPBOTTOM && $AxisParameter["Identity"] == AXIS_Y)

    1837. 

  1837.         { $Height = $this->GraphAreaX2-$this->GraphAreaX1 - $YMargin*2;; }

    1838. 

  1838.        else

    1839. 

  1839.         { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }

    1840. 

  1840. 

    1841. 

  1841.        $AxisMin = ABSOLUTE_MAX; $AxisMax = OUT_OF_SIGHT;

    1842. 

  1842.        if ( $Mode == SCALE_MODE_FLOATING || $Mode == SCALE_MODE_START0 )

    1843. 

  1843.         {

    1844. 

  1844.          foreach($Data["Series"] as $SerieID => $SerieParameter)

    1845. 

  1845.           {

    1846. 

  1846.            if ( $SerieParameter["Axis"] == $AxisID && $Data["Series"][$SerieID]["isDrawable"] && $Data["Abscissa"] != $SerieID)

    1847. 

  1847.             {

    1848. 

  1848.              $AxisMax = max($AxisMax,$Data["Series"][$SerieID]["Max"]);

    1849. 

  1849.              $AxisMin = min($AxisMin,$Data["Series"][$SerieID]["Min"]);

    1850. 

  1850.             }

    1851. 

  1851.           }

    1852. 

  1852.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;

    1853. 

  1853. 

    1854. 

  1854.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;

    1855. 

  1855.          if ( $Mode == SCALE_MODE_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; }

    1856. 

  1856.         }

    1857. 

  1857.        elseif ( $Mode == SCALE_MODE_MANUAL )

    1858. 

  1858.         {

    1859. 

  1859.          if ( isset($ManualScale[$AxisID]["Min"]) && isset($ManualScale[$AxisID]["Max"]) )

    1860. 

  1860.           {

    1861. 

  1861.            $Data["Axis"][$AxisID]["Min"] = $ManualScale[$AxisID]["Min"];

    1862. 

  1862.            $Data["Axis"][$AxisID]["Max"] = $ManualScale[$AxisID]["Max"];

    1863. 

  1863.           }

    1864. 

  1864.          else

    1865. 

  1865.           { echo "Manual scale boundaries not set."; exit(); }

    1866. 

  1866.         }

    1867. 

  1867.        elseif ( $Mode == SCALE_MODE_ADDALL || $Mode == SCALE_MODE_ADDALL_START0 )

    1868. 

  1868.         {

    1869. 

  1869.          $Series = "";

    1870. 

  1870.          foreach($Data["Series"] as $SerieID => $SerieParameter)

    1871. 

  1871.           { if ( $SerieParameter["Axis"] == $AxisID && $SerieParameter["isDrawable"] && $Data["Abscissa"] != $SerieID ) { $Series[$SerieID] = count($Data["Series"][$SerieID]["Data"]); } }

    1872. 

  1872. 

    1873. 

  1873.          for ($ID=0;$ID<=max($Series)-1;$ID++)

    1874. 

  1874.           {

    1875. 

  1875.            $PointMin = 0; $PointMax = 0;

    1876. 

  1876.            foreach($Series as $SerieID => $ValuesCount )

    1877. 

  1877.             {

    1878. 

  1878.              if (isset($Data["Series"][$SerieID]["Data"][$ID]) && $Data["Series"][$SerieID]["Data"][$ID] != NULL )

    1879. 

  1879.               {

    1880. 

  1880.                $Value = $Data["Series"][$SerieID]["Data"][$ID];

    1881. 

  1881.                if ( $Value > 0 ) { $PointMax = $PointMax + $Value; } else { $PointMin = $PointMin + $Value; }

    1882. 

  1882.               }

    1883. 

  1883.             }

    1884. 

  1884.            $AxisMax = max($AxisMax,$PointMax);

    1885. 

  1885.            $AxisMin = min($AxisMin,$PointMin);

    1886. 

  1886.           }

    1887. 

  1887.          $AutoMargin = (($AxisMax-$AxisMin)/100)*$XReleasePercent;

    1888. 

  1888.          $Data["Axis"][$AxisID]["Min"] = $AxisMin-$AutoMargin; $Data["Axis"][$AxisID]["Max"] = $AxisMax+$AutoMargin;

    1889. 

  1889.         }

    1890. 

  1890.        $MaxDivs = floor($Height/$MinDivHeight);

    1891. 

  1891. 

    1892. 

  1892.        if ( $Mode == SCALE_MODE_ADDALL_START0 ) { $Data["Axis"][$AxisID]["Min"] = 0; }

    1893. 

  1893. 

    1894. 

  1894.        $Scale   = $this->computeScale($Data["Axis"][$AxisID]["Min"],$Data["Axis"][$AxisID]["Max"],$MaxDivs,$Factors,$AxisID);

    1895. 

  1895. 

    1896. 

  1896.        $Data["Axis"][$AxisID]["Margin"]    = $AxisParameter["Identity"] == AXIS_X ? $XMargin : $YMargin;

    1897. 

  1897.        $Data["Axis"][$AxisID]["ScaleMin"]  = $Scale["XMin"];

    1898. 

  1898.        $Data["Axis"][$AxisID]["ScaleMax"]  = $Scale["XMax"];

    1899. 

  1899.        $Data["Axis"][$AxisID]["Rows"]      = $Scale["Rows"];

    1900. 

  1900.        $Data["Axis"][$AxisID]["RowHeight"] = $Scale["RowHeight"];

    1901. 

  1901. 

    1902. 

  1902.        if ( isset($Scale["Format"]) ) { $Data["Axis"][$AxisID]["Format"] = $Scale["Format"]; }

    1903. 

  1903. 

    1904. 

  1904.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }

    1905. 

  1905.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }

    1906. 

  1906.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }

    1907. 

  1907.       }

    1908. 

  1908. 

    1909. 

  1909.      /* Still no X axis */

    1910. 

  1910.      if ( $GotXAxis == FALSE )

    1911. 

  1911.       {

    1912. 

  1912.        if ( $Abscissa != NULL )

    1913. 

  1913.         {

    1914. 

  1914.          $Points = count($Data["Series"][$Abscissa]["Data"]);

    1915. 

  1915.          if ( $AutoAxisLabels )

    1916. 

  1916.           $AxisName = isset($Data["Series"][$Abscissa]["Description"]) ? $Data["Series"][$Abscissa]["Description"] : NULL;

    1917. 

  1917.          else

    1918. 

  1918.           $AxisName = NULL;

    1919. 

  1919.         }

    1920. 

  1920.        else

    1921. 

  1921.         {

    1922. 

  1922.          $Points = 0;

    1923. 

  1923.          $AxisName = isset($Data["XAxisName"]) ? $Data["XAxisName"] : NULL;

    1924. 

  1924.          foreach($Data["Series"] as $SerieID => $SerieParameter)

    1925. 

  1925.           { if ( $SerieParameter["isDrawable"] ) { $Points = max($Points,count($SerieParameter["Data"])); } }

    1926. 

  1926.         }

    1927. 

  1927. 

    1928. 

  1928.        $AxisID = count($Data["Axis"]);

    1929. 

  1929.        $Data["Axis"][$AxisID]["Identity"] = AXIS_X;

    1930. 

  1930.        if ( $Pos == SCALE_POS_LEFTRIGHT ) { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_BOTTOM; } else { $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_LEFT; }

    1931. 

  1931.        if ( isset($Data["AbscissaName"]) ) { $Data["Axis"][$AxisID]["Name"] = $Data["AbscissaName"]; }

    1932. 

  1932.        if ( $XMargin == AUTO )

    1933. 

  1933.         {

    1934. 

  1934.          if ( $Pos == SCALE_POS_LEFTRIGHT )

    1935. 

  1935.           { $Height = $this->GraphAreaX2-$this->GraphAreaX1; }

    1936. 

  1936.          else

    1937. 

  1937.           { $Height = $this->GraphAreaY2-$this->GraphAreaY1; }

    1938. 

  1938. 

    1939. 

  1939.          if ( $Points == 1 )

    1940. 

  1940.           $Data["Axis"][$AxisID]["Margin"] = $Height / 2;

    1941. 

  1941.          else

    1942. 

  1942.           $Data["Axis"][$AxisID]["Margin"] = ($Height/$Points) / 2;

    1943. 

  1943.         }

    1944. 

  1944.        else

    1945. 

  1945.         { $Data["Axis"][$AxisID]["Margin"] = $XMargin; }

    1946. 

  1946.        $Data["Axis"][$AxisID]["Rows"] = $Points-1;

    1947. 

  1947.        if ( !isset($Data["Axis"][$AxisID]["Display"]) ) { $Data["Axis"][$AxisID]["Display"] = NULL; }

    1948. 

  1948.        if ( !isset($Data["Axis"][$AxisID]["Format"]) )  { $Data["Axis"][$AxisID]["Format"] = NULL; }

    1949. 

  1949.        if ( !isset($Data["Axis"][$AxisID]["Unit"]) )    { $Data["Axis"][$AxisID]["Unit"] = NULL; }

    1950. 

  1950.       }

    1951. 

  1951. 

    1952. 

  1952.      /* Do we need to reverse the abscissa position? */

    1953. 

  1953.      if ( $Pos != SCALE_POS_LEFTRIGHT )

    1954. 

  1954.       {

    1955. 

  1955.        if ( $Data["AbsicssaPosition"] == AXIS_POSITION_BOTTOM )

    1956. 

  1956.         { $Data["AbsicssaPosition"] = AXIS_POSITION_LEFT; }

    1957. 

  1957.        else

    1958. 

  1958.         { $Data["AbsicssaPosition"] = AXIS_POSITION_RIGHT; }

    1959. 

  1959.       }

    1960. 

  1960.      $Data["Axis"][$AxisID]["Position"] = $Data["AbsicssaPosition"];

    1961. 

  1961. 

    1962. 

  1962.      $this->DataSet->saveOrientation($Pos);

    1963. 

  1963.      $this->DataSet->saveAxisConfig($Data["Axis"]);

    1964. 

  1964.      $this->DataSet->saveYMargin($YMargin);

    1965. 

  1965. 

    1966. 

  1966.      $FontColorRo = $this->FontColorR; $FontColorGo = $this->FontColorG; $FontColorBo = $this->FontColorB;

    1967. 

  1967. 

    1968. 

  1968.      $AxisPos["L"] = $this->GraphAreaX1; $AxisPos["R"] = $this->GraphAreaX2; $AxisPos["T"] = $this->GraphAreaY1; $AxisPos["B"] = $this->GraphAreaY2;

    1969. 

  1969.      foreach($Data["Axis"] as $AxisID => $Parameters)

    1970. 

  1970.       {

    1971. 

  1971.        if ( isset($Parameters["Color"]) )

    1972. 

  1972.         {

    1973. 

  1973.          $AxisR = $Parameters["Color"]["R"]; $AxisG = $Parameters["Color"]["G"]; $AxisB = $Parameters["Color"]["B"];

    1974. 

  1974.          $TickR = $Parameters["Color"]["R"]; $TickG = $Parameters["Color"]["G"]; $TickB = $Parameters["Color"]["B"];

    1975. 

  1975.          $this->setFontProperties(array("R"=>$Parameters["Color"]["R"],"G"=>$Parameters["Color"]["G"],"B"=>$Parameters["Color"]["B"]));

    1976. 

  1976.         }

    1977. 

  1977.        else

    1978. 

  1978.         {

    1979. 

  1979.          $AxisR = $AxisRo; $AxisG = $AxisGo; $AxisB = $AxisBo;

    1980. 

  1980.          $TickR = $TickRo; $TickG = $TickGo; $TickB = $TickBo;

    1981. 

  1981.          $this->setFontProperties(array("R"=>$FontColorRo,"G"=>$FontColorGo,"B"=>$FontColorBo));

    1982. 

  1982.         }

    1983. 

  1983. 

    1984. 

  1984.        $LastValue = "w00t"; $ID = 1;

    1985. 

  1985.        if ( $Parameters["Identity"] == AXIS_X )

    1986. 

  1986.         {

    1987. 

  1987.          if ( $Pos == SCALE_POS_LEFTRIGHT )

    1988. 

  1988.           {

    1989. 

  1989.            if ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )

    1990. 

  1990.             {

    1991. 

  1991.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 2; }

    1992. 

  1992.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }

    1993. 

  1993.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 5; }

    1994. 

  1994.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }

    1995. 

  1995. 

    1996. 

  1996.              if ( !$RemoveXAxis )

    1997. 

  1997.               {

    1998. 

  1998.                if ( $Floating )

    1999. 

  1999.                 { $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)); }

    2000. 

  2000.                else

    2001. 

  2001.                 { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2002. 

  2002. 

    2003. 

  2003.                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)); }

    2004. 

  2004.               }

    2005. 

  2005. 

    2006. 

  2006.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

    2007. 

  2007. 

    2008. 

  2008.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / ($Parameters["Rows"]); }

    2009. 

  2009.              

    2010. 

  2010.              $MaxBottom = $AxisPos["B"];

    2011. 

  2011.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2012. 

  2012.               {

    2013. 

  2013.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

    2014. 

  2014.                $YPos  = $AxisPos["B"];

    2015. 

  2015. 

    2016. 

  2016.                if ( $Abscissa != NULL )

    2017. 

  2017.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

    2018. 

  2018.                else

    2019. 

  2019.                 {

    2020. 

  2020.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

    2021. 

  2021.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

    2022. 

  2022.                  else

    2023. 

  2023.                   $Value = $i;

    2024. 

  2024.                 }

    2025. 

  2025. 

    2026. 

  2026.                $ID++; $Skipped = TRUE;

    2027. 

  2027.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

    2028. 

  2028.                 {

    2029. 

  2029.                  $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

    2030. 

  2030.                  $TxtBottom = $YPos+$OuterTickWidth+2+($Bounds[0]["Y"]-$Bounds[2]["Y"]);

    2031. 

  2031.                  $MaxBottom = max($MaxBottom,$TxtBottom);

    2032. 

  2032.                  $LastValue = $Value;

    2033. 

  2033.                  $Skipped   = FALSE;

    2034. 

  2034.                 }

    2035. 

  2035. 

    2036. 

  2036.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

    2037. 

  2037. 

    2038. 

  2038.                if ( $Skipped )

    2039. 

  2039.                 {

    2040. 

  2040.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }

    2041. 

  2041.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) { $this->drawLine($XPos,$YPos-$SkippedInnerTickWidth,$XPos,$YPos+$SkippedOuterTickWidth,$SkippedTickColor); }

    2042. 

  2042.                 }

    2043. 

  2043.                else

    2044. 

  2044.                 {

    2045. 

  2045.                  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)); }

    2046. 

  2046.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos,$YPos-$InnerTickWidth,$XPos,$YPos+$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

    2047. 

  2047.                 }

    2048. 

  2048.               }

    2049. 

  2049. 

    2050. 

  2050.              if ( isset($Parameters["Name"]) && !$RemoveXAxis)

    2051. 

  2051.               {

    2052. 

  2052.                $YPos   = $MaxBottom+2;

    2053. 

  2053.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

    2054. 

  2054.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));

    2055. 

  2055.                $MaxBottom = $Bounds[0]["Y"];

    2056. 

  2056. 

    2057. 

  2057.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;

    2058. 

  2058.               }

    2059. 

  2059. 

    2060. 

  2060.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;

    2061. 

  2061.             }

    2062. 

  2062.            elseif ( $Parameters["Position"] == AXIS_POSITION_TOP )

    2063. 

  2063.             {

    2064. 

  2064.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE; $YLabelOffset = 2; }

    2065. 

  2065.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $YLabelOffset = 2; }

    2066. 

  2066.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_TOPMIDDLE; $YLabelOffset = 5; }

    2067. 

  2067.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $YLabelOffset = 5; }

    2068. 

  2068. 

    2069. 

  2069.              if ( !$RemoveXAxis )

    2070. 

  2070.               {

    2071. 

  2071.                if ( $Floating )

    2072. 

  2072.                 { $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)); }

    2073. 

  2073.                else

    2074. 

  2074.                 { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2075. 

  2075. 

    2076. 

  2076.                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)); }

    2077. 

  2077.               }

    2078. 

  2078. 

    2079. 

  2079.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

    2080. 

  2080. 

    2081. 

  2081.              if ($Parameters["Rows"] == 0 ) { $Step  = $Width; } else { $Step  = $Width / $Parameters["Rows"]; }

    2082. 

  2082.              

    2083. 

  2083.              $MinTop = $AxisPos["T"];

    2084. 

  2084.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2085. 

  2085.               {

    2086. 

  2086.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

    2087. 

  2087.                $YPos  = $AxisPos["T"];

    2088. 

  2088. 

    2089. 

  2089.                if ( $Abscissa != NULL )

    2090. 

  2090.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

    2091. 

  2091.                else

    2092. 

  2092.                 {

    2093. 

  2093.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

    2094. 

  2094.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

    2095. 

  2095.                  else

    2096. 

  2096.                   $Value = $i;

    2097. 

  2097.                 }

    2098. 

  2098. 

    2099. 

  2099.                $ID++; $Skipped = TRUE;

    2100. 

  2100.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

    2101. 

  2101.                 {

    2102. 

  2102.                  $Bounds = $this->drawText($XPos,$YPos-$OuterTickWidth-$YLabelOffset,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

    2103. 

  2103.                  $TxtBox = $YPos-$OuterTickWidth-2-($Bounds[0]["Y"]-$Bounds[2]["Y"]);

    2104. 

  2104.                  $MinTop = min($MinTop,$TxtBox);

    2105. 

  2105.                  $LastValue = $Value;

    2106. 

  2106.                  $Skipped   = FALSE;

    2107. 

  2107.                 }

    2108. 

  2108. 

    2109. 

  2109.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

    2110. 

  2110. 

    2111. 

  2111.                if ( $Skipped )

    2112. 

  2112.                 {

    2113. 

  2113.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$SkippedAxisColor); }

    2114. 

  2114.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos,$YPos+$SkippedInnerTickWidth,$XPos,$YPos-$SkippedOuterTickWidth,$SkippedTickColor); }

    2115. 

  2115.                 }

    2116. 

  2116.                else

    2117. 

  2117.                 {

    2118. 

  2118.                  if ( $DrawXLines ) { $this->drawLine($XPos,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

    2119. 

  2119.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos,$YPos+$InnerTickWidth,$XPos,$YPos-$OuterTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

    2120. 

  2120.                 }

    2121. 

  2121. 

    2122. 

  2122.               }

    2123. 

  2123. 

    2124. 

  2124.              if ( isset($Parameters["Name"]) && !$RemoveXAxis )

    2125. 

  2125.               {

    2126. 

  2126.                $YPos   = $MinTop-2;

    2127. 

  2127.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

    2128. 

  2128.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    2129. 

  2129.                $MinTop = $Bounds[2]["Y"];

    2130. 

  2130. 

    2131. 

  2131.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;

    2132. 

  2132.               }

    2133. 

  2133. 

    2134. 

  2134.              $AxisPos["T"] = $MinTop - $ScaleSpacing;

    2135. 

  2135.             }

    2136. 

  2136.           }

    2137. 

  2137.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )

    2138. 

  2138.           {

    2139. 

  2139.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )

    2140. 

  2140.             {

    2141. 

  2141.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -2; }

    2142. 

  2142.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = -6; }

    2143. 

  2143.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -2; }

    2144. 

  2144.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = -5; }

    2145. 

  2145. 

    2146. 

  2146.              if ( !$RemoveXAxis )

    2147. 

  2147.               {

    2148. 

  2148.                if ( $Floating )

    2149. 

  2149.                 { $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)); }

    2150. 

  2150.                else

    2151. 

  2151.                 { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2152. 

  2152. 

    2153. 

  2153.                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)); }

    2154. 

  2154.               }

    2155. 

  2155. 

    2156. 

  2156.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

    2157. 

  2157. 

    2158. 

  2158.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }

    2159. 

  2159. 

    2160. 

  2160.              $MinLeft = $AxisPos["L"];

    2161. 

  2161.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2162. 

  2162.               {

    2163. 

  2163.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;

    2164. 

  2164.                $XPos  = $AxisPos["L"];

    2165. 

  2165. 

    2166. 

  2166.                if ( $Abscissa != NULL )

    2167. 

  2167.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

    2168. 

  2168.                else

    2169. 

  2169.                 {

    2170. 

  2170.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

    2171. 

  2171.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

    2172. 

  2172.                  else

    2173. 

  2173.                   $Value = $i;

    2174. 

  2174.                 }

    2175. 

  2175. 

    2176. 

  2176.                $ID++; $Skipped = TRUE;

    2177. 

  2177.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

    2178. 

  2178.                 {

    2179. 

  2179.                  $Bounds  = $this->drawText($XPos-$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

    2180. 

  2180.                  $TxtBox  = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);

    2181. 

  2181.                  $MinLeft = min($MinLeft,$TxtBox);

    2182. 

  2182.                  $LastValue = $Value;

    2183. 

  2183.                  $Skipped   = FALSE;

    2184. 

  2184.                 }

    2185. 

  2185. 

    2186. 

  2186.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

    2187. 

  2187. 

    2188. 

  2188.                if ( $Skipped )

    2189. 

  2189.                 {

    2190. 

  2190.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }

    2191. 

  2191.                  if ( ($SkippedInnerTickWidth !=0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos-$SkippedOuterTickWidth,$YPos,$XPos+$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }

    2192. 

  2192.                 }

    2193. 

  2193.                else

    2194. 

  2194.                 {

    2195. 

  2195.                  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)); }

    2196. 

  2196.                  if ( ($InnerTickWidth !=0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

    2197. 

  2197.                 }

    2198. 

  2198. 

    2199. 

  2199.               }

    2200. 

  2200.              if ( isset($Parameters["Name"]) && !$RemoveXAxis )

    2201. 

  2201.               {

    2202. 

  2202.                $XPos   = $MinLeft-2;

    2203. 

  2203.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

    2204. 

  2204.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));

    2205. 

  2205.                $MinLeft = $Bounds[0]["X"];

    2206. 

  2206. 

    2207. 

  2207.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;

    2208. 

  2208.               }

    2209. 

  2209. 

    2210. 

  2210.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;

    2211. 

  2211.             }

    2212. 

  2212.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )

    2213. 

  2213.             {

    2214. 

  2214.              if ( $LabelRotation == 0 )					{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 2; }

    2215. 

  2215.              if ( $LabelRotation > 0 && $LabelRotation < 190 )		{ $LabelAlign = TEXT_ALIGN_MIDDLELEFT; $XLabelOffset = 6; }

    2216. 

  2216.              if ( $LabelRotation == 180 )				{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 5; }

    2217. 

  2217.              if ( $LabelRotation > 180 && $LabelRotation < 360 )	{ $LabelAlign = TEXT_ALIGN_MIDDLERIGHT; $XLabelOffset = 7; }

    2218. 

  2218. 

    2219. 

  2219.              if ( !$RemoveXAxis )

    2220. 

  2220.               {

    2221. 

  2221.                if ( $Floating )

    2222. 

  2222.                 { $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)); }

    2223. 

  2223.                else

    2224. 

  2224.                 { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2225. 

  2225. 

    2226. 

  2226.                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)); }

    2227. 

  2227.               }

    2228. 

  2228. 

    2229. 

  2229.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

    2230. 

  2230. 

    2231. 

  2231.              if ($Parameters["Rows"] == 0 ) { $Step  = $Height; } else { $Step   = $Height / $Parameters["Rows"]; }

    2232. 

  2232.              

    2233. 

  2233.              $MaxRight = $AxisPos["R"];

    2234. 

  2234.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2235. 

  2235.               {

    2236. 

  2236.                $YPos  = $this->GraphAreaY1 + $Parameters["Margin"] + $Step*$i;

    2237. 

  2237.                $XPos  = $AxisPos["R"];

    2238. 

  2238. 

    2239. 

  2239.                if ( $Abscissa != NULL )

    2240. 

  2240.                 { if ( isset($Data["Series"][$Abscissa]["Data"][$i]) ) { $Value = $this->scaleFormat($Data["Series"][$Abscissa]["Data"][$i],$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]); } else { $Value = ""; } }

    2241. 

  2241.                else

    2242. 

  2242.                 {

    2243. 

  2243.                  if ( isset($Parameters["ScaleMin"]) && isset ($Parameters["RowHeight"]) )

    2244. 

  2244.                   $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Data["XAxisDisplay"],$Data["XAxisFormat"],$Data["XAxisUnit"]);

    2245. 

  2245.                  else

    2246. 

  2246.                   $Value = $i;

    2247. 

  2247.                 }

    2248. 

  2248. 

    2249. 

  2249.                $ID++; $Skipped = TRUE;

    2250. 

  2250.                if ( $this->isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip) && !$RemoveXAxis)

    2251. 

  2251.                 {

    2252. 

  2252.                  $Bounds   = $this->drawText($XPos+$OuterTickWidth+$XLabelOffset,$YPos,$Value,array("Angle"=>$LabelRotation,"Align"=>$LabelAlign));

    2253. 

  2253.                  $TxtBox   = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);

    2254. 

  2254.                  $MaxRight = max($MaxRight,$TxtBox);

    2255. 

  2255.                  $LastValue = $Value;

    2256. 

  2256.                  $Skipped   = FALSE;

    2257. 

  2257.                 }

    2258. 

  2258. 

    2259. 

  2259.                if ( $RemoveXAxis ) { $Skipped   = FALSE; }

    2260. 

  2260. 

    2261. 

  2261.                if ( $Skipped )

    2262. 

  2262.                 {

    2263. 

  2263.                  if ( $DrawXLines && !$RemoveSkippedAxis ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,$SkippedAxisColor); }

    2264. 

  2264.                  if ( ($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis ) { $this->drawLine($XPos+$SkippedOuterTickWidth,$YPos,$XPos-$SkippedInnerTickWidth,$YPos,$SkippedTickColor); }

    2265. 

  2265.                 }

    2266. 

  2266.                else

    2267. 

  2267.                 {

    2268. 

  2268.                  if ( $DrawXLines ) { $this->drawLine($this->GraphAreaX1+$FloatingOffset,$YPos,$this->GraphAreaX2-$FloatingOffset,$YPos,array("R"=>$GridR,"G"=>$GridG,"B"=>$GridB,"Alpha"=>$GridAlpha,"Ticks"=>$GridTicks)); }

    2269. 

  2269.                  if ( ($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis ) { $this->drawLine($XPos+$OuterTickWidth,$YPos,$XPos-$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha)); }

    2270. 

  2270.                 }

    2271. 

  2271. 

    2272. 

  2272.               }

    2273. 

  2273. 

    2274. 

  2274.              if ( isset($Parameters["Name"]) && !$RemoveXAxis)

    2275. 

  2275.               {

    2276. 

  2276.                $XPos   = $MaxRight+4;

    2277. 

  2277.                $YPos   = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

    2278. 

  2278.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));

    2279. 

  2279.                $MaxRight = $Bounds[1]["X"];

    2280. 

  2280. 

    2281. 

  2281.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxRight + $this->FontSize;

    2282. 

  2282.               }

    2283. 

  2283. 

    2284. 

  2284.              $AxisPos["R"] = $MaxRight + $ScaleSpacing;

    2285. 

  2285.             }

    2286. 

  2286.           }

    2287. 

  2287.         }

    2288. 

  2288. 

    2289. 

  2289. 

    2290. 

  2290. 

    2291. 

  2291.        if ( $Parameters["Identity"] == AXIS_Y )

    2292. 

  2292.         {

    2293. 

  2293.          if ( $Pos == SCALE_POS_LEFTRIGHT )

    2294. 

  2294.           {

    2295. 

  2295.            if ( $Parameters["Position"] == AXIS_POSITION_LEFT )

    2296. 

  2296.             {

    2297. 

  2297. 

    2298. 

  2298.              if ( $Floating )

    2299. 

  2299.               { $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)); }

    2300. 

  2300.              else

    2301. 

  2301.               { $FloatingOffset = 0; $this->drawLine($AxisPos["L"],$this->GraphAreaY1,$AxisPos["L"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2302. 

  2302. 

    2303. 

  2303.              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)); }

    2304. 

  2304. 

    2305. 

  2305.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

    2306. 

  2306.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinLeft = $AxisPos["L"];

    2307. 

  2307.              $LastY  = NULL;

    2308. 

  2308.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2309. 

  2309.               {

    2310. 

  2310.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;

    2311. 

  2311.                $XPos  = $AxisPos["L"];

    2312. 

  2312.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

    2313. 

  2313. 

    2314. 

  2314.                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); }

    2315. 

  2315.                if ( $LastY != NULL && $CycleBackground && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }

    2316. 

  2316. 

    2317. 

  2317.                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)); }

    2318. 

  2318. 

    2319. 

  2319.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

    2320. 

  2320.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

    2321. 

  2321. 

    2322. 

  2322.                $this->drawLine($XPos-$OuterTickWidth,$YPos,$XPos+$InnerTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

    2323. 

  2323.                $Bounds  = $this->drawText($XPos-$OuterTickWidth-2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));

    2324. 

  2324.                $TxtLeft = $XPos-$OuterTickWidth-2-($Bounds[1]["X"]-$Bounds[0]["X"]);

    2325. 

  2325.                $MinLeft = min($MinLeft,$TxtLeft);

    2326. 

  2326. 

    2327. 

  2327.                $LastY = $YPos;

    2328. 

  2328.               }

    2329. 

  2329. 

    2330. 

  2330.              if ( isset($Parameters["Name"]) )

    2331. 

  2331.               {

    2332. 

  2332.                $XPos    = $MinLeft-2;

    2333. 

  2333.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

    2334. 

  2334.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>90));

    2335. 

  2335.                $MinLeft = $Bounds[2]["X"];

    2336. 

  2336. 

    2337. 

  2337.                $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;

    2338. 

  2338.               }

    2339. 

  2339. 

    2340. 

  2340.              $AxisPos["L"] = $MinLeft - $ScaleSpacing;

    2341. 

  2341.             }

    2342. 

  2342.            elseif ( $Parameters["Position"] == AXIS_POSITION_RIGHT )

    2343. 

  2343.             {

    2344. 

  2344.              if ( $Floating )

    2345. 

  2345.               { $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)); }

    2346. 

  2346.              else

    2347. 

  2347.               { $FloatingOffset = 0; $this->drawLine($AxisPos["R"],$this->GraphAreaY1,$AxisPos["R"],$this->GraphAreaY2,array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2348. 

  2348. 

    2349. 

  2349.              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)); }

    2350. 

  2350. 

    2351. 

  2351.              $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Parameters["Margin"]*2;

    2352. 

  2352.              $Step   = $Height / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxLeft = $AxisPos["R"];

    2353. 

  2353.              $LastY  = NULL;

    2354. 

  2354.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2355. 

  2355.               {

    2356. 

  2356.                $YPos  = $this->GraphAreaY2 - $Parameters["Margin"] - $Step*$i;

    2357. 

  2357.                $XPos  = $AxisPos["R"];

    2358. 

  2358.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

    2359. 

  2359. 

    2360. 

  2360.                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); }

    2361. 

  2361.                if ( $LastY != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($this->GraphAreaX1+$FloatingOffset,$LastY,$this->GraphAreaX2-$FloatingOffset,$YPos,$BGColor); }

    2362. 

  2362. 

    2363. 

  2363.                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)); }

    2364. 

  2364. 

    2365. 

  2365.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

    2366. 

  2366.                 $this->drawLine($XPos-$OuterSubTickWidth,$YPos-$SubTicksSize,$XPos+$InnerSubTickWidth,$YPos-$SubTicksSize,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

    2367. 

  2367. 

    2368. 

  2368.                $this->drawLine($XPos-$InnerTickWidth,$YPos,$XPos+$OuterTickWidth,$YPos,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

    2369. 

  2369.                $Bounds  = $this->drawText($XPos+$OuterTickWidth+2,$YPos,$Value,array("Align"=>TEXT_ALIGN_MIDDLELEFT));

    2370. 

  2370.                $TxtLeft = $XPos+$OuterTickWidth+2+($Bounds[1]["X"]-$Bounds[0]["X"]);

    2371. 

  2371.                $MaxLeft = max($MaxLeft,$TxtLeft);

    2372. 

  2372. 

    2373. 

  2373.                $LastY = $YPos;

    2374. 

  2374.               }

    2375. 

  2375. 

    2376. 

  2376.              if ( isset($Parameters["Name"]) )

    2377. 

  2377.               {

    2378. 

  2378.                $XPos    = $MaxLeft+6;

    2379. 

  2379.                $YPos    = $this->GraphAreaY1+($this->GraphAreaY2-$this->GraphAreaY1)/2;

    2380. 

  2380.                $Bounds  = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE,"Angle"=>270));

    2381. 

  2381.                $MaxLeft = $Bounds[2]["X"];

    2382. 

  2382. 

    2383. 

  2383.                $this->DataSet->Data["GraphArea"]["X2"] = $MaxLeft + $this->FontSize;

    2384. 

  2384.               }

    2385. 

  2385.              $AxisPos["R"] = $MaxLeft + $ScaleSpacing;

    2386. 

  2386.             }

    2387. 

  2387.           }

    2388. 

  2388.          elseif ( $Pos == SCALE_POS_TOPBOTTOM )

    2389. 

  2389.           {

    2390. 

  2390.            if ( $Parameters["Position"] == AXIS_POSITION_TOP )

    2391. 

  2391.             {

    2392. 

  2392.              if ( $Floating )

    2393. 

  2393.               { $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)); }

    2394. 

  2394.              else

    2395. 

  2395.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["T"],$this->GraphAreaX2,$AxisPos["T"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2396. 

  2396. 

    2397. 

  2397.              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)); }

    2398. 

  2398. 

    2399. 

  2399.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

    2400. 

  2400.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MinTop = $AxisPos["T"];

    2401. 

  2401.              $LastX  = NULL;

    2402. 

  2402.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2403. 

  2403.               {

    2404. 

  2404.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

    2405. 

  2405.                $YPos  = $AxisPos["T"];

    2406. 

  2406.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

    2407. 

  2407. 

    2408. 

  2408.                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); }

    2409. 

  2409.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }

    2410. 

  2410. 

    2411. 

  2411.                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)); }

    2412. 

  2412. 

    2413. 

  2413.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

    2414. 

  2414.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

    2415. 

  2415. 

    2416. 

  2416.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

    2417. 

  2417.                $Bounds    = $this->drawText($XPos,$YPos-$OuterTickWidth-2,$Value,array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    2418. 

  2418.                $TxtHeight = $YPos-$OuterTickWidth-2-($Bounds[1]["Y"]-$Bounds[2]["Y"]);

    2419. 

  2419.                $MinTop    = min($MinTop,$TxtHeight);

    2420. 

  2420. 

    2421. 

  2421.                $LastX = $XPos;

    2422. 

  2422.               }

    2423. 

  2423. 

    2424. 

  2424.              if ( isset($Parameters["Name"]) )

    2425. 

  2425.               {

    2426. 

  2426.                $YPos   = $MinTop-2;

    2427. 

  2427.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

    2428. 

  2428.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    2429. 

  2429.                $MinTop = $Bounds[2]["Y"];

    2430. 

  2430. 

    2431. 

  2431.                $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;

    2432. 

  2432.               }

    2433. 

  2433. 

    2434. 

  2434.              $AxisPos["T"] = $MinTop - $ScaleSpacing;

    2435. 

  2435.             }

    2436. 

  2436.            elseif ( $Parameters["Position"] == AXIS_POSITION_BOTTOM )

    2437. 

  2437.             {

    2438. 

  2438.              if ( $Floating )

    2439. 

  2439.               { $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)); }

    2440. 

  2440.              else

    2441. 

  2441.               { $FloatingOffset = 0; $this->drawLine($this->GraphAreaX1,$AxisPos["B"],$this->GraphAreaX2,$AxisPos["B"],array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha)); }

    2442. 

  2442. 

    2443. 

  2443.              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)); }

    2444. 

  2444. 

    2445. 

  2445.              $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Parameters["Margin"]*2;

    2446. 

  2446.              $Step   = $Width / $Parameters["Rows"]; $SubTicksSize = $Step /2; $MaxBottom = $AxisPos["B"];

    2447. 

  2447.              $LastX  = NULL;

    2448. 

  2448.              for($i=0;$i<=$Parameters["Rows"];$i++)

    2449. 

  2449.               {

    2450. 

  2450.                $XPos  = $this->GraphAreaX1 + $Parameters["Margin"] + $Step*$i;

    2451. 

  2451.                $YPos  = $AxisPos["B"];

    2452. 

  2452.                $Value = $this->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"]*$i,$Parameters["Display"],$Parameters["Format"],$Parameters["Unit"]);

    2453. 

  2453. 

    2454. 

  2454.                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); }

    2455. 

  2455.                if ( $LastX != NULL && $CycleBackground  && ( $DrawYLines == ALL || in_array($AxisID,$DrawYLines) )) { $this->drawFilledRectangle($LastX,$this->GraphAreaY1+$FloatingOffset,$XPos,$this->GraphAreaY2-$FloatingOffset,$BGColor); }

    2456. 

  2456. 

    2457. 

  2457.                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)); }

    2458. 

  2458. 

    2459. 

  2459.                if ( $DrawSubTicks && $i != $Parameters["Rows"] )

    2460. 

  2460.                 $this->drawLine($XPos+$SubTicksSize,$YPos-$OuterSubTickWidth,$XPos+$SubTicksSize,$YPos+$InnerSubTickWidth,array("R"=>$SubTickR,"G"=>$SubTickG,"B"=>$SubTickB,"Alpha"=>$SubTickAlpha));

    2461. 

  2461. 

    2462. 

  2462.                $this->drawLine($XPos,$YPos-$OuterTickWidth,$XPos,$YPos+$InnerTickWidth,array("R"=>$TickR,"G"=>$TickG,"B"=>$TickB,"Alpha"=>$TickAlpha));

    2463. 

  2463.                $Bounds    = $this->drawText($XPos,$YPos+$OuterTickWidth+2,$Value,array("Align"=>TEXT_ALIGN_TOPMIDDLE));

    2464. 

  2464.                $TxtHeight = $YPos+$OuterTickWidth+2+($Bounds[1]["Y"]-$Bounds[2]["Y"]);

    2465. 

  2465.                $MaxBottom = max($MaxBottom,$TxtHeight);

    2466. 

  2466. 

    2467. 

  2467.                $LastX = $XPos;

    2468. 

  2468.               }

    2469. 

  2469. 

    2470. 

  2470.              if ( isset($Parameters["Name"]) )

    2471. 

  2471.               {

    2472. 

  2472.                $YPos   = $MaxBottom+2;

    2473. 

  2473.                $XPos   = $this->GraphAreaX1+($this->GraphAreaX2-$this->GraphAreaX1)/2;

    2474. 

  2474.                $Bounds = $this->drawText($XPos,$YPos,$Parameters["Name"],array("Align"=>TEXT_ALIGN_TOPMIDDLE));

    2475. 

  2475.                $MaxBottom = $Bounds[0]["Y"];

    2476. 

  2476. 

    2477. 

  2477.                $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;

    2478. 

  2478.               }

    2479. 

  2479. 

    2480. 

  2480.              $AxisPos["B"] = $MaxBottom + $ScaleSpacing;

    2481. 

  2481.             }

    2482. 

  2482.           }

    2483. 

  2483.         }

    2484. 

  2484.       }

    2485. 

  2485.     }

    2486. 

  2486. 

    2487. 

  2487.    function isValidLabel($Value,$LastValue,$LabelingMethod,$ID,$LabelSkip)

    2488. 

  2488.     {

    2489. 

  2489.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value != $LastValue ) { return(TRUE); }

    2490. 

  2490.      if ( $LabelingMethod == LABELING_DIFFERENT && $Value == $LastValue ) { return(FALSE); }

    2491. 

  2491.      if ( $LabelingMethod == LABELING_ALL && $LabelSkip == 0 ) { return(TRUE); }

    2492. 

  2492.      if ( $LabelingMethod == LABELING_ALL && ($ID+$LabelSkip) % ($LabelSkip+1) != 1 ) { return(FALSE); }

    2493. 

  2493. 

    2494. 

  2494.      return(TRUE);

    2495. 

  2495.     }

    2496. 

  2496. 

    2497. 

  2497.    /* Compute the scale, check for the best visual factors */

    2498. 

  2498.    function computeScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID=0)

    2499. 

  2499.     {

    2500. 

  2500.      /* Compute each factors */

    2501. 

  2501.      $Results = "";

    2502. 

  2502.      foreach ($Factors as $Key => $Factor)

    2503. 

  2503.       $Results[$Factor] = $this->processScale($XMin,$XMax,$MaxDivs,array($Factor),$AxisID);

    2504. 

  2504. 

    2505. 

  2505.      /* Remove scales that are creating to much decimals */

    2506. 

  2506.      $GoodScaleFactors = "";

    2507. 

  2507.      foreach ($Results as $Key => $Result)

    2508. 

  2508.       {

    2509. 

  2509.        $Decimals = preg_split("/\./",$Result["RowHeight"]);

    2510. 

  2510.        if ( (!isset($Decimals[1])) || (strlen($Decimals[1]) < 6) ) { $GoodScaleFactors[] = $Key; }

    2511. 

  2511.       }

    2512. 

  2512. 

    2513. 

  2513.      /* Found no correct scale, shame,... returns the 1st one as default */

    2514. 

  2514.      if ( $GoodScaleFactors == "" ) { return($Results[$Factors[0]]); }

    2515. 

  2515. 

    2516. 

  2516.      /* Find the factor that cause the maximum number of Rows */

    2517. 

  2517.      $MaxRows = 0; $BestFactor = 0;

    2518. 

  2518.      foreach($GoodScaleFactors as $Key => $Factor)

    2519. 

  2519.       { if ( $Results[$Factor]["Rows"] > $MaxRows ) { $MaxRows = $Results[$Factor]["Rows"]; $BestFactor = $Factor; } }

    2520. 

  2520. 

    2521. 

  2521.      /* Return the best visual scale */

    2522. 

  2522.      return($Results[$BestFactor]);

    2523. 

  2523.     }

    2524. 

  2524. 

    2525. 

  2525.    /* Compute the best matching scale based on size & factors */

    2526. 

  2526.    function processScale($XMin,$XMax,$MaxDivs,$Factors,$AxisID)

    2527. 

  2527.     {

    2528. 

  2528.      $ScaleHeight = abs(ceil($XMax)-floor($XMin));

    2529. 

  2529. 

    2530. 

  2530.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Format"]) )

    2531. 

  2531.       $Format = $this->DataSet->Data["Axis"][$AxisID]["Format"];

    2532. 

  2532.      else

    2533. 

  2533.       $Format = NULL;

    2534. 

  2534. 

    2535. 

  2535.      if ( isset($this->DataSet->Data["Axis"][$AxisID]["Display"]) )

    2536. 

  2536.       $Mode = $this->DataSet->Data["Axis"][$AxisID]["Display"];

    2537. 

  2537.      else

    2538. 

  2538.       $Mode = AXIS_FORMAT_DEFAULT;

    2539. 

  2539. 

    2540. 

  2540.      $Scale = "";

    2541. 

  2541.      if ( $XMin != $XMax )

    2542. 

  2542.       {

    2543. 

  2543.        $Found = FALSE; $Rescaled = FALSE; $Scaled10Factor = .0001; $Result = 0;

    2544. 

  2544.        while(!$Found)

    2545. 

  2545.         {

    2546. 

  2546.          foreach($Factors as $Key => $Factor)

    2547. 

  2547.           {

    2548. 

  2548.            if ( !$Found )

    2549. 

  2549.             {

    2550. 

  2550.              if ( !($this->modulo($XMin,$Factor*$Scaled10Factor) == 0) || ($XMin != floor($XMin))) { $XMinRescaled = floor($XMin/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor; } else { $XMinRescaled = $XMin; }

    2551. 

  2551.              if ( !($this->modulo($XMax,$Factor*$Scaled10Factor) == 0) || ($XMax != floor($XMax))) { $XMaxRescaled = floor($XMax/($Factor*$Scaled10Factor))*$Factor*$Scaled10Factor+($Factor*$Scaled10Factor); } else { $XMaxRescaled = $XMax; }

    2552. 

  2552.              $ScaleHeightRescaled = abs($XMaxRescaled-$XMinRescaled);

    2553. 

  2553. 

    2554. 

  2554.              if ( !$Found && floor($ScaleHeightRescaled/($Factor*$Scaled10Factor)) <= $MaxDivs ) { $Found = TRUE; $Rescaled = TRUE; $Result = $Factor * $Scaled10Factor; }

    2555. 

  2555.             }

    2556. 

  2556.           }

    2557. 

  2557.          $Scaled10Factor = $Scaled10Factor * 10;

    2558. 

  2558.         }

    2559. 

  2559. 

    2560. 

  2560.        /* ReCall Min / Max / Height */

    2561. 

  2561.        if ( $Rescaled ) { $XMin = $XMinRescaled; $XMax = $XMaxRescaled; $ScaleHeight = $ScaleHeightRescaled; }

    2562. 

  2562. 

    2563. 

  2563.        /* Compute rows size */

    2564. 

  2564.        $Rows      = floor($ScaleHeight / $Result); if ( $Rows == 0 ) { $Rows = 1; }

    2565. 

  2565.        $RowHeight = $ScaleHeight / $Rows;

    2566. 

  2566. 

    2567. 

  2567.        /* Return the results */

    2568. 

  2568.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;

    2569. 

  2569. 

    2570. 

  2570.        /* Compute the needed decimals for the metric view to avoid repetition of the same X Axis labels */

    2571. 

  2571.        if ( $Mode == AXIS_FORMAT_METRIC && $Format == NULL )

    2572. 

  2572.         {

    2573. 

  2573.          $Done = FALSE; $GoodDecimals = 0;

    2574. 

  2574.          for($Decimals=0;$Decimals<=10;$Decimals++)

    2575. 

  2575.           {

    2576. 

  2576.            if ( !$Done )

    2577. 

  2577.             {

    2578. 

  2578.              $LastLabel = "zob"; $ScaleOK = TRUE;

    2579. 

  2579.              for($i=0;$i<=$Rows;$i++)

    2580. 

  2580.               {

    2581. 

  2581.                $Value = $XMin + $i*$RowHeight;

    2582. 

  2582.                $Label = $this->scaleFormat($Value,AXIS_FORMAT_METRIC,$Decimals);

    2583. 

  2583. 

    2584. 

  2584.                if ( $LastLabel == $Label ) { $ScaleOK = FALSE; }

    2585. 

  2585.                $LastLabel = $Label;

    2586. 

  2586.               }

    2587. 

  2587.              if ( $ScaleOK ) { $Done = TRUE; $GoodDecimals = $Decimals; }

    2588. 

  2588.             }

    2589. 

  2589.           }

    2590. 

  2590. 

    2591. 

  2591.          $Scale["Format"] = $GoodDecimals;

    2592. 

  2592.         }

    2593. 

  2593.       }

    2594. 

  2594.      else

    2595. 

  2595.       {

    2596. 

  2596.        /* If all values are the same we keep a +1/-1 scale */

    2597. 

  2597.        $Rows = 2; $XMin = $XMax-1; $XMax = $XMax+1; $RowHeight = 1;

    2598. 

  2598. 

    2599. 

  2599.        /* Return the results */

    2600. 

  2600.        $Scale["Rows"] = $Rows; $Scale["RowHeight"] = $RowHeight; $Scale["XMin"] = $XMin;  $Scale["XMax"] = $XMax;

    2601. 

  2601.       }

    2602. 

  2602. 

    2603. 

  2603.      return($Scale);

    2604. 

  2604.     }

    2605. 

  2605. 

    2606. 

  2606.    function modulo($Value1,$Value2)

    2607. 

  2607.     {

    2608. 

  2608.      if (floor($Value2) == 0) { return(0); }

    2609. 

  2609.      if (floor($Value2) != 0) { return($Value1 % $Value2); }

    2610. 

  2610. 

    2611. 

  2611.      $MinValue = min($Value1,$Value2); $Factor = 10;

    2612. 

  2612.      while ( floor($MinValue*$Factor) == 0 )

    2613. 

  2613.       { $Factor = $Factor * 10; }

    2614. 

  2614. 

    2615. 

  2615.      return(($Value1*$Factor) % ($Value2*$Factor));

    2616. 

  2616.     }

    2617. 

  2617. 

    2618. 

  2618.    /* Draw an X threshold */

    2619. 

  2619.    function drawXThreshold($Value,$Format="")

    2620. 

  2620.     {

    2621. 

  2621.      $R			= isset($Format["R"]) ? $Format["R"] : 255;

    2622. 

  2622.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

    2623. 

  2623.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

    2624. 

  2624.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 50;

    2625. 

  2625.      $Weight		= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

    2626. 

  2626.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : 6;

    2627. 

  2627.      $Wide		= isset($Format["Wide"]) ? $Format["Wide"] : FALSE;

    2628. 

  2628.      $WideFactor	= isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;

    2629. 

  2629.      $WriteCaption	= isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;

    2630. 

  2630.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : NULL;

    2631. 

  2631.      $CaptionAlign	= isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;

    2632. 

  2632.      $CaptionOffset     = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 5;

    2633. 

  2633.      $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;

    2634. 

  2634.      $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;

    2635. 

  2635.      $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;

    2636. 

  2636.      $CaptionAlpha	= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;

    2637. 

  2637.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

    2638. 

  2638.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

    2639. 

  2639.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 3;

    2640. 

  2640.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

    2641. 

  2641.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

    2642. 

  2642.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

    2643. 

  2643.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

    2644. 

  2644.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

    2645. 

  2645.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 30;

    2646. 

  2646.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

    2647. 

  2647.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

    2648. 

  2648.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

    2649. 

  2649.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

    2650. 

  2650.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

    2651. 

  2651.      $ValueIsLabel	= isset($Format["ValueIsLabel"]) ? $Format["ValueIsLabel"] : FALSE;

    2652. 

  2652. 

    2653. 

  2653.      $Data           = $this->DataSet->getData();

    2654. 

  2654.      $AbscissaMargin = $this->getAbscissaMargin($Data);

    2655. 

  2655.      $XScale         = $this->scaleGetXSettings();

    2656. 

  2656. 

    2657. 

  2657.      if ( is_array($Value) ) { foreach ($Value as $Key => $ID) { $this->drawXThreshold($ID,$Format); } return(0); }

    2658. 

  2658. 

    2659. 

  2659.      if ( $ValueIsLabel )

    2660. 

  2660.       {

    2661. 

  2661.        $Format["ValueIsLabel"] = FALSE;

    2662. 

  2662.        foreach($Data["Series"][$Data["Abscissa"]]["Data"] as $Key => $SerieValue)

    2663. 

  2663.         { if ( $SerieValue == $Value ) { $this->drawXThreshold($Key,$Format); } }

    2664. 

  2664. 

    2665. 

  2665.        return(0);

    2666. 

  2666.       }

    2667. 

  2667. 

    2668. 

  2668.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

    2669. 

  2669.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

    2670. 

  2670.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha,

    2671. 

  2671.                               "R"=>$CaptionR,"G"=>$CaptionG,"B"=>$CaptionB,"Alpha"=>$CaptionAlpha);

    2672. 

  2672. 

    2673. 

  2673.      if ( $Caption == NULL )

    2674. 

  2674.       {

    2675. 

  2675.        if ( isset($Data["Abscissa"]) )

    2676. 

  2676.         {

    2677. 

  2677.          if ( isset($Data["Series"][$Data["Abscissa"]]["Data"][$Value]) )

    2678. 

  2678.           $Caption = $Data["Series"][$Data["Abscissa"]]["Data"][$Value];

    2679. 

  2679.          else

    2680. 

  2680.           $Caption = $Value;

    2681. 

  2681.         }

    2682. 

  2682.        else

    2683. 

  2683.         $Caption = $Value;

    2684. 

  2684.       }

    2685. 

  2685. 

    2686. 

  2686.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    2687. 

  2687.       {

    2688. 

  2688.        $XStep = (($this->GraphAreaX2 - $this->GraphAreaX1) - $XScale[0] *2 ) / $XScale[1];

    2689. 

  2689.        $XPos  = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value;

    2690. 

  2690.        $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];

    2691. 

  2691.        $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];

    2692. 

  2692. 

    2693. 

  2693.        if ( $XPos >= $this->GraphAreaX1 + $AbscissaMargin && $XPos <= $this->GraphAreaX2 - $AbscissaMargin )

    2694. 

  2694.         {

    2695. 

  2695.          $this->drawLine($XPos,$YPos1,$XPos,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    2696. 

  2696. 

    2697. 

  2697.          if ( $Wide )

    2698. 

  2698.           {

    2699. 

  2699.            $this->drawLine($XPos-1,$YPos1,$XPos-1,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2700. 

  2700.            $this->drawLine($XPos+1,$YPos1,$XPos+1,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2701. 

  2701.           }

    2702. 

  2702. 

    2703. 

  2703.          if ( $WriteCaption )

    2704. 

  2704.           {

    2705. 

  2705.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

    2706. 

  2706.             { $Y = $YPos1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE; }

    2707. 

  2707.            else 

    2708. 

  2708.             { $Y = $YPos2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }

    2709. 

  2709.            

    2710. 

  2710.            $this->drawText($XPos,$Y,$Caption,$CaptionSettings);

    2711. 

  2711.           }

    2712. 

  2712. 

    2713. 

  2713.          return(array("X"=>$XPos));

    2714. 

  2714.         }

    2715. 

  2715.       }

    2716. 

  2716.      elseif( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

    2717. 

  2717.       {

    2718. 

  2718.        $XStep = (($this->GraphAreaY2 - $this->GraphAreaY1) - $XScale[0] *2 ) / $XScale[1];

    2719. 

  2719.        $XPos  = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value;

    2720. 

  2720.        $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];

    2721. 

  2721.        $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];

    2722. 

  2722. 

    2723. 

  2723.        if ( $XPos >= $this->GraphAreaY1 + $AbscissaMargin && $XPos <= $this->GraphAreaY2 - $AbscissaMargin )

    2724. 

  2724.         {

    2725. 

  2725.          $this->drawLine($YPos1,$XPos,$YPos2,$XPos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    2726. 

  2726. 

    2727. 

  2727.          if ( $Wide )

    2728. 

  2728.           {

    2729. 

  2729.            $this->drawLine($YPos1,$XPos-1,$YPos2,$XPos-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2730. 

  2730.            $this->drawLine($YPos1,$XPos+1,$YPos2,$XPos+1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2731. 

  2731.           }

    2732. 

  2732. 

    2733. 

  2733.          if ( $WriteCaption )

    2734. 

  2734.           {

    2735. 

  2735.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

    2736. 

  2736.             { $Y = $YPos1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT; }

    2737. 

  2737.            else 

    2738. 

  2738.             { $Y = $YPos2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }

    2739. 

  2739.            

    2740. 

  2740.            $this->drawText($Y,$XPos,$Caption,$CaptionSettings);

    2741. 

  2741.           }

    2742. 

  2742. 

    2743. 

  2743.          return(array("X"=>$XPos));

    2744. 

  2744.         }

    2745. 

  2745.       }

    2746. 

  2746.     }

    2747. 

  2747. 

    2748. 

  2748.    /* Draw an X threshold area */

    2749. 

  2749.    function drawXThresholdArea($Value1,$Value2,$Format="")

    2750. 

  2750.     {

    2751. 

  2751.      $R		= isset($Format["R"]) ? $Format["R"] : 255;

    2752. 

  2752.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

    2753. 

  2753.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

    2754. 

  2754.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 20;

    2755. 

  2755.      $Border    = isset($Format["Border"]) ? $Format["Border"] : TRUE;

    2756. 

  2756.      $BorderR   = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

    2757. 

  2757.      $BorderG   = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

    2758. 

  2758.      $BorderB   = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

    2759. 

  2759.      $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;

    2760. 

  2760.      $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;

    2761. 

  2761.      $AreaName 	= isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;

    2762. 

  2762.      $NameAngle	= isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;

    2763. 

  2763.      $NameR	= isset($Format["NameR"]) ? $Format["NameR"] : 255;

    2764. 

  2764.      $NameG	= isset($Format["NameG"]) ? $Format["NameG"] : 255;

    2765. 

  2765.      $NameB	= isset($Format["NameB"]) ? $Format["NameB"] : 255;

    2766. 

  2766.      $NameAlpha	= isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;

    2767. 

  2767.      $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;

    2768. 

  2768. 

    2769. 

  2769.      $RestoreShadow = $this->Shadow;

    2770. 

  2770.      if ( $DisableShadowOnArea && $this->Shadow ) { $this->Shadow = FALSE; }

    2771. 

  2771. 

    2772. 

  2772.      if ($BorderAlpha >100) { $BorderAlpha = 100;}

    2773. 

  2773. 

    2774. 

  2774.      $Data           = $this->DataSet->getData();

    2775. 

  2775.      $XScale         = $this->scaleGetXSettings();

    2776. 

  2776.      $AbscissaMargin = $this->getAbscissaMargin($Data);

    2777. 

  2777. 

    2778. 

  2778.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    2779. 

  2779.       {

    2780. 

  2780.        $XStep = (($this->GraphAreaX2 - $this->GraphAreaX1) - $XScale[0] *2 ) / $XScale[1];

    2781. 

  2781.        $XPos1 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value1;

    2782. 

  2782.        $XPos2 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value2;

    2783. 

  2783.        $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];

    2784. 

  2784.        $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];

    2785. 

  2785. 

    2786. 

  2786.        if ( $XPos1 < $this->GraphAreaX1 + $XScale[0] ) { $XPos1 = $this->GraphAreaX1 + $XScale[0]; }

    2787. 

  2787.        if ( $XPos1 > $this->GraphAreaX2 - $XScale[0] ) { $XPos1 = $this->GraphAreaX2 - $XScale[0]; }

    2788. 

  2788.        if ( $XPos2 < $this->GraphAreaX1 + $XScale[0] ) { $XPos2 = $this->GraphAreaX1 + $XScale[0]; }

    2789. 

  2789.        if ( $XPos2 > $this->GraphAreaX2 - $XScale[0] ) { $XPos2 = $this->GraphAreaX2 - $XScale[0]; }

    2790. 

  2790. 

    2791. 

  2791.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    2792. 

  2792. 

    2793. 

  2793.        if ( $Border )

    2794. 

  2794.         {

    2795. 

  2795.          $this->drawLine($XPos1,$YPos1,$XPos1,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    2796. 

  2796.          $this->drawLine($XPos2,$YPos1,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    2797. 

  2797.         }

    2798. 

  2798. 

    2799. 

  2799.        if ( $AreaName != NULL )

    2800. 

  2800.         {

    2801. 

  2801.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

    2802. 

  2802.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

    2803. 

  2803. 

    2804. 

  2804.          if ( $NameAngle == ZONE_NAME_ANGLE_AUTO )

    2805. 

  2805.           {

    2806. 

  2806.            $TxtPos   = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$AreaName);

    2807. 

  2807.            $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];

    2808. 

  2808.            if ( abs($XPos2 - $XPos1) > $TxtWidth ) { $NameAngle = 0; } else { $NameAngle = 90; }

    2809. 

  2809.           }

    2810. 

  2810.          $this->Shadow = $RestoreShadow;

    2811. 

  2811.          $this->drawText($XPos,$YPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>$NameAngle,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

    2812. 

  2812.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

    2813. 

  2813.         }

    2814. 

  2814. 

    2815. 

  2815.        $this->Shadow = $RestoreShadow;

    2816. 

  2816.        return(array("X1"=>$XPos1,"X2"=>$XPos2));

    2817. 

  2817.       }

    2818. 

  2818.      elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

    2819. 

  2819.       {

    2820. 

  2820.        $XStep = (($this->GraphAreaY2 - $this->GraphAreaY1) - $XScale[0] *2 ) / $XScale[1];

    2821. 

  2821.        $XPos1 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value1;

    2822. 

  2822.        $XPos2 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value2;

    2823. 

  2823.        $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];

    2824. 

  2824.        $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];

    2825. 

  2825. 

    2826. 

  2826.        if ( $XPos1 < $this->GraphAreaY1 + $XScale[0] ) { $XPos1 = $this->GraphAreaY1 + $XScale[0]; }

    2827. 

  2827.        if ( $XPos1 > $this->GraphAreaY2 - $XScale[0] ) { $XPos1 = $this->GraphAreaY2 - $XScale[0]; }

    2828. 

  2828.        if ( $XPos2 < $this->GraphAreaY1 + $XScale[0] ) { $XPos2 = $this->GraphAreaY1 + $XScale[0]; }

    2829. 

  2829.        if ( $XPos2 > $this->GraphAreaY2 - $XScale[0] ) { $XPos2 = $this->GraphAreaY2 - $XScale[0]; }

    2830. 

  2830. 

    2831. 

  2831.        $this->drawFilledRectangle($YPos1,$XPos1,$YPos2,$XPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    2832. 

  2832. 

    2833. 

  2833.        if ( $Border )

    2834. 

  2834.         {

    2835. 

  2835.          $this->drawLine($YPos1,$XPos1,$YPos2,$XPos1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    2836. 

  2836.          $this->drawLine($YPos1,$XPos2,$YPos2,$XPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    2837. 

  2837.         }

    2838. 

  2838. 

    2839. 

  2839.        if ( $AreaName != NULL )

    2840. 

  2840.         {

    2841. 

  2841.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

    2842. 

  2842.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

    2843. 

  2843. 

    2844. 

  2844.          $this->Shadow = $RestoreShadow;

    2845. 

  2845.          $this->drawText($YPos,$XPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>0,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

    2846. 

  2846.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

    2847. 

  2847.         }

    2848. 

  2848. 

    2849. 

  2849.        $this->Shadow = $RestoreShadow;

    2850. 

  2850.        return(array("X1"=>$XPos1,"X2"=>$XPos2));

    2851. 

  2851.       }

    2852. 

  2852.     }

    2853. 

  2853. 

    2854. 

  2854.    /* Draw an Y threshold with the computed scale */

    2855. 

  2855.    function drawThreshold($Value,$Format="")

    2856. 

  2856.     {

    2857. 

  2857.      $AxisID		= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

    2858. 

  2858.      $R			= isset($Format["R"]) ? $Format["R"] : 255;

    2859. 

  2859.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

    2860. 

  2860.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

    2861. 

  2861.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 50;

    2862. 

  2862.      $Weight		= isset($Format["Weight"]) ? $Format["Weight"] : NULL;

    2863. 

  2863.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : 6;

    2864. 

  2864.      $Wide		= isset($Format["Wide"]) ? $Format["Wide"] : FALSE;

    2865. 

  2865.      $WideFactor	= isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;

    2866. 

  2866.      $WriteCaption	= isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;

    2867. 

  2867.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : NULL;

    2868. 

  2868.      $CaptionAlign	= isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;

    2869. 

  2869.      $CaptionOffset     = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 10;

    2870. 

  2870.      $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;

    2871. 

  2871.      $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;

    2872. 

  2872.      $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;

    2873. 

  2873.      $CaptionAlpha	= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;

    2874. 

  2874.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

    2875. 

  2875.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

    2876. 

  2876.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;

    2877. 

  2877.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

    2878. 

  2878.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

    2879. 

  2879.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

    2880. 

  2880.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

    2881. 

  2881.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

    2882. 

  2882.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;

    2883. 

  2883.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

    2884. 

  2884.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

    2885. 

  2885.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

    2886. 

  2886.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

    2887. 

  2887.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

    2888. 

  2888.      $NoMargin		= isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;

    2889. 

  2889. 

    2890. 

  2890.      if ( is_array($Value) ) { foreach ($Value as $Key => $ID) { $this->drawThreshold($ID,$Format); } return(0); }

    2891. 

  2891. 

    2892. 

  2892.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

    2893. 

  2893.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

    2894. 

  2894.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha,

    2895. 

  2895.                               "R"=>$CaptionR,"G"=>$CaptionG,"B"=>$CaptionB,"Alpha"=>$CaptionAlpha);

    2896. 

  2896. 

    2897. 

  2897.      $Data           = $this->DataSet->getData();

    2898. 

  2898.      $AbscissaMargin = $this->getAbscissaMargin($Data);

    2899. 

  2899. 

    2900. 

  2900.      if ( $NoMargin ) { $AbscissaMargin = 0; }

    2901. 

  2901.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

    2902. 

  2902.      if ( $Caption == NULL ) { $Caption = $Value; }

    2903. 

  2903. 

    2904. 

  2904.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    2905. 

  2905.       {

    2906. 

  2906.        $YPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));

    2907. 

  2907.        if ( $YPos >= $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] && $YPos <= $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] )

    2908. 

  2908.         {

    2909. 

  2909.          $X1 = $this->GraphAreaX1 + $AbscissaMargin;

    2910. 

  2910.          $X2 = $this->GraphAreaX2 - $AbscissaMargin;

    2911. 

  2911. 

    2912. 

  2912.          $this->drawLine($X1,$YPos,$X2,$YPos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    2913. 

  2913. 

    2914. 

  2914.          if ( $Wide )

    2915. 

  2915.           {

    2916. 

  2916.            $this->drawLine($X1,$YPos-1,$X2,$YPos-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2917. 

  2917.            $this->drawLine($X1,$YPos+1,$X2,$YPos+1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2918. 

  2918.           }

    2919. 

  2919. 

    2920. 

  2920.          if ( $WriteCaption )

    2921. 

  2921.           {

    2922. 

  2922.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

    2923. 

  2923.             { $X = $X1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT; }

    2924. 

  2924.            else 

    2925. 

  2925.             { $X = $X2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }

    2926. 

  2926.            

    2927. 

  2927.            $this->drawText($X,$YPos,$Caption,$CaptionSettings);

    2928. 

  2928.           }

    2929. 

  2929.         }

    2930. 

  2930. 

    2931. 

  2931.        return(array("Y"=>$YPos));

    2932. 

  2932.       }

    2933. 

  2933. 

    2934. 

  2934.      if ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

    2935. 

  2935.       {

    2936. 

  2936.        $XPos = $this->scaleComputeY($Value,array("AxisID"=>$AxisID));

    2937. 

  2937.        if ( $XPos >= $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] && $XPos <= $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] )

    2938. 

  2938.         {

    2939. 

  2939.          $Y1 = $this->GraphAreaY1 + $AbscissaMargin;

    2940. 

  2940.          $Y2 = $this->GraphAreaY2 - $AbscissaMargin;

    2941. 

  2941. 

    2942. 

  2942.          $this->drawLine($XPos,$Y1,$XPos,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    2943. 

  2943. 

    2944. 

  2944.          if ( $Wide )

    2945. 

  2945.           {

    2946. 

  2946.            $this->drawLine($XPos-1,$Y1,$XPos-1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2947. 

  2947.            $this->drawLine($XPos+1,$Y1,$XPos+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/$WideFactor,"Ticks"=>$Ticks));

    2948. 

  2948.           }

    2949. 

  2949. 

    2950. 

  2950.          if ( $WriteCaption )

    2951. 

  2951.           {

    2952. 

  2952.            if ( $CaptionAlign == CAPTION_LEFT_TOP )

    2953. 

  2953.             { $Y = $Y1 + $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE; }

    2954. 

  2954.            else 

    2955. 

  2955.             { $Y = $Y2 - $CaptionOffset; $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }

    2956. 

  2956. 

    2957. 

  2957.            $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;

    2958. 

  2958.            $this->drawText($XPos,$Y,$Caption,$CaptionSettings);

    2959. 

  2959.           }

    2960. 

  2960.         }

    2961. 

  2961. 

    2962. 

  2962.        return(array("Y"=>$XPos));

    2963. 

  2963.       }

    2964. 

  2964.     }

    2965. 

  2965. 

    2966. 

  2966.    /* Draw a threshold with the computed scale */

    2967. 

  2967.    function drawThresholdArea($Value1,$Value2,$Format="")

    2968. 

  2968.     {

    2969. 

  2969.      $AxisID	= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

    2970. 

  2970.      $R		= isset($Format["R"]) ? $Format["R"] : 255;

    2971. 

  2971.      $G		= isset($Format["G"]) ? $Format["G"] : 0;

    2972. 

  2972.      $B		= isset($Format["B"]) ? $Format["B"] : 0;

    2973. 

  2973.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 20;

    2974. 

  2974.      $Border    = isset($Format["Border"]) ? $Format["Border"] : TRUE;

    2975. 

  2975.      $BorderR   = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

    2976. 

  2976.      $BorderG   = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

    2977. 

  2977.      $BorderB   = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

    2978. 

  2978.      $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;

    2979. 

  2979.      $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;

    2980. 

  2980.      $AreaName 	= isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;

    2981. 

  2981.      $NameAngle	= isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;

    2982. 

  2982.      $NameR	= isset($Format["NameR"]) ? $Format["NameR"] : 255;

    2983. 

  2983.      $NameG	= isset($Format["NameG"]) ? $Format["NameG"] : 255;

    2984. 

  2984.      $NameB	= isset($Format["NameB"]) ? $Format["NameB"] : 255;

    2985. 

  2985.      $NameAlpha	= isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;

    2986. 

  2986.      $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;

    2987. 

  2987.      $NoMargin	= isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;

    2988. 

  2988. 

    2989. 

  2989.      if ($Value1 > $Value2) { list($Value1, $Value2) = array($Value2, $Value1); }

    2990. 

  2990. 

    2991. 

  2991.      $RestoreShadow = $this->Shadow;

    2992. 

  2992.      if ( $DisableShadowOnArea && $this->Shadow ) { $this->Shadow = FALSE; }

    2993. 

  2993. 

    2994. 

  2994.      if ($BorderAlpha >100) { $BorderAlpha = 100;}

    2995. 

  2995. 

    2996. 

  2996.      $Data           = $this->DataSet->getData();

    2997. 

  2997.      $AbscissaMargin = $this->getAbscissaMargin($Data);

    2998. 

  2998. 

    2999. 

  2999.      if ( $NoMargin ) { $AbscissaMargin = 0; }

    3000. 

  3000.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

    3001. 

  3001. 

    3002. 

  3002.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3003. 

  3003.       {

    3004. 

  3004.        $XPos1 = $this->GraphAreaX1 + $AbscissaMargin;

    3005. 

  3005.        $XPos2 = $this->GraphAreaX2 - $AbscissaMargin;

    3006. 

  3006.        $YPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));

    3007. 

  3007.        $YPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));

    3008. 

  3008. 

    3009. 

  3009.        if ( $YPos1 < $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] ) { $YPos1 = $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"]; }

    3010. 

  3010.        if ( $YPos1 > $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] ) { $YPos1 = $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"]; }

    3011. 

  3011.        if ( $YPos2 < $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"] ) { $YPos2 = $this->GraphAreaY1+$Data["Axis"][$AxisID]["Margin"]; }

    3012. 

  3012.        if ( $YPos2 > $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"] ) { $YPos2 = $this->GraphAreaY2-$Data["Axis"][$AxisID]["Margin"]; }

    3013. 

  3013. 

    3014. 

  3014.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    3015. 

  3015.        if ( $Border )

    3016. 

  3016.         {

    3017. 

  3017.          $this->drawLine($XPos1,$YPos1,$XPos2,$YPos1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    3018. 

  3018.          $this->drawLine($XPos1,$YPos2,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    3019. 

  3019.         }

    3020. 

  3020. 

    3021. 

  3021.        if ( $AreaName != NULL )

    3022. 

  3022.         {

    3023. 

  3023.          $XPos = ($XPos2-$XPos1)/2 + $XPos1;

    3024. 

  3024.          $YPos = ($YPos2-$YPos1)/2 + $YPos1;

    3025. 

  3025.          $this->Shadow = $RestoreShadow;

    3026. 

  3026.          $this->drawText($XPos,$YPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>0,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

    3027. 

  3027.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

    3028. 

  3028.         }

    3029. 

  3029. 

    3030. 

  3030.        $this->Shadow = $RestoreShadow;

    3031. 

  3031.        return(array("Y1"=>$YPos1,"Y2"=>$YPos2));

    3032. 

  3032.       }

    3033. 

  3033.      elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

    3034. 

  3034.       {

    3035. 

  3035.        $YPos1 = $this->GraphAreaY1 + $AbscissaMargin;

    3036. 

  3036.        $YPos2 = $this->GraphAreaY2 - $AbscissaMargin;

    3037. 

  3037.        $XPos1 = $this->scaleComputeY($Value1,array("AxisID"=>$AxisID));

    3038. 

  3038.        $XPos2 = $this->scaleComputeY($Value2,array("AxisID"=>$AxisID));

    3039. 

  3039. 

    3040. 

  3040.        if ( $XPos1 < $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] ) { $XPos1 = $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"]; }

    3041. 

  3041.        if ( $XPos1 > $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] ) { $XPos1 = $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"]; }

    3042. 

  3042.        if ( $XPos2 < $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"] ) { $XPos2 = $this->GraphAreaX1+$Data["Axis"][$AxisID]["Margin"]; }

    3043. 

  3043.        if ( $XPos2 > $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"] ) { $XPos2 = $this->GraphAreaX2-$Data["Axis"][$AxisID]["Margin"]; }

    3044. 

  3044. 

    3045. 

  3045.        $this->drawFilledRectangle($XPos1,$YPos1,$XPos2,$YPos2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    3046. 

  3046.        if ( $Border )

    3047. 

  3047.         {

    3048. 

  3048.          $this->drawLine($XPos1,$YPos1,$XPos1,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    3049. 

  3049.          $this->drawLine($XPos2,$YPos1,$XPos2,$YPos2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$BorderTicks));

    3050. 

  3050.         }

    3051. 

  3051. 

    3052. 

  3052.        if ( $AreaName != NULL )

    3053. 

  3053.         {

    3054. 

  3054.          $XPos = ($YPos2-$YPos1)/2 + $YPos1;

    3055. 

  3055.          $YPos = ($XPos2-$XPos1)/2 + $XPos1;

    3056. 

  3056. 

    3057. 

  3057.          if ( $NameAngle == ZONE_NAME_ANGLE_AUTO )

    3058. 

  3058.           {

    3059. 

  3059.            $TxtPos   = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$AreaName);

    3060. 

  3060.            $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];

    3061. 

  3061.            if ( abs($XPos2 - $XPos1) > $TxtWidth ) { $NameAngle = 0; } else { $NameAngle = 90; }

    3062. 

  3062.           }

    3063. 

  3063.          $this->Shadow = $RestoreShadow;

    3064. 

  3064.          $this->drawText($YPos,$XPos,$AreaName,array("R"=>$NameR,"G"=>$NameG,"B"=>$NameB,"Alpha"=>$NameAlpha,"Angle"=>$NameAngle,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE));

    3065. 

  3065.          if ( $DisableShadowOnArea ) { $this->Shadow = FALSE; }

    3066. 

  3066.         }

    3067. 

  3067. 

    3068. 

  3068.        $this->Shadow = $RestoreShadow;

    3069. 

  3069.        return(array("Y1"=>$XPos1,"Y2"=>$XPos2));

    3070. 

  3070.       }

    3071. 

  3071.     }

    3072. 

  3072. 

    3073. 

  3073.    function scaleGetXSettings()

    3074. 

  3074.     {

    3075. 

  3075.      $Data = $this->DataSet->getData();

    3076. 

  3076.      foreach($Data["Axis"] as $AxisID => $Settings)

    3077. 

  3077.       {

    3078. 

  3078.        if ( $Settings["Identity"] == AXIS_X )

    3079. 

  3079.         {

    3080. 

  3080.          $Rows = $Settings["Rows"];

    3081. 

  3081. 

    3082. 

  3082.          return(array($Settings["Margin"],$Rows));

    3083. 

  3083.         }

    3084. 

  3084.       }

    3085. 

  3085.     }

    3086. 

  3086. 

    3087. 

  3087.    function scaleComputeY($Values,$Option="",$ReturnOnly0Height=FALSE)

    3088. 

  3088.     {

    3089. 

  3089.      $AxisID	= isset($Option["AxisID"]) ? $Option["AxisID"] : 0;

    3090. 

  3090.      $SerieName	= isset($Option["SerieName"]) ? $Option["SerieName"] : NULL;

    3091. 

  3091. 

    3092. 

  3092.      $Data = $this->DataSet->getData();

    3093. 

  3093.      if ( !isset($Data["Axis"][$AxisID]) ) { return(-1); }

    3094. 

  3094. 

    3095. 

  3095.      if ( $SerieName != NULL ) { $AxisID = $Data["Series"][$SerieName]["Axis"]; }

    3096. 

  3096.      if ( !is_array($Values) ) { $tmp = $Values; $Values = ""; $Values[0] = $tmp; }

    3097. 

  3097. 

    3098. 

  3098.      $Result = "";

    3099. 

  3099.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3100. 

  3100.       {

    3101. 

  3101.        $Height      = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Data["Axis"][$AxisID]["Margin"]*2;

    3102. 

  3102.        $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];

    3103. 

  3103.        $Step        = $Height / $ScaleHeight;

    3104. 

  3104. 

    3105. 

  3105.        if ( $ReturnOnly0Height )

    3106. 

  3106.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }

    3107. 

  3107.        else

    3108. 

  3108.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"] - ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }

    3109. 

  3109.       }

    3110. 

  3110.      else

    3111. 

  3111.       {

    3112. 

  3112.        $Width      = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Data["Axis"][$AxisID]["Margin"]*2;

    3113. 

  3113.        $ScaleWidth = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];

    3114. 

  3114.        $Step       = $Width / $ScaleWidth;

    3115. 

  3115. 

    3116. 

  3116.        if ( $ReturnOnly0Height )

    3117. 

  3117.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $Step * $Value; } } }

    3118. 

  3118.        else

    3119. 

  3119.         { foreach($Values as $Key => $Value) { if ( $Value == VOID ) { $Result[] = VOID; } else { $Result[] = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] + ($Step * ($Value-$Data["Axis"][$AxisID]["ScaleMin"])); } } }

    3120. 

  3120.       }

    3121. 

  3121. 

    3122. 

  3122.      if ( count($Result) == 1 )

    3123. 

  3123.       return($Result[0]);

    3124. 

  3124.      else

    3125. 

  3125.       return($Result);

    3126. 

  3126.     }

    3127. 

  3127. 

    3128. 

  3128.    /* Format the axis values */

    3129. 

  3129.    function scaleFormat($Value,$Mode=NULL,$Format=NULL,$Unit=NULL)

    3130. 

  3130.     {

    3131. 

  3131.      if ( $Value == VOID ) { return(""); }

    3132. 

  3132. 

    3133. 

  3133.      if ( $Mode == AXIS_FORMAT_TRAFFIC )

    3134. 

  3134.       {

    3135. 

  3135.        if ( $Value == 0 ) { return("0B"); }

    3136. 

  3136.        $Units = array("B","KB","MB","GB","TB","PB");

    3137. 

  3137.        $Sign = ""; if ( $Value < 0 ) { $Value = abs($Value); $Sign = "-"; }

    3138. 

  3138. 

    3139. 

  3139.        $Value = number_format($Value/pow(1024,($Scale=floor(log($Value,1024)))),2,",",".");

    3140. 

  3140.        return($Sign.$Value." ".$Units[$Scale]);

    3141. 

  3141.       }

    3142. 

  3142. 

    3143. 

  3143.      if ( $Mode == AXIS_FORMAT_CUSTOM )

    3144. 

  3144.       { if ( function_exists($Format) ) { return(call_user_func($Format,$Value)); } }

    3145. 

  3145. 

    3146. 

  3146.      if ( $Mode == AXIS_FORMAT_DATE )

    3147. 

  3147.       { if ( $Format == NULL ) { $Pattern = "d/m/Y"; } else { $Pattern = $Format; } return(gmdate($Pattern,$Value)); }

    3148. 

  3148. 

    3149. 

  3149.      if ( $Mode == AXIS_FORMAT_TIME )

    3150. 

  3150.       { if ( $Format == NULL ) { $Pattern = "H:i:s"; } else { $Pattern = $Format; } return(gmdate($Pattern,$Value)); }

    3151. 

  3151. 

    3152. 

  3152.      if ( $Mode == AXIS_FORMAT_CURRENCY )

    3153. 

  3153.       { return($Format.number_format($Value,2)); }

    3154. 

  3154. 

    3155. 

  3155.      if ( $Mode == AXIS_FORMAT_METRIC )

    3156. 

  3156.       {

    3157. 

  3157.        if (abs($Value) > 1000000000)

    3158. 

  3158.         return(round($Value/1000000000,$Format)."g".$Unit);

    3159. 

  3159.        if (abs($Value) > 1000000)

    3160. 

  3160.         return(round($Value/1000000,$Format)."m".$Unit);

    3161. 

  3161.        elseif (abs($Value) >= 1000)

    3162. 

  3162.         return(round($Value/1000,$Format)."k".$Unit);

    3163. 

  3163.        

    3164. 

  3164.       }

    3165. 

  3165.      return($Value.$Unit);

    3166. 

  3166.     }

    3167. 

  3167. 

    3168. 

  3168.    /* Write Max value on a chart */

    3169. 

  3169.    function writeBounds($Type=BOUND_BOTH,$Format=NULL)

    3170. 

  3170.     {

    3171. 

  3171.      $MaxLabelTxt	= isset($Format["MaxLabelTxt"]) ? $Format["MaxLabelTxt"] : "max=";

    3172. 

  3172.      $MinLabelTxt	= isset($Format["MinLabelTxt"]) ? $Format["MinLabelTxt"] : "min=";

    3173. 

  3173.      $Decimals		= isset($Format["Decimals"]) ? $Format["Decimals"] : 1;

    3174. 

  3174.      $ExcludedSeries	= isset($Format["ExcludedSeries"]) ? $Format["ExcludedSeries"] : "";

    3175. 

  3175.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;

    3176. 

  3176.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3177. 

  3177.      $MaxDisplayR	= isset($Format["MaxDisplayR"]) ? $Format["MaxDisplayR"] : 0;

    3178. 

  3178.      $MaxDisplayG	= isset($Format["MaxDisplayG"]) ? $Format["MaxDisplayG"] : 0;

    3179. 

  3179.      $MaxDisplayB	= isset($Format["MaxDisplayB"]) ? $Format["MaxDisplayB"] : 0;

    3180. 

  3180.      $MinDisplayR	= isset($Format["MinDisplayR"]) ? $Format["MinDisplayR"] : 255;

    3181. 

  3181.      $MinDisplayG	= isset($Format["MinDisplayG"]) ? $Format["MinDisplayG"] : 255;

    3182. 

  3182.      $MinDisplayB	= isset($Format["MinDisplayB"]) ? $Format["MinDisplayB"] : 255;

    3183. 

  3183.      $MinLabelPos	= isset($Format["MinLabelPos"]) ? $Format["MinLabelPos"] : BOUND_LABEL_POS_AUTO;

    3184. 

  3184.      $MaxLabelPos	= isset($Format["MaxLabelPos"]) ? $Format["MaxLabelPos"] : BOUND_LABEL_POS_AUTO;

    3185. 

  3185.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;

    3186. 

  3186.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;

    3187. 

  3187.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;

    3188. 

  3188.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;

    3189. 

  3189.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;

    3190. 

  3190.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;

    3191. 

  3191.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;

    3192. 

  3192.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;

    3193. 

  3193.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;

    3194. 

  3194.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";

    3195. 

  3195.      $BoxBorderR	= isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;

    3196. 

  3196.      $BoxBorderG	= isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;

    3197. 

  3197.      $BoxBorderB	= isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;

    3198. 

  3198.      $BoxBorderAlpha	= isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

    3199. 

  3199. 

    3200. 

  3200.      $CaptionSettings = array("DrawBox"=>$DrawBox,"DrawBoxBorder"=>$DrawBoxBorder,"BorderOffset"=>$BorderOffset,"BoxRounded"=>$BoxRounded,"RoundedRadius"=>$RoundedRadius,

    3201. 

  3201.                               "BoxR"=>$BoxR,"BoxG"=>$BoxG,"BoxB"=>$BoxB,"BoxAlpha"=>$BoxAlpha,"BoxSurrounding"=>$BoxSurrounding,

    3202. 

  3202.                               "BoxBorderR"=>$BoxBorderR,"BoxBorderG"=>$BoxBorderG,"BoxBorderB"=>$BoxBorderB,"BoxBorderAlpha"=>$BoxBorderAlpha);

    3203. 

  3203. 

    3204. 

  3204.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3205. 

  3205. 

    3206. 

  3206.      $Data = $this->DataSet->getData();

    3207. 

  3207.      foreach($Data["Series"] as $SerieName => $Serie)

    3208. 

  3208.       {

    3209. 

  3209.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && !isset($ExcludedSeries[$SerieName]))

    3210. 

  3210.         {

    3211. 

  3211.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    3212. 

  3212.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3213. 

  3213. 

    3214. 

  3214.          $MinValue = $this->DataSet->getMin($SerieName);

    3215. 

  3215.          $MaxValue = $this->DataSet->getMax($SerieName);

    3216. 

  3216. 

    3217. 

  3217.          $MinPos = VOID; $MaxPos = VOID;

    3218. 

  3218.          foreach($Serie["Data"] as $Key => $Value)

    3219. 

  3219.           { 

    3220. 

  3220.            if ( $Value == $MinValue && $MinPos == VOID ) { $MinPos = $Key; }

    3221. 

  3221.            if ( $Value == $MaxValue ) { $MaxPos = $Key; }

    3222. 

  3222.           }

    3223. 

  3223. 

    3224. 

  3224.          $AxisID	= $Serie["Axis"];

    3225. 

  3225.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3226. 

  3226.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3227. 

  3227.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3228. 

  3228. 

    3229. 

  3229.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3230. 

  3230. 

    3231. 

  3231.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3232. 

  3232.           {

    3233. 

  3233.            $XStep       = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs;

    3234. 

  3234.            $X           = $this->GraphAreaX1 + $XMargin;

    3235. 

  3235.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

    3236. 

  3236. 

    3237. 

  3237.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )

    3238. 

  3238.             {

    3239. 

  3239.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }

    3240. 

  3240.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }

    3241. 

  3241. 

    3242. 

  3242.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;

    3243. 

  3243.              $Label = $MaxLabelTxt.$this->scaleFormat(round($MaxValue,$Decimals),$Mode,$Format,$Unit);

    3244. 

  3244. 

    3245. 

  3245.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);

    3246. 

  3246.              $XOffset = 0; $YOffset = 0;

    3247. 

  3247.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }

    3248. 

  3248.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }

    3249. 

  3249.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }

    3250. 

  3250.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }

    3251. 

  3251. 

    3252. 

  3252.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;

    3253. 

  3253.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;

    3254. 

  3254. 

    3255. 

  3255.              $this->drawText($XPos+$XOffset,$YPos+$YOffset,$Label,$CaptionSettings);

    3256. 

  3256.             }

    3257. 

  3257. 

    3258. 

  3258.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )

    3259. 

  3259.             {

    3260. 

  3260.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_BOTTOMMIDDLE; }

    3261. 

  3261.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_TOPMIDDLE; }

    3262. 

  3262. 

    3263. 

  3263.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;

    3264. 

  3264.              $Label = $MinLabelTxt.$this->scaleFormat(round($MinValue,$Decimals),$Mode,$Format,$Unit);

    3265. 

  3265. 

    3266. 

  3266.              $TxtPos  = $this->getTextBox($XPos,$YPos,$this->FontName,$this->FontSize,0,$Label);

    3267. 

  3267.              $XOffset = 0; $YOffset = 0;

    3268. 

  3268.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"])/2); }

    3269. 

  3269.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2)/2); }

    3270. 

  3270.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"]; }

    3271. 

  3271.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2); }

    3272. 

  3272. 

    3273. 

  3273.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;

    3274. 

  3274.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;

    3275. 

  3275. 

    3276. 

  3276.              $this->drawText($XPos+$XOffset,$YPos-$DisplayOffset+$YOffset,$Label,$CaptionSettings);

    3277. 

  3277.             }

    3278. 

  3278.           }

    3279. 

  3279.          else

    3280. 

  3280.           {

    3281. 

  3281.            $XStep       = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs;

    3282. 

  3282.            $X           = $this->GraphAreaY1 + $XMargin;

    3283. 

  3283.            $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

    3284. 

  3284. 

    3285. 

  3285.            if ( $Type == BOUND_MAX || $Type == BOUND_BOTH )

    3286. 

  3286.             {

    3287. 

  3287.              if ( $MaxLabelPos == BOUND_LABEL_POS_TOP    || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue >= 0) ) { $YPos  = $PosArray[$MaxPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }

    3288. 

  3288.              if ( $MaxLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MaxLabelPos ==  BOUND_LABEL_POS_AUTO && $MaxValue < 0) ) { $YPos  = $PosArray[$MaxPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }

    3289. 

  3289. 

    3290. 

  3290.              $XPos  = $X + $MaxPos*$XStep + $SerieOffset;

    3291. 

  3291.              $Label = $MaxLabelTxt.$this->scaleFormat($MaxValue,$Mode,$Format,$Unit);

    3292. 

  3292. 

    3293. 

  3293.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);

    3294. 

  3294.              $XOffset = 0; $YOffset = 0;

    3295. 

  3295.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }

    3296. 

  3296.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }

    3297. 

  3297.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }

    3298. 

  3298.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}

    3299. 

  3299. 

    3300. 

  3300.              $CaptionSettings["R"] = $MaxDisplayR; $CaptionSettings["G"] = $MaxDisplayG;

    3301. 

  3301.              $CaptionSettings["B"] = $MaxDisplayB; $CaptionSettings["Align"] = $Align;

    3302. 

  3302. 

    3303. 

  3303.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);

    3304. 

  3304.             }

    3305. 

  3305. 

    3306. 

  3306.            if ( $Type == BOUND_MIN || $Type == BOUND_BOTH )

    3307. 

  3307.             {

    3308. 

  3308.              if ( $MinLabelPos == BOUND_LABEL_POS_TOP    || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue >= 0) ) { $YPos  = $PosArray[$MinPos] + $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLELEFT; }

    3309. 

  3309.              if ( $MinLabelPos == BOUND_LABEL_POS_BOTTOM || ( $MinLabelPos ==  BOUND_LABEL_POS_AUTO && $MinValue < 0) ) { $YPos  = $PosArray[$MinPos] - $DisplayOffset + 2; $Align = TEXT_ALIGN_MIDDLERIGHT; }

    3310. 

  3310. 

    3311. 

  3311.              $XPos  = $X + $MinPos*$XStep + $SerieOffset;

    3312. 

  3312.              $Label = $MinLabelTxt.$this->scaleFormat($MinValue,$Mode,$Format,$Unit);

    3313. 

  3313. 

    3314. 

  3314.              $TxtPos  = $this->getTextBox($YPos,$XPos,$this->FontName,$this->FontSize,0,$Label);

    3315. 

  3315.              $XOffset = 0; $YOffset = 0;

    3316. 

  3316.              if ( $TxtPos[0]["X"] < $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"]; }

    3317. 

  3317.              if ( $TxtPos[1]["X"] > $this->GraphAreaX2 ) { $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2); }

    3318. 

  3318.              if ( $TxtPos[2]["Y"] < $this->GraphAreaY1 ) { $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"])/2; }

    3319. 

  3319.              if ( $TxtPos[0]["Y"] > $this->GraphAreaY2 ) { $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2)/2);}

    3320. 

  3320. 

    3321. 

  3321.              $CaptionSettings["R"] = $MinDisplayR; $CaptionSettings["G"] = $MinDisplayG;

    3322. 

  3322.              $CaptionSettings["B"] = $MinDisplayB; $CaptionSettings["Align"] = $Align;

    3323. 

  3323. 

    3324. 

  3324.              $this->drawText($YPos+$XOffset,$XPos+$YOffset,$Label,$CaptionSettings);

    3325. 

  3325.             }

    3326. 

  3326.           }

    3327. 

  3327.         }

    3328. 

  3328.       }

    3329. 

  3329.     }

    3330. 

  3330. 

    3331. 

  3331.    /* Draw a plot chart */

    3332. 

  3332.    function drawPlotChart($Format=NULL)

    3333. 

  3333.     {

    3334. 

  3334.      $PlotSize		= isset($Format["PlotSize"]) ? $Format["PlotSize"] : NULL;

    3335. 

  3335.      $PlotBorder	= isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : FALSE;

    3336. 

  3336.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 50;

    3337. 

  3337.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 50;

    3338. 

  3338.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 50;

    3339. 

  3339.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;

    3340. 

  3340.      $BorderSize	= isset($Format["BorderSize"]) ? $Format["BorderSize"] : 2;

    3341. 

  3341.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    3342. 

  3342.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    3343. 

  3343.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;

    3344. 

  3344.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3345. 

  3345.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    3346. 

  3346.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    3347. 

  3347.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    3348. 

  3348.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    3349. 

  3349. 

    3350. 

  3350.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3351. 

  3351. 

    3352. 

  3352.      $Data = $this->DataSet->getData();

    3353. 

  3353.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3354. 

  3354. 

    3355. 

  3355.      foreach($Data["Series"] as $SerieName => $Serie)

    3356. 

  3356.       {

    3357. 

  3357.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    3358. 

  3358.         {

    3359. 

  3359.          if ( isset($Serie["Weight"]) ) { $SerieWeight = $Serie["Weight"] + 2; } else { $SerieWeight = 2; }

    3360. 

  3360.          if ( $PlotSize != NULL ) { $SerieWeight = $PlotSize; }

    3361. 

  3361. 

    3362. 

  3362.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    3363. 

  3363.          if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }

    3364. 

  3364.          if ( isset($Serie["Picture"]) )

    3365. 

  3365.           { $Picture = $Serie["Picture"]; list($PicWidth,$PicHeight,$PicType) = $this->getPicInfo($Picture); }

    3366. 

  3366.          else { $Picture = NULL; $PicOffset = 0; }

    3367. 

  3367. 

    3368. 

  3368.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3369. 

  3369. 

    3370. 

  3370.          $AxisID	= $Serie["Axis"];

    3371. 

  3371.          $Shape		= $Serie["Shape"];

    3372. 

  3372.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3373. 

  3373.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3374. 

  3374.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3375. 

  3375. 

    3376. 

  3376.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    3377. 

  3377. 

    3378. 

  3378.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3379. 

  3379. 

    3380. 

  3380.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    3381. 

  3381. 

    3382. 

  3382.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3383. 

  3383.           {

    3384. 

  3384.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3385. 

  3385.            if ( $Picture != NULL ) { $PicOffset = $PicHeight / 2; $SerieWeight = 0; }

    3386. 

  3386.            $X = $this->GraphAreaX1 + $XMargin;

    3387. 

  3387. 

    3388. 

  3388.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3389. 

  3389.            foreach($PosArray as $Key => $Y)

    3390. 

  3390.             {

    3391. 

  3391.              if ( $DisplayValues ) 

    3392. 

  3392.               $this->drawText($X,$Y-$DisplayOffset-$SerieWeight-$BorderSize-$PicOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    3393. 

  3393. 

    3394. 

  3394.              if ( $Y != VOID )

    3395. 

  3395.               {

    3396. 

  3396.                if ( $RecordImageMap ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$SerieWeight,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3397. 

  3397. 

    3398. 

  3398.                if ( $Picture != NULL )

    3399. 

  3399.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }

    3400. 

  3400.                else

    3401. 

  3401.                 { $this->drawShape($X,$Y,$Shape,$SerieWeight,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }

    3402. 

  3402.               }

    3403. 

  3403.              $X = $X + $XStep;

    3404. 

  3404.             }

    3405. 

  3405.           }

    3406. 

  3406.          else

    3407. 

  3407.           {

    3408. 

  3408.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    3409. 

  3409.            if ( $Picture != NULL ) { $PicOffset = $PicWidth / 2; $SerieWeight = 0; }

    3410. 

  3410.            $Y = $this->GraphAreaY1 + $XMargin;

    3411. 

  3411. 

    3412. 

  3412.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3413. 

  3413.            foreach($PosArray as $Key => $X)

    3414. 

  3414.             {

    3415. 

  3415.              if ( $DisplayValues ) 

    3416. 

  3416.               $this->drawText($X+$DisplayOffset+$SerieWeight+$BorderSize+$PicOffset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    3417. 

  3417. 

    3418. 

  3418.              if ( $X != VOID )

    3419. 

  3419.               {

    3420. 

  3420.                if ( $RecordImageMap ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$SerieWeight,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3421. 

  3421. 

    3422. 

  3422.                if ( $Picture != NULL )

    3423. 

  3423.                 { $this->drawFromPicture($PicType,$Picture,$X-$PicWidth/2,$Y-$PicHeight/2); }

    3424. 

  3424.                else

    3425. 

  3425.                 { $this->drawShape($X,$Y,$Shape,$SerieWeight,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha); }

    3426. 

  3426.               }

    3427. 

  3427.              $Y = $Y + $YStep;

    3428. 

  3428.             }

    3429. 

  3429.           }

    3430. 

  3430.         }

    3431. 

  3431.       }

    3432. 

  3432.     }

    3433. 

  3433. 

    3434. 

  3434.    /* Draw a spline chart */

    3435. 

  3435.    function drawSplineChart($Format=NULL)

    3436. 

  3436.     {

    3437. 

  3437.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;

    3438. 

  3438.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

    3439. 

  3439.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL; // 234

    3440. 

  3440.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL; // 55

    3441. 

  3441.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL; // 26

    3442. 

  3442.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    3443. 

  3443.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    3444. 

  3444.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3445. 

  3445.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    3446. 

  3446.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    3447. 

  3447.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    3448. 

  3448.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    3449. 

  3449.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

    3450. 

  3450. 

    3451. 

  3451.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3452. 

  3452. 

    3453. 

  3453.      $Data = $this->DataSet->getData();

    3454. 

  3454.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3455. 

  3455.      foreach($Data["Series"] as $SerieName => $Serie)

    3456. 

  3456.       {

    3457. 

  3457.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    3458. 

  3458.         {

    3459. 

  3459.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    3460. 

  3460. 

    3461. 

  3461.          if ( $BreakR == NULL )

    3462. 

  3462.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks);

    3463. 

  3463.          else

    3464. 

  3464.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

    3465. 

  3465. 

    3466. 

  3466.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3467. 

  3467. 

    3468. 

  3468.          $AxisID	= $Serie["Axis"];

    3469. 

  3469.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3470. 

  3470.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3471. 

  3471.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3472. 

  3472. 

    3473. 

  3473.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    3474. 

  3474. 

    3475. 

  3475.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3476. 

  3476. 

    3477. 

  3477.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    3478. 

  3478. 

    3479. 

  3479.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3480. 

  3480.           {

    3481. 

  3481.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3482. 

  3482.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";

    3483. 

  3483.            $Force = $XStep / 5;

    3484. 

  3484. 

    3485. 

  3485.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3486. 

  3486.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;

    3487. 

  3487.            foreach($PosArray as $Key => $Y)

    3488. 

  3488.             {

    3489. 

  3489.              if ( $DisplayValues ) 

    3490. 

  3490.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    3491. 

  3491. 	

    3492. 

  3492.              if ( $RecordImageMap && $Y != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3493. 

  3493. 

    3494. 

  3494.              if ( $Y == VOID && $LastY != NULL )

    3495. 

  3495.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }

    3496. 

  3496. 

    3497. 

  3497.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

    3498. 

  3498.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }

    3499. 

  3499. 

    3500. 

  3500.              if ( $Y != VOID )

    3501. 

  3501.               $WayPoints[] = array($X,$Y);

    3502. 

  3502. 

    3503. 

  3503.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    3504. 

  3504.              if ( $Y == VOID ) { $Y = NULL; }

    3505. 

  3505. 

    3506. 

  3506.              $LastX = $X; $LastY = $Y;

    3507. 

  3507.              $X = $X + $XStep;

    3508. 

  3508.             }

    3509. 

  3509.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    3510. 

  3510.           }

    3511. 

  3511.          else

    3512. 

  3512.           {

    3513. 

  3513.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    3514. 

  3514.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";

    3515. 

  3515.            $Force = $YStep / 5;

    3516. 

  3516. 

    3517. 

  3517.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3518. 

  3518.            $LastGoodY = NULL; $LastGoodX = NULL; $LastX = 1; $LastY = 1;

    3519. 

  3519.            foreach($PosArray as $Key => $X)

    3520. 

  3520.             {

    3521. 

  3521.              if ( $DisplayValues ) 

    3522. 

  3522.               $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));

    3523. 

  3523. 

    3524. 

  3524.              if ( $RecordImageMap && $X != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3525. 

  3525. 

    3526. 

  3526.              if ( $X == VOID && $LastX != NULL )

    3527. 

  3527.               { $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight)); $WayPoints = ""; }

    3528. 

  3528. 

    3529. 

  3529.              if ( $X != VOID && $LastX == NULL && $LastGoodX != NULL && !$BreakVoid )

    3530. 

  3530.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); }

    3531. 

  3531. 

    3532. 

  3532.              if ( $X != VOID )

    3533. 

  3533.               $WayPoints[] = array($X,$Y);

    3534. 

  3534. 

    3535. 

  3535.              if ( $X != VOID ) { $LastGoodX = $X; $LastGoodY = $Y; }

    3536. 

  3536.              if ( $X == VOID ) { $X = NULL; }

    3537. 

  3537. 

    3538. 

  3538.              $LastX = $X; $LastY = $Y;

    3539. 

  3539.              $Y = $Y + $YStep;

    3540. 

  3540.             }

    3541. 

  3541.            $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    3542. 

  3542.           }

    3543. 

  3543.         }

    3544. 

  3544.       }

    3545. 

  3545.     }

    3546. 

  3546. 

    3547. 

  3547.    /* Draw a filled spline chart */

    3548. 

  3548.    function drawFilledSplineChart($Format=NULL)

    3549. 

  3549.     {

    3550. 

  3550.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    3551. 

  3551.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    3552. 

  3552.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3553. 

  3553.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    3554. 

  3554.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    3555. 

  3555.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    3556. 

  3556.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

    3557. 

  3557.      $Threshold		= isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

    3558. 

  3558. 

    3559. 

  3559.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3560. 

  3560. 

    3561. 

  3561.      $Data = $this->DataSet->getData();

    3562. 

  3562.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3563. 

  3563.      foreach($Data["Series"] as $SerieName => $Serie)

    3564. 

  3564.       {

    3565. 

  3565.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    3566. 

  3566.         {

    3567. 

  3567.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    3568. 

  3568.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3569. 

  3569. 

    3570. 

  3570.          $AxisID	= $Serie["Axis"];

    3571. 

  3571.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3572. 

  3572.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3573. 

  3573.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3574. 

  3574. 

    3575. 

  3575.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3576. 

  3576.          if ( $AroundZero ) { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }

    3577. 

  3577. 

    3578. 

  3578.          if ( $Threshold != NULL )

    3579. 

  3579.           {

    3580. 

  3580.            foreach($Threshold as $Key => $Params)

    3581. 

  3581.             {

    3582. 

  3582.              $Threshold[$Key]["MinX"] = $this->scaleComputeY($Params["Min"],array("AxisID"=>$Serie["Axis"]));

    3583. 

  3583.              $Threshold[$Key]["MaxX"] = $this->scaleComputeY($Params["Max"],array("AxisID"=>$Serie["Axis"]));

    3584. 

  3584.             }

    3585. 

  3585.           }

    3586. 

  3586. 

    3587. 

  3587.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    3588. 

  3588. 

    3589. 

  3589.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3590. 

  3590.           {

    3591. 

  3591.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3592. 

  3592.            $X     = $this->GraphAreaX1 + $XMargin; $WayPoints = "";

    3593. 

  3593.            $Force = $XStep / 5;

    3594. 

  3594. 

    3595. 

  3595.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }

    3596. 

  3596.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    3597. 

  3597.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

    3598. 

  3598. 

    3599. 

  3599.            $LastX = ""; $LastY = "";

    3600. 

  3600.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3601. 

  3601.            foreach($PosArray as $Key => $Y)

    3602. 

  3602.             {

    3603. 

  3603.              if ( $DisplayValues ) 

    3604. 

  3604.               $this->drawText($X,$Y-$DisplayOffset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));

    3605. 

  3605. 

    3606. 

  3606.              if ( $Y == VOID )

    3607. 

  3607.               {

    3608. 

  3608.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

    3609. 

  3609. 

    3610. 

  3610.                if ( $Area != "" )

    3611. 

  3611.                 {

    3612. 

  3612.                  foreach ($Area as $key => $Points)

    3613. 

  3613.                   {

    3614. 

  3614.                    $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;

    3615. 

  3615.                    foreach($Points as $subKey => $Point)

    3616. 

  3616.                     {

    3617. 

  3617.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

    3618. 

  3618.                      $Corners[] = $Point["Y"]+1;

    3619. 

  3619.                     }

    3620. 

  3620.                    $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;

    3621. 

  3621. 

    3622. 

  3622.                    $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

    3623. 

  3623.                   }

    3624. 

  3624.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

    3625. 

  3625.                 }

    3626. 

  3626. 

    3627. 

  3627.                $WayPoints = "";

    3628. 

  3628.               }

    3629. 

  3629.              else

    3630. 

  3630.               $WayPoints[] = array($X,$Y-.5); /* -.5 for AA visual fix */

    3631. 

  3631. 

    3632. 

  3632.              $X = $X + $XStep;

    3633. 

  3633.             }

    3634. 

  3634.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

    3635. 

  3635. 

    3636. 

  3636.            if ( $Area != "" )

    3637. 

  3637.             {

    3638. 

  3638.              foreach ($Area as $key => $Points)

    3639. 

  3639.               {

    3640. 

  3640.                $Corners = ""; $Corners[] = $Area[$key][0]["X"]; $Corners[] = $YZero;

    3641. 

  3641.                foreach($Points as $subKey => $Point)

    3642. 

  3642.                 {

    3643. 

  3643.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

    3644. 

  3644.                  $Corners[] = $Point["Y"]+1;

    3645. 

  3645.                 }

    3646. 

  3646.                $Corners[] = $Points[$subKey]["X"]-1; $Corners[] = $YZero;

    3647. 

  3647. 

    3648. 

  3648.                $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

    3649. 

  3649.               }

    3650. 

  3650.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

    3651. 

  3651.             }

    3652. 

  3652.           }

    3653. 

  3653.          else

    3654. 

  3654.           {

    3655. 

  3655.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    3656. 

  3656.            $Y     = $this->GraphAreaY1 + $XMargin; $WayPoints = "";

    3657. 

  3657.            $Force = $YStep / 5;

    3658. 

  3658. 

    3659. 

  3659.            if ( !$AroundZero ) { $YZero = $this->GraphAreaX1+1; }

    3660. 

  3660.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    3661. 

  3661.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    3662. 

  3662. 

    3663. 

  3663.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3664. 

  3664.            foreach($PosArray as $Key => $X)

    3665. 

  3665.             {

    3666. 

  3666.              if ( $DisplayValues ) 

    3667. 

  3667.               $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));

    3668. 

  3668. 

    3669. 

  3669.              if ( $X == VOID )

    3670. 

  3670.               {

    3671. 

  3671.                $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

    3672. 

  3672. 

    3673. 

  3673.                if ( $Area != "" )

    3674. 

  3674.                 {

    3675. 

  3675.                  foreach ($Area as $key => $Points)

    3676. 

  3676.                   {

    3677. 

  3677.                    $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];

    3678. 

  3678.                    foreach($Points as $subKey => $Point)

    3679. 

  3679.                     {

    3680. 

  3680.                      if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

    3681. 

  3681.                      $Corners[] = $Point["Y"];

    3682. 

  3682.                     }

    3683. 

  3683.                    $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;

    3684. 

  3684. 

    3685. 

  3685.                    $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

    3686. 

  3686.                   }

    3687. 

  3687.                  $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

    3688. 

  3688.                 }

    3689. 

  3689. 

    3690. 

  3690.                $WayPoints = "";

    3691. 

  3691.               }

    3692. 

  3692.              else

    3693. 

  3693.               $WayPoints[] = array($X,$Y);

    3694. 

  3694. 

    3695. 

  3695.              $Y = $Y + $YStep;

    3696. 

  3696.             }

    3697. 

  3697.            $Area = $this->drawSpline($WayPoints,array("Force"=>$Force,"PathOnly"=>TRUE));

    3698. 

  3698. 

    3699. 

  3699.            if ( $Area != "" )

    3700. 

  3700.             {

    3701. 

  3701.              foreach ($Area as $key => $Points)

    3702. 

  3702.               {

    3703. 

  3703.                $Corners = ""; $Corners[] = $YZero; $Corners[] = $Area[$key][0]["Y"];

    3704. 

  3704.                foreach($Points as $subKey => $Point)

    3705. 

  3705.                 {

    3706. 

  3706.                  if ( $subKey == count($Points)-1) { $Corners[] = $Point["X"]-1; } else { $Corners[] = $Point["X"]; }

    3707. 

  3707.                  $Corners[] = $Point["Y"];

    3708. 

  3708.                 }

    3709. 

  3709.                $Corners[] = $YZero; $Corners[] = $Points[$subKey]["Y"]-1;

    3710. 

  3710. 

    3711. 

  3711.                $this->drawPolygonChart($Corners,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha/2,"NoBorder"=>TRUE,"Threshold"=>$Threshold));

    3712. 

  3712.               }

    3713. 

  3713.              $this->drawSpline($WayPoints,array("Force"=>$Force,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));

    3714. 

  3714.             }

    3715. 

  3715. 

    3716. 

  3716.           }

    3717. 

  3717.         }

    3718. 

  3718.       }

    3719. 

  3719.     }

    3720. 

  3720. 

    3721. 

  3721.    /* Draw a line chart */

    3722. 

  3722.    function drawLineChart($Format=NULL)

    3723. 

  3723.     {

    3724. 

  3724.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;

    3725. 

  3725.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

    3726. 

  3726.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;

    3727. 

  3727.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;

    3728. 

  3728.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;

    3729. 

  3729.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    3730. 

  3730.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    3731. 

  3731.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3732. 

  3732.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    3733. 

  3733.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    3734. 

  3734.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    3735. 

  3735.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    3736. 

  3736.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

    3737. 

  3737.      $ForceColor	= isset($Format["ForceColor"]) ? $Format["ForceColor"] : FALSE;

    3738. 

  3738.      $ForceR		= isset($Format["ForceR"]) ? $Format["ForceR"] : 0;

    3739. 

  3739.      $ForceG		= isset($Format["ForceG"]) ? $Format["ForceG"] : 0;

    3740. 

  3740.      $ForceB		= isset($Format["ForceB"]) ? $Format["ForceB"] : 0;

    3741. 

  3741.      $ForceAlpha	= isset($Format["ForceAlpha"]) ? $Format["ForceAlpha"] : 100;

    3742. 

  3742. 

    3743. 

  3743.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3744. 

  3744. 

    3745. 

  3745.      $Data = $this->DataSet->getData();

    3746. 

  3746.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3747. 

  3747.      foreach($Data["Series"] as $SerieName => $Serie)

    3748. 

  3748.       {

    3749. 

  3749.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    3750. 

  3750.         {

    3751. 

  3751.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    3752. 

  3752. 

    3753. 

  3753.          if ( $ForceColor )

    3754. 

  3754.           { $R = $ForceR; $G = $ForceG; $B = $ForceB; $Alpha = $ForceAlpha; }

    3755. 

  3755. 

    3756. 

  3756.          if ( $BreakR == NULL )

    3757. 

  3757.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

    3758. 

  3758.          else

    3759. 

  3759.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

    3760. 

  3760. 

    3761. 

  3761.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3762. 

  3762. 

    3763. 

  3763.          $AxisID	= $Serie["Axis"];

    3764. 

  3764.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3765. 

  3765.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3766. 

  3766.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3767. 

  3767. 

    3768. 

  3768.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    3769. 

  3769. 

    3770. 

  3770.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3771. 

  3771. 

    3772. 

  3772.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    3773. 

  3773. 

    3774. 

  3774.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3775. 

  3775.           {

    3776. 

  3776.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3777. 

  3777.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

    3778. 

  3778. 

    3779. 

  3779.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3780. 

  3780.            $LastGoodY = NULL; $LastGoodX = NULL;

    3781. 

  3781.            foreach($PosArray as $Key => $Y)

    3782. 

  3782.             {

    3783. 

  3783.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

    3784. 

  3784.               {

    3785. 

  3785.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

    3786. 

  3786.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

    3787. 

  3787.               }

    3788. 

  3788. 

    3789. 

  3789.              if ( $RecordImageMap && $Y != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3790. 

  3790. 

    3791. 

  3791.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

    3792. 

  3792.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    3793. 

  3793. 

    3794. 

  3794.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

    3795. 

  3795.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }

    3796. 

  3796. 

    3797. 

  3797.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    3798. 

  3798.              if ( $Y == VOID ) { $Y = NULL; }

    3799. 

  3799. 

    3800. 

  3800.              $LastX = $X; $LastY = $Y;

    3801. 

  3801.              $X = $X + $XStep;

    3802. 

  3802.             }

    3803. 

  3803.           }

    3804. 

  3804.          else

    3805. 

  3805.           {

    3806. 

  3806.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    3807. 

  3807.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

    3808. 

  3808. 

    3809. 

  3809.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3810. 

  3810.            $LastGoodY = NULL; $LastGoodX = NULL;

    3811. 

  3811.            foreach($PosArray as $Key => $X)

    3812. 

  3812.             {

    3813. 

  3813.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

    3814. 

  3814.               { $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)); }

    3815. 

  3815. 

    3816. 

  3816.              if ( $RecordImageMap && $X != VOID ) { $this->addToImageMap("CIRCLE",floor($X).",".floor($Y).",".$ImageMapPlotSize,$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3817. 

  3817. 

    3818. 

  3818.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

    3819. 

  3819.               $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight));

    3820. 

  3820. 

    3821. 

  3821.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )

    3822. 

  3822.               { $this->drawLine($LastGoodX,$LastGoodY,$X,$Y,$BreakSettings); $LastGoodY = NULL; }

    3823. 

  3823. 

    3824. 

  3824.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    3825. 

  3825.              if ( $X == VOID ) { $X = NULL; }

    3826. 

  3826. 

    3827. 

  3827.              $LastX = $X; $LastY = $Y;

    3828. 

  3828.              $Y = $Y + $YStep;

    3829. 

  3829.             }

    3830. 

  3830.           }

    3831. 

  3831.         }

    3832. 

  3832.       }

    3833. 

  3833.     }

    3834. 

  3834. 

    3835. 

  3835.    /* Draw a line chart */

    3836. 

  3836.    function drawZoneChart($SerieA,$SerieB,$Format=NULL)

    3837. 

  3837.     {

    3838. 

  3838.      $AxisID	= isset($Format["AxisID"]) ? $Format["AxisID"] : 0;

    3839. 

  3839.      $LineR	= isset($Format["LineR"]) ? $Format["LineR"] : 150;

    3840. 

  3840.      $LineG	= isset($Format["LineG"]) ? $Format["LineG"] : 150;

    3841. 

  3841.      $LineB	= isset($Format["LineB"]) ? $Format["LineB"] : 150;

    3842. 

  3842.      $LineAlpha	= isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 50;

    3843. 

  3843.      $LineTicks	= isset($Format["LineTicks"]) ? $Format["LineTicks"] : 1;

    3844. 

  3844.      $AreaR	= isset($Format["AreaR"]) ? $Format["AreaR"] : 150;

    3845. 

  3845.      $AreaG	= isset($Format["AreaG"]) ? $Format["AreaG"] : 150;

    3846. 

  3846.      $AreaB	= isset($Format["AreaB"]) ? $Format["AreaB"] : 150;

    3847. 

  3847.      $AreaAlpha	= isset($Format["AreaAlpha"]) ? $Format["AreaAlpha"] : 5;

    3848. 

  3848. 

    3849. 

  3849.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3850. 

  3850. 

    3851. 

  3851.      $Data	 = $this->DataSet->getData();

    3852. 

  3852.      if ( !isset($Data["Series"][$SerieA]["Data"]) || !isset($Data["Series"][$SerieB]["Data"]) ) { return(0); }

    3853. 

  3853.      $SerieAData = $Data["Series"][$SerieA]["Data"];

    3854. 

  3854.      $SerieBData = $Data["Series"][$SerieB]["Data"];

    3855. 

  3855. 

    3856. 

  3856.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3857. 

  3857. 

    3858. 

  3858.      $Mode	= $Data["Axis"][$AxisID]["Display"];

    3859. 

  3859.      $Format	= $Data["Axis"][$AxisID]["Format"];

    3860. 

  3860.      $Unit	= $Data["Axis"][$AxisID]["Unit"];

    3861. 

  3861. 

    3862. 

  3862.      $PosArrayA = $this->scaleComputeY($SerieAData,array("AxisID"=>$AxisID));

    3863. 

  3863.      $PosArrayB = $this->scaleComputeY($SerieBData,array("AxisID"=>$AxisID));

    3864. 

  3864.      if ( count($PosArrayA) != count($PosArrayB) ) { return(0); }

    3865. 

  3865. 

    3866. 

  3866.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3867. 

  3867.       {

    3868. 

  3868.        if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3869. 

  3869.        $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

    3870. 

  3870. 

    3871. 

  3871.        $LastX = NULL; $LastY1 = NULL; $LastY2 = NULL;

    3872. 

  3872.        $BoundsA = ""; $BoundsB = "";

    3873. 

  3873.        foreach($PosArrayA as $Key => $Y1)

    3874. 

  3874.         {

    3875. 

  3875.          $Y2 = $PosArrayB[$Key];

    3876. 

  3876. 

    3877. 

  3877.          $BoundsA[] = $X; $BoundsA[] = $Y1;

    3878. 

  3878.          $BoundsB[] = $X; $BoundsB[] = $Y2;

    3879. 

  3879. 

    3880. 

  3880.          $LastX = $X;

    3881. 

  3881.          $LastY1 = $Y1; $LastY2 = $Y2;

    3882. 

  3882. 

    3883. 

  3883.          $X = $X + $XStep;

    3884. 

  3884.         }

    3885. 

  3885.        $Bounds = array_merge($BoundsA,$this->reversePlots($BoundsB));

    3886. 

  3886.        $this->drawPolygonChart($Bounds,array("R"=>$AreaR,"G"=>$AreaG,"B"=>$AreaB,"Alpha"=>$AreaAlpha));

    3887. 

  3887. 

    3888. 

  3888.        for($i=0;$i<=count($BoundsA)-4;$i=$i+2)

    3889. 

  3889.         {

    3890. 

  3890.          $this->drawLine($BoundsA[$i],$BoundsA[$i+1],$BoundsA[$i+2],$BoundsA[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

    3891. 

  3891.          $this->drawLine($BoundsB[$i],$BoundsB[$i+1],$BoundsB[$i+2],$BoundsB[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

    3892. 

  3892.         }

    3893. 

  3893.       }

    3894. 

  3894.      else

    3895. 

  3895.       {

    3896. 

  3896.        if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    3897. 

  3897.        $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

    3898. 

  3898. 

    3899. 

  3899.        $LastY = NULL; $LastX1 = NULL; $LastX2 = NULL;

    3900. 

  3900.        $BoundsA = ""; $BoundsB = "";

    3901. 

  3901.        foreach($PosArrayA as $Key => $X1)

    3902. 

  3902.         {

    3903. 

  3903.          $X2 = $PosArrayB[$Key];

    3904. 

  3904. 

    3905. 

  3905.          $BoundsA[] = $X1; $BoundsA[] = $Y;

    3906. 

  3906.          $BoundsB[] = $X2; $BoundsB[] = $Y;

    3907. 

  3907. 

    3908. 

  3908.          $LastY = $Y;

    3909. 

  3909.          $LastX1 = $X1; $LastX2 = $X2;

    3910. 

  3910. 

    3911. 

  3911.          $Y = $Y + $YStep;

    3912. 

  3912.         }

    3913. 

  3913.        $Bounds = array_merge($BoundsA,$this->reversePlots($BoundsB));

    3914. 

  3914.        $this->drawPolygonChart($Bounds,array("R"=>$AreaR,"G"=>$AreaG,"B"=>$AreaB,"Alpha"=>$AreaAlpha));

    3915. 

  3915. 

    3916. 

  3916.        for($i=0;$i<=count($BoundsA)-4;$i=$i+2)

    3917. 

  3917.         {

    3918. 

  3918.          $this->drawLine($BoundsA[$i],$BoundsA[$i+1],$BoundsA[$i+2],$BoundsA[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

    3919. 

  3919.          $this->drawLine($BoundsB[$i],$BoundsB[$i+1],$BoundsB[$i+2],$BoundsB[$i+3],array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha,"Ticks"=>$LineTicks));

    3920. 

  3920.         }

    3921. 

  3921.       }

    3922. 

  3922.     }

    3923. 

  3923. 

    3924. 

  3924.    /* Draw a step chart */

    3925. 

  3925.    function drawStepChart($Format=NULL)

    3926. 

  3926.     {

    3927. 

  3927.      $BreakVoid		= isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : FALSE;

    3928. 

  3928.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;

    3929. 

  3929.      $VoidTicks		= isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;

    3930. 

  3930.      $BreakR		= isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;

    3931. 

  3931.      $BreakG		= isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;

    3932. 

  3932.      $BreakB		= isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;

    3933. 

  3933.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;

    3934. 

  3934.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    3935. 

  3935.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    3936. 

  3936.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    3937. 

  3937.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    3938. 

  3938.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    3939. 

  3939.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    3940. 

  3940.      $ImageMapPlotSize  = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;

    3941. 

  3941. 

    3942. 

  3942.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    3943. 

  3943. 

    3944. 

  3944.      $Data = $this->DataSet->getData();

    3945. 

  3945.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    3946. 

  3946.      foreach($Data["Series"] as $SerieName => $Serie)

    3947. 

  3947.       {

    3948. 

  3948.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    3949. 

  3949.         {

    3950. 

  3950.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    3951. 

  3951. 

    3952. 

  3952.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    3953. 

  3953. 

    3954. 

  3954.          if ( $BreakR == NULL )

    3955. 

  3955.           $BreakSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

    3956. 

  3956.          else

    3957. 

  3957.           $BreakSettings = array("R"=>$BreakR,"G"=>$BreakG,"B"=>$BreakB,"Alpha"=>$Alpha,"Ticks"=>$VoidTicks,"Weight"=>$Weight);

    3958. 

  3958. 

    3959. 

  3959.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    3960. 

  3960. 

    3961. 

  3961.          $AxisID	= $Serie["Axis"];

    3962. 

  3962.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    3963. 

  3963.          $Format	= $Data["Axis"][$AxisID]["Format"];

    3964. 

  3964.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    3965. 

  3965.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

    3966. 

  3966. 

    3967. 

  3967.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    3968. 

  3968. 

    3969. 

  3969.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    3970. 

  3970. 

    3971. 

  3971.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    3972. 

  3972.           {

    3973. 

  3973.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    3974. 

  3974.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

    3975. 

  3975. 

    3976. 

  3976.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    3977. 

  3977.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;

    3978. 

  3978.            foreach($PosArray as $Key => $Y)

    3979. 

  3979.             {

    3980. 

  3980.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

    3981. 

  3981.               {

    3982. 

  3982.                if ( $Y <= $LastY ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

    3983. 

  3983.                $this->drawText($X,$Y-$Offset-$Weight,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

    3984. 

  3984.               }

    3985. 

  3985. 

    3986. 

  3986.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

    3987. 

  3987.               {

    3988. 

  3988.                $this->drawLine($LastX,$LastY,$X,$LastY,$Color);

    3989. 

  3989.                $this->drawLine($X,$LastY,$X,$Y,$Color);

    3990. 

  3990.                if ( $ReCenter && $X+$XStep < $this->GraphAreaX2 - $XMargin )

    3991. 

  3991.                 {

    3992. 

  3992.                  $this->drawLine($X,$Y,$X+$XStep,$Y,$Color);

    3993. 

  3993.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X-$ImageMapPlotSize).",".floor($Y-$ImageMapPlotSize).",".floor($X+$XStep+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    3994. 

  3994.                 }

    3995. 

  3995.                else

    3996. 

  3996.                 { if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); } }

    3997. 

  3997.               }

    3998. 

  3998. 

    3999. 

  3999.              if ( $Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid )

    4000. 

  4000.               { 

    4001. 

  4001.                if ( $ReCenter )

    4002. 

  4002.                 {

    4003. 

  4003.                  $this->drawLine($LastGoodX+$XStep,$LastGoodY,$X,$LastGoodY,$BreakSettings);

    4004. 

  4004.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX+$XStep-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastGoodY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4005. 

  4005.                 }

    4006. 

  4006.                else

    4007. 

  4007.                 {

    4008. 

  4008.                  $this->drawLine($LastGoodX,$LastGoodY,$X,$LastGoodY,$BreakSettings);

    4009. 

  4009.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($LastGoodY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4010. 

  4010.                 }

    4011. 

  4011. 

    4012. 

  4012.                $this->drawLine($X,$LastGoodY,$X,$Y,$BreakSettings);

    4013. 

  4013.                $LastGoodY = NULL;

    4014. 

  4014.               }

    4015. 

  4015.              elseif( !$BreakVoid && $LastGoodY == NULL && $Y != VOID )

    4016. 

  4016.               {

    4017. 

  4017.               $this->drawLine($this->GraphAreaX1 + $XMargin,$Y,$X,$Y,$BreakSettings);

    4018. 

  4018.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($this->GraphAreaX1+$XMargin-$ImageMapPlotSize).",".floor($Y-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4019. 

  4019.               }

    4020. 

  4020. 

    4021. 

  4021.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    4022. 

  4022.              if ( $Y == VOID ) { $Y = NULL; }

    4023. 

  4023. 

    4024. 

  4024.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }

    4025. 

  4025.              $LastX = $X; $LastY = $Y;

    4026. 

  4026.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }

    4027. 

  4027.              $X = $X + $XStep;

    4028. 

  4028.             }

    4029. 

  4029.            if ( $ReCenter )

    4030. 

  4030.             {

    4031. 

  4031.              $this->drawLine($LastX,$LastY,$this->GraphAreaX2 - $XMargin,$LastY,$Color);

    4032. 

  4032.              if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($this->GraphAreaX2-$XMargin+$ImageMapPlotSize).",".floor($LastY+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4033. 

  4033.             }

    4034. 

  4034.           }

    4035. 

  4035.          else

    4036. 

  4036.           {

    4037. 

  4037.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    4038. 

  4038.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

    4039. 

  4039. 

    4040. 

  4040.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4041. 

  4041.            $LastGoodY = NULL; $LastGoodX = NULL; $Init = FALSE;

    4042. 

  4042.            foreach($PosArray as $Key => $X)

    4043. 

  4043.             {

    4044. 

  4044.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

    4045. 

  4045.               {

    4046. 

  4046.                if ( $X >= $LastX ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }

    4047. 

  4047.                $this->drawText($X+$Offset+$Weight,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

    4048. 

  4048.               }

    4049. 

  4049. 

    4050. 

  4050.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

    4051. 

  4051.               {

    4052. 

  4052.                $this->drawLine($LastX,$LastY,$LastX,$Y,$Color);

    4053. 

  4053.                $this->drawLine($LastX,$Y,$X,$Y,$Color);

    4054. 

  4054. 

    4055. 

  4055.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($LastX+$XStep+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4056. 

  4056.               }

    4057. 

  4057. 

    4058. 

  4058.              if ( $X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid )

    4059. 

  4059.               {

    4060. 

  4060.                $this->drawLine($LastGoodX,$LastGoodY,$LastGoodX,$LastGoodY+$YStep,$Color);

    4061. 

  4061.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY-$ImageMapPlotSize).",".floor($LastGoodX+$ImageMapPlotSize).",".floor($LastGoodY+$YStep+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4062. 

  4062. 

    4063. 

  4063.                $this->drawLine($LastGoodX,$LastGoodY+$YStep,$LastGoodX,$Y,$BreakSettings);

    4064. 

  4064.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastGoodX-$ImageMapPlotSize).",".floor($LastGoodY+$YStep-$ImageMapPlotSize).",".floor($LastGoodX+$ImageMapPlotSize).",".floor($YStep+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4065. 

  4065. 

    4066. 

  4066.                $this->drawLine($LastGoodX,$Y,$X,$Y,$BreakSettings);

    4067. 

  4067.                $LastGoodY = NULL;

    4068. 

  4068.               }

    4069. 

  4069.              elseif ( $X != VOID && $LastGoodY == NULL && !$BreakVoid )

    4070. 

  4070.               {

    4071. 

  4071.                $this->drawLine($X,$this->GraphAreaY1 + $XMargin,$X,$Y,$BreakSettings);

    4072. 

  4072.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X-$ImageMapPlotSize).",".floor($this->GraphAreaY1+$XMargin-$ImageMapPlotSize).",".floor($X+$ImageMapPlotSize).",".floor($Y+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4073. 

  4073.               }

    4074. 

  4074. 

    4075. 

  4075.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    4076. 

  4076.              if ( $X == VOID ) { $X = NULL; }

    4077. 

  4077. 

    4078. 

  4078.              if ( !$Init && $ReCenter ) { $Y = $Y - $YStep/2; $Init = TRUE; }

    4079. 

  4079.              $LastX = $X; $LastY = $Y;

    4080. 

  4080.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }

    4081. 

  4081.              $Y = $Y + $YStep;

    4082. 

  4082.             }

    4083. 

  4083.            if ( $ReCenter )

    4084. 

  4084.             {

    4085. 

  4085.              $this->drawLine($LastX,$LastY,$LastX,$this->GraphAreaY2 - $XMargin,$Color);

    4086. 

  4086.              if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($LastX-$ImageMapPlotSize).",".floor($LastY-$ImageMapPlotSize).",".floor($LastX+$ImageMapPlotSize).",".floor($this->GraphAreaY2-$XMargin+$ImageMapPlotSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4087. 

  4087.             }

    4088. 

  4088.           }

    4089. 

  4089.         }

    4090. 

  4090.       }

    4091. 

  4091.     }

    4092. 

  4092. 

    4093. 

  4093.    /* Draw a step chart */

    4094. 

  4094.    function drawFilledStepChart($Format=NULL)

    4095. 

  4095.     {

    4096. 

  4096.      $ReCenter		= isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;

    4097. 

  4097.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] :FALSE;

    4098. 

  4098.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    4099. 

  4099.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    4100. 

  4100.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;

    4101. 

  4101.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    4102. 

  4102.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    4103. 

  4103.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    4104. 

  4104.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

    4105. 

  4105. 

    4106. 

  4106.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    4107. 

  4107. 

    4108. 

  4108.      $Data = $this->DataSet->getData();

    4109. 

  4109.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    4110. 

  4110.      foreach($Data["Series"] as $SerieName => $Serie)

    4111. 

  4111.       {

    4112. 

  4112.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    4113. 

  4113.         {

    4114. 

  4114.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    4115. 

  4115. 

    4116. 

  4116.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    4117. 

  4117. 

    4118. 

  4118.          $AxisID	= $Serie["Axis"];

    4119. 

  4119.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    4120. 

  4120.          $Format	= $Data["Axis"][$AxisID]["Format"];

    4121. 

  4121.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    4122. 

  4122. 

    4123. 

  4123.          $Color		= array("R"=>$R,"G"=>$G,"B"=>$B);

    4124. 

  4124.          if ( $ForceTransparency != NULL ) { $Color["Alpha"] = $ForceTransparency; } else { $Color["Alpha"] = $Alpha; }

    4125. 

  4125. 

    4126. 

  4126.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    4127. 

  4127.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

    4128. 

  4128. 

    4129. 

  4129.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    4130. 

  4130. 

    4131. 

  4131.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    4132. 

  4132.           {

    4133. 

  4133.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4134. 

  4134.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

    4135. 

  4135. 

    4136. 

  4136.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    4137. 

  4137.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

    4138. 

  4138. 

    4139. 

  4139.            if ( !$AroundZero ) { $YZero = $this->GraphAreaY2-1; }

    4140. 

  4140. 

    4141. 

  4141.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4142. 

  4142.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = ""; $Init = FALSE;

    4143. 

  4143.            foreach($PosArray as $Key => $Y)

    4144. 

  4144.             {

    4145. 

  4145.              if ( $Y == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )

    4146. 

  4146.               {

    4147. 

  4147.                $Points[] = $LastX; $Points[] = $LastY;

    4148. 

  4148.                $Points[] = $X; $Points[] = $LastY;

    4149. 

  4149.                $Points[] = $X; $Points[] = $YZero;

    4150. 

  4150.                $this->drawPolygon($Points,$Color);

    4151. 

  4151.                $Points = "";

    4152. 

  4152.               }

    4153. 

  4153. 

    4154. 

  4154.              if ( $Y != VOID && $LastX != NULL && $LastY != NULL )

    4155. 

  4155.               {

    4156. 

  4156.                if ( $Points == "") { $Points[] = $LastX; $Points[] = $YZero; }

    4157. 

  4157.                $Points[] = $LastX; $Points[] = $LastY;

    4158. 

  4158.                $Points[] = $X; $Points[] = $LastY;

    4159. 

  4159.                $Points[] = $X; $Points[] = $Y;

    4160. 

  4160.               }

    4161. 

  4161. 

    4162. 

  4162.              if ( $Y != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    4163. 

  4163.              if ( $Y == VOID ) { $Y = NULL; }

    4164. 

  4164. 

    4165. 

  4165.              if ( !$Init && $ReCenter ) { $X = $X - $XStep/2; $Init = TRUE; }

    4166. 

  4166.              $LastX = $X; $LastY = $Y;

    4167. 

  4167.              if ( $LastX < $this->GraphAreaX1 + $XMargin ) { $LastX = $this->GraphAreaX1 + $XMargin; }

    4168. 

  4168.              $X = $X + $XStep;

    4169. 

  4169.             }

    4170. 

  4170. 

    4171. 

  4171.            if ( $ReCenter )

    4172. 

  4172.             {

    4173. 

  4173.              $Points[] = $LastX+$XStep/2; $Points[] = $LastY;

    4174. 

  4174.              $Points[] = $LastX+$XStep/2; $Points[] = $YZero;

    4175. 

  4175.             }

    4176. 

  4176.            else

    4177. 

  4177.             { $Points[] = $LastX; $Points[] = $YZero; }

    4178. 

  4178. 

    4179. 

  4179.            $this->drawPolygon($Points,$Color);

    4180. 

  4180.           }

    4181. 

  4181.          else

    4182. 

  4182.           {

    4183. 

  4183.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    4184. 

  4184.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    4185. 

  4185. 

    4186. 

  4186.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    4187. 

  4187.            $Y = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

    4188. 

  4188. 

    4189. 

  4189.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4190. 

  4190.            $LastGoodY = NULL; $LastGoodX = NULL; $Points = "";

    4191. 

  4191.            foreach($PosArray as $Key => $X)

    4192. 

  4192.             {

    4193. 

  4193.              if ( $X == VOID && $LastX != NULL && $LastY != NULL && $Points !="" )

    4194. 

  4194.               {

    4195. 

  4195.                $Points[] = $LastX; $Points[] = $LastY;

    4196. 

  4196.                $Points[] = $LastX; $Points[] = $Y;

    4197. 

  4197.                $Points[] = $YZero; $Points[] = $Y;

    4198. 

  4198.                $this->drawPolygon($Points,$Color);

    4199. 

  4199.                $Points = "";

    4200. 

  4200.               }

    4201. 

  4201. 

    4202. 

  4202.              if ( $X != VOID && $LastX != NULL && $LastY != NULL )

    4203. 

  4203.               {

    4204. 

  4204.                if ( $Points == "") { $Points[] = $YZero; $Points[] = $LastY; }

    4205. 

  4205.                $Points[] = $LastX; $Points[] = $LastY;

    4206. 

  4206.                $Points[] = $LastX; $Points[] = $Y;

    4207. 

  4207.                $Points[] = $X; $Points[] = $Y;

    4208. 

  4208.               }

    4209. 

  4209. 

    4210. 

  4210.              if ( $X != VOID ) { $LastGoodY = $Y; $LastGoodX = $X; }

    4211. 

  4211.              if ( $X == VOID ) { $X = NULL; }

    4212. 

  4212. 

    4213. 

  4213.              if ( $LastX == NULL && $ReCenter ) { $Y = $Y - $YStep/2; }

    4214. 

  4214.              $LastX = $X; $LastY = $Y;

    4215. 

  4215.              if ( $LastY < $this->GraphAreaY1 + $XMargin ) { $LastY = $this->GraphAreaY1 + $XMargin; }

    4216. 

  4216.              $Y = $Y + $YStep;

    4217. 

  4217.             }

    4218. 

  4218. 

    4219. 

  4219.            if ( $ReCenter )

    4220. 

  4220.             {

    4221. 

  4221.              $Points[] = $LastX; $Points[] = $LastY+$YStep/2;

    4222. 

  4222.              $Points[] = $YZero; $Points[] = $LastY+$YStep/2;

    4223. 

  4223.             }

    4224. 

  4224.            else

    4225. 

  4225.             { $Points[] = $YZero; $Points[] = $LastY; }

    4226. 

  4226. 

    4227. 

  4227.            $this->drawPolygon($Points,$Color);

    4228. 

  4228.           }

    4229. 

  4229.         }

    4230. 

  4230.       }

    4231. 

  4231.     }

    4232. 

  4232. 

    4233. 

  4233.    /* Draw an area chart */

    4234. 

  4234.    function drawAreaChart($Format=NULL)

    4235. 

  4235.     {

    4236. 

  4236.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    4237. 

  4237.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    4238. 

  4238.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    4239. 

  4239.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    4240. 

  4240.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    4241. 

  4241.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    4242. 

  4242.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : 25;

    4243. 

  4243.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

    4244. 

  4244.      $Threshold		= isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

    4245. 

  4245. 

    4246. 

  4246.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    4247. 

  4247. 

    4248. 

  4248.      $Data  = $this->DataSet->getData();

    4249. 

  4249.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    4250. 

  4250. 

    4251. 

  4251.      foreach($Data["Series"] as $SerieName => $Serie)

    4252. 

  4252.       {

    4253. 

  4253.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    4254. 

  4254.         {

    4255. 

  4255.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    4256. 

  4256.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    4257. 

  4257. 

    4258. 

  4258.          $AxisID	= $Serie["Axis"];

    4259. 

  4259.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    4260. 

  4260.          $Format	= $Data["Axis"][$AxisID]["Format"];

    4261. 

  4261.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    4262. 

  4262. 

    4263. 

  4263.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    4264. 

  4264.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

    4265. 

  4265. 

    4266. 

  4266.          if ( $Threshold != NULL )

    4267. 

  4267.           {

    4268. 

  4268.            foreach($Threshold as $Key => $Params)

    4269. 

  4269.             {

    4270. 

  4270.              $Threshold[$Key]["MinX"] = $this->scaleComputeY($Params["Min"],array("AxisID"=>$Serie["Axis"]));

    4271. 

  4271.              $Threshold[$Key]["MaxX"] = $this->scaleComputeY($Params["Max"],array("AxisID"=>$Serie["Axis"]));

    4272. 

  4272.             }

    4273. 

  4273.           }

    4274. 

  4274. 

    4275. 

  4275.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    4276. 

  4276. 

    4277. 

  4277.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    4278. 

  4278.           {

    4279. 

  4279.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4280. 

  4280. 

    4281. 

  4281.            $Areas = ""; $AreaID = 0; 

    4282. 

  4282.            $Areas[$AreaID][] = $this->GraphAreaX1 + $XMargin;

    4283. 

  4283.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

    4284. 

  4284. 

    4285. 

  4285.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    4286. 

  4286.            $X = $this->GraphAreaX1 + $XMargin; $LastX = NULL; $LastY = NULL;

    4287. 

  4287. 

    4288. 

  4288.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4289. 

  4289.            foreach($PosArray as $Key => $Y)

    4290. 

  4290.             {

    4291. 

  4291.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

    4292. 

  4292.               {

    4293. 

  4293.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

    4294. 

  4294.                $this->drawText($X,$Y-$Offset,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

    4295. 

  4295.               }

    4296. 

  4296. 

    4297. 

  4297.              if ( $Y == VOID && isset($Areas[$AreaID]) )

    4298. 

  4298.               {

    4299. 

  4299.                if($LastX == NULL)

    4300. 

  4300.                 { $Areas[$AreaID][] = $X; }

    4301. 

  4301.                else

    4302. 

  4302.                 { $Areas[$AreaID][] = $LastX; }

    4303. 

  4303. 

    4304. 

  4304.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

    4305. 

  4305.                $AreaID++;

    4306. 

  4306.               }

    4307. 

  4307.              elseif ($Y != VOID)

    4308. 

  4308.               {

    4309. 

  4309.                if ( !isset($Areas[$AreaID]) )

    4310. 

  4310.                 {

    4311. 

  4311.                  $Areas[$AreaID][] = $X;

    4312. 

  4312.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

    4313. 

  4313.                 }

    4314. 

  4314. 

    4315. 

  4315.                $Areas[$AreaID][] = $X;

    4316. 

  4316.                $Areas[$AreaID][] = $Y;

    4317. 

  4317.               }

    4318. 

  4318. 

    4319. 

  4319.              $LastX = $X;

    4320. 

  4320.              $X = $X + $XStep;

    4321. 

  4321.             }

    4322. 

  4322.            $Areas[$AreaID][] = $LastX;

    4323. 

  4323.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaY2-1; }

    4324. 

  4324. 

    4325. 

  4325.            /* Handle shadows in the areas */

    4326. 

  4326.            if ( $this->Shadow )

    4327. 

  4327.             {

    4328. 

  4328.              $ShadowArea = "";

    4329. 

  4329.              foreach($Areas as $Key => $Points)

    4330. 

  4330.               {

    4331. 

  4331.                $ShadowArea[$Key] = "";

    4332. 

  4332.                foreach($Points as $Key2 => $Value)

    4333. 

  4333.                 {

    4334. 

  4334.                  if ( $Key2 % 2 == 0 )

    4335. 

  4335.                   { $ShadowArea[$Key][] = $Value + $this->ShadowX; }

    4336. 

  4336.                  else

    4337. 

  4337.                   { $ShadowArea[$Key][] = $Value + $this->ShadowY; }

    4338. 

  4338.                 }

    4339. 

  4339.               }              

    4340. 

  4340. 

    4341. 

  4341.              foreach($ShadowArea as $Key => $Points)

    4342. 

  4342.               $this->drawPolygonChart($Points,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

    4343. 

  4343.             }

    4344. 

  4344. 

    4345. 

  4345.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;

    4346. 

  4346.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Threshold"=>$Threshold);

    4347. 

  4347. 

    4348. 

  4348.            foreach($Areas as $Key => $Points)

    4349. 

  4349.             $this->drawPolygonChart($Points,$Color);

    4350. 

  4350.           }

    4351. 

  4351.          else

    4352. 

  4352.           {

    4353. 

  4353.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    4354. 

  4354.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    4355. 

  4355. 

    4356. 

  4356.            $Areas = ""; $AreaID = 0; 

    4357. 

  4357.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

    4358. 

  4358.            $Areas[$AreaID][] = $this->GraphAreaY1 + $XMargin;

    4359. 

  4359. 

    4360. 

  4360.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    4361. 

  4361.            $Y     = $this->GraphAreaY1 + $XMargin; $LastX = NULL; $LastY = NULL;

    4362. 

  4362. 

    4363. 

  4363.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4364. 

  4364.            foreach($PosArray as $Key => $X)

    4365. 

  4365.             {

    4366. 

  4366.              if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

    4367. 

  4367.               {

    4368. 

  4368.                if ( $Serie["Data"][$Key] > 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

    4369. 

  4369.                $this->drawText($X+$Offset,$Y,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("Angle"=>270,"R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align));

    4370. 

  4370.               }

    4371. 

  4371. 

    4372. 

  4372.              if ( $X == VOID && isset($Areas[$AreaID]) )

    4373. 

  4373.               {

    4374. 

  4374.                if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

    4375. 

  4375. 

    4376. 

  4376.                if($LastY == NULL)

    4377. 

  4377.                 { $Areas[$AreaID][] = $Y; }

    4378. 

  4378.                else

    4379. 

  4379.                 { $Areas[$AreaID][] = $LastY; }

    4380. 

  4380. 

    4381. 

  4381.                $AreaID++;

    4382. 

  4382.               }

    4383. 

  4383.              elseif ($X != VOID)

    4384. 

  4384.               {

    4385. 

  4385.                if ( !isset($Areas[$AreaID]) )

    4386. 

  4386.                 {

    4387. 

  4387.                  if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

    4388. 

  4388.                  $Areas[$AreaID][] = $Y;

    4389. 

  4389.                 }

    4390. 

  4390. 

    4391. 

  4391.                $Areas[$AreaID][] = $X;

    4392. 

  4392.                $Areas[$AreaID][] = $Y;

    4393. 

  4393.               }

    4394. 

  4394. 

    4395. 

  4395.              $LastX = $X; $LastY = $Y;

    4396. 

  4396.              $Y = $Y + $YStep;

    4397. 

  4397.             }

    4398. 

  4398.            if ( $AroundZero ) { $Areas[$AreaID][] = $YZero; } else { $Areas[$AreaID][] = $this->GraphAreaX1+1; }

    4399. 

  4399.            $Areas[$AreaID][] = $LastY;

    4400. 

  4400. 

    4401. 

  4401.            /* Handle shadows in the areas */

    4402. 

  4402.            if ( $this->Shadow )

    4403. 

  4403.             {

    4404. 

  4404.              $ShadowArea = "";

    4405. 

  4405.              foreach($Areas as $Key => $Points)

    4406. 

  4406.               {

    4407. 

  4407.                $ShadowArea[$Key] = "";

    4408. 

  4408.                foreach($Points as $Key2 => $Value)

    4409. 

  4409.                 {

    4410. 

  4410.                  if ( $Key2 % 2 == 0 )

    4411. 

  4411.                   { $ShadowArea[$Key][] = $Value + $this->ShadowX; }

    4412. 

  4412.                  else

    4413. 

  4413.                   { $ShadowArea[$Key][] = $Value + $this->ShadowY; }

    4414. 

  4414.                 }

    4415. 

  4415.               }              

    4416. 

  4416. 

    4417. 

  4417.              foreach($ShadowArea as $Key => $Points)

    4418. 

  4418.               $this->drawPolygonChart($Points,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

    4419. 

  4419.             }

    4420. 

  4420. 

    4421. 

  4421.            $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;

    4422. 

  4422.            $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Threshold"=>$Threshold);

    4423. 

  4423. 

    4424. 

  4424.            foreach($Areas as $Key => $Points)

    4425. 

  4425.             $this->drawPolygonChart($Points,$Color);

    4426. 

  4426.           }

    4427. 

  4427.         }

    4428. 

  4428.       }

    4429. 

  4429.     }

    4430. 

  4430. 

    4431. 

  4431. 

    4432. 

  4432.    /* Draw a bar chart */

    4433. 

  4433.    function drawBarChart($Format=NULL)

    4434. 

  4434.     {

    4435. 

  4435.      $Floating0Serie	= isset($Format["Floating0Serie"]) ? $Format["Floating0Serie"] : NULL;

    4436. 

  4436.      $Floating0Value	= isset($Format["Floating0Value"]) ? $Format["Floating0Value"] : NULL;

    4437. 

  4437.      $Draw0Line		= isset($Format["Draw0Line"]) ? $Format["Draw0Line"] : FALSE;

    4438. 

  4438.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    4439. 

  4439.      $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_HORIZONTAL;

    4440. 

  4440.      $DisplayOffset	= isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;

    4441. 

  4441.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    4442. 

  4442.      $DisplayFont	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontName;

    4443. 

  4443.      $DisplaySize	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;

    4444. 

  4444.      $DisplayPos	= isset($Format["DisplayPos"]) ? $Format["DisplayPos"] : LABEL_POS_OUTSIDE;

    4445. 

  4445.      $DisplayShadow	= isset($Format["DisplayShadow"]) ? $Format["DisplayShadow"] : TRUE;

    4446. 

  4446.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    4447. 

  4447.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    4448. 

  4448.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    4449. 

  4449.      $AroundZero	= isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;

    4450. 

  4450.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;

    4451. 

  4451.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;

    4452. 

  4452.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;

    4453. 

  4453.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    4454. 

  4454.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

    4455. 

  4455.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

    4456. 

  4456.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

    4457. 

  4457.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;

    4458. 

  4458.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;

    4459. 

  4459.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;

    4460. 

  4460.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

    4461. 

  4461.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

    4462. 

  4462.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

    4463. 

  4463.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;

    4464. 

  4464.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;

    4465. 

  4465.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;

    4466. 

  4466.      $TxtMargin		= isset($Format["TxtMargin"]) ? $Format["TxtMargin"] : 6;

    4467. 

  4467.      $OverrideColors	= isset($Format["OverrideColors"]) ? $Format["OverrideColors"] : NULL;

    4468. 

  4468.      $OverrideSurrounding = isset($Format["OverrideSurrounding"]) ? $Format["OverrideSurrounding"] : 30;

    4469. 

  4469.      $InnerSurrounding	= isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;

    4470. 

  4470.      $InnerBorderR	= isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;

    4471. 

  4471.      $InnerBorderG	= isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;

    4472. 

  4472.      $InnerBorderB	= isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;

    4473. 

  4473.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    4474. 

  4474. 

    4475. 

  4475.      $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    4476. 

  4476. 

    4477. 

  4477.      $Data = $this->DataSet->getData();

    4478. 

  4478.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    4479. 

  4479. 

    4480. 

  4480.      if ( $OverrideColors != NULL )

    4481. 

  4481.       {

    4482. 

  4482.        $OverrideColors = $this->validatePalette($OverrideColors,$OverrideSurrounding);

    4483. 

  4483.        $this->DataSet->saveExtendedData("Palette",$OverrideColors);

    4484. 

  4484.       }

    4485. 

  4485. 

    4486. 

  4486.      $RestoreShadow = $this->Shadow;

    4487. 

  4487. 

    4488. 

  4488.      $SeriesCount  = $this->countDrawableSeries();

    4489. 

  4489.      $CurrentSerie = 0;

    4490. 

  4490.      foreach($Data["Series"] as $SerieName => $Serie)

    4491. 

  4491.       {

    4492. 

  4492.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    4493. 

  4493.         {

    4494. 

  4494.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    4495. 

  4495.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = $R; $DisplayG = $G; $DisplayB = $B; }

    4496. 

  4496.          if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

    4497. 

  4497.          if ( $InnerSurrounding != NULL ) { $InnerBorderR = $R+$InnerSurrounding; $InnerBorderG = $G+$InnerSurrounding; $InnerBorderB = $B+$InnerSurrounding; }

    4498. 

  4498.          if ( $InnerBorderR == -1 ) { $InnerColor = NULL; } else { $InnerColor = array("R"=>$InnerBorderR,"G"=>$InnerBorderG,"B"=>$InnerBorderB); }

    4499. 

  4499.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);

    4500. 

  4500. 

    4501. 

  4501.          $AxisID	= $Serie["Axis"];

    4502. 

  4502.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    4503. 

  4503.          $Format	= $Data["Axis"][$AxisID]["Format"];

    4504. 

  4504.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    4505. 

  4505. 

    4506. 

  4506.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    4507. 

  4507. 

    4508. 

  4508.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    4509. 

  4509. 

    4510. 

  4510.          if ( $Floating0Value != NULL )

    4511. 

  4511.           { $YZero = $this->scaleComputeY($Floating0Value,array("AxisID"=>$Serie["Axis"])); }

    4512. 

  4512.          else

    4513. 

  4513.           { $YZero = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"])); }

    4514. 

  4514. 

    4515. 

  4515.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    4516. 

  4516.           {

    4517. 

  4517.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4518. 

  4518.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

    4519. 

  4519. 

    4520. 

  4520.            if ( $XDivs == 0 ) { $XStep = 0; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    4521. 

  4521.            $X = $this->GraphAreaX1 + $XMargin;

    4522. 

  4522. 

    4523. 

  4523.            if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }

    4524. 

  4524.            if ( $XDivs == 0 ) { $XSize = ($this->GraphAreaX2-$this->GraphAreaX1)/($SeriesCount+$Interleave); } else { $XSize   = ($XStep / ($SeriesCount+$Interleave) ); }

    4525. 

  4525. 

    4526. 

  4526.            $XOffset = -($XSize*$SeriesCount)/2 + $CurrentSerie * $XSize;

    4527. 

  4527.            if ( $X + $XOffset <= $this->GraphAreaX1 ) { $XOffset = $this->GraphAreaX1 - $X + 1 ; }

    4528. 

  4528. 

    4529. 

  4529.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $XOffset + $XSize / 2;

    4530. 

  4530. 

    4531. 

  4531.            if ( $Rounded || $BorderR != -1) { $XSpace = 1; } else { $XSpace = 0; }

    4532. 

  4532. 

    4533. 

  4533.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4534. 

  4534. 

    4535. 

  4535.            $ID = 0;

    4536. 

  4536.            foreach($PosArray as $Key => $Y2)

    4537. 

  4537.             {

    4538. 

  4538.              if ( $Floating0Serie != NULL )

    4539. 

  4539.               {

    4540. 

  4540.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )

    4541. 

  4541.                 { $Value = $Data["Series"][$Floating0Serie]["Data"][$Key]; }

    4542. 

  4542.                else

    4543. 

  4543.                 { $Value = 0; }

    4544. 

  4544. 

    4545. 

  4545.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));

    4546. 

  4546.                if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4547. 

  4547.                if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

    4548. 

  4548. 

    4549. 

  4549.                if ( $AroundZero ) { $Y1 = $YZero; } else { $Y1 = $this->GraphAreaY2-1; }

    4550. 

  4550.               }

    4551. 

  4551. 

    4552. 

  4552.              if ( $OverrideColors != NULL )

    4553. 

  4553.               { 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(); } }

    4554. 

  4554. 

    4555. 

  4555.              if ( $Y2 != VOID )

    4556. 

  4556.               {

    4557. 

  4557.                $BarHeight = $Y1 - $Y2;

    4558. 

  4558. 

    4559. 

  4559.                if ( $Serie["Data"][$Key] == 0 )

    4560. 

  4560.                 {

    4561. 

  4561.                  $this->drawLine($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y1,$Color);

    4562. 

  4562.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset+$XSpace).",".floor($Y1-1).",".floor($X+$XOffset+$XSize-$XSpace).",".floor($Y1+1),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4563. 

  4563.                 }

    4564. 

  4564.                else

    4565. 

  4565.                 {

    4566. 

  4566.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset+$XSpace).",".floor($Y1).",".floor($X+$XOffset+$XSize-$XSpace).",".floor($Y2),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4567. 

  4567. 

    4568. 

  4568.                  if ( $Rounded )

    4569. 

  4569.                   $this->drawRoundedFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$RoundRadius,$Color);

    4570. 

  4570.                  else

    4571. 

  4571.                   {

    4572. 

  4572.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,$Color);

    4573. 

  4573. 

    4574. 

  4574.                    if ( $InnerColor != NULL ) { $this->drawRectangle($X+$XOffset+$XSpace+1,min($Y1,$Y2)+1,$X+$XOffset+$XSize-$XSpace-1,max($Y1,$Y2)-1,$InnerColor); }

    4575. 

  4575. 

    4576. 

  4576.                    if ( $Gradient )

    4577. 

  4577.                     {

    4578. 

  4578.                      $this->Shadow  = FALSE;

    4579. 

  4579. 

    4580. 

  4580.                      if ( $GradientMode == GRADIENT_SIMPLE )

    4581. 

  4581.                       {

    4582. 

  4582.                        if ( $Serie["Data"][$Key] >= 0 )

    4583. 

  4583.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4584. 

  4584.                        else

    4585. 

  4585.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4586. 

  4586. 

    4587. 

  4587.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_VERTICAL,$GradienColor);

    4588. 

  4588.                       }

    4589. 

  4589.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

    4590. 

  4590.                       {

    4591. 

  4591.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4592. 

  4592.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4593. 

  4593.                        $XSpan = floor($XSize / 3);

    4594. 

  4594. 

    4595. 

  4595.                        $this->drawGradientArea($X+$XOffset+$XSpace,$Y1,$X+$XOffset+$XSpan-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor1);

    4596. 

  4596.                        $this->drawGradientArea($X+$XOffset+$XSpan+$XSpace,$Y1,$X+$XOffset+$XSize-$XSpace,$Y2,DIRECTION_HORIZONTAL,$GradienColor2);

    4597. 

  4597.                       }

    4598. 

  4598.                      $this->Shadow = $RestoreShadow;

    4599. 

  4599.                     }

    4600. 

  4600.                   }

    4601. 

  4601. 

    4602. 

  4602.                  if ( $Draw0Line )

    4603. 

  4603.                   {

    4604. 

  4604.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);

    4605. 

  4605. 

    4606. 

  4606.                    if ( abs($Y1 - $Y2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }

    4607. 

  4607.                    if ( $Y1 - $Y2 < 0 ) { $Line0Width = -$Line0Width; }

    4608. 

  4608. 

    4609. 

  4609.                    $this->drawFilledRectangle($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1)-$Line0Width,$Line0Color);

    4610. 

  4610.                    $this->drawLine($X+$XOffset+$XSpace,floor($Y1),$X+$XOffset+$XSize-$XSpace,floor($Y1),$Line0Color);

    4611. 

  4611.                   }

    4612. 

  4612.                 }

    4613. 

  4613. 

    4614. 

  4614.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID )

    4615. 

  4615.                 {

    4616. 

  4616.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }

    4617. 

  4617. 

    4618. 

  4618.                  $Caption    = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);

    4619. 

  4619.                  $TxtPos     = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,90,$Caption);

    4620. 

  4620.                  $TxtHeight  = $TxtPos[0]["Y"] - $TxtPos[1]["Y"] + $TxtMargin;

    4621. 

  4621. 

    4622. 

  4622.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtHeight) < abs($BarHeight) )

    4623. 

  4623.                   {

    4624. 

  4624.                    $CenterX = (($X+$XOffset+$XSize-$XSpace)-($X+$XOffset+$XSpace))/2 + $X+$XOffset+$XSpace;

    4625. 

  4625.                    $CenterY = ($Y2-$Y1)/2 + $Y1;

    4626. 

  4626. 

    4627. 

  4627.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"Angle"=>90));

    4628. 

  4628.                   }

    4629. 

  4629.                  else

    4630. 

  4630.                   {

    4631. 

  4631.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_BOTTOMMIDDLE; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_TOPMIDDLE; $Offset = -$DisplayOffset; }

    4632. 

  4632.                    $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));

    4633. 

  4633.                   }

    4634. 

  4634. 

    4635. 

  4635.                  $this->Shadow = $RestoreShadow;

    4636. 

  4636.                 }

    4637. 

  4637.               }

    4638. 

  4638. 

    4639. 

  4639.              $X = $X + $XStep;

    4640. 

  4640.              $ID++;

    4641. 

  4641.             }

    4642. 

  4642.           }

    4643. 

  4643.          else

    4644. 

  4644.           {

    4645. 

  4645.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    4646. 

  4646.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    4647. 

  4647. 

    4648. 

  4648.            if ( $XDivs == 0 ) { $YStep = 0; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    4649. 

  4649.            

    4650. 

  4650.            $Y = $this->GraphAreaY1 + $XMargin;

    4651. 

  4651. 

    4652. 

  4652.            if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }

    4653. 

  4653.            if ( $XDivs == 0 ) { $YSize = ($this->GraphAreaY2-$this->GraphAreaY1)/($SeriesCount+$Interleave); } else { $YSize   = ($YStep / ($SeriesCount+$Interleave) ); }

    4654. 

  4654.            

    4655. 

  4655.            $YOffset = -($YSize*$SeriesCount)/2 + $CurrentSerie * $YSize;

    4656. 

  4656.            if ( $Y + $YOffset <= $this->GraphAreaY1 ) { $YOffset = $this->GraphAreaY1 - $Y + 1 ; }

    4657. 

  4657. 

    4658. 

  4658.            $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $YOffset + $YSize / 2;

    4659. 

  4659. 

    4660. 

  4660.            if ( $Rounded || $BorderR != -1 ) { $YSpace = 1; } else { $YSpace = 0; }

    4661. 

  4661. 

    4662. 

  4662.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4663. 

  4663. 

    4664. 

  4664.            $ID = 0 ;

    4665. 

  4665.            foreach($PosArray as $Key => $X2)

    4666. 

  4666.             {

    4667. 

  4667.              if ( $Floating0Serie != NULL )

    4668. 

  4668.               {

    4669. 

  4669.                if ( isset($Data["Series"][$Floating0Serie]["Data"][$Key]) )

    4670. 

  4670.                 $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];

    4671. 

  4671.                else { $Value = 0; }

    4672. 

  4672. 

    4673. 

  4673.                $YZero = $this->scaleComputeY($Value,array("AxisID"=>$Serie["Axis"]));

    4674. 

  4674.                if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    4675. 

  4675.                if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    4676. 

  4676.                if ( $AroundZero ) { $X1 = $YZero; } else { $X1 = $this->GraphAreaX1+1; }

    4677. 

  4677.               }

    4678. 

  4678. 

    4679. 

  4679.              if ( $OverrideColors != NULL )

    4680. 

  4680.               { 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(); } }

    4681. 

  4681. 

    4682. 

  4682.              if ( $X2 != VOID )

    4683. 

  4683.               {

    4684. 

  4684.                $BarWidth = $X2 - $X1;

    4685. 

  4685. 

    4686. 

  4686.                if ( $Serie["Data"][$Key] == 0 )

    4687. 

  4687.                 {

    4688. 

  4688.                  $this->drawLine($X1,$Y+$YOffset+$YSpace,$X1,$Y+$YOffset+$YSize-$YSpace,$Color);

    4689. 

  4689.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1-1).",".floor($Y+$YOffset+$YSpace).",".floor($X1+1).",".floor($Y+$YOffset+$YSize-$YSpace),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4690. 

  4690.                 }

    4691. 

  4691.                else

    4692. 

  4692.                 {

    4693. 

  4693.                  if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1).",".floor($Y+$YOffset+$YSpace).",".floor($X2).",".floor($Y+$YOffset+$YSize-$YSpace),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4694. 

  4694. 

    4695. 

  4695.                  if ( $Rounded )

    4696. 

  4696.                   $this->drawRoundedFilledRectangle($X1+1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$RoundRadius,$Color);

    4697. 

  4697.                  else

    4698. 

  4698.                   {

    4699. 

  4699.                    $this->drawFilledRectangle($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,$Color);

    4700. 

  4700. 

    4701. 

  4701.                    if ( $InnerColor != NULL ) { $this->drawRectangle(min($X1,$X2)+1,$Y+$YOffset+$YSpace+1,max($X1,$X2)-1,$Y+$YOffset+$YSize-$YSpace-1,$InnerColor); }

    4702. 

  4702. 

    4703. 

  4703.                    if ( $Gradient )

    4704. 

  4704.                     {

    4705. 

  4705.                      $this->Shadow  = FALSE;

    4706. 

  4706. 

    4707. 

  4707.                      if ( $GradientMode == GRADIENT_SIMPLE )

    4708. 

  4708.                       {

    4709. 

  4709.                        if ( $Serie["Data"][$Key] >= 0 )

    4710. 

  4710.                         $GradienColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4711. 

  4711.                        else

    4712. 

  4712.                         $GradienColor = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4713. 

  4713. 

    4714. 

  4714.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_HORIZONTAL,$GradienColor);

    4715. 

  4715.                       }

    4716. 

  4716.                      elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

    4717. 

  4717.                       {

    4718. 

  4718.                        $GradienColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4719. 

  4719.                        $GradienColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4720. 

  4720.                        $YSpan = floor($YSize / 3);

    4721. 

  4721. 

    4722. 

  4722.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpace,$X2,$Y+$YOffset+$YSpan-$YSpace,DIRECTION_VERTICAL,$GradienColor1);

    4723. 

  4723.                        $this->drawGradientArea($X1,$Y+$YOffset+$YSpan,$X2,$Y+$YOffset+$YSize-$YSpace,DIRECTION_VERTICAL,$GradienColor2);

    4724. 

  4724.                       }

    4725. 

  4725.                      $this->Shadow = $RestoreShadow;

    4726. 

  4726.                     }

    4727. 

  4727.                   }

    4728. 

  4728. 

    4729. 

  4729.                  if ( $Draw0Line )

    4730. 

  4730.                   {

    4731. 

  4731.                    $Line0Color = array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20);

    4732. 

  4732. 

    4733. 

  4733.                    if ( abs($X1 - $X2) > 3 ) { $Line0Width = 3; } else { $Line0Width = 1; }

    4734. 

  4734.                    if ( $X2 - $X1 < 0 ) { $Line0Width = -$Line0Width; }

    4735. 

  4735. 

    4736. 

  4736.                    $this->drawFilledRectangle(floor($X1),$Y+$YOffset+$YSpace,floor($X1)+$Line0Width,$Y+$YOffset+$YSize-$YSpace,$Line0Color);

    4737. 

  4737.                    $this->drawLine(floor($X1),$Y+$YOffset+$YSpace,floor($X1),$Y+$YOffset+$YSize-$YSpace,$Line0Color);

    4738. 

  4738.                   }

    4739. 

  4739.                 }

    4740. 

  4740. 

    4741. 

  4741.                if ( $DisplayValues && $Serie["Data"][$Key] != VOID ) 

    4742. 

  4742.                 {

    4743. 

  4743.                  if ( $DisplayShadow ) { $this->Shadow = TRUE; }

    4744. 

  4744. 

    4745. 

  4745.                  $Caption   = $this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit);

    4746. 

  4746.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

    4747. 

  4747.                  $TxtWidth  = $TxtPos[1]["X"] - $TxtPos[0]["X"] + $TxtMargin;

    4748. 

  4748. 

    4749. 

  4749.                  if ( $DisplayPos == LABEL_POS_INSIDE && abs($TxtWidth) < abs($BarWidth) )

    4750. 

  4750.                   {

    4751. 

  4751.                    $CenterX = ($X2-$X1)/2 + $X1;

    4752. 

  4752.                    $CenterY = (($Y+$YOffset+$YSize-$YSpace)-($Y+$YOffset+$YSpace))/2 + ($Y+$YOffset+$YSpace);

    4753. 

  4753. 

    4754. 

  4754.                    $this->drawText($CenterX,$CenterY,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize));

    4755. 

  4755.                   }

    4756. 

  4756.                  else

    4757. 

  4757.                   {

    4758. 

  4758.                    if ( $Serie["Data"][$Key] >= 0 ) { $Align = TEXT_ALIGN_MIDDLELEFT; $Offset = $DisplayOffset; } else { $Align = TEXT_ALIGN_MIDDLERIGHT; $Offset = -$DisplayOffset; }

    4759. 

  4759.                    $this->drawText($X2+$Offset,$Y+$YOffset+$YSize/2,$Caption,array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Align"=>$Align,"FontSize"=>$DisplaySize));

    4760. 

  4760.                   }

    4761. 

  4761. 

    4762. 

  4762.                  $this->Shadow = $RestoreShadow;

    4763. 

  4763.                 }

    4764. 

  4764.               }

    4765. 

  4765.              $Y = $Y + $YStep;

    4766. 

  4766.              $ID++;

    4767. 

  4767.             }

    4768. 

  4768.           }

    4769. 

  4769.          $CurrentSerie++;

    4770. 

  4770.         }

    4771. 

  4771.       }

    4772. 

  4772.     }

    4773. 

  4773. 

    4774. 

  4774.    /* Draw a bar chart */

    4775. 

  4775.    function drawStackedBarChart($Format=NULL)

    4776. 

  4776.     {

    4777. 

  4777.      $DisplayValues	= isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;

    4778. 

  4778.      $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_AUTO;

    4779. 

  4779.      $DisplayRound      = isset($Format["DisplayRound"]) ? $Format["DisplayRound"] : 0;

    4780. 

  4780.      $DisplayColor	= isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;

    4781. 

  4781.      $DisplayFont	= isset($Format["DisplayFont"]) ? $Format["DisplayFont"] : $this->FontName;

    4782. 

  4782.      $DisplaySize	= isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;

    4783. 

  4783.      $DisplayR		= isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;

    4784. 

  4784.      $DisplayG		= isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;

    4785. 

  4785.      $DisplayB		= isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;

    4786. 

  4786.      $Interleave	= isset($Format["Interleave"]) ? $Format["Interleave"] : .5;

    4787. 

  4787.      $Rounded		= isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;

    4788. 

  4788.      $RoundRadius	= isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;

    4789. 

  4789.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    4790. 

  4790.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;

    4791. 

  4791.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;

    4792. 

  4792.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;

    4793. 

  4793.      $Gradient		= isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;

    4794. 

  4794.      $GradientMode	= isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;

    4795. 

  4795.      $GradientAlpha	= isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;

    4796. 

  4796.      $GradientStartR	= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

    4797. 

  4797.      $GradientStartG	= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

    4798. 

  4798.      $GradientStartB	= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

    4799. 

  4799.      $GradientEndR	= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;

    4800. 

  4800.      $GradientEndG	= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;

    4801. 

  4801.      $GradientEndB	= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;

    4802. 

  4802.      $InnerSurrounding	= isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;

    4803. 

  4803.      $InnerBorderR	= isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;

    4804. 

  4804.      $InnerBorderG	= isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;

    4805. 

  4805.      $InnerBorderB	= isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;

    4806. 

  4806.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    4807. 

  4807.      $FontFactor	= isset($Format["FontFactor"]) ? $Format["FontFactor"] : 8;

    4808. 

  4808. 

    4809. 

  4809.      $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;

    4810. 

  4810. 

    4811. 

  4811.      $Data = $this->DataSet->getData();

    4812. 

  4812.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    4813. 

  4813. 

    4814. 

  4814.      $RestoreShadow = $this->Shadow;

    4815. 

  4815. 

    4816. 

  4816.      $LastX = ""; $LastY = "";

    4817. 

  4817.      foreach($Data["Series"] as $SerieName => $Serie)

    4818. 

  4818.       {

    4819. 

  4819.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    4820. 

  4820.         {

    4821. 

  4821.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    4822. 

  4822.          if ( $DisplayColor == DISPLAY_AUTO ) { $DisplayR = 255; $DisplayG = 255; $DisplayB = 255; }

    4823. 

  4823.          if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

    4824. 

  4824.          if ( $InnerSurrounding != NULL ) { $InnerBorderR = $R+$InnerSurrounding; $InnerBorderG = $G+$InnerSurrounding; $InnerBorderB = $B+$InnerSurrounding; }

    4825. 

  4825.          if ( $InnerBorderR == -1 ) { $InnerColor = NULL; } else { $InnerColor = array("R"=>$InnerBorderR,"G"=>$InnerBorderG,"B"=>$InnerBorderB); }

    4826. 

  4826. 

    4827. 

  4827.          $AxisID	= $Serie["Axis"];

    4828. 

  4828.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    4829. 

  4829.          $Format	= $Data["Axis"][$AxisID]["Format"];

    4830. 

  4830.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    4831. 

  4831. 

    4832. 

  4832.          if (isset($Serie["Description"])) { $SerieDescription = $Serie["Description"]; } else { $SerieDescription = $SerieName; }

    4833. 

  4833. 

    4834. 

  4834.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);

    4835. 

  4835.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

    4836. 

  4836. 

    4837. 

  4837.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    4838. 

  4838. 

    4839. 

  4839.          $Color = array("TransCorner"=>TRUE,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB);

    4840. 

  4840. 

    4841. 

  4841.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    4842. 

  4842.           {

    4843. 

  4843.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4844. 

  4844.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    4845. 

  4845. 

    4846. 

  4846.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    4847. 

  4847.            $X     = $this->GraphAreaX1 + $XMargin;

    4848. 

  4848. 

    4849. 

  4849.            $XSize   = ($XStep / (1+$Interleave) );

    4850. 

  4850.            $XOffset = -($XSize/2);

    4851. 

  4851. 

    4852. 

  4852.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4853. 

  4853.            foreach($PosArray as $Key => $Height)

    4854. 

  4854.             {

    4855. 

  4855.              if ( $Height != VOID && $Serie["Data"][$Key] != 0 )

    4856. 

  4856.               {

    4857. 

  4857.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }

    4858. 

  4858. 

    4859. 

  4859.                if ( !isset($LastY[$Key] ) ) { $LastY[$Key] = ""; }

    4860. 

  4860.                if ( !isset($LastY[$Key][$Pos] ) ) { $LastY[$Key][$Pos] = $YZero; }

    4861. 

  4861. 

    4862. 

  4862.                $Y1 = $LastY[$Key][$Pos];

    4863. 

  4863.                $Y2 = $Y1 - $Height;

    4864. 

  4864. 

    4865. 

  4865.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $Y1 != $YZero) ) { $YSpaceUp = 1; } else { $YSpaceUp = 0; }

    4866. 

  4866.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $Y1 != $YZero) ) { $YSpaceDown = 1; } else { $YSpaceDown = 0; }

    4867. 

  4867. 

    4868. 

  4868.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X+$XOffset).",".floor($Y1-$YSpaceUp+$YSpaceDown).",".floor($X+$XOffset+$XSize).",".floor($Y2),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4869. 

  4869. 

    4870. 

  4870.                if ( $Rounded )

    4871. 

  4871.                 $this->drawRoundedFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$RoundRadius,$Color);

    4872. 

  4872.                else

    4873. 

  4873.                 {

    4874. 

  4874.                  $this->drawFilledRectangle($X+$XOffset,$Y1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2,$Color);

    4875. 

  4875. 

    4876. 

  4876.                  if ( $InnerColor != NULL ) { $RestoreShadow = $this->Shadow; $this->Shadow = FALSE; $this->drawRectangle(min($X+$XOffset+1,$X+$XOffset+$XSize),min($Y1-$YSpaceUp+$YSpaceDown,$Y2)+1,max($X+$XOffset+1,$X+$XOffset+$XSize)-1,max($Y1-$YSpaceUp+$YSpaceDown,$Y2)-1,$InnerColor); $this->Shadow = $RestoreShadow;}

    4877. 

  4877. 

    4878. 

  4878.                  if ( $Gradient )

    4879. 

  4879.                   {

    4880. 

  4880.                    $this->Shadow  = FALSE;

    4881. 

  4881. 

    4882. 

  4882.                    if ( $GradientMode == GRADIENT_SIMPLE )

    4883. 

  4883.                     {

    4884. 

  4884.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4885. 

  4885.                      $this->drawGradientArea($X+$XOffset,$Y1-1-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+1,DIRECTION_VERTICAL,$GradientColor);

    4886. 

  4886.                     }

    4887. 

  4887.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

    4888. 

  4888.                     {

    4889. 

  4889.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4890. 

  4890.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4891. 

  4891.                      $XSpan = floor($XSize / 3);

    4892. 

  4892. 

    4893. 

  4893.                      $this->drawGradientArea($X+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSpan,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor1);

    4894. 

  4894.                      $this->drawGradientArea($X+$XSpan+$XOffset-.5,$Y1-.5-$YSpaceUp+$YSpaceDown,$X+$XOffset+$XSize,$Y2+.5,DIRECTION_HORIZONTAL,$GradientColor2);

    4895. 

  4895.                     }

    4896. 

  4896.                    $this->Shadow = $RestoreShadow;

    4897. 

  4897.                   }

    4898. 

  4898.                 }

    4899. 

  4899. 

    4900. 

  4900.                if ( $DisplayValues )

    4901. 

  4901.                 {

    4902. 

  4902.                  $BarHeight = abs($Y2-$Y1)-2;

    4903. 

  4903.                  $BarWidth  = $XSize+($XOffset/2)-$FontFactor;

    4904. 

  4904. 

    4905. 

  4905.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);

    4906. 

  4906.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

    4907. 

  4907.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);

    4908. 

  4908.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);

    4909. 

  4909. 

    4910. 

  4910.                  $XCenter = ( ($X+$XOffset+$XSize) - ($X+$XOffset) ) / 2 + $X+$XOffset;

    4911. 

  4911.                  $YCenter = ( ($Y2) - ($Y1-$YSpaceUp+$YSpaceDown) ) / 2 + $Y1-$YSpaceUp+$YSpaceDown;

    4912. 

  4912. 

    4913. 

  4913.                  $Done = FALSE;

    4914. 

  4914.                  if ( $DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO )

    4915. 

  4915.                   {

    4916. 

  4916.                    if ( $TxtHeight < $BarHeight && $TxtWidth < $BarWidth  )

    4917. 

  4917.                     {

    4918. 

  4918.                      $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));

    4919. 

  4919.                      $Done = TRUE;

    4920. 

  4920.                     }

    4921. 

  4921.                   }

    4922. 

  4922. 

    4923. 

  4923.                  if ( $DisplayOrientation == ORIENTATION_VERTICAL || ( $DisplayOrientation == ORIENTATION_AUTO && !$Done) )

    4924. 

  4924.                   {

    4925. 

  4925.                    if ( $TxtHeight < $BarWidth && $TxtWidth < $BarHeight  )

    4926. 

  4926.                     $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Angle"=>90,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

    4927. 

  4927.                   }

    4928. 

  4928.                 }

    4929. 

  4929. 

    4930. 

  4930.                $LastY[$Key][$Pos] = $Y2;

    4931. 

  4931.               }

    4932. 

  4932. 

    4933. 

  4933.              $X = $X + $XStep;

    4934. 

  4934.             }

    4935. 

  4935.           }

    4936. 

  4936.          else

    4937. 

  4937.           {

    4938. 

  4938.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    4939. 

  4939.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    4940. 

  4940. 

    4941. 

  4941.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    4942. 

  4942.            $Y     = $this->GraphAreaY1 + $XMargin;

    4943. 

  4943. 

    4944. 

  4944.            $YSize   = $YStep / (1+$Interleave);

    4945. 

  4945.            $YOffset = -($YSize/2);

    4946. 

  4946. 

    4947. 

  4947.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    4948. 

  4948.            foreach($PosArray as $Key => $Width)

    4949. 

  4949.             {

    4950. 

  4950.              if ( $Width != VOID && $Serie["Data"][$Key] != 0 )

    4951. 

  4951.               {

    4952. 

  4952.                if ( $Serie["Data"][$Key] > 0 ) { $Pos = "+"; } else { $Pos = "-"; }

    4953. 

  4953. 

    4954. 

  4954.                if ( !isset($LastX[$Key] ) ) { $LastX[$Key] = ""; }

    4955. 

  4955.                if ( !isset($LastX[$Key][$Pos] ) ) { $LastX[$Key][$Pos] = $YZero; }

    4956. 

  4956. 

    4957. 

  4957.                $X1 = $LastX[$Key][$Pos];

    4958. 

  4958.                $X2 = $X1 + $Width;

    4959. 

  4959. 

    4960. 

  4960.                if ( ($Rounded || $BorderR != -1) && ($Pos == "+" && $X1 != $YZero) ) { $XSpaceLeft = 2; } else { $XSpaceLeft = 0; }

    4961. 

  4961.                if ( ($Rounded || $BorderR != -1) && ($Pos == "-" && $X1 != $YZero) ) { $XSpaceRight = 2; } else { $XSpaceRight = 0; }

    4962. 

  4962. 

    4963. 

  4963.                if ( $RecordImageMap ) { $this->addToImageMap("RECT",floor($X1+$XSpaceLeft).",".floor($Y+$YOffset).",".floor($X2-$XSpaceRight).",".floor($Y+$YOffset+$YSize),$this->toHTMLColor($R,$G,$B),$SerieDescription,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit)); }

    4964. 

  4964. 

    4965. 

  4965.                if ( $Rounded )

    4966. 

  4966.                 $this->drawRoundedFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$RoundRadius,$Color);

    4967. 

  4967.                else

    4968. 

  4968.                 {

    4969. 

  4969.                  $this->drawFilledRectangle($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,$Color);

    4970. 

  4970. 

    4971. 

  4971.                  if ( $InnerColor != NULL ) { $RestoreShadow = $this->Shadow; $this->Shadow = FALSE; $this->drawRectangle(min($X1+$XSpaceLeft,$X2-$XSpaceRight)+1,min($Y+$YOffset,$Y+$YOffset+$YSize)+1,max($X1+$XSpaceLeft,$X2-$XSpaceRight)-1,max($Y+$YOffset,$Y+$YOffset+$YSize)-1,$InnerColor); $this->Shadow = $RestoreShadow;}

    4972. 

  4972. 

    4973. 

  4973.                  if ( $Gradient )

    4974. 

  4974.                   {

    4975. 

  4975.                    $this->Shadow  = FALSE;

    4976. 

  4976. 

    4977. 

  4977.                    if ( $GradientMode == GRADIENT_SIMPLE )

    4978. 

  4978.                     {

    4979. 

  4979.                      $GradientColor = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4980. 

  4980.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_HORIZONTAL,$GradientColor);

    4981. 

  4981.                     }

    4982. 

  4982.                    elseif ( $GradientMode == GRADIENT_EFFECT_CAN )

    4983. 

  4983.                     {

    4984. 

  4984.                      $GradientColor1 = array("StartR"=>$GradientEndR,"StartG"=>$GradientEndG,"StartB"=>$GradientEndB,"EndR"=>$GradientStartR,"EndG"=>$GradientStartG,"EndB"=>$GradientStartB,"Alpha"=>$GradientAlpha);

    4985. 

  4985.                      $GradientColor2 = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$GradientAlpha);

    4986. 

  4986.                      $YSpan = floor($YSize / 3);

    4987. 

  4987. 

    4988. 

  4988.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset,$X2-$XSpaceRight,$Y+$YOffset+$YSpan,DIRECTION_VERTICAL,$GradientColor1);

    4989. 

  4989.                      $this->drawGradientArea($X1+$XSpaceLeft,$Y+$YOffset+$YSpan,$X2-$XSpaceRight,$Y+$YOffset+$YSize,DIRECTION_VERTICAL,$GradientColor2);

    4990. 

  4990.                     }

    4991. 

  4991.                    $this->Shadow = $RestoreShadow;

    4992. 

  4992.                   }

    4993. 

  4993.                 }

    4994. 

  4994. 

    4995. 

  4995.                if ( $DisplayValues )

    4996. 

  4996.                 {

    4997. 

  4997.                  $BarWidth = abs($X2-$X1)-$FontFactor;

    4998. 

  4998.                  $BarHeight = $YSize+($YOffset/2)-$FontFactor/2;

    4999. 

  4999.                  $Caption   = $this->scaleFormat(round($Serie["Data"][$Key],$DisplayRound),$Mode,$Format,$Unit);

    5000. 

  5000.                  $TxtPos    = $this->getTextBox(0,0,$DisplayFont,$DisplaySize,0,$Caption);

    5001. 

  5001.                  $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);

    5002. 

  5002.                  $TxtWidth  = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);

    5003. 

  5003. 

    5004. 

  5004.                  $XCenter  = ( $X2 - $X1 ) / 2 + $X1;

    5005. 

  5005.                  $YCenter  = ( ($Y+$YOffset+$YSize) - ($Y+$YOffset) ) / 2 + $Y+$YOffset;

    5006. 

  5006. 

    5007. 

  5007.                  $Done = FALSE;

    5008. 

  5008.                  if ( $DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO )

    5009. 

  5009.                   {

    5010. 

  5010.                    if ( $TxtHeight < $BarHeight && $TxtWidth < $BarWidth  )

    5011. 

  5011.                     {

    5012. 

  5012.                      $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));

    5013. 

  5013.                      $Done = TRUE;

    5014. 

  5014.                     }

    5015. 

  5015.                   }

    5016. 

  5016. 

    5017. 

  5017.                  if ( $DisplayOrientation == ORIENTATION_VERTICAL || ( $DisplayOrientation == ORIENTATION_AUTO && !$Done) )

    5018. 

  5018.                   {

    5019. 

  5019.                    if ( $TxtHeight < $BarWidth && $TxtWidth < $BarHeight  )

    5020. 

  5020.                     $this->drawText($XCenter,$YCenter,$this->scaleFormat($Serie["Data"][$Key],$Mode,$Format,$Unit),array("R"=>$DisplayR,"G"=>$DisplayG,"B"=>$DisplayB,"Angle"=>90,"Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontSize"=>$DisplaySize,"FontName"=>$DisplayFont));

    5021. 

  5021.                   }

    5022. 

  5022.                 }

    5023. 

  5023. 

    5024. 

  5024.                $LastX[$Key][$Pos] = $X2;

    5025. 

  5025.               }

    5026. 

  5026. 

    5027. 

  5027.              $Y = $Y + $YStep;

    5028. 

  5028.             }

    5029. 

  5029.           }

    5030. 

  5030.         }

    5031. 

  5031.       }

    5032. 

  5032.     }

    5033. 

  5033. 

    5034. 

  5034.    /* Draw a stacked area chart */

    5035. 

  5035.    function drawStackedAreaChart($Format=NULL)

    5036. 

  5036.     {

    5037. 

  5037.      $DrawLine		= isset($Format["DrawLine"]) ? $Format["DrawLine"] : FALSE;

    5038. 

  5038.      $LineSurrounding	= isset($Format["LineSurrounding"]) ? $Format["LineSurrounding"] : NULL;

    5039. 

  5039.      $LineR		= isset($Format["LineR"]) ? $Format["LineR"] : VOID;

    5040. 

  5040.      $LineG		= isset($Format["LineG"]) ? $Format["LineG"] : VOID;

    5041. 

  5041.      $LineB		= isset($Format["LineB"]) ? $Format["LineB"] : VOID;

    5042. 

  5042.      $LineAlpha		= isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 100;

    5043. 

  5043.      $DrawPlot		= isset($Format["DrawPlot"]) ? $Format["DrawPlot"] : FALSE;

    5044. 

  5044.      $PlotRadius	= isset($Format["PlotRadius"]) ? $Format["PlotRadius"] : 2;

    5045. 

  5045.      $PlotBorder	= isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : 1;

    5046. 

  5046.      $PlotBorderSurrounding = isset($Format["PlotBorderSurrounding"]) ? $Format["PlotBorderSurrounding"] : NULL;

    5047. 

  5047.      $PlotBorderR	= isset($Format["PlotBorderR"]) ? $Format["PlotBorderR"] : 0;

    5048. 

  5048.      $PlotBorderG	= isset($Format["PlotBorderG"]) ? $Format["PlotBorderG"] : 0;

    5049. 

  5049.      $PlotBorderB	= isset($Format["PlotBorderB"]) ? $Format["PlotBorderB"] : 0;

    5050. 

  5050.      $PlotBorderAlpha	= isset($Format["PlotBorderAlpha"]) ? $Format["PlotBorderAlpha"] : 50;

    5051. 

  5051.      $ForceTransparency	= isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;

    5052. 

  5052. 

    5053. 

  5053.      $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;

    5054. 

  5054. 

    5055. 

  5055.      $Data = $this->DataSet->getData();

    5056. 

  5056.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    5057. 

  5057. 

    5058. 

  5058.      $RestoreShadow = $this->Shadow;

    5059. 

  5059.      $this->Shadow  = FALSE;

    5060. 

  5060. 

    5061. 

  5061.      /* Build the offset data series */

    5062. 

  5062.      $OffsetData    = "";

    5063. 

  5063.      $OverallOffset = "";

    5064. 

  5064.      $SerieOrder    = "";

    5065. 

  5065.      foreach($Data["Series"] as $SerieName => $Serie)

    5066. 

  5066.       {

    5067. 

  5067.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    5068. 

  5068.         {

    5069. 

  5069.          $SerieOrder[] = $SerieName;

    5070. 

  5070. 

    5071. 

  5071.          foreach($Serie["Data"] as $Key => $Value)

    5072. 

  5072.           {

    5073. 

  5073.            if ( $Value == VOID ) { $Value = 0; }

    5074. 

  5074.            if ($Value >= 0) { $Sign = "+"; } else { $Sign = "-"; }

    5075. 

  5075.            if ( !isset($OverallOffset[$Key]) || !isset($OverallOffset[$Key][$Sign]) ) { $OverallOffset[$Key][$Sign] = 0; }

    5076. 

  5076. 

    5077. 

  5077.            if ( $Sign == "+" )

    5078. 

  5078.             { $Data["Series"][$SerieName]["Data"][$Key] = $Value + $OverallOffset[$Key][$Sign]; }

    5079. 

  5079.            else

    5080. 

  5080.             { $Data["Series"][$SerieName]["Data"][$Key] = $Value - $OverallOffset[$Key][$Sign]; }

    5081. 

  5081. 

    5082. 

  5082.            $OverallOffset[$Key][$Sign] = $OverallOffset[$Key][$Sign] + abs($Value);

    5083. 

  5083.           }

    5084. 

  5084.         } 

    5085. 

  5085.       }

    5086. 

  5086.      $SerieOrder = array_reverse($SerieOrder);

    5087. 

  5087. 

    5088. 

  5088.      $LastX = ""; $LastY = "";

    5089. 

  5089.      foreach($SerieOrder as $Key => $SerieName)

    5090. 

  5090.       {

    5091. 

  5091.        $Serie = $Data["Series"][$SerieName];

    5092. 

  5092.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    5093. 

  5093.         {

    5094. 

  5094.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"];

    5095. 

  5095.          if ( $ForceTransparency != NULL ) { $Alpha = $ForceTransparency; }

    5096. 

  5096. 

    5097. 

  5097.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);

    5098. 

  5098. 

    5099. 

  5099.          if ( $LineSurrounding != NULL )

    5100. 

  5100.           $LineColor = array("R"=>$R+$LineSurrounding,"G"=>$G+$LineSurrounding,"B"=>$B+$LineSurrounding,"Alpha"=>$Alpha);

    5101. 

  5101.          elseif ( $LineR != VOID )

    5102. 

  5102.           $LineColor = array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha);

    5103. 

  5103.          else

    5104. 

  5104.           $LineColor = $Color;

    5105. 

  5105. 

    5106. 

  5106.          if ( $PlotBorderSurrounding != NULL )

    5107. 

  5107.           $PlotBorderColor = array("R"=>$R+$PlotBorderSurrounding,"G"=>$G+$PlotBorderSurrounding,"B"=>$B+$PlotBorderSurrounding,"Alpha"=>$PlotBorderAlpha);

    5108. 

  5108.          else

    5109. 

  5109.           $PlotBorderColor = array("R"=>$PlotBorderR,"G"=>$PlotBorderG,"B"=>$PlotBorderB,"Alpha"=>$PlotBorderAlpha);

    5110. 

  5110. 

    5111. 

  5111.          $AxisID	= $Serie["Axis"];

    5112. 

  5112.          $Mode		= $Data["Axis"][$AxisID]["Display"];

    5113. 

  5113.          $Format	= $Data["Axis"][$AxisID]["Format"];

    5114. 

  5114.          $Unit		= $Data["Axis"][$AxisID]["Unit"];

    5115. 

  5115. 

    5116. 

  5116.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]),TRUE);

    5117. 

  5117.          $YZero    = $this->scaleComputeY(0,array("AxisID"=>$Serie["Axis"]));

    5118. 

  5118. 

    5119. 

  5119.          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;

    5120. 

  5120. 

    5121. 

  5121.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    5122. 

  5122.           {

    5123. 

  5123.            if ( $YZero < $this->GraphAreaY1+1 ) { $YZero = $this->GraphAreaY1+1; }

    5124. 

  5124.            if ( $YZero > $this->GraphAreaY2-1 ) { $YZero = $this->GraphAreaY2-1; }

    5125. 

  5125. 

    5126. 

  5126.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    5127. 

  5127.            $X = $this->GraphAreaX1 + $XMargin;

    5128. 

  5128. 

    5129. 

  5129.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5130. 

  5130. 

    5131. 

  5131.            $Plots = ""; $Plots[] = $X; $Plots[] = $YZero;

    5132. 

  5132.            foreach($PosArray as $Key => $Height)

    5133. 

  5133.             {

    5134. 

  5134.              if ( $Height != VOID ) { $Plots[] = $X; $Plots[] = $YZero-$Height; }

    5135. 

  5135.              $X = $X + $XStep;

    5136. 

  5136.             }

    5137. 

  5137.            $Plots[] = $X-$XStep; $Plots[] = $YZero;

    5138. 

  5138. 

    5139. 

  5139.            $this->drawPolygon($Plots,$Color);

    5140. 

  5140. 

    5141. 

  5141.            $this->Shadow = $RestoreShadow;

    5142. 

  5142.            if ( $DrawLine ) { for($i=2; $i<=count($Plots)-6; $i=$i+2) { $this->drawLine($Plots[$i],$Plots[$i+1],$Plots[$i+2],$Plots[$i+3],$LineColor); } }

    5143. 

  5143.            if ( $DrawPlot )

    5144. 

  5144.             {

    5145. 

  5145.              for($i=2; $i<=count($Plots)-4; $i=$i+2)

    5146. 

  5146.               {

    5147. 

  5147.                if ( $PlotBorder != 0 )

    5148. 

  5148.                 { $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius+$PlotBorder,$PlotBorderColor); }

    5149. 

  5149. 

    5150. 

  5150.                $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius,$Color);

    5151. 

  5151.               }

    5152. 

  5152.             }

    5153. 

  5153.            $this->Shadow = FALSE;

    5154. 

  5154.           }

    5155. 

  5155.          elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM )

    5156. 

  5156.           {

    5157. 

  5157.            if ( $YZero < $this->GraphAreaX1+1 ) { $YZero = $this->GraphAreaX1+1; }

    5158. 

  5158.            if ( $YZero > $this->GraphAreaX2-1 ) { $YZero = $this->GraphAreaX2-1; }

    5159. 

  5159. 

    5160. 

  5160.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    5161. 

  5161.            $Y = $this->GraphAreaY1 + $XMargin;

    5162. 

  5162. 

    5163. 

  5163.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5164. 

  5164. 

    5165. 

  5165.            $Plots = ""; $Plots[] = $YZero; $Plots[] = $Y;

    5166. 

  5166.            foreach($PosArray as $Key => $Height)

    5167. 

  5167.             {

    5168. 

  5168.              if ( $Height != VOID ) { $Plots[] = $YZero+$Height; $Plots[] = $Y; }

    5169. 

  5169.              $Y = $Y + $YStep;

    5170. 

  5170.             }

    5171. 

  5171.            $Plots[] = $YZero; $Plots[] = $Y-$YStep;

    5172. 

  5172. 

    5173. 

  5173.            $this->drawPolygon($Plots,$Color);

    5174. 

  5174. 

    5175. 

  5175.            $this->Shadow = $RestoreShadow;

    5176. 

  5176.            if ( $DrawLine ) { for($i=2; $i<=count($Plots)-6; $i=$i+2) { $this->drawLine($Plots[$i],$Plots[$i+1],$Plots[$i+2],$Plots[$i+3],$LineColor); } }

    5177. 

  5177.            if ( $DrawPlot )

    5178. 

  5178.             {

    5179. 

  5179.              for($i=2; $i<=count($Plots)-4; $i=$i+2)

    5180. 

  5180.               {

    5181. 

  5181.                if ( $PlotBorder != 0 )

    5182. 

  5182.                 { $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius+$PlotBorder,$PlotBorderColor); }

    5183. 

  5183. 

    5184. 

  5184.                $this->drawFilledCircle($Plots[$i],$Plots[$i+1],$PlotRadius,$Color);

    5185. 

  5185.               }

    5186. 

  5186.             }

    5187. 

  5187.            $this->Shadow = FALSE;

    5188. 

  5188.           }

    5189. 

  5189.         }

    5190. 

  5190.       }

    5191. 

  5191.      $this->Shadow = $RestoreShadow;

    5192. 

  5192.     }

    5193. 

  5193. 

    5194. 

  5194.    /* Returns a random color */

    5195. 

  5195.    function getRandomColor($Alpha=100)

    5196. 

  5196.     { return(array("R"=>rand(0,255),"G"=>rand(0,255),"B"=>rand(0,255),"Alpha"=>$Alpha)); }

    5197. 

  5197.  

    5198. 

  5198.    /* Validate a palette */

    5199. 

  5199.    function validatePalette($Colors,$Surrounding=NULL)

    5200. 

  5200.     {

    5201. 

  5201.      $Result = "";

    5202. 

  5202. 

    5203. 

  5203.      if ( !is_array($Colors) ) { return($this->getRandomColor()); }

    5204. 

  5204. 

    5205. 

  5205.      foreach($Colors as $Key => $Values)

    5206. 

  5206.       {

    5207. 

  5207.        if ( isset($Values["R"]) ) { $Result[$Key]["R"] = $Values["R"]; } else { $Result[$Key]["R"] = rand(0,255); }

    5208. 

  5208.        if ( isset($Values["G"]) ) { $Result[$Key]["G"] = $Values["G"]; } else { $Result[$Key]["G"] = rand(0,255); }

    5209. 

  5209.        if ( isset($Values["B"]) ) { $Result[$Key]["B"] = $Values["B"]; } else { $Result[$Key]["B"] = rand(0,255); }

    5210. 

  5210.        if ( isset($Values["Alpha"]) ) { $Result[$Key]["Alpha"] = $Values["Alpha"]; } else { $Result[$Key]["Alpha"] = 100; }

    5211. 

  5211. 

    5212. 

  5212.        if ( $Surrounding != NULL )

    5213. 

  5213.         {

    5214. 

  5214.          $Result[$Key]["BorderR"] = $Result[$Key]["R"] + $Surrounding;

    5215. 

  5215.          $Result[$Key]["BorderG"] = $Result[$Key]["G"] + $Surrounding;

    5216. 

  5216.          $Result[$Key]["BorderB"] = $Result[$Key]["B"] + $Surrounding;

    5217. 

  5217.         }

    5218. 

  5218.        else

    5219. 

  5219.         {

    5220. 

  5220.          if ( isset($Values["BorderR"]) )     { $Result[$Key]["BorderR"] = $Values["BorderR"]; } else { $Result[$Key]["BorderR"] = $Result[$Key]["R"]; }

    5221. 

  5221.          if ( isset($Values["BorderG"]) )     { $Result[$Key]["BorderG"] = $Values["BorderG"]; } else { $Result[$Key]["BorderG"] = $Result[$Key]["G"]; }

    5222. 

  5222.          if ( isset($Values["BorderB"]) )     { $Result[$Key]["BorderB"] = $Values["BorderB"]; } else { $Result[$Key]["BorderB"] = $Result[$Key]["B"]; }

    5223. 

  5223.          if ( isset($Values["BorderAlpha"]) ) { $Result[$Key]["BorderAlpha"] = $Values["BorderAlpha"]; } else { $Result[$Key]["BorderAlpha"] = $Result[$Key]["Alpha"]; }

    5224. 

  5224.         }

    5225. 

  5225.       }

    5226. 

  5226. 

    5227. 

  5227.      return($Result);

    5228. 

  5228.     }

    5229. 

  5229. 

    5230. 

  5230.    /* Draw the derivative chart associated to the data series */

    5231. 

  5231.    function drawDerivative($Format=NULL)

    5232. 

  5232.     {

    5233. 

  5233.      $Offset		= isset($Format["Offset"]) ? $Format["Offset"] : 10;

    5234. 

  5234.      $SerieSpacing	= isset($Format["SerieSpacing"]) ? $Format["SerieSpacing"] : 3;

    5235. 

  5235.      $DerivativeHeight	= isset($Format["DerivativeHeight"]) ? $Format["DerivativeHeight"] : 4;

    5236. 

  5236.      $ShadedSlopeBox	= isset($Format["ShadedSlopeBox"]) ? $Format["ShadedSlopeBox"] : FALSE;

    5237. 

  5237.      $DrawBackground	= isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : TRUE;

    5238. 

  5238.      $BackgroundR	= isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;

    5239. 

  5239.      $BackgroundG	= isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;

    5240. 

  5240.      $BackgroundB	= isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;

    5241. 

  5241.      $BackgroundAlpha	= isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 20;

    5242. 

  5242.      $DrawBorder	= isset($Format["DrawBorder"]) ? $Format["DrawBorder"] : TRUE;

    5243. 

  5243.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 0;

    5244. 

  5244.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 0;

    5245. 

  5245.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 0;

    5246. 

  5246.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 100;

    5247. 

  5247.      $Caption		= isset($Format["Caption"]) ? $Format["Caption"] : TRUE;

    5248. 

  5248.      $CaptionHeight	= isset($Format["CaptionHeight"]) ? $Format["CaptionHeight"] : 10;

    5249. 

  5249.      $CaptionWidth	= isset($Format["CaptionWidth"]) ? $Format["CaptionWidth"] : 20;

    5250. 

  5250.      $CaptionMargin	= isset($Format["CaptionMargin"]) ? $Format["CaptionMargin"] : 4;

    5251. 

  5251.      $CaptionLine	= isset($Format["CaptionLine"]) ? $Format["CaptionLine"] : FALSE;

    5252. 

  5252.      $CaptionBox	= isset($Format["CaptionBox"]) ? $Format["CaptionBox"] : FALSE;

    5253. 

  5253.      $CaptionBorderR	= isset($Format["CaptionBorderR"]) ? $Format["CaptionBorderR"] : 0;

    5254. 

  5254.      $CaptionBorderG	= isset($Format["CaptionBorderG"]) ? $Format["CaptionBorderG"] : 0;

    5255. 

  5255.      $CaptionBorderB	= isset($Format["CaptionBorderB"]) ? $Format["CaptionBorderB"] : 0;

    5256. 

  5256.      $CaptionFillR	= isset($Format["CaptionFillR"]) ? $Format["CaptionFillR"] : 255;

    5257. 

  5257.      $CaptionFillG	= isset($Format["CaptionFillG"]) ? $Format["CaptionFillG"] : 255;

    5258. 

  5258.      $CaptionFillB	= isset($Format["CaptionFillB"]) ? $Format["CaptionFillB"] : 255;

    5259. 

  5259.      $CaptionFillAlpha	= isset($Format["CaptionFillAlpha"]) ? $Format["CaptionFillAlpha"] : 80;

    5260. 

  5260.      $PositiveSlopeStartR	= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 184;

    5261. 

  5261.      $PositiveSlopeStartG	= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 234;

    5262. 

  5262.      $PositiveSlopeStartB	= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 88;

    5263. 

  5263.      $PositiveSlopeEndR		= isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 239;

    5264. 

  5264.      $PositiveSlopeEndG		= isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 31;

    5265. 

  5265.      $PositiveSlopeEndB		= isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 36;

    5266. 

  5266.      $NegativeSlopeStartR	= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 184;

    5267. 

  5267.      $NegativeSlopeStartG	= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 234;

    5268. 

  5268.      $NegativeSlopeStartB	= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 88;

    5269. 

  5269.      $NegativeSlopeEndR		= isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 67;

    5270. 

  5270.      $NegativeSlopeEndG		= isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 124;

    5271. 

  5271.      $NegativeSlopeEndB		= isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 227;

    5272. 

  5272. 

    5273. 

  5273.      $Data = $this->DataSet->getData();

    5274. 

  5274. 

    5275. 

  5275.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    5276. 

  5276. 

    5277. 

  5277.      if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    5278. 

  5278.       $YPos = $this->DataSet->Data["GraphArea"]["Y2"] + $Offset;

    5279. 

  5279.      else

    5280. 

  5280.       $XPos = $this->DataSet->Data["GraphArea"]["X2"] + $Offset;

    5281. 

  5281. 

    5282. 

  5282.      foreach($Data["Series"] as $SerieName => $Serie)

    5283. 

  5283.       {

    5284. 

  5284.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    5285. 

  5285.         {

    5286. 

  5286.          $R = $Serie["Color"]["R"]; $G = $Serie["Color"]["G"]; $B = $Serie["Color"]["B"]; $Alpha = $Serie["Color"]["Alpha"]; $Ticks = $Serie["Ticks"]; $Weight = $Serie["Weight"];

    5287. 

  5287. 

    5288. 

  5288.          $AxisID   = $Serie["Axis"];

    5289. 

  5289.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    5290. 

  5290. 

    5291. 

  5291.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    5292. 

  5292.           {

    5293. 

  5293.            if ( $Caption )

    5294. 

  5294.             {

    5295. 

  5295.              if ( $CaptionLine ) 

    5296. 

  5296.               {

    5297. 

  5297.                $StartX = floor($this->GraphAreaX1-$CaptionWidth+$XMargin-$CaptionMargin);

    5298. 

  5298.                $EndX   = floor($this->GraphAreaX1-$CaptionMargin+$XMargin);

    5299. 

  5299. 

    5300. 

  5300.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

    5301. 

  5301.                if ( $CaptionBox ) { $this->drawFilledRectangle($StartX,$YPos,$EndX,$YPos+$CaptionHeight,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }

    5302. 

  5302.                $this->drawLine($StartX+2,$YPos+($CaptionHeight/2),$EndX-2,$YPos+($CaptionHeight/2),$CaptionSettings);

    5303. 

  5303.               }

    5304. 

  5304.              else

    5305. 

  5305.               $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));

    5306. 

  5306.             }

    5307. 

  5307. 

    5308. 

  5308.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    5309. 

  5309.            $X = $this->GraphAreaX1 + $XMargin;

    5310. 

  5310. 

    5311. 

  5311.            $TopY    = $YPos + ($CaptionHeight/2) - ($DerivativeHeight/2);

    5312. 

  5312.            $BottomY = $YPos + ($CaptionHeight/2) + ($DerivativeHeight/2);

    5313. 

  5313. 

    5314. 

  5314.            $StartX  = floor($this->GraphAreaX1+$XMargin);

    5315. 

  5315.            $EndX    = floor($this->GraphAreaX2-$XMargin);

    5316. 

  5316. 

    5317. 

  5317.            if ( $DrawBackground ) { $this->drawFilledRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }

    5318. 

  5318.            if ( $DrawBorder ) { $this->drawRectangle($StartX-1,$TopY-1,$EndX+1,$BottomY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

    5319. 

  5319. 

    5320. 

  5320.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5321. 

  5321. 

    5322. 

  5322.            $RestoreShadow = $this->Shadow;

    5323. 

  5323.            $this->Shadow  = FALSE;

    5324. 

  5324. 

    5325. 

  5325.            /* Determine the Max slope index */

    5326. 

  5326.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;

    5327. 

  5327.            foreach($PosArray as $Key => $Y)

    5328. 

  5328.             {

    5329. 

  5329.              if ( $Y != VOID && $LastX != NULL )

    5330. 

  5330.               { $Slope = ($LastY - $Y); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }

    5331. 

  5331. 

    5332. 

  5332.              if ( $Y == VOID )

    5333. 

  5333.               { $LastX = NULL; $LastY = NULL; }

    5334. 

  5334.              else

    5335. 

  5335.               { $LastX = $X; $LastY = $Y; }

    5336. 

  5336.             }

    5337. 

  5337. 

    5338. 

  5338.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;

    5339. 

  5339.            foreach($PosArray as $Key => $Y)

    5340. 

  5340.             {

    5341. 

  5341.              if ( $Y != VOID && $LastY != NULL )

    5342. 

  5342.               {

    5343. 

  5343.                $Slope = ($LastY - $Y);

    5344. 

  5344. 

    5345. 

  5345.                if ( $Slope >= 0 )

    5346. 

  5346.                 {

    5347. 

  5347.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;

    5348. 

  5348.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;

    5349. 

  5349.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;

    5350. 

  5350.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;

    5351. 

  5351.                 }

    5352. 

  5352.                elseif ( $Slope < 0 )

    5353. 

  5353.                 {

    5354. 

  5354.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);

    5355. 

  5355.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;

    5356. 

  5356.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;

    5357. 

  5357.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;

    5358. 

  5358.                 }

    5359. 

  5359. 

    5360. 

  5360.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);

    5361. 

  5361. 

    5362. 

  5362.                if ( $ShadedSlopeBox && $LastColor != NULL ) // && $Slope != 0

    5363. 

  5363.                 {

    5364. 

  5364.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);

    5365. 

  5365.                  $this->drawGradientArea($LastX,$TopY,$X,$BottomY,DIRECTION_HORIZONTAL,$GradientSettings);

    5366. 

  5366.                 }

    5367. 

  5367.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) // || $Slope == 0

    5368. 

  5368.                 $this->drawFilledRectangle(floor($LastX),$TopY,floor($X),$BottomY,$Color);

    5369. 

  5369. 

    5370. 

  5370.                $LastColor = $Color;

    5371. 

  5371.               }

    5372. 

  5372. 

    5373. 

  5373.              if ( $Y == VOID )

    5374. 

  5374.               { $LastY = NULL; }

    5375. 

  5375.              else

    5376. 

  5376.               { $LastX = $X; $LastY = $Y; }

    5377. 

  5377. 

    5378. 

  5378.              $X = $X + $XStep;

    5379. 

  5379.             }

    5380. 

  5380. 

    5381. 

  5381.            $YPos = $YPos + $CaptionHeight + $SerieSpacing;

    5382. 

  5382.           }

    5383. 

  5383.          else

    5384. 

  5384.           {

    5385. 

  5385.            if ( $Caption )

    5386. 

  5386.             {

    5387. 

  5387.              $StartY = floor($this->GraphAreaY1-$CaptionWidth+$XMargin-$CaptionMargin);

    5388. 

  5388.              $EndY   = floor($this->GraphAreaY1-$CaptionMargin+$XMargin);

    5389. 

  5389.              if ( $CaptionLine ) 

    5390. 

  5390.               {

    5391. 

  5391.                $CaptionSettings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Weight"=>$Weight);

    5392. 

  5392.                if ( $CaptionBox ) { $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$CaptionFillR,"G"=>$CaptionFillG,"B"=>$CaptionFillB,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB,"Alpha"=>$CaptionFillAlpha)); }

    5393. 

  5393.                $this->drawLine($XPos+($CaptionHeight/2),$StartY+2,$XPos+($CaptionHeight/2),$EndY-2,$CaptionSettings);

    5394. 

  5394.               }

    5395. 

  5395.              else

    5396. 

  5396.               $this->drawFilledRectangle($XPos,$StartY,$XPos+$CaptionHeight,$EndY,array("R"=>$R,"G"=>$G,"B"=>$B,"BorderR"=>$CaptionBorderR,"BorderG"=>$CaptionBorderG,"BorderB"=>$CaptionBorderB));

    5397. 

  5397.             }

    5398. 

  5398. 

    5399. 

  5399. 

    5400. 

  5400.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    5401. 

  5401.            $Y = $this->GraphAreaY1 + $XMargin;

    5402. 

  5402. 

    5403. 

  5403.            $TopX    = $XPos + ($CaptionHeight/2) - ($DerivativeHeight/2);

    5404. 

  5404.            $BottomX = $XPos + ($CaptionHeight/2) + ($DerivativeHeight/2);

    5405. 

  5405. 

    5406. 

  5406.            $StartY  = floor($this->GraphAreaY1+$XMargin);

    5407. 

  5407.            $EndY    = floor($this->GraphAreaY2-$XMargin);

    5408. 

  5408. 

    5409. 

  5409.            if ( $DrawBackground ) { $this->drawFilledRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha)); }

    5410. 

  5410.            if ( $DrawBorder ) { $this->drawRectangle($TopX-1,$StartY-1,$BottomX+1,$EndY+1,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

    5411. 

  5411. 

    5412. 

  5412.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5413. 

  5413. 

    5414. 

  5414.            $RestoreShadow = $this->Shadow;

    5415. 

  5415.            $this->Shadow  = FALSE;

    5416. 

  5416. 

    5417. 

  5417.            /* Determine the Max slope index */

    5418. 

  5418.            $LastX = NULL; $LastY = NULL; $MinSlope = 0; $MaxSlope = 1;

    5419. 

  5419.            foreach($PosArray as $Key => $X)

    5420. 

  5420.             {

    5421. 

  5421.              if ( $X != VOID && $LastX != NULL )

    5422. 

  5422.               { $Slope = ($X - $LastX); if ( $Slope > $MaxSlope ) { $MaxSlope = $Slope; } if ( $Slope < $MinSlope ) { $MinSlope = $Slope; } }

    5423. 

  5423. 

    5424. 

  5424.              if ( $X == VOID )

    5425. 

  5425.               { $LastX = NULL; }

    5426. 

  5426.              else

    5427. 

  5427.               { $LastX = $X; }

    5428. 

  5428.             }

    5429. 

  5429. 

    5430. 

  5430.            $LastX = NULL; $LastY = NULL; $LastColor = NULL;

    5431. 

  5431.            foreach($PosArray as $Key => $X)

    5432. 

  5432.             {

    5433. 

  5433.              if ( $X != VOID && $LastX != NULL )

    5434. 

  5434.               {

    5435. 

  5435.                $Slope = ($X - $LastX);

    5436. 

  5436. 

    5437. 

  5437.                if ( $Slope >= 0 )

    5438. 

  5438.                 {

    5439. 

  5439.                  $SlopeIndex = (100 / $MaxSlope) * $Slope;

    5440. 

  5440.                  $R = (($PositiveSlopeEndR - $PositiveSlopeStartR)/100)*$SlopeIndex+$PositiveSlopeStartR;

    5441. 

  5441.                  $G = (($PositiveSlopeEndG - $PositiveSlopeStartG)/100)*$SlopeIndex+$PositiveSlopeStartG;

    5442. 

  5442.                  $B = (($PositiveSlopeEndB - $PositiveSlopeStartB)/100)*$SlopeIndex+$PositiveSlopeStartB;

    5443. 

  5443.                 }

    5444. 

  5444.                elseif ( $Slope < 0 )

    5445. 

  5445.                 {

    5446. 

  5446.                  $SlopeIndex = (100 / abs($MinSlope)) * abs($Slope);

    5447. 

  5447.                  $R = (($NegativeSlopeEndR - $NegativeSlopeStartR)/100)*$SlopeIndex+$NegativeSlopeStartR;

    5448. 

  5448.                  $G = (($NegativeSlopeEndG - $NegativeSlopeStartG)/100)*$SlopeIndex+$NegativeSlopeStartG;

    5449. 

  5449.                  $B = (($NegativeSlopeEndB - $NegativeSlopeStartB)/100)*$SlopeIndex+$NegativeSlopeStartB;

    5450. 

  5450.                 }

    5451. 

  5451. 

    5452. 

  5452.                $Color = array("R"=>$R,"G"=>$G,"B"=>$B);

    5453. 

  5453. 

    5454. 

  5454.                if ( $ShadedSlopeBox && $LastColor != NULL )

    5455. 

  5455.                 {

    5456. 

  5456.                  $GradientSettings = array("StartR"=>$LastColor["R"],"StartG"=>$LastColor["G"],"StartB"=>$LastColor["B"],"EndR"=>$R,"EndG"=>$G,"EndB"=>$B);

    5457. 

  5457. 

    5458. 

  5458.                  $this->drawGradientArea($TopX,$LastY,$BottomX,$Y,DIRECTION_VERTICAL,$GradientSettings);

    5459. 

  5459.                 }

    5460. 

  5460.                elseif ( !$ShadedSlopeBox || $LastColor == NULL ) 

    5461. 

  5461.                 $this->drawFilledRectangle($TopX,floor($LastY),$BottomX,floor($Y),$Color);

    5462. 

  5462. 

    5463. 

  5463.                $LastColor = $Color;

    5464. 

  5464.               }

    5465. 

  5465. 

    5466. 

  5466.              if ( $X == VOID )

    5467. 

  5467.               { $LastX = NULL; }

    5468. 

  5468.              else

    5469. 

  5469.               { $LastX = $X; $LastY = $Y; }

    5470. 

  5470. 

    5471. 

  5471.              $Y = $Y + $XStep;

    5472. 

  5472.             }

    5473. 

  5473. 

    5474. 

  5474.            $XPos = $XPos + $CaptionHeight + $SerieSpacing;

    5475. 

  5475.           }

    5476. 

  5476. 

    5477. 

  5477.          $this->Shadow = $RestoreShadow;

    5478. 

  5478.         }

    5479. 

  5479.       }

    5480. 

  5480.     }

    5481. 

  5481. 

    5482. 

  5482.    /* Draw the line of best fit */

    5483. 

  5483.    function drawBestFit($Format="")

    5484. 

  5484.     {

    5485. 

  5485.      $OverrideTicks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;

    5486. 

  5486.      $OverrideR		= isset($Format["R"]) ? $Format["R"] : VOID;

    5487. 

  5487.      $OverrideG		= isset($Format["G"]) ? $Format["G"] : VOID;

    5488. 

  5488.      $OverrideB		= isset($Format["B"]) ? $Format["B"] : VOID;

    5489. 

  5489.      $OverrideAlpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : VOID;

    5490. 

  5490. 

    5491. 

  5491.      $Data = $this->DataSet->getData();

    5492. 

  5492.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    5493. 

  5493. 

    5494. 

  5494.      foreach($Data["Series"] as $SerieName => $Serie)

    5495. 

  5495.       {

    5496. 

  5496.        if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] )

    5497. 

  5497.         {

    5498. 

  5498.          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"]; }

    5499. 

  5499.          if ( $OverrideTicks == NULL ) { $Ticks = $Serie["Ticks"]; } else { $Ticks = $OverrideTicks; }

    5500. 

  5500.          if ( $OverrideAlpha == VOID ) { $Alpha = $Serie["Color"]["Alpha"]; } else { $Alpha = $OverrideAlpha; }

    5501. 

  5501. 

    5502. 

  5502.          $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks);

    5503. 

  5503. 

    5504. 

  5504.          $AxisID   = $Serie["Axis"];

    5505. 

  5505.          $PosArray = $this->scaleComputeY($Serie["Data"],array("AxisID"=>$Serie["Axis"]));

    5506. 

  5506. 

    5507. 

  5507.          if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    5508. 

  5508.           {

    5509. 

  5509.            if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    5510. 

  5510.            $X = $this->GraphAreaX1 + $XMargin;

    5511. 

  5511. 

    5512. 

  5512.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5513. 

  5513.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;

    5514. 

  5514.            foreach($PosArray as $Key => $Y)

    5515. 

  5515.             {

    5516. 

  5516.              if ( $Y != VOID )

    5517. 

  5517.               {

    5518. 

  5518.                $Sxy = $Sxy + $X*$Y;

    5519. 

  5519.                $Sx  = $Sx + $X;

    5520. 

  5520.                $Sy  = $Sy + $Y;

    5521. 

  5521.                $Sxx = $Sxx + $X*$X;

    5522. 

  5522.               }

    5523. 

  5523. 

    5524. 

  5524.              $X = $X + $XStep;

    5525. 

  5525.             }

    5526. 

  5526.            $n = count($this->DataSet->stripVOID($PosArray)); //$n = count($PosArray);

    5527. 

  5527.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));

    5528. 

  5528.            $B = (($Sy)-($M*$Sx))/($n);

    5529. 

  5529. 

    5530. 

  5530.            $X1 = $this->GraphAreaX1 + $XMargin;

    5531. 

  5531.            $Y1 = $M * $X1 + $B;

    5532. 

  5532.            $X2 = $this->GraphAreaX2 - $XMargin;

    5533. 

  5533.            $Y2 = $M * $X2 + $B;

    5534. 

  5534. 

    5535. 

  5535.            if ( $Y1 < $this->GraphAreaY1 ) { $X1 = $X1 + ($this->GraphAreaY1-$Y1); $Y1 = $this->GraphAreaY1; }

    5536. 

  5536.            if ( $Y1 > $this->GraphAreaY2 ) { $X1 = $X1 + ($Y1-$this->GraphAreaY2); $Y1 = $this->GraphAreaY2; }

    5537. 

  5537.            if ( $Y2 < $this->GraphAreaY1 ) { $X2 = $X2 - ($this->GraphAreaY1-$Y2); $Y2 = $this->GraphAreaY1; }

    5538. 

  5538.            if ( $Y2 > $this->GraphAreaY2 ) { $X2 = $X2 - ($Y2-$this->GraphAreaY2); $Y2 = $this->GraphAreaY2; }

    5539. 

  5539. 

    5540. 

  5540.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);

    5541. 

  5541.           }

    5542. 

  5542.          else

    5543. 

  5543.           {

    5544. 

  5544.            if ( $XDivs == 0 ) { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $YStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    5545. 

  5545.            $Y = $this->GraphAreaY1 + $XMargin;

    5546. 

  5546. 

    5547. 

  5547.            if ( !is_array($PosArray) ) { $Value = $PosArray; $PosArray = ""; $PosArray[0] = $Value; }

    5548. 

  5548.            $Sxy = 0; $Sx = 0; $Sy = 0; $Sxx = 0;

    5549. 

  5549.            foreach($PosArray as $Key => $X)

    5550. 

  5550.             {

    5551. 

  5551.              if ( $X != VOID )

    5552. 

  5552.               {

    5553. 

  5553.                $Sxy = $Sxy + $X*$Y;

    5554. 

  5554.                $Sx  = $Sx + $Y;

    5555. 

  5555.                $Sy  = $Sy + $X;

    5556. 

  5556.                $Sxx = $Sxx + $Y*$Y;

    5557. 

  5557.               }

    5558. 

  5558. 

    5559. 

  5559.              $Y = $Y + $YStep;

    5560. 

  5560.             }

    5561. 

  5561.            $n = count($this->DataSet->stripVOID($PosArray)); //$n = count($PosArray);

    5562. 

  5562.            $M = (($n*$Sxy)-($Sx*$Sy)) / (($n*$Sxx)-($Sx*$Sx));

    5563. 

  5563.            $B = (($Sy)-($M*$Sx))/($n);

    5564. 

  5564. 

    5565. 

  5565.            $Y1 = $this->GraphAreaY1 + $XMargin;

    5566. 

  5566.            $X1 = $M * $Y1 + $B;

    5567. 

  5567.            $Y2 = $this->GraphAreaY2 - $XMargin;

    5568. 

  5568.            $X2 = $M * $Y2 + $B;

    5569. 

  5569. 

    5570. 

  5570.            if ( $X1 < $this->GraphAreaX1 ) { $Y1 = $Y1 + ($this->GraphAreaX1-$X1); $X1 = $this->GraphAreaX1; }

    5571. 

  5571.            if ( $X1 > $this->GraphAreaX2 ) { $Y1 = $Y1 + ($X1-$this->GraphAreaX2); $X1 = $this->GraphAreaX2; }

    5572. 

  5572.            if ( $X2 < $this->GraphAreaX1 ) { $Y2 = $Y2 - ($this->GraphAreaY1-$X2); $X2 = $this->GraphAreaX1; }

    5573. 

  5573.            if ( $X2 > $this->GraphAreaX2 ) { $Y2 = $Y2 - ($X2-$this->GraphAreaX2); $X2 = $this->GraphAreaX2; }

    5574. 

  5574. 

    5575. 

  5575.            $this->drawLine($X1,$Y1,$X2,$Y2,$Color);

    5576. 

  5576.           }

    5577. 

  5577.         }

    5578. 

  5578.       }

    5579. 

  5579.     }

    5580. 

  5580. 

    5581. 

  5581.    /* Write labels */

    5582. 

  5582.    function writeLabel($SeriesName,$Indexes,$Format="")

    5583. 

  5583.     {

    5584. 

  5584.      $OverrideTitle	= isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : NULL;

    5585. 

  5585.      $ForceLabels	= isset($Format["ForceLabels"]) ? $Format["ForceLabels"] : NULL;

    5586. 

  5586.      $DrawPoint		= isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;

    5587. 

  5587.      $DrawVerticalLine	= isset($Format["DrawVerticalLine"]) ? $Format["DrawVerticalLine"] : FALSE;

    5588. 

  5588.      $VerticalLineR	= isset($Format["VerticalLineR"]) ? $Format["VerticalLineR"] : 0;

    5589. 

  5589.      $VerticalLineG	= isset($Format["VerticalLineG"]) ? $Format["VerticalLineG"] : 0;

    5590. 

  5590.      $VerticalLineB	= isset($Format["VerticalLineB"]) ? $Format["VerticalLineB"] : 0;

    5591. 

  5591.      $VerticalLineAlpha	= isset($Format["VerticalLineAlpha"]) ? $Format["VerticalLineAlpha"] : 40;

    5592. 

  5592.      $VerticalLineTicks	= isset($Format["VerticalLineTicks"]) ? $Format["VerticalLineTicks"] : 2;

    5593. 

  5593. 

    5594. 

  5594.      $Data = $this->DataSet->getData();

    5595. 

  5595.      list($XMargin,$XDivs) = $this->scaleGetXSettings();

    5596. 

  5596. 

    5597. 

  5597.      if ( !is_array($Indexes) )    { $Index = $Indexes; $Indexes = ""; $Indexes[] = $Index; }

    5598. 

  5598.      if ( !is_array($SeriesName) ) { $SerieName = $SeriesName; $SeriesName = ""; $SeriesName[] = $SerieName; }

    5599. 

  5599.      if ( $ForceLabels != NULL && !is_array($ForceLabels) ) { $ForceLabel = $ForceLabels; $ForceLabels = ""; $ForceLabels[] = $ForceLabel; }

    5600. 

  5600. 

    5601. 

  5601.      foreach ($Indexes as $Key => $Index)

    5602. 

  5602.       {

    5603. 

  5603.        $Series = "";

    5604. 

  5604. 

    5605. 

  5605.        if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT )

    5606. 

  5606.         {

    5607. 

  5607.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1)/4; } else { $XStep = ($this->GraphAreaX2-$this->GraphAreaX1-$XMargin*2)/$XDivs; }

    5608. 

  5608.          $X = $this->GraphAreaX1 + $XMargin + $Index * $XStep;

    5609. 

  5609. 

    5610. 

  5610.          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)); }

    5611. 

  5611. 

    5612. 

  5612.          $MinY = $this->GraphAreaY2;

    5613. 

  5613.          foreach ($SeriesName as $iKey => $SerieName)

    5614. 

  5614.           {

    5615. 

  5615.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )

    5616. 

  5616.             {

    5617. 

  5617.              $AxisID       = $Data["Series"][$SerieName]["Axis"];

    5618. 

  5618.              $XAxisMode    = $Data["XAxisDisplay"];

    5619. 

  5619.              $XAxisFormat  = $Data["XAxisFormat"];

    5620. 

  5620.              $XAxisUnit    = $Data["XAxisUnit"];

    5621. 

  5621.              $AxisMode     = $Data["Axis"][$AxisID]["Display"];

    5622. 

  5622.              $AxisFormat   = $Data["Axis"][$AxisID]["Format"];

    5623. 

  5623.              $AxisUnit     = $Data["Axis"][$AxisID]["Unit"];

    5624. 

  5624. 

    5625. 

  5625.              if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

    5626. 

  5626.               $XLabel = $this->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index],$XAxisMode,$XAxisFormat,$XAxisUnit);

    5627. 

  5627.              else

    5628. 

  5628.               $XLabel = "";

    5629. 

  5629. 

    5630. 

  5630.              if ( $OverrideTitle != NULL)

    5631. 

  5631.               $Description = $OverrideTitle;

    5632. 

  5632.              elseif ( count($SeriesName) == 1 )

    5633. 

  5633.               {

    5634. 

  5634.                $Description = $Data["Series"][$SerieName]["Description"]." - ".$XLabel;

    5635. 

  5635.               }

    5636. 

  5636.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

    5637. 

  5637.               $Description = $XLabel;

    5638. 

  5638. 

    5639. 

  5639.              $Serie = "";

    5640. 

  5640.              $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];

    5641. 

  5641.              $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];

    5642. 

  5642.              $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];

    5643. 

  5643.              $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];

    5644. 

  5644. 

    5645. 

  5645.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )

    5646. 

  5646.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];

    5647. 

  5647.              else

    5648. 

  5648.               $SerieOffset = 0;

    5649. 

  5649. 

    5650. 

  5650.              $Value = $Data["Series"][$SerieName]["Data"][$Index];

    5651. 

  5651.              if ( $Value == VOID ) { $Value = "NaN"; }

    5652. 

  5652. 

    5653. 

  5653.              if ( $ForceLabels != NULL )

    5654. 

  5654.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";

    5655. 

  5655.              else

    5656. 

  5656.               $Caption = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);

    5657. 

  5657. 

    5658. 

  5658.              if ( $this->LastChartLayout == CHART_LAST_LAYOUT_STACKED )

    5659. 

  5659.               {

    5660. 

  5660.                if ( $Value >=0 ) { $LookFor = "+"; } else { $LookFor = "-"; }

    5661. 

  5661. 

    5662. 

  5662.                $Value = 0; $Done = FALSE;

    5663. 

  5663.                foreach($Data["Series"] as $Name => $SerieLookup)

    5664. 

  5664.                 {

    5665. 

  5665.                  if ( $SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done )

    5666. 

  5666.                   {

    5667. 

  5667.                    if ( isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID )

    5668. 

  5668.                     {

    5669. 

  5669.                      if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+" ) { $Value = $Value + $Data["Series"][$Name]["Data"][$Index]; }

    5670. 

  5670.                      if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-" )  { $Value = $Value - $Data["Series"][$Name]["Data"][$Index]; }

    5671. 

  5671.                      if ($Name == $SerieName ) { $Done = TRUE; }

    5672. 

  5672.                     }

    5673. 

  5673.                   }

    5674. 

  5674.                 }

    5675. 

  5675.               }

    5676. 

  5676. 

    5677. 

  5677.              $X = floor($this->GraphAreaX1 + $XMargin + $Index * $XStep + $SerieOffset);

    5678. 

  5678.              $Y = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));

    5679. 

  5679. 

    5680. 

  5680.              if ($Y < $MinY) { $MinY = $Y; }

    5681. 

  5681. 

    5682. 

  5682.              if ( $DrawPoint == LABEL_POINT_CIRCLE )

    5683. 

  5683.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

    5684. 

  5684.              elseif ( $DrawPoint == LABEL_POINT_BOX )

    5685. 

  5685.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

    5686. 

  5686. 

    5687. 

  5687.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);

    5688. 

  5688.             }

    5689. 

  5689.           }

    5690. 

  5690.          $this->drawLabelBox($X,$MinY-3,$Description,$Series,$Format);

    5691. 

  5691. 

    5692. 

  5692.         }

    5693. 

  5693.        else

    5694. 

  5694.         {

    5695. 

  5695.          if ( $XDivs == 0 ) { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1)/4; } else { $XStep = ($this->GraphAreaY2-$this->GraphAreaY1-$XMargin*2)/$XDivs; }

    5696. 

  5696.          $Y = $this->GraphAreaY1 + $XMargin + $Index * $XStep;

    5697. 

  5697. 

    5698. 

  5698.          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)); }

    5699. 

  5699. 

    5700. 

  5700.          $MinX = $this->GraphAreaX2;

    5701. 

  5701.          foreach ($SeriesName as $Key => $SerieName)

    5702. 

  5702.           {

    5703. 

  5703.            if ( isset($Data["Series"][$SerieName]["Data"][$Index]) )

    5704. 

  5704.             {

    5705. 

  5705.              $AxisID      = $Data["Series"][$SerieName]["Axis"];

    5706. 

  5706.              $XAxisMode   = $Data["XAxisDisplay"];

    5707. 

  5707.              $XAxisFormat = $Data["XAxisFormat"];

    5708. 

  5708.              $XAxisUnit   = $Data["XAxisUnit"];

    5709. 

  5709.              $AxisMode    = $Data["Axis"][$AxisID]["Display"];

    5710. 

  5710.              $AxisFormat  = $Data["Axis"][$AxisID]["Format"];

    5711. 

  5711.              $AxisUnit    = $Data["Axis"][$AxisID]["Unit"];

    5712. 

  5712. 

    5713. 

  5713.              if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

    5714. 

  5714.               $XLabel = $this->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index],$XAxisMode,$XAxisFormat,$XAxisUnit);

    5715. 

  5715.              else

    5716. 

  5716.               $XLabel = "";

    5717. 

  5717. 

    5718. 

  5718.              if ( $OverrideTitle != NULL)

    5719. 

  5719.               $Description = $OverrideTitle;

    5720. 

  5720.              elseif ( count($SeriesName) == 1 )

    5721. 

  5721.               {

    5722. 

  5722.                if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

    5723. 

  5723.                 $Description = $Data["Series"][$SerieName]["Description"]." - ".$XLabel;

    5724. 

  5724.               }

    5725. 

  5725.              elseif ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index]) )

    5726. 

  5726.               $Description = $XLabel;

    5727. 

  5727. 

    5728. 

  5728.              $Serie = "";

    5729. 

  5729.              if ( isset($Data["Extended"]["Palette"][$Index] ) )

    5730. 

  5730.               {

    5731. 

  5731.                $Serie["R"] = $Data["Extended"]["Palette"][$Index]["R"];

    5732. 

  5732.                $Serie["G"] = $Data["Extended"]["Palette"][$Index]["G"];

    5733. 

  5733.                $Serie["B"] = $Data["Extended"]["Palette"][$Index]["B"];

    5734. 

  5734.                $Serie["Alpha"] = $Data["Extended"]["Palette"][$Index]["Alpha"];

    5735. 

  5735.               }

    5736. 

  5736.              else

    5737. 

  5737.               {

    5738. 

  5738.                $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];

    5739. 

  5739.                $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];

    5740. 

  5740.                $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];

    5741. 

  5741.                $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];

    5742. 

  5742.               }

    5743. 

  5743. 

    5744. 

  5744.              if ( count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"]) )

    5745. 

  5745.               $SerieOffset = $Data["Series"][$SerieName]["XOffset"];

    5746. 

  5746.              else

    5747. 

  5747.               $SerieOffset = 0;

    5748. 

  5748. 

    5749. 

  5749.              $Value = $Data["Series"][$SerieName]["Data"][$Index];

    5750. 

  5750.              if ( $ForceLabels != NULL )

    5751. 

  5751.               $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";

    5752. 

  5752.              else

    5753. 

  5753.               $Caption = $this->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);

    5754. 

  5754.              if ( $Value == VOID ) { $Value = "NaN"; }

    5755. 

  5755. 

    5756. 

  5756.              if ( $this->LastChartLayout == CHART_LAST_LAYOUT_STACKED )

    5757. 

  5757.               {

    5758. 

  5758.                if ( $Value >=0 ) { $LookFor = "+"; } else { $LookFor = "-"; }

    5759. 

  5759. 

    5760. 

  5760.                $Value = 0; $Done = FALSE;

    5761. 

  5761.                foreach($Data["Series"] as $Name => $SerieLookup)

    5762. 

  5762.                 {

    5763. 

  5763.                  if ( $SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done )

    5764. 

  5764.                   {

    5765. 

  5765.                    if ( isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID )

    5766. 

  5766.                     {

    5767. 

  5767.                      if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+" ) { $Value = $Value + $Data["Series"][$Name]["Data"][$Index]; }

    5768. 

  5768.                      if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-" )  { $Value = $Value - $Data["Series"][$Name]["Data"][$Index]; }

    5769. 

  5769.                      if ($Name == $SerieName ) { $Done = TRUE; }

    5770. 

  5770.                     }

    5771. 

  5771.                   }

    5772. 

  5772.                 }

    5773. 

  5773.               }

    5774. 

  5774. 

    5775. 

  5775.              $X = floor($this->scaleComputeY($Value,array("AxisID"=>$AxisID)));

    5776. 

  5776.              $Y = floor($this->GraphAreaY1 + $XMargin + $Index * $XStep + $SerieOffset);

    5777. 

  5777. 

    5778. 

  5778.              if ($X < $MinX) { $MinX = $X; }

    5779. 

  5779. 

    5780. 

  5780.              if ( $DrawPoint == LABEL_POINT_CIRCLE )

    5781. 

  5781.               $this->drawFilledCircle($X,$Y,3,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

    5782. 

  5782.              elseif ( $DrawPoint == LABEL_POINT_BOX )

    5783. 

  5783.               $this->drawFilledRectangle($X-2,$Y-2,$X+2,$Y+2,array("R"=>255,"G"=>255,"B"=>255,"BorderR"=>0,"BorderG"=>0,"BorderB"=>0));

    5784. 

  5784. 

    5785. 

  5785.              $Series[] = array("Format"=>$Serie,"Caption"=>$Caption);

    5786. 

  5786.             }

    5787. 

  5787.           }

    5788. 

  5788.          $this->drawLabelBox($MinX,$Y-3,$Description,$Series,$Format);

    5789. 

  5789. 

    5790. 

  5790.         }

    5791. 

  5791.       }

    5792. 

  5792.     }

    5793. 

  5793. 

    5794. 

  5794.    /* Draw a label box */

    5795. 

  5795.    function drawLabelBox($X,$Y,$Title,$Captions,$Format="")

    5796. 

  5796.     {

    5797. 

  5797.      $NoTitle			= isset($Format["NoTitle"]) ? $Format["NoTitle"] : NULL;

    5798. 

  5798.      $BoxWidth			= isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 50;

    5799. 

  5799.      $DrawSerieColor		= isset($Format["DrawSerieColor"]) ? $Format["DrawSerieColor"] : TRUE;

    5800. 

  5800.      $SerieR			= isset($Format["SerieR"]) ? $Format["SerieR"] : NULL;

    5801. 

  5801.      $SerieG			= isset($Format["SerieG"]) ? $Format["SerieG"] : NULL;

    5802. 

  5802.      $SerieB			= isset($Format["SerieB"]) ? $Format["SerieB"] : NULL;

    5803. 

  5803.      $SerieAlpha		= isset($Format["SerieAlpha"]) ? $Format["SerieAlpha"] : NULL;

    5804. 

  5804.      $SerieBoxSize		= isset($Format["SerieBoxSize"]) ? $Format["SerieBoxSize"] : 6;

    5805. 

  5805.      $SerieBoxSpacing		= isset($Format["SerieBoxSpacing"]) ? $Format["SerieBoxSpacing"] : 4;

    5806. 

  5806.      $VerticalMargin		= isset($Format["VerticalMargin"]) ? $Format["VerticalMargin"] : 10;

    5807. 

  5807.      $HorizontalMargin		= isset($Format["HorizontalMargin"]) ? $Format["HorizontalMargin"] : 8;

    5808. 

  5808.      $R				= isset($Format["R"]) ? $Format["R"] : $this->FontColorR;

    5809. 

  5809.      $G				= isset($Format["G"]) ? $Format["G"] : $this->FontColorG;

    5810. 

  5810.      $B				= isset($Format["B"]) ? $Format["B"] : $this->FontColorB;

    5811. 

  5811.      $Alpha			= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;

    5812. 

  5812.      $FontName			= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;

    5813. 

  5813.      $FontSize			= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;

    5814. 

  5814.      $TitleMode			= isset($Format["TitleMode"]) ? $Format["TitleMode"] : LABEL_TITLE_NOBACKGROUND;

    5815. 

  5815.      $TitleR			= isset($Format["TitleR"]) ? $Format["TitleR"] : $R;

    5816. 

  5816.      $TitleG			= isset($Format["TitleG"]) ? $Format["TitleG"] : $G;

    5817. 

  5817.      $TitleB			= isset($Format["TitleB"]) ? $Format["TitleB"] : $B;

    5818. 

  5818.      $TitleAlpha		= isset($Format["TitleAlpha"]) ? $Format["TitleAlpha"] : 100;

    5819. 

  5819.      $TitleBackgroundR		= isset($Format["TitleBackgroundR"]) ? $Format["TitleBackgroundR"] : 0;

    5820. 

  5820.      $TitleBackgroundG		= isset($Format["TitleBackgroundG"]) ? $Format["TitleBackgroundG"] : 0;

    5821. 

  5821.      $TitleBackgroundB		= isset($Format["TitleBackgroundB"]) ? $Format["TitleBackgroundB"] : 0;

    5822. 

  5822.      $TitleBackgroundAlpha	= isset($Format["TitleBackgroundAlpha"]) ? $Format["TitleBackgroundAlpha"] : 100;

    5823. 

  5823.      $GradientStartR		= isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;

    5824. 

  5824.      $GradientStartG		= isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;

    5825. 

  5825.      $GradientStartB		= isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;

    5826. 

  5826.      $GradientEndR		= isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 220;

    5827. 

  5827.      $GradientEndG		= isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 220;

    5828. 

  5828.      $GradientEndB		= isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 220;

    5829. 

  5829.      $BoxAlpha			= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 100;

    5830. 

  5830. 

    5831. 

  5831.      if ( !$DrawSerieColor ) { $SerieBoxSize = 0; $SerieBoxSpacing = 0; }

    5832. 

  5832. 

    5833. 

  5833.      $TxtPos      = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Title);

    5834. 

  5834.      $TitleWidth  = ($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2;

    5835. 

  5835.      $TitleHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);

    5836. 

  5836. 

    5837. 

  5837.      if ( $NoTitle ) { $TitleWidth = 0; $TitleHeight = 0; }

    5838. 

  5838. 

    5839. 

  5839.      $CaptionWidth = 0; $CaptionHeight = -$HorizontalMargin;

    5840. 

  5840.      foreach($Captions as $Key =>$Caption)

    5841. 

  5841.       {

    5842. 

  5842.        $TxtPos        = $this->getTextBox($X,$Y,$FontName,$FontSize,0,$Caption["Caption"]);

    5843. 

  5843.        $CaptionWidth  = max($CaptionWidth,($TxtPos[1]["X"] - $TxtPos[0]["X"])+$VerticalMargin*2);

    5844. 

  5844.        $CaptionHeight = $CaptionHeight + max(($TxtPos[0]["Y"] - $TxtPos[2]["Y"]),($SerieBoxSize+2)) + $HorizontalMargin;

    5845. 

  5845.       }

    5846. 

  5846. 

    5847. 

  5847.      if ( $CaptionHeight <= 5 ) { $CaptionHeight = $CaptionHeight + $HorizontalMargin/2; }

    5848. 

  5848. 

    5849. 

  5849.      if ( $DrawSerieColor ) { $CaptionWidth = $CaptionWidth + $SerieBoxSize + $SerieBoxSpacing; }

    5850. 

  5850. 

    5851. 

  5851.      $BoxWidth = max($BoxWidth,$TitleWidth,$CaptionWidth);

    5852. 

  5852. 

    5853. 

  5853.      $XMin = $X - 5 - floor(($BoxWidth-10) / 2);

    5854. 

  5854.      $XMax = $X + 5 + floor(($BoxWidth-10) / 2);

    5855. 

  5855. 

    5856. 

  5856.      $RestoreShadow = $this->Shadow;

    5857. 

  5857.      if ( $this->Shadow == TRUE )

    5858. 

  5858.       {

    5859. 

  5859.        $this->Shadow = FALSE;

    5860. 

  5860. 

    5861. 

  5861.        $Poly = "";

    5862. 

  5862.        $Poly[] = $X+$this->ShadowX; $Poly[] = $Y+$this->ShadowX;

    5863. 

  5863.        $Poly[] = $X+5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

    5864. 

  5864.        $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

    5865. 

  5865. 

    5866. 

  5866.        if ( $NoTitle )

    5867. 

  5867.         {

    5868. 

  5868.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;

    5869. 

  5869.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2+$this->ShadowX;

    5870. 

  5870.         }

    5871. 

  5871.        else

    5872. 

  5872.         {

    5873. 

  5873.          $Poly[] = $XMax+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;

    5874. 

  5874.          $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3+$this->ShadowX;

    5875. 

  5875.         }

    5876. 

  5876. 

    5877. 

  5877.        $Poly[] = $XMin+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

    5878. 

  5878.        $Poly[] = $X-5+$this->ShadowX; $Poly[] = $Y-5+$this->ShadowX;

    5879. 

  5879.        $this->drawPolygon($Poly,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));

    5880. 

  5880.       }

    5881. 

  5881. 

    5882. 

  5882.      /* Draw the background */

    5883. 

  5883.      $GradientSettings = array("StartR"=>$GradientStartR,"StartG"=>$GradientStartG,"StartB"=>$GradientStartB,"EndR"=>$GradientEndR,"EndG"=>$GradientEndG,"EndB"=>$GradientEndB,"Alpha"=>$BoxAlpha);

    5884. 

  5884.      if ( $NoTitle )

    5885. 

  5885.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);

    5886. 

  5886.      else

    5887. 

  5887.       $this->drawGradientArea($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-6,DIRECTION_VERTICAL,$GradientSettings);

    5888. 

  5888.      $Poly = ""; $Poly[] = $X; $Poly[] = $Y; $Poly[] = $X-5; $Poly[] = $Y-5; $Poly[] = $X+5; $Poly[] = $Y-5;

    5889. 

  5889.      $this->drawPolygon($Poly,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB,"Alpha"=>$BoxAlpha,"NoBorder"=>TRUE));

    5890. 

  5890. 

    5891. 

  5891.      /* Outer border */

    5892. 

  5892.      $OuterBorderColor = $this->allocateColor($this->Picture,100,100,100,$BoxAlpha);

    5893. 

  5893.      imageline($this->Picture,$XMin,$Y-5,$X-5,$Y-5,$OuterBorderColor);

    5894. 

  5894.      imageline($this->Picture,$X,$Y,$X-5,$Y-5,$OuterBorderColor);

    5895. 

  5895.      imageline($this->Picture,$X,$Y,$X+5,$Y-5,$OuterBorderColor);

    5896. 

  5896.      imageline($this->Picture,$X+5,$Y-5,$XMax,$Y-5,$OuterBorderColor);

    5897. 

  5897.      if ( $NoTitle )

    5898. 

  5898.       {

    5899. 

  5899.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin,$Y-5,$OuterBorderColor);

    5900. 

  5900.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5,$OuterBorderColor);

    5901. 

  5901.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$OuterBorderColor);

    5902. 

  5902.       }

    5903. 

  5903.      else

    5904. 

  5904.       {

    5905. 

  5905.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin,$Y-5,$OuterBorderColor);

    5906. 

  5906.        imageline($this->Picture,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5,$OuterBorderColor);

    5907. 

  5907.        imageline($this->Picture,$XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$OuterBorderColor);

    5908. 

  5908.       }

    5909. 

  5909. 

    5910. 

  5910.      /* Inner border */

    5911. 

  5911.      $InnerBorderColor = $this->allocateColor($this->Picture,255,255,255,$BoxAlpha);

    5912. 

  5912.      imageline($this->Picture,$XMin+1,$Y-6,$X-5,$Y-6,$InnerBorderColor);

    5913. 

  5913.      imageline($this->Picture,$X,$Y-1,$X-5,$Y-6,$InnerBorderColor);

    5914. 

  5914.      imageline($this->Picture,$X,$Y-1,$X+5,$Y-6,$InnerBorderColor);

    5915. 

  5915.      imageline($this->Picture,$X+5,$Y-6,$XMax-1,$Y-6,$InnerBorderColor);

    5916. 

  5916.      if ( $NoTitle )

    5917. 

  5917.       {

    5918. 

  5918.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMin+1,$Y-6,$InnerBorderColor);

    5919. 

  5919.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-6,$InnerBorderColor);

    5920. 

  5920.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*2,$InnerBorderColor);

    5921. 

  5921.       }

    5922. 

  5922.      else

    5923. 

  5923.       {

    5924. 

  5924.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMin+1,$Y-6,$InnerBorderColor);

    5925. 

  5925.        imageline($this->Picture,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-6,$InnerBorderColor);

    5926. 

  5926.        imageline($this->Picture,$XMin+1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax-1,$Y-4-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$InnerBorderColor);

    5927. 

  5927.       }

    5928. 

  5928. 

    5929. 

  5929.      /* Draw the separator line */

    5930. 

  5930.      if ( $TitleMode == LABEL_TITLE_NOBACKGROUND && !$NoTitle )

    5931. 

  5931.       {

    5932. 

  5932.        $YPos    = $Y-7-$CaptionHeight-$HorizontalMargin-$HorizontalMargin/2;

    5933. 

  5933.        $XMargin = $VerticalMargin / 2;

    5934. 

  5934.        $this->drawLine($XMin+$XMargin,$YPos+1,$XMax-$XMargin,$YPos+1,array("R"=>$GradientEndR,"G"=>$GradientEndG,"B"=>$GradientEndB,"Alpha"=>$BoxAlpha));

    5935. 

  5935.        $this->drawLine($XMin+$XMargin,$YPos,$XMax-$XMargin,$YPos,array("R"=>$GradientStartR,"G"=>$GradientStartG,"B"=>$GradientStartB,"Alpha"=>$BoxAlpha));

    5936. 

  5936.       }

    5937. 

  5937.      elseif ( $TitleMode == LABEL_TITLE_BACKGROUND )

    5938. 

  5938.       {

    5939. 

  5939.        $this->drawFilledRectangle($XMin,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin*3,$XMax,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2,array("R"=>$TitleBackgroundR,"G"=>$TitleBackgroundG,"B"=>$TitleBackgroundB,"Alpha"=>$BoxAlpha));

    5940. 

  5940.        imageline($this->Picture,$XMin+1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$XMax-1,$Y-5-$TitleHeight-$CaptionHeight-$HorizontalMargin+$HorizontalMargin/2+1,$InnerBorderColor);

    5941. 

  5941.       }

    5942. 

  5942. 

    5943. 

  5943.      /* Write the description */

    5944. 

  5944.      if ( !$NoTitle )

    5945. 

  5945.       $this->drawText($XMin+$VerticalMargin,$Y-7-$CaptionHeight-$HorizontalMargin*2,$Title,array("Align"=>TEXT_ALIGN_BOTTOMLEFT,"R"=>$TitleR,"G"=>$TitleG,"B"=>$TitleB));

    5946. 

  5946. 

    5947. 

  5947.      /* Write the value */

    5948. 

  5948.      $YPos = $Y-5-$HorizontalMargin; $XPos = $XMin+$VerticalMargin+$SerieBoxSize+$SerieBoxSpacing;

    5949. 

  5949.      foreach($Captions as $Key => $Caption)

    5950. 

  5950.       {

    5951. 

  5951.        $CaptionTxt    = $Caption["Caption"];

    5952. 

  5952.        $TxtPos        = $this->getTextBox($XPos,$YPos,$FontName,$FontSize,0,$CaptionTxt);

    5953. 

  5953.        $CaptionHeight = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]);

    5954. 

  5954. 

    5955. 

  5955.        /* Write the serie color if needed */

    5956. 

  5956.        if ( $DrawSerieColor )

    5957. 

  5957.         {

    5958. 

  5958.          $BoxSettings = array("R"=>$Caption["Format"]["R"],"G"=>$Caption["Format"]["G"],"B"=>$Caption["Format"]["B"],"Alpha"=>$Caption["Format"]["Alpha"],"BorderR"=>0,"BorderG"=>0,"BorderB"=>0);

    5959. 

  5959.          $this->drawFilledRectangle($XMin+$VerticalMargin,$YPos-$SerieBoxSize,$XMin+$VerticalMargin+$SerieBoxSize,$YPos,$BoxSettings);

    5960. 

  5960.         }

    5961. 

  5961. 

    5962. 

  5962.        $this->drawText($XPos,$YPos,$CaptionTxt,array("Align"=>TEXT_ALIGN_BOTTOMLEFT));

    5963. 

  5963. 

    5964. 

  5964.        $YPos = $YPos - $CaptionHeight - $HorizontalMargin;

    5965. 

  5965.       }

    5966. 

  5966. 

    5967. 

  5967.      $this->Shadow = $RestoreShadow;

    5968. 

  5968.     }

    5969. 

  5969. 

    5970. 

  5970.    /* Draw a basic shape */

    5971. 

  5971.    function drawShape($X,$Y,$Shape,$PlotSize,$PlotBorder,$BorderSize,$R,$G,$B,$Alpha,$BorderR,$BorderG,$BorderB,$BorderAlpha)

    5972. 

  5972.     {

    5973. 

  5973.      if ( $Shape == SERIE_SHAPE_FILLEDCIRCLE )

    5974. 

  5974.       {

    5975. 

  5975.        if ( $PlotBorder ) { $this->drawFilledCircle($X,$Y,$PlotSize+$BorderSize,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha)); }

    5976. 

  5976.        $this->drawFilledCircle($X,$Y,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5977. 

  5977.       }

    5978. 

  5978.      elseif ( $Shape == SERIE_SHAPE_FILLEDSQUARE )

    5979. 

  5979.       {

    5980. 

  5980.        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)); }

    5981. 

  5981.        $this->drawFilledRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5982. 

  5982.       }

    5983. 

  5983.      elseif ( $Shape == SERIE_SHAPE_FILLEDTRIANGLE )

    5984. 

  5984.       {

    5985. 

  5985.        if ( $PlotBorder )

    5986. 

  5986.         {

    5987. 

  5987.          $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize-$BorderSize; $Pos[]=$X-$PlotSize-$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize; $Pos[]=$X+$PlotSize+$BorderSize; $Pos[]=$Y+$PlotSize+$BorderSize;

    5988. 

  5988.          $this->drawPolygon($Pos,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha));

    5989. 

  5989.         }

    5990. 

  5990. 

    5991. 

  5991.        $Pos = ""; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X-$PlotSize; $Pos[]=$Y+$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y+$PlotSize;

    5992. 

  5992.        $this->drawPolygon($Pos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5993. 

  5993.       }

    5994. 

  5994.      elseif ( $Shape == SERIE_SHAPE_TRIANGLE )

    5995. 

  5995.       {

    5996. 

  5996.        $this->drawLine($X,$Y-$PlotSize,$X-$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5997. 

  5997.        $this->drawLine($X-$PlotSize,$Y+$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5998. 

  5998.        $this->drawLine($X+$PlotSize,$Y+$PlotSize,$X,$Y-$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    5999. 

  5999.       }

    6000. 

  6000.      elseif ( $Shape == SERIE_SHAPE_SQUARE )

    6001. 

  6001.       $this->drawRectangle($X-$PlotSize,$Y-$PlotSize,$X+$PlotSize,$Y+$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    6002. 

  6002.      elseif ( $Shape == SERIE_SHAPE_CIRCLE )

    6003. 

  6003.       $this->drawCircle($X,$Y,$PlotSize,$PlotSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    6004. 

  6004.      elseif ( $Shape == SERIE_SHAPE_DIAMOND )

    6005. 

  6005.       {

    6006. 

  6006.        $Pos = ""; $Pos[]=$X-$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize;

    6007. 

  6007.        $this->drawPolygon($Pos,array("NoFill"=>TRUE,"BorderR"=>$R,"BorderG"=>$G,"BorderB"=>$B,"BorderAlpha"=>$Alpha));

    6008. 

  6008.       }      

    6009. 

  6009.      elseif ( $Shape == SERIE_SHAPE_FILLEDDIAMOND )

    6010. 

  6010.       {

    6011. 

  6011.        if ( $PlotBorder )

    6012. 

  6012.         {

    6013. 

  6013.          $Pos = ""; $Pos[]=$X-$PlotSize-$BorderSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize-$BorderSize; $Pos[]=$X+$PlotSize+$BorderSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize+$BorderSize;

    6014. 

  6014.          $this->drawPolygon($Pos,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha));

    6015. 

  6015.         }

    6016. 

  6016. 

    6017. 

  6017.        $Pos = ""; $Pos[]=$X-$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y-$PlotSize; $Pos[]=$X+$PlotSize; $Pos[]=$Y; $Pos[]=$X; $Pos[]=$Y+$PlotSize;

    6018. 

  6018.        $this->drawPolygon($Pos,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));

    6019. 

  6019.       }      

    6020. 

  6020.     }

    6021. 

  6021. 

    6022. 

  6022.    function drawPolygonChart($Points,$Format="")

    6023. 

  6023.     {

    6024. 

  6024.      $R			= isset($Format["R"]) ? $Format["R"] : 0;

    6025. 

  6025.      $G			= isset($Format["G"]) ? $Format["G"] : 0;

    6026. 

  6026.      $B			= isset($Format["B"]) ? $Format["B"] : 0;

    6027. 

  6027.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;

    6028. 

  6028.      $NoFill		= isset($Format["NoFill"]) ? $Format["NoFill"] : FALSE;

    6029. 

  6029.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;

    6030. 

  6030.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : $R;

    6031. 

  6031.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : $G;

    6032. 

  6032.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : $B;

    6033. 

  6033.      $BorderAlpha 	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha / 2;

    6034. 

  6034.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    6035. 

  6035.      $Threshold         = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;

    6036. 

  6036. 

    6037. 

  6037.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }

    6038. 

  6038. 

    6039. 

  6039.      $RestoreShadow = $this->Shadow;

    6040. 

  6040.      $this->Shadow = FALSE;

    6041. 

  6041. 

    6042. 

  6042.      $AllIntegers = TRUE;

    6043. 

  6043.      for($i=0;$i<=count($Points)-2;$i=$i+2)

    6044. 

  6044.       { if ( $this->getFirstDecimal($Points[$i+1]) != 0 ) { $AllIntegers = FALSE; } }

    6045. 

  6045. 

    6046. 

  6046.      /* Convert polygon to segments */

    6047. 

  6047.      $Segments = "";

    6048. 

  6048.      for($i=2;$i<=count($Points)-2;$i=$i+2)

    6049. 

  6049.       { $Segments[] = array("X1"=>$Points[$i-2],"Y1"=>$Points[$i-1],"X2"=>$Points[$i],"Y2"=>$Points[$i+1]); }

    6050. 

  6050.      $Segments[] = array("X1"=>$Points[$i-2],"Y1"=>$Points[$i-1],"X2"=>$Points[0],"Y2"=>$Points[1]);

    6051. 

  6051. 

    6052. 

  6052.      /* Simplify straight lines */

    6053. 

  6053.      $Result = ""; $inHorizon = FALSE; $LastX = VOID;

    6054. 

  6054.      foreach($Segments as $Key => $Pos)

    6055. 

  6055.       {

    6056. 

  6056.        if ( $Pos["Y1"] != $Pos["Y2"] )

    6057. 

  6057.         {

    6058. 

  6058.          if ( $inHorizon ) { $inHorizon = FALSE; $Result[] = array("X1"=>$LastX,"Y1"=>$Pos["Y1"],"X2"=>$Pos["X1"],"Y2"=>$Pos["Y1"]); }

    6059. 

  6059. 

    6060. 

  6060.          $Result[] = array("X1"=>$Pos["X1"],"Y1"=>$Pos["Y1"],"X2"=>$Pos["X2"],"Y2"=>$Pos["Y2"]);

    6061. 

  6061.         }

    6062. 

  6062.        else { if ( !$inHorizon ) { $inHorizon = TRUE; $LastX = $Pos["X1"];} }

    6063. 

  6063.       }

    6064. 

  6064.      $Segments = $Result;

    6065. 

  6065. 

    6066. 

  6066.      /* Do we have something to draw */

    6067. 

  6067.      if ( $Segments == "" ) { return(0); }

    6068. 

  6068. 

    6069. 

  6069.      /* For segments debugging purpose */

    6070. 

  6070.      //foreach($Segments as $Key => $Pos)

    6071. 

  6071.      // echo $Pos["X1"].",".$Pos["Y1"].",".$Pos["X2"].",".$Pos["Y2"]."\r\n";

    6072. 

  6072. 

    6073. 

  6073.      /* Find out the min & max Y boundaries */

    6074. 

  6074.      $MinY = OUT_OF_SIGHT; $MaxY = OUT_OF_SIGHT;

    6075. 

  6075.      foreach($Segments as $Key => $Coords)

    6076. 

  6076.       {

    6077. 

  6077.        if ( $MinY == OUT_OF_SIGHT || $MinY > min($Coords["Y1"],$Coords["Y2"]) ) { $MinY = min($Coords["Y1"],$Coords["Y2"]); }

    6078. 

  6078.        if ( $MaxY == OUT_OF_SIGHT || $MaxY < max($Coords["Y1"],$Coords["Y2"]) ) { $MaxY = max($Coords["Y1"],$Coords["Y2"]); }

    6079. 

  6079.       }

    6080. 

  6080. 

    6081. 

  6081.      if ( $AllIntegers ) { $YStep = 1; } else { $YStep = .5; }

    6082. 

  6082. 

    6083. 

  6083.      $MinY = floor($MinY); $MaxY = floor($MaxY);

    6084. 

  6084. 

    6085. 

  6085.      /* Scan each Y lines */

    6086. 

  6086.      $DefaultColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

    6087. 

  6087.      $DebugLine = 0; $DebugColor = $this->allocateColor($this->Picture,255,0,0,100);

    6088. 

  6088. 

    6089. 

  6089.      $MinY = floor($MinY); $MaxY = floor($MaxY); $YStep = 1; 

    6090. 

  6090. 

    6091. 

  6091.      if ( !$NoFill )

    6092. 

  6092.       {

    6093. 

  6093.        //if ( $DebugLine ) { $MinY = $DebugLine; $MaxY = $DebugLine; }

    6094. 

  6094.        for($Y=$MinY;$Y<=$MaxY;$Y=$Y+$YStep)

    6095. 

  6095.         {

    6096. 

  6096.          $Intersections = ""; $LastSlope = NULL; $RestoreLast = "-";

    6097. 

  6097.          foreach($Segments as $Key => $Coords)

    6098. 

  6098.           {

    6099. 

  6099.            $X1 = $Coords["X1"]; $X2 = $Coords["X2"]; $Y1 = $Coords["Y1"]; $Y2 = $Coords["Y2"];

    6100. 

  6100. 

    6101. 

  6101.            if ( min($Y1,$Y2) <= $Y && max($Y1,$Y2) >= $Y )

    6102. 

  6102.             {

    6103. 

  6103.              if ( $Y1 == $Y2 )

    6104. 

  6104.               { $X = $X1; }

    6105. 

  6105.              else

    6106. 

  6106.               { $X = $X1 + ( ($Y-$Y1)*$X2 - ($Y-$Y1)*$X1 ) / ($Y2-$Y1); }

    6107. 

  6107. 

    6108. 

  6108.              $X = floor($X);

    6109. 

  6109. 

    6110. 

  6110.              if ( $X2 == $X1 )

    6111. 

  6111.               { $Slope = "!"; }

    6112. 

  6112.              else

    6113. 

  6113.               {

    6114. 

  6114.                $SlopeC = ($Y2 - $Y1) / ($X2 - $X1);

    6115. 

  6115.                if( $SlopeC == 0 )

    6116. 

  6116.                 { $Slope = "="; }

    6117. 

  6117.                elseif( $SlopeC > 0 )

    6118. 

  6118.                 { $Slope = "+"; }

    6119. 

  6119.                elseif ( $SlopeC < 0 )

    6120. 

  6120.                 { $Slope = "-"; }

    6121. 

  6121.               }

    6122. 

  6122. 

    6123. 

  6123.              if ( !is_array($Intersections) )

    6124. 

  6124.               { $Intersections[] = $X; }

    6125. 

  6125.              elseif( !in_array($X,$Intersections) )

    6126. 

  6126.               { $Intersections[] = $X; }

    6127. 

  6127.              elseif( in_array($X,$Intersections) )

    6128. 

  6128.               {

    6129. 

  6129.                if ($Y == $DebugLine) { echo $Slope."/".$LastSlope."(".$X.") "; }

    6130. 

  6130. 

    6131. 

  6131.                if ( $Slope == "=" && $LastSlope == "-"  )                             { $Intersections[] = $X; }

    6132. 

  6132.                if ( $Slope != $LastSlope && $LastSlope != "!" && $LastSlope != "=" )  { $Intersections[] = $X; }

    6133. 

  6133.                if ( $Slope != $LastSlope && $LastSlope == "!" && $Slope == "+" )      { $Intersections[] = $X; }

    6134. 

  6134.               }

    6135. 

  6135. 

    6136. 

  6136.              if ( is_array($Intersections) && in_array($X,$Intersections) && $LastSlope == "=" && ($Slope == "-" )) { $Intersections[] = $X; }

    6137. 

  6137. 

    6138. 

  6138.              $LastSlope = $Slope;

    6139. 

  6139.             }

    6140. 

  6140.           }

    6141. 

  6141.          if ( $RestoreLast != "-" ) { $Intersections[] = $RestoreLast; echo "@".$Y."\r\n"; }

    6142. 

  6142. 

    6143. 

  6143.          if ( is_array($Intersections) )

    6144. 

  6144.           {

    6145. 

  6145.            sort($Intersections);

    6146. 

  6146. 

    6147. 

  6147.            if ($Y == $DebugLine) { print_r($Intersections); }

    6148. 

  6148. 

    6149. 

  6149.            /* Remove NULL plots */

    6150. 

  6150.            $Result = "";

    6151. 

  6151.            for($i=0;$i<=count($Intersections)-1;$i=$i+2)

    6152. 

  6152.             {

    6153. 

  6153.              if ( isset($Intersections[$i+1]) )

    6154. 

  6154.               { if ( $Intersections[$i] != $Intersections[$i+1] ) { $Result[] = $Intersections[$i]; $Result[] = $Intersections[$i+1]; } }

    6155. 

  6155.             }

    6156. 

  6156. 

    6157. 

  6157.            if ( is_array($Result) )

    6158. 

  6158.             {

    6159. 

  6159.              $Intersections = $Result;

    6160. 

  6160. 

    6161. 

  6161.              $LastX = OUT_OF_SIGHT;

    6162. 

  6162.              foreach($Intersections as $Key => $X)

    6163. 

  6163.               {

    6164. 

  6164.                if ( $LastX == OUT_OF_SIGHT )

    6165. 

  6165.                 $LastX = $X;

    6166. 

  6166.                elseif ( $LastX != OUT_OF_SIGHT )

    6167. 

  6167.                 {

    6168. 

  6168.                  if ( $this->getFirstDecimal($LastX) > 1 ) { $LastX++; }

    6169. 

  6169. 

    6170. 

  6170.                  $Color = $DefaultColor;

    6171. 

  6171.                  if ( $Threshold != NULL )

    6172. 

  6172.                   {

    6173. 

  6173.                    foreach($Threshold as $Key => $Parameters)

    6174. 

  6174.                     {

    6175. 

  6175.                      if ( $Y <= $Parameters["MinX"] && $Y >= $Parameters["MaxX"])

    6176. 

  6176.                       {

    6177. 

  6177.                        if ( isset($Parameters["R"]) ) { $R = $Parameters["R"]; } else { $R = 0; }

    6178. 

  6178.                        if ( isset($Parameters["G"]) ) { $G = $Parameters["G"]; } else { $G = 0; }

    6179. 

  6179.                        if ( isset($Parameters["B"]) ) { $B = $Parameters["B"]; } else { $B = 0; }

    6180. 

  6180.                        if ( isset($Parameters["Alpha"]) ) { $Alpha = $Parameters["Alpha"]; } else { $Alpha = 100; }

    6181. 

  6181.                        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);

    6182. 

  6182.                       }

    6183. 

  6183.                     }

    6184. 

  6184.                   }

    6185. 

  6185. 

    6186. 

  6186.                  imageline($this->Picture,$LastX,$Y,$X,$Y,$Color);

    6187. 

  6187. 

    6188. 

  6188.                  if ( $Y == $DebugLine) { imageline($this->Picture,$LastX,$Y,$X,$Y,$DebugColor); }

    6189. 

  6189. 

    6190. 

  6190.                  $LastX = OUT_OF_SIGHT;

    6191. 

  6191.                 }

    6192. 

  6192.               }

    6193. 

  6193.             }

    6194. 

  6194.           }

    6195. 

  6195.         }

    6196. 

  6196.       }

    6197. 

  6197. 

    6198. 

  6198.      /* Draw the polygon border, if required */

    6199. 

  6199.      if ( !$NoBorder)

    6200. 

  6200.       {

    6201. 

  6201.        foreach($Segments as $Key => $Coords)

    6202. 

  6202.         $this->drawLine($Coords["X1"],$Coords["Y1"],$Coords["X2"],$Coords["Y2"],array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Threshold"=>$Threshold));

    6203. 

  6203.       }

    6204. 

  6204. 

    6205. 

  6205.      $this->Shadow = $RestoreShadow;

    6206. 

  6206.     }

    6207. 

  6207. 

    6208. 

  6208.    /* Return the abscissa margin */

    6209. 

  6209.    function getAbscissaMargin($Data)

    6210. 

  6210.     {

    6211. 

  6211.      foreach($Data["Axis"] as $AxisID => $Values) { if ( $Values["Identity"] == AXIS_X ) { return($Values["Margin"]); } }

    6212. 

  6212.      return(0);

    6213. 

  6213.     }

    6214. 

  6214. 

    6215. 

  6215.   }

    6216. 

  6216. ?>
    6217.