You are here

pDraw.class.php in Visitors 7

Same filename and directory in other branches
  1. 7.2 pChart/class/pDraw.class.php

File

pChart/class/pDraw.class.php
View source
<?php

/*
    pDraw - class extension with drawing methods

    Version     : 2.1.4
    Made by     : Jean-Damien POGOLOTTI
    Last Update : 19/01/2014

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

                      http://www.pchart.net/license

    You can find the whole class documentation on the pChart web site.
*/
define("DIRECTION_VERTICAL", 690001);
define("DIRECTION_HORIZONTAL", 690002);
define("SCALE_POS_LEFTRIGHT", 690101);
define("SCALE_POS_TOPBOTTOM", 690102);
define("SCALE_MODE_FLOATING", 690201);
define("SCALE_MODE_START0", 690202);
define("SCALE_MODE_ADDALL", 690203);
define("SCALE_MODE_ADDALL_START0", 690204);
define("SCALE_MODE_MANUAL", 690205);
define("SCALE_SKIP_NONE", 690301);
define("SCALE_SKIP_SAME", 690302);
define("SCALE_SKIP_NUMBERS", 690303);
define("TEXT_ALIGN_TOPLEFT", 690401);
define("TEXT_ALIGN_TOPMIDDLE", 690402);
define("TEXT_ALIGN_TOPRIGHT", 690403);
define("TEXT_ALIGN_MIDDLELEFT", 690404);
define("TEXT_ALIGN_MIDDLEMIDDLE", 690405);
define("TEXT_ALIGN_MIDDLERIGHT", 690406);
define("TEXT_ALIGN_BOTTOMLEFT", 690407);
define("TEXT_ALIGN_BOTTOMMIDDLE", 690408);
define("TEXT_ALIGN_BOTTOMRIGHT", 690409);
define("POSITION_TOP", 690501);
define("POSITION_BOTTOM", 690502);
define("LABEL_POS_LEFT", 690601);
define("LABEL_POS_CENTER", 690602);
define("LABEL_POS_RIGHT", 690603);
define("LABEL_POS_TOP", 690604);
define("LABEL_POS_BOTTOM", 690605);
define("LABEL_POS_INSIDE", 690606);
define("LABEL_POS_OUTSIDE", 690607);
define("ORIENTATION_HORIZONTAL", 690701);
define("ORIENTATION_VERTICAL", 690702);
define("ORIENTATION_AUTO", 690703);
define("LEGEND_NOBORDER", 690800);
define("LEGEND_BOX", 690801);
define("LEGEND_ROUND", 690802);
define("LEGEND_VERTICAL", 690901);
define("LEGEND_HORIZONTAL", 690902);
define("LEGEND_FAMILY_BOX", 691051);
define("LEGEND_FAMILY_CIRCLE", 691052);
define("LEGEND_FAMILY_LINE", 691053);
define("DISPLAY_AUTO", 691001);
define("DISPLAY_MANUAL", 691002);
define("LABELING_ALL", 691011);
define("LABELING_DIFFERENT", 691012);
define("BOUND_MIN", 691021);
define("BOUND_MAX", 691022);
define("BOUND_BOTH", 691023);
define("BOUND_LABEL_POS_TOP", 691031);
define("BOUND_LABEL_POS_BOTTOM", 691032);
define("BOUND_LABEL_POS_AUTO", 691033);
define("CAPTION_LEFT_TOP", 691041);
define("CAPTION_RIGHT_BOTTOM", 691042);
define("GRADIENT_SIMPLE", 691051);
define("GRADIENT_EFFECT_CAN", 691052);
define("LABEL_TITLE_NOBACKGROUND", 691061);
define("LABEL_TITLE_BACKGROUND", 691062);
define("LABEL_POINT_NONE", 691071);
define("LABEL_POINT_CIRCLE", 691072);
define("LABEL_POINT_BOX", 691073);
define("ZONE_NAME_ANGLE_AUTO", 691081);
define("PI", 3.14159265);
define("ALL", 69);
define("NONE", 31);
define("AUTO", 690000);
define("OUT_OF_SIGHT", -10000000000000);
class pDraw {

  /* Returns the number of drawable series */
  function countDrawableSeries() {
    $Results = 0;
    $Data = $this->DataSet
      ->getData();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $Results++;
      }
    }
    return $Results;
  }

  /* Fix box coordinates */
  function fixBoxCoordinates($Xa, $Ya, $Xb, $Yb) {
    $X1 = min($Xa, $Xb);
    $Y1 = min($Ya, $Yb);
    $X2 = max($Xa, $Xb);
    $Y2 = max($Ya, $Yb);
    return array(
      $X1,
      $Y1,
      $X2,
      $Y2,
    );
  }

  /* Draw a polygon */
  function drawPolygon($Points, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $NoFill = isset($Format["NoFill"]) ? $Format["NoFill"] : FALSE;
    $NoBorder = isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    $BorderAlpha = isset($Format["Alpha"]) ? $Format["Alpha"] : $Alpha / 2;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $SkipX = isset($Format["SkipX"]) ? $Format["SkipX"] : OUT_OF_SIGHT;
    $SkipY = isset($Format["SkipY"]) ? $Format["SkipY"] : OUT_OF_SIGHT;

    /* Calling the ImageFilledPolygon() function over the $Points array will round it */
    $Backup = $Points;
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    if ($SkipX != OUT_OF_SIGHT) {
      $SkipX = floor($SkipX);
    }
    if ($SkipY != OUT_OF_SIGHT) {
      $SkipY = floor($SkipY);
    }
    $RestoreShadow = $this->Shadow;
    if (!$NoFill) {
      if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
        $this->Shadow = FALSE;
        for ($i = 0; $i <= count($Points) - 1; $i = $i + 2) {
          $Shadow[] = $Points[$i] + $this->ShadowX;
          $Shadow[] = $Points[$i + 1] + $this->ShadowY;
        }
        $this
          ->drawPolygon($Shadow, array(
          "R" => $this->ShadowR,
          "G" => $this->ShadowG,
          "B" => $this->ShadowB,
          "Alpha" => $this->Shadowa,
          "NoBorder" => TRUE,
        ));
      }
      $FillColor = $this
        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
      if (count($Points) >= 6) {
        ImageFilledPolygon($this->Picture, $Points, count($Points) / 2, $FillColor);
      }
    }
    if (!$NoBorder) {
      $Points = $Backup;
      if ($NoFill) {
        $BorderSettings = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
        );
      }
      else {
        $BorderSettings = array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
        );
      }
      for ($i = 0; $i <= count($Points) - 1; $i = $i + 2) {
        if (isset($Points[$i + 2])) {
          if (!($Points[$i] == $Points[$i + 2] && $Points[$i] == $SkipX) && !($Points[$i + 1] == $Points[$i + 3] && $Points[$i + 1] == $SkipY)) {
            $this
              ->drawLine($Points[$i], $Points[$i + 1], $Points[$i + 2], $Points[$i + 3], $BorderSettings);
          }
        }
        else {
          if (!($Points[$i] == $Points[0] && $Points[$i] == $SkipX) && !($Points[$i + 1] == $Points[1] && $Points[$i + 1] == $SkipY)) {
            $this
              ->drawLine($Points[$i], $Points[$i + 1], $Points[0], $Points[1], $BorderSettings);
          }
        }
      }
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Apply AALias correction to the rounded box boundaries */
  function offsetCorrection($Value, $Mode) {
    $Value = round($Value, 1);
    if ($Value == 0 && $Mode == 1) {
      return 0.9;
    }
    if ($Value == 0) {
      return 0;
    }
    if ($Mode == 1) {
      if ($Value == 1) {
        return 0.9;
      }
      if ($Value == 0.1) {
        return 0.9;
      }
      if ($Value == 0.2) {
        return 0.8;
      }
      if ($Value == 0.3) {
        return 0.8;
      }
      if ($Value == 0.4) {
        return 0.7;
      }
      if ($Value == 0.5) {
        return 0.5;
      }
      if ($Value == 0.6) {
        return 0.8;
      }
      if ($Value == 0.7) {
        return 0.7;
      }
      if ($Value == 0.8) {
        return 0.6;
      }
      if ($Value == 0.9) {
        return 0.9;
      }
    }
    if ($Mode == 2) {
      if ($Value == 1) {
        return 0.9;
      }
      if ($Value == 0.1) {
        return 0.1;
      }
      if ($Value == 0.2) {
        return 0.2;
      }
      if ($Value == 0.3) {
        return 0.3;
      }
      if ($Value == 0.4) {
        return 0.4;
      }
      if ($Value == 0.5) {
        return 0.5;
      }
      if ($Value == 0.6) {
        return 0.8;
      }
      if ($Value == 0.7) {
        return 0.7;
      }
      if ($Value == 0.8) {
        return 0.8;
      }
      if ($Value == 0.9) {
        return 0.9;
      }
    }
    if ($Mode == 3) {
      if ($Value == 1) {
        return 0.1;
      }
      if ($Value == 0.1) {
        return 0.1;
      }
      if ($Value == 0.2) {
        return 0.2;
      }
      if ($Value == 0.3) {
        return 0.3;
      }
      if ($Value == 0.4) {
        return 0.4;
      }
      if ($Value == 0.5) {
        return 0.9;
      }
      if ($Value == 0.6) {
        return 0.6;
      }
      if ($Value == 0.7) {
        return 0.7;
      }
      if ($Value == 0.8) {
        return 0.4;
      }
      if ($Value == 0.9) {
        return 0.5;
      }
    }
    if ($Mode == 4) {
      if ($Value == 1) {
        return -1;
      }
      if ($Value == 0.1) {
        return 0.1;
      }
      if ($Value == 0.2) {
        return 0.2;
      }
      if ($Value == 0.3) {
        return 0.3;
      }
      if ($Value == 0.4) {
        return 0.1;
      }
      if ($Value == 0.5) {
        return -0.1;
      }
      if ($Value == 0.6) {
        return 0.8;
      }
      if ($Value == 0.7) {
        return 0.1;
      }
      if ($Value == 0.8) {
        return 0.1;
      }
      if ($Value == 0.9) {
        return 0.1;
      }
    }
  }

  /* Draw a rectangle with rounded corners */
  function drawRoundedRectangle($X1, $Y1, $X2, $Y2, $Radius, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    list($X1, $Y1, $X2, $Y2) = $this
      ->fixBoxCoordinates($X1, $Y1, $X2, $Y2);
    if ($X2 - $X1 < $Radius) {
      $Radius = floor(($X2 - $X1) / 2);
    }
    if ($Y2 - $Y1 < $Radius) {
      $Radius = floor(($Y2 - $Y1) / 2);
    }
    $Color = array(
      "R" => $R,
      "G" => $G,
      "B" => $B,
      "Alpha" => $Alpha,
      "NoBorder" => TRUE,
    );
    if ($Radius <= 0) {
      $this
        ->drawRectangle($X1, $Y1, $X2, $Y2, $Color);
      return 0;
    }
    if ($this->Antialias) {
      $this
        ->drawLine($X1 + $Radius, $Y1, $X2 - $Radius, $Y1, $Color);
      $this
        ->drawLine($X2, $Y1 + $Radius, $X2, $Y2 - $Radius, $Color);
      $this
        ->drawLine($X2 - $Radius, $Y2, $X1 + $Radius, $Y2, $Color);
      $this
        ->drawLine($X1, $Y1 + $Radius, $X1, $Y2 - $Radius, $Color);
    }
    else {
      $Color = $this
        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
      imageline($this->Picture, $X1 + $Radius, $Y1, $X2 - $Radius, $Y1, $Color);
      imageline($this->Picture, $X2, $Y1 + $Radius, $X2, $Y2 - $Radius, $Color);
      imageline($this->Picture, $X2 - $Radius, $Y2, $X1 + $Radius, $Y2, $Color);
      imageline($this->Picture, $X1, $Y1 + $Radius, $X1, $Y2 - $Radius, $Color);
    }
    $Step = 360 / (2 * PI * $Radius);
    for ($i = 0; $i <= 90; $i = $i + $Step) {
      $X = cos(($i + 180) * PI / 180) * $Radius + $X1 + $Radius;
      $Y = sin(($i + 180) * PI / 180) * $Radius + $Y1 + $Radius;
      $this
        ->drawAntialiasPixel($X, $Y, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      $X = cos(($i + 90) * PI / 180) * $Radius + $X1 + $Radius;
      $Y = sin(($i + 90) * PI / 180) * $Radius + $Y2 - $Radius;
      $this
        ->drawAntialiasPixel($X, $Y, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      $X = cos($i * PI / 180) * $Radius + $X2 - $Radius;
      $Y = sin($i * PI / 180) * $Radius + $Y2 - $Radius;
      $this
        ->drawAntialiasPixel($X, $Y, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      $X = cos(($i + 270) * PI / 180) * $Radius + $X2 - $Radius;
      $Y = sin(($i + 270) * PI / 180) * $Radius + $Y1 + $Radius;
      $this
        ->drawAntialiasPixel($X, $Y, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
  }

  /* Draw a rectangle with rounded corners */
  function drawRoundedFilledRectangle($X1, $Y1, $X2, $Y2, $Radius, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;

    /* Temporary fix for AA issue */
    $Y1 = floor($Y1);
    $Y2 = floor($Y2);
    $X1 = floor($X1);
    $X2 = floor($X2);
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    if ($BorderR == -1) {
      $BorderR = $R;
      $BorderG = $G;
      $BorderB = $B;
    }
    list($X1, $Y1, $X2, $Y2) = $this
      ->fixBoxCoordinates($X1, $Y1, $X2, $Y2);
    if ($X2 - $X1 < $Radius * 2) {
      $Radius = floor(($X2 - $X1) / 4);
    }
    if ($Y2 - $Y1 < $Radius * 2) {
      $Radius = floor(($Y2 - $Y1) / 4);
    }
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $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,
      ));
    }
    $Color = array(
      "R" => $R,
      "G" => $G,
      "B" => $B,
      "Alpha" => $Alpha,
      "NoBorder" => TRUE,
    );
    if ($Radius <= 0) {
      $this
        ->drawFilledRectangle($X1, $Y1, $X2, $Y2, $Color);
      return 0;
    }
    $YTop = $Y1 + $Radius;
    $YBottom = $Y2 - $Radius;
    $Step = 360 / (2 * PI * $Radius);
    $Positions = "";
    $Radius--;
    $MinY = "";
    $MaxY = "";
    for ($i = 0; $i <= 90; $i = $i + $Step) {
      $Xp1 = cos(($i + 180) * PI / 180) * $Radius + $X1 + $Radius;
      $Xp2 = cos((90 - $i + 270) * PI / 180) * $Radius + $X2 - $Radius;
      $Yp = floor(sin(($i + 180) * PI / 180) * $Radius + $YTop);
      if ($MinY == "" || $Yp > $MinY) {
        $MinY = $Yp;
      }
      if ($Xp1 <= floor($X1)) {
        $Xp1++;
      }
      if ($Xp2 >= floor($X2)) {
        $Xp2--;
      }
      $Xp1++;
      if (!isset($Positions[$Yp])) {
        $Positions[$Yp]["X1"] = $Xp1;
        $Positions[$Yp]["X2"] = $Xp2;
      }
      else {
        $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"] + $Xp1) / 2;
        $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"] + $Xp2) / 2;
      }
      $Xp1 = cos(($i + 90) * PI / 180) * $Radius + $X1 + $Radius;
      $Xp2 = cos((90 - $i) * PI / 180) * $Radius + $X2 - $Radius;
      $Yp = floor(sin(($i + 90) * PI / 180) * $Radius + $YBottom);
      if ($MaxY == "" || $Yp < $MaxY) {
        $MaxY = $Yp;
      }
      if ($Xp1 <= floor($X1)) {
        $Xp1++;
      }
      if ($Xp2 >= floor($X2)) {
        $Xp2--;
      }
      $Xp1++;
      if (!isset($Positions[$Yp])) {
        $Positions[$Yp]["X1"] = $Xp1;
        $Positions[$Yp]["X2"] = $Xp2;
      }
      else {
        $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"] + $Xp1) / 2;
        $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"] + $Xp2) / 2;
      }
    }
    $ManualColor = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    foreach ($Positions as $Yp => $Bounds) {
      $X1 = $Bounds["X1"];
      $X1Dec = $this
        ->getFirstDecimal($X1);
      if ($X1Dec != 0) {
        $X1 = floor($X1) + 1;
      }
      $X2 = $Bounds["X2"];
      $X2Dec = $this
        ->getFirstDecimal($X2);
      if ($X2Dec != 0) {
        $X2 = floor($X2) - 1;
      }
      imageline($this->Picture, $X1, $Yp, $X2, $Yp, $ManualColor);
    }
    $this
      ->drawFilledRectangle($X1, $MinY + 1, floor($X2), $MaxY - 1, $Color);
    $Radius++;
    $this
      ->drawRoundedRectangle($X1, $Y1, $X2 + 1, $Y2 - 1, $Radius, array(
      "R" => $BorderR,
      "G" => $BorderG,
      "B" => $BorderB,
      "Alpha" => $Alpha,
    ));
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a rectangle with rounded corners */
  function drawRoundedFilledRectangle_deprecated($X1, $Y1, $X2, $Y2, $Radius, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    if ($BorderR == -1) {
      $BorderR = $R;
      $BorderG = $G;
      $BorderB = $B;
    }
    list($X1, $Y1, $X2, $Y2) = $this
      ->fixBoxCoordinates($X1, $Y1, $X2, $Y2);
    if ($X2 - $X1 < $Radius) {
      $Radius = floor(($X2 - $X1 + 2) / 2);
    }
    if ($Y2 - $Y1 < $Radius) {
      $Radius = floor(($Y2 - $Y1 + 2) / 2);
    }
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $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,
      ));
    }
    if ($this
      ->getFirstDecimal($X2) >= 5) {
      $XOffset2 = 1;
    }
    else {
      $XOffset2 = 0;
    }
    if ($this
      ->getFirstDecimal($X1) <= 5) {
      $XOffset1 = 1;
    }
    else {
      $XOffset1 = 0;
    }
    if (!$this->Antialias) {
      $XOffset1 = 1;
      $XOffset2 = 1;
    }
    $YTop = floor($Y1 + $Radius);
    $YBottom = floor($Y2 - $Radius);
    $this
      ->drawFilledRectangle($X1 - $XOffset1, $YTop, $X2 + $XOffset2, $YBottom, array(
      "R" => $R,
      "G" => $G,
      "B" => $B,
      "Alpha" => $Alpha,
      "NoBorder" => TRUE,
    ));
    $Step = 360 / (2 * PI * $Radius);
    $Color = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    $Color2 = $this
      ->allocateColor($this->Picture, 255, 0, 0, $Alpha);
    $Drawn = "";
    if ($Alpha < 100) {
      $Drawn[$YTop] = FALSE;
    }
    if ($Alpha < 100) {
      $Drawn[$YBottom] = TRUE;
    }
    for ($i = 0; $i <= 90; $i = $i + $Step) {
      $Xp1 = cos(($i + 180) * PI / 180) * $Radius + $X1 + $Radius;
      $Xp2 = cos((90 - $i + 270) * PI / 180) * $Radius + $X2 - $Radius;
      $Yp = sin(($i + 180) * PI / 180) * $Radius + $YTop;
      if ($this
        ->getFirstDecimal($Xp1) > 5) {
        $XOffset1 = 1;
      }
      else {
        $XOffset1 = 0;
      }
      if ($this
        ->getFirstDecimal($Xp2) > 5) {
        $XOffset2 = 1;
      }
      else {
        $XOffset2 = 0;
      }
      if ($this
        ->getFirstDecimal($Yp) > 5) {
        $YOffset = 1;
      }
      else {
        $YOffset = 0;
      }
      if (!isset($Drawn[$Yp + $YOffset]) || $Alpha == 100) {
        imageline($this->Picture, $Xp1 + $XOffset1, $Yp + $YOffset, $Xp2 + $XOffset2, $Yp + $YOffset, $Color);
      }
      $Drawn[$Yp + $YOffset] = $Xp2;
      $Xp1 = cos(($i + 90) * PI / 180) * $Radius + $X1 + $Radius;
      $Xp2 = cos((90 - $i) * PI / 180) * $Radius + $X2 - $Radius;
      $Yp = sin(($i + 90) * PI / 180) * $Radius + $YBottom;
      if ($this
        ->getFirstDecimal($Xp1) > 7) {
        $XOffset1 = 1;
      }
      else {
        $XOffset1 = 0;
      }
      if ($this
        ->getFirstDecimal($Xp2) > 7) {
        $XOffset2 = 1;
      }
      else {
        $XOffset2 = 0;
      }
      if ($this
        ->getFirstDecimal($Yp) > 5) {
        $YOffset = 1;
      }
      else {
        $YOffset = 0;
      }
      if (!isset($Drawn[$Yp + $YOffset]) || $Alpha == 100) {
        imageline($this->Picture, $Xp1 + $XOffset1, $Yp + $YOffset, $Xp2 + $XOffset2, $Yp + $YOffset, $Color);
      }
      $Drawn[$Yp + $YOffset] = $Xp2;
    }
    $this
      ->drawRoundedRectangle($X1, $Y1, $X2, $Y2, $Radius, array(
      "R" => $BorderR,
      "G" => $BorderG,
      "B" => $BorderB,
      "Alpha" => $Alpha,
    ));
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a rectangle */
  function drawRectangle($X1, $Y1, $X2, $Y2, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $NoAngle = isset($Format["NoAngle"]) ? $Format["NoAngle"] : FALSE;
    if ($X1 > $X2) {
      list($X1, $X2) = array(
        $X2,
        $X1,
      );
    }
    if ($Y1 > $Y2) {
      list($Y1, $Y2) = array(
        $Y2,
        $Y1,
      );
    }
    if ($this->Antialias) {
      if ($NoAngle) {
        $this
          ->drawLine($X1 + 1, $Y1, $X2 - 1, $Y1, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X2, $Y1 + 1, $X2, $Y2 - 1, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X2 - 1, $Y2, $X1 + 1, $Y2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X1, $Y1 + 1, $X1, $Y2 - 1, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
      }
      else {
        $this
          ->drawLine($X1 + 1, $Y1, $X2 - 1, $Y1, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X2, $Y1, $X2, $Y2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X2 - 1, $Y2, $X1 + 1, $Y2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
        $this
          ->drawLine($X1, $Y1, $X1, $Y2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        ));
      }
    }
    else {
      $Color = $this
        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
      imagerectangle($this->Picture, $X1, $Y1, $X2, $Y2, $Color);
    }
  }

  /* Draw a filled rectangle */
  function drawFilledRectangle($X1, $Y1, $X2, $Y2, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $NoAngle = isset($Format["NoAngle"]) ? $Format["NoAngle"] : NULL;
    $Dash = isset($Format["Dash"]) ? $Format["Dash"] : FALSE;
    $DashStep = isset($Format["DashStep"]) ? $Format["DashStep"] : 4;
    $DashR = isset($Format["DashR"]) ? $Format["DashR"] : 0;
    $DashG = isset($Format["DashG"]) ? $Format["DashG"] : 0;
    $DashB = isset($Format["DashB"]) ? $Format["DashB"] : 0;
    $NoBorder = isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    if ($X1 > $X2) {
      list($X1, $X2) = array(
        $X2,
        $X1,
      );
    }
    if ($Y1 > $Y2) {
      list($Y1, $Y2) = array(
        $Y2,
        $Y1,
      );
    }
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $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,
      ));
    }
    $Color = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    if ($NoAngle) {
      imagefilledrectangle($this->Picture, ceil($X1) + 1, ceil($Y1), floor($X2) - 1, floor($Y2), $Color);
      imageline($this->Picture, ceil($X1), ceil($Y1) + 1, ceil($X1), floor($Y2) - 1, $Color);
      imageline($this->Picture, floor($X2), ceil($Y1) + 1, floor($X2), floor($Y2) - 1, $Color);
    }
    else {
      imagefilledrectangle($this->Picture, ceil($X1), ceil($Y1), floor($X2), floor($Y2), $Color);
    }
    if ($Dash) {
      if ($BorderR != -1) {
        $iX1 = $X1 + 1;
        $iY1 = $Y1 + 1;
        $iX2 = $X2 - 1;
        $iY2 = $Y2 - 1;
      }
      else {
        $iX1 = $X1;
        $iY1 = $Y1;
        $iX2 = $X2;
        $iY2 = $Y2;
      }
      $Color = $this
        ->allocateColor($this->Picture, $DashR, $DashG, $DashB, $Alpha);
      $Y = $iY1 - $DashStep;
      for ($X = $iX1; $X <= $iX2 + ($iY2 - $iY1); $X = $X + $DashStep) {
        $Y = $Y + $DashStep;
        if ($X > $iX2) {
          $Xa = $X - ($X - $iX2);
          $Ya = $iY1 + ($X - $iX2);
        }
        else {
          $Xa = $X;
          $Ya = $iY1;
        }
        if ($Y > $iY2) {
          $Xb = $iX1 + ($Y - $iY2);
          $Yb = $Y - ($Y - $iY2);
        }
        else {
          $Xb = $iX1;
          $Yb = $Y;
        }
        imageline($this->Picture, $Xa, $Ya, $Xb, $Yb, $Color);
      }
    }
    if ($this->Antialias && !$NoBorder) {
      if ($X1 < ceil($X1)) {
        $AlphaA = $Alpha * (ceil($X1) - $X1);
        $Color = $this
          ->allocateColor($this->Picture, $R, $G, $B, $AlphaA);
        imageline($this->Picture, ceil($X1) - 1, ceil($Y1), ceil($X1) - 1, floor($Y2), $Color);
      }
      if ($Y1 < ceil($Y1)) {
        $AlphaA = $Alpha * (ceil($Y1) - $Y1);
        $Color = $this
          ->allocateColor($this->Picture, $R, $G, $B, $AlphaA);
        imageline($this->Picture, ceil($X1), ceil($Y1) - 1, floor($X2), ceil($Y1) - 1, $Color);
      }
      if ($X2 > floor($X2)) {
        $AlphaA = $Alpha * (0.5 - ($X2 - floor($X2)));
        $Color = $this
          ->allocateColor($this->Picture, $R, $G, $B, $AlphaA);
        imageline($this->Picture, floor($X2) + 1, ceil($Y1), floor($X2) + 1, floor($Y2), $Color);
      }
      if ($Y2 > floor($Y2)) {
        $AlphaA = $Alpha * (0.5 - ($Y2 - floor($Y2)));
        $Color = $this
          ->allocateColor($this->Picture, $R, $G, $B, $AlphaA);
        imageline($this->Picture, ceil($X1), floor($Y2) + 1, floor($X2), floor($Y2) + 1, $Color);
      }
    }
    if ($BorderR != -1) {
      $this
        ->drawRectangle($X1, $Y1, $X2, $Y2, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $BorderAlpha,
        "Ticks" => $Ticks,
        "NoAngle" => $NoAngle,
      ));
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a rectangular marker of the specified size */
  function drawRectangleMarker($X, $Y, $Format = "") {
    $Size = isset($Format["Size"]) ? $Format["Size"] : 4;
    $HalfSize = floor($Size / 2);
    $this
      ->drawFilledRectangle($X - $HalfSize, $Y - $HalfSize, $X + $HalfSize, $Y + $HalfSize, $Format);
  }

  /* Drawn a spline based on the bezier function */
  function drawSpline($Coordinates, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Force = isset($Format["Force"]) ? $Format["Force"] : 30;
    $Forces = isset($Format["Forces"]) ? $Format["Forces"] : NULL;
    $ShowC = isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $PathOnly = isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;
    $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    $Cpt = NULL;
    $Mode = NULL;
    $Result = "";
    for ($i = 1; $i <= count($Coordinates) - 1; $i++) {
      $X1 = $Coordinates[$i - 1][0];
      $Y1 = $Coordinates[$i - 1][1];
      $X2 = $Coordinates[$i][0];
      $Y2 = $Coordinates[$i][1];
      if ($Forces != NULL) {
        $Force = $Forces[$i];
      }

      /* First segment */
      if ($i == 1) {
        $Xv1 = $X1;
        $Yv1 = $Y1;
      }
      else {
        $Angle1 = $this
          ->getAngle($XLast, $YLast, $X1, $Y1);
        $Angle2 = $this
          ->getAngle($X1, $Y1, $X2, $Y2);
        $XOff = cos($Angle2 * PI / 180) * $Force + $X1;
        $YOff = sin($Angle2 * PI / 180) * $Force + $Y1;
        $Xv1 = cos($Angle1 * PI / 180) * $Force + $XOff;
        $Yv1 = sin($Angle1 * PI / 180) * $Force + $YOff;
      }

      /* Last segment */
      if ($i == count($Coordinates) - 1) {
        $Xv2 = $X2;
        $Yv2 = $Y2;
      }
      else {
        $Angle1 = $this
          ->getAngle($X2, $Y2, $Coordinates[$i + 1][0], $Coordinates[$i + 1][1]);
        $Angle2 = $this
          ->getAngle($X1, $Y1, $X2, $Y2);
        $XOff = cos(($Angle2 + 180) * PI / 180) * $Force + $X2;
        $YOff = sin(($Angle2 + 180) * PI / 180) * $Force + $Y2;
        $Xv2 = cos(($Angle1 + 180) * PI / 180) * $Force + $XOff;
        $Yv2 = sin(($Angle1 + 180) * PI / 180) * $Force + $YOff;
      }
      $Path = $this
        ->drawBezier($X1, $Y1, $X2, $Y2, $Xv1, $Yv1, $Xv2, $Yv2, $Format);
      if ($PathOnly) {
        $Result[] = $Path;
      }
      $XLast = $X1;
      $YLast = $Y1;
    }
    return $Result;
  }

  /* Draw a bezier curve with two controls points */
  function drawBezier($X1, $Y1, $X2, $Y2, $Xv1, $Yv1, $Xv2, $Yv2, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $ShowC = isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;
    $Segments = isset($Format["Segments"]) ? $Format["Segments"] : NULL;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $NoDraw = isset($Format["NoDraw"]) ? $Format["NoDraw"] : FALSE;
    $PathOnly = isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;
    $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    $DrawArrow = isset($Format["DrawArrow"]) ? $Format["DrawArrow"] : FALSE;
    $ArrowSize = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 10;
    $ArrowRatio = isset($Format["ArrowRatio"]) ? $Format["ArrowRatio"] : 0.5;
    $ArrowTwoHeads = isset($Format["ArrowTwoHeads"]) ? $Format["ArrowTwoHeads"] : FALSE;
    if ($Segments == NULL) {
      $Length = $this
        ->getLength($X1, $Y1, $X2, $Y2);
      $Precision = $Length * 125 / 1000;
    }
    else {
      $Precision = $Segments;
    }
    $P[0]["X"] = $X1;
    $P[0]["Y"] = $Y1;
    $P[1]["X"] = $Xv1;
    $P[1]["Y"] = $Yv1;
    $P[2]["X"] = $Xv2;
    $P[2]["Y"] = $Yv2;
    $P[3]["X"] = $X2;
    $P[3]["Y"] = $Y2;

    /* Compute the bezier points */
    $Q = "";
    $ID = 0;
    $Path = "";
    for ($i = 0; $i <= $Precision; $i = $i + 1) {
      $u = $i / $Precision;
      $C = "";
      $C[0] = (1 - $u) * (1 - $u) * (1 - $u);
      $C[1] = $u * 3 * (1 - $u) * (1 - $u);
      $C[2] = 3 * $u * $u * (1 - $u);
      $C[3] = $u * $u * $u;
      for ($j = 0; $j <= 3; $j++) {
        if (!isset($Q[$ID])) {
          $Q[$ID] = "";
        }
        if (!isset($Q[$ID]["X"])) {
          $Q[$ID]["X"] = 0;
        }
        if (!isset($Q[$ID]["Y"])) {
          $Q[$ID]["Y"] = 0;
        }
        $Q[$ID]["X"] = $Q[$ID]["X"] + $P[$j]["X"] * $C[$j];
        $Q[$ID]["Y"] = $Q[$ID]["Y"] + $P[$j]["Y"] * $C[$j];
      }
      $ID++;
    }
    $Q[$ID]["X"] = $X2;
    $Q[$ID]["Y"] = $Y2;
    if (!$NoDraw) {

      /* Display the control points */
      if ($ShowC && !$PathOnly) {
        $Xv1 = floor($Xv1);
        $Yv1 = floor($Yv1);
        $Xv2 = floor($Xv2);
        $Yv2 = floor($Yv2);
        $this
          ->drawLine($X1, $Y1, $X2, $Y2, array(
          "R" => 0,
          "G" => 0,
          "B" => 0,
          "Alpha" => 30,
        ));
        $MyMarkerSettings = array(
          "R" => 255,
          "G" => 0,
          "B" => 0,
          "BorderR" => 255,
          "BorderB" => 255,
          "BorderG" => 255,
          "Size" => 4,
        );
        $this
          ->drawRectangleMarker($Xv1, $Yv1, $MyMarkerSettings);
        $this
          ->drawText($Xv1 + 4, $Yv1, "v1");
        $MyMarkerSettings = array(
          "R" => 0,
          "G" => 0,
          "B" => 255,
          "BorderR" => 255,
          "BorderB" => 255,
          "BorderG" => 255,
          "Size" => 4,
        );
        $this
          ->drawRectangleMarker($Xv2, $Yv2, $MyMarkerSettings);
        $this
          ->drawText($Xv2 + 4, $Yv2, "v2");
      }

      /* Draw the bezier */
      $LastX = NULL;
      $LastY = NULL;
      $Cpt = NULL;
      $Mode = NULL;
      $ArrowS = NULL;
      foreach ($Q as $Key => $Point) {
        $X = $Point["X"];
        $Y = $Point["Y"];

        /* Get the first segment */
        if ($ArrowS == NULL && $LastX != NULL && $LastY != NULL) {
          $ArrowS["X2"] = $LastX;
          $ArrowS["Y2"] = $LastY;
          $ArrowS["X1"] = $X;
          $ArrowS["Y1"] = $Y;
        }
        if ($LastX != NULL && $LastY != NULL && !$PathOnly) {
          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,
          ));
        }

        /* Get the last segment */
        $ArrowE["X1"] = $LastX;
        $ArrowE["Y1"] = $LastY;
        $ArrowE["X2"] = $X;
        $ArrowE["Y2"] = $Y;
        $LastX = $X;
        $LastY = $Y;
      }
      if ($DrawArrow && !$PathOnly) {
        $ArrowSettings = array(
          "FillR" => $R,
          "FillG" => $G,
          "FillB" => $B,
          "Alpha" => $Alpha,
          "Size" => $ArrowSize,
          "Ratio" => $ArrowRatio,
        );
        if ($ArrowTwoHeads) {
          $this
            ->drawArrow($ArrowS["X1"], $ArrowS["Y1"], $ArrowS["X2"], $ArrowS["Y2"], $ArrowSettings);
        }
        $this
          ->drawArrow($ArrowE["X1"], $ArrowE["Y1"], $ArrowE["X2"], $ArrowE["Y2"], $ArrowSettings);
      }
    }
    return $Q;
  }

  /* Draw a line between two points */
  function drawLine($X1, $Y1, $X2, $Y2, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $Cpt = isset($Format["Cpt"]) ? $Format["Cpt"] : 1;
    $Mode = isset($Format["Mode"]) ? $Format["Mode"] : 1;
    $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    $Threshold = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;
    if ($this->Antialias == FALSE && $Ticks == NULL) {
      if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
        $ShadowColor = $this
          ->allocateColor($this->Picture, $this->ShadowR, $this->ShadowG, $this->ShadowB, $this->Shadowa);
        imageline($this->Picture, $X1 + $this->ShadowX, $Y1 + $this->ShadowY, $X2 + $this->ShadowX, $Y2 + $this->ShadowY, $ShadowColor);
      }
      $Color = $this
        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
      imageline($this->Picture, $X1, $Y1, $X2, $Y2, $Color);
      return 0;
    }
    $Distance = sqrt(($X2 - $X1) * ($X2 - $X1) + ($Y2 - $Y1) * ($Y2 - $Y1));
    if ($Distance == 0) {
      return -1;
    }

    /* Derivative algorithm for overweighted lines, re-route to polygons primitives */
    if ($Weight != NULL) {
      $Angle = $this
        ->getAngle($X1, $Y1, $X2, $Y2);
      $PolySettings = array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
        "BorderAlpha" => $Alpha,
      );
      if ($Ticks == NULL) {
        $Points = "";
        $Points[] = cos(deg2rad($Angle - 90)) * $Weight + $X1;
        $Points[] = sin(deg2rad($Angle - 90)) * $Weight + $Y1;
        $Points[] = cos(deg2rad($Angle + 90)) * $Weight + $X1;
        $Points[] = sin(deg2rad($Angle + 90)) * $Weight + $Y1;
        $Points[] = cos(deg2rad($Angle + 90)) * $Weight + $X2;
        $Points[] = sin(deg2rad($Angle + 90)) * $Weight + $Y2;
        $Points[] = cos(deg2rad($Angle - 90)) * $Weight + $X2;
        $Points[] = sin(deg2rad($Angle - 90)) * $Weight + $Y2;
        $this
          ->drawPolygon($Points, $PolySettings);
      }
      else {
        for ($i = 0; $i <= $Distance; $i = $i + $Ticks * 2) {
          $Xa = ($X2 - $X1) / $Distance * $i + $X1;
          $Ya = ($Y2 - $Y1) / $Distance * $i + $Y1;
          $Xb = ($X2 - $X1) / $Distance * ($i + $Ticks) + $X1;
          $Yb = ($Y2 - $Y1) / $Distance * ($i + $Ticks) + $Y1;
          $Points = "";
          $Points[] = cos(deg2rad($Angle - 90)) * $Weight + $Xa;
          $Points[] = sin(deg2rad($Angle - 90)) * $Weight + $Ya;
          $Points[] = cos(deg2rad($Angle + 90)) * $Weight + $Xa;
          $Points[] = sin(deg2rad($Angle + 90)) * $Weight + $Ya;
          $Points[] = cos(deg2rad($Angle + 90)) * $Weight + $Xb;
          $Points[] = sin(deg2rad($Angle + 90)) * $Weight + $Yb;
          $Points[] = cos(deg2rad($Angle - 90)) * $Weight + $Xb;
          $Points[] = sin(deg2rad($Angle - 90)) * $Weight + $Yb;
          $this
            ->drawPolygon($Points, $PolySettings);
        }
      }
      return 1;
    }
    $XStep = ($X2 - $X1) / $Distance;
    $YStep = ($Y2 - $Y1) / $Distance;
    for ($i = 0; $i <= $Distance; $i++) {
      $X = $i * $XStep + $X1;
      $Y = $i * $YStep + $Y1;
      $Color = array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      );
      if ($Threshold != NULL) {
        foreach ($Threshold as $Key => $Parameters) {
          if ($Y <= $Parameters["MinX"] && $Y >= $Parameters["MaxX"]) {
            if (isset($Parameters["R"])) {
              $RT = $Parameters["R"];
            }
            else {
              $RT = 0;
            }
            if (isset($Parameters["G"])) {
              $GT = $Parameters["G"];
            }
            else {
              $GT = 0;
            }
            if (isset($Parameters["B"])) {
              $BT = $Parameters["B"];
            }
            else {
              $BT = 0;
            }
            if (isset($Parameters["Alpha"])) {
              $AlphaT = $Parameters["Alpha"];
            }
            else {
              $AlphaT = 0;
            }
            $Color = array(
              "R" => $RT,
              "G" => $GT,
              "B" => $BT,
              "Alpha" => $AlphaT,
            );
          }
        }
      }
      if ($Ticks != NULL) {
        if ($Cpt % $Ticks == 0) {
          $Cpt = 0;
          if ($Mode == 1) {
            $Mode = 0;
          }
          else {
            $Mode = 1;
          }
        }
        if ($Mode == 1) {
          $this
            ->drawAntialiasPixel($X, $Y, $Color);
        }
        $Cpt++;
      }
      else {
        $this
          ->drawAntialiasPixel($X, $Y, $Color);
      }
    }
    return array(
      $Cpt,
      $Mode,
    );
  }

  /* Draw a circle */
  function drawCircle($Xc, $Yc, $Height, $Width, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $Height = abs($Height);
    $Width = abs($Width);
    if ($Height == 0) {
      $Height = 1;
    }
    if ($Width == 0) {
      $Width = 1;
    }
    $Xc = floor($Xc);
    $Yc = floor($Yc);
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $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,
      ));
    }
    if ($Width == 0) {
      $Width = $Height;
    }
    if ($R < 0) {
      $R = 0;
    }
    if ($R > 255) {
      $R = 255;
    }
    if ($G < 0) {
      $G = 0;
    }
    if ($G > 255) {
      $G = 255;
    }
    if ($B < 0) {
      $B = 0;
    }
    if ($B > 255) {
      $B = 255;
    }
    $Step = 360 / (2 * PI * max($Width, $Height));
    $Mode = 1;
    $Cpt = 1;
    for ($i = 0; $i <= 360; $i = $i + $Step) {
      $X = cos($i * PI / 180) * $Height + $Xc;
      $Y = sin($i * PI / 180) * $Width + $Yc;
      if ($Ticks != NULL) {
        if ($Cpt % $Ticks == 0) {
          $Cpt = 0;
          if ($Mode == 1) {
            $Mode = 0;
          }
          else {
            $Mode = 1;
          }
        }
        if ($Mode == 1) {
          $this
            ->drawAntialiasPixel($X, $Y, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
          ));
        }
        $Cpt++;
      }
      else {
        $this
          ->drawAntialiasPixel($X, $Y, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
        ));
      }
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a filled circle */
  function drawFilledCircle($X, $Y, $Radius, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    if ($Radius == 0) {
      $Radius = 1;
    }
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    $X = floor($X);
    $Y = floor($Y);
    $Radius = abs($Radius);
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $this
        ->drawFilledCircle($X + $this->ShadowX, $Y + $this->ShadowY, $Radius, array(
        "R" => $this->ShadowR,
        "G" => $this->ShadowG,
        "B" => $this->ShadowB,
        "Alpha" => $this->Shadowa,
        "Ticks" => $Ticks,
      ));
    }
    $this->Mask = "";
    $Color = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    for ($i = 0; $i <= $Radius * 2; $i++) {
      $Slice = sqrt($Radius * $Radius - ($Radius - $i) * ($Radius - $i));
      $XPos = floor($Slice);
      $YPos = $Y + $i - $Radius;
      $AAlias = $Slice - floor($Slice);
      $this->Mask[$X - $XPos][$YPos] = TRUE;
      $this->Mask[$X + $XPos][$YPos] = TRUE;
      imageline($this->Picture, $X - $XPos, $YPos, $X + $XPos, $YPos, $Color);
    }
    if ($this->Antialias) {
      $this
        ->drawCircle($X, $Y, $Radius, $Radius, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
        "Ticks" => $Ticks,
      ));
    }
    $this->Mask = "";
    if ($BorderR != -1) {
      $this
        ->drawCircle($X, $Y, $Radius, $Radius, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $BorderAlpha,
        "Ticks" => $Ticks,
      ));
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Write text */
  function drawText($X, $Y, $Text, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : $this->FontColorR;
    $G = isset($Format["G"]) ? $Format["G"] : $this->FontColorG;
    $B = isset($Format["B"]) ? $Format["B"] : $this->FontColorB;
    $Angle = isset($Format["Angle"]) ? $Format["Angle"] : 0;
    $Align = isset($Format["Align"]) ? $Format["Align"] : TEXT_ALIGN_BOTTOMLEFT;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;
    $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    $ShowOrigine = isset($Format["ShowOrigine"]) ? $Format["ShowOrigine"] : FALSE;
    $TOffset = isset($Format["TOffset"]) ? $Format["TOffset"] : 2;
    $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : FALSE;
    $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : TRUE;
    $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 6;
    $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : FALSE;
    $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 6;
    $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 255;
    $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 255;
    $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 255;
    $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;
    $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
    $BoxBorderR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    $BoxBorderG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    $BoxBorderB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    $BoxBorderAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;
    $NoShadow = isset($Format["NoShadow"]) ? $Format["NoShadow"] : FALSE;
    $Shadow = $this->Shadow;
    if ($NoShadow) {
      $this->Shadow = FALSE;
    }
    if ($BoxSurrounding != "") {
      $BoxBorderR = $BoxR - $BoxSurrounding;
      $BoxBorderG = $BoxG - $BoxSurrounding;
      $BoxBorderB = $BoxB - $BoxSurrounding;
      $BoxBorderAlpha = $BoxAlpha;
    }
    if ($ShowOrigine) {
      $MyMarkerSettings = array(
        "R" => 255,
        "G" => 0,
        "B" => 0,
        "BorderR" => 255,
        "BorderB" => 255,
        "BorderG" => 255,
        "Size" => 4,
      );
      $this
        ->drawRectangleMarker($X, $Y, $MyMarkerSettings);
    }
    $TxtPos = $this
      ->getTextBox($X, $Y, $FontName, $FontSize, $Angle, $Text);
    if ($DrawBox && ($Angle == 0 || $Angle == 90 || $Angle == 180 || $Angle == 270)) {
      $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;
      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;
      }
      $X1 = min($TxtPos[0]["X"], $TxtPos[1]["X"], $TxtPos[2]["X"], $TxtPos[3]["X"]) - $BorderOffset + 3;
      $Y1 = min($TxtPos[0]["Y"], $TxtPos[1]["Y"], $TxtPos[2]["Y"], $TxtPos[3]["Y"]) - $BorderOffset;
      $X2 = max($TxtPos[0]["X"], $TxtPos[1]["X"], $TxtPos[2]["X"], $TxtPos[3]["X"]) + $BorderOffset + 3;
      $Y2 = max($TxtPos[0]["Y"], $TxtPos[1]["Y"], $TxtPos[2]["Y"], $TxtPos[3]["Y"]) + $BorderOffset - 3;
      $X1 = $X1 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];
      $Y1 = $Y1 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];
      $X2 = $X2 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];
      $Y2 = $Y2 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];
      $Settings = array(
        "R" => $BoxR,
        "G" => $BoxG,
        "B" => $BoxB,
        "Alpha" => $BoxAlpha,
        "BorderR" => $BoxBorderR,
        "BorderG" => $BoxBorderG,
        "BorderB" => $BoxBorderB,
        "BorderAlpha" => $BoxBorderAlpha,
      );
      if ($BoxRounded) {
        $this
          ->drawRoundedFilledRectangle($X1, $Y1, $X2, $Y2, $RoundedRadius, $Settings);
      }
      else {
        $this
          ->drawFilledRectangle($X1, $Y1, $X2, $Y2, $Settings);
      }
    }
    $X = $X - $TxtPos[$Align]["X"] + $X;
    $Y = $Y - $TxtPos[$Align]["Y"] + $Y;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $C_ShadowColor = $this
        ->allocateColor($this->Picture, $this->ShadowR, $this->ShadowG, $this->ShadowB, $this->Shadowa);
      imagettftext($this->Picture, $FontSize, $Angle, $X + $this->ShadowX, $Y + $this->ShadowY, $C_ShadowColor, $FontName, $Text);
    }
    $C_TextColor = $this
      ->AllocateColor($this->Picture, $R, $G, $B, $Alpha);
    imagettftext($this->Picture, $FontSize, $Angle, $X, $Y, $C_TextColor, $FontName, $Text);
    $this->Shadow = $Shadow;
    return $TxtPos;
  }

  /* Draw a gradient within a defined area */
  function drawGradientArea($X1, $Y1, $X2, $Y2, $Direction, $Format = "") {
    $StartR = isset($Format["StartR"]) ? $Format["StartR"] : 90;
    $StartG = isset($Format["StartG"]) ? $Format["StartG"] : 90;
    $StartB = isset($Format["StartB"]) ? $Format["StartB"] : 90;
    $EndR = isset($Format["EndR"]) ? $Format["EndR"] : 0;
    $EndG = isset($Format["EndG"]) ? $Format["EndG"] : 0;
    $EndB = isset($Format["EndB"]) ? $Format["EndB"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Levels = isset($Format["Levels"]) ? $Format["Levels"] : NULL;
    $Shadow = $this->Shadow;
    $this->Shadow = FALSE;
    if ($StartR == $EndR && $StartG == $EndG && $StartB == $EndB) {
      $this
        ->drawFilledRectangle($X1, $Y1, $X2, $Y2, array(
        "R" => $StartR,
        "G" => $StartG,
        "B" => $StartB,
        "Alpha" => $Alpha,
      ));
      return 0;
    }
    if ($Levels != NULL) {
      $EndR = $StartR + $Levels;
      $EndG = $StartG + $Levels;
      $EndB = $StartB + $Levels;
    }
    if ($X1 > $X2) {
      list($X1, $X2) = array(
        $X2,
        $X1,
      );
    }
    if ($Y1 > $Y2) {
      list($Y1, $Y2) = array(
        $Y2,
        $Y1,
      );
    }
    if ($Direction == DIRECTION_VERTICAL) {
      $Width = abs($Y2 - $Y1);
    }
    if ($Direction == DIRECTION_HORIZONTAL) {
      $Width = abs($X2 - $X1);
    }
    $Step = max(abs($EndR - $StartR), abs($EndG - $StartG), abs($EndB - $StartB));
    $StepSize = $Width / $Step;
    $RStep = ($EndR - $StartR) / $Step;
    $GStep = ($EndG - $StartG) / $Step;
    $BStep = ($EndB - $StartB) / $Step;
    $R = $StartR;
    $G = $StartG;
    $B = $StartB;
    switch ($Direction) {
      case DIRECTION_VERTICAL:
        $StartY = $Y1;
        $EndY = floor($Y2) + 1;
        $LastY2 = $StartY;
        for ($i = 0; $i <= $Step; $i++) {
          $Y2 = floor($StartY + $i * $StepSize);
          if ($Y2 > $EndY) {
            $Y2 = $EndY;
          }
          if ($Y1 != $Y2 && $Y1 < $Y2 || $Y2 == $EndY) {
            $Color = array(
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Alpha" => $Alpha,
            );
            $this
              ->drawFilledRectangle($X1, $Y1, $X2, $Y2, $Color);
            $LastY2 = max($LastY2, $Y2);
            $Y1 = $Y2 + 1;
          }
          $R = $R + $RStep;
          $G = $G + $GStep;
          $B = $B + $BStep;
        }
        if ($LastY2 < $EndY && isset($Color)) {
          for ($i = $LastY2 + 1; $i <= $EndY; $i++) {
            $this
              ->drawLine($X1, $i, $X2, $i, $Color);
          }
        }
        break;
      case DIRECTION_HORIZONTAL:
        $StartX = $X1;
        $EndX = $X2;
        for ($i = 0; $i <= $Step; $i++) {
          $X2 = floor($StartX + $i * $StepSize);
          if ($X2 > $EndX) {
            $X2 = $EndX;
          }
          if ($X1 != $X2 && $X1 < $X2 || $X2 == $EndX) {
            $Color = array(
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Alpha" => $Alpha,
            );
            $this
              ->drawFilledRectangle($X1, $Y1, $X2, $Y2, $Color);
            $X1 = $X2 + 1;
          }
          $R = $R + $RStep;
          $G = $G + $GStep;
          $B = $B + $BStep;
        }
        if ($X2 < $EndX && isset($Color)) {
          $this
            ->drawFilledRectangle($X2, $Y1, $EndX, $Y2, $Color);
        }
        break;
    }
    $this->Shadow = $Shadow;
  }

  /* Draw an aliased pixel */
  function drawAntialiasPixel($X, $Y, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    if ($X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize) {
      return -1;
    }
    if ($R < 0) {
      $R = 0;
    }
    if ($R > 255) {
      $R = 255;
    }
    if ($G < 0) {
      $G = 0;
    }
    if ($G > 255) {
      $G = 255;
    }
    if ($B < 0) {
      $B = 0;
    }
    if ($B > 255) {
      $B = 255;
    }
    if (!$this->Antialias) {
      if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
        $ShadowColor = $this
          ->allocateColor($this->Picture, $this->ShadowR, $this->ShadowG, $this->ShadowB, $this->Shadowa);
        imagesetpixel($this->Picture, $X + $this->ShadowX, $Y + $this->ShadowY, $ShadowColor);
      }
      $PlotColor = $this
        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
      imagesetpixel($this->Picture, $X, $Y, $PlotColor);
      return 0;
    }
    $Plot = "";
    $Xi = floor($X);
    $Yi = floor($Y);
    if ($Xi == $X && $Yi == $Y) {
      if ($Alpha == 100) {
        $this
          ->drawAlphaPixel($X, $Y, 100, $R, $G, $B);
      }
      else {
        $this
          ->drawAlphaPixel($X, $Y, $Alpha, $R, $G, $B);
      }
    }
    else {
      $Alpha1 = (1 - ($X - floor($X))) * (1 - ($Y - floor($Y))) * 100 / 100 * $Alpha;
      if ($Alpha1 > $this->AntialiasQuality) {
        $this
          ->drawAlphaPixel($Xi, $Yi, $Alpha1, $R, $G, $B);
      }
      $Alpha2 = ($X - floor($X)) * (1 - ($Y - floor($Y))) * 100 / 100 * $Alpha;
      if ($Alpha2 > $this->AntialiasQuality) {
        $this
          ->drawAlphaPixel($Xi + 1, $Yi, $Alpha2, $R, $G, $B);
      }
      $Alpha3 = (1 - ($X - floor($X))) * ($Y - floor($Y)) * 100 / 100 * $Alpha;
      if ($Alpha3 > $this->AntialiasQuality) {
        $this
          ->drawAlphaPixel($Xi, $Yi + 1, $Alpha3, $R, $G, $B);
      }
      $Alpha4 = ($X - floor($X)) * ($Y - floor($Y)) * 100 / 100 * $Alpha;
      if ($Alpha4 > $this->AntialiasQuality) {
        $this
          ->drawAlphaPixel($Xi + 1, $Yi + 1, $Alpha4, $R, $G, $B);
      }
    }
  }

  /* Draw a semi-transparent pixel */
  function drawAlphaPixel($X, $Y, $Alpha, $R, $G, $B) {
    if (isset($this->Mask[$X])) {
      if (isset($this->Mask[$X][$Y])) {
        return 0;
      }
    }
    if ($X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize) {
      return -1;
    }
    if ($R < 0) {
      $R = 0;
    }
    if ($R > 255) {
      $R = 255;
    }
    if ($G < 0) {
      $G = 0;
    }
    if ($G > 255) {
      $G = 255;
    }
    if ($B < 0) {
      $B = 0;
    }
    if ($B > 255) {
      $B = 255;
    }
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $AlphaFactor = floor($Alpha / 100 * $this->Shadowa);
      $ShadowColor = $this
        ->allocateColor($this->Picture, $this->ShadowR, $this->ShadowG, $this->ShadowB, $AlphaFactor);
      imagesetpixel($this->Picture, $X + $this->ShadowX, $Y + $this->ShadowY, $ShadowColor);
    }
    $C_Aliased = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    imagesetpixel($this->Picture, $X, $Y, $C_Aliased);
  }

  /* Convert apha to base 10 */
  function convertAlpha($AlphaValue) {
    return 127 / 100 * (100 - $AlphaValue);
  }

  /* Allocate a color with transparency */
  function allocateColor($Picture, $R, $G, $B, $Alpha = 100) {
    if ($R < 0) {
      $R = 0;
    }
    if ($R > 255) {
      $R = 255;
    }
    if ($G < 0) {
      $G = 0;
    }
    if ($G > 255) {
      $G = 255;
    }
    if ($B < 0) {
      $B = 0;
    }
    if ($B > 255) {
      $B = 255;
    }
    if ($Alpha < 0) {
      $Alpha = 0;
    }
    if ($Alpha > 100) {
      $Alpha = 100;
    }
    $Alpha = $this
      ->convertAlpha($Alpha);
    return imagecolorallocatealpha($Picture, $R, $G, $B, $Alpha);
  }

  /* Load a PNG file and draw it over the chart */
  function drawFromPNG($X, $Y, $FileName) {
    $this
      ->drawFromPicture(1, $FileName, $X, $Y);
  }

  /* Load a GIF file and draw it over the chart */
  function drawFromGIF($X, $Y, $FileName) {
    $this
      ->drawFromPicture(2, $FileName, $X, $Y);
  }

  /* Load a JPEG file and draw it over the chart */
  function drawFromJPG($X, $Y, $FileName) {
    $this
      ->drawFromPicture(3, $FileName, $X, $Y);
  }
  function getPicInfo($FileName) {
    $Infos = getimagesize($FileName);
    $Width = $Infos[0];
    $Height = $Infos[1];
    $Type = $Infos["mime"];
    if ($Type == "image/png") {
      $Type = 1;
    }
    if ($Type == "image/gif") {
      $Type = 2;
    }
    if ($Type == "image/jpeg ") {
      $Type = 3;
    }
    return array(
      $Width,
      $Height,
      $Type,
    );
  }

  /* Generic loader function for external pictures */
  function drawFromPicture($PicType, $FileName, $X, $Y) {
    if (file_exists($FileName)) {
      list($Width, $Height) = $this
        ->getPicInfo($FileName);
      if ($PicType == 1) {
        $Raster = imagecreatefrompng($FileName);
      }
      elseif ($PicType == 2) {
        $Raster = imagecreatefromgif($FileName);
      }
      elseif ($PicType == 3) {
        $Raster = imagecreatefromjpeg($FileName);
      }
      else {
        return 0;
      }
      $RestoreShadow = $this->Shadow;
      if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
        $this->Shadow = FALSE;
        if ($PicType == 3) {
          $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,
          ));
        }
        else {
          $TranparentID = imagecolortransparent($Raster);
          for ($Xc = 0; $Xc <= $Width - 1; $Xc++) {
            for ($Yc = 0; $Yc <= $Height - 1; $Yc++) {
              $RGBa = imagecolorat($Raster, $Xc, $Yc);
              $Values = imagecolorsforindex($Raster, $RGBa);
              if ($Values["alpha"] < 120) {
                $AlphaFactor = floor($this->Shadowa / 100 * (100 / 127 * (127 - $Values["alpha"])));
                $this
                  ->drawAlphaPixel($X + $Xc + $this->ShadowX, $Y + $Yc + $this->ShadowY, $AlphaFactor, $this->ShadowR, $this->ShadowG, $this->ShadowB);
              }
            }
          }
        }
      }
      $this->Shadow = $RestoreShadow;
      imagecopy($this->Picture, $Raster, $X, $Y, 0, 0, $Width, $Height);
      imagedestroy($Raster);
    }
  }

  /* Draw an arrow */
  function drawArrow($X1, $Y1, $X2, $Y2, $Format = "") {
    $FillR = isset($Format["FillR"]) ? $Format["FillR"] : 0;
    $FillG = isset($Format["FillG"]) ? $Format["FillG"] : 0;
    $FillB = isset($Format["FillB"]) ? $Format["FillB"] : 0;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $FillR;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $FillG;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $FillB;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Size = isset($Format["Size"]) ? $Format["Size"] : 10;
    $Ratio = isset($Format["Ratio"]) ? $Format["Ratio"] : 0.5;
    $TwoHeads = isset($Format["TwoHeads"]) ? $Format["TwoHeads"] : FALSE;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : FALSE;

    /* Calculate the line angle */
    $Angle = $this
      ->getAngle($X1, $Y1, $X2, $Y2);

    /* Override Shadow support, this will be managed internally */
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0) {
      $this->Shadow = FALSE;
      $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,
      ));
    }

    /* Draw the 1st Head */
    $TailX = cos(($Angle - 180) * PI / 180) * $Size + $X2;
    $TailY = sin(($Angle - 180) * PI / 180) * $Size + $Y2;
    $Points = "";
    $Points[] = $X2;
    $Points[] = $Y2;
    $Points[] = cos(($Angle - 90) * PI / 180) * $Size * $Ratio + $TailX;
    $Points[] = sin(($Angle - 90) * PI / 180) * $Size * $Ratio + $TailY;
    $Points[] = cos(($Angle - 270) * PI / 180) * $Size * $Ratio + $TailX;
    $Points[] = sin(($Angle - 270) * PI / 180) * $Size * $Ratio + $TailY;
    $Points[] = $X2;
    $Points[] = $Y2;

    /* Visual correction */
    if ($Angle == 180 || $Angle == 360) {
      $Points[4] = $Points[2];
    }
    if ($Angle == 90 || $Angle == 270) {
      $Points[5] = $Points[3];
    }
    $ArrowColor = $this
      ->allocateColor($this->Picture, $FillR, $FillG, $FillB, $Alpha);
    ImageFilledPolygon($this->Picture, $Points, 4, $ArrowColor);
    $this
      ->drawLine($Points[0], $Points[1], $Points[2], $Points[3], array(
      "R" => $BorderR,
      "G" => $BorderG,
      "B" => $BorderB,
      "Alpha" => $Alpha,
    ));
    $this
      ->drawLine($Points[2], $Points[3], $Points[4], $Points[5], array(
      "R" => $BorderR,
      "G" => $BorderG,
      "B" => $BorderB,
      "Alpha" => $Alpha,
    ));
    $this
      ->drawLine($Points[0], $Points[1], $Points[4], $Points[5], array(
      "R" => $BorderR,
      "G" => $BorderG,
      "B" => $BorderB,
      "Alpha" => $Alpha,
    ));

    /* Draw the second head */
    if ($TwoHeads) {
      $Angle = $this
        ->getAngle($X2, $Y2, $X1, $Y1);
      $TailX2 = cos(($Angle - 180) * PI / 180) * $Size + $X1;
      $TailY2 = sin(($Angle - 180) * PI / 180) * $Size + $Y1;
      $Points = "";
      $Points[] = $X1;
      $Points[] = $Y1;
      $Points[] = cos(($Angle - 90) * PI / 180) * $Size * $Ratio + $TailX2;
      $Points[] = sin(($Angle - 90) * PI / 180) * $Size * $Ratio + $TailY2;
      $Points[] = cos(($Angle - 270) * PI / 180) * $Size * $Ratio + $TailX2;
      $Points[] = sin(($Angle - 270) * PI / 180) * $Size * $Ratio + $TailY2;
      $Points[] = $X1;
      $Points[] = $Y1;

      /* Visual correction */
      if ($Angle == 180 || $Angle == 360) {
        $Points[4] = $Points[2];
      }
      if ($Angle == 90 || $Angle == 270) {
        $Points[5] = $Points[3];
      }
      $ArrowColor = $this
        ->allocateColor($this->Picture, $FillR, $FillG, $FillB, $Alpha);
      ImageFilledPolygon($this->Picture, $Points, 4, $ArrowColor);
      $this
        ->drawLine($Points[0], $Points[1], $Points[2], $Points[3], array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
      ));
      $this
        ->drawLine($Points[2], $Points[3], $Points[4], $Points[5], array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
      ));
      $this
        ->drawLine($Points[0], $Points[1], $Points[4], $Points[5], array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
      ));
      $this
        ->drawLine($TailX, $TailY, $TailX2, $TailY2, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
        "Ticks" => $Ticks,
      ));
    }
    else {
      $this
        ->drawLine($X1, $Y1, $TailX, $TailY, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
        "Ticks" => $Ticks,
      ));
    }

    /* Re-enable shadows */
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a label with associated arrow */
  function drawArrowLabel($X1, $Y1, $Text, $Format = "") {
    $FillR = isset($Format["FillR"]) ? $Format["FillR"] : 0;
    $FillG = isset($Format["FillG"]) ? $Format["FillG"] : 0;
    $FillB = isset($Format["FillB"]) ? $Format["FillB"] : 0;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $FillR;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $FillG;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $FillB;
    $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Length = isset($Format["Length"]) ? $Format["Length"] : 50;
    $Angle = isset($Format["Angle"]) ? $Format["Angle"] : 315;
    $Size = isset($Format["Size"]) ? $Format["Size"] : 10;
    $Position = isset($Format["Position"]) ? $Format["Position"] : POSITION_TOP;
    $RoundPos = isset($Format["RoundPos"]) ? $Format["RoundPos"] : FALSE;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $Angle = $Angle % 360;
    $X2 = sin(($Angle + 180) * PI / 180) * $Length + $X1;
    $Y2 = cos(($Angle + 180) * PI / 180) * $Length + $Y1;
    if ($RoundPos && $Angle > 0 && $Angle < 180) {
      $Y2 = ceil($Y2);
    }
    if ($RoundPos && $Angle > 180) {
      $Y2 = floor($Y2);
    }
    $this
      ->drawArrow($X2, $Y2, $X1, $Y1, $Format);
    $Size = imagettfbbox($FontSize, 0, $FontName, $Text);
    $TxtWidth = max(abs($Size[2] - $Size[0]), abs($Size[0] - $Size[6]));
    $TxtHeight = max(abs($Size[1] - $Size[7]), abs($Size[3] - $Size[1]));
    if ($Angle > 0 && $Angle < 180) {
      $this
        ->drawLine($X2, $Y2, $X2 - $TxtWidth, $Y2, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
        "Ticks" => $Ticks,
      ));
      if ($Position == POSITION_TOP) {
        $this
          ->drawText($X2, $Y2 - 2, $Text, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $Alpha,
          "Align" => TEXT_ALIGN_BOTTOMRIGHT,
        ));
      }
      else {
        $this
          ->drawText($X2, $Y2 + 4, $Text, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $Alpha,
          "Align" => TEXT_ALIGN_TOPRIGHT,
        ));
      }
    }
    else {
      $this
        ->drawLine($X2, $Y2, $X2 + $TxtWidth, $Y2, array(
        "R" => $BorderR,
        "G" => $BorderG,
        "B" => $BorderB,
        "Alpha" => $Alpha,
        "Ticks" => $Ticks,
      ));
      if ($Position == POSITION_TOP) {
        $this
          ->drawText($X2, $Y2 - 2, $Text, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $Alpha,
        ));
      }
      else {
        $this
          ->drawText($X2, $Y2 + 4, $Text, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $Alpha,
          "Align" => TEXT_ALIGN_TOPLEFT,
        ));
      }
    }
  }

  /* Draw a progress bar filled with specified % */
  function drawProgress($X, $Y, $Percent, $Format = "") {
    if ($Percent > 100) {
      $Percent = 100;
    }
    if ($Percent < 0) {
      $Percent = 0;
    }
    $Width = isset($Format["Width"]) ? $Format["Width"] : 200;
    $Height = isset($Format["Height"]) ? $Format["Height"] : 20;
    $Orientation = isset($Format["Orientation"]) ? $Format["Orientation"] : ORIENTATION_HORIZONTAL;
    $ShowLabel = isset($Format["ShowLabel"]) ? $Format["ShowLabel"] : FALSE;
    $LabelPos = isset($Format["LabelPos"]) ? $Format["LabelPos"] : LABEL_POS_INSIDE;
    $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 10;
    $R = isset($Format["R"]) ? $Format["R"] : 130;
    $G = isset($Format["G"]) ? $Format["G"] : 130;
    $B = isset($Format["B"]) ? $Format["B"] : 130;
    $RFade = isset($Format["RFade"]) ? $Format["RFade"] : -1;
    $GFade = isset($Format["GFade"]) ? $Format["GFade"] : -1;
    $BFade = isset($Format["BFade"]) ? $Format["BFade"] : -1;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 0;
    $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 0;
    $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 0;
    $BoxBackR = isset($Format["BoxBackR"]) ? $Format["BoxBackR"] : 255;
    $BoxBackG = isset($Format["BoxBackG"]) ? $Format["BoxBackG"] : 255;
    $BoxBackB = isset($Format["BoxBackB"]) ? $Format["BoxBackB"] : 255;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : NULL;
    $NoAngle = isset($Format["NoAngle"]) ? $Format["NoAngle"] : FALSE;
    if ($RFade != -1 && $GFade != -1 && $BFade != -1) {
      $RFade = ($RFade - $R) / 100 * $Percent + $R;
      $GFade = ($GFade - $G) / 100 * $Percent + $G;
      $BFade = ($BFade - $B) / 100 * $Percent + $B;
    }
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    if ($BoxSurrounding != NULL) {
      $BoxBorderR = $BoxBackR + $Surrounding;
      $BoxBorderG = $BoxBackG + $Surrounding;
      $BoxBorderB = $BoxBackB + $Surrounding;
    }
    if ($Orientation == ORIENTATION_VERTICAL) {
      $InnerHeight = ($Height - 2) / 100 * $Percent;
      $this
        ->drawFilledRectangle($X, $Y, $X + $Width, $Y - $Height, array(
        "R" => $BoxBackR,
        "G" => $BoxBackG,
        "B" => $BoxBackB,
        "BorderR" => $BoxBorderR,
        "BorderG" => $BoxBorderG,
        "BorderB" => $BoxBorderB,
        "NoAngle" => $NoAngle,
      ));
      $RestoreShadow = $this->Shadow;
      $this->Shadow = FALSE;
      if ($RFade != -1 && $GFade != -1 && $BFade != -1) {
        $GradientOptions = array(
          "StartR" => $RFade,
          "StartG" => $GFade,
          "StartB" => $BFade,
          "EndR" => $R,
          "EndG" => $G,
          "EndB" => $B,
        );
        $this
          ->drawGradientArea($X + 1, $Y - 1, $X + $Width - 1, $Y - $InnerHeight, DIRECTION_VERTICAL, $GradientOptions);
        if ($Surrounding) {
          $this
            ->drawRectangle($X + 1, $Y - 1, $X + $Width - 1, $Y - $InnerHeight, array(
            "R" => 255,
            "G" => 255,
            "B" => 255,
            "Alpha" => $Surrounding,
          ));
        }
      }
      else {
        $this
          ->drawFilledRectangle($X + 1, $Y - 1, $X + $Width - 1, $Y - $InnerHeight, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "BorderR" => $BorderR,
          "BorderG" => $BorderG,
          "BorderB" => $BorderB,
        ));
      }
      $this->Shadow = $RestoreShadow;
      if ($ShowLabel && $LabelPos == LABEL_POS_BOTTOM) {
        $this
          ->drawText($X + $Width / 2, $Y + $Margin, $Percent . "%", array(
          "Align" => TEXT_ALIGN_TOPMIDDLE,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_TOP) {
        $this
          ->drawText($X + $Width / 2, $Y - $Height - $Margin, $Percent . "%", array(
          "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_INSIDE) {
        $this
          ->drawText($X + $Width / 2, $Y - $InnerHeight - $Margin, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLELEFT,
          "Angle" => 90,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_CENTER) {
        $this
          ->drawText($X + $Width / 2, $Y - $Height / 2, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
          "Angle" => 90,
        ));
      }
    }
    else {
      if ($Percent == 100) {
        $InnerWidth = $Width - 1;
      }
      else {
        $InnerWidth = ($Width - 2) / 100 * $Percent;
      }
      $this
        ->drawFilledRectangle($X, $Y, $X + $Width, $Y + $Height, array(
        "R" => $BoxBackR,
        "G" => $BoxBackG,
        "B" => $BoxBackB,
        "BorderR" => $BoxBorderR,
        "BorderG" => $BoxBorderG,
        "BorderB" => $BoxBorderB,
        "NoAngle" => $NoAngle,
      ));
      $RestoreShadow = $this->Shadow;
      $this->Shadow = FALSE;
      if ($RFade != -1 && $GFade != -1 && $BFade != -1) {
        $GradientOptions = array(
          "StartR" => $R,
          "StartG" => $G,
          "StartB" => $B,
          "EndR" => $RFade,
          "EndG" => $GFade,
          "EndB" => $BFade,
        );
        $this
          ->drawGradientArea($X + 1, $Y + 1, $X + $InnerWidth, $Y + $Height - 1, DIRECTION_HORIZONTAL, $GradientOptions);
        if ($Surrounding) {
          $this
            ->drawRectangle($X + 1, $Y + 1, $X + $InnerWidth, $Y + $Height - 1, array(
            "R" => 255,
            "G" => 255,
            "B" => 255,
            "Alpha" => $Surrounding,
          ));
        }
      }
      else {
        $this
          ->drawFilledRectangle($X + 1, $Y + 1, $X + $InnerWidth, $Y + $Height - 1, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "BorderR" => $BorderR,
          "BorderG" => $BorderG,
          "BorderB" => $BorderB,
        ));
      }
      $this->Shadow = $RestoreShadow;
      if ($ShowLabel && $LabelPos == LABEL_POS_LEFT) {
        $this
          ->drawText($X - $Margin, $Y + $Height / 2, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLERIGHT,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_RIGHT) {
        $this
          ->drawText($X + $Width + $Margin, $Y + $Height / 2, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLELEFT,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_CENTER) {
        $this
          ->drawText($X + $Width / 2, $Y + $Height / 2, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
        ));
      }
      if ($ShowLabel && $LabelPos == LABEL_POS_INSIDE) {
        $this
          ->drawText($X + $InnerWidth + $Margin, $Y + $Height / 2, $Percent . "%", array(
          "Align" => TEXT_ALIGN_MIDDLELEFT,
        ));
      }
    }
  }

  /* Get the legend box size */
  function getLegendSize($Format = "") {
    $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    $BoxSize = isset($Format["BoxSize"]) ? $Format["BoxSize"] : 5;
    $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 5;
    $Style = isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;
    $Mode = isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;
    $BoxWidth = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;
    $BoxHeight = isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;
    $IconAreaWidth = isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;
    $IconAreaHeight = isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;
    $XSpacing = isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;
    $Data = $this->DataSet
      ->getData();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && isset($Serie["Picture"])) {
        list($PicWidth, $PicHeight) = $this
          ->getPicInfo($Serie["Picture"]);
        if ($IconAreaWidth < $PicWidth) {
          $IconAreaWidth = $PicWidth;
        }
        if ($IconAreaHeight < $PicHeight) {
          $IconAreaHeight = $PicHeight;
        }
      }
    }
    $YStep = max($this->FontSize, $IconAreaHeight) + 5;
    $XStep = $IconAreaWidth + 5;
    $XStep = $XSpacing;
    $X = 100;
    $Y = 100;
    $Boundaries = "";
    $Boundaries["L"] = $X;
    $Boundaries["T"] = $Y;
    $Boundaries["R"] = 0;
    $Boundaries["B"] = 0;
    $vY = $Y;
    $vX = $X;
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        if ($Mode == LEGEND_VERTICAL) {
          $BoxArray = $this
            ->getTextBox($vX + $IconAreaWidth + 4, $vY + $IconAreaHeight / 2, $FontName, $FontSize, 0, $Serie["Description"]);
          if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
            $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
          }
          if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
            $Boundaries["R"] = $BoxArray[1]["X"] + 2;
          }
          if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
            $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
          }
          $Lines = preg_split("/\n/", $Serie["Description"]);
          $vY = $vY + max($this->FontSize * count($Lines), $IconAreaHeight) + 5;
        }
        elseif ($Mode == LEGEND_HORIZONTAL) {
          $Lines = preg_split("/\n/", $Serie["Description"]);
          $Width = "";
          foreach ($Lines as $Key => $Value) {
            $BoxArray = $this
              ->getTextBox($vX + $IconAreaWidth + 6, $Y + $IconAreaHeight / 2 + ($this->FontSize + 3) * $Key, $FontName, $FontSize, 0, $Value);
            if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
              $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
            }
            if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
              $Boundaries["R"] = $BoxArray[1]["X"] + 2;
            }
            if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
              $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
            }
            $Width[] = $BoxArray[1]["X"];
          }
          $vX = max($Width) + $XStep;
        }
      }
    }
    $vY = $vY - $YStep;
    $vX = $vX - $XStep;
    $TopOffset = $Y - $Boundaries["T"];
    if ($Boundaries["B"] - ($vY + $IconAreaHeight) < $TopOffset) {
      $Boundaries["B"] = $vY + $IconAreaHeight + $TopOffset;
    }
    $Width = $Boundaries["R"] + $Margin - ($Boundaries["L"] - $Margin);
    $Height = $Boundaries["B"] + $Margin - ($Boundaries["T"] - $Margin);
    return array(
      "Width" => $Width,
      "Height" => $Height,
    );
  }

  /* Draw the legend of the active series */
  function drawLegend($X, $Y, $Format = "") {
    $Family = isset($Format["Family"]) ? $Format["Family"] : LEGEND_FAMILY_BOX;
    $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    $FontR = isset($Format["FontR"]) ? $Format["FontR"] : $this->FontColorR;
    $FontG = isset($Format["FontG"]) ? $Format["FontG"] : $this->FontColorG;
    $FontB = isset($Format["FontB"]) ? $Format["FontB"] : $this->FontColorB;
    $BoxWidth = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;
    $BoxHeight = isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;
    $IconAreaWidth = isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;
    $IconAreaHeight = isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;
    $XSpacing = isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;
    $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 5;
    $R = isset($Format["R"]) ? $Format["R"] : 200;
    $G = isset($Format["G"]) ? $Format["G"] : 200;
    $B = isset($Format["B"]) ? $Format["B"] : 200;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : 255;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : 255;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : 255;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $Style = isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;
    $Mode = isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    $Data = $this->DataSet
      ->getData();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && isset($Serie["Picture"])) {
        list($PicWidth, $PicHeight) = $this
          ->getPicInfo($Serie["Picture"]);
        if ($IconAreaWidth < $PicWidth) {
          $IconAreaWidth = $PicWidth;
        }
        if ($IconAreaHeight < $PicHeight) {
          $IconAreaHeight = $PicHeight;
        }
      }
    }
    $YStep = max($this->FontSize, $IconAreaHeight) + 5;
    $XStep = $IconAreaWidth + 5;
    $XStep = $XSpacing;
    $Boundaries = "";
    $Boundaries["L"] = $X;
    $Boundaries["T"] = $Y;
    $Boundaries["R"] = 0;
    $Boundaries["B"] = 0;
    $vY = $Y;
    $vX = $X;
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        if ($Mode == LEGEND_VERTICAL) {
          $BoxArray = $this
            ->getTextBox($vX + $IconAreaWidth + 4, $vY + $IconAreaHeight / 2, $FontName, $FontSize, 0, $Serie["Description"]);
          if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
            $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
          }
          if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
            $Boundaries["R"] = $BoxArray[1]["X"] + 2;
          }
          if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
            $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
          }
          $Lines = preg_split("/\n/", $Serie["Description"]);
          $vY = $vY + max($this->FontSize * count($Lines), $IconAreaHeight) + 5;
        }
        elseif ($Mode == LEGEND_HORIZONTAL) {
          $Lines = preg_split("/\n/", $Serie["Description"]);
          $Width = "";
          foreach ($Lines as $Key => $Value) {
            $BoxArray = $this
              ->getTextBox($vX + $IconAreaWidth + 6, $Y + $IconAreaHeight / 2 + ($this->FontSize + 3) * $Key, $FontName, $FontSize, 0, $Value);
            if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
              $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
            }
            if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
              $Boundaries["R"] = $BoxArray[1]["X"] + 2;
            }
            if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
              $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
            }
            $Width[] = $BoxArray[1]["X"];
          }
          $vX = max($Width) + $XStep;
        }
      }
    }
    $vY = $vY - $YStep;
    $vX = $vX - $XStep;
    $TopOffset = $Y - $Boundaries["T"];
    if ($Boundaries["B"] - ($vY + $IconAreaHeight) < $TopOffset) {
      $Boundaries["B"] = $vY + $IconAreaHeight + $TopOffset;
    }
    if ($Style == LEGEND_ROUND) {
      $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,
      ));
    }
    elseif ($Style == LEGEND_BOX) {
      $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,
      ));
    }
    $RestoreShadow = $this->Shadow;
    $this->Shadow = FALSE;
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        if (isset($Serie["Picture"])) {
          $Picture = $Serie["Picture"];
          list($PicWidth, $PicHeight) = $this
            ->getPicInfo($Picture);
          $PicX = $X + $IconAreaWidth / 2;
          $PicY = $Y + $IconAreaHeight / 2;
          $this
            ->drawFromPNG($PicX - $PicWidth / 2, $PicY - $PicHeight / 2, $Picture);
        }
        else {
          if ($Family == LEGEND_FAMILY_BOX) {
            if ($BoxWidth != $IconAreaWidth) {
              $XOffset = floor(($IconAreaWidth - $BoxWidth) / 2);
            }
            else {
              $XOffset = 0;
            }
            if ($BoxHeight != $IconAreaHeight) {
              $YOffset = floor(($IconAreaHeight - $BoxHeight) / 2);
            }
            else {
              $YOffset = 0;
            }
            $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,
            ));
            $this
              ->drawFilledRectangle($X + $XOffset, $Y + $YOffset, $X + $BoxWidth + $XOffset, $Y + $BoxHeight + $YOffset, array(
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Surrounding" => 20,
            ));
          }
          elseif ($Family == LEGEND_FAMILY_CIRCLE) {
            $this
              ->drawFilledCircle($X + 1 + $IconAreaWidth / 2, $Y + 1 + $IconAreaHeight / 2, min($IconAreaHeight / 2, $IconAreaWidth / 2), array(
              "R" => 0,
              "G" => 0,
              "B" => 0,
              "Alpha" => 20,
            ));
            $this
              ->drawFilledCircle($X + $IconAreaWidth / 2, $Y + $IconAreaHeight / 2, min($IconAreaHeight / 2, $IconAreaWidth / 2), array(
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Surrounding" => 20,
            ));
          }
          elseif ($Family == LEGEND_FAMILY_LINE) {
            $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,
            ));
            $this
              ->drawLine($X, $Y + $IconAreaHeight / 2, $X + $IconAreaWidth, $Y + $IconAreaHeight / 2, array(
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Ticks" => $Ticks,
              "Weight" => $Weight,
            ));
          }
        }
        if ($Mode == LEGEND_VERTICAL) {
          $Lines = preg_split("/\n/", $Serie["Description"]);
          foreach ($Lines as $Key => $Value) {
            $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,
            ));
          }
          $Y = $Y + max($this->FontSize * count($Lines), $IconAreaHeight) + 5;
        }
        elseif ($Mode == LEGEND_HORIZONTAL) {
          $Lines = preg_split("/\n/", $Serie["Description"]);
          $Width = "";
          foreach ($Lines as $Key => $Value) {
            $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,
            ));
            $Width[] = $BoxArray[1]["X"];
          }
          $X = max($Width) + 2 + $XStep;
        }
      }
    }
    $this->Shadow = $RestoreShadow;
  }
  function drawScale($Format = "") {
    $Pos = isset($Format["Pos"]) ? $Format["Pos"] : SCALE_POS_LEFTRIGHT;
    $Floating = isset($Format["Floating"]) ? $Format["Floating"] : FALSE;
    $Mode = isset($Format["Mode"]) ? $Format["Mode"] : SCALE_MODE_FLOATING;
    $RemoveXAxis = isset($Format["RemoveXAxis"]) ? $Format["RemoveXAxis"] : FALSE;
    $MinDivHeight = isset($Format["MinDivHeight"]) ? $Format["MinDivHeight"] : 20;
    $Factors = isset($Format["Factors"]) ? $Format["Factors"] : array(
      1,
      2,
      5,
    );
    $ManualScale = isset($Format["ManualScale"]) ? $Format["ManualScale"] : array(
      "0" => array(
        "Min" => -100,
        "Max" => 100,
      ),
    );
    $XMargin = isset($Format["XMargin"]) ? $Format["XMargin"] : AUTO;
    $YMargin = isset($Format["YMargin"]) ? $Format["YMargin"] : 0;
    $ScaleSpacing = isset($Format["ScaleSpacing"]) ? $Format["ScaleSpacing"] : 15;
    $InnerTickWidth = isset($Format["InnerTickWidth"]) ? $Format["InnerTickWidth"] : 2;
    $OuterTickWidth = isset($Format["OuterTickWidth"]) ? $Format["OuterTickWidth"] : 2;
    $DrawXLines = isset($Format["DrawXLines"]) ? $Format["DrawXLines"] : TRUE;
    $DrawYLines = isset($Format["DrawYLines"]) ? $Format["DrawYLines"] : ALL;
    $GridTicks = isset($Format["GridTicks"]) ? $Format["GridTicks"] : 4;
    $GridR = isset($Format["GridR"]) ? $Format["GridR"] : 255;
    $GridG = isset($Format["GridG"]) ? $Format["GridG"] : 255;
    $GridB = isset($Format["GridB"]) ? $Format["GridB"] : 255;
    $GridAlpha = isset($Format["GridAlpha"]) ? $Format["GridAlpha"] : 40;
    $AxisRo = isset($Format["AxisR"]) ? $Format["AxisR"] : 0;
    $AxisGo = isset($Format["AxisG"]) ? $Format["AxisG"] : 0;
    $AxisBo = isset($Format["AxisB"]) ? $Format["AxisB"] : 0;
    $AxisAlpha = isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 100;
    $TickRo = isset($Format["TickR"]) ? $Format["TickR"] : 0;
    $TickGo = isset($Format["TickG"]) ? $Format["TickG"] : 0;
    $TickBo = isset($Format["TickB"]) ? $Format["TickB"] : 0;
    $TickAlpha = isset($Format["TickAlpha"]) ? $Format["TickAlpha"] : 100;
    $DrawSubTicks = isset($Format["DrawSubTicks"]) ? $Format["DrawSubTicks"] : FALSE;
    $InnerSubTickWidth = isset($Format["InnerSubTickWidth"]) ? $Format["InnerSubTickWidth"] : 0;
    $OuterSubTickWidth = isset($Format["OuterSubTickWidth"]) ? $Format["OuterSubTickWidth"] : 2;
    $SubTickR = isset($Format["SubTickR"]) ? $Format["SubTickR"] : 255;
    $SubTickG = isset($Format["SubTickG"]) ? $Format["SubTickG"] : 0;
    $SubTickB = isset($Format["SubTickB"]) ? $Format["SubTickB"] : 0;
    $SubTickAlpha = isset($Format["SubTickAlpha"]) ? $Format["SubTickAlpha"] : 100;
    $AutoAxisLabels = isset($Format["AutoAxisLabels"]) ? $Format["AutoAxisLabels"] : TRUE;
    $XReleasePercent = isset($Format["XReleasePercent"]) ? $Format["XReleasePercent"] : 1;
    $DrawArrows = isset($Format["DrawArrows"]) ? $Format["DrawArrows"] : FALSE;
    $ArrowSize = isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 8;
    $CycleBackground = isset($Format["CycleBackground"]) ? $Format["CycleBackground"] : FALSE;
    $BackgroundR1 = isset($Format["BackgroundR1"]) ? $Format["BackgroundR1"] : 255;
    $BackgroundG1 = isset($Format["BackgroundG1"]) ? $Format["BackgroundG1"] : 255;
    $BackgroundB1 = isset($Format["BackgroundB1"]) ? $Format["BackgroundB1"] : 255;
    $BackgroundAlpha1 = isset($Format["BackgroundAlpha1"]) ? $Format["BackgroundAlpha1"] : 20;
    $BackgroundR2 = isset($Format["BackgroundR2"]) ? $Format["BackgroundR2"] : 230;
    $BackgroundG2 = isset($Format["BackgroundG2"]) ? $Format["BackgroundG2"] : 230;
    $BackgroundB2 = isset($Format["BackgroundB2"]) ? $Format["BackgroundB2"] : 230;
    $BackgroundAlpha2 = isset($Format["BackgroundAlpha2"]) ? $Format["BackgroundAlpha2"] : 20;
    $LabelingMethod = isset($Format["LabelingMethod"]) ? $Format["LabelingMethod"] : LABELING_ALL;
    $LabelSkip = isset($Format["LabelSkip"]) ? $Format["LabelSkip"] : 0;
    $LabelRotation = isset($Format["LabelRotation"]) ? $Format["LabelRotation"] : 0;
    $RemoveSkippedAxis = isset($Format["RemoveSkippedAxis"]) ? $Format["RemoveSkippedAxis"] : FALSE;
    $SkippedAxisTicks = isset($Format["SkippedAxisTicks"]) ? $Format["SkippedAxisTicks"] : $GridTicks + 2;
    $SkippedAxisR = isset($Format["SkippedAxisR"]) ? $Format["SkippedAxisR"] : $GridR;
    $SkippedAxisG = isset($Format["SkippedAxisG"]) ? $Format["SkippedAxisG"] : $GridG;
    $SkippedAxisB = isset($Format["SkippedAxisB"]) ? $Format["SkippedAxisB"] : $GridB;
    $SkippedAxisAlpha = isset($Format["SkippedAxisAlpha"]) ? $Format["SkippedAxisAlpha"] : $GridAlpha - 30;
    $SkippedTickR = isset($Format["SkippedTickR"]) ? $Format["SkippedTickR"] : $TickRo;
    $SkippedTickG = isset($Format["SkippedTickG"]) ? $Format["SkippedTickG"] : $TickGo;
    $SkippedTickB = isset($Format["SkippedTicksB"]) ? $Format["SkippedTickB"] : $TickBo;
    $SkippedTickAlpha = isset($Format["SkippedTickAlpha"]) ? $Format["SkippedTickAlpha"] : $TickAlpha - 80;
    $SkippedInnerTickWidth = isset($Format["SkippedInnerTickWidth"]) ? $Format["SkippedInnerTickWidth"] : 0;
    $SkippedOuterTickWidth = isset($Format["SkippedOuterTickWidth"]) ? $Format["SkippedOuterTickWidth"] : 2;

    /* Floating scale require X & Y margins to be set manually */
    if ($Floating && ($XMargin == AUTO || $YMargin == 0)) {
      $Floating = FALSE;
    }

    /* Skip a NOTICE event in case of an empty array */
    if ($DrawYLines == NONE || $DrawYLines == FALSE) {
      $DrawYLines = array(
        "zarma" => "31",
      );
    }

    /* Define the color for the skipped elements */
    $SkippedAxisColor = array(
      "R" => $SkippedAxisR,
      "G" => $SkippedAxisG,
      "B" => $SkippedAxisB,
      "Alpha" => $SkippedAxisAlpha,
      "Ticks" => $SkippedAxisTicks,
    );
    $SkippedTickColor = array(
      "R" => $SkippedTickR,
      "G" => $SkippedTickG,
      "B" => $SkippedTickB,
      "Alpha" => $SkippedTickAlpha,
    );
    $Data = $this->DataSet
      ->getData();
    if (isset($Data["Abscissa"])) {
      $Abscissa = $Data["Abscissa"];
    }
    else {
      $Abscissa = NULL;
    }

    /* Unset the abscissa axis, needed if we display multiple charts on the same picture */
    if ($Abscissa != NULL) {
      foreach ($Data["Axis"] as $AxisID => $Parameters) {
        if ($Parameters["Identity"] == AXIS_X) {
          unset($Data["Axis"][$AxisID]);
        }
      }
    }

    /* Build the scale settings */
    $GotXAxis = FALSE;
    foreach ($Data["Axis"] as $AxisID => $AxisParameter) {
      if ($AxisParameter["Identity"] == AXIS_X) {
        $GotXAxis = TRUE;
      }
      if ($Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_Y) {
        $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $YMargin * 2;
      }
      elseif ($Pos == SCALE_POS_LEFTRIGHT && $AxisParameter["Identity"] == AXIS_X) {
        $Height = $this->GraphAreaX2 - $this->GraphAreaX1;
      }
      elseif ($Pos == SCALE_POS_TOPBOTTOM && $AxisParameter["Identity"] == AXIS_Y) {
        $Height = $this->GraphAreaX2 - $this->GraphAreaX1 - $YMargin * 2;
      }
      else {
        $Height = $this->GraphAreaY2 - $this->GraphAreaY1;
      }
      $AxisMin = ABSOLUTE_MAX;
      $AxisMax = OUT_OF_SIGHT;
      if ($Mode == SCALE_MODE_FLOATING || $Mode == SCALE_MODE_START0) {
        foreach ($Data["Series"] as $SerieID => $SerieParameter) {
          if ($SerieParameter["Axis"] == $AxisID && $Data["Series"][$SerieID]["isDrawable"] && $Data["Abscissa"] != $SerieID) {
            $AxisMax = max($AxisMax, $Data["Series"][$SerieID]["Max"]);
            $AxisMin = min($AxisMin, $Data["Series"][$SerieID]["Min"]);
          }
        }
        $AutoMargin = ($AxisMax - $AxisMin) / 100 * $XReleasePercent;
        $Data["Axis"][$AxisID]["Min"] = $AxisMin - $AutoMargin;
        $Data["Axis"][$AxisID]["Max"] = $AxisMax + $AutoMargin;
        if ($Mode == SCALE_MODE_START0) {
          $Data["Axis"][$AxisID]["Min"] = 0;
        }
      }
      elseif ($Mode == SCALE_MODE_MANUAL) {
        if (isset($ManualScale[$AxisID]["Min"]) && isset($ManualScale[$AxisID]["Max"])) {
          $Data["Axis"][$AxisID]["Min"] = $ManualScale[$AxisID]["Min"];
          $Data["Axis"][$AxisID]["Max"] = $ManualScale[$AxisID]["Max"];
        }
        else {
          echo "Manual scale boundaries not set.";
          exit;
        }
      }
      elseif ($Mode == SCALE_MODE_ADDALL || $Mode == SCALE_MODE_ADDALL_START0) {
        $Series = "";
        foreach ($Data["Series"] as $SerieID => $SerieParameter) {
          if ($SerieParameter["Axis"] == $AxisID && $SerieParameter["isDrawable"] && $Data["Abscissa"] != $SerieID) {
            $Series[$SerieID] = count($Data["Series"][$SerieID]["Data"]);
          }
        }
        for ($ID = 0; $ID <= max($Series) - 1; $ID++) {
          $PointMin = 0;
          $PointMax = 0;
          foreach ($Series as $SerieID => $ValuesCount) {
            if (isset($Data["Series"][$SerieID]["Data"][$ID]) && $Data["Series"][$SerieID]["Data"][$ID] != NULL) {
              $Value = $Data["Series"][$SerieID]["Data"][$ID];
              if ($Value > 0) {
                $PointMax = $PointMax + $Value;
              }
              else {
                $PointMin = $PointMin + $Value;
              }
            }
          }
          $AxisMax = max($AxisMax, $PointMax);
          $AxisMin = min($AxisMin, $PointMin);
        }
        $AutoMargin = ($AxisMax - $AxisMin) / 100 * $XReleasePercent;
        $Data["Axis"][$AxisID]["Min"] = $AxisMin - $AutoMargin;
        $Data["Axis"][$AxisID]["Max"] = $AxisMax + $AutoMargin;
      }
      $MaxDivs = floor($Height / $MinDivHeight);
      if ($Mode == SCALE_MODE_ADDALL_START0) {
        $Data["Axis"][$AxisID]["Min"] = 0;
      }
      $Scale = $this
        ->computeScale($Data["Axis"][$AxisID]["Min"], $Data["Axis"][$AxisID]["Max"], $MaxDivs, $Factors, $AxisID);
      $Data["Axis"][$AxisID]["Margin"] = $AxisParameter["Identity"] == AXIS_X ? $XMargin : $YMargin;
      $Data["Axis"][$AxisID]["ScaleMin"] = $Scale["XMin"];
      $Data["Axis"][$AxisID]["ScaleMax"] = $Scale["XMax"];
      $Data["Axis"][$AxisID]["Rows"] = $Scale["Rows"];
      $Data["Axis"][$AxisID]["RowHeight"] = $Scale["RowHeight"];
      if (isset($Scale["Format"])) {
        $Data["Axis"][$AxisID]["Format"] = $Scale["Format"];
      }
      if (!isset($Data["Axis"][$AxisID]["Display"])) {
        $Data["Axis"][$AxisID]["Display"] = NULL;
      }
      if (!isset($Data["Axis"][$AxisID]["Format"])) {
        $Data["Axis"][$AxisID]["Format"] = NULL;
      }
      if (!isset($Data["Axis"][$AxisID]["Unit"])) {
        $Data["Axis"][$AxisID]["Unit"] = NULL;
      }
    }

    /* Still no X axis */
    if ($GotXAxis == FALSE) {
      if ($Abscissa != NULL) {
        $Points = count($Data["Series"][$Abscissa]["Data"]);
        if ($AutoAxisLabels) {
          $AxisName = isset($Data["Series"][$Abscissa]["Description"]) ? $Data["Series"][$Abscissa]["Description"] : NULL;
        }
        else {
          $AxisName = NULL;
        }
      }
      else {
        $Points = 0;
        $AxisName = isset($Data["XAxisName"]) ? $Data["XAxisName"] : NULL;
        foreach ($Data["Series"] as $SerieID => $SerieParameter) {
          if ($SerieParameter["isDrawable"]) {
            $Points = max($Points, count($SerieParameter["Data"]));
          }
        }
      }
      $AxisID = count($Data["Axis"]);
      $Data["Axis"][$AxisID]["Identity"] = AXIS_X;
      if ($Pos == SCALE_POS_LEFTRIGHT) {
        $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_BOTTOM;
      }
      else {
        $Data["Axis"][$AxisID]["Position"] = AXIS_POSITION_LEFT;
      }
      if (isset($Data["AbscissaName"])) {
        $Data["Axis"][$AxisID]["Name"] = $Data["AbscissaName"];
      }
      if ($XMargin == AUTO) {
        if ($Pos == SCALE_POS_LEFTRIGHT) {
          $Height = $this->GraphAreaX2 - $this->GraphAreaX1;
        }
        else {
          $Height = $this->GraphAreaY2 - $this->GraphAreaY1;
        }
        if ($Points == 1) {
          $Data["Axis"][$AxisID]["Margin"] = $Height / 2;
        }
        else {
          $Data["Axis"][$AxisID]["Margin"] = $Height / $Points / 2;
        }
      }
      else {
        $Data["Axis"][$AxisID]["Margin"] = $XMargin;
      }
      $Data["Axis"][$AxisID]["Rows"] = $Points - 1;
      if (!isset($Data["Axis"][$AxisID]["Display"])) {
        $Data["Axis"][$AxisID]["Display"] = NULL;
      }
      if (!isset($Data["Axis"][$AxisID]["Format"])) {
        $Data["Axis"][$AxisID]["Format"] = NULL;
      }
      if (!isset($Data["Axis"][$AxisID]["Unit"])) {
        $Data["Axis"][$AxisID]["Unit"] = NULL;
      }
    }

    /* Do we need to reverse the abscissa position? */
    if ($Pos != SCALE_POS_LEFTRIGHT) {
      if ($Data["AbsicssaPosition"] == AXIS_POSITION_BOTTOM) {
        $Data["AbsicssaPosition"] = AXIS_POSITION_LEFT;
      }
      else {
        $Data["AbsicssaPosition"] = AXIS_POSITION_RIGHT;
      }
    }
    $Data["Axis"][$AxisID]["Position"] = $Data["AbsicssaPosition"];
    $this->DataSet
      ->saveOrientation($Pos);
    $this->DataSet
      ->saveAxisConfig($Data["Axis"]);
    $this->DataSet
      ->saveYMargin($YMargin);
    $FontColorRo = $this->FontColorR;
    $FontColorGo = $this->FontColorG;
    $FontColorBo = $this->FontColorB;
    $AxisPos["L"] = $this->GraphAreaX1;
    $AxisPos["R"] = $this->GraphAreaX2;
    $AxisPos["T"] = $this->GraphAreaY1;
    $AxisPos["B"] = $this->GraphAreaY2;
    foreach ($Data["Axis"] as $AxisID => $Parameters) {
      if (isset($Parameters["Color"])) {
        $AxisR = $Parameters["Color"]["R"];
        $AxisG = $Parameters["Color"]["G"];
        $AxisB = $Parameters["Color"]["B"];
        $TickR = $Parameters["Color"]["R"];
        $TickG = $Parameters["Color"]["G"];
        $TickB = $Parameters["Color"]["B"];
        $this
          ->setFontProperties(array(
          "R" => $Parameters["Color"]["R"],
          "G" => $Parameters["Color"]["G"],
          "B" => $Parameters["Color"]["B"],
        ));
      }
      else {
        $AxisR = $AxisRo;
        $AxisG = $AxisGo;
        $AxisB = $AxisBo;
        $TickR = $TickRo;
        $TickG = $TickGo;
        $TickB = $TickBo;
        $this
          ->setFontProperties(array(
          "R" => $FontColorRo,
          "G" => $FontColorGo,
          "B" => $FontColorBo,
        ));
      }
      $LastValue = "w00t";
      $ID = 1;
      if ($Parameters["Identity"] == AXIS_X) {
        if ($Pos == SCALE_POS_LEFTRIGHT) {
          if ($Parameters["Position"] == AXIS_POSITION_BOTTOM) {
            if ($LabelRotation == 0) {
              $LabelAlign = TEXT_ALIGN_TOPMIDDLE;
              $YLabelOffset = 2;
            }
            if ($LabelRotation > 0 && $LabelRotation < 190) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $YLabelOffset = 5;
            }
            if ($LabelRotation == 180) {
              $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE;
              $YLabelOffset = 5;
            }
            if ($LabelRotation > 180 && $LabelRotation < 360) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $YLabelOffset = 2;
            }
            if (!$RemoveXAxis) {
              if ($Floating) {
                $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,
                ));
              }
              else {
                $FloatingOffset = 0;
                $this
                  ->drawLine($this->GraphAreaX1, $AxisPos["B"], $this->GraphAreaX2, $AxisPos["B"], array(
                  "R" => $AxisR,
                  "G" => $AxisG,
                  "B" => $AxisB,
                  "Alpha" => $AxisAlpha,
                ));
              }
              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,
                ));
              }
            }
            $Width = $this->GraphAreaX2 - $this->GraphAreaX1 - $Parameters["Margin"] * 2;
            if ($Parameters["Rows"] == 0) {
              $Step = $Width;
            }
            else {
              $Step = $Width / $Parameters["Rows"];
            }
            $MaxBottom = $AxisPos["B"];
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $XPos = $this->GraphAreaX1 + $Parameters["Margin"] + $Step * $i;
              $YPos = $AxisPos["B"];
              if ($Abscissa != NULL) {
                if (isset($Data["Series"][$Abscissa]["Data"][$i])) {
                  $Value = $this
                    ->scaleFormat($Data["Series"][$Abscissa]["Data"][$i], $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = "";
                }
              }
              else {
                if (isset($Parameters["ScaleMin"]) && isset($Parameters["RowHeight"])) {
                  $Value = $this
                    ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = $i;
                }
              }
              $ID++;
              $Skipped = TRUE;
              if ($this
                ->isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip) && !$RemoveXAxis) {
                $Bounds = $this
                  ->drawText($XPos, $YPos + $OuterTickWidth + $YLabelOffset, $Value, array(
                  "Angle" => $LabelRotation,
                  "Align" => $LabelAlign,
                ));
                $TxtBottom = $YPos + $OuterTickWidth + 2 + ($Bounds[0]["Y"] - $Bounds[2]["Y"]);
                $MaxBottom = max($MaxBottom, $TxtBottom);
                $LastValue = $Value;
                $Skipped = FALSE;
              }
              if ($RemoveXAxis) {
                $Skipped = FALSE;
              }
              if ($Skipped) {
                if ($DrawXLines && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos, $this->GraphAreaY1 + $FloatingOffset, $XPos, $this->GraphAreaY2 - $FloatingOffset, $SkippedAxisColor);
                }
                if (($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos, $YPos - $SkippedInnerTickWidth, $XPos, $YPos + $SkippedOuterTickWidth, $SkippedTickColor);
                }
              }
              else {
                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,
                  ));
                }
                if (($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis) {
                  $this
                    ->drawLine($XPos, $YPos - $InnerTickWidth, $XPos, $YPos + $OuterTickWidth, array(
                    "R" => $TickR,
                    "G" => $TickG,
                    "B" => $TickB,
                    "Alpha" => $TickAlpha,
                  ));
                }
              }
            }
            if (isset($Parameters["Name"]) && !$RemoveXAxis) {
              $YPos = $MaxBottom + 2;
              $XPos = $this->GraphAreaX1 + ($this->GraphAreaX2 - $this->GraphAreaX1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_TOPMIDDLE,
              ));
              $MaxBottom = $Bounds[0]["Y"];
              $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;
            }
            $AxisPos["B"] = $MaxBottom + $ScaleSpacing;
          }
          elseif ($Parameters["Position"] == AXIS_POSITION_TOP) {
            if ($LabelRotation == 0) {
              $LabelAlign = TEXT_ALIGN_BOTTOMMIDDLE;
              $YLabelOffset = 2;
            }
            if ($LabelRotation > 0 && $LabelRotation < 190) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $YLabelOffset = 2;
            }
            if ($LabelRotation == 180) {
              $LabelAlign = TEXT_ALIGN_TOPMIDDLE;
              $YLabelOffset = 5;
            }
            if ($LabelRotation > 180 && $LabelRotation < 360) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $YLabelOffset = 5;
            }
            if (!$RemoveXAxis) {
              if ($Floating) {
                $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,
                ));
              }
              else {
                $FloatingOffset = 0;
                $this
                  ->drawLine($this->GraphAreaX1, $AxisPos["T"], $this->GraphAreaX2, $AxisPos["T"], array(
                  "R" => $AxisR,
                  "G" => $AxisG,
                  "B" => $AxisB,
                  "Alpha" => $AxisAlpha,
                ));
              }
              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,
                ));
              }
            }
            $Width = $this->GraphAreaX2 - $this->GraphAreaX1 - $Parameters["Margin"] * 2;
            if ($Parameters["Rows"] == 0) {
              $Step = $Width;
            }
            else {
              $Step = $Width / $Parameters["Rows"];
            }
            $MinTop = $AxisPos["T"];
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $XPos = $this->GraphAreaX1 + $Parameters["Margin"] + $Step * $i;
              $YPos = $AxisPos["T"];
              if ($Abscissa != NULL) {
                if (isset($Data["Series"][$Abscissa]["Data"][$i])) {
                  $Value = $this
                    ->scaleFormat($Data["Series"][$Abscissa]["Data"][$i], $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = "";
                }
              }
              else {
                if (isset($Parameters["ScaleMin"]) && isset($Parameters["RowHeight"])) {
                  $Value = $this
                    ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = $i;
                }
              }
              $ID++;
              $Skipped = TRUE;
              if ($this
                ->isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip) && !$RemoveXAxis) {
                $Bounds = $this
                  ->drawText($XPos, $YPos - $OuterTickWidth - $YLabelOffset, $Value, array(
                  "Angle" => $LabelRotation,
                  "Align" => $LabelAlign,
                ));
                $TxtBox = $YPos - $OuterTickWidth - 2 - ($Bounds[0]["Y"] - $Bounds[2]["Y"]);
                $MinTop = min($MinTop, $TxtBox);
                $LastValue = $Value;
                $Skipped = FALSE;
              }
              if ($RemoveXAxis) {
                $Skipped = FALSE;
              }
              if ($Skipped) {
                if ($DrawXLines && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos, $this->GraphAreaY1 + $FloatingOffset, $XPos, $this->GraphAreaY2 - $FloatingOffset, $SkippedAxisColor);
                }
                if (($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos, $YPos + $SkippedInnerTickWidth, $XPos, $YPos - $SkippedOuterTickWidth, $SkippedTickColor);
                }
              }
              else {
                if ($DrawXLines) {
                  $this
                    ->drawLine($XPos, $this->GraphAreaY1 + $FloatingOffset, $XPos, $this->GraphAreaY2 - $FloatingOffset, array(
                    "R" => $GridR,
                    "G" => $GridG,
                    "B" => $GridB,
                    "Alpha" => $GridAlpha,
                    "Ticks" => $GridTicks,
                  ));
                }
                if (($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis) {
                  $this
                    ->drawLine($XPos, $YPos + $InnerTickWidth, $XPos, $YPos - $OuterTickWidth, array(
                    "R" => $TickR,
                    "G" => $TickG,
                    "B" => $TickB,
                    "Alpha" => $TickAlpha,
                  ));
                }
              }
            }
            if (isset($Parameters["Name"]) && !$RemoveXAxis) {
              $YPos = $MinTop - 2;
              $XPos = $this->GraphAreaX1 + ($this->GraphAreaX2 - $this->GraphAreaX1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
              ));
              $MinTop = $Bounds[2]["Y"];
              $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;
            }
            $AxisPos["T"] = $MinTop - $ScaleSpacing;
          }
        }
        elseif ($Pos == SCALE_POS_TOPBOTTOM) {
          if ($Parameters["Position"] == AXIS_POSITION_LEFT) {
            if ($LabelRotation == 0) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $XLabelOffset = -2;
            }
            if ($LabelRotation > 0 && $LabelRotation < 190) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $XLabelOffset = -6;
            }
            if ($LabelRotation == 180) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $XLabelOffset = -2;
            }
            if ($LabelRotation > 180 && $LabelRotation < 360) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $XLabelOffset = -5;
            }
            if (!$RemoveXAxis) {
              if ($Floating) {
                $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,
                ));
              }
              else {
                $FloatingOffset = 0;
                $this
                  ->drawLine($AxisPos["L"], $this->GraphAreaY1, $AxisPos["L"], $this->GraphAreaY2, array(
                  "R" => $AxisR,
                  "G" => $AxisG,
                  "B" => $AxisB,
                  "Alpha" => $AxisAlpha,
                ));
              }
              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,
                ));
              }
            }
            $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $Parameters["Margin"] * 2;
            if ($Parameters["Rows"] == 0) {
              $Step = $Height;
            }
            else {
              $Step = $Height / $Parameters["Rows"];
            }
            $MinLeft = $AxisPos["L"];
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $YPos = $this->GraphAreaY1 + $Parameters["Margin"] + $Step * $i;
              $XPos = $AxisPos["L"];
              if ($Abscissa != NULL) {
                if (isset($Data["Series"][$Abscissa]["Data"][$i])) {
                  $Value = $this
                    ->scaleFormat($Data["Series"][$Abscissa]["Data"][$i], $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = "";
                }
              }
              else {
                if (isset($Parameters["ScaleMin"]) && isset($Parameters["RowHeight"])) {
                  $Value = $this
                    ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = $i;
                }
              }
              $ID++;
              $Skipped = TRUE;
              if ($this
                ->isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip) && !$RemoveXAxis) {
                $Bounds = $this
                  ->drawText($XPos - $OuterTickWidth + $XLabelOffset, $YPos, $Value, array(
                  "Angle" => $LabelRotation,
                  "Align" => $LabelAlign,
                ));
                $TxtBox = $XPos - $OuterTickWidth - 2 - ($Bounds[1]["X"] - $Bounds[0]["X"]);
                $MinLeft = min($MinLeft, $TxtBox);
                $LastValue = $Value;
                $Skipped = FALSE;
              }
              if ($RemoveXAxis) {
                $Skipped = FALSE;
              }
              if ($Skipped) {
                if ($DrawXLines && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($this->GraphAreaX1 + $FloatingOffset, $YPos, $this->GraphAreaX2 - $FloatingOffset, $YPos, $SkippedAxisColor);
                }
                if (($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos - $SkippedOuterTickWidth, $YPos, $XPos + $SkippedInnerTickWidth, $YPos, $SkippedTickColor);
                }
              }
              else {
                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,
                  ));
                }
                if (($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis) {
                  $this
                    ->drawLine($XPos - $OuterTickWidth, $YPos, $XPos + $InnerTickWidth, $YPos, array(
                    "R" => $TickR,
                    "G" => $TickG,
                    "B" => $TickB,
                    "Alpha" => $TickAlpha,
                  ));
                }
              }
            }
            if (isset($Parameters["Name"]) && !$RemoveXAxis) {
              $XPos = $MinLeft - 2;
              $YPos = $this->GraphAreaY1 + ($this->GraphAreaY2 - $this->GraphAreaY1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
                "Angle" => 90,
              ));
              $MinLeft = $Bounds[0]["X"];
              $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;
            }
            $AxisPos["L"] = $MinLeft - $ScaleSpacing;
          }
          elseif ($Parameters["Position"] == AXIS_POSITION_RIGHT) {
            if ($LabelRotation == 0) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $XLabelOffset = 2;
            }
            if ($LabelRotation > 0 && $LabelRotation < 190) {
              $LabelAlign = TEXT_ALIGN_MIDDLELEFT;
              $XLabelOffset = 6;
            }
            if ($LabelRotation == 180) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $XLabelOffset = 5;
            }
            if ($LabelRotation > 180 && $LabelRotation < 360) {
              $LabelAlign = TEXT_ALIGN_MIDDLERIGHT;
              $XLabelOffset = 7;
            }
            if (!$RemoveXAxis) {
              if ($Floating) {
                $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,
                ));
              }
              else {
                $FloatingOffset = 0;
                $this
                  ->drawLine($AxisPos["R"], $this->GraphAreaY1, $AxisPos["R"], $this->GraphAreaY2, array(
                  "R" => $AxisR,
                  "G" => $AxisG,
                  "B" => $AxisB,
                  "Alpha" => $AxisAlpha,
                ));
              }
              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,
                ));
              }
            }
            $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $Parameters["Margin"] * 2;
            if ($Parameters["Rows"] == 0) {
              $Step = $Height;
            }
            else {
              $Step = $Height / $Parameters["Rows"];
            }
            $MaxRight = $AxisPos["R"];
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $YPos = $this->GraphAreaY1 + $Parameters["Margin"] + $Step * $i;
              $XPos = $AxisPos["R"];
              if ($Abscissa != NULL) {
                if (isset($Data["Series"][$Abscissa]["Data"][$i])) {
                  $Value = $this
                    ->scaleFormat($Data["Series"][$Abscissa]["Data"][$i], $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = "";
                }
              }
              else {
                if (isset($Parameters["ScaleMin"]) && isset($Parameters["RowHeight"])) {
                  $Value = $this
                    ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Data["XAxisDisplay"], $Data["XAxisFormat"], $Data["XAxisUnit"]);
                }
                else {
                  $Value = $i;
                }
              }
              $ID++;
              $Skipped = TRUE;
              if ($this
                ->isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip) && !$RemoveXAxis) {
                $Bounds = $this
                  ->drawText($XPos + $OuterTickWidth + $XLabelOffset, $YPos, $Value, array(
                  "Angle" => $LabelRotation,
                  "Align" => $LabelAlign,
                ));
                $TxtBox = $XPos + $OuterTickWidth + 2 + ($Bounds[1]["X"] - $Bounds[0]["X"]);
                $MaxRight = max($MaxRight, $TxtBox);
                $LastValue = $Value;
                $Skipped = FALSE;
              }
              if ($RemoveXAxis) {
                $Skipped = FALSE;
              }
              if ($Skipped) {
                if ($DrawXLines && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($this->GraphAreaX1 + $FloatingOffset, $YPos, $this->GraphAreaX2 - $FloatingOffset, $YPos, $SkippedAxisColor);
                }
                if (($SkippedInnerTickWidth != 0 || $SkippedOuterTickWidth != 0) && !$RemoveXAxis && !$RemoveSkippedAxis) {
                  $this
                    ->drawLine($XPos + $SkippedOuterTickWidth, $YPos, $XPos - $SkippedInnerTickWidth, $YPos, $SkippedTickColor);
                }
              }
              else {
                if ($DrawXLines) {
                  $this
                    ->drawLine($this->GraphAreaX1 + $FloatingOffset, $YPos, $this->GraphAreaX2 - $FloatingOffset, $YPos, array(
                    "R" => $GridR,
                    "G" => $GridG,
                    "B" => $GridB,
                    "Alpha" => $GridAlpha,
                    "Ticks" => $GridTicks,
                  ));
                }
                if (($InnerTickWidth != 0 || $OuterTickWidth != 0) && !$RemoveXAxis) {
                  $this
                    ->drawLine($XPos + $OuterTickWidth, $YPos, $XPos - $InnerTickWidth, $YPos, array(
                    "R" => $TickR,
                    "G" => $TickG,
                    "B" => $TickB,
                    "Alpha" => $TickAlpha,
                  ));
                }
              }
            }
            if (isset($Parameters["Name"]) && !$RemoveXAxis) {
              $XPos = $MaxRight + 4;
              $YPos = $this->GraphAreaY1 + ($this->GraphAreaY2 - $this->GraphAreaY1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
                "Angle" => 270,
              ));
              $MaxRight = $Bounds[1]["X"];
              $this->DataSet->Data["GraphArea"]["X2"] = $MaxRight + $this->FontSize;
            }
            $AxisPos["R"] = $MaxRight + $ScaleSpacing;
          }
        }
      }
      if ($Parameters["Identity"] == AXIS_Y) {
        if ($Pos == SCALE_POS_LEFTRIGHT) {
          if ($Parameters["Position"] == AXIS_POSITION_LEFT) {
            if ($Floating) {
              $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,
              ));
            }
            else {
              $FloatingOffset = 0;
              $this
                ->drawLine($AxisPos["L"], $this->GraphAreaY1, $AxisPos["L"], $this->GraphAreaY2, array(
                "R" => $AxisR,
                "G" => $AxisG,
                "B" => $AxisB,
                "Alpha" => $AxisAlpha,
              ));
            }
            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,
              ));
            }
            $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $Parameters["Margin"] * 2;
            $Step = $Height / $Parameters["Rows"];
            $SubTicksSize = $Step / 2;
            $MinLeft = $AxisPos["L"];
            $LastY = NULL;
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $YPos = $this->GraphAreaY2 - $Parameters["Margin"] - $Step * $i;
              $XPos = $AxisPos["L"];
              $Value = $this
                ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Parameters["Display"], $Parameters["Format"], $Parameters["Unit"]);
              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,
                );
              }
              if ($LastY != NULL && $CycleBackground && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))) {
                $this
                  ->drawFilledRectangle($this->GraphAreaX1 + $FloatingOffset, $LastY, $this->GraphAreaX2 - $FloatingOffset, $YPos, $BGColor);
              }
              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,
                ));
              }
              if ($DrawSubTicks && $i != $Parameters["Rows"]) {
                $this
                  ->drawLine($XPos - $OuterSubTickWidth, $YPos - $SubTicksSize, $XPos + $InnerSubTickWidth, $YPos - $SubTicksSize, array(
                  "R" => $SubTickR,
                  "G" => $SubTickG,
                  "B" => $SubTickB,
                  "Alpha" => $SubTickAlpha,
                ));
              }
              $this
                ->drawLine($XPos - $OuterTickWidth, $YPos, $XPos + $InnerTickWidth, $YPos, array(
                "R" => $TickR,
                "G" => $TickG,
                "B" => $TickB,
                "Alpha" => $TickAlpha,
              ));
              $Bounds = $this
                ->drawText($XPos - $OuterTickWidth - 2, $YPos, $Value, array(
                "Align" => TEXT_ALIGN_MIDDLERIGHT,
              ));
              $TxtLeft = $XPos - $OuterTickWidth - 2 - ($Bounds[1]["X"] - $Bounds[0]["X"]);
              $MinLeft = min($MinLeft, $TxtLeft);
              $LastY = $YPos;
            }
            if (isset($Parameters["Name"])) {
              $XPos = $MinLeft - 2;
              $YPos = $this->GraphAreaY1 + ($this->GraphAreaY2 - $this->GraphAreaY1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
                "Angle" => 90,
              ));
              $MinLeft = $Bounds[2]["X"];
              $this->DataSet->Data["GraphArea"]["X1"] = $MinLeft;
            }
            $AxisPos["L"] = $MinLeft - $ScaleSpacing;
          }
          elseif ($Parameters["Position"] == AXIS_POSITION_RIGHT) {
            if ($Floating) {
              $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,
              ));
            }
            else {
              $FloatingOffset = 0;
              $this
                ->drawLine($AxisPos["R"], $this->GraphAreaY1, $AxisPos["R"], $this->GraphAreaY2, array(
                "R" => $AxisR,
                "G" => $AxisG,
                "B" => $AxisB,
                "Alpha" => $AxisAlpha,
              ));
            }
            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,
              ));
            }
            $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $Parameters["Margin"] * 2;
            $Step = $Height / $Parameters["Rows"];
            $SubTicksSize = $Step / 2;
            $MaxLeft = $AxisPos["R"];
            $LastY = NULL;
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $YPos = $this->GraphAreaY2 - $Parameters["Margin"] - $Step * $i;
              $XPos = $AxisPos["R"];
              $Value = $this
                ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Parameters["Display"], $Parameters["Format"], $Parameters["Unit"]);
              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,
                );
              }
              if ($LastY != NULL && $CycleBackground && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))) {
                $this
                  ->drawFilledRectangle($this->GraphAreaX1 + $FloatingOffset, $LastY, $this->GraphAreaX2 - $FloatingOffset, $YPos, $BGColor);
              }
              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,
                ));
              }
              if ($DrawSubTicks && $i != $Parameters["Rows"]) {
                $this
                  ->drawLine($XPos - $OuterSubTickWidth, $YPos - $SubTicksSize, $XPos + $InnerSubTickWidth, $YPos - $SubTicksSize, array(
                  "R" => $SubTickR,
                  "G" => $SubTickG,
                  "B" => $SubTickB,
                  "Alpha" => $SubTickAlpha,
                ));
              }
              $this
                ->drawLine($XPos - $InnerTickWidth, $YPos, $XPos + $OuterTickWidth, $YPos, array(
                "R" => $TickR,
                "G" => $TickG,
                "B" => $TickB,
                "Alpha" => $TickAlpha,
              ));
              $Bounds = $this
                ->drawText($XPos + $OuterTickWidth + 2, $YPos, $Value, array(
                "Align" => TEXT_ALIGN_MIDDLELEFT,
              ));
              $TxtLeft = $XPos + $OuterTickWidth + 2 + ($Bounds[1]["X"] - $Bounds[0]["X"]);
              $MaxLeft = max($MaxLeft, $TxtLeft);
              $LastY = $YPos;
            }
            if (isset($Parameters["Name"])) {
              $XPos = $MaxLeft + 6;
              $YPos = $this->GraphAreaY1 + ($this->GraphAreaY2 - $this->GraphAreaY1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
                "Angle" => 270,
              ));
              $MaxLeft = $Bounds[2]["X"];
              $this->DataSet->Data["GraphArea"]["X2"] = $MaxLeft + $this->FontSize;
            }
            $AxisPos["R"] = $MaxLeft + $ScaleSpacing;
          }
        }
        elseif ($Pos == SCALE_POS_TOPBOTTOM) {
          if ($Parameters["Position"] == AXIS_POSITION_TOP) {
            if ($Floating) {
              $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,
              ));
            }
            else {
              $FloatingOffset = 0;
              $this
                ->drawLine($this->GraphAreaX1, $AxisPos["T"], $this->GraphAreaX2, $AxisPos["T"], array(
                "R" => $AxisR,
                "G" => $AxisG,
                "B" => $AxisB,
                "Alpha" => $AxisAlpha,
              ));
            }
            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,
              ));
            }
            $Width = $this->GraphAreaX2 - $this->GraphAreaX1 - $Parameters["Margin"] * 2;
            $Step = $Width / $Parameters["Rows"];
            $SubTicksSize = $Step / 2;
            $MinTop = $AxisPos["T"];
            $LastX = NULL;
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $XPos = $this->GraphAreaX1 + $Parameters["Margin"] + $Step * $i;
              $YPos = $AxisPos["T"];
              $Value = $this
                ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Parameters["Display"], $Parameters["Format"], $Parameters["Unit"]);
              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,
                );
              }
              if ($LastX != NULL && $CycleBackground && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))) {
                $this
                  ->drawFilledRectangle($LastX, $this->GraphAreaY1 + $FloatingOffset, $XPos, $this->GraphAreaY2 - $FloatingOffset, $BGColor);
              }
              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,
                ));
              }
              if ($DrawSubTicks && $i != $Parameters["Rows"]) {
                $this
                  ->drawLine($XPos + $SubTicksSize, $YPos - $OuterSubTickWidth, $XPos + $SubTicksSize, $YPos + $InnerSubTickWidth, array(
                  "R" => $SubTickR,
                  "G" => $SubTickG,
                  "B" => $SubTickB,
                  "Alpha" => $SubTickAlpha,
                ));
              }
              $this
                ->drawLine($XPos, $YPos - $OuterTickWidth, $XPos, $YPos + $InnerTickWidth, array(
                "R" => $TickR,
                "G" => $TickG,
                "B" => $TickB,
                "Alpha" => $TickAlpha,
              ));
              $Bounds = $this
                ->drawText($XPos, $YPos - $OuterTickWidth - 2, $Value, array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
              ));
              $TxtHeight = $YPos - $OuterTickWidth - 2 - ($Bounds[1]["Y"] - $Bounds[2]["Y"]);
              $MinTop = min($MinTop, $TxtHeight);
              $LastX = $XPos;
            }
            if (isset($Parameters["Name"])) {
              $YPos = $MinTop - 2;
              $XPos = $this->GraphAreaX1 + ($this->GraphAreaX2 - $this->GraphAreaX1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
              ));
              $MinTop = $Bounds[2]["Y"];
              $this->DataSet->Data["GraphArea"]["Y1"] = $MinTop;
            }
            $AxisPos["T"] = $MinTop - $ScaleSpacing;
          }
          elseif ($Parameters["Position"] == AXIS_POSITION_BOTTOM) {
            if ($Floating) {
              $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,
              ));
            }
            else {
              $FloatingOffset = 0;
              $this
                ->drawLine($this->GraphAreaX1, $AxisPos["B"], $this->GraphAreaX2, $AxisPos["B"], array(
                "R" => $AxisR,
                "G" => $AxisG,
                "B" => $AxisB,
                "Alpha" => $AxisAlpha,
              ));
            }
            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,
              ));
            }
            $Width = $this->GraphAreaX2 - $this->GraphAreaX1 - $Parameters["Margin"] * 2;
            $Step = $Width / $Parameters["Rows"];
            $SubTicksSize = $Step / 2;
            $MaxBottom = $AxisPos["B"];
            $LastX = NULL;
            for ($i = 0; $i <= $Parameters["Rows"]; $i++) {
              $XPos = $this->GraphAreaX1 + $Parameters["Margin"] + $Step * $i;
              $YPos = $AxisPos["B"];
              $Value = $this
                ->scaleFormat($Parameters["ScaleMin"] + $Parameters["RowHeight"] * $i, $Parameters["Display"], $Parameters["Format"], $Parameters["Unit"]);
              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,
                );
              }
              if ($LastX != NULL && $CycleBackground && ($DrawYLines == ALL || in_array($AxisID, $DrawYLines))) {
                $this
                  ->drawFilledRectangle($LastX, $this->GraphAreaY1 + $FloatingOffset, $XPos, $this->GraphAreaY2 - $FloatingOffset, $BGColor);
              }
              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,
                ));
              }
              if ($DrawSubTicks && $i != $Parameters["Rows"]) {
                $this
                  ->drawLine($XPos + $SubTicksSize, $YPos - $OuterSubTickWidth, $XPos + $SubTicksSize, $YPos + $InnerSubTickWidth, array(
                  "R" => $SubTickR,
                  "G" => $SubTickG,
                  "B" => $SubTickB,
                  "Alpha" => $SubTickAlpha,
                ));
              }
              $this
                ->drawLine($XPos, $YPos - $OuterTickWidth, $XPos, $YPos + $InnerTickWidth, array(
                "R" => $TickR,
                "G" => $TickG,
                "B" => $TickB,
                "Alpha" => $TickAlpha,
              ));
              $Bounds = $this
                ->drawText($XPos, $YPos + $OuterTickWidth + 2, $Value, array(
                "Align" => TEXT_ALIGN_TOPMIDDLE,
              ));
              $TxtHeight = $YPos + $OuterTickWidth + 2 + ($Bounds[1]["Y"] - $Bounds[2]["Y"]);
              $MaxBottom = max($MaxBottom, $TxtHeight);
              $LastX = $XPos;
            }
            if (isset($Parameters["Name"])) {
              $YPos = $MaxBottom + 2;
              $XPos = $this->GraphAreaX1 + ($this->GraphAreaX2 - $this->GraphAreaX1) / 2;
              $Bounds = $this
                ->drawText($XPos, $YPos, $Parameters["Name"], array(
                "Align" => TEXT_ALIGN_TOPMIDDLE,
              ));
              $MaxBottom = $Bounds[0]["Y"];
              $this->DataSet->Data["GraphArea"]["Y2"] = $MaxBottom + $this->FontSize;
            }
            $AxisPos["B"] = $MaxBottom + $ScaleSpacing;
          }
        }
      }
    }
  }
  function isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip) {
    if ($LabelingMethod == LABELING_DIFFERENT && $Value != $LastValue) {
      return TRUE;
    }
    if ($LabelingMethod == LABELING_DIFFERENT && $Value == $LastValue) {
      return FALSE;
    }
    if ($LabelingMethod == LABELING_ALL && $LabelSkip == 0) {
      return TRUE;
    }
    if ($LabelingMethod == LABELING_ALL && ($ID + $LabelSkip) % ($LabelSkip + 1) != 1) {
      return FALSE;
    }
    return TRUE;
  }

  /* Compute the scale, check for the best visual factors */
  function computeScale($XMin, $XMax, $MaxDivs, $Factors, $AxisID = 0) {

    /* Compute each factors */
    $Results = "";
    foreach ($Factors as $Key => $Factor) {
      $Results[$Factor] = $this
        ->processScale($XMin, $XMax, $MaxDivs, array(
        $Factor,
      ), $AxisID);
    }

    /* Remove scales that are creating to much decimals */
    $GoodScaleFactors = "";
    foreach ($Results as $Key => $Result) {
      $Decimals = preg_split("/\\./", $Result["RowHeight"]);
      if (!isset($Decimals[1]) || strlen($Decimals[1]) < 6) {
        $GoodScaleFactors[] = $Key;
      }
    }

    /* Found no correct scale, shame,... returns the 1st one as default */
    if ($GoodScaleFactors == "") {
      return $Results[$Factors[0]];
    }

    /* Find the factor that cause the maximum number of Rows */
    $MaxRows = 0;
    $BestFactor = 0;
    foreach ($GoodScaleFactors as $Key => $Factor) {
      if ($Results[$Factor]["Rows"] > $MaxRows) {
        $MaxRows = $Results[$Factor]["Rows"];
        $BestFactor = $Factor;
      }
    }

    /* Return the best visual scale */
    return $Results[$BestFactor];
  }

  /* Compute the best matching scale based on size & factors */
  function processScale($XMin, $XMax, $MaxDivs, $Factors, $AxisID) {
    $ScaleHeight = abs(ceil($XMax) - floor($XMin));
    if (isset($this->DataSet->Data["Axis"][$AxisID]["Format"])) {
      $Format = $this->DataSet->Data["Axis"][$AxisID]["Format"];
    }
    else {
      $Format = NULL;
    }
    if (isset($this->DataSet->Data["Axis"][$AxisID]["Display"])) {
      $Mode = $this->DataSet->Data["Axis"][$AxisID]["Display"];
    }
    else {
      $Mode = AXIS_FORMAT_DEFAULT;
    }
    $Scale = "";
    if ($XMin != $XMax) {
      $Found = FALSE;
      $Rescaled = FALSE;
      $Scaled10Factor = 0.0001;
      $Result = 0;
      while (!$Found) {
        foreach ($Factors as $Key => $Factor) {
          if (!$Found) {
            if (!($this
              ->modulo($XMin, $Factor * $Scaled10Factor) == 0) || $XMin != floor($XMin)) {
              $XMinRescaled = floor($XMin / ($Factor * $Scaled10Factor)) * $Factor * $Scaled10Factor;
            }
            else {
              $XMinRescaled = $XMin;
            }
            if (!($this
              ->modulo($XMax, $Factor * $Scaled10Factor) == 0) || $XMax != floor($XMax)) {
              $XMaxRescaled = floor($XMax / ($Factor * $Scaled10Factor)) * $Factor * $Scaled10Factor + $Factor * $Scaled10Factor;
            }
            else {
              $XMaxRescaled = $XMax;
            }
            $ScaleHeightRescaled = abs($XMaxRescaled - $XMinRescaled);
            if (!$Found && floor($ScaleHeightRescaled / ($Factor * $Scaled10Factor)) <= $MaxDivs) {
              $Found = TRUE;
              $Rescaled = TRUE;
              $Result = $Factor * $Scaled10Factor;
            }
          }
        }
        $Scaled10Factor = $Scaled10Factor * 10;
      }

      /* ReCall Min / Max / Height */
      if ($Rescaled) {
        $XMin = $XMinRescaled;
        $XMax = $XMaxRescaled;
        $ScaleHeight = $ScaleHeightRescaled;
      }

      /* Compute rows size */
      $Rows = floor($ScaleHeight / $Result);
      if ($Rows == 0) {
        $Rows = 1;
      }
      $RowHeight = $ScaleHeight / $Rows;

      /* Return the results */
      $Scale["Rows"] = $Rows;
      $Scale["RowHeight"] = $RowHeight;
      $Scale["XMin"] = $XMin;
      $Scale["XMax"] = $XMax;

      /* Compute the needed decimals for the metric view to avoid repetition of the same X Axis labels */
      if ($Mode == AXIS_FORMAT_METRIC && $Format == NULL) {
        $Done = FALSE;
        $GoodDecimals = 0;
        for ($Decimals = 0; $Decimals <= 10; $Decimals++) {
          if (!$Done) {
            $LastLabel = "zob";
            $ScaleOK = TRUE;
            for ($i = 0; $i <= $Rows; $i++) {
              $Value = $XMin + $i * $RowHeight;
              $Label = $this
                ->scaleFormat($Value, AXIS_FORMAT_METRIC, $Decimals);
              if ($LastLabel == $Label) {
                $ScaleOK = FALSE;
              }
              $LastLabel = $Label;
            }
            if ($ScaleOK) {
              $Done = TRUE;
              $GoodDecimals = $Decimals;
            }
          }
        }
        $Scale["Format"] = $GoodDecimals;
      }
    }
    else {

      /* If all values are the same we keep a +1/-1 scale */
      $Rows = 2;
      $XMin = $XMax - 1;
      $XMax = $XMax + 1;
      $RowHeight = 1;

      /* Return the results */
      $Scale["Rows"] = $Rows;
      $Scale["RowHeight"] = $RowHeight;
      $Scale["XMin"] = $XMin;
      $Scale["XMax"] = $XMax;
    }
    return $Scale;
  }
  function modulo($Value1, $Value2) {
    if (floor($Value2) == 0) {
      return 0;
    }
    if (floor($Value2) != 0) {
      return $Value1 % $Value2;
    }
    $MinValue = min($Value1, $Value2);
    $Factor = 10;
    while (floor($MinValue * $Factor) == 0) {
      $Factor = $Factor * 10;
    }
    return $Value1 * $Factor % ($Value2 * $Factor);
  }

  /* Draw an X threshold */
  function drawXThreshold($Value, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 255;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 50;
    $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : 6;
    $Wide = isset($Format["Wide"]) ? $Format["Wide"] : FALSE;
    $WideFactor = isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;
    $WriteCaption = isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;
    $Caption = isset($Format["Caption"]) ? $Format["Caption"] : NULL;
    $CaptionAlign = isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;
    $CaptionOffset = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 5;
    $CaptionR = isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;
    $CaptionG = isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;
    $CaptionB = isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;
    $CaptionAlpha = isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;
    $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;
    $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;
    $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 3;
    $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;
    $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
    $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 30;
    $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
    $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
    $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
    $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
    $BoxBorderAlpha = isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;
    $ValueIsLabel = isset($Format["ValueIsLabel"]) ? $Format["ValueIsLabel"] : FALSE;
    $Data = $this->DataSet
      ->getData();
    $AbscissaMargin = $this
      ->getAbscissaMargin($Data);
    $XScale = $this
      ->scaleGetXSettings();
    if (is_array($Value)) {
      foreach ($Value as $Key => $ID) {
        $this
          ->drawXThreshold($ID, $Format);
      }
      return 0;
    }
    if ($ValueIsLabel) {
      $Format["ValueIsLabel"] = FALSE;
      foreach ($Data["Series"][$Data["Abscissa"]]["Data"] as $Key => $SerieValue) {
        if ($SerieValue == $Value) {
          $this
            ->drawXThreshold($Key, $Format);
        }
      }
      return 0;
    }
    $CaptionSettings = array(
      "DrawBox" => $DrawBox,
      "DrawBoxBorder" => $DrawBoxBorder,
      "BorderOffset" => $BorderOffset,
      "BoxRounded" => $BoxRounded,
      "RoundedRadius" => $RoundedRadius,
      "BoxR" => $BoxR,
      "BoxG" => $BoxG,
      "BoxB" => $BoxB,
      "BoxAlpha" => $BoxAlpha,
      "BoxSurrounding" => $BoxSurrounding,
      "BoxBorderR" => $BoxBorderR,
      "BoxBorderG" => $BoxBorderG,
      "BoxBorderB" => $BoxBorderB,
      "BoxBorderAlpha" => $BoxBorderAlpha,
      "R" => $CaptionR,
      "G" => $CaptionG,
      "B" => $CaptionB,
      "Alpha" => $CaptionAlpha,
    );
    if ($Caption == NULL) {
      if (isset($Data["Abscissa"])) {
        if (isset($Data["Series"][$Data["Abscissa"]]["Data"][$Value])) {
          $Caption = $Data["Series"][$Data["Abscissa"]]["Data"][$Value];
        }
        else {
          $Caption = $Value;
        }
      }
      else {
        $Caption = $Value;
      }
    }
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XScale[0] * 2) / $XScale[1];
      $XPos = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value;
      $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];
      $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];
      if ($XPos >= $this->GraphAreaX1 + $AbscissaMargin && $XPos <= $this->GraphAreaX2 - $AbscissaMargin) {
        $this
          ->drawLine($XPos, $YPos1, $XPos, $YPos2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
          "Weight" => $Weight,
        ));
        if ($Wide) {
          $this
            ->drawLine($XPos - 1, $YPos1, $XPos - 1, $YPos2, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
          $this
            ->drawLine($XPos + 1, $YPos1, $XPos + 1, $YPos2, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
        }
        if ($WriteCaption) {
          if ($CaptionAlign == CAPTION_LEFT_TOP) {
            $Y = $YPos1 + $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
          }
          else {
            $Y = $YPos2 - $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE;
          }
          $this
            ->drawText($XPos, $Y, $Caption, $CaptionSettings);
        }
        return array(
          "X" => $XPos,
        );
      }
    }
    elseif ($Data["Orientation"] == SCALE_POS_TOPBOTTOM) {
      $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XScale[0] * 2) / $XScale[1];
      $XPos = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value;
      $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];
      $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];
      if ($XPos >= $this->GraphAreaY1 + $AbscissaMargin && $XPos <= $this->GraphAreaY2 - $AbscissaMargin) {
        $this
          ->drawLine($YPos1, $XPos, $YPos2, $XPos, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
          "Weight" => $Weight,
        ));
        if ($Wide) {
          $this
            ->drawLine($YPos1, $XPos - 1, $YPos2, $XPos - 1, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
          $this
            ->drawLine($YPos1, $XPos + 1, $YPos2, $XPos + 1, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
        }
        if ($WriteCaption) {
          if ($CaptionAlign == CAPTION_LEFT_TOP) {
            $Y = $YPos1 + $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT;
          }
          else {
            $Y = $YPos2 - $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT;
          }
          $this
            ->drawText($Y, $XPos, $Caption, $CaptionSettings);
        }
        return array(
          "X" => $XPos,
        );
      }
    }
  }

  /* Draw an X threshold area */
  function drawXThresholdArea($Value1, $Value2, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 255;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 20;
    $Border = isset($Format["Border"]) ? $Format["Border"] : TRUE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;
    $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;
    $AreaName = isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;
    $NameAngle = isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;
    $NameR = isset($Format["NameR"]) ? $Format["NameR"] : 255;
    $NameG = isset($Format["NameG"]) ? $Format["NameG"] : 255;
    $NameB = isset($Format["NameB"]) ? $Format["NameB"] : 255;
    $NameAlpha = isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;
    $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;
    $RestoreShadow = $this->Shadow;
    if ($DisableShadowOnArea && $this->Shadow) {
      $this->Shadow = FALSE;
    }
    if ($BorderAlpha > 100) {
      $BorderAlpha = 100;
    }
    $Data = $this->DataSet
      ->getData();
    $XScale = $this
      ->scaleGetXSettings();
    $AbscissaMargin = $this
      ->getAbscissaMargin($Data);
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XScale[0] * 2) / $XScale[1];
      $XPos1 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value1;
      $XPos2 = $this->GraphAreaX1 + $XScale[0] + $XStep * $Value2;
      $YPos1 = $this->GraphAreaY1 + $Data["YMargin"];
      $YPos2 = $this->GraphAreaY2 - $Data["YMargin"];
      if ($XPos1 < $this->GraphAreaX1 + $XScale[0]) {
        $XPos1 = $this->GraphAreaX1 + $XScale[0];
      }
      if ($XPos1 > $this->GraphAreaX2 - $XScale[0]) {
        $XPos1 = $this->GraphAreaX2 - $XScale[0];
      }
      if ($XPos2 < $this->GraphAreaX1 + $XScale[0]) {
        $XPos2 = $this->GraphAreaX1 + $XScale[0];
      }
      if ($XPos2 > $this->GraphAreaX2 - $XScale[0]) {
        $XPos2 = $this->GraphAreaX2 - $XScale[0];
      }
      $this
        ->drawFilledRectangle($XPos1, $YPos1, $XPos2, $YPos2, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      if ($Border) {
        $this
          ->drawLine($XPos1, $YPos1, $XPos1, $YPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
        $this
          ->drawLine($XPos2, $YPos1, $XPos2, $YPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
      }
      if ($AreaName != NULL) {
        $XPos = ($XPos2 - $XPos1) / 2 + $XPos1;
        $YPos = ($YPos2 - $YPos1) / 2 + $YPos1;
        if ($NameAngle == ZONE_NAME_ANGLE_AUTO) {
          $TxtPos = $this
            ->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $AreaName);
          $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];
          if (abs($XPos2 - $XPos1) > $TxtWidth) {
            $NameAngle = 0;
          }
          else {
            $NameAngle = 90;
          }
        }
        $this->Shadow = $RestoreShadow;
        $this
          ->drawText($XPos, $YPos, $AreaName, array(
          "R" => $NameR,
          "G" => $NameG,
          "B" => $NameB,
          "Alpha" => $NameAlpha,
          "Angle" => $NameAngle,
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
        ));
        if ($DisableShadowOnArea) {
          $this->Shadow = FALSE;
        }
      }
      $this->Shadow = $RestoreShadow;
      return array(
        "X1" => $XPos1,
        "X2" => $XPos2,
      );
    }
    elseif ($Data["Orientation"] == SCALE_POS_TOPBOTTOM) {
      $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XScale[0] * 2) / $XScale[1];
      $XPos1 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value1;
      $XPos2 = $this->GraphAreaY1 + $XScale[0] + $XStep * $Value2;
      $YPos1 = $this->GraphAreaX1 + $Data["YMargin"];
      $YPos2 = $this->GraphAreaX2 - $Data["YMargin"];
      if ($XPos1 < $this->GraphAreaY1 + $XScale[0]) {
        $XPos1 = $this->GraphAreaY1 + $XScale[0];
      }
      if ($XPos1 > $this->GraphAreaY2 - $XScale[0]) {
        $XPos1 = $this->GraphAreaY2 - $XScale[0];
      }
      if ($XPos2 < $this->GraphAreaY1 + $XScale[0]) {
        $XPos2 = $this->GraphAreaY1 + $XScale[0];
      }
      if ($XPos2 > $this->GraphAreaY2 - $XScale[0]) {
        $XPos2 = $this->GraphAreaY2 - $XScale[0];
      }
      $this
        ->drawFilledRectangle($YPos1, $XPos1, $YPos2, $XPos2, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      if ($Border) {
        $this
          ->drawLine($YPos1, $XPos1, $YPos2, $XPos1, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
        $this
          ->drawLine($YPos1, $XPos2, $YPos2, $XPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
      }
      if ($AreaName != NULL) {
        $XPos = ($XPos2 - $XPos1) / 2 + $XPos1;
        $YPos = ($YPos2 - $YPos1) / 2 + $YPos1;
        $this->Shadow = $RestoreShadow;
        $this
          ->drawText($YPos, $XPos, $AreaName, array(
          "R" => $NameR,
          "G" => $NameG,
          "B" => $NameB,
          "Alpha" => $NameAlpha,
          "Angle" => 0,
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
        ));
        if ($DisableShadowOnArea) {
          $this->Shadow = FALSE;
        }
      }
      $this->Shadow = $RestoreShadow;
      return array(
        "X1" => $XPos1,
        "X2" => $XPos2,
      );
    }
  }

  /* Draw an Y threshold with the computed scale */
  function drawThreshold($Value, $Format = "") {
    $AxisID = isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
    $R = isset($Format["R"]) ? $Format["R"] : 255;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 50;
    $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : 6;
    $Wide = isset($Format["Wide"]) ? $Format["Wide"] : FALSE;
    $WideFactor = isset($Format["WideFactor"]) ? $Format["WideFactor"] : 5;
    $WriteCaption = isset($Format["WriteCaption"]) ? $Format["WriteCaption"] : FALSE;
    $Caption = isset($Format["Caption"]) ? $Format["Caption"] : NULL;
    $CaptionAlign = isset($Format["CaptionAlign"]) ? $Format["CaptionAlign"] : CAPTION_LEFT_TOP;
    $CaptionOffset = isset($Format["CaptionOffset"]) ? $Format["CaptionOffset"] : 10;
    $CaptionR = isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;
    $CaptionG = isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;
    $CaptionB = isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;
    $CaptionAlpha = isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;
    $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;
    $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;
    $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;
    $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;
    $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
    $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;
    $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
    $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
    $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
    $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
    $BoxBorderAlpha = isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;
    $NoMargin = isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;
    if (is_array($Value)) {
      foreach ($Value as $Key => $ID) {
        $this
          ->drawThreshold($ID, $Format);
      }
      return 0;
    }
    $CaptionSettings = array(
      "DrawBox" => $DrawBox,
      "DrawBoxBorder" => $DrawBoxBorder,
      "BorderOffset" => $BorderOffset,
      "BoxRounded" => $BoxRounded,
      "RoundedRadius" => $RoundedRadius,
      "BoxR" => $BoxR,
      "BoxG" => $BoxG,
      "BoxB" => $BoxB,
      "BoxAlpha" => $BoxAlpha,
      "BoxSurrounding" => $BoxSurrounding,
      "BoxBorderR" => $BoxBorderR,
      "BoxBorderG" => $BoxBorderG,
      "BoxBorderB" => $BoxBorderB,
      "BoxBorderAlpha" => $BoxBorderAlpha,
      "R" => $CaptionR,
      "G" => $CaptionG,
      "B" => $CaptionB,
      "Alpha" => $CaptionAlpha,
    );
    $Data = $this->DataSet
      ->getData();
    $AbscissaMargin = $this
      ->getAbscissaMargin($Data);
    if ($NoMargin) {
      $AbscissaMargin = 0;
    }
    if (!isset($Data["Axis"][$AxisID])) {
      return -1;
    }
    if ($Caption == NULL) {
      $Caption = $Value;
    }
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $YPos = $this
        ->scaleComputeY($Value, array(
        "AxisID" => $AxisID,
      ));
      if ($YPos >= $this->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"] && $YPos <= $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"]) {
        $X1 = $this->GraphAreaX1 + $AbscissaMargin;
        $X2 = $this->GraphAreaX2 - $AbscissaMargin;
        $this
          ->drawLine($X1, $YPos, $X2, $YPos, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
          "Weight" => $Weight,
        ));
        if ($Wide) {
          $this
            ->drawLine($X1, $YPos - 1, $X2, $YPos - 1, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
          $this
            ->drawLine($X1, $YPos + 1, $X2, $YPos + 1, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
        }
        if ($WriteCaption) {
          if ($CaptionAlign == CAPTION_LEFT_TOP) {
            $X = $X1 + $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLELEFT;
          }
          else {
            $X = $X2 - $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_MIDDLERIGHT;
          }
          $this
            ->drawText($X, $YPos, $Caption, $CaptionSettings);
        }
      }
      return array(
        "Y" => $YPos,
      );
    }
    if ($Data["Orientation"] == SCALE_POS_TOPBOTTOM) {
      $XPos = $this
        ->scaleComputeY($Value, array(
        "AxisID" => $AxisID,
      ));
      if ($XPos >= $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] && $XPos <= $this->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"]) {
        $Y1 = $this->GraphAreaY1 + $AbscissaMargin;
        $Y2 = $this->GraphAreaY2 - $AbscissaMargin;
        $this
          ->drawLine($XPos, $Y1, $XPos, $Y2, array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
          "Weight" => $Weight,
        ));
        if ($Wide) {
          $this
            ->drawLine($XPos - 1, $Y1, $XPos - 1, $Y2, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
          $this
            ->drawLine($XPos + 1, $Y1, $XPos + 1, $Y2, array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha / $WideFactor,
            "Ticks" => $Ticks,
          ));
        }
        if ($WriteCaption) {
          if ($CaptionAlign == CAPTION_LEFT_TOP) {
            $Y = $Y1 + $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
          }
          else {
            $Y = $Y2 - $CaptionOffset;
            $CaptionSettings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE;
          }
          $CaptionSettings["Align"] = TEXT_ALIGN_TOPMIDDLE;
          $this
            ->drawText($XPos, $Y, $Caption, $CaptionSettings);
        }
      }
      return array(
        "Y" => $XPos,
      );
    }
  }

  /* Draw a threshold with the computed scale */
  function drawThresholdArea($Value1, $Value2, $Format = "") {
    $AxisID = isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
    $R = isset($Format["R"]) ? $Format["R"] : 255;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 20;
    $Border = isset($Format["Border"]) ? $Format["Border"] : TRUE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha + 20;
    $BorderTicks = isset($Format["BorderTicks"]) ? $Format["BorderTicks"] : 2;
    $AreaName = isset($Format["AreaName"]) ? $Format["AreaName"] : NULL;
    $NameAngle = isset($Format["NameAngle"]) ? $Format["NameAngle"] : ZONE_NAME_ANGLE_AUTO;
    $NameR = isset($Format["NameR"]) ? $Format["NameR"] : 255;
    $NameG = isset($Format["NameG"]) ? $Format["NameG"] : 255;
    $NameB = isset($Format["NameB"]) ? $Format["NameB"] : 255;
    $NameAlpha = isset($Format["NameAlpha"]) ? $Format["NameAlpha"] : 100;
    $DisableShadowOnArea = isset($Format["DisableShadowOnArea"]) ? $Format["DisableShadowOnArea"] : TRUE;
    $NoMargin = isset($Format["NoMargin"]) ? $Format["NoMargin"] : FALSE;
    if ($Value1 > $Value2) {
      list($Value1, $Value2) = array(
        $Value2,
        $Value1,
      );
    }
    $RestoreShadow = $this->Shadow;
    if ($DisableShadowOnArea && $this->Shadow) {
      $this->Shadow = FALSE;
    }
    if ($BorderAlpha > 100) {
      $BorderAlpha = 100;
    }
    $Data = $this->DataSet
      ->getData();
    $AbscissaMargin = $this
      ->getAbscissaMargin($Data);
    if ($NoMargin) {
      $AbscissaMargin = 0;
    }
    if (!isset($Data["Axis"][$AxisID])) {
      return -1;
    }
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $XPos1 = $this->GraphAreaX1 + $AbscissaMargin;
      $XPos2 = $this->GraphAreaX2 - $AbscissaMargin;
      $YPos1 = $this
        ->scaleComputeY($Value1, array(
        "AxisID" => $AxisID,
      ));
      $YPos2 = $this
        ->scaleComputeY($Value2, array(
        "AxisID" => $AxisID,
      ));
      if ($YPos1 < $this->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"]) {
        $YPos1 = $this->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"];
      }
      if ($YPos1 > $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"]) {
        $YPos1 = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"];
      }
      if ($YPos2 < $this->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"]) {
        $YPos2 = $this->GraphAreaY1 + $Data["Axis"][$AxisID]["Margin"];
      }
      if ($YPos2 > $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"]) {
        $YPos2 = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"];
      }
      $this
        ->drawFilledRectangle($XPos1, $YPos1, $XPos2, $YPos2, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      if ($Border) {
        $this
          ->drawLine($XPos1, $YPos1, $XPos2, $YPos1, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
        $this
          ->drawLine($XPos1, $YPos2, $XPos2, $YPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
      }
      if ($AreaName != NULL) {
        $XPos = ($XPos2 - $XPos1) / 2 + $XPos1;
        $YPos = ($YPos2 - $YPos1) / 2 + $YPos1;
        $this->Shadow = $RestoreShadow;
        $this
          ->drawText($XPos, $YPos, $AreaName, array(
          "R" => $NameR,
          "G" => $NameG,
          "B" => $NameB,
          "Alpha" => $NameAlpha,
          "Angle" => 0,
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
        ));
        if ($DisableShadowOnArea) {
          $this->Shadow = FALSE;
        }
      }
      $this->Shadow = $RestoreShadow;
      return array(
        "Y1" => $YPos1,
        "Y2" => $YPos2,
      );
    }
    elseif ($Data["Orientation"] == SCALE_POS_TOPBOTTOM) {
      $YPos1 = $this->GraphAreaY1 + $AbscissaMargin;
      $YPos2 = $this->GraphAreaY2 - $AbscissaMargin;
      $XPos1 = $this
        ->scaleComputeY($Value1, array(
        "AxisID" => $AxisID,
      ));
      $XPos2 = $this
        ->scaleComputeY($Value2, array(
        "AxisID" => $AxisID,
      ));
      if ($XPos1 < $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"]) {
        $XPos1 = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"];
      }
      if ($XPos1 > $this->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"]) {
        $XPos1 = $this->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"];
      }
      if ($XPos2 < $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"]) {
        $XPos2 = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"];
      }
      if ($XPos2 > $this->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"]) {
        $XPos2 = $this->GraphAreaX2 - $Data["Axis"][$AxisID]["Margin"];
      }
      $this
        ->drawFilledRectangle($XPos1, $YPos1, $XPos2, $YPos2, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      if ($Border) {
        $this
          ->drawLine($XPos1, $YPos1, $XPos1, $YPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
        $this
          ->drawLine($XPos2, $YPos1, $XPos2, $YPos2, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Ticks" => $BorderTicks,
        ));
      }
      if ($AreaName != NULL) {
        $XPos = ($YPos2 - $YPos1) / 2 + $YPos1;
        $YPos = ($XPos2 - $XPos1) / 2 + $XPos1;
        if ($NameAngle == ZONE_NAME_ANGLE_AUTO) {
          $TxtPos = $this
            ->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $AreaName);
          $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"];
          if (abs($XPos2 - $XPos1) > $TxtWidth) {
            $NameAngle = 0;
          }
          else {
            $NameAngle = 90;
          }
        }
        $this->Shadow = $RestoreShadow;
        $this
          ->drawText($YPos, $XPos, $AreaName, array(
          "R" => $NameR,
          "G" => $NameG,
          "B" => $NameB,
          "Alpha" => $NameAlpha,
          "Angle" => $NameAngle,
          "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
        ));
        if ($DisableShadowOnArea) {
          $this->Shadow = FALSE;
        }
      }
      $this->Shadow = $RestoreShadow;
      return array(
        "Y1" => $XPos1,
        "Y2" => $XPos2,
      );
    }
  }
  function scaleGetXSettings() {
    $Data = $this->DataSet
      ->getData();
    foreach ($Data["Axis"] as $AxisID => $Settings) {
      if ($Settings["Identity"] == AXIS_X) {
        $Rows = $Settings["Rows"];
        return array(
          $Settings["Margin"],
          $Rows,
        );
      }
    }
  }
  function scaleComputeY($Values, $Option = "", $ReturnOnly0Height = FALSE) {
    $AxisID = isset($Option["AxisID"]) ? $Option["AxisID"] : 0;
    $SerieName = isset($Option["SerieName"]) ? $Option["SerieName"] : NULL;
    $Data = $this->DataSet
      ->getData();
    if (!isset($Data["Axis"][$AxisID])) {
      return -1;
    }
    if ($SerieName != NULL) {
      $AxisID = $Data["Series"][$SerieName]["Axis"];
    }
    if (!is_array($Values)) {
      $tmp = $Values;
      $Values = "";
      $Values[0] = $tmp;
    }
    $Result = "";
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $Height = $this->GraphAreaY2 - $this->GraphAreaY1 - $Data["Axis"][$AxisID]["Margin"] * 2;
      $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
      $Step = $Height / $ScaleHeight;
      if ($ReturnOnly0Height) {
        foreach ($Values as $Key => $Value) {
          if ($Value == VOID) {
            $Result[] = VOID;
          }
          else {
            $Result[] = $Step * $Value;
          }
        }
      }
      else {
        foreach ($Values as $Key => $Value) {
          if ($Value == VOID) {
            $Result[] = VOID;
          }
          else {
            $Result[] = $this->GraphAreaY2 - $Data["Axis"][$AxisID]["Margin"] - $Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]);
          }
        }
      }
    }
    else {
      $Width = $this->GraphAreaX2 - $this->GraphAreaX1 - $Data["Axis"][$AxisID]["Margin"] * 2;
      $ScaleWidth = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
      $Step = $Width / $ScaleWidth;
      if ($ReturnOnly0Height) {
        foreach ($Values as $Key => $Value) {
          if ($Value == VOID) {
            $Result[] = VOID;
          }
          else {
            $Result[] = $Step * $Value;
          }
        }
      }
      else {
        foreach ($Values as $Key => $Value) {
          if ($Value == VOID) {
            $Result[] = VOID;
          }
          else {
            $Result[] = $this->GraphAreaX1 + $Data["Axis"][$AxisID]["Margin"] + $Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]);
          }
        }
      }
    }
    if (count($Result) == 1) {
      return $Result[0];
    }
    else {
      return $Result;
    }
  }

  /* Format the axis values */
  function scaleFormat($Value, $Mode = NULL, $Format = NULL, $Unit = NULL) {
    if ($Value == VOID) {
      return "";
    }
    if ($Mode == AXIS_FORMAT_TRAFFIC) {
      if ($Value == 0) {
        return "0B";
      }
      $Units = array(
        "B",
        "KB",
        "MB",
        "GB",
        "TB",
        "PB",
      );
      $Sign = "";
      if ($Value < 0) {
        $Value = abs($Value);
        $Sign = "-";
      }
      $Value = number_format($Value / pow(1024, $Scale = floor(log($Value, 1024))), 2, ",", ".");
      return $Sign . $Value . " " . $Units[$Scale];
    }
    if ($Mode == AXIS_FORMAT_CUSTOM) {
      if (function_exists($Format)) {
        return call_user_func($Format, $Value);
      }
    }
    if ($Mode == AXIS_FORMAT_DATE) {
      if ($Format == NULL) {
        $Pattern = "d/m/Y";
      }
      else {
        $Pattern = $Format;
      }
      return gmdate($Pattern, $Value);
    }
    if ($Mode == AXIS_FORMAT_TIME) {
      if ($Format == NULL) {
        $Pattern = "H:i:s";
      }
      else {
        $Pattern = $Format;
      }
      return gmdate($Pattern, $Value);
    }
    if ($Mode == AXIS_FORMAT_CURRENCY) {
      return $Format . number_format($Value, 2);
    }
    if ($Mode == AXIS_FORMAT_METRIC) {
      if (abs($Value) > 1000000000) {
        return round($Value / 1000000000, $Format) . "g" . $Unit;
      }
      if (abs($Value) > 1000000) {
        return round($Value / 1000000, $Format) . "m" . $Unit;
      }
      elseif (abs($Value) >= 1000) {
        return round($Value / 1000, $Format) . "k" . $Unit;
      }
    }
    return $Value . $Unit;
  }

  /* Write Max value on a chart */
  function writeBounds($Type = BOUND_BOTH, $Format = NULL) {
    $MaxLabelTxt = isset($Format["MaxLabelTxt"]) ? $Format["MaxLabelTxt"] : "max=";
    $MinLabelTxt = isset($Format["MinLabelTxt"]) ? $Format["MinLabelTxt"] : "min=";
    $Decimals = isset($Format["Decimals"]) ? $Format["Decimals"] : 1;
    $ExcludedSeries = isset($Format["ExcludedSeries"]) ? $Format["ExcludedSeries"] : "";
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $MaxDisplayR = isset($Format["MaxDisplayR"]) ? $Format["MaxDisplayR"] : 0;
    $MaxDisplayG = isset($Format["MaxDisplayG"]) ? $Format["MaxDisplayG"] : 0;
    $MaxDisplayB = isset($Format["MaxDisplayB"]) ? $Format["MaxDisplayB"] : 0;
    $MinDisplayR = isset($Format["MinDisplayR"]) ? $Format["MinDisplayR"] : 255;
    $MinDisplayG = isset($Format["MinDisplayG"]) ? $Format["MinDisplayG"] : 255;
    $MinDisplayB = isset($Format["MinDisplayB"]) ? $Format["MinDisplayB"] : 255;
    $MinLabelPos = isset($Format["MinLabelPos"]) ? $Format["MinLabelPos"] : BOUND_LABEL_POS_AUTO;
    $MaxLabelPos = isset($Format["MaxLabelPos"]) ? $Format["MaxLabelPos"] : BOUND_LABEL_POS_AUTO;
    $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : TRUE;
    $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : FALSE;
    $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;
    $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : TRUE;
    $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
    $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;
    $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
    $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
    $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
    $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
    $BoxBorderAlpha = isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;
    $CaptionSettings = array(
      "DrawBox" => $DrawBox,
      "DrawBoxBorder" => $DrawBoxBorder,
      "BorderOffset" => $BorderOffset,
      "BoxRounded" => $BoxRounded,
      "RoundedRadius" => $RoundedRadius,
      "BoxR" => $BoxR,
      "BoxG" => $BoxG,
      "BoxB" => $BoxB,
      "BoxAlpha" => $BoxAlpha,
      "BoxSurrounding" => $BoxSurrounding,
      "BoxBorderR" => $BoxBorderR,
      "BoxBorderG" => $BoxBorderG,
      "BoxBorderB" => $BoxBorderB,
      "BoxBorderAlpha" => $BoxBorderAlpha,
    );
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    $Data = $this->DataSet
      ->getData();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] && !isset($ExcludedSeries[$SerieName])) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $MinValue = $this->DataSet
          ->getMin($SerieName);
        $MaxValue = $this->DataSet
          ->getMax($SerieName);
        $MinPos = VOID;
        $MaxPos = VOID;
        foreach ($Serie["Data"] as $Key => $Value) {
          if ($Value == $MinValue && $MinPos == VOID) {
            $MinPos = $Key;
          }
          if ($Value == $MaxValue) {
            $MaxPos = $Key;
          }
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          $X = $this->GraphAreaX1 + $XMargin;
          $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;
          if ($Type == BOUND_MAX || $Type == BOUND_BOTH) {
            if ($MaxLabelPos == BOUND_LABEL_POS_TOP || $MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue >= 0) {
              $YPos = $PosArray[$MaxPos] - $DisplayOffset + 2;
              $Align = TEXT_ALIGN_BOTTOMMIDDLE;
            }
            if ($MaxLabelPos == BOUND_LABEL_POS_BOTTOM || $MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue < 0) {
              $YPos = $PosArray[$MaxPos] + $DisplayOffset + 2;
              $Align = TEXT_ALIGN_TOPMIDDLE;
            }
            $XPos = $X + $MaxPos * $XStep + $SerieOffset;
            $Label = $MaxLabelTxt . $this
              ->scaleFormat(round($MaxValue, $Decimals), $Mode, $Format, $Unit);
            $TxtPos = $this
              ->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $Label);
            $XOffset = 0;
            $YOffset = 0;
            if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
              $XOffset = ($this->GraphAreaX1 - $TxtPos[0]["X"]) / 2;
            }
            if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
              $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2) / 2);
            }
            if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
              $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"];
            }
            if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
              $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2);
            }
            $CaptionSettings["R"] = $MaxDisplayR;
            $CaptionSettings["G"] = $MaxDisplayG;
            $CaptionSettings["B"] = $MaxDisplayB;
            $CaptionSettings["Align"] = $Align;
            $this
              ->drawText($XPos + $XOffset, $YPos + $YOffset, $Label, $CaptionSettings);
          }
          if ($Type == BOUND_MIN || $Type == BOUND_BOTH) {
            if ($MinLabelPos == BOUND_LABEL_POS_TOP || $MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue >= 0) {
              $YPos = $PosArray[$MinPos] - $DisplayOffset + 2;
              $Align = TEXT_ALIGN_BOTTOMMIDDLE;
            }
            if ($MinLabelPos == BOUND_LABEL_POS_BOTTOM || $MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue < 0) {
              $YPos = $PosArray[$MinPos] + $DisplayOffset + 2;
              $Align = TEXT_ALIGN_TOPMIDDLE;
            }
            $XPos = $X + $MinPos * $XStep + $SerieOffset;
            $Label = $MinLabelTxt . $this
              ->scaleFormat(round($MinValue, $Decimals), $Mode, $Format, $Unit);
            $TxtPos = $this
              ->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $Label);
            $XOffset = 0;
            $YOffset = 0;
            if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
              $XOffset = ($this->GraphAreaX1 - $TxtPos[0]["X"]) / 2;
            }
            if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
              $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2) / 2);
            }
            if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
              $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"];
            }
            if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
              $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2);
            }
            $CaptionSettings["R"] = $MinDisplayR;
            $CaptionSettings["G"] = $MinDisplayG;
            $CaptionSettings["B"] = $MinDisplayB;
            $CaptionSettings["Align"] = $Align;
            $this
              ->drawText($XPos + $XOffset, $YPos - $DisplayOffset + $YOffset, $Label, $CaptionSettings);
          }
        }
        else {
          $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          $X = $this->GraphAreaY1 + $XMargin;
          $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;
          if ($Type == BOUND_MAX || $Type == BOUND_BOTH) {
            if ($MaxLabelPos == BOUND_LABEL_POS_TOP || $MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue >= 0) {
              $YPos = $PosArray[$MaxPos] + $DisplayOffset + 2;
              $Align = TEXT_ALIGN_MIDDLELEFT;
            }
            if ($MaxLabelPos == BOUND_LABEL_POS_BOTTOM || $MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue < 0) {
              $YPos = $PosArray[$MaxPos] - $DisplayOffset + 2;
              $Align = TEXT_ALIGN_MIDDLERIGHT;
            }
            $XPos = $X + $MaxPos * $XStep + $SerieOffset;
            $Label = $MaxLabelTxt . $this
              ->scaleFormat($MaxValue, $Mode, $Format, $Unit);
            $TxtPos = $this
              ->getTextBox($YPos, $XPos, $this->FontName, $this->FontSize, 0, $Label);
            $XOffset = 0;
            $YOffset = 0;
            if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
              $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"];
            }
            if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
              $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2);
            }
            if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
              $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"]) / 2;
            }
            if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
              $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2) / 2);
            }
            $CaptionSettings["R"] = $MaxDisplayR;
            $CaptionSettings["G"] = $MaxDisplayG;
            $CaptionSettings["B"] = $MaxDisplayB;
            $CaptionSettings["Align"] = $Align;
            $this
              ->drawText($YPos + $XOffset, $XPos + $YOffset, $Label, $CaptionSettings);
          }
          if ($Type == BOUND_MIN || $Type == BOUND_BOTH) {
            if ($MinLabelPos == BOUND_LABEL_POS_TOP || $MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue >= 0) {
              $YPos = $PosArray[$MinPos] + $DisplayOffset + 2;
              $Align = TEXT_ALIGN_MIDDLELEFT;
            }
            if ($MinLabelPos == BOUND_LABEL_POS_BOTTOM || $MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue < 0) {
              $YPos = $PosArray[$MinPos] - $DisplayOffset + 2;
              $Align = TEXT_ALIGN_MIDDLERIGHT;
            }
            $XPos = $X + $MinPos * $XStep + $SerieOffset;
            $Label = $MinLabelTxt . $this
              ->scaleFormat($MinValue, $Mode, $Format, $Unit);
            $TxtPos = $this
              ->getTextBox($YPos, $XPos, $this->FontName, $this->FontSize, 0, $Label);
            $XOffset = 0;
            $YOffset = 0;
            if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
              $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"];
            }
            if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
              $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2);
            }
            if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
              $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"]) / 2;
            }
            if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
              $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2) / 2);
            }
            $CaptionSettings["R"] = $MinDisplayR;
            $CaptionSettings["G"] = $MinDisplayG;
            $CaptionSettings["B"] = $MinDisplayB;
            $CaptionSettings["Align"] = $Align;
            $this
              ->drawText($YPos + $XOffset, $XPos + $YOffset, $Label, $CaptionSettings);
          }
        }
      }
    }
  }

  /* Draw a plot chart */
  function drawPlotChart($Format = NULL) {
    $PlotSize = isset($Format["PlotSize"]) ? $Format["PlotSize"] : NULL;
    $PlotBorder = isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : FALSE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : 50;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : 50;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : 50;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;
    $BorderSize = isset($Format["BorderSize"]) ? $Format["BorderSize"] : 2;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        if (isset($Serie["Weight"])) {
          $SerieWeight = $Serie["Weight"] + 2;
        }
        else {
          $SerieWeight = 2;
        }
        if ($PlotSize != NULL) {
          $SerieWeight = $PlotSize;
        }
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($Surrounding != NULL) {
          $BorderR = $R + $Surrounding;
          $BorderG = $G + $Surrounding;
          $BorderB = $B + $Surrounding;
        }
        if (isset($Serie["Picture"])) {
          $Picture = $Serie["Picture"];
          list($PicWidth, $PicHeight, $PicType) = $this
            ->getPicInfo($Picture);
        }
        else {
          $Picture = NULL;
          $PicOffset = 0;
        }
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Shape = $Serie["Shape"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          if ($Picture != NULL) {
            $PicOffset = $PicHeight / 2;
            $SerieWeight = 0;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues) {
              $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,
              ));
            }
            if ($Y != VOID) {
              if ($RecordImageMap) {
                $this
                  ->addToImageMap("CIRCLE", floor($X) . "," . floor($Y) . "," . $SerieWeight, $this
                  ->toHTMLColor($R, $G, $B), $SerieDescription, $this
                  ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit));
              }
              if ($Picture != NULL) {
                $this
                  ->drawFromPicture($PicType, $Picture, $X - $PicWidth / 2, $Y - $PicHeight / 2);
              }
              else {
                $this
                  ->drawShape($X, $Y, $Shape, $SerieWeight, $PlotBorder, $BorderSize, $R, $G, $B, $Alpha, $BorderR, $BorderG, $BorderB, $BorderAlpha);
              }
            }
            $X = $X + $XStep;
          }
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          if ($Picture != NULL) {
            $PicOffset = $PicWidth / 2;
            $SerieWeight = 0;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues) {
              $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,
              ));
            }
            if ($X != VOID) {
              if ($RecordImageMap) {
                $this
                  ->addToImageMap("CIRCLE", floor($X) . "," . floor($Y) . "," . $SerieWeight, $this
                  ->toHTMLColor($R, $G, $B), $SerieDescription, $this
                  ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit));
              }
              if ($Picture != NULL) {
                $this
                  ->drawFromPicture($PicType, $Picture, $X - $PicWidth / 2, $Y - $PicHeight / 2);
              }
              else {
                $this
                  ->drawShape($X, $Y, $Shape, $SerieWeight, $PlotBorder, $BorderSize, $R, $G, $B, $Alpha, $BorderR, $BorderG, $BorderB, $BorderAlpha);
              }
            }
            $Y = $Y + $YStep;
          }
        }
      }
    }
  }

  /* Draw a spline chart */
  function drawSplineChart($Format = NULL) {
    $BreakVoid = isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;
    $VoidTicks = isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    $BreakR = isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;

    // 234
    $BreakG = isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;

    // 55
    $BreakB = isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;

    // 26
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $ImageMapPlotSize = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        if ($BreakR == NULL) {
          $BreakSettings = array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
          );
        }
        else {
          $BreakSettings = array(
            "R" => $BreakR,
            "G" => $BreakG,
            "B" => $BreakB,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
            "Weight" => $Weight,
          );
        }
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $WayPoints = "";
          $Force = $XStep / 5;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $LastX = 1;
          $LastY = 1;
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues) {
              $this
                ->drawText($X, $Y - $DisplayOffset, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
              ));
            }
            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));
            }
            if ($Y == VOID && $LastY != NULL) {
              $this
                ->drawSpline($WayPoints, array(
                "Force" => $Force,
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              ));
              $WayPoints = "";
            }
            if ($Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid) {
              $this
                ->drawLine($LastGoodX, $LastGoodY, $X, $Y, $BreakSettings);
            }
            if ($Y != VOID) {
              $WayPoints[] = array(
                $X,
                $Y,
              );
            }
            if ($Y != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($Y == VOID) {
              $Y = NULL;
            }
            $LastX = $X;
            $LastY = $Y;
            $X = $X + $XStep;
          }
          $this
            ->drawSpline($WayPoints, array(
            "Force" => $Force,
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Ticks" => $Ticks,
            "Weight" => $Weight,
          ));
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $WayPoints = "";
          $Force = $YStep / 5;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $LastX = 1;
          $LastY = 1;
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues) {
              $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,
              ));
            }
            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));
            }
            if ($X == VOID && $LastX != NULL) {
              $this
                ->drawSpline($WayPoints, array(
                "Force" => $Force,
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              ));
              $WayPoints = "";
            }
            if ($X != VOID && $LastX == NULL && $LastGoodX != NULL && !$BreakVoid) {
              $this
                ->drawLine($LastGoodX, $LastGoodY, $X, $Y, $BreakSettings);
            }
            if ($X != VOID) {
              $WayPoints[] = array(
                $X,
                $Y,
              );
            }
            if ($X != VOID) {
              $LastGoodX = $X;
              $LastGoodY = $Y;
            }
            if ($X == VOID) {
              $X = NULL;
            }
            $LastX = $X;
            $LastY = $Y;
            $Y = $Y + $YStep;
          }
          $this
            ->drawSpline($WayPoints, array(
            "Force" => $Force,
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Ticks" => $Ticks,
            "Weight" => $Weight,
          ));
        }
      }
    }
  }

  /* Draw a filled spline chart */
  function drawFilledSplineChart($Format = NULL) {
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $AroundZero = isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    $Threshold = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($AroundZero) {
          $YZero = $this
            ->scaleComputeY(0, array(
            "AxisID" => $Serie["Axis"],
          ));
        }
        if ($Threshold != NULL) {
          foreach ($Threshold as $Key => $Params) {
            $Threshold[$Key]["MinX"] = $this
              ->scaleComputeY($Params["Min"], array(
              "AxisID" => $Serie["Axis"],
            ));
            $Threshold[$Key]["MaxX"] = $this
              ->scaleComputeY($Params["Max"], array(
              "AxisID" => $Serie["Axis"],
            ));
          }
        }
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $WayPoints = "";
          $Force = $XStep / 5;
          if (!$AroundZero) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($YZero < $this->GraphAreaY1 + 1) {
            $YZero = $this->GraphAreaY1 + 1;
          }
          $LastX = "";
          $LastY = "";
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues) {
              $this
                ->drawText($X, $Y - $DisplayOffset, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => TEXT_ALIGN_BOTTOMMIDDLE,
              ));
            }
            if ($Y == VOID) {
              $Area = $this
                ->drawSpline($WayPoints, array(
                "Force" => $Force,
                "PathOnly" => TRUE,
              ));
              if ($Area != "") {
                foreach ($Area as $key => $Points) {
                  $Corners = "";
                  $Corners[] = $Area[$key][0]["X"];
                  $Corners[] = $YZero;
                  foreach ($Points as $subKey => $Point) {
                    if ($subKey == count($Points) - 1) {
                      $Corners[] = $Point["X"] - 1;
                    }
                    else {
                      $Corners[] = $Point["X"];
                    }
                    $Corners[] = $Point["Y"] + 1;
                  }
                  $Corners[] = $Points[$subKey]["X"] - 1;
                  $Corners[] = $YZero;
                  $this
                    ->drawPolygonChart($Corners, array(
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha / 2,
                    "NoBorder" => TRUE,
                    "Threshold" => $Threshold,
                  ));
                }
                $this
                  ->drawSpline($WayPoints, array(
                  "Force" => $Force,
                  "R" => $R,
                  "G" => $G,
                  "B" => $B,
                  "Alpha" => $Alpha,
                  "Ticks" => $Ticks,
                ));
              }
              $WayPoints = "";
            }
            else {
              $WayPoints[] = array(
                $X,
                $Y - 0.5,
              );
            }

            /* -.5 for AA visual fix */
            $X = $X + $XStep;
          }
          $Area = $this
            ->drawSpline($WayPoints, array(
            "Force" => $Force,
            "PathOnly" => TRUE,
          ));
          if ($Area != "") {
            foreach ($Area as $key => $Points) {
              $Corners = "";
              $Corners[] = $Area[$key][0]["X"];
              $Corners[] = $YZero;
              foreach ($Points as $subKey => $Point) {
                if ($subKey == count($Points) - 1) {
                  $Corners[] = $Point["X"] - 1;
                }
                else {
                  $Corners[] = $Point["X"];
                }
                $Corners[] = $Point["Y"] + 1;
              }
              $Corners[] = $Points[$subKey]["X"] - 1;
              $Corners[] = $YZero;
              $this
                ->drawPolygonChart($Corners, array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha / 2,
                "NoBorder" => TRUE,
                "Threshold" => $Threshold,
              ));
            }
            $this
              ->drawSpline($WayPoints, array(
              "Force" => $Force,
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Alpha" => $Alpha,
              "Ticks" => $Ticks,
            ));
          }
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $WayPoints = "";
          $Force = $YStep / 5;
          if (!$AroundZero) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues) {
              $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,
              ));
            }
            if ($X == VOID) {
              $Area = $this
                ->drawSpline($WayPoints, array(
                "Force" => $Force,
                "PathOnly" => TRUE,
              ));
              if ($Area != "") {
                foreach ($Area as $key => $Points) {
                  $Corners = "";
                  $Corners[] = $YZero;
                  $Corners[] = $Area[$key][0]["Y"];
                  foreach ($Points as $subKey => $Point) {
                    if ($subKey == count($Points) - 1) {
                      $Corners[] = $Point["X"] - 1;
                    }
                    else {
                      $Corners[] = $Point["X"];
                    }
                    $Corners[] = $Point["Y"];
                  }
                  $Corners[] = $YZero;
                  $Corners[] = $Points[$subKey]["Y"] - 1;
                  $this
                    ->drawPolygonChart($Corners, array(
                    "R" => $R,
                    "G" => $G,
                    "B" => $B,
                    "Alpha" => $Alpha / 2,
                    "NoBorder" => TRUE,
                    "Threshold" => $Threshold,
                  ));
                }
                $this
                  ->drawSpline($WayPoints, array(
                  "Force" => $Force,
                  "R" => $R,
                  "G" => $G,
                  "B" => $B,
                  "Alpha" => $Alpha,
                  "Ticks" => $Ticks,
                ));
              }
              $WayPoints = "";
            }
            else {
              $WayPoints[] = array(
                $X,
                $Y,
              );
            }
            $Y = $Y + $YStep;
          }
          $Area = $this
            ->drawSpline($WayPoints, array(
            "Force" => $Force,
            "PathOnly" => TRUE,
          ));
          if ($Area != "") {
            foreach ($Area as $key => $Points) {
              $Corners = "";
              $Corners[] = $YZero;
              $Corners[] = $Area[$key][0]["Y"];
              foreach ($Points as $subKey => $Point) {
                if ($subKey == count($Points) - 1) {
                  $Corners[] = $Point["X"] - 1;
                }
                else {
                  $Corners[] = $Point["X"];
                }
                $Corners[] = $Point["Y"];
              }
              $Corners[] = $YZero;
              $Corners[] = $Points[$subKey]["Y"] - 1;
              $this
                ->drawPolygonChart($Corners, array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha / 2,
                "NoBorder" => TRUE,
                "Threshold" => $Threshold,
              ));
            }
            $this
              ->drawSpline($WayPoints, array(
              "Force" => $Force,
              "R" => $R,
              "G" => $G,
              "B" => $B,
              "Alpha" => $Alpha,
              "Ticks" => $Ticks,
            ));
          }
        }
      }
    }
  }

  /* Draw a line chart */
  function drawLineChart($Format = NULL) {
    $BreakVoid = isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : TRUE;
    $VoidTicks = isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    $BreakR = isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;
    $BreakG = isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;
    $BreakB = isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $ImageMapPlotSize = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;
    $ForceColor = isset($Format["ForceColor"]) ? $Format["ForceColor"] : FALSE;
    $ForceR = isset($Format["ForceR"]) ? $Format["ForceR"] : 0;
    $ForceG = isset($Format["ForceG"]) ? $Format["ForceG"] : 0;
    $ForceB = isset($Format["ForceB"]) ? $Format["ForceB"] : 0;
    $ForceAlpha = isset($Format["ForceAlpha"]) ? $Format["ForceAlpha"] : 100;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        if ($ForceColor) {
          $R = $ForceR;
          $G = $ForceG;
          $B = $ForceB;
          $Alpha = $ForceAlpha;
        }
        if ($BreakR == NULL) {
          $BreakSettings = array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
            "Weight" => $Weight,
          );
        }
        else {
          $BreakSettings = array(
            "R" => $BreakR,
            "G" => $BreakG,
            "B" => $BreakB,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
            "Weight" => $Weight,
          );
        }
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              if ($Serie["Data"][$Key] > 0) {
                $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                $Offset = $DisplayOffset;
              }
              else {
                $Align = TEXT_ALIGN_TOPMIDDLE;
                $Offset = -$DisplayOffset;
              }
              $this
                ->drawText($X, $Y - $Offset - $Weight, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => $Align,
              ));
            }
            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));
            }
            if ($Y != VOID && $LastX != NULL && $LastY != NULL) {
              $this
                ->drawLine($LastX, $LastY, $X, $Y, array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              ));
            }
            if ($Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid) {
              $this
                ->drawLine($LastGoodX, $LastGoodY, $X, $Y, $BreakSettings);
              $LastGoodY = NULL;
            }
            if ($Y != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($Y == VOID) {
              $Y = NULL;
            }
            $LastX = $X;
            $LastY = $Y;
            $X = $X + $XStep;
          }
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              $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,
              ));
            }
            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));
            }
            if ($X != VOID && $LastX != NULL && $LastY != NULL) {
              $this
                ->drawLine($LastX, $LastY, $X, $Y, array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              ));
            }
            if ($X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid) {
              $this
                ->drawLine($LastGoodX, $LastGoodY, $X, $Y, $BreakSettings);
              $LastGoodY = NULL;
            }
            if ($X != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($X == VOID) {
              $X = NULL;
            }
            $LastX = $X;
            $LastY = $Y;
            $Y = $Y + $YStep;
          }
        }
      }
    }
  }

  /* Draw a line chart */
  function drawZoneChart($SerieA, $SerieB, $Format = NULL) {
    $AxisID = isset($Format["AxisID"]) ? $Format["AxisID"] : 0;
    $LineR = isset($Format["LineR"]) ? $Format["LineR"] : 150;
    $LineG = isset($Format["LineG"]) ? $Format["LineG"] : 150;
    $LineB = isset($Format["LineB"]) ? $Format["LineB"] : 150;
    $LineAlpha = isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 50;
    $LineTicks = isset($Format["LineTicks"]) ? $Format["LineTicks"] : 1;
    $AreaR = isset($Format["AreaR"]) ? $Format["AreaR"] : 150;
    $AreaG = isset($Format["AreaG"]) ? $Format["AreaG"] : 150;
    $AreaB = isset($Format["AreaB"]) ? $Format["AreaB"] : 150;
    $AreaAlpha = isset($Format["AreaAlpha"]) ? $Format["AreaAlpha"] : 5;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    if (!isset($Data["Series"][$SerieA]["Data"]) || !isset($Data["Series"][$SerieB]["Data"])) {
      return 0;
    }
    $SerieAData = $Data["Series"][$SerieA]["Data"];
    $SerieBData = $Data["Series"][$SerieB]["Data"];
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    $Mode = $Data["Axis"][$AxisID]["Display"];
    $Format = $Data["Axis"][$AxisID]["Format"];
    $Unit = $Data["Axis"][$AxisID]["Unit"];
    $PosArrayA = $this
      ->scaleComputeY($SerieAData, array(
      "AxisID" => $AxisID,
    ));
    $PosArrayB = $this
      ->scaleComputeY($SerieBData, array(
      "AxisID" => $AxisID,
    ));
    if (count($PosArrayA) != count($PosArrayB)) {
      return 0;
    }
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      if ($XDivs == 0) {
        $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
      }
      else {
        $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
      }
      $X = $this->GraphAreaX1 + $XMargin;
      $LastX = NULL;
      $LastY = NULL;
      $LastX = NULL;
      $LastY1 = NULL;
      $LastY2 = NULL;
      $BoundsA = "";
      $BoundsB = "";
      foreach ($PosArrayA as $Key => $Y1) {
        $Y2 = $PosArrayB[$Key];
        $BoundsA[] = $X;
        $BoundsA[] = $Y1;
        $BoundsB[] = $X;
        $BoundsB[] = $Y2;
        $LastX = $X;
        $LastY1 = $Y1;
        $LastY2 = $Y2;
        $X = $X + $XStep;
      }
      $Bounds = array_merge($BoundsA, $this
        ->reversePlots($BoundsB));
      $this
        ->drawPolygonChart($Bounds, array(
        "R" => $AreaR,
        "G" => $AreaG,
        "B" => $AreaB,
        "Alpha" => $AreaAlpha,
      ));
      for ($i = 0; $i <= count($BoundsA) - 4; $i = $i + 2) {
        $this
          ->drawLine($BoundsA[$i], $BoundsA[$i + 1], $BoundsA[$i + 2], $BoundsA[$i + 3], array(
          "R" => $LineR,
          "G" => $LineG,
          "B" => $LineB,
          "Alpha" => $LineAlpha,
          "Ticks" => $LineTicks,
        ));
        $this
          ->drawLine($BoundsB[$i], $BoundsB[$i + 1], $BoundsB[$i + 2], $BoundsB[$i + 3], array(
          "R" => $LineR,
          "G" => $LineG,
          "B" => $LineB,
          "Alpha" => $LineAlpha,
          "Ticks" => $LineTicks,
        ));
      }
    }
    else {
      if ($XDivs == 0) {
        $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
      }
      else {
        $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
      }
      $Y = $this->GraphAreaY1 + $XMargin;
      $LastX = NULL;
      $LastY = NULL;
      $LastY = NULL;
      $LastX1 = NULL;
      $LastX2 = NULL;
      $BoundsA = "";
      $BoundsB = "";
      foreach ($PosArrayA as $Key => $X1) {
        $X2 = $PosArrayB[$Key];
        $BoundsA[] = $X1;
        $BoundsA[] = $Y;
        $BoundsB[] = $X2;
        $BoundsB[] = $Y;
        $LastY = $Y;
        $LastX1 = $X1;
        $LastX2 = $X2;
        $Y = $Y + $YStep;
      }
      $Bounds = array_merge($BoundsA, $this
        ->reversePlots($BoundsB));
      $this
        ->drawPolygonChart($Bounds, array(
        "R" => $AreaR,
        "G" => $AreaG,
        "B" => $AreaB,
        "Alpha" => $AreaAlpha,
      ));
      for ($i = 0; $i <= count($BoundsA) - 4; $i = $i + 2) {
        $this
          ->drawLine($BoundsA[$i], $BoundsA[$i + 1], $BoundsA[$i + 2], $BoundsA[$i + 3], array(
          "R" => $LineR,
          "G" => $LineG,
          "B" => $LineB,
          "Alpha" => $LineAlpha,
          "Ticks" => $LineTicks,
        ));
        $this
          ->drawLine($BoundsB[$i], $BoundsB[$i + 1], $BoundsB[$i + 2], $BoundsB[$i + 3], array(
          "R" => $LineR,
          "G" => $LineG,
          "B" => $LineB,
          "Alpha" => $LineAlpha,
          "Ticks" => $LineTicks,
        ));
      }
    }
  }

  /* Draw a step chart */
  function drawStepChart($Format = NULL) {
    $BreakVoid = isset($Format["BreakVoid"]) ? $Format["BreakVoid"] : FALSE;
    $ReCenter = isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;
    $VoidTicks = isset($Format["VoidTicks"]) ? $Format["VoidTicks"] : 4;
    $BreakR = isset($Format["BreakR"]) ? $Format["BreakR"] : NULL;
    $BreakG = isset($Format["BreakG"]) ? $Format["BreakG"] : NULL;
    $BreakB = isset($Format["BreakB"]) ? $Format["BreakB"] : NULL;
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $ImageMapPlotSize = isset($Format["ImageMapPlotSize"]) ? $Format["ImageMapPlotSize"] : 5;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        if ($BreakR == NULL) {
          $BreakSettings = array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
            "Weight" => $Weight,
          );
        }
        else {
          $BreakSettings = array(
            "R" => $BreakR,
            "G" => $BreakG,
            "B" => $BreakB,
            "Alpha" => $Alpha,
            "Ticks" => $VoidTicks,
            "Weight" => $Weight,
          );
        }
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $Color = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
          "Weight" => $Weight,
        );
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $Init = FALSE;
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              if ($Y <= $LastY) {
                $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                $Offset = $DisplayOffset;
              }
              else {
                $Align = TEXT_ALIGN_TOPMIDDLE;
                $Offset = -$DisplayOffset;
              }
              $this
                ->drawText($X, $Y - $Offset - $Weight, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => $Align,
              ));
            }
            if ($Y != VOID && $LastX != NULL && $LastY != NULL) {
              $this
                ->drawLine($LastX, $LastY, $X, $LastY, $Color);
              $this
                ->drawLine($X, $LastY, $X, $Y, $Color);
              if ($ReCenter && $X + $XStep < $this->GraphAreaX2 - $XMargin) {
                $this
                  ->drawLine($X, $Y, $X + $XStep, $Y, $Color);
                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));
                }
              }
              else {
                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));
                }
              }
            }
            if ($Y != VOID && $LastY == NULL && $LastGoodY != NULL && !$BreakVoid) {
              if ($ReCenter) {
                $this
                  ->drawLine($LastGoodX + $XStep, $LastGoodY, $X, $LastGoodY, $BreakSettings);
                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));
                }
              }
              else {
                $this
                  ->drawLine($LastGoodX, $LastGoodY, $X, $LastGoodY, $BreakSettings);
                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));
                }
              }
              $this
                ->drawLine($X, $LastGoodY, $X, $Y, $BreakSettings);
              $LastGoodY = NULL;
            }
            elseif (!$BreakVoid && $LastGoodY == NULL && $Y != VOID) {
              $this
                ->drawLine($this->GraphAreaX1 + $XMargin, $Y, $X, $Y, $BreakSettings);
              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));
              }
            }
            if ($Y != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($Y == VOID) {
              $Y = NULL;
            }
            if (!$Init && $ReCenter) {
              $X = $X - $XStep / 2;
              $Init = TRUE;
            }
            $LastX = $X;
            $LastY = $Y;
            if ($LastX < $this->GraphAreaX1 + $XMargin) {
              $LastX = $this->GraphAreaX1 + $XMargin;
            }
            $X = $X + $XStep;
          }
          if ($ReCenter) {
            $this
              ->drawLine($LastX, $LastY, $this->GraphAreaX2 - $XMargin, $LastY, $Color);
            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));
            }
          }
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $Init = FALSE;
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              if ($X >= $LastX) {
                $Align = TEXT_ALIGN_MIDDLELEFT;
                $Offset = $DisplayOffset;
              }
              else {
                $Align = TEXT_ALIGN_MIDDLERIGHT;
                $Offset = -$DisplayOffset;
              }
              $this
                ->drawText($X + $Offset + $Weight, $Y, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => $Align,
              ));
            }
            if ($X != VOID && $LastX != NULL && $LastY != NULL) {
              $this
                ->drawLine($LastX, $LastY, $LastX, $Y, $Color);
              $this
                ->drawLine($LastX, $Y, $X, $Y, $Color);
              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));
              }
            }
            if ($X != VOID && $LastX == NULL && $LastGoodY != NULL && !$BreakVoid) {
              $this
                ->drawLine($LastGoodX, $LastGoodY, $LastGoodX, $LastGoodY + $YStep, $Color);
              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));
              }
              $this
                ->drawLine($LastGoodX, $LastGoodY + $YStep, $LastGoodX, $Y, $BreakSettings);
              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));
              }
              $this
                ->drawLine($LastGoodX, $Y, $X, $Y, $BreakSettings);
              $LastGoodY = NULL;
            }
            elseif ($X != VOID && $LastGoodY == NULL && !$BreakVoid) {
              $this
                ->drawLine($X, $this->GraphAreaY1 + $XMargin, $X, $Y, $BreakSettings);
              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));
              }
            }
            if ($X != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($X == VOID) {
              $X = NULL;
            }
            if (!$Init && $ReCenter) {
              $Y = $Y - $YStep / 2;
              $Init = TRUE;
            }
            $LastX = $X;
            $LastY = $Y;
            if ($LastY < $this->GraphAreaY1 + $XMargin) {
              $LastY = $this->GraphAreaY1 + $XMargin;
            }
            $Y = $Y + $YStep;
          }
          if ($ReCenter) {
            $this
              ->drawLine($LastX, $LastY, $LastX, $this->GraphAreaY2 - $XMargin, $Color);
            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));
            }
          }
        }
      }
    }
  }

  /* Draw a step chart */
  function drawFilledStepChart($Format = NULL) {
    $ReCenter = isset($Format["ReCenter"]) ? $Format["ReCenter"] : TRUE;
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $ForceTransparency = isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $AroundZero = isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $Color = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
        );
        if ($ForceTransparency != NULL) {
          $Color["Alpha"] = $ForceTransparency;
        }
        else {
          $Color["Alpha"] = $Alpha;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $YZero = $this
          ->scaleComputeY(0, array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($YZero < $this->GraphAreaY1 + 1) {
            $YZero = $this->GraphAreaY1 + 1;
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!$AroundZero) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $Points = "";
          $Init = FALSE;
          foreach ($PosArray as $Key => $Y) {
            if ($Y == VOID && $LastX != NULL && $LastY != NULL && $Points != "") {
              $Points[] = $LastX;
              $Points[] = $LastY;
              $Points[] = $X;
              $Points[] = $LastY;
              $Points[] = $X;
              $Points[] = $YZero;
              $this
                ->drawPolygon($Points, $Color);
              $Points = "";
            }
            if ($Y != VOID && $LastX != NULL && $LastY != NULL) {
              if ($Points == "") {
                $Points[] = $LastX;
                $Points[] = $YZero;
              }
              $Points[] = $LastX;
              $Points[] = $LastY;
              $Points[] = $X;
              $Points[] = $LastY;
              $Points[] = $X;
              $Points[] = $Y;
            }
            if ($Y != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($Y == VOID) {
              $Y = NULL;
            }
            if (!$Init && $ReCenter) {
              $X = $X - $XStep / 2;
              $Init = TRUE;
            }
            $LastX = $X;
            $LastY = $Y;
            if ($LastX < $this->GraphAreaX1 + $XMargin) {
              $LastX = $this->GraphAreaX1 + $XMargin;
            }
            $X = $X + $XStep;
          }
          if ($ReCenter) {
            $Points[] = $LastX + $XStep / 2;
            $Points[] = $LastY;
            $Points[] = $LastX + $XStep / 2;
            $Points[] = $YZero;
          }
          else {
            $Points[] = $LastX;
            $Points[] = $YZero;
          }
          $this
            ->drawPolygon($Points, $Color);
        }
        else {
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $LastGoodY = NULL;
          $LastGoodX = NULL;
          $Points = "";
          foreach ($PosArray as $Key => $X) {
            if ($X == VOID && $LastX != NULL && $LastY != NULL && $Points != "") {
              $Points[] = $LastX;
              $Points[] = $LastY;
              $Points[] = $LastX;
              $Points[] = $Y;
              $Points[] = $YZero;
              $Points[] = $Y;
              $this
                ->drawPolygon($Points, $Color);
              $Points = "";
            }
            if ($X != VOID && $LastX != NULL && $LastY != NULL) {
              if ($Points == "") {
                $Points[] = $YZero;
                $Points[] = $LastY;
              }
              $Points[] = $LastX;
              $Points[] = $LastY;
              $Points[] = $LastX;
              $Points[] = $Y;
              $Points[] = $X;
              $Points[] = $Y;
            }
            if ($X != VOID) {
              $LastGoodY = $Y;
              $LastGoodX = $X;
            }
            if ($X == VOID) {
              $X = NULL;
            }
            if ($LastX == NULL && $ReCenter) {
              $Y = $Y - $YStep / 2;
            }
            $LastX = $X;
            $LastY = $Y;
            if ($LastY < $this->GraphAreaY1 + $XMargin) {
              $LastY = $this->GraphAreaY1 + $XMargin;
            }
            $Y = $Y + $YStep;
          }
          if ($ReCenter) {
            $Points[] = $LastX;
            $Points[] = $LastY + $YStep / 2;
            $Points[] = $YZero;
            $Points[] = $LastY + $YStep / 2;
          }
          else {
            $Points[] = $YZero;
            $Points[] = $LastY;
          }
          $this
            ->drawPolygon($Points, $Color);
        }
      }
    }
  }

  /* Draw an area chart */
  function drawAreaChart($Format = NULL) {
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $ForceTransparency = isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : 25;
    $AroundZero = isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    $Threshold = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        $YZero = $this
          ->scaleComputeY(0, array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($Threshold != NULL) {
          foreach ($Threshold as $Key => $Params) {
            $Threshold[$Key]["MinX"] = $this
              ->scaleComputeY($Params["Min"], array(
              "AxisID" => $Serie["Axis"],
            ));
            $Threshold[$Key]["MaxX"] = $this
              ->scaleComputeY($Params["Max"], array(
              "AxisID" => $Serie["Axis"],
            ));
          }
        }
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          $Areas = "";
          $AreaID = 0;
          $Areas[$AreaID][] = $this->GraphAreaX1 + $XMargin;
          if ($AroundZero) {
            $Areas[$AreaID][] = $YZero;
          }
          else {
            $Areas[$AreaID][] = $this->GraphAreaY2 - 1;
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $Y) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              if ($Serie["Data"][$Key] > 0) {
                $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                $Offset = $DisplayOffset;
              }
              else {
                $Align = TEXT_ALIGN_TOPMIDDLE;
                $Offset = -$DisplayOffset;
              }
              $this
                ->drawText($X, $Y - $Offset, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => $Align,
              ));
            }
            if ($Y == VOID && isset($Areas[$AreaID])) {
              if ($LastX == NULL) {
                $Areas[$AreaID][] = $X;
              }
              else {
                $Areas[$AreaID][] = $LastX;
              }
              if ($AroundZero) {
                $Areas[$AreaID][] = $YZero;
              }
              else {
                $Areas[$AreaID][] = $this->GraphAreaY2 - 1;
              }
              $AreaID++;
            }
            elseif ($Y != VOID) {
              if (!isset($Areas[$AreaID])) {
                $Areas[$AreaID][] = $X;
                if ($AroundZero) {
                  $Areas[$AreaID][] = $YZero;
                }
                else {
                  $Areas[$AreaID][] = $this->GraphAreaY2 - 1;
                }
              }
              $Areas[$AreaID][] = $X;
              $Areas[$AreaID][] = $Y;
            }
            $LastX = $X;
            $X = $X + $XStep;
          }
          $Areas[$AreaID][] = $LastX;
          if ($AroundZero) {
            $Areas[$AreaID][] = $YZero;
          }
          else {
            $Areas[$AreaID][] = $this->GraphAreaY2 - 1;
          }

          /* Handle shadows in the areas */
          if ($this->Shadow) {
            $ShadowArea = "";
            foreach ($Areas as $Key => $Points) {
              $ShadowArea[$Key] = "";
              foreach ($Points as $Key2 => $Value) {
                if ($Key2 % 2 == 0) {
                  $ShadowArea[$Key][] = $Value + $this->ShadowX;
                }
                else {
                  $ShadowArea[$Key][] = $Value + $this->ShadowY;
                }
              }
            }
            foreach ($ShadowArea as $Key => $Points) {
              $this
                ->drawPolygonChart($Points, array(
                "R" => $this->ShadowR,
                "G" => $this->ShadowG,
                "B" => $this->ShadowB,
                "Alpha" => $this->Shadowa,
              ));
            }
          }
          $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;
          $Color = array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Threshold" => $Threshold,
          );
          foreach ($Areas as $Key => $Points) {
            $this
              ->drawPolygonChart($Points, $Color);
          }
        }
        else {
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          $Areas = "";
          $AreaID = 0;
          if ($AroundZero) {
            $Areas[$AreaID][] = $YZero;
          }
          else {
            $Areas[$AreaID][] = $this->GraphAreaX1 + 1;
          }
          $Areas[$AreaID][] = $this->GraphAreaY1 + $XMargin;
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $LastX = NULL;
          $LastY = NULL;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $X) {
            if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
              if ($Serie["Data"][$Key] > 0) {
                $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                $Offset = $DisplayOffset;
              }
              else {
                $Align = TEXT_ALIGN_TOPMIDDLE;
                $Offset = -$DisplayOffset;
              }
              $this
                ->drawText($X + $Offset, $Y, $this
                ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit), array(
                "Angle" => 270,
                "R" => $DisplayR,
                "G" => $DisplayG,
                "B" => $DisplayB,
                "Align" => $Align,
              ));
            }
            if ($X == VOID && isset($Areas[$AreaID])) {
              if ($AroundZero) {
                $Areas[$AreaID][] = $YZero;
              }
              else {
                $Areas[$AreaID][] = $this->GraphAreaX1 + 1;
              }
              if ($LastY == NULL) {
                $Areas[$AreaID][] = $Y;
              }
              else {
                $Areas[$AreaID][] = $LastY;
              }
              $AreaID++;
            }
            elseif ($X != VOID) {
              if (!isset($Areas[$AreaID])) {
                if ($AroundZero) {
                  $Areas[$AreaID][] = $YZero;
                }
                else {
                  $Areas[$AreaID][] = $this->GraphAreaX1 + 1;
                }
                $Areas[$AreaID][] = $Y;
              }
              $Areas[$AreaID][] = $X;
              $Areas[$AreaID][] = $Y;
            }
            $LastX = $X;
            $LastY = $Y;
            $Y = $Y + $YStep;
          }
          if ($AroundZero) {
            $Areas[$AreaID][] = $YZero;
          }
          else {
            $Areas[$AreaID][] = $this->GraphAreaX1 + 1;
          }
          $Areas[$AreaID][] = $LastY;

          /* Handle shadows in the areas */
          if ($this->Shadow) {
            $ShadowArea = "";
            foreach ($Areas as $Key => $Points) {
              $ShadowArea[$Key] = "";
              foreach ($Points as $Key2 => $Value) {
                if ($Key2 % 2 == 0) {
                  $ShadowArea[$Key][] = $Value + $this->ShadowX;
                }
                else {
                  $ShadowArea[$Key][] = $Value + $this->ShadowY;
                }
              }
            }
            foreach ($ShadowArea as $Key => $Points) {
              $this
                ->drawPolygonChart($Points, array(
                "R" => $this->ShadowR,
                "G" => $this->ShadowG,
                "B" => $this->ShadowB,
                "Alpha" => $this->Shadowa,
              ));
            }
          }
          $Alpha = $ForceTransparency != NULL ? $ForceTransparency : $Alpha;
          $Color = array(
            "R" => $R,
            "G" => $G,
            "B" => $B,
            "Alpha" => $Alpha,
            "Threshold" => $Threshold,
          );
          foreach ($Areas as $Key => $Points) {
            $this
              ->drawPolygonChart($Points, $Color);
          }
        }
      }
    }
  }

  /* Draw a bar chart */
  function drawBarChart($Format = NULL) {
    $Floating0Serie = isset($Format["Floating0Serie"]) ? $Format["Floating0Serie"] : NULL;
    $Floating0Value = isset($Format["Floating0Value"]) ? $Format["Floating0Value"] : NULL;
    $Draw0Line = isset($Format["Draw0Line"]) ? $Format["Draw0Line"] : FALSE;
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_HORIZONTAL;
    $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 2;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayFont = isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontName;
    $DisplaySize = isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;
    $DisplayPos = isset($Format["DisplayPos"]) ? $Format["DisplayPos"] : LABEL_POS_OUTSIDE;
    $DisplayShadow = isset($Format["DisplayShadow"]) ? $Format["DisplayShadow"] : TRUE;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $AroundZero = isset($Format["AroundZero"]) ? $Format["AroundZero"] : TRUE;
    $Interleave = isset($Format["Interleave"]) ? $Format["Interleave"] : 0.5;
    $Rounded = isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;
    $RoundRadius = isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $Gradient = isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;
    $GradientMode = isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;
    $GradientAlpha = isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;
    $GradientStartR = isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    $GradientStartG = isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    $GradientStartB = isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    $GradientEndR = isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;
    $GradientEndG = isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;
    $GradientEndB = isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;
    $TxtMargin = isset($Format["TxtMargin"]) ? $Format["TxtMargin"] : 6;
    $OverrideColors = isset($Format["OverrideColors"]) ? $Format["OverrideColors"] : NULL;
    $OverrideSurrounding = isset($Format["OverrideSurrounding"]) ? $Format["OverrideSurrounding"] : 30;
    $InnerSurrounding = isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;
    $InnerBorderR = isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;
    $InnerBorderG = isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;
    $InnerBorderB = isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $this->LastChartLayout = CHART_LAST_LAYOUT_REGULAR;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    if ($OverrideColors != NULL) {
      $OverrideColors = $this
        ->validatePalette($OverrideColors, $OverrideSurrounding);
      $this->DataSet
        ->saveExtendedData("Palette", $OverrideColors);
    }
    $RestoreShadow = $this->Shadow;
    $SeriesCount = $this
      ->countDrawableSeries();
    $CurrentSerie = 0;
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = $R;
          $DisplayG = $G;
          $DisplayB = $B;
        }
        if ($Surrounding != NULL) {
          $BorderR = $R + $Surrounding;
          $BorderG = $G + $Surrounding;
          $BorderB = $B + $Surrounding;
        }
        if ($InnerSurrounding != NULL) {
          $InnerBorderR = $R + $InnerSurrounding;
          $InnerBorderG = $G + $InnerSurrounding;
          $InnerBorderB = $B + $InnerSurrounding;
        }
        if ($InnerBorderR == -1) {
          $InnerColor = NULL;
        }
        else {
          $InnerColor = array(
            "R" => $InnerBorderR,
            "G" => $InnerBorderG,
            "B" => $InnerBorderB,
          );
        }
        $Color = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "BorderR" => $BorderR,
          "BorderG" => $BorderG,
          "BorderB" => $BorderB,
        );
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($Floating0Value != NULL) {
          $YZero = $this
            ->scaleComputeY($Floating0Value, array(
            "AxisID" => $Serie["Axis"],
          ));
        }
        else {
          $YZero = $this
            ->scaleComputeY(0, array(
            "AxisID" => $Serie["Axis"],
          ));
        }
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($YZero < $this->GraphAreaY1 + 1) {
            $YZero = $this->GraphAreaY1 + 1;
          }
          if ($XDivs == 0) {
            $XStep = 0;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          if ($AroundZero) {
            $Y1 = $YZero;
          }
          else {
            $Y1 = $this->GraphAreaY2 - 1;
          }
          if ($XDivs == 0) {
            $XSize = ($this->GraphAreaX2 - $this->GraphAreaX1) / ($SeriesCount + $Interleave);
          }
          else {
            $XSize = $XStep / ($SeriesCount + $Interleave);
          }
          $XOffset = -($XSize * $SeriesCount) / 2 + $CurrentSerie * $XSize;
          if ($X + $XOffset <= $this->GraphAreaX1) {
            $XOffset = $this->GraphAreaX1 - $X + 1;
          }
          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $XOffset + $XSize / 2;
          if ($Rounded || $BorderR != -1) {
            $XSpace = 1;
          }
          else {
            $XSpace = 0;
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $ID = 0;
          foreach ($PosArray as $Key => $Y2) {
            if ($Floating0Serie != NULL) {
              if (isset($Data["Series"][$Floating0Serie]["Data"][$Key])) {
                $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];
              }
              else {
                $Value = 0;
              }
              $YZero = $this
                ->scaleComputeY($Value, array(
                "AxisID" => $Serie["Axis"],
              ));
              if ($YZero > $this->GraphAreaY2 - 1) {
                $YZero = $this->GraphAreaY2 - 1;
              }
              if ($YZero < $this->GraphAreaY1 + 1) {
                $YZero = $this->GraphAreaY1 + 1;
              }
              if ($AroundZero) {
                $Y1 = $YZero;
              }
              else {
                $Y1 = $this->GraphAreaY2 - 1;
              }
            }
            if ($OverrideColors != NULL) {
              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();
              }
            }
            if ($Y2 != VOID) {
              $BarHeight = $Y1 - $Y2;
              if ($Serie["Data"][$Key] == 0) {
                $this
                  ->drawLine($X + $XOffset + $XSpace, $Y1, $X + $XOffset + $XSize - $XSpace, $Y1, $Color);
                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));
                }
              }
              else {
                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));
                }
                if ($Rounded) {
                  $this
                    ->drawRoundedFilledRectangle($X + $XOffset + $XSpace, $Y1, $X + $XOffset + $XSize - $XSpace, $Y2, $RoundRadius, $Color);
                }
                else {
                  $this
                    ->drawFilledRectangle($X + $XOffset + $XSpace, $Y1, $X + $XOffset + $XSize - $XSpace, $Y2, $Color);
                  if ($InnerColor != NULL) {
                    $this
                      ->drawRectangle($X + $XOffset + $XSpace + 1, min($Y1, $Y2) + 1, $X + $XOffset + $XSize - $XSpace - 1, max($Y1, $Y2) - 1, $InnerColor);
                  }
                  if ($Gradient) {
                    $this->Shadow = FALSE;
                    if ($GradientMode == GRADIENT_SIMPLE) {
                      if ($Serie["Data"][$Key] >= 0) {
                        $GradienColor = array(
                          "StartR" => $GradientStartR,
                          "StartG" => $GradientStartG,
                          "StartB" => $GradientStartB,
                          "EndR" => $GradientEndR,
                          "EndG" => $GradientEndG,
                          "EndB" => $GradientEndB,
                          "Alpha" => $GradientAlpha,
                        );
                      }
                      else {
                        $GradienColor = array(
                          "StartR" => $GradientEndR,
                          "StartG" => $GradientEndG,
                          "StartB" => $GradientEndB,
                          "EndR" => $GradientStartR,
                          "EndG" => $GradientStartG,
                          "EndB" => $GradientStartB,
                          "Alpha" => $GradientAlpha,
                        );
                      }
                      $this
                        ->drawGradientArea($X + $XOffset + $XSpace, $Y1, $X + $XOffset + $XSize - $XSpace, $Y2, DIRECTION_VERTICAL, $GradienColor);
                    }
                    elseif ($GradientMode == GRADIENT_EFFECT_CAN) {
                      $GradienColor1 = array(
                        "StartR" => $GradientEndR,
                        "StartG" => $GradientEndG,
                        "StartB" => $GradientEndB,
                        "EndR" => $GradientStartR,
                        "EndG" => $GradientStartG,
                        "EndB" => $GradientStartB,
                        "Alpha" => $GradientAlpha,
                      );
                      $GradienColor2 = array(
                        "StartR" => $GradientStartR,
                        "StartG" => $GradientStartG,
                        "StartB" => $GradientStartB,
                        "EndR" => $GradientEndR,
                        "EndG" => $GradientEndG,
                        "EndB" => $GradientEndB,
                        "Alpha" => $GradientAlpha,
                      );
                      $XSpan = floor($XSize / 3);
                      $this
                        ->drawGradientArea($X + $XOffset + $XSpace, $Y1, $X + $XOffset + $XSpan - $XSpace, $Y2, DIRECTION_HORIZONTAL, $GradienColor1);
                      $this
                        ->drawGradientArea($X + $XOffset + $XSpan + $XSpace, $Y1, $X + $XOffset + $XSize - $XSpace, $Y2, DIRECTION_HORIZONTAL, $GradienColor2);
                    }
                    $this->Shadow = $RestoreShadow;
                  }
                }
                if ($Draw0Line) {
                  $Line0Color = array(
                    "R" => 0,
                    "G" => 0,
                    "B" => 0,
                    "Alpha" => 20,
                  );
                  if (abs($Y1 - $Y2) > 3) {
                    $Line0Width = 3;
                  }
                  else {
                    $Line0Width = 1;
                  }
                  if ($Y1 - $Y2 < 0) {
                    $Line0Width = -$Line0Width;
                  }
                  $this
                    ->drawFilledRectangle($X + $XOffset + $XSpace, floor($Y1), $X + $XOffset + $XSize - $XSpace, floor($Y1) - $Line0Width, $Line0Color);
                  $this
                    ->drawLine($X + $XOffset + $XSpace, floor($Y1), $X + $XOffset + $XSize - $XSpace, floor($Y1), $Line0Color);
                }
              }
              if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
                if ($DisplayShadow) {
                  $this->Shadow = TRUE;
                }
                $Caption = $this
                  ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit);
                $TxtPos = $this
                  ->getTextBox(0, 0, $DisplayFont, $DisplaySize, 90, $Caption);
                $TxtHeight = $TxtPos[0]["Y"] - $TxtPos[1]["Y"] + $TxtMargin;
                if ($DisplayPos == LABEL_POS_INSIDE && abs($TxtHeight) < abs($BarHeight)) {
                  $CenterX = ($X + $XOffset + $XSize - $XSpace - ($X + $XOffset + $XSpace)) / 2 + $X + $XOffset + $XSpace;
                  $CenterY = ($Y2 - $Y1) / 2 + $Y1;
                  $this
                    ->drawText($CenterX, $CenterY, $Caption, array(
                    "R" => $DisplayR,
                    "G" => $DisplayG,
                    "B" => $DisplayB,
                    "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
                    "FontSize" => $DisplaySize,
                    "Angle" => 90,
                  ));
                }
                else {
                  if ($Serie["Data"][$Key] >= 0) {
                    $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                    $Offset = $DisplayOffset;
                  }
                  else {
                    $Align = TEXT_ALIGN_TOPMIDDLE;
                    $Offset = -$DisplayOffset;
                  }
                  $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,
                  ));
                }
                $this->Shadow = $RestoreShadow;
              }
            }
            $X = $X + $XStep;
            $ID++;
          }
        }
        else {
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          if ($XDivs == 0) {
            $YStep = 0;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          if ($AroundZero) {
            $X1 = $YZero;
          }
          else {
            $X1 = $this->GraphAreaX1 + 1;
          }
          if ($XDivs == 0) {
            $YSize = ($this->GraphAreaY2 - $this->GraphAreaY1) / ($SeriesCount + $Interleave);
          }
          else {
            $YSize = $YStep / ($SeriesCount + $Interleave);
          }
          $YOffset = -($YSize * $SeriesCount) / 2 + $CurrentSerie * $YSize;
          if ($Y + $YOffset <= $this->GraphAreaY1) {
            $YOffset = $this->GraphAreaY1 - $Y + 1;
          }
          $this->DataSet->Data["Series"][$SerieName]["XOffset"] = $YOffset + $YSize / 2;
          if ($Rounded || $BorderR != -1) {
            $YSpace = 1;
          }
          else {
            $YSpace = 0;
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $ID = 0;
          foreach ($PosArray as $Key => $X2) {
            if ($Floating0Serie != NULL) {
              if (isset($Data["Series"][$Floating0Serie]["Data"][$Key])) {
                $Value = $Data["Series"][$Floating0Serie]["Data"][$Key];
              }
              else {
                $Value = 0;
              }
              $YZero = $this
                ->scaleComputeY($Value, array(
                "AxisID" => $Serie["Axis"],
              ));
              if ($YZero < $this->GraphAreaX1 + 1) {
                $YZero = $this->GraphAreaX1 + 1;
              }
              if ($YZero > $this->GraphAreaX2 - 1) {
                $YZero = $this->GraphAreaX2 - 1;
              }
              if ($AroundZero) {
                $X1 = $YZero;
              }
              else {
                $X1 = $this->GraphAreaX1 + 1;
              }
            }
            if ($OverrideColors != NULL) {
              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();
              }
            }
            if ($X2 != VOID) {
              $BarWidth = $X2 - $X1;
              if ($Serie["Data"][$Key] == 0) {
                $this
                  ->drawLine($X1, $Y + $YOffset + $YSpace, $X1, $Y + $YOffset + $YSize - $YSpace, $Color);
                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));
                }
              }
              else {
                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));
                }
                if ($Rounded) {
                  $this
                    ->drawRoundedFilledRectangle($X1 + 1, $Y + $YOffset + $YSpace, $X2, $Y + $YOffset + $YSize - $YSpace, $RoundRadius, $Color);
                }
                else {
                  $this
                    ->drawFilledRectangle($X1, $Y + $YOffset + $YSpace, $X2, $Y + $YOffset + $YSize - $YSpace, $Color);
                  if ($InnerColor != NULL) {
                    $this
                      ->drawRectangle(min($X1, $X2) + 1, $Y + $YOffset + $YSpace + 1, max($X1, $X2) - 1, $Y + $YOffset + $YSize - $YSpace - 1, $InnerColor);
                  }
                  if ($Gradient) {
                    $this->Shadow = FALSE;
                    if ($GradientMode == GRADIENT_SIMPLE) {
                      if ($Serie["Data"][$Key] >= 0) {
                        $GradienColor = array(
                          "StartR" => $GradientStartR,
                          "StartG" => $GradientStartG,
                          "StartB" => $GradientStartB,
                          "EndR" => $GradientEndR,
                          "EndG" => $GradientEndG,
                          "EndB" => $GradientEndB,
                          "Alpha" => $GradientAlpha,
                        );
                      }
                      else {
                        $GradienColor = array(
                          "StartR" => $GradientEndR,
                          "StartG" => $GradientEndG,
                          "StartB" => $GradientEndB,
                          "EndR" => $GradientStartR,
                          "EndG" => $GradientStartG,
                          "EndB" => $GradientStartB,
                          "Alpha" => $GradientAlpha,
                        );
                      }
                      $this
                        ->drawGradientArea($X1, $Y + $YOffset + $YSpace, $X2, $Y + $YOffset + $YSize - $YSpace, DIRECTION_HORIZONTAL, $GradienColor);
                    }
                    elseif ($GradientMode == GRADIENT_EFFECT_CAN) {
                      $GradienColor1 = array(
                        "StartR" => $GradientEndR,
                        "StartG" => $GradientEndG,
                        "StartB" => $GradientEndB,
                        "EndR" => $GradientStartR,
                        "EndG" => $GradientStartG,
                        "EndB" => $GradientStartB,
                        "Alpha" => $GradientAlpha,
                      );
                      $GradienColor2 = array(
                        "StartR" => $GradientStartR,
                        "StartG" => $GradientStartG,
                        "StartB" => $GradientStartB,
                        "EndR" => $GradientEndR,
                        "EndG" => $GradientEndG,
                        "EndB" => $GradientEndB,
                        "Alpha" => $GradientAlpha,
                      );
                      $YSpan = floor($YSize / 3);
                      $this
                        ->drawGradientArea($X1, $Y + $YOffset + $YSpace, $X2, $Y + $YOffset + $YSpan - $YSpace, DIRECTION_VERTICAL, $GradienColor1);
                      $this
                        ->drawGradientArea($X1, $Y + $YOffset + $YSpan, $X2, $Y + $YOffset + $YSize - $YSpace, DIRECTION_VERTICAL, $GradienColor2);
                    }
                    $this->Shadow = $RestoreShadow;
                  }
                }
                if ($Draw0Line) {
                  $Line0Color = array(
                    "R" => 0,
                    "G" => 0,
                    "B" => 0,
                    "Alpha" => 20,
                  );
                  if (abs($X1 - $X2) > 3) {
                    $Line0Width = 3;
                  }
                  else {
                    $Line0Width = 1;
                  }
                  if ($X2 - $X1 < 0) {
                    $Line0Width = -$Line0Width;
                  }
                  $this
                    ->drawFilledRectangle(floor($X1), $Y + $YOffset + $YSpace, floor($X1) + $Line0Width, $Y + $YOffset + $YSize - $YSpace, $Line0Color);
                  $this
                    ->drawLine(floor($X1), $Y + $YOffset + $YSpace, floor($X1), $Y + $YOffset + $YSize - $YSpace, $Line0Color);
                }
              }
              if ($DisplayValues && $Serie["Data"][$Key] != VOID) {
                if ($DisplayShadow) {
                  $this->Shadow = TRUE;
                }
                $Caption = $this
                  ->scaleFormat($Serie["Data"][$Key], $Mode, $Format, $Unit);
                $TxtPos = $this
                  ->getTextBox(0, 0, $DisplayFont, $DisplaySize, 0, $Caption);
                $TxtWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"] + $TxtMargin;
                if ($DisplayPos == LABEL_POS_INSIDE && abs($TxtWidth) < abs($BarWidth)) {
                  $CenterX = ($X2 - $X1) / 2 + $X1;
                  $CenterY = ($Y + $YOffset + $YSize - $YSpace - ($Y + $YOffset + $YSpace)) / 2 + ($Y + $YOffset + $YSpace);
                  $this
                    ->drawText($CenterX, $CenterY, $Caption, array(
                    "R" => $DisplayR,
                    "G" => $DisplayG,
                    "B" => $DisplayB,
                    "Align" => TEXT_ALIGN_MIDDLEMIDDLE,
                    "FontSize" => $DisplaySize,
                  ));
                }
                else {
                  if ($Serie["Data"][$Key] >= 0) {
                    $Align = TEXT_ALIGN_MIDDLELEFT;
                    $Offset = $DisplayOffset;
                  }
                  else {
                    $Align = TEXT_ALIGN_MIDDLERIGHT;
                    $Offset = -$DisplayOffset;
                  }
                  $this
                    ->drawText($X2 + $Offset, $Y + $YOffset + $YSize / 2, $Caption, array(
                    "R" => $DisplayR,
                    "G" => $DisplayG,
                    "B" => $DisplayB,
                    "Align" => $Align,
                    "FontSize" => $DisplaySize,
                  ));
                }
                $this->Shadow = $RestoreShadow;
              }
            }
            $Y = $Y + $YStep;
            $ID++;
          }
        }
        $CurrentSerie++;
      }
    }
  }

  /* Draw a bar chart */
  function drawStackedBarChart($Format = NULL) {
    $DisplayValues = isset($Format["DisplayValues"]) ? $Format["DisplayValues"] : FALSE;
    $DisplayOrientation = isset($Format["DisplayOrientation"]) ? $Format["DisplayOrientation"] : ORIENTATION_AUTO;
    $DisplayRound = isset($Format["DisplayRound"]) ? $Format["DisplayRound"] : 0;
    $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
    $DisplayFont = isset($Format["DisplayFont"]) ? $Format["DisplayFont"] : $this->FontName;
    $DisplaySize = isset($Format["DisplaySize"]) ? $Format["DisplaySize"] : $this->FontSize;
    $DisplayR = isset($Format["DisplayR"]) ? $Format["DisplayR"] : 0;
    $DisplayG = isset($Format["DisplayG"]) ? $Format["DisplayG"] : 0;
    $DisplayB = isset($Format["DisplayB"]) ? $Format["DisplayB"] : 0;
    $Interleave = isset($Format["Interleave"]) ? $Format["Interleave"] : 0.5;
    $Rounded = isset($Format["Rounded"]) ? $Format["Rounded"] : FALSE;
    $RoundRadius = isset($Format["RoundRadius"]) ? $Format["RoundRadius"] : 4;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    $Gradient = isset($Format["Gradient"]) ? $Format["Gradient"] : FALSE;
    $GradientMode = isset($Format["GradientMode"]) ? $Format["GradientMode"] : GRADIENT_SIMPLE;
    $GradientAlpha = isset($Format["GradientAlpha"]) ? $Format["GradientAlpha"] : 20;
    $GradientStartR = isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    $GradientStartG = isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    $GradientStartB = isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    $GradientEndR = isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 0;
    $GradientEndG = isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 0;
    $GradientEndB = isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 0;
    $InnerSurrounding = isset($Format["InnerSurrounding"]) ? $Format["InnerSurrounding"] : NULL;
    $InnerBorderR = isset($Format["InnerBorderR"]) ? $Format["InnerBorderR"] : -1;
    $InnerBorderG = isset($Format["InnerBorderG"]) ? $Format["InnerBorderG"] : -1;
    $InnerBorderB = isset($Format["InnerBorderB"]) ? $Format["InnerBorderB"] : -1;
    $RecordImageMap = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;
    $FontFactor = isset($Format["FontFactor"]) ? $Format["FontFactor"] : 8;
    $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    $RestoreShadow = $this->Shadow;
    $LastX = "";
    $LastY = "";
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($DisplayColor == DISPLAY_AUTO) {
          $DisplayR = 255;
          $DisplayG = 255;
          $DisplayB = 255;
        }
        if ($Surrounding != NULL) {
          $BorderR = $R + $Surrounding;
          $BorderG = $G + $Surrounding;
          $BorderB = $B + $Surrounding;
        }
        if ($InnerSurrounding != NULL) {
          $InnerBorderR = $R + $InnerSurrounding;
          $InnerBorderG = $G + $InnerSurrounding;
          $InnerBorderB = $B + $InnerSurrounding;
        }
        if ($InnerBorderR == -1) {
          $InnerColor = NULL;
        }
        else {
          $InnerColor = array(
            "R" => $InnerBorderR,
            "G" => $InnerBorderG,
            "B" => $InnerBorderB,
          );
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        if (isset($Serie["Description"])) {
          $SerieDescription = $Serie["Description"];
        }
        else {
          $SerieDescription = $SerieName;
        }
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ), TRUE);
        $YZero = $this
          ->scaleComputeY(0, array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        $Color = array(
          "TransCorner" => TRUE,
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "BorderR" => $BorderR,
          "BorderG" => $BorderG,
          "BorderB" => $BorderB,
        );
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $XSize = $XStep / (1 + $Interleave);
          $XOffset = -($XSize / 2);
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $Height) {
            if ($Height != VOID && $Serie["Data"][$Key] != 0) {
              if ($Serie["Data"][$Key] > 0) {
                $Pos = "+";
              }
              else {
                $Pos = "-";
              }
              if (!isset($LastY[$Key])) {
                $LastY[$Key] = "";
              }
              if (!isset($LastY[$Key][$Pos])) {
                $LastY[$Key][$Pos] = $YZero;
              }
              $Y1 = $LastY[$Key][$Pos];
              $Y2 = $Y1 - $Height;
              if (($Rounded || $BorderR != -1) && ($Pos == "+" && $Y1 != $YZero)) {
                $YSpaceUp = 1;
              }
              else {
                $YSpaceUp = 0;
              }
              if (($Rounded || $BorderR != -1) && ($Pos == "-" && $Y1 != $YZero)) {
                $YSpaceDown = 1;
              }
              else {
                $YSpaceDown = 0;
              }
              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));
              }
              if ($Rounded) {
                $this
                  ->drawRoundedFilledRectangle($X + $XOffset, $Y1 - $YSpaceUp + $YSpaceDown, $X + $XOffset + $XSize, $Y2, $RoundRadius, $Color);
              }
              else {
                $this
                  ->drawFilledRectangle($X + $XOffset, $Y1 - $YSpaceUp + $YSpaceDown, $X + $XOffset + $XSize, $Y2, $Color);
                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;
                }
                if ($Gradient) {
                  $this->Shadow = FALSE;
                  if ($GradientMode == GRADIENT_SIMPLE) {
                    $GradientColor = array(
                      "StartR" => $GradientStartR,
                      "StartG" => $GradientStartG,
                      "StartB" => $GradientStartB,
                      "EndR" => $GradientEndR,
                      "EndG" => $GradientEndG,
                      "EndB" => $GradientEndB,
                      "Alpha" => $GradientAlpha,
                    );
                    $this
                      ->drawGradientArea($X + $XOffset, $Y1 - 1 - $YSpaceUp + $YSpaceDown, $X + $XOffset + $XSize, $Y2 + 1, DIRECTION_VERTICAL, $GradientColor);
                  }
                  elseif ($GradientMode == GRADIENT_EFFECT_CAN) {
                    $GradientColor1 = array(
                      "StartR" => $GradientEndR,
                      "StartG" => $GradientEndG,
                      "StartB" => $GradientEndB,
                      "EndR" => $GradientStartR,
                      "EndG" => $GradientStartG,
                      "EndB" => $GradientStartB,
                      "Alpha" => $GradientAlpha,
                    );
                    $GradientColor2 = array(
                      "StartR" => $GradientStartR,
                      "StartG" => $GradientStartG,
                      "StartB" => $GradientStartB,
                      "EndR" => $GradientEndR,
                      "EndG" => $GradientEndG,
                      "EndB" => $GradientEndB,
                      "Alpha" => $GradientAlpha,
                    );
                    $XSpan = floor($XSize / 3);
                    $this
                      ->drawGradientArea($X + $XOffset - 0.5, $Y1 - 0.5 - $YSpaceUp + $YSpaceDown, $X + $XOffset + $XSpan, $Y2 + 0.5, DIRECTION_HORIZONTAL, $GradientColor1);
                    $this
                      ->drawGradientArea($X + $XSpan + $XOffset - 0.5, $Y1 - 0.5 - $YSpaceUp + $YSpaceDown, $X + $XOffset + $XSize, $Y2 + 0.5, DIRECTION_HORIZONTAL, $GradientColor2);
                  }
                  $this->Shadow = $RestoreShadow;
                }
              }
              if ($DisplayValues) {
                $BarHeight = abs($Y2 - $Y1) - 2;
                $BarWidth = $XSize + $XOffset / 2 - $FontFactor;
                $Caption = $this
                  ->scaleFormat(round($Serie["Data"][$Key], $DisplayRound), $Mode, $Format, $Unit);
                $TxtPos = $this
                  ->getTextBox(0, 0, $DisplayFont, $DisplaySize, 0, $Caption);
                $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);
                $TxtWidth = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);
                $XCenter = ($X + $XOffset + $XSize - ($X + $XOffset)) / 2 + $X + $XOffset;
                $YCenter = ($Y2 - ($Y1 - $YSpaceUp + $YSpaceDown)) / 2 + $Y1 - $YSpaceUp + $YSpaceDown;
                $Done = FALSE;
                if ($DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO) {
                  if ($TxtHeight < $BarHeight && $TxtWidth < $BarWidth) {
                    $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,
                    ));
                    $Done = TRUE;
                  }
                }
                if ($DisplayOrientation == ORIENTATION_VERTICAL || $DisplayOrientation == ORIENTATION_AUTO && !$Done) {
                  if ($TxtHeight < $BarWidth && $TxtWidth < $BarHeight) {
                    $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,
                    ));
                  }
                }
              }
              $LastY[$Key][$Pos] = $Y2;
            }
            $X = $X + $XStep;
          }
        }
        else {
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $YSize = $YStep / (1 + $Interleave);
          $YOffset = -($YSize / 2);
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          foreach ($PosArray as $Key => $Width) {
            if ($Width != VOID && $Serie["Data"][$Key] != 0) {
              if ($Serie["Data"][$Key] > 0) {
                $Pos = "+";
              }
              else {
                $Pos = "-";
              }
              if (!isset($LastX[$Key])) {
                $LastX[$Key] = "";
              }
              if (!isset($LastX[$Key][$Pos])) {
                $LastX[$Key][$Pos] = $YZero;
              }
              $X1 = $LastX[$Key][$Pos];
              $X2 = $X1 + $Width;
              if (($Rounded || $BorderR != -1) && ($Pos == "+" && $X1 != $YZero)) {
                $XSpaceLeft = 2;
              }
              else {
                $XSpaceLeft = 0;
              }
              if (($Rounded || $BorderR != -1) && ($Pos == "-" && $X1 != $YZero)) {
                $XSpaceRight = 2;
              }
              else {
                $XSpaceRight = 0;
              }
              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));
              }
              if ($Rounded) {
                $this
                  ->drawRoundedFilledRectangle($X1 + $XSpaceLeft, $Y + $YOffset, $X2 - $XSpaceRight, $Y + $YOffset + $YSize, $RoundRadius, $Color);
              }
              else {
                $this
                  ->drawFilledRectangle($X1 + $XSpaceLeft, $Y + $YOffset, $X2 - $XSpaceRight, $Y + $YOffset + $YSize, $Color);
                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;
                }
                if ($Gradient) {
                  $this->Shadow = FALSE;
                  if ($GradientMode == GRADIENT_SIMPLE) {
                    $GradientColor = array(
                      "StartR" => $GradientStartR,
                      "StartG" => $GradientStartG,
                      "StartB" => $GradientStartB,
                      "EndR" => $GradientEndR,
                      "EndG" => $GradientEndG,
                      "EndB" => $GradientEndB,
                      "Alpha" => $GradientAlpha,
                    );
                    $this
                      ->drawGradientArea($X1 + $XSpaceLeft, $Y + $YOffset, $X2 - $XSpaceRight, $Y + $YOffset + $YSize, DIRECTION_HORIZONTAL, $GradientColor);
                  }
                  elseif ($GradientMode == GRADIENT_EFFECT_CAN) {
                    $GradientColor1 = array(
                      "StartR" => $GradientEndR,
                      "StartG" => $GradientEndG,
                      "StartB" => $GradientEndB,
                      "EndR" => $GradientStartR,
                      "EndG" => $GradientStartG,
                      "EndB" => $GradientStartB,
                      "Alpha" => $GradientAlpha,
                    );
                    $GradientColor2 = array(
                      "StartR" => $GradientStartR,
                      "StartG" => $GradientStartG,
                      "StartB" => $GradientStartB,
                      "EndR" => $GradientEndR,
                      "EndG" => $GradientEndG,
                      "EndB" => $GradientEndB,
                      "Alpha" => $GradientAlpha,
                    );
                    $YSpan = floor($YSize / 3);
                    $this
                      ->drawGradientArea($X1 + $XSpaceLeft, $Y + $YOffset, $X2 - $XSpaceRight, $Y + $YOffset + $YSpan, DIRECTION_VERTICAL, $GradientColor1);
                    $this
                      ->drawGradientArea($X1 + $XSpaceLeft, $Y + $YOffset + $YSpan, $X2 - $XSpaceRight, $Y + $YOffset + $YSize, DIRECTION_VERTICAL, $GradientColor2);
                  }
                  $this->Shadow = $RestoreShadow;
                }
              }
              if ($DisplayValues) {
                $BarWidth = abs($X2 - $X1) - $FontFactor;
                $BarHeight = $YSize + $YOffset / 2 - $FontFactor / 2;
                $Caption = $this
                  ->scaleFormat(round($Serie["Data"][$Key], $DisplayRound), $Mode, $Format, $Unit);
                $TxtPos = $this
                  ->getTextBox(0, 0, $DisplayFont, $DisplaySize, 0, $Caption);
                $TxtHeight = abs($TxtPos[2]["Y"] - $TxtPos[0]["Y"]);
                $TxtWidth = abs($TxtPos[1]["X"] - $TxtPos[0]["X"]);
                $XCenter = ($X2 - $X1) / 2 + $X1;
                $YCenter = ($Y + $YOffset + $YSize - ($Y + $YOffset)) / 2 + $Y + $YOffset;
                $Done = FALSE;
                if ($DisplayOrientation == ORIENTATION_HORIZONTAL || $DisplayOrientation == ORIENTATION_AUTO) {
                  if ($TxtHeight < $BarHeight && $TxtWidth < $BarWidth) {
                    $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,
                    ));
                    $Done = TRUE;
                  }
                }
                if ($DisplayOrientation == ORIENTATION_VERTICAL || $DisplayOrientation == ORIENTATION_AUTO && !$Done) {
                  if ($TxtHeight < $BarWidth && $TxtWidth < $BarHeight) {
                    $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,
                    ));
                  }
                }
              }
              $LastX[$Key][$Pos] = $X2;
            }
            $Y = $Y + $YStep;
          }
        }
      }
    }
  }

  /* Draw a stacked area chart */
  function drawStackedAreaChart($Format = NULL) {
    $DrawLine = isset($Format["DrawLine"]) ? $Format["DrawLine"] : FALSE;
    $LineSurrounding = isset($Format["LineSurrounding"]) ? $Format["LineSurrounding"] : NULL;
    $LineR = isset($Format["LineR"]) ? $Format["LineR"] : VOID;
    $LineG = isset($Format["LineG"]) ? $Format["LineG"] : VOID;
    $LineB = isset($Format["LineB"]) ? $Format["LineB"] : VOID;
    $LineAlpha = isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 100;
    $DrawPlot = isset($Format["DrawPlot"]) ? $Format["DrawPlot"] : FALSE;
    $PlotRadius = isset($Format["PlotRadius"]) ? $Format["PlotRadius"] : 2;
    $PlotBorder = isset($Format["PlotBorder"]) ? $Format["PlotBorder"] : 1;
    $PlotBorderSurrounding = isset($Format["PlotBorderSurrounding"]) ? $Format["PlotBorderSurrounding"] : NULL;
    $PlotBorderR = isset($Format["PlotBorderR"]) ? $Format["PlotBorderR"] : 0;
    $PlotBorderG = isset($Format["PlotBorderG"]) ? $Format["PlotBorderG"] : 0;
    $PlotBorderB = isset($Format["PlotBorderB"]) ? $Format["PlotBorderB"] : 0;
    $PlotBorderAlpha = isset($Format["PlotBorderAlpha"]) ? $Format["PlotBorderAlpha"] : 50;
    $ForceTransparency = isset($Format["ForceTransparency"]) ? $Format["ForceTransparency"] : NULL;
    $this->LastChartLayout = CHART_LAST_LAYOUT_STACKED;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    $RestoreShadow = $this->Shadow;
    $this->Shadow = FALSE;

    /* Build the offset data series */
    $OffsetData = "";
    $OverallOffset = "";
    $SerieOrder = "";
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $SerieOrder[] = $SerieName;
        foreach ($Serie["Data"] as $Key => $Value) {
          if ($Value == VOID) {
            $Value = 0;
          }
          if ($Value >= 0) {
            $Sign = "+";
          }
          else {
            $Sign = "-";
          }
          if (!isset($OverallOffset[$Key]) || !isset($OverallOffset[$Key][$Sign])) {
            $OverallOffset[$Key][$Sign] = 0;
          }
          if ($Sign == "+") {
            $Data["Series"][$SerieName]["Data"][$Key] = $Value + $OverallOffset[$Key][$Sign];
          }
          else {
            $Data["Series"][$SerieName]["Data"][$Key] = $Value - $OverallOffset[$Key][$Sign];
          }
          $OverallOffset[$Key][$Sign] = $OverallOffset[$Key][$Sign] + abs($Value);
        }
      }
    }
    $SerieOrder = array_reverse($SerieOrder);
    $LastX = "";
    $LastY = "";
    foreach ($SerieOrder as $Key => $SerieName) {
      $Serie = $Data["Series"][$SerieName];
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        if ($ForceTransparency != NULL) {
          $Alpha = $ForceTransparency;
        }
        $Color = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
        );
        if ($LineSurrounding != NULL) {
          $LineColor = array(
            "R" => $R + $LineSurrounding,
            "G" => $G + $LineSurrounding,
            "B" => $B + $LineSurrounding,
            "Alpha" => $Alpha,
          );
        }
        elseif ($LineR != VOID) {
          $LineColor = array(
            "R" => $LineR,
            "G" => $LineG,
            "B" => $LineB,
            "Alpha" => $LineAlpha,
          );
        }
        else {
          $LineColor = $Color;
        }
        if ($PlotBorderSurrounding != NULL) {
          $PlotBorderColor = array(
            "R" => $R + $PlotBorderSurrounding,
            "G" => $G + $PlotBorderSurrounding,
            "B" => $B + $PlotBorderSurrounding,
            "Alpha" => $PlotBorderAlpha,
          );
        }
        else {
          $PlotBorderColor = array(
            "R" => $PlotBorderR,
            "G" => $PlotBorderG,
            "B" => $PlotBorderB,
            "Alpha" => $PlotBorderAlpha,
          );
        }
        $AxisID = $Serie["Axis"];
        $Mode = $Data["Axis"][$AxisID]["Display"];
        $Format = $Data["Axis"][$AxisID]["Format"];
        $Unit = $Data["Axis"][$AxisID]["Unit"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ), TRUE);
        $YZero = $this
          ->scaleComputeY(0, array(
          "AxisID" => $Serie["Axis"],
        ));
        $this->DataSet->Data["Series"][$SerieName]["XOffset"] = 0;
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($YZero < $this->GraphAreaY1 + 1) {
            $YZero = $this->GraphAreaY1 + 1;
          }
          if ($YZero > $this->GraphAreaY2 - 1) {
            $YZero = $this->GraphAreaY2 - 1;
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $Plots = "";
          $Plots[] = $X;
          $Plots[] = $YZero;
          foreach ($PosArray as $Key => $Height) {
            if ($Height != VOID) {
              $Plots[] = $X;
              $Plots[] = $YZero - $Height;
            }
            $X = $X + $XStep;
          }
          $Plots[] = $X - $XStep;
          $Plots[] = $YZero;
          $this
            ->drawPolygon($Plots, $Color);
          $this->Shadow = $RestoreShadow;
          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);
            }
          }
          if ($DrawPlot) {
            for ($i = 2; $i <= count($Plots) - 4; $i = $i + 2) {
              if ($PlotBorder != 0) {
                $this
                  ->drawFilledCircle($Plots[$i], $Plots[$i + 1], $PlotRadius + $PlotBorder, $PlotBorderColor);
              }
              $this
                ->drawFilledCircle($Plots[$i], $Plots[$i + 1], $PlotRadius, $Color);
            }
          }
          $this->Shadow = FALSE;
        }
        elseif ($Data["Orientation"] == SCALE_POS_TOPBOTTOM) {
          if ($YZero < $this->GraphAreaX1 + 1) {
            $YZero = $this->GraphAreaX1 + 1;
          }
          if ($YZero > $this->GraphAreaX2 - 1) {
            $YZero = $this->GraphAreaX2 - 1;
          }
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $Plots = "";
          $Plots[] = $YZero;
          $Plots[] = $Y;
          foreach ($PosArray as $Key => $Height) {
            if ($Height != VOID) {
              $Plots[] = $YZero + $Height;
              $Plots[] = $Y;
            }
            $Y = $Y + $YStep;
          }
          $Plots[] = $YZero;
          $Plots[] = $Y - $YStep;
          $this
            ->drawPolygon($Plots, $Color);
          $this->Shadow = $RestoreShadow;
          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);
            }
          }
          if ($DrawPlot) {
            for ($i = 2; $i <= count($Plots) - 4; $i = $i + 2) {
              if ($PlotBorder != 0) {
                $this
                  ->drawFilledCircle($Plots[$i], $Plots[$i + 1], $PlotRadius + $PlotBorder, $PlotBorderColor);
              }
              $this
                ->drawFilledCircle($Plots[$i], $Plots[$i + 1], $PlotRadius, $Color);
            }
          }
          $this->Shadow = FALSE;
        }
      }
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Returns a random color */
  function getRandomColor($Alpha = 100) {
    return array(
      "R" => rand(0, 255),
      "G" => rand(0, 255),
      "B" => rand(0, 255),
      "Alpha" => $Alpha,
    );
  }

  /* Validate a palette */
  function validatePalette($Colors, $Surrounding = NULL) {
    $Result = "";
    if (!is_array($Colors)) {
      return $this
        ->getRandomColor();
    }
    foreach ($Colors as $Key => $Values) {
      if (isset($Values["R"])) {
        $Result[$Key]["R"] = $Values["R"];
      }
      else {
        $Result[$Key]["R"] = rand(0, 255);
      }
      if (isset($Values["G"])) {
        $Result[$Key]["G"] = $Values["G"];
      }
      else {
        $Result[$Key]["G"] = rand(0, 255);
      }
      if (isset($Values["B"])) {
        $Result[$Key]["B"] = $Values["B"];
      }
      else {
        $Result[$Key]["B"] = rand(0, 255);
      }
      if (isset($Values["Alpha"])) {
        $Result[$Key]["Alpha"] = $Values["Alpha"];
      }
      else {
        $Result[$Key]["Alpha"] = 100;
      }
      if ($Surrounding != NULL) {
        $Result[$Key]["BorderR"] = $Result[$Key]["R"] + $Surrounding;
        $Result[$Key]["BorderG"] = $Result[$Key]["G"] + $Surrounding;
        $Result[$Key]["BorderB"] = $Result[$Key]["B"] + $Surrounding;
      }
      else {
        if (isset($Values["BorderR"])) {
          $Result[$Key]["BorderR"] = $Values["BorderR"];
        }
        else {
          $Result[$Key]["BorderR"] = $Result[$Key]["R"];
        }
        if (isset($Values["BorderG"])) {
          $Result[$Key]["BorderG"] = $Values["BorderG"];
        }
        else {
          $Result[$Key]["BorderG"] = $Result[$Key]["G"];
        }
        if (isset($Values["BorderB"])) {
          $Result[$Key]["BorderB"] = $Values["BorderB"];
        }
        else {
          $Result[$Key]["BorderB"] = $Result[$Key]["B"];
        }
        if (isset($Values["BorderAlpha"])) {
          $Result[$Key]["BorderAlpha"] = $Values["BorderAlpha"];
        }
        else {
          $Result[$Key]["BorderAlpha"] = $Result[$Key]["Alpha"];
        }
      }
    }
    return $Result;
  }

  /* Draw the derivative chart associated to the data series */
  function drawDerivative($Format = NULL) {
    $Offset = isset($Format["Offset"]) ? $Format["Offset"] : 10;
    $SerieSpacing = isset($Format["SerieSpacing"]) ? $Format["SerieSpacing"] : 3;
    $DerivativeHeight = isset($Format["DerivativeHeight"]) ? $Format["DerivativeHeight"] : 4;
    $ShadedSlopeBox = isset($Format["ShadedSlopeBox"]) ? $Format["ShadedSlopeBox"] : FALSE;
    $DrawBackground = isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : TRUE;
    $BackgroundR = isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;
    $BackgroundG = isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;
    $BackgroundB = isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;
    $BackgroundAlpha = isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 20;
    $DrawBorder = isset($Format["DrawBorder"]) ? $Format["DrawBorder"] : TRUE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : 0;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : 0;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : 0;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 100;
    $Caption = isset($Format["Caption"]) ? $Format["Caption"] : TRUE;
    $CaptionHeight = isset($Format["CaptionHeight"]) ? $Format["CaptionHeight"] : 10;
    $CaptionWidth = isset($Format["CaptionWidth"]) ? $Format["CaptionWidth"] : 20;
    $CaptionMargin = isset($Format["CaptionMargin"]) ? $Format["CaptionMargin"] : 4;
    $CaptionLine = isset($Format["CaptionLine"]) ? $Format["CaptionLine"] : FALSE;
    $CaptionBox = isset($Format["CaptionBox"]) ? $Format["CaptionBox"] : FALSE;
    $CaptionBorderR = isset($Format["CaptionBorderR"]) ? $Format["CaptionBorderR"] : 0;
    $CaptionBorderG = isset($Format["CaptionBorderG"]) ? $Format["CaptionBorderG"] : 0;
    $CaptionBorderB = isset($Format["CaptionBorderB"]) ? $Format["CaptionBorderB"] : 0;
    $CaptionFillR = isset($Format["CaptionFillR"]) ? $Format["CaptionFillR"] : 255;
    $CaptionFillG = isset($Format["CaptionFillG"]) ? $Format["CaptionFillG"] : 255;
    $CaptionFillB = isset($Format["CaptionFillB"]) ? $Format["CaptionFillB"] : 255;
    $CaptionFillAlpha = isset($Format["CaptionFillAlpha"]) ? $Format["CaptionFillAlpha"] : 80;
    $PositiveSlopeStartR = isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 184;
    $PositiveSlopeStartG = isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 234;
    $PositiveSlopeStartB = isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 88;
    $PositiveSlopeEndR = isset($Format["PositiveSlopeStartR"]) ? $Format["PositiveSlopeStartR"] : 239;
    $PositiveSlopeEndG = isset($Format["PositiveSlopeStartG"]) ? $Format["PositiveSlopeStartG"] : 31;
    $PositiveSlopeEndB = isset($Format["PositiveSlopeStartB"]) ? $Format["PositiveSlopeStartB"] : 36;
    $NegativeSlopeStartR = isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 184;
    $NegativeSlopeStartG = isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 234;
    $NegativeSlopeStartB = isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 88;
    $NegativeSlopeEndR = isset($Format["NegativeSlopeStartR"]) ? $Format["NegativeSlopeStartR"] : 67;
    $NegativeSlopeEndG = isset($Format["NegativeSlopeStartG"]) ? $Format["NegativeSlopeStartG"] : 124;
    $NegativeSlopeEndB = isset($Format["NegativeSlopeStartB"]) ? $Format["NegativeSlopeStartB"] : 227;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
      $YPos = $this->DataSet->Data["GraphArea"]["Y2"] + $Offset;
    }
    else {
      $XPos = $this->DataSet->Data["GraphArea"]["X2"] + $Offset;
    }
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        $R = $Serie["Color"]["R"];
        $G = $Serie["Color"]["G"];
        $B = $Serie["Color"]["B"];
        $Alpha = $Serie["Color"]["Alpha"];
        $Ticks = $Serie["Ticks"];
        $Weight = $Serie["Weight"];
        $AxisID = $Serie["Axis"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($Caption) {
            if ($CaptionLine) {
              $StartX = floor($this->GraphAreaX1 - $CaptionWidth + $XMargin - $CaptionMargin);
              $EndX = floor($this->GraphAreaX1 - $CaptionMargin + $XMargin);
              $CaptionSettings = array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              );
              if ($CaptionBox) {
                $this
                  ->drawFilledRectangle($StartX, $YPos, $EndX, $YPos + $CaptionHeight, array(
                  "R" => $CaptionFillR,
                  "G" => $CaptionFillG,
                  "B" => $CaptionFillB,
                  "BorderR" => $CaptionBorderR,
                  "BorderG" => $CaptionBorderG,
                  "BorderB" => $CaptionBorderB,
                  "Alpha" => $CaptionFillAlpha,
                ));
              }
              $this
                ->drawLine($StartX + 2, $YPos + $CaptionHeight / 2, $EndX - 2, $YPos + $CaptionHeight / 2, $CaptionSettings);
            }
            else {
              $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,
              ));
            }
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          $TopY = $YPos + $CaptionHeight / 2 - $DerivativeHeight / 2;
          $BottomY = $YPos + $CaptionHeight / 2 + $DerivativeHeight / 2;
          $StartX = floor($this->GraphAreaX1 + $XMargin);
          $EndX = floor($this->GraphAreaX2 - $XMargin);
          if ($DrawBackground) {
            $this
              ->drawFilledRectangle($StartX - 1, $TopY - 1, $EndX + 1, $BottomY + 1, array(
              "R" => $BackgroundR,
              "G" => $BackgroundG,
              "B" => $BackgroundB,
              "Alpha" => $BackgroundAlpha,
            ));
          }
          if ($DrawBorder) {
            $this
              ->drawRectangle($StartX - 1, $TopY - 1, $EndX + 1, $BottomY + 1, array(
              "R" => $BorderR,
              "G" => $BorderG,
              "B" => $BorderB,
              "Alpha" => $BorderAlpha,
            ));
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $RestoreShadow = $this->Shadow;
          $this->Shadow = FALSE;

          /* Determine the Max slope index */
          $LastX = NULL;
          $LastY = NULL;
          $MinSlope = 0;
          $MaxSlope = 1;
          foreach ($PosArray as $Key => $Y) {
            if ($Y != VOID && $LastX != NULL) {
              $Slope = $LastY - $Y;
              if ($Slope > $MaxSlope) {
                $MaxSlope = $Slope;
              }
              if ($Slope < $MinSlope) {
                $MinSlope = $Slope;
              }
            }
            if ($Y == VOID) {
              $LastX = NULL;
              $LastY = NULL;
            }
            else {
              $LastX = $X;
              $LastY = $Y;
            }
          }
          $LastX = NULL;
          $LastY = NULL;
          $LastColor = NULL;
          foreach ($PosArray as $Key => $Y) {
            if ($Y != VOID && $LastY != NULL) {
              $Slope = $LastY - $Y;
              if ($Slope >= 0) {
                $SlopeIndex = 100 / $MaxSlope * $Slope;
                $R = ($PositiveSlopeEndR - $PositiveSlopeStartR) / 100 * $SlopeIndex + $PositiveSlopeStartR;
                $G = ($PositiveSlopeEndG - $PositiveSlopeStartG) / 100 * $SlopeIndex + $PositiveSlopeStartG;
                $B = ($PositiveSlopeEndB - $PositiveSlopeStartB) / 100 * $SlopeIndex + $PositiveSlopeStartB;
              }
              elseif ($Slope < 0) {
                $SlopeIndex = 100 / abs($MinSlope) * abs($Slope);
                $R = ($NegativeSlopeEndR - $NegativeSlopeStartR) / 100 * $SlopeIndex + $NegativeSlopeStartR;
                $G = ($NegativeSlopeEndG - $NegativeSlopeStartG) / 100 * $SlopeIndex + $NegativeSlopeStartG;
                $B = ($NegativeSlopeEndB - $NegativeSlopeStartB) / 100 * $SlopeIndex + $NegativeSlopeStartB;
              }
              $Color = array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
              );
              if ($ShadedSlopeBox && $LastColor != NULL) {

                // && $Slope != 0
                $GradientSettings = array(
                  "StartR" => $LastColor["R"],
                  "StartG" => $LastColor["G"],
                  "StartB" => $LastColor["B"],
                  "EndR" => $R,
                  "EndG" => $G,
                  "EndB" => $B,
                );
                $this
                  ->drawGradientArea($LastX, $TopY, $X, $BottomY, DIRECTION_HORIZONTAL, $GradientSettings);
              }
              elseif (!$ShadedSlopeBox || $LastColor == NULL) {

                // || $Slope == 0
                $this
                  ->drawFilledRectangle(floor($LastX), $TopY, floor($X), $BottomY, $Color);
              }
              $LastColor = $Color;
            }
            if ($Y == VOID) {
              $LastY = NULL;
            }
            else {
              $LastX = $X;
              $LastY = $Y;
            }
            $X = $X + $XStep;
          }
          $YPos = $YPos + $CaptionHeight + $SerieSpacing;
        }
        else {
          if ($Caption) {
            $StartY = floor($this->GraphAreaY1 - $CaptionWidth + $XMargin - $CaptionMargin);
            $EndY = floor($this->GraphAreaY1 - $CaptionMargin + $XMargin);
            if ($CaptionLine) {
              $CaptionSettings = array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "Alpha" => $Alpha,
                "Ticks" => $Ticks,
                "Weight" => $Weight,
              );
              if ($CaptionBox) {
                $this
                  ->drawFilledRectangle($XPos, $StartY, $XPos + $CaptionHeight, $EndY, array(
                  "R" => $CaptionFillR,
                  "G" => $CaptionFillG,
                  "B" => $CaptionFillB,
                  "BorderR" => $CaptionBorderR,
                  "BorderG" => $CaptionBorderG,
                  "BorderB" => $CaptionBorderB,
                  "Alpha" => $CaptionFillAlpha,
                ));
              }
              $this
                ->drawLine($XPos + $CaptionHeight / 2, $StartY + 2, $XPos + $CaptionHeight / 2, $EndY - 2, $CaptionSettings);
            }
            else {
              $this
                ->drawFilledRectangle($XPos, $StartY, $XPos + $CaptionHeight, $EndY, array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
                "BorderR" => $CaptionBorderR,
                "BorderG" => $CaptionBorderG,
                "BorderB" => $CaptionBorderB,
              ));
            }
          }
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          $TopX = $XPos + $CaptionHeight / 2 - $DerivativeHeight / 2;
          $BottomX = $XPos + $CaptionHeight / 2 + $DerivativeHeight / 2;
          $StartY = floor($this->GraphAreaY1 + $XMargin);
          $EndY = floor($this->GraphAreaY2 - $XMargin);
          if ($DrawBackground) {
            $this
              ->drawFilledRectangle($TopX - 1, $StartY - 1, $BottomX + 1, $EndY + 1, array(
              "R" => $BackgroundR,
              "G" => $BackgroundG,
              "B" => $BackgroundB,
              "Alpha" => $BackgroundAlpha,
            ));
          }
          if ($DrawBorder) {
            $this
              ->drawRectangle($TopX - 1, $StartY - 1, $BottomX + 1, $EndY + 1, array(
              "R" => $BorderR,
              "G" => $BorderG,
              "B" => $BorderB,
              "Alpha" => $BorderAlpha,
            ));
          }
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $RestoreShadow = $this->Shadow;
          $this->Shadow = FALSE;

          /* Determine the Max slope index */
          $LastX = NULL;
          $LastY = NULL;
          $MinSlope = 0;
          $MaxSlope = 1;
          foreach ($PosArray as $Key => $X) {
            if ($X != VOID && $LastX != NULL) {
              $Slope = $X - $LastX;
              if ($Slope > $MaxSlope) {
                $MaxSlope = $Slope;
              }
              if ($Slope < $MinSlope) {
                $MinSlope = $Slope;
              }
            }
            if ($X == VOID) {
              $LastX = NULL;
            }
            else {
              $LastX = $X;
            }
          }
          $LastX = NULL;
          $LastY = NULL;
          $LastColor = NULL;
          foreach ($PosArray as $Key => $X) {
            if ($X != VOID && $LastX != NULL) {
              $Slope = $X - $LastX;
              if ($Slope >= 0) {
                $SlopeIndex = 100 / $MaxSlope * $Slope;
                $R = ($PositiveSlopeEndR - $PositiveSlopeStartR) / 100 * $SlopeIndex + $PositiveSlopeStartR;
                $G = ($PositiveSlopeEndG - $PositiveSlopeStartG) / 100 * $SlopeIndex + $PositiveSlopeStartG;
                $B = ($PositiveSlopeEndB - $PositiveSlopeStartB) / 100 * $SlopeIndex + $PositiveSlopeStartB;
              }
              elseif ($Slope < 0) {
                $SlopeIndex = 100 / abs($MinSlope) * abs($Slope);
                $R = ($NegativeSlopeEndR - $NegativeSlopeStartR) / 100 * $SlopeIndex + $NegativeSlopeStartR;
                $G = ($NegativeSlopeEndG - $NegativeSlopeStartG) / 100 * $SlopeIndex + $NegativeSlopeStartG;
                $B = ($NegativeSlopeEndB - $NegativeSlopeStartB) / 100 * $SlopeIndex + $NegativeSlopeStartB;
              }
              $Color = array(
                "R" => $R,
                "G" => $G,
                "B" => $B,
              );
              if ($ShadedSlopeBox && $LastColor != NULL) {
                $GradientSettings = array(
                  "StartR" => $LastColor["R"],
                  "StartG" => $LastColor["G"],
                  "StartB" => $LastColor["B"],
                  "EndR" => $R,
                  "EndG" => $G,
                  "EndB" => $B,
                );
                $this
                  ->drawGradientArea($TopX, $LastY, $BottomX, $Y, DIRECTION_VERTICAL, $GradientSettings);
              }
              elseif (!$ShadedSlopeBox || $LastColor == NULL) {
                $this
                  ->drawFilledRectangle($TopX, floor($LastY), $BottomX, floor($Y), $Color);
              }
              $LastColor = $Color;
            }
            if ($X == VOID) {
              $LastX = NULL;
            }
            else {
              $LastX = $X;
              $LastY = $Y;
            }
            $Y = $Y + $XStep;
          }
          $XPos = $XPos + $CaptionHeight + $SerieSpacing;
        }
        $this->Shadow = $RestoreShadow;
      }
    }
  }

  /* Draw the line of best fit */
  function drawBestFit($Format = "") {
    $OverrideTicks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    $OverrideR = isset($Format["R"]) ? $Format["R"] : VOID;
    $OverrideG = isset($Format["G"]) ? $Format["G"] : VOID;
    $OverrideB = isset($Format["B"]) ? $Format["B"] : VOID;
    $OverrideAlpha = isset($Format["Alpha"]) ? $Format["Alpha"] : VOID;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    foreach ($Data["Series"] as $SerieName => $Serie) {
      if ($Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"]) {
        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"];
        }
        if ($OverrideTicks == NULL) {
          $Ticks = $Serie["Ticks"];
        }
        else {
          $Ticks = $OverrideTicks;
        }
        if ($OverrideAlpha == VOID) {
          $Alpha = $Serie["Color"]["Alpha"];
        }
        else {
          $Alpha = $OverrideAlpha;
        }
        $Color = array(
          "R" => $R,
          "G" => $G,
          "B" => $B,
          "Alpha" => $Alpha,
          "Ticks" => $Ticks,
        );
        $AxisID = $Serie["Axis"];
        $PosArray = $this
          ->scaleComputeY($Serie["Data"], array(
          "AxisID" => $Serie["Axis"],
        ));
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
          if ($XDivs == 0) {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
          }
          else {
            $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
          }
          $X = $this->GraphAreaX1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $Sxy = 0;
          $Sx = 0;
          $Sy = 0;
          $Sxx = 0;
          foreach ($PosArray as $Key => $Y) {
            if ($Y != VOID) {
              $Sxy = $Sxy + $X * $Y;
              $Sx = $Sx + $X;
              $Sy = $Sy + $Y;
              $Sxx = $Sxx + $X * $X;
            }
            $X = $X + $XStep;
          }
          $n = count($this->DataSet
            ->stripVOID($PosArray));

          //$n = count($PosArray);
          $M = ($n * $Sxy - $Sx * $Sy) / ($n * $Sxx - $Sx * $Sx);
          $B = ($Sy - $M * $Sx) / $n;
          $X1 = $this->GraphAreaX1 + $XMargin;
          $Y1 = $M * $X1 + $B;
          $X2 = $this->GraphAreaX2 - $XMargin;
          $Y2 = $M * $X2 + $B;
          if ($Y1 < $this->GraphAreaY1) {
            $X1 = $X1 + ($this->GraphAreaY1 - $Y1);
            $Y1 = $this->GraphAreaY1;
          }
          if ($Y1 > $this->GraphAreaY2) {
            $X1 = $X1 + ($Y1 - $this->GraphAreaY2);
            $Y1 = $this->GraphAreaY2;
          }
          if ($Y2 < $this->GraphAreaY1) {
            $X2 = $X2 - ($this->GraphAreaY1 - $Y2);
            $Y2 = $this->GraphAreaY1;
          }
          if ($Y2 > $this->GraphAreaY2) {
            $X2 = $X2 - ($Y2 - $this->GraphAreaY2);
            $Y2 = $this->GraphAreaY2;
          }
          $this
            ->drawLine($X1, $Y1, $X2, $Y2, $Color);
        }
        else {
          if ($XDivs == 0) {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
          }
          else {
            $YStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
          }
          $Y = $this->GraphAreaY1 + $XMargin;
          if (!is_array($PosArray)) {
            $Value = $PosArray;
            $PosArray = "";
            $PosArray[0] = $Value;
          }
          $Sxy = 0;
          $Sx = 0;
          $Sy = 0;
          $Sxx = 0;
          foreach ($PosArray as $Key => $X) {
            if ($X != VOID) {
              $Sxy = $Sxy + $X * $Y;
              $Sx = $Sx + $Y;
              $Sy = $Sy + $X;
              $Sxx = $Sxx + $Y * $Y;
            }
            $Y = $Y + $YStep;
          }
          $n = count($this->DataSet
            ->stripVOID($PosArray));

          //$n = count($PosArray);
          $M = ($n * $Sxy - $Sx * $Sy) / ($n * $Sxx - $Sx * $Sx);
          $B = ($Sy - $M * $Sx) / $n;
          $Y1 = $this->GraphAreaY1 + $XMargin;
          $X1 = $M * $Y1 + $B;
          $Y2 = $this->GraphAreaY2 - $XMargin;
          $X2 = $M * $Y2 + $B;
          if ($X1 < $this->GraphAreaX1) {
            $Y1 = $Y1 + ($this->GraphAreaX1 - $X1);
            $X1 = $this->GraphAreaX1;
          }
          if ($X1 > $this->GraphAreaX2) {
            $Y1 = $Y1 + ($X1 - $this->GraphAreaX2);
            $X1 = $this->GraphAreaX2;
          }
          if ($X2 < $this->GraphAreaX1) {
            $Y2 = $Y2 - ($this->GraphAreaY1 - $X2);
            $X2 = $this->GraphAreaX1;
          }
          if ($X2 > $this->GraphAreaX2) {
            $Y2 = $Y2 - ($X2 - $this->GraphAreaX2);
            $X2 = $this->GraphAreaX2;
          }
          $this
            ->drawLine($X1, $Y1, $X2, $Y2, $Color);
        }
      }
    }
  }

  /* Write labels */
  function writeLabel($SeriesName, $Indexes, $Format = "") {
    $OverrideTitle = isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : NULL;
    $ForceLabels = isset($Format["ForceLabels"]) ? $Format["ForceLabels"] : NULL;
    $DrawPoint = isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;
    $DrawVerticalLine = isset($Format["DrawVerticalLine"]) ? $Format["DrawVerticalLine"] : FALSE;
    $VerticalLineR = isset($Format["VerticalLineR"]) ? $Format["VerticalLineR"] : 0;
    $VerticalLineG = isset($Format["VerticalLineG"]) ? $Format["VerticalLineG"] : 0;
    $VerticalLineB = isset($Format["VerticalLineB"]) ? $Format["VerticalLineB"] : 0;
    $VerticalLineAlpha = isset($Format["VerticalLineAlpha"]) ? $Format["VerticalLineAlpha"] : 40;
    $VerticalLineTicks = isset($Format["VerticalLineTicks"]) ? $Format["VerticalLineTicks"] : 2;
    $Data = $this->DataSet
      ->getData();
    list($XMargin, $XDivs) = $this
      ->scaleGetXSettings();
    if (!is_array($Indexes)) {
      $Index = $Indexes;
      $Indexes = "";
      $Indexes[] = $Index;
    }
    if (!is_array($SeriesName)) {
      $SerieName = $SeriesName;
      $SeriesName = "";
      $SeriesName[] = $SerieName;
    }
    if ($ForceLabels != NULL && !is_array($ForceLabels)) {
      $ForceLabel = $ForceLabels;
      $ForceLabels = "";
      $ForceLabels[] = $ForceLabel;
    }
    foreach ($Indexes as $Key => $Index) {
      $Series = "";
      if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
        if ($XDivs == 0) {
          $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
        }
        else {
          $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
        }
        $X = $this->GraphAreaX1 + $XMargin + $Index * $XStep;
        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,
          ));
        }
        $MinY = $this->GraphAreaY2;
        foreach ($SeriesName as $iKey => $SerieName) {
          if (isset($Data["Series"][$SerieName]["Data"][$Index])) {
            $AxisID = $Data["Series"][$SerieName]["Axis"];
            $XAxisMode = $Data["XAxisDisplay"];
            $XAxisFormat = $Data["XAxisFormat"];
            $XAxisUnit = $Data["XAxisUnit"];
            $AxisMode = $Data["Axis"][$AxisID]["Display"];
            $AxisFormat = $Data["Axis"][$AxisID]["Format"];
            $AxisUnit = $Data["Axis"][$AxisID]["Unit"];
            if (isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])) {
              $XLabel = $this
                ->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index], $XAxisMode, $XAxisFormat, $XAxisUnit);
            }
            else {
              $XLabel = "";
            }
            if ($OverrideTitle != NULL) {
              $Description = $OverrideTitle;
            }
            elseif (count($SeriesName) == 1) {
              $Description = $Data["Series"][$SerieName]["Description"] . " - " . $XLabel;
            }
            elseif (isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])) {
              $Description = $XLabel;
            }
            $Serie = "";
            $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];
            $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];
            $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];
            $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];
            if (count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"])) {
              $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
            }
            else {
              $SerieOffset = 0;
            }
            $Value = $Data["Series"][$SerieName]["Data"][$Index];
            if ($Value == VOID) {
              $Value = "NaN";
            }
            if ($ForceLabels != NULL) {
              $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
            }
            else {
              $Caption = $this
                ->scaleFormat($Value, $AxisMode, $AxisFormat, $AxisUnit);
            }
            if ($this->LastChartLayout == CHART_LAST_LAYOUT_STACKED) {
              if ($Value >= 0) {
                $LookFor = "+";
              }
              else {
                $LookFor = "-";
              }
              $Value = 0;
              $Done = FALSE;
              foreach ($Data["Series"] as $Name => $SerieLookup) {
                if ($SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done) {
                  if (isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID) {
                    if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+") {
                      $Value = $Value + $Data["Series"][$Name]["Data"][$Index];
                    }
                    if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-") {
                      $Value = $Value - $Data["Series"][$Name]["Data"][$Index];
                    }
                    if ($Name == $SerieName) {
                      $Done = TRUE;
                    }
                  }
                }
              }
            }
            $X = floor($this->GraphAreaX1 + $XMargin + $Index * $XStep + $SerieOffset);
            $Y = floor($this
              ->scaleComputeY($Value, array(
              "AxisID" => $AxisID,
            )));
            if ($Y < $MinY) {
              $MinY = $Y;
            }
            if ($DrawPoint == LABEL_POINT_CIRCLE) {
              $this
                ->drawFilledCircle($X, $Y, 3, array(
                "R" => 255,
                "G" => 255,
                "B" => 255,
                "BorderR" => 0,
                "BorderG" => 0,
                "BorderB" => 0,
              ));
            }
            elseif ($DrawPoint == LABEL_POINT_BOX) {
              $this
                ->drawFilledRectangle($X - 2, $Y - 2, $X + 2, $Y + 2, array(
                "R" => 255,
                "G" => 255,
                "B" => 255,
                "BorderR" => 0,
                "BorderG" => 0,
                "BorderB" => 0,
              ));
            }
            $Series[] = array(
              "Format" => $Serie,
              "Caption" => $Caption,
            );
          }
        }
        $this
          ->drawLabelBox($X, $MinY - 3, $Description, $Series, $Format);
      }
      else {
        if ($XDivs == 0) {
          $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
        }
        else {
          $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
        }
        $Y = $this->GraphAreaY1 + $XMargin + $Index * $XStep;
        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,
          ));
        }
        $MinX = $this->GraphAreaX2;
        foreach ($SeriesName as $Key => $SerieName) {
          if (isset($Data["Series"][$SerieName]["Data"][$Index])) {
            $AxisID = $Data["Series"][$SerieName]["Axis"];
            $XAxisMode = $Data["XAxisDisplay"];
            $XAxisFormat = $Data["XAxisFormat"];
            $XAxisUnit = $Data["XAxisUnit"];
            $AxisMode = $Data["Axis"][$AxisID]["Display"];
            $AxisFormat = $Data["Axis"][$AxisID]["Format"];
            $AxisUnit = $Data["Axis"][$AxisID]["Unit"];
            if (isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])) {
              $XLabel = $this
                ->scaleFormat($Data["Series"][$Data["Abscissa"]]["Data"][$Index], $XAxisMode, $XAxisFormat, $XAxisUnit);
            }
            else {
              $XLabel = "";
            }
            if ($OverrideTitle != NULL) {
              $Description = $OverrideTitle;
            }
            elseif (count($SeriesName) == 1) {
              if (isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])) {
                $Description = $Data["Series"][$SerieName]["Description"] . " - " . $XLabel;
              }
            }
            elseif (isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])) {
              $Description = $XLabel;
            }
            $Serie = "";
            if (isset($Data["Extended"]["Palette"][$Index])) {
              $Serie["R"] = $Data["Extended"]["Palette"][$Index]["R"];
              $Serie["G"] = $Data["Extended"]["Palette"][$Index]["G"];
              $Serie["B"] = $Data["Extended"]["Palette"][$Index]["B"];
              $Serie["Alpha"] = $Data["Extended"]["Palette"][$Index]["Alpha"];
            }
            else {
              $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];
              $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];
              $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];
              $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];
            }
            if (count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"])) {
              $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
            }
            else {
              $SerieOffset = 0;
            }
            $Value = $Data["Series"][$SerieName]["Data"][$Index];
            if ($ForceLabels != NULL) {
              $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
            }
            else {
              $Caption = $this
                ->scaleFormat($Value, $AxisMode, $AxisFormat, $AxisUnit);
            }
            if ($Value == VOID) {
              $Value = "NaN";
            }
            if ($this->LastChartLayout == CHART_LAST_LAYOUT_STACKED) {
              if ($Value >= 0) {
                $LookFor = "+";
              }
              else {
                $LookFor = "-";
              }
              $Value = 0;
              $Done = FALSE;
              foreach ($Data["Series"] as $Name => $SerieLookup) {
                if ($SerieLookup["isDrawable"] == TRUE && $Name != $Data["Abscissa"] && !$Done) {
                  if (isset($Data["Series"][$Name]["Data"][$Index]) && $Data["Series"][$Name]["Data"][$Index] != VOID) {
                    if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+") {
                      $Value = $Value + $Data["Series"][$Name]["Data"][$Index];
                    }
                    if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-") {
                      $Value = $Value - $Data["Series"][$Name]["Data"][$Index];
                    }
                    if ($Name == $SerieName) {
                      $Done = TRUE;
                    }
                  }
                }
              }
            }
            $X = floor($this
              ->scaleComputeY($Value, array(
              "AxisID" => $AxisID,
            )));
            $Y = floor($this->GraphAreaY1 + $XMargin + $Index * $XStep + $SerieOffset);
            if ($X < $MinX) {
              $MinX = $X;
            }
            if ($DrawPoint == LABEL_POINT_CIRCLE) {
              $this
                ->drawFilledCircle($X, $Y, 3, array(
                "R" => 255,
                "G" => 255,
                "B" => 255,
                "BorderR" => 0,
                "BorderG" => 0,
                "BorderB" => 0,
              ));
            }
            elseif ($DrawPoint == LABEL_POINT_BOX) {
              $this
                ->drawFilledRectangle($X - 2, $Y - 2, $X + 2, $Y + 2, array(
                "R" => 255,
                "G" => 255,
                "B" => 255,
                "BorderR" => 0,
                "BorderG" => 0,
                "BorderB" => 0,
              ));
            }
            $Series[] = array(
              "Format" => $Serie,
              "Caption" => $Caption,
            );
          }
        }
        $this
          ->drawLabelBox($MinX, $Y - 3, $Description, $Series, $Format);
      }
    }
  }

  /* Draw a label box */
  function drawLabelBox($X, $Y, $Title, $Captions, $Format = "") {
    $NoTitle = isset($Format["NoTitle"]) ? $Format["NoTitle"] : NULL;
    $BoxWidth = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 50;
    $DrawSerieColor = isset($Format["DrawSerieColor"]) ? $Format["DrawSerieColor"] : TRUE;
    $SerieR = isset($Format["SerieR"]) ? $Format["SerieR"] : NULL;
    $SerieG = isset($Format["SerieG"]) ? $Format["SerieG"] : NULL;
    $SerieB = isset($Format["SerieB"]) ? $Format["SerieB"] : NULL;
    $SerieAlpha = isset($Format["SerieAlpha"]) ? $Format["SerieAlpha"] : NULL;
    $SerieBoxSize = isset($Format["SerieBoxSize"]) ? $Format["SerieBoxSize"] : 6;
    $SerieBoxSpacing = isset($Format["SerieBoxSpacing"]) ? $Format["SerieBoxSpacing"] : 4;
    $VerticalMargin = isset($Format["VerticalMargin"]) ? $Format["VerticalMargin"] : 10;
    $HorizontalMargin = isset($Format["HorizontalMargin"]) ? $Format["HorizontalMargin"] : 8;
    $R = isset($Format["R"]) ? $Format["R"] : $this->FontColorR;
    $G = isset($Format["G"]) ? $Format["G"] : $this->FontColorG;
    $B = isset($Format["B"]) ? $Format["B"] : $this->FontColorB;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;
    $FontName = isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    $TitleMode = isset($Format["TitleMode"]) ? $Format["TitleMode"] : LABEL_TITLE_NOBACKGROUND;
    $TitleR = isset($Format["TitleR"]) ? $Format["TitleR"] : $R;
    $TitleG = isset($Format["TitleG"]) ? $Format["TitleG"] : $G;
    $TitleB = isset($Format["TitleB"]) ? $Format["TitleB"] : $B;
    $TitleAlpha = isset($Format["TitleAlpha"]) ? $Format["TitleAlpha"] : 100;
    $TitleBackgroundR = isset($Format["TitleBackgroundR"]) ? $Format["TitleBackgroundR"] : 0;
    $TitleBackgroundG = isset($Format["TitleBackgroundG"]) ? $Format["TitleBackgroundG"] : 0;
    $TitleBackgroundB = isset($Format["TitleBackgroundB"]) ? $Format["TitleBackgroundB"] : 0;
    $TitleBackgroundAlpha = isset($Format["TitleBackgroundAlpha"]) ? $Format["TitleBackgroundAlpha"] : 100;
    $GradientStartR = isset($Format["GradientStartR"]) ? $Format["GradientStartR"] : 255;
    $GradientStartG = isset($Format["GradientStartG"]) ? $Format["GradientStartG"] : 255;
    $GradientStartB = isset($Format["GradientStartB"]) ? $Format["GradientStartB"] : 255;
    $GradientEndR = isset($Format["GradientEndR"]) ? $Format["GradientEndR"] : 220;
    $GradientEndG = isset($Format["GradientEndG"]) ? $Format["GradientEndG"] : 220;
    $GradientEndB = isset($Format["GradientEndB"]) ? $Format["GradientEndB"] : 220;
    $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 100;
    if (!$DrawSerieColor) {
      $SerieBoxSize = 0;
      $SerieBoxSpacing = 0;
    }
    $TxtPos = $this
      ->getTextBox($X, $Y, $FontName, $FontSize, 0, $Title);
    $TitleWidth = $TxtPos[1]["X"] - $TxtPos[0]["X"] + $VerticalMargin * 2;
    $TitleHeight = $TxtPos[0]["Y"] - $TxtPos[2]["Y"];
    if ($NoTitle) {
      $TitleWidth = 0;
      $TitleHeight = 0;
    }
    $CaptionWidth = 0;
    $CaptionHeight = -$HorizontalMargin;
    foreach ($Captions as $Key => $Caption) {
      $TxtPos = $this
        ->getTextBox($X, $Y, $FontName, $FontSize, 0, $Caption["Caption"]);
      $CaptionWidth = max($CaptionWidth, $TxtPos[1]["X"] - $TxtPos[0]["X"] + $VerticalMargin * 2);
      $CaptionHeight = $CaptionHeight + max($TxtPos[0]["Y"] - $TxtPos[2]["Y"], $SerieBoxSize + 2) + $HorizontalMargin;
    }
    if ($CaptionHeight <= 5) {
      $CaptionHeight = $CaptionHeight + $HorizontalMargin / 2;
    }
    if ($DrawSerieColor) {
      $CaptionWidth = $CaptionWidth + $SerieBoxSize + $SerieBoxSpacing;
    }
    $BoxWidth = max($BoxWidth, $TitleWidth, $CaptionWidth);
    $XMin = $X - 5 - floor(($BoxWidth - 10) / 2);
    $XMax = $X + 5 + floor(($BoxWidth - 10) / 2);
    $RestoreShadow = $this->Shadow;
    if ($this->Shadow == TRUE) {
      $this->Shadow = FALSE;
      $Poly = "";
      $Poly[] = $X + $this->ShadowX;
      $Poly[] = $Y + $this->ShadowX;
      $Poly[] = $X + 5 + $this->ShadowX;
      $Poly[] = $Y - 5 + $this->ShadowX;
      $Poly[] = $XMax + $this->ShadowX;
      $Poly[] = $Y - 5 + $this->ShadowX;
      if ($NoTitle) {
        $Poly[] = $XMax + $this->ShadowX;
        $Poly[] = $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2 + $this->ShadowX;
        $Poly[] = $XMin + $this->ShadowX;
        $Poly[] = $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2 + $this->ShadowX;
      }
      else {
        $Poly[] = $XMax + $this->ShadowX;
        $Poly[] = $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3 + $this->ShadowX;
        $Poly[] = $XMin + $this->ShadowX;
        $Poly[] = $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3 + $this->ShadowX;
      }
      $Poly[] = $XMin + $this->ShadowX;
      $Poly[] = $Y - 5 + $this->ShadowX;
      $Poly[] = $X - 5 + $this->ShadowX;
      $Poly[] = $Y - 5 + $this->ShadowX;
      $this
        ->drawPolygon($Poly, array(
        "R" => $this->ShadowR,
        "G" => $this->ShadowG,
        "B" => $this->ShadowB,
        "Alpha" => $this->Shadowa,
      ));
    }

    /* Draw the background */
    $GradientSettings = array(
      "StartR" => $GradientStartR,
      "StartG" => $GradientStartG,
      "StartB" => $GradientStartB,
      "EndR" => $GradientEndR,
      "EndG" => $GradientEndG,
      "EndB" => $GradientEndB,
      "Alpha" => $BoxAlpha,
    );
    if ($NoTitle) {
      $this
        ->drawGradientArea($XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMax, $Y - 6, DIRECTION_VERTICAL, $GradientSettings);
    }
    else {
      $this
        ->drawGradientArea($XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMax, $Y - 6, DIRECTION_VERTICAL, $GradientSettings);
    }
    $Poly = "";
    $Poly[] = $X;
    $Poly[] = $Y;
    $Poly[] = $X - 5;
    $Poly[] = $Y - 5;
    $Poly[] = $X + 5;
    $Poly[] = $Y - 5;
    $this
      ->drawPolygon($Poly, array(
      "R" => $GradientEndR,
      "G" => $GradientEndG,
      "B" => $GradientEndB,
      "Alpha" => $BoxAlpha,
      "NoBorder" => TRUE,
    ));

    /* Outer border */
    $OuterBorderColor = $this
      ->allocateColor($this->Picture, 100, 100, 100, $BoxAlpha);
    imageline($this->Picture, $XMin, $Y - 5, $X - 5, $Y - 5, $OuterBorderColor);
    imageline($this->Picture, $X, $Y, $X - 5, $Y - 5, $OuterBorderColor);
    imageline($this->Picture, $X, $Y, $X + 5, $Y - 5, $OuterBorderColor);
    imageline($this->Picture, $X + 5, $Y - 5, $XMax, $Y - 5, $OuterBorderColor);
    if ($NoTitle) {
      imageline($this->Picture, $XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMin, $Y - 5, $OuterBorderColor);
      imageline($this->Picture, $XMax, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMax, $Y - 5, $OuterBorderColor);
      imageline($this->Picture, $XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMax, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $OuterBorderColor);
    }
    else {
      imageline($this->Picture, $XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMin, $Y - 5, $OuterBorderColor);
      imageline($this->Picture, $XMax, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMax, $Y - 5, $OuterBorderColor);
      imageline($this->Picture, $XMin, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMax, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $OuterBorderColor);
    }

    /* Inner border */
    $InnerBorderColor = $this
      ->allocateColor($this->Picture, 255, 255, 255, $BoxAlpha);
    imageline($this->Picture, $XMin + 1, $Y - 6, $X - 5, $Y - 6, $InnerBorderColor);
    imageline($this->Picture, $X, $Y - 1, $X - 5, $Y - 6, $InnerBorderColor);
    imageline($this->Picture, $X, $Y - 1, $X + 5, $Y - 6, $InnerBorderColor);
    imageline($this->Picture, $X + 5, $Y - 6, $XMax - 1, $Y - 6, $InnerBorderColor);
    if ($NoTitle) {
      imageline($this->Picture, $XMin + 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMin + 1, $Y - 6, $InnerBorderColor);
      imageline($this->Picture, $XMax - 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMax - 1, $Y - 6, $InnerBorderColor);
      imageline($this->Picture, $XMin + 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $XMax - 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 2, $InnerBorderColor);
    }
    else {
      imageline($this->Picture, $XMin + 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMin + 1, $Y - 6, $InnerBorderColor);
      imageline($this->Picture, $XMax - 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMax - 1, $Y - 6, $InnerBorderColor);
      imageline($this->Picture, $XMin + 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $XMax - 1, $Y - 4 - $TitleHeight - $CaptionHeight - $HorizontalMargin * 3, $InnerBorderColor);
    }

    /* Draw the separator line */
    if ($TitleMode == LABEL_TITLE_NOBACKGROUND && !$NoTitle) {
      $YPos = $Y - 7 - $CaptionHeight - $HorizontalMargin - $HorizontalMargin / 2;
      $XMargin = $VerticalMargin / 2;
      $this
        ->drawLine($XMin + $XMargin, $YPos + 1, $XMax - $XMargin, $YPos + 1, array(
        "R" => $GradientEndR,
        "G" => $GradientEndG,
        "B" => $GradientEndB,
        "Alpha" => $BoxAlpha,
      ));
      $this
        ->drawLine($XMin + $XMargin, $YPos, $XMax - $XMargin, $YPos, array(
        "R" => $GradientStartR,
        "G" => $GradientStartG,
        "B" => $GradientStartB,
        "Alpha" => $BoxAlpha,
      ));
    }
    elseif ($TitleMode == LABEL_TITLE_BACKGROUND) {
      $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,
      ));
      imageline($this->Picture, $XMin + 1, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin + $HorizontalMargin / 2 + 1, $XMax - 1, $Y - 5 - $TitleHeight - $CaptionHeight - $HorizontalMargin + $HorizontalMargin / 2 + 1, $InnerBorderColor);
    }

    /* Write the description */
    if (!$NoTitle) {
      $this
        ->drawText($XMin + $VerticalMargin, $Y - 7 - $CaptionHeight - $HorizontalMargin * 2, $Title, array(
        "Align" => TEXT_ALIGN_BOTTOMLEFT,
        "R" => $TitleR,
        "G" => $TitleG,
        "B" => $TitleB,
      ));
    }

    /* Write the value */
    $YPos = $Y - 5 - $HorizontalMargin;
    $XPos = $XMin + $VerticalMargin + $SerieBoxSize + $SerieBoxSpacing;
    foreach ($Captions as $Key => $Caption) {
      $CaptionTxt = $Caption["Caption"];
      $TxtPos = $this
        ->getTextBox($XPos, $YPos, $FontName, $FontSize, 0, $CaptionTxt);
      $CaptionHeight = $TxtPos[0]["Y"] - $TxtPos[2]["Y"];

      /* Write the serie color if needed */
      if ($DrawSerieColor) {
        $BoxSettings = array(
          "R" => $Caption["Format"]["R"],
          "G" => $Caption["Format"]["G"],
          "B" => $Caption["Format"]["B"],
          "Alpha" => $Caption["Format"]["Alpha"],
          "BorderR" => 0,
          "BorderG" => 0,
          "BorderB" => 0,
        );
        $this
          ->drawFilledRectangle($XMin + $VerticalMargin, $YPos - $SerieBoxSize, $XMin + $VerticalMargin + $SerieBoxSize, $YPos, $BoxSettings);
      }
      $this
        ->drawText($XPos, $YPos, $CaptionTxt, array(
        "Align" => TEXT_ALIGN_BOTTOMLEFT,
      ));
      $YPos = $YPos - $CaptionHeight - $HorizontalMargin;
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Draw a basic shape */
  function drawShape($X, $Y, $Shape, $PlotSize, $PlotBorder, $BorderSize, $R, $G, $B, $Alpha, $BorderR, $BorderG, $BorderB, $BorderAlpha) {
    if ($Shape == SERIE_SHAPE_FILLEDCIRCLE) {
      if ($PlotBorder) {
        $this
          ->drawFilledCircle($X, $Y, $PlotSize + $BorderSize, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
        ));
      }
      $this
        ->drawFilledCircle($X, $Y, $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_FILLEDSQUARE) {
      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,
        ));
      }
      $this
        ->drawFilledRectangle($X - $PlotSize, $Y - $PlotSize, $X + $PlotSize, $Y + $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_FILLEDTRIANGLE) {
      if ($PlotBorder) {
        $Pos = "";
        $Pos[] = $X;
        $Pos[] = $Y - $PlotSize - $BorderSize;
        $Pos[] = $X - $PlotSize - $BorderSize;
        $Pos[] = $Y + $PlotSize + $BorderSize;
        $Pos[] = $X + $PlotSize + $BorderSize;
        $Pos[] = $Y + $PlotSize + $BorderSize;
        $this
          ->drawPolygon($Pos, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
        ));
      }
      $Pos = "";
      $Pos[] = $X;
      $Pos[] = $Y - $PlotSize;
      $Pos[] = $X - $PlotSize;
      $Pos[] = $Y + $PlotSize;
      $Pos[] = $X + $PlotSize;
      $Pos[] = $Y + $PlotSize;
      $this
        ->drawPolygon($Pos, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_TRIANGLE) {
      $this
        ->drawLine($X, $Y - $PlotSize, $X - $PlotSize, $Y + $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      $this
        ->drawLine($X - $PlotSize, $Y + $PlotSize, $X + $PlotSize, $Y + $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
      $this
        ->drawLine($X + $PlotSize, $Y + $PlotSize, $X, $Y - $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_SQUARE) {
      $this
        ->drawRectangle($X - $PlotSize, $Y - $PlotSize, $X + $PlotSize, $Y + $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_CIRCLE) {
      $this
        ->drawCircle($X, $Y, $PlotSize, $PlotSize, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_DIAMOND) {
      $Pos = "";
      $Pos[] = $X - $PlotSize;
      $Pos[] = $Y;
      $Pos[] = $X;
      $Pos[] = $Y - $PlotSize;
      $Pos[] = $X + $PlotSize;
      $Pos[] = $Y;
      $Pos[] = $X;
      $Pos[] = $Y + $PlotSize;
      $this
        ->drawPolygon($Pos, array(
        "NoFill" => TRUE,
        "BorderR" => $R,
        "BorderG" => $G,
        "BorderB" => $B,
        "BorderAlpha" => $Alpha,
      ));
    }
    elseif ($Shape == SERIE_SHAPE_FILLEDDIAMOND) {
      if ($PlotBorder) {
        $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;
        $this
          ->drawPolygon($Pos, array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
        ));
      }
      $Pos = "";
      $Pos[] = $X - $PlotSize;
      $Pos[] = $Y;
      $Pos[] = $X;
      $Pos[] = $Y - $PlotSize;
      $Pos[] = $X + $PlotSize;
      $Pos[] = $Y;
      $Pos[] = $X;
      $Pos[] = $Y + $PlotSize;
      $this
        ->drawPolygon($Pos, array(
        "R" => $R,
        "G" => $G,
        "B" => $B,
        "Alpha" => $Alpha,
      ));
    }
  }
  function drawPolygonChart($Points, $Format = "") {
    $R = isset($Format["R"]) ? $Format["R"] : 0;
    $G = isset($Format["G"]) ? $Format["G"] : 0;
    $B = isset($Format["B"]) ? $Format["B"] : 0;
    $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    $NoFill = isset($Format["NoFill"]) ? $Format["NoFill"] : FALSE;
    $NoBorder = isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;
    $BorderR = isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    $BorderG = isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    $BorderB = isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    $BorderAlpha = isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha / 2;
    $Surrounding = isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    $Threshold = isset($Format["Threshold"]) ? $Format["Threshold"] : NULL;
    if ($Surrounding != NULL) {
      $BorderR = $R + $Surrounding;
      $BorderG = $G + $Surrounding;
      $BorderB = $B + $Surrounding;
    }
    $RestoreShadow = $this->Shadow;
    $this->Shadow = FALSE;
    $AllIntegers = TRUE;
    for ($i = 0; $i <= count($Points) - 2; $i = $i + 2) {
      if ($this
        ->getFirstDecimal($Points[$i + 1]) != 0) {
        $AllIntegers = FALSE;
      }
    }

    /* Convert polygon to segments */
    $Segments = "";
    for ($i = 2; $i <= count($Points) - 2; $i = $i + 2) {
      $Segments[] = array(
        "X1" => $Points[$i - 2],
        "Y1" => $Points[$i - 1],
        "X2" => $Points[$i],
        "Y2" => $Points[$i + 1],
      );
    }
    $Segments[] = array(
      "X1" => $Points[$i - 2],
      "Y1" => $Points[$i - 1],
      "X2" => $Points[0],
      "Y2" => $Points[1],
    );

    /* Simplify straight lines */
    $Result = "";
    $inHorizon = FALSE;
    $LastX = VOID;
    foreach ($Segments as $Key => $Pos) {
      if ($Pos["Y1"] != $Pos["Y2"]) {
        if ($inHorizon) {
          $inHorizon = FALSE;
          $Result[] = array(
            "X1" => $LastX,
            "Y1" => $Pos["Y1"],
            "X2" => $Pos["X1"],
            "Y2" => $Pos["Y1"],
          );
        }
        $Result[] = array(
          "X1" => $Pos["X1"],
          "Y1" => $Pos["Y1"],
          "X2" => $Pos["X2"],
          "Y2" => $Pos["Y2"],
        );
      }
      else {
        if (!$inHorizon) {
          $inHorizon = TRUE;
          $LastX = $Pos["X1"];
        }
      }
    }
    $Segments = $Result;

    /* Do we have something to draw */
    if ($Segments == "") {
      return 0;
    }

    /* For segments debugging purpose */

    //foreach($Segments as $Key => $Pos)

    // echo $Pos["X1"].",".$Pos["Y1"].",".$Pos["X2"].",".$Pos["Y2"]."\r\n";

    /* Find out the min & max Y boundaries */
    $MinY = OUT_OF_SIGHT;
    $MaxY = OUT_OF_SIGHT;
    foreach ($Segments as $Key => $Coords) {
      if ($MinY == OUT_OF_SIGHT || $MinY > min($Coords["Y1"], $Coords["Y2"])) {
        $MinY = min($Coords["Y1"], $Coords["Y2"]);
      }
      if ($MaxY == OUT_OF_SIGHT || $MaxY < max($Coords["Y1"], $Coords["Y2"])) {
        $MaxY = max($Coords["Y1"], $Coords["Y2"]);
      }
    }
    if ($AllIntegers) {
      $YStep = 1;
    }
    else {
      $YStep = 0.5;
    }
    $MinY = floor($MinY);
    $MaxY = floor($MaxY);

    /* Scan each Y lines */
    $DefaultColor = $this
      ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
    $DebugLine = 0;
    $DebugColor = $this
      ->allocateColor($this->Picture, 255, 0, 0, 100);
    $MinY = floor($MinY);
    $MaxY = floor($MaxY);
    $YStep = 1;
    if (!$NoFill) {

      //if ( $DebugLine ) { $MinY = $DebugLine; $MaxY = $DebugLine; }
      for ($Y = $MinY; $Y <= $MaxY; $Y = $Y + $YStep) {
        $Intersections = "";
        $LastSlope = NULL;
        $RestoreLast = "-";
        foreach ($Segments as $Key => $Coords) {
          $X1 = $Coords["X1"];
          $X2 = $Coords["X2"];
          $Y1 = $Coords["Y1"];
          $Y2 = $Coords["Y2"];
          if (min($Y1, $Y2) <= $Y && max($Y1, $Y2) >= $Y) {
            if ($Y1 == $Y2) {
              $X = $X1;
            }
            else {
              $X = $X1 + (($Y - $Y1) * $X2 - ($Y - $Y1) * $X1) / ($Y2 - $Y1);
            }
            $X = floor($X);
            if ($X2 == $X1) {
              $Slope = "!";
            }
            else {
              $SlopeC = ($Y2 - $Y1) / ($X2 - $X1);
              if ($SlopeC == 0) {
                $Slope = "=";
              }
              elseif ($SlopeC > 0) {
                $Slope = "+";
              }
              elseif ($SlopeC < 0) {
                $Slope = "-";
              }
            }
            if (!is_array($Intersections)) {
              $Intersections[] = $X;
            }
            elseif (!in_array($X, $Intersections)) {
              $Intersections[] = $X;
            }
            elseif (in_array($X, $Intersections)) {
              if ($Y == $DebugLine) {
                echo $Slope . "/" . $LastSlope . "(" . $X . ") ";
              }
              if ($Slope == "=" && $LastSlope == "-") {
                $Intersections[] = $X;
              }
              if ($Slope != $LastSlope && $LastSlope != "!" && $LastSlope != "=") {
                $Intersections[] = $X;
              }
              if ($Slope != $LastSlope && $LastSlope == "!" && $Slope == "+") {
                $Intersections[] = $X;
              }
            }
            if (is_array($Intersections) && in_array($X, $Intersections) && $LastSlope == "=" && $Slope == "-") {
              $Intersections[] = $X;
            }
            $LastSlope = $Slope;
          }
        }
        if ($RestoreLast != "-") {
          $Intersections[] = $RestoreLast;
          echo "@" . $Y . "\r\n";
        }
        if (is_array($Intersections)) {
          sort($Intersections);
          if ($Y == $DebugLine) {
            print_r($Intersections);
          }

          /* Remove NULL plots */
          $Result = "";
          for ($i = 0; $i <= count($Intersections) - 1; $i = $i + 2) {
            if (isset($Intersections[$i + 1])) {
              if ($Intersections[$i] != $Intersections[$i + 1]) {
                $Result[] = $Intersections[$i];
                $Result[] = $Intersections[$i + 1];
              }
            }
          }
          if (is_array($Result)) {
            $Intersections = $Result;
            $LastX = OUT_OF_SIGHT;
            foreach ($Intersections as $Key => $X) {
              if ($LastX == OUT_OF_SIGHT) {
                $LastX = $X;
              }
              elseif ($LastX != OUT_OF_SIGHT) {
                if ($this
                  ->getFirstDecimal($LastX) > 1) {
                  $LastX++;
                }
                $Color = $DefaultColor;
                if ($Threshold != NULL) {
                  foreach ($Threshold as $Key => $Parameters) {
                    if ($Y <= $Parameters["MinX"] && $Y >= $Parameters["MaxX"]) {
                      if (isset($Parameters["R"])) {
                        $R = $Parameters["R"];
                      }
                      else {
                        $R = 0;
                      }
                      if (isset($Parameters["G"])) {
                        $G = $Parameters["G"];
                      }
                      else {
                        $G = 0;
                      }
                      if (isset($Parameters["B"])) {
                        $B = $Parameters["B"];
                      }
                      else {
                        $B = 0;
                      }
                      if (isset($Parameters["Alpha"])) {
                        $Alpha = $Parameters["Alpha"];
                      }
                      else {
                        $Alpha = 100;
                      }
                      $Color = $this
                        ->allocateColor($this->Picture, $R, $G, $B, $Alpha);
                    }
                  }
                }
                imageline($this->Picture, $LastX, $Y, $X, $Y, $Color);
                if ($Y == $DebugLine) {
                  imageline($this->Picture, $LastX, $Y, $X, $Y, $DebugColor);
                }
                $LastX = OUT_OF_SIGHT;
              }
            }
          }
        }
      }
    }

    /* Draw the polygon border, if required */
    if (!$NoBorder) {
      foreach ($Segments as $Key => $Coords) {
        $this
          ->drawLine($Coords["X1"], $Coords["Y1"], $Coords["X2"], $Coords["Y2"], array(
          "R" => $BorderR,
          "G" => $BorderG,
          "B" => $BorderB,
          "Alpha" => $BorderAlpha,
          "Threshold" => $Threshold,
        ));
      }
    }
    $this->Shadow = $RestoreShadow;
  }

  /* Return the abscissa margin */
  function getAbscissaMargin($Data) {
    foreach ($Data["Axis"] as $AxisID => $Values) {
      if ($Values["Identity"] == AXIS_X) {
        return $Values["Margin"];
      }
    }
    return 0;
  }

}