Location: PHPKode > scripts > DbGraph > dbgraph/class.graph.php
<?php
/** *********************************************************************************************************************
 * This is main class of graph which can be generate a bar graph or line graph.
 * @author Shailesh Patel
 * @version  1.0
 * Date: 5th March.
 ** *********************************************************************************************************************
 */
class CGraph {
	var $data = array();
	//---------------------------------------------
	var $graph_areaheight = 100;
	var $graph_areawidth = 50;
	var $graph_padding = array('left' => 50, 'top' => 20, 'right'  => 20, 'bottom' => 20);
	var $graph_title = "";
	var $graph_titlefont = 3;
	var $graph_bgcolor = array(255, 255, 255);
	var $graph_bgtransparent = false;
	var $graph_transparencylevel = 0;
	var $graph_borderwidth = 1;
	var $graph_bordercolor = array(218, 218, 239);
	var $graph_titlecolor = array(99, 88, 78);
	//---------------------------------------------
	var $axis_stepX = 1;
	var $axis_stepY = 1;
	var $axis_stepSize = 3;
	var $axis_deepness = 0;
	var $axis_maxX = 0;
	var $axis_minX = 0;
	var $axis_maxY = 0;
	var $axis_minY = 0;
	var $axis_bordercolor = array(99, 88, 78);
	var $axis_bgcolor = array(152, 137, 124);
	var $axis_scalefont = 2;
	var $axis_scalecolor = array(0, 0, 255);
	var $axis_xscalevisible = true;
	var $axis_yscalevisible = true;
	var $axis_gridlines = true;
	var $axis_frontgridlines = true;
	var $axis_positions = array(true, false, false, true);
	var $axis_modeX = 0; // 0=diference between steps 1=number of steps
	var $axis_modeY = 0; // 0=diference between steps 1=number of steps
	//---------------------------------------------
	var $scale_roundX = 1;
	var $scale_roundY = 1;
	var $scale_funX = "";
	var $scale_funY = "";
	//---------------------------------------------
	var $legend_visible = false;
	var $legend_floating = false;
	var $legend_borderwidth = 1;
	var $legend_bgcolor = array(255, 255, 255);
	var $legend_bordercolor = array(0, 0, 0);
	var $legend_width = 0;
	var $legend_height = 0;
	var $legend_padding = 30;
	var $legend_insidepadding = 3;
	var $legend_font = 1;
	var $legend_position = 3; // 1=bottom left | 2=top left | 3=top right | 4=bottom right
	var $legend_color = array(array(0, 0, 255));
	var $legend_data = array("Item 1");

	function CGraph() {
		//nothing @ the moment.. maybe later will set image at startup
	}

	/****************************************************************
	GRAPH
	****************************************************************/
	function SetGraphAreaHeight($height) {
		if ($height > 0) {
			$this->graph_areaheight = $height;
			$this->graph_height = $this->graph_padding['top'] + $height + $this->graph_padding['bottom'];
		}
	}
	function SetGraphAreaWidth($width) {
		if ($width > 0) {
			$this->graph_areawidth = $width;
			$this->graph_width = $this->graph_padding['left'] + $width + $this->graph_padding['right'];
		}
	}
	function SetGraphPadding($left, $top, $right, $bottom) {
		$this->graph_padding = array('left' => (int)$left, 'top' => (int)$top, 'right' => (int)$right, 'bottom' => (int)$bottom);
	}
	function SetGraphTitle($title) {
		$this->graph_title = $title;
	}
	function SetGraphTitleFont($font) {
		$this->graph_titlefont = 0;
		switch ($font) {
			case 'x-large': $this->graph_titlefont++;
			case 'large':   $this->graph_titlefont++;
			case 'medium':  $this->graph_titlefont++;
			case 'small':   $this->graph_titlefont++;
			case 'x-small': $this->graph_titlefont++; break;
			default:
				$this->graph_titlefont = $font;
		}
	}
	function SetGraphTitleColor($red, $green, $blue) {
		$this->graph_titlecolor = array($red, $green, $blue);
	}
	function SetGraphBorderColor($red, $green, $blue) {
		$this->graph_bordercolor = array($red, $green, $blue);
	}
	function SetGraphBorderWidth($width = 0) {
		$this->graph_borderwidth = $width;
	}
	function SetGraphBackgroundColor($red, $green, $blue) {
		$this->graph_bgcolor = array($red, $green, $blue);
	}
	function SetGraphBackgroundTransparent($addtransparency = true, $red = 255, $green = 0, $blue = 255) {
		$this->graph_bgcolor = array($red, $green, $blue);
		$this->graph_bgtransparent = ($addtransparency ? true : false);
	}
	function SetGraphTransparency($percent) {
		if ($percent < 0) $percent = 0;
		elseif ($percent > 100) $percent = 127;
		else $percent = $percent * 1.27;
		$this->graph_transparencylevel = $percent;
	}

	/****************************************************************
	AXIS
	****************************************************************/
	function SetAxisBorderColor($red, $green, $blue) {
		$this->axis_bordercolor = array($red, $green, $blue);
	}
	function SetAxisBackgroundColor($red, $green, $blue) {
		$this->axis_bgcolor = array($red, $green, $blue);
	}
	function SetAxisScaleColor($red, $green, $blue) {
		$this->axis_scalecolor = array($red, $green, $blue);
	}
	function SetAxisStepX($step) {
		if ($step > 0) $this->axis_stepX = $step;
	}
	function SetAxisStepY($step) {
		if ($step > 0) $this->axis_stepY = $step;
	}
	function SetAxisStepSize($size) {
		$this->axis_stepSize = (int) $size;
	}
	function SetAxisScaleXVisibility($state) {
		$this->axis_xscalevisible = ($state ? true : false);
	}
	function SetAxisScaleYVisibility($state) {
		$this->axis_yscalevisible = ($state ? true : false);
	}
	function SetAxisModeX($mode) {
		switch ($mode) {
			case '0':
			case 'value':
				$this->axis_modeX = 0; break;
			case '1':
			case 'dynamic':
				$this->axis_modeX = 1; break;
			case '2':
			case 'pixel':
				$this->axis_modeX = 2; break;
		}
	}
	function SetAxisModeY($mode) {
		switch ($mode) {
			case '0':
			case 'value':
				$this->axis_modeY = 0; break;
			case '1':
			case 'dynamic':
				$this->axis_modeY = 1; break;
			case '2':
			case 'pixel':
				$this->axis_modeY = 2; break;
		}
	}
	function SetAxisDeepness($deepness) {
		$this->axis_deepness = (int) $deepness;
	}
	function SetAxisScaleFont($font) {
		$this->axis_scalefont = 0;
		switch ($font) {
			case 'x-large': $this->axis_scalefont++;
			case 'large':   $this->axis_scalefont++;
			case 'medium':  $this->axis_scalefont++;
			case 'small':   $this->axis_scalefont++;
			case 'x-small': $this->axis_scalefont++; break;
			default:
				$this->axis_scalefont = $font;
		}
	}
	function SetAxisPositions($positions) {
		$positions = explode(",", strtolower($positions));
		$this->axis_positions = array(0, 0, 0, 0);
		for ($i = 0; $i < count($positions); $i++) {
			if ($positions[$i][0] == '-') {
				$v = false;
				$positions[$i] = substr($positions[$i], 1);
			} else $v = true;
			switch ($positions[$i]) {
				case 'all':    $this->axis_positions = array($v, $v, $v, $v); break;
				case 'left':   $this->axis_positions[0] = $v; break;
				case 'top':    $this->axis_positions[1] = $v; break;
				case 'right':  $this->axis_positions[2] = $v; break;
				case 'bottom': $this->axis_positions[3] = $v; break;
			}
		}
	}
	function SetAxisGridlines($state) {
		$this->axis_gridlines = ($state ? true : false);
	}
	function SetAxisFrontGridlines($state) {
		$this->axis_frontgridlines = ($state ? true : false);
	}
	/****************************************************************
	SCALE
	****************************************************************/
	function SetScaleRoundX($number) {
		if ($number < 0) $number = 0;
		$this->scale_roundX = (int) $number;
	}
	function SetScaleRoundY($number) {
		if ($number < 0) $number = 0;
		$this->scale_roundY = (int) $number;
	}
	function SetScaleFunctionX($name) {
		$this->scale_funX = $name;
	}
	function SetScaleFunctionY($name) {
		$this->scale_funY = $name;
	}

	/****************************************************************
	LEGEND
	****************************************************************/
	function SetLegendVisible($visible) {
		$this->legend_visible = ($visible ? true : false);
	}
	function SetLegendFloating($floating) {
		$this->legend_floating = ($floating ? true : false);
	}
	function SetLegendBackgroundColor($red, $green, $blue) {
		$this->legend_bgcolor = array($red, $green, $blue);
	}
	function SetLegendBorderColor($red, $green, $blue) {
		$this->legend_bordercolor = array($red, $green, $blue);
	}
	function SetLegendBorderWidth($width = 0) {
		$this->legend_borderwidth = $width;
	}
	function SetLegendColors($colors) {
		$this->__SetColorToValue("legend_color", $colors);
	}
	function SetLegendPadding($padding = 0) {
		$this->legend_padding = $padding;
	}
	function SetLegendInsidePadding($padding = 0) {
		$this->legend_insidepadding = $padding;
	}
	function SetLegendPosition($position) {
		switch ($position) {
			case 1:
			case 'bottom left':
				$this->legend_position = 1; break;
			case 2:
			case 'top left':
				$this->legend_position = 2; break;
			case 3:
			case 'top right':
				$this->legend_position = 3; break;
			case 4:
			case 'bottom right':
				$this->legend_position = 4; break;

		}
	}
	function SetLegendData($data) {
		if (is_array($data)) {
			$this->legend_data = $data;
		}
	}
	function SetLegentFont($font) {
		$this->legend_font = 0;
		switch ($font) {
			case 'x-large': $this->legend_font++;
			case 'large':   $this->legend_font++;
			case 'medium':  $this->legend_font++;
			case 'small':   $this->legend_font++;
			case 'x-small': $this->legend_font++; break;
			default:
				$this->legend_font = $font;
		}
	}

	/****************************************************************
	DATA
	****************************************************************/
	function SetData($data) {
		if (is_array($data)) {
			$this->data = $data;
		}
	}

	function DrawGraph() {
		if ($this->graph_transparencylevel) {
			imagealphablending($this->im, true);
		}

		if ($this->legend_visible) {
			$maxlength = 0;
			for ($i = 0; $i < count($this->legend_data); $i++) {
				if (strlen($this->legend_data[$i]) > $maxlength) $maxlength = strlen($this->legend_data[$i]);
			}
			$this->legend_width = ($this->legend_insidepadding * 4) + ($maxlength * imagefontwidth($this->legend_font));

			if (!$this->legend_floating) {
				$this->graph_padding[($this->legend_position < 3 ? 'left' : 'right')] += $this->legend_padding + $this->legend_width;
				$this->graph_areawidth -= ($this->legend_padding + $this->legend_width);
			}
		}

		$this->__PaintBackground();

		$this->__DrawAxis();
	}

	function DrawGraph2() {
		if (strlen($this->graph_title)) {
			$this->__AllocateColor("im_graph_titlecolor",
			$this->graph_titlecolor,
			$this->graph_transparencylevel);
			$this->__DrawText($this->graph_title,
			floor($this->graph_width / 2),
			floor(($this->graph_padding['top'] - $this->axis_deepness - imagefontwidth($this->graph_titlefont)) / 2),
			$this->im_graph_titlecolor,
			$this->graph_titlefont,
			1);
		}

		$this->__DrawLegend();
	}

	function __PaintBackground() {
		$this->__AllocateColor("im_graph_bgcolor",
		$this->graph_bgcolor,
		0);
		if ($this->graph_bgtransparent) {
			imagecolortransparent($this->im, $this->im_graph_bgcolor);
		}
		imagefilledrectangle($this->im, 0, 0, $this->graph_width, $this->graph_height, $this->im_graph_bgcolor);
		if ($this->graph_borderwidth) {
			$this->__AllocateColor("im_graph_bordercolor",
			$this->graph_bordercolor,
			$this->graph_transparencylevel);
			for ($i = 0; $i < $this->graph_borderwidth; $i++) {
				imagerectangle($this->im,
				$i,
				$i,
				$this->graph_width - 1 - $i,
				$this->graph_height - 1 - $i,
				$this->im_graph_bordercolor);
			}
		}
	}

	function __DrawAxis() {
		$this->__AllocateColor("im_axis_bordercolor",
		$this->axis_bordercolor,
		$this->graph_transparencylevel);
		$this->__AllocateColor("im_axis_bgcolor",
		$this->axis_bgcolor,
		$this->graph_transparencylevel);
		$this->__AllocateColor("im_axis_scalecolor",
		$this->axis_scalecolor,
		$this->graph_transparencylevel);

		list($this->axis_minX,
		$this->axis_maxX,
		$this->axis_minY,
		$this->axis_maxY) = $this->__GetMinMaxGraphValue();

		if ($this->axis_gridlines) {
			$style = array($this->im_axis_bordercolor, $this->im_graph_bgcolor);
			imagesetstyle($this->im, $style);
		}

		if ($this->axis_modeX == 1) {
			$this->axis_stepX = ($this->axis_maxX - $this->axis_minX) / $this->axis_stepX;
		} elseif ($this->axis_modeX == 2) {
			$this->axis_stepX = $this->axis_stepX * ($this->axis_maxX - $this->axis_minX) / $this->graph_areawidth;
		}

		if ($this->axis_modeY == 1) {
			$this->axis_stepY = ($this->axis_maxY - $this->axis_minY) / $this->axis_stepY;
		} elseif ($this->axis_modeY == 2) {
			$this->axis_stepY = $this->axis_stepY * ($this->axis_maxY - $this->axis_minY) / $this->graph_areaheight;
			$rest = abs($this->axis_maxY) % $this->axis_stepY;
			// need to center a step on coord 0

		}

		if (!$this->axis_deepness) {
			$this->axis_frontgridlines = 1;
		}

		if (!$this->axis_xscalevisible) {
			$this->axis_positions[1] = 0;
			$this->axis_positions[3] = 0;
		}
		if (!$this->axis_yscalevisible) {
			$this->axis_positions[0] = 0;
			$this->axis_positions[2] = 0;
		}
		$this->__CorrectMinMax($this->axis_minX, $this->axis_maxX, $this->axis_stepX);
		$this->__CorrectMinMax($this->axis_minY, $this->axis_maxY, $this->axis_stepY);
		if ($this->axis_yscalevisible) {
			$this->__DrawHorizontalGridlines();
		}
		$this->__DrawHorizontalGideGridlines();
		if ($this->axis_xscalevisible) {
			$this->__DrawVerticalGridlines();
		}
		$this->__DrawVerticalGideGridlines();
	}

	function __Draw_LeftBottom_Axis() {
		$w = $this->graph_width;
		$h = $this->graph_height;
		$p = $this->graph_padding;
		if ($this->axis_positions[3]) {
			$this->__DrawAxisPart($p['left'], $h - $p['bottom'], $w - $p['right'], $h - $p['bottom'],
			$this->axis_minX, $this->axis_maxX, $this->axis_stepX,
			"right", "bottom");
		}
		if ($this->axis_positions[0]) {
			$this->__DrawAxisPart($p['left'], $p['top'], $p['left'], $h - $p['bottom'],
			$this->axis_minY, $this->axis_maxY, $this->axis_stepY,
			"up", "left");
		}
	}

	function __Draw_TopRight_Axis() {
		$w = $this->graph_width;
		$h = $this->graph_height;
		$p = $this->graph_padding;
		if ($this->axis_positions[1]) {
			$this->__DrawAxisPart($p['left'], $p['top'], $w - $p['right'], $p['top'],
			$this->axis_minX, $this->axis_maxX, $this->axis_stepX,
			"right", "top");
		}
		if ($this->axis_positions[2]) {
			$this->__DrawAxisPart($w - $p['right'], $p['top'], $w - $p['right'], $h - $p['bottom'],
			$this->axis_minY, $this->axis_maxY, $this->axis_stepY,
			"up", "right");
		}
	}

	function __CorrectMinMax(&$min, &$max, &$step) {
		if (($max % $step) != 0) $max += ($step - abs($max % $step));
		if (($min % $step) != 0) $min -= abs($min % $step);
	}

	function __DrawHorizontalGridlines() {
		$maxy = $this->graph_height - $this->graph_padding['bottom'];
		$miny = $this->graph_padding['top'];
		$maxx = $this->graph_width - $this->graph_padding['right'];
		$minx = $this->graph_padding['left'];
		$offset = ($maxy - $miny) / ($this->axis_maxY - $this->axis_minY) * $this->axis_stepY;
		$v = $miny + $offset;

		$deep = $this->axis_deepness;
		if (!$deep) $grid_offset = $this->axis_stepSize;
		else $grid_offset = 1;
		while ($v < $maxy) {
			imageline($this->im, $minx + $deep + (!$this->axis_positions[0] ? 0 : $grid_offset),
			floor($v) - $deep,
			$maxx + $deep - (!$this->axis_positions[2] ? 0 : $grid_offset),
			floor($v) - $deep, IMG_COLOR_STYLED);
			$v += $offset;
		}
	}

	function __DrawHorizontalGideGridlines() {
		$maxy = $this->graph_height - $this->graph_padding['bottom'];
		$miny = $this->graph_padding['top'];
		$maxx = $this->graph_width - $this->graph_padding['right'];
		$minx = $this->graph_padding['left'];

		$deep = $this->axis_deepness;
		if (!$deep) $grid_offset = $this->axis_stepSize;
		else $grid_offset = 1;

		if (!$this->axis_positions[1]) {
			if ($deep) {
				imageline($this->im, $minx + $deep + $grid_offset, $miny - $deep,
				$maxx + $deep + $grid_offset, $miny - $deep, IMG_COLOR_STYLED);
			}
			if ($this->axis_frontgridlines) {
				imageline($this->im, $minx, $miny, $maxx, $miny, IMG_COLOR_STYLED);
			}
		}
		if (!$this->axis_positions[3]) {
			if ($deep) {
				imageline($this->im, $minx + $deep + $grid_offset, $maxy - $deep,
				$maxx + $deep + $grid_offset, $maxy - $deep, IMG_COLOR_STYLED);
			}
			if ($this->axis_frontgridlines) {
				imageline($this->im, $minx, $maxy, $maxx, $maxy, IMG_COLOR_STYLED);
			}
		}
	}

	function __DrawVerticalGridlines() {
		$maxy = $this->graph_height - $this->graph_padding['bottom'];
		$miny = $this->graph_padding['top'];
		$maxx = $this->graph_width - $this->graph_padding['right'];
		$minx = $this->graph_padding['left'];
		$offset = ($maxx - $minx) / ($this->axis_maxX - $this->axis_minX) * $this->axis_stepX;
		$v = $minx + $offset;

		$deep = $this->axis_deepness;
		if (!$deep) $grid_offset = $this->axis_stepSize;
		else $grid_offset = 1;

		while ($v < $maxx) {
			imageline($this->im, floor($v) + $deep,
			$miny - $deep + (!$this->axis_positions[1] ? 0 : $grid_offset),
			floor($v) + $deep,
			$maxy - $deep - (!$this->axis_positions[3] ? 0 : $grid_offset),
			IMG_COLOR_STYLED);
			$v += $offset;
		}
	}

	function __DrawVerticalGideGridlines() {
		$maxy = $this->graph_height - $this->graph_padding['bottom'];
		$miny = $this->graph_padding['top'];
		$maxx = $this->graph_width - $this->graph_padding['right'];
		$minx = $this->graph_padding['left'];

		$deep = $this->axis_deepness;
		if (!$deep) $grid_offset = $this->axis_stepSize;
		else $grid_offset = 1;

		if (!$this->axis_positions[0]) {
			if ($deep) {
				imageline($this->im, $minx + $deep + $grid_offset, $miny - $deep,
				$minx + $deep + $grid_offset, $maxy - $deep, IMG_COLOR_STYLED);
			}
			if ($this->axis_frontgridlines) {
				imageline($this->im, $minx, $miny, $minx, $maxy, IMG_COLOR_STYLED);
			}
		}
		if (!$this->axis_positions[2]) {
			if ($deep) {
				imageline($this->im, $maxx + $deep + $grid_offset, $miny - $deep,
				$maxx + $deep + $grid_offset, $maxy - $deep, IMG_COLOR_STYLED);
			}
			if ($this->axis_frontgridlines) {
				imageline($this->im, $maxx, $miny, $maxx, $maxy, IMG_COLOR_STYLED);
			}
		}
	}

	function __DrawAxisPart($x1, $y1, $x2, $y2, $scale_start, $scale_end, $scale_step, $scale_direction, $scaletext_side) {
		$deep = $this->axis_deepness;
		if ($deep > 0) {
			$this->__DrawPolygon(array($x1, $y1, $x1 + $deep, $y1 - $deep, $x2 + $deep, $y2 - $deep, $x2, $y2), $this->im_axis_bgcolor, true);
			$this->__DrawPolygon(array($x1, $y1, $x1 + $deep, $y1 - $deep, $x2 + $deep, $y2 - $deep, $x2, $y2), $this->im_axis_bordercolor);
		} else {
			imageline($this->im, $x1, $y1, $x2, $y2, $this->im_axis_bordercolor);
		}

		// reverse order if needed
		if ($x1 == $x2) {
			if ($scale_direction == "up") {
				$scale_direction = "down";
				$v = $scale_start;
				$scale_start = $scale_end;
				$scale_end = $v;
				$scale_step = -$scale_step;
			} else $scale_direction = "down";
			if ($scaletext_side != "left") $scaletext_side = "right";
		} else {
			if ($scale_direction == "left") {
				$scale_direction = "right";
				$v = $scale_start;
				$scale_start = $scale_end;
				$scale_end = $v;
				$scale_step = -$scale_step;
			} else $scale_direction = "right";
			if ($scaletext_side != "top") $scaletext_side = "bottom";
		}

		$v = $scale_start;
		$total = $scale_end - $v;
		if ($x1 == $x2) {
			$totalarea = $this->graph_areaheight;
		} else {
			$totalarea = $this->graph_areawidth;
		}

		while (($v <= $scale_end && $scale_step > 0) || ($v >= $scale_end && $scale_step < 0)) {
			if ($x1 == $x2) {
				$offset = floor($y1 + (($v - $scale_start) * $totalarea / $total));
				if (strlen($this->scale_funY)) {
					$fun = str_replace("%d", $v, $this->scale_funY);
					eval("\$scale_value = " . $fun . ";");
				} else {
					$scale_value = $this->__RoundNumber($v, $this->scale_roundY);
				}
				// vertical axis scale text
				$this->__DrawText($scale_value, $x1 + ($scaletext_side == "left" ? -6 : 6 + $deep),
				$offset, $this->im_axis_scalecolor, $this->axis_scalefont,
				($scaletext_side == "left" ? 2 : 0), 1);
				if ($v != $scale_start && $v != $scale_end) {
					// vertical axis scale line
					imageline($this->im, $x1 + ($scaletext_side == "left" ? 1 : -1), $offset,
					$x1 + ($scaletext_side == "left" ? $this->axis_stepSize : -$this->axis_stepSize),
					$offset, $this->im_axis_bordercolor);
				}
			} else {
				$offset = floor($x1 + (($v - $scale_start) * $totalarea / $total));
				if (function_exists($this->scale_funX)) {
					$fun = $this->scale_funX;
					$scale_value = $fun($v);
				} else {
					$scale_value = $this->__RoundNumber($v, $this->scale_roundX);
				}
				// horizontal axis scale text
				$this->__DrawText($scale_value, $offset, $y1 + ($scaletext_side == "top" ? -6 - $deep : 6),
				$this->im_axis_scalecolor, $this->axis_scalefont, 1,
				($scaletext_side == "top" ? 2 : 0));
				if ($v != $scale_start && $v != $scale_end) {
					// horizontal axis scale line
					imageline($this->im, $offset, $y1 + ($scaletext_side == "top" ? 1 : -1),
					$offset,
					$y1 + ($scaletext_side == "top" ? $this->axis_stepSize : -$this->axis_stepSize),
					$this->im_axis_bordercolor);
				}
			}
			$v += $scale_step;
		}
	}

	function __DrawText($text, $x, $y, $color, $size = 1, $align = 0, $valign = 0) {
		/* Align: 0=left | 1=center | 2=right */
		if ($valign == 1) $y -= floor(imagefontheight($size) / 2);
		elseif ($valign == 2) $y -= imagefontheight($size);

		if(!is_numeric($text))	{
			$_SESSION['newY'] = $y+(strlen($text)*6);
			$font="./arial.ttf";
			imagettftext($this->im, $size+7, 90, $x, $_SESSION['newY']+8, $color,$font, $text);
  		} else {
		imagestring($this->im, $size, $x-(strlen($text)*6), $y, $text, $color);
  		}
	}

	function __GetMinMaxGraphValue() {
		$arrki = array_keys($this->data);
		if (is_array($this->data[$arrki[0]])) {
			for ($i = 0; $i < count($arrki); $i++) {
				$arrkj = array_keys($this->data[$arrki[$i]]);
				if ($i == 0) {
					$maxX = $minX = (int) $arrkj[0];
					$maxY = $minY = (int) $this->data[$arrki[0]][$arrkj[0]];
				}
				for ($j = 0; $j < count($arrkj); $j++) {
					if ($arrkj[$j] > $maxX) $maxX = $arrkj[$j];
					elseif ($arrkj[$j] < $minX) $minX = $arrkj[$j];
					if ($this->data[$arrki[$i]][$arrkj[$j]] > $maxY) $maxY = $this->data[$arrki[$i]][$arrkj[$j]];
					elseif ($this->data[$arrki[$i]][$arrkj[$j]] < $minY) $minY = $this->data[$arrki[$i]][$arrkj[$j]];
				}
			}
		} else {
			$maxX = $minX = (int) $arrki[0];
			$maxY = $minY = (int) $this->data[$arrki[0]];
			foreach ($this->data as $x => $y) {
				if ($x > $maxX) $maxX = $x;
				elseif ($x < $minX) $minX = $x;
				if ($y > $maxY) $maxY = $y;
				elseif ($y < $minY) $minY = $y;
			}
		}
		return array($minX, $maxX, $minY, $maxY);
	}

	function __DrawPolygon($points, $color, $filled = false) {
		if ($filled) {
			imagefilledpolygon($this->im, $points, 4, $color);
		} else {
			imagepolygon($this->im, $points, 4, $color);
		}
	}

	function __LoadGraphDefinitions($data) {
		foreach ($data as $key => $settings) {
			$func = "__Load" . ucfirst($key) . "Values";
			if (method_exists($this, $func)) {
				$this->$func($settings);
			}
		}
		if (is_array($data['data'])) {
			$this->data = $data['data'];
		}
	}

	function __LoadGraphValues($data) {
		foreach ($data as $name => $value) {
			$name = strtolower($name);
			switch ($name) {
				case 'background-color':
					$this->__SetColorToValue("graph_bgcolor", $value);
					break;
				case 'border-color':
					$this->__SetColorToValue("graph_bordercolor", $value);
					break;
				case 'title-color':
					$this->__SetColorToValue("graph_titlecolor", $value);
					break;
				case 'background-transparent':
					$this->graph_bgtransparent = ($value == 1 || $value == 'yes' ? 1 : 0);
					break;
				case 'transparency':
					$this->SetGraphTransparency(str_replace('%', '', $value));
					break;
				case 'title':
					$this->graph_title = $value;
					break;
				case 'title-font':
					$this->SetGraphTitleFont($value);
					break;
				case 'border-width':
					$this->graph_borderwidth = (int) $value;
					break;
				case 'area-height':
					$this->graph_areaheight = (int) $value;
					$this->graph_height = $this->graph_padding['top'] + (int)$value + $this->graph_padding['bottom'];
					break;
				case 'area-width':
					$this->graph_areawidth = (int) $value;
					$this->graph_width = $this->graph_padding['left'] + (int)$value + $this->graph_padding['right'];
					break;
				default:
					if (substr($name, 0, 8) == 'padding-' && strlen($name) > 8) {
						$this->graph_padding[substr($name, 8)] = $value;
					}
			}
		}
	}

	function __LoadAxisValues($data) {
		foreach ($data as $name => $value) {
			$name = strtolower($name);
			switch ($name) {
				case 'x-step':
					$this->SetAxisStepX($value);
					break;
				case 'y-step':
					$this->SetAxisStepY($value);
					break;
				case 'step-size':
					$this->axis_stepSize = (int) $value;
					break;
				case 'x-step-mode':
					$this->SetAxisModeX($value);
					break;
				case 'y-step-mode':
					$this->SetAxisModeY($value);
					break;
				case 'background-color':
				case 'border-color':
				case 'scale-color':
					$this->__SetColorToValue("axis_" . str_replace(array("ackground", "-"),
					array("g", ""),
					$name),
					$value);
					break;
				case 'scale-font':
					$this->SetAxisScaleFont($value);
					break;
				case 'show-xscale':
					$this->axis_xscalevisible = ($value == 1 || $value == 'yes' ? 1 : 0);
					break;
				case 'show-yscale':
					$this->axis_yscalevisible = ($value == 1 || $value == 'yes' ? 1 : 0);
					break;
				case 'gridlines':
					$this->axis_gridlines = ($value == 1 || $value == 'yes' ? 1 : 0);
					break;
				case 'position':
					$this->SetAxisPositions($value);
					break;
				case 'deepness':
					$this->axis_deepness = (int) $value;
					break;
			}
		}
	}

	function __LoadScaleValues($data) {
		foreach ($data as $name => $value) {
			$name = strtolower($name);
			switch ($name) {
				case 'x-round':
					$this->SetScaleRoundX($value);
					break;
				case 'y-round':
					$this->SetScaleRoundY($value);
					break;
				case 'x-fun':
					$this->SetScaleFunctionX($value);
					break;
				case 'y-fun':
					$this->SetScaleFunctionY($value);
					break;
			}
		}
	}

	function __LoadLegendValues($data) {
		foreach ($data as $name => $value) {
			$name = strtolower($name);
			switch ($name) {
				case 'background-color':
				case 'border-color':
				case 'color':
					$this->__SetColorToValue("legend_" . str_replace(array("ackground", "-"),
					array("g", ""),
					$name),
					$value);
					break;
				case 'visible':
					$this->SetLegendVisible($value);
					break;
				case 'floating':
					$this->SetLegendFloating($value);
					break;
				case 'position':
					$this->SetLegendPosition($value);
					break;
				case 'borderwidth':
					$this->SetLegendBorderWidth($value);
					break;
				case 'padding':
					$this->SetLegendPadding($value);
					break;
				case 'inside-padding':
					$this->SetLegendInsidePadding($value);
					break;
				case 'data':
					$this->SetLegendData($value);
					break;
			}
		}
	}

	function __SetColorToValue($varname, $color, $index = false) {
		if (is_array($color)) {
			for ($i = 0; $i < count($color); $i++) {
				$this->__SetColorToValue($varname, $color[$i], $i);
			}
		} else {
			if ($color[0] == "#") { // if it's hex (html format), change to rgb array
				if (strlen($color) == 4) {
					// if only 3 hex values (I assume it's a shade of grey: #ddd)
					$color .= substr($color, -3);
				}
				$color = array(hexdec($color[1].$color[2]),
				hexdec($color[3].$color[4]),
				hexdec($color[5].$color[6]));
			}
			if ($index !== false) $this->{$varname}[$index] = $color;
			else $this->$varname = $color;
		}
	}

	function __AllocateColor($varname, $color, $alpha, $index = false) {
		if ($index !== false) {
			$this->{$varname}[$index] = imagecolorallocatealpha($this->im, $color[0], $color[1], $color[2], $alpha);
		} else {
			$this->$varname = imagecolorallocatealpha($this->im, $color[0], $color[1], $color[2], $alpha);
		}
	}

	function __DrawLegend() {
		if (!$this->legend_visible) return;

		$this->legend_height = $this->legend_insidepadding + (count($this->legend_data) * (imagefontheight($this->legend_font) + $this->legend_insidepadding));

		switch ($this->legend_position) {
			case 1:
				$x = $this->legend_padding;
				$y = $this->graph_height - $this->legend_padding - $this->legend_height;
				break;
			case 2:
				$x = $y = $this->legend_padding;
				break;
			case 3:
				$x = $this->graph_width - $this->legend_padding - $this->legend_width;
				$y = $this->legend_padding;
				break;
			case 4:
				$x = $this->graph_width - $this->legend_padding - $this->legend_width;
				$y = $this->graph_height - $this->legend_padding - $this->legend_height;
				break;
		}
		if ($this->legend_floating) {
			$x = $x + ($this->legend_position < 3 ? $this->graph_padding['left'] : -$this->graph_padding['right']);
			$y = $y + ($this->legend_position == 2 || $this->legend_position == 3 ? $this->graph_padding['top'] : -$this->graph_padding['bottom']);
		}
		$this->__AllocateColor("im_legend_bordercolor",
		$this->legend_bordercolor,
		$this->graph_transparencylevel);
		$this->__AllocateColor("im_legend_bgcolor",
		$this->legend_bgcolor,
		$this->graph_transparencylevel);

		imagefilledrectangle($this->im, $x + 1, $y + 1, $x + $this->legend_width - 1, $y + $this->legend_height - 1, $this->im_legend_bgcolor);
		imagerectangle($this->im, $x, $y, $x + $this->legend_width, $y + $this->legend_height, $this->im_legend_bordercolor);
		for ($i = 0; $i < count($this->legend_data); $i++) {
			$this->__AllocateColor("im_legend_color", $this->legend_color[$i], $this->graph_transparencylevel, $i);
			$this->__DrawLegendItem($x, $y, $i, $this->legend_data[$i], $this->im_legend_color[$i]);
		}
	}

	function __DrawLegendItem($legendx, $legendy, $position, $text, $color) {
		$x = $legendx + $this->legend_insidepadding * 3;
		$y = $legendy + $this->legend_insidepadding + (($this->legend_insidepadding + imagefontheight($this->legend_font)) * $position);
		imagefilledrectangle($this->im, $legendx + $this->legend_insidepadding,
		$y + ((imagefontheight($this->legend_font) - $this->legend_insidepadding) / 2),
		$legendx + $this->legend_insidepadding * 2,
		$y + ((imagefontheight($this->legend_font) - $this->legend_insidepadding) / 2) + $this->legend_insidepadding,
		$color);
		$this->__DrawText($text, $x, $y, $color, $this->legend_font, 0, 0);
	}

	function __RoundNumber($n, $round = 1) {
		if (is_numeric($n)) {
			$weights = " KMG";
			$p = 0;
			while (abs($n) >= 1000) {
				$n = $n / 1000;
				$p++;
			}
			return number_format($n, $round) . trim($weights[$p]);
		} else return $n;
	}
}
?>
Return current item: DbGraph