Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/client/modules/Elezioni/grafici/jpgraph.php@ 250

Last change on this file since 250 was 2, checked in by root, 15 years ago
importo il progetto
File size: 162.2 KB

Line
1	<?php
2	//=======================================================================
3	// File: JPGRAPH.PHP
4	// Description: PHP Graph Plotting library. Base module.
5	// Created: 2001-01-08
6	// Ver: $Id: jpgraph.php 1091 2009-01-18 22:57:40Z ljp $
7	//
8	// Copyright (c) Aditus Consulting. All rights reserved.
9	//========================================================================
10
11	require_once('jpg-config.inc.php');
12	require_once('jpgraph_gradient.php');
13	require_once('jpgraph_errhandler.inc.php');
14	require_once('jpgraph_ttf.inc.php');
15	require_once('jpgraph_rgb.inc.php');
16	require_once('jpgraph_text.inc.php');
17	require_once('jpgraph_legend.inc.php');
18
19	// Version info
20	define('JPG_VERSION','2.3.5-dev');
21
22	// Minimum required PHP version
23	define('MIN_PHPVERSION','5.1.0');
24
25	// Should the image be a truecolor image?
26	define('USE_TRUECOLOR',true);
27
28	//------------------------------------------------------------------------
29	// Automatic settings of path for cache and font directory
30	// if they have not been previously specified
31	//------------------------------------------------------------------------
32	if(USE_CACHE) {
33	if (!defined('CACHE_DIR')) {
34	if ( strstr( PHP_OS, 'WIN') ) {
35	if( empty($_SERVER['TEMP']) ) {
36	$t = new ErrMsgText();
37	$msg = $t->Get(11,$file,$lineno);
38	die($msg);
39	}
40	else {
41	define('CACHE_DIR', $_SERVER['TEMP'] . '/');
42	}
43	} else {
44	define('CACHE_DIR','/tmp/jpgraph_cache/');
45	}
46	}
47	}
48	elseif( !defined('CACHE_DIR') ) {
49	define('CACHE_DIR', '');
50	}
51
52	if (!defined('TTF_DIR')) {
53	if (strstr( PHP_OS, 'WIN') ) {
54	$sroot = getenv('SystemRoot');
55	if( empty($sroot) ) {
56	$t = new ErrMsgText();
57	$msg = $t->Get(12,$file,$lineno);
58	die($msg);
59	}
60	else {
61	define('TTF_DIR', $sroot.'/fonts/');
62	}
63	} else {
64	define('TTF_DIR','/usr/share/fonts/truetype/');
65	}
66	}
67
68	if (!defined('MBTTF_DIR')) {
69	if (strstr( PHP_OS, 'WIN') ) {
70	$sroot = getenv('SystemRoot');
71	if( empty($sroot) ) {
72	$t = new ErrMsgText();
73	$msg = $t->Get(12,$file,$lineno);
74	die($msg);
75	}
76	else {
77	define('TTF_DIR', $sroot.'/fonts/');
78	}
79	} else {
80	define('MBTTF_DIR','/usr/share/fonts/ja/TrueType/');
81	}
82	}
83
84	//------------------------------------------------------------------
85	// Constants which are used as parameters for the method calls
86	//------------------------------------------------------------------
87
88
89	// Tick density
90	define("TICKD_DENSE",1);
91	define("TICKD_NORMAL",2);
92	define("TICKD_SPARSE",3);
93	define("TICKD_VERYSPARSE",4);
94
95	// Side for ticks and labels.
96	define("SIDE_LEFT",-1);
97	define("SIDE_RIGHT",1);
98	define("SIDE_DOWN",-1);
99	define("SIDE_BOTTOM",-1);
100	define("SIDE_UP",1);
101	define("SIDE_TOP",1);
102
103	// Legend type stacked vertical or horizontal
104	define("LEGEND_VERT",0);
105	define("LEGEND_HOR",1);
106
107	// Mark types for plot marks
108	define("MARK_SQUARE",1);
109	define("MARK_UTRIANGLE",2);
110	define("MARK_DTRIANGLE",3);
111	define("MARK_DIAMOND",4);
112	define("MARK_CIRCLE",5);
113	define("MARK_FILLEDCIRCLE",6);
114	define("MARK_CROSS",7);
115	define("MARK_STAR",8);
116	define("MARK_X",9);
117	define("MARK_LEFTTRIANGLE",10);
118	define("MARK_RIGHTTRIANGLE",11);
119	define("MARK_FLASH",12);
120	define("MARK_IMG",13);
121	define("MARK_FLAG1",14);
122	define("MARK_FLAG2",15);
123	define("MARK_FLAG3",16);
124	define("MARK_FLAG4",17);
125
126	// Builtin images
127	define("MARK_IMG_PUSHPIN",50);
128	define("MARK_IMG_SPUSHPIN",50);
129	define("MARK_IMG_LPUSHPIN",51);
130	define("MARK_IMG_DIAMOND",52);
131	define("MARK_IMG_SQUARE",53);
132	define("MARK_IMG_STAR",54);
133	define("MARK_IMG_BALL",55);
134	define("MARK_IMG_SBALL",55);
135	define("MARK_IMG_MBALL",56);
136	define("MARK_IMG_LBALL",57);
137	define("MARK_IMG_BEVEL",58);
138
139	// Inline defines
140	define("INLINE_YES",1);
141	define("INLINE_NO",0);
142
143	// Format for background images
144	define("BGIMG_FILLPLOT",1);
145	define("BGIMG_FILLFRAME",2);
146	define("BGIMG_COPY",3);
147	define("BGIMG_CENTER",4);
148	define("BGIMG_FREE",5);
149
150	// Depth of objects
151	define("DEPTH_BACK",0);
152	define("DEPTH_FRONT",1);
153
154	// Direction
155	define("VERTICAL",1);
156	define("HORIZONTAL",0);
157
158
159	// Axis styles for scientific style axis
160	define('AXSTYLE_SIMPLE',1);
161	define('AXSTYLE_BOXIN',2);
162	define('AXSTYLE_BOXOUT',3);
163	define('AXSTYLE_YBOXIN',4);
164	define('AXSTYLE_YBOXOUT',5);
165
166	// Style for title backgrounds
167	define('TITLEBKG_STYLE1',1);
168	define('TITLEBKG_STYLE2',2);
169	define('TITLEBKG_STYLE3',3);
170	define('TITLEBKG_FRAME_NONE',0);
171	define('TITLEBKG_FRAME_FULL',1);
172	define('TITLEBKG_FRAME_BOTTOM',2);
173	define('TITLEBKG_FRAME_BEVEL',3);
174	define('TITLEBKG_FILLSTYLE_HSTRIPED',1);
175	define('TITLEBKG_FILLSTYLE_VSTRIPED',2);
176	define('TITLEBKG_FILLSTYLE_SOLID',3);
177
178	// Style for background gradient fills
179	define('BGRAD_FRAME',1);
180	define('BGRAD_MARGIN',2);
181	define('BGRAD_PLOT',3);
182
183	// Width of tab titles
184	define('TABTITLE_WIDTHFIT',0);
185	define('TABTITLE_WIDTHFULL',-1);
186
187	// Defines for 3D skew directions
188	define('SKEW3D_UP',0);
189	define('SKEW3D_DOWN',1);
190	define('SKEW3D_LEFT',2);
191	define('SKEW3D_RIGHT',3);
192
193	// Line styles
194	define('LINESTYLE_SOLID',1);
195	define('LINESTYLE_DOTTED',2);
196	define('LINESTYLE_DASHED',3);
197	define('LINESTYLE_LONGDASH',4);
198
199	// For internal use only
200	define("_JPG_DEBUG",false);
201	define("_FORCE_IMGTOFILE",false);
202	define("_FORCE_IMGDIR",'/tmp/jpgimg/');
203
204	require_once('gd_image.inc.php');
205
206	function CheckPHPVersion($aMinVersion)
207	{
208	list($majorC, $minorC, $editC) = split('[/.-]', PHP_VERSION);
209	list($majorR, $minorR, $editR) = split('[/.-]', $aMinVersion);
210
211	if ($majorC != $majorR) return false;
212	if ($majorC < $majorR) return false;
213	// same major - check ninor
214	if ($minorC > $minorR) return true;
215	if ($minorC < $minorR) return false;
216	// and same minor
217	if ($editC >= $editR) return true;
218	return true;
219	}
220
221	//
222	// Make sure PHP version is high enough
223	//
224	if( !CheckPHPVersion(MIN_PHPVERSION) ) {
225	JpGraphError::RaiseL(13,PHP_VERSION,MIN_PHPVERSION);
226	die();
227	}
228
229
230	//
231	// Make GD sanity check
232	//
233	if( !function_exists("imagetypes") \|\| !function_exists('imagecreatefromstring') ) {
234	JpGraphError::RaiseL(25001);
235	//("This PHP installation is not configured with the GD library. Please recompile PHP with GD support to run JpGraph. (Neither function imagetypes() nor imagecreatefromstring() does exist)");
236	}
237
238	//
239	// Setup PHP error handler
240	//
241	function _phpErrorHandler($errno,$errmsg,$filename, $linenum, $vars) {
242	// Respect current error level
243	if( $errno & error_reporting() ) {
244	JpGraphError::RaiseL(25003,basename($filename),$linenum,$errmsg);
245	}
246	}
247
248	if( INSTALL_PHP_ERR_HANDLER ) {
249	set_error_handler("_phpErrorHandler");
250	}
251
252	//
253	//Check if there were any warnings, perhaps some wrong includes by the
254	//user
255	//
256	if( isset($GLOBALS['php_errormsg']) && CATCH_PHPERRMSG &&
257	!preg_match('/\|Deprecated\|/i', $GLOBALS['php_errormsg']) ) {
258	JpGraphError::RaiseL(25004,$GLOBALS['php_errormsg']);
259	}
260
261
262	// Useful mathematical function
263	function sign($a) {return $a >= 0 ? 1 : -1;}
264
265	// Utility function to generate an image name based on the filename we
266	// are running from and assuming we use auto detection of graphic format
267	// (top level), i.e it is safe to call this function
268	// from a script that uses JpGraph
269	function GenImgName() {
270	// Determine what format we should use when we save the images
271	$supported = imagetypes();
272	if( $supported & IMG_PNG ) $img_format="png";
273	elseif( $supported & IMG_GIF ) $img_format="gif";
274	elseif( $supported & IMG_JPG ) $img_format="jpeg";
275	elseif( $supported & IMG_WBMP ) $img_format="wbmp";
276	elseif( $supported & IMG_XPM ) $img_format="xpm";
277
278
279	if( !isset($_SERVER['PHP_SELF']) )
280	JpGraphError::RaiseL(25005);
281	//(" Can't access PHP_SELF, PHP global variable. You can't run PHP from command line if you want to use the 'auto' naming of cache or image files.");
282	$fname = basename($_SERVER['PHP_SELF']);
283	if( !empty($_SERVER['QUERY_STRING']) ) {
284	$q = @$_SERVER['QUERY_STRING'];
285	$fname .= '_'.preg_replace("/\W/", "_", $q).'.'.$img_format;
286	}
287	else {
288	$fname = substr($fname,0,strlen($fname)-4).'.'.$img_format;
289	}
290	return $fname;
291	}
292
293
294	//===================================================
295	// CLASS JpgTimer
296	// Description: General timing utility class to handle
297	// time measurement of generating graphs. Multiple
298	// timers can be started.
299	//===================================================
300	class JpgTimer {
301	private $start, $idx;
302	//---------------
303	// CONSTRUCTOR
304	function JpgTimer() {
305	$this->idx=0;
306	}
307
308	//---------------
309	// PUBLIC METHODS
310
311	// Push a new timer start on stack
312	function Push() {
313	list($ms,$s)=explode(" ",microtime());
314	$this->start[$this->idx++]=floor($ms1000) + 1000$s;
315	}
316
317	// Pop the latest timer start and return the diff with the
318	// current time
319	function Pop() {
320	assert($this->idx>0);
321	list($ms,$s)=explode(" ",microtime());
322	$etime=floor($ms1000) + (1000$s);
323	$this->idx--;
324	return $etime-$this->start[$this->idx];
325	}
326	} // Class
327
328	$gJpgBrandTiming = BRAND_TIMING;
329	//===================================================
330	// CLASS DateLocale
331	// Description: Hold localized text used in dates
332	//===================================================
333	class DateLocale {
334
335	public $iLocale = 'C'; // environmental locale be used by default
336	private $iDayAbb = null, $iShortDay = null, $iShortMonth = null, $iMonthName = null;
337
338	//---------------
339	// CONSTRUCTOR
340	function DateLocale() {
341	settype($this->iDayAbb, 'array');
342	settype($this->iShortDay, 'array');
343	settype($this->iShortMonth, 'array');
344	settype($this->iMonthName, 'array');
345
346
347	$this->Set('C');
348	}
349
350	//---------------
351	// PUBLIC METHODS
352	function Set($aLocale) {
353	if ( in_array($aLocale, array_keys($this->iDayAbb)) ){
354	$this->iLocale = $aLocale;
355	return TRUE; // already cached nothing else to do!
356	}
357
358	$pLocale = setlocale(LC_TIME, 0); // get current locale for LC_TIME
359
360	if (is_array($aLocale)) {
361	foreach ($aLocale as $loc) {
362	$res = @setlocale(LC_TIME, $loc);
363	if ( $res ) {
364	$aLocale = $loc;
365	break;
366	}
367	}
368	}
369	else {
370	$res = @setlocale(LC_TIME, $aLocale);
371	}
372
373	if ( ! $res ){
374	JpGraphError::RaiseL(25007,$aLocale);
375	//("You are trying to use the locale ($aLocale) which your PHP installation does not support. Hint: Use '' to indicate the default locale for this geographic region.");
376	return FALSE;
377	}
378
379	$this->iLocale = $aLocale;
380	for ( $i = 0, $ofs = 0 - strftime('%w'); $i < 7; $i++, $ofs++ ){
381	$day = strftime('%a', strtotime("$ofs day"));
382	$day[0] = strtoupper($day[0]);
383	$this->iDayAbb[$aLocale][]= $day[0];
384	$this->iShortDay[$aLocale][]= $day;
385	}
386
387	for($i=1; $i<=12; ++$i) {
388	list($short ,$full) = explode('\|', strftime("%b\|%B",strtotime("2001-$i-01")));
389	$this->iShortMonth[$aLocale][] = ucfirst($short);
390	$this->iMonthName [$aLocale][] = ucfirst($full);
391	}
392
393	setlocale(LC_TIME, $pLocale);
394
395	return TRUE;
396	}
397
398
399	function GetDayAbb() {
400	return $this->iDayAbb[$this->iLocale];
401	}
402
403	function GetShortDay() {
404	return $this->iShortDay[$this->iLocale];
405	}
406
407	function GetShortMonth() {
408	return $this->iShortMonth[$this->iLocale];
409	}
410
411	function GetShortMonthName($aNbr) {
412	return $this->iShortMonth[$this->iLocale][$aNbr];
413	}
414
415	function GetLongMonthName($aNbr) {
416	return $this->iMonthName[$this->iLocale][$aNbr];
417	}
418
419	function GetMonth() {
420	return $this->iMonthName[$this->iLocale];
421	}
422	}
423
424	$gDateLocale = new DateLocale();
425	$gJpgDateLocale = new DateLocale();
426
427	//=======================================================
428	// CLASS Footer
429	// Description: Encapsulates the footer line in the Graph
430	//=======================================================
431	class Footer {
432	public $iLeftMargin = 3, $iRightMargin = 3, $iBottomMargin = 3 ;
433	public $left,$center,$right;
434
435	function Footer() {
436	$this->left = new Text();
437	$this->left->ParagraphAlign('left');
438	$this->center = new Text();
439	$this->center->ParagraphAlign('center');
440	$this->right = new Text();
441	$this->right->ParagraphAlign('right');
442	}
443
444	function SetMargin($aLeft=3,$aRight=3,$aBottom=3) {
445	$this->iLeftMargin = $aLeft;
446	$this->iRightMargin = $aRight;
447	$this->iBottomMargin = $aBottom;
448	}
449
450	function Stroke($aImg) {
451	$y = $aImg->height - $this->iBottomMargin;
452	$x = $this->iLeftMargin;
453	$this->left->Align('left','bottom');
454	$this->left->Stroke($aImg,$x,$y);
455
456	$x = ($aImg->width - $this->iLeftMargin - $this->iRightMargin)/2;
457	$this->center->Align('center','bottom');
458	$this->center->Stroke($aImg,$x,$y);
459
460	$x = $aImg->width - $this->iRightMargin;
461	$this->right->Align('right','bottom');
462	$this->right->Stroke($aImg,$x,$y);
463	}
464	}
465
466
467	//===================================================
468	// CLASS Graph
469	// Description: Main class to handle graphs
470	//===================================================
471	class Graph {
472	public $cache=null; // Cache object (singleton)
473	public $img=null; // Img object (singleton)
474	public $plots=array(); // Array of all plot object in the graph (for Y 1 axis)
475	public $y2plots=array(); // Array of all plot object in the graph (for Y 2 axis)
476	public $ynplots=array();
477	public $xscale=null; // X Scale object (could be instance of LinearScale or LogScale
478	public $yscale=null,$y2scale=null, $ynscale=array();
479	public $iIcons = array(); // Array of Icons to add to
480	public $cache_name; // File name to be used for the current graph in the cache directory
481	public $xgrid=null; // X Grid object (linear or logarithmic)
482	public $ygrid=null,$y2grid=null; //dito for Y
483	public $doframe=true,$frame_color=array(0,0,0), $frame_weight=1; // Frame around graph
484	public $boxed=false, $box_color=array(0,0,0), $box_weight=1; // Box around plot area
485	public $doshadow=false,$shadow_width=4,$shadow_color=array(102,102,102); // Shadow for graph
486	public $xaxis=null; // X-axis (instane of Axis class)
487	public $yaxis=null, $y2axis=null, $ynaxis=array(); // Y axis (instance of Axis class)
488	public $margin_color=array(200,200,200); // Margin color of graph
489	public $plotarea_color=array(255,255,255); // Plot area color
490	public $title,$subtitle,$subsubtitle; // Title and subtitle(s) text object
491	public $axtype="linlin"; // Type of axis
492	public $xtick_factor,$ytick_factor; // Factor to determine the maximum number of ticks depending on the plot width
493	public $texts=null, $y2texts=null; // Text object to ge shown in the graph
494	public $lines=null, $y2lines=null;
495	public $bands=null, $y2bands=null;
496	public $text_scale_off=0, $text_scale_abscenteroff=-1; // Text scale in fractions and for centering bars
497	public $background_image="",$background_image_type=-1,$background_image_format="png";
498	public $background_image_bright=0,$background_image_contr=0,$background_image_sat=0;
499	public $background_image_xpos=0,$background_image_ypos=0;
500	public $image_bright=0, $image_contr=0, $image_sat=0;
501	public $inline;
502	public $showcsim=0,$csimcolor="red";//debug stuff, draw the csim boundaris on the image if <>0
503	public $grid_depth=DEPTH_BACK; // Draw grid under all plots as default
504	public $iAxisStyle = AXSTYLE_SIMPLE;
505	public $iCSIMdisplay=false,$iHasStroked = false;
506	public $footer;
507	public $csimcachename = '', $csimcachetimeout = 0, $iCSIMImgAlt='';
508	public $iDoClipping = false;
509	public $y2orderback=true;
510	public $tabtitle;
511	public $bkg_gradtype=-1,$bkg_gradstyle=BGRAD_MARGIN;
512	public $bkg_gradfrom='navy', $bkg_gradto='silver';
513	public $titlebackground = false;
514	public $titlebackground_color = 'lightblue',
515	$titlebackground_style = 1,
516	$titlebackground_framecolor = 'blue',
517	$titlebackground_framestyle = 2,
518	$titlebackground_frameweight = 1,
519	$titlebackground_bevelheight = 3 ;
520	public $titlebkg_fillstyle=TITLEBKG_FILLSTYLE_SOLID;
521	public $titlebkg_scolor1='black',$titlebkg_scolor2='white';
522	public $framebevel = false, $framebeveldepth = 2 ;
523	public $framebevelborder = false, $framebevelbordercolor='black';
524	public $framebevelcolor1='white@0.4', $framebevelcolor2='black@0.4';
525	public $background_image_mix=100;
526	public $background_cflag = '';
527	public $background_cflag_type = BGIMG_FILLPLOT;
528	public $background_cflag_mix = 100;
529	public $iImgTrans=false,
530	$iImgTransHorizon = 100,$iImgTransSkewDist=150,
531	$iImgTransDirection = 1, $iImgTransMinSize = true,
532	$iImgTransFillColor='white',$iImgTransHighQ=false,
533	$iImgTransBorder=false,$iImgTransHorizonPos=0.5;
534	public $legend;
535	protected $iYAxisDeltaPos=50;
536	protected $iIconDepth=DEPTH_BACK;
537	protected $iAxisLblBgType = 0,
538	$iXAxisLblBgFillColor = 'lightgray', $iXAxisLblBgColor = 'black',
539	$iYAxisLblBgFillColor = 'lightgray', $iYAxisLblBgColor = 'black';
540	protected $iTables=NULL;
541
542	//---------------
543	// CONSTRUCTOR
544
545	// aWIdth Width in pixels of image
546	// aHeight Height in pixels of image
547	// aCachedName Name for image file in cache directory
548	// aTimeOut Timeout in minutes for image in cache
549	// aInline If true the image is streamed back in the call to Stroke()
550	// If false the image is just created in the cache
551	function Graph($aWidth=300,$aHeight=200,$aCachedName="",$aTimeOut=0,$aInline=true) {
552	GLOBAL $gJpgBrandTiming;
553	// If timing is used create a new timing object
554	if( $gJpgBrandTiming ) {
555	global $tim;
556	$tim = new JpgTimer();
557	$tim->Push();
558	}
559
560	if( !is_numeric($aWidth) \|\| !is_numeric($aHeight) ) {
561	JpGraphError::RaiseL(25008);//('Image width/height argument in Graph::Graph() must be numeric');
562	}
563
564	// Automatically generate the image file name based on the name of the script that
565	// generates the graph
566	if( $aCachedName=="auto" )
567	$aCachedName=GenImgName();
568
569	// Should the image be streamed back to the browser or only to the cache?
570	$this->inline=$aInline;
571
572	$this->img = new RotImage($aWidth,$aHeight);
573
574	$this->cache = new ImgStreamCache($this->img);
575	$this->cache->SetTimeOut($aTimeOut);
576
577	$this->title = new Text();
578	$this->title->ParagraphAlign('center');
579	$this->title->SetFont(FF_FONT2,FS_BOLD);
580	$this->title->SetMargin(3);
581	$this->title->SetAlign('center');
582
583	$this->subtitle = new Text();
584	$this->subtitle->ParagraphAlign('center');
585	$this->subtitle->SetMargin(2);
586	$this->subtitle->SetAlign('center');
587
588	$this->subsubtitle = new Text();
589	$this->subsubtitle->ParagraphAlign('center');
590	$this->subsubtitle->SetMargin(2);
591	$this->subsubtitle->SetAlign('center');
592
593	$this->legend = new Legend();
594	$this->footer = new Footer();
595
596	// Window doesn't like '?' in the file name so replace it with an '_'
597	$aCachedName = str_replace("?","_",$aCachedName);
598
599	// If the cached version exist just read it directly from the
600	// cache, stream it back to browser and exit
601	if( $aCachedName!="" && READ_CACHE && $aInline )
602	if( $this->cache->GetAndStream($aCachedName) ) {
603	exit();
604	}
605
606	$this->cache_name = $aCachedName;
607	$this->SetTickDensity(); // Normal density
608
609	$this->tabtitle = new GraphTabTitle();
610	}
611	//---------------
612	// PUBLIC METHODS
613
614	// Enable final image perspective transformation
615	function Set3DPerspective($aDir=1,$aHorizon=100,$aSkewDist=120,$aQuality=false,$aFillColor='#FFFFFF',$aBorder=false,$aMinSize=true,$aHorizonPos=0.5) {
616	$this->iImgTrans = true;
617	$this->iImgTransHorizon = $aHorizon;
618	$this->iImgTransSkewDist= $aSkewDist;
619	$this->iImgTransDirection = $aDir;
620	$this->iImgTransMinSize = $aMinSize;
621	$this->iImgTransFillColor=$aFillColor;
622	$this->iImgTransHighQ=$aQuality;
623	$this->iImgTransBorder=$aBorder;
624	$this->iImgTransHorizonPos=$aHorizonPos;
625	}
626
627	function SetUserFont($aNormal,$aBold='',$aItalic='',$aBoldIt='') {
628	$this->img->ttf->SetUserFont($aNormal,$aBold,$aItalic,$aBoldIt);
629	}
630
631	function SetUserFont1($aNormal,$aBold='',$aItalic='',$aBoldIt='') {
632	$this->img->ttf->SetUserFont1($aNormal,$aBold,$aItalic,$aBoldIt);
633	}
634
635	function SetUserFont2($aNormal,$aBold='',$aItalic='',$aBoldIt='') {
636	$this->img->ttf->SetUserFont2($aNormal,$aBold,$aItalic,$aBoldIt);
637	}
638
639	function SetUserFont3($aNormal,$aBold='',$aItalic='',$aBoldIt='') {
640	$this->img->ttf->SetUserFont3($aNormal,$aBold,$aItalic,$aBoldIt);
641	}
642
643	// Set Image format and optional quality
644	function SetImgFormat($aFormat,$aQuality=75) {
645	$this->img->SetImgFormat($aFormat,$aQuality);
646	}
647
648	// Should the grid be in front or back of the plot?
649	function SetGridDepth($aDepth) {
650	$this->grid_depth=$aDepth;
651	}
652
653	function SetIconDepth($aDepth) {
654	$this->iIconDepth=$aDepth;
655	}
656
657	// Specify graph angle 0-360 degrees.
658	function SetAngle($aAngle) {
659	$this->img->SetAngle($aAngle);
660	}
661
662	function SetAlphaBlending($aFlg=true) {
663	$this->img->SetAlphaBlending($aFlg);
664	}
665
666	// Shortcut to image margin
667	function SetMargin($lm,$rm,$tm,$bm) {
668	$this->img->SetMargin($lm,$rm,$tm,$bm);
669	}
670
671	function SetY2OrderBack($aBack=true) {
672	$this->y2orderback = $aBack;
673	}
674
675	// Rotate the graph 90 degrees and set the margin
676	// when we have done a 90 degree rotation
677	function Set90AndMargin($lm=0,$rm=0,$tm=0,$bm=0) {
678	$lm = $lm ==0 ? floor(0.2 * $this->img->width) : $lm ;
679	$rm = $rm ==0 ? floor(0.1 * $this->img->width) : $rm ;
680	$tm = $tm ==0 ? floor(0.2 * $this->img->height) : $tm ;
681	$bm = $bm ==0 ? floor(0.1 * $this->img->height) : $bm ;
682
683	$adj = ($this->img->height - $this->img->width)/2;
684	$this->img->SetMargin($tm-$adj,$bm-$adj,$rm+$adj,$lm+$adj);
685	$this->img->SetCenter(floor($this->img->width/2),floor($this->img->height/2));
686	$this->SetAngle(90);
687	if( empty($this->yaxis) \|\| empty($this->xaxis) ) {
688	JpgraphError::RaiseL(25009);//('You must specify what scale to use with a call to Graph::SetScale()');
689	}
690	$this->xaxis->SetLabelAlign('right','center');
691	$this->yaxis->SetLabelAlign('center','bottom');
692	}
693
694	function SetClipping($aFlg=true) {
695	$this->iDoClipping = $aFlg ;
696	}
697
698	// Add a plot object to the graph
699	function Add($aPlot) {
700	if( $aPlot == null )
701	JpGraphError::RaiseL(25010);//("Graph::Add() You tried to add a null plot to the graph.");
702	if( is_array($aPlot) && count($aPlot) > 0 )
703	$cl = $aPlot[0];
704	else
705	$cl = $aPlot;
706
707	if( $cl instanceof Text )
708	$this->AddText($aPlot);
709	elseif( $cl instanceof PlotLine )
710	$this->AddLine($aPlot);
711	elseif( class_exists('PlotBand',false) && ($cl instanceof PlotBand) )
712	$this->AddBand($aPlot);
713	elseif( class_exists('IconPlot',false) && ($cl instanceof IconPlot) )
714	$this->AddIcon($aPlot);
715	elseif( class_exists('GTextTable',false) && ($cl instanceof GTextTable) )
716	$this->AddTable($aPlot);
717	else
718	$this->plots[] = $aPlot;
719	}
720
721	function AddTable($aTable) {
722	if( is_array($aTable) ) {
723	for($i=0; $i < count($aTable); ++$i )
724	$this->iTables[]=$aTable[$i];
725	}
726	else {
727	$this->iTables[] = $aTable ;
728	}
729	}
730
731	function AddIcon($aIcon) {
732	if( is_array($aIcon) ) {
733	for($i=0; $i < count($aIcon); ++$i )
734	$this->iIcons[]=$aIcon[$i];
735	}
736	else {
737	$this->iIcons[] = $aIcon ;
738	}
739	}
740
741	// Add plot to second Y-scale
742	function AddY2($aPlot) {
743	if( $aPlot == null )
744	JpGraphError::RaiseL(25011);//("Graph::AddY2() You tried to add a null plot to the graph.");
745
746	if( is_array($aPlot) && count($aPlot) > 0 )
747	$cl = $aPlot[0];
748	else
749	$cl = $aPlot;
750
751	if( $cl instanceof Text )
752	$this->AddText($aPlot,true);
753	elseif( $cl instanceof PlotLine )
754	$this->AddLine($aPlot,true);
755	elseif( class_exists('PlotBand',false) && ($cl instanceof PlotBand) )
756	$this->AddBand($aPlot,true);
757	else
758	$this->y2plots[] = $aPlot;
759	}
760
761	// Add plot to the extra Y-axises
762	function AddY($aN,$aPlot) {
763
764	if( $aPlot == null )
765	JpGraphError::RaiseL(25012);//("Graph::AddYN() You tried to add a null plot to the graph.");
766
767	if( is_array($aPlot) && count($aPlot) > 0 )
768	$cl = $aPlot[0];
769	else
770	$cl = $aPlot;
771
772	if( ($cl instanceof Text) \|\| ($cl instanceof PlotLine) \|\|
773	(class_exists('PlotBand',false) && ($cl instanceof PlotBand)) )
774	JpGraph::RaiseL(25013);//('You can only add standard plots to multiple Y-axis');
775	else
776	$this->ynplots[$aN][] = $aPlot;
777	}
778
779	// Add text object to the graph
780	function AddText($aTxt,$aToY2=false) {
781	if( $aTxt == null )
782	JpGraphError::RaiseL(25014);//("Graph::AddText() You tried to add a null text to the graph.");
783	if( $aToY2 ) {
784	if( is_array($aTxt) ) {
785	for($i=0; $i < count($aTxt); ++$i )
786	$this->y2texts[]=$aTxt[$i];
787	}
788	else
789	$this->y2texts[] = $aTxt;
790	}
791	else {
792	if( is_array($aTxt) ) {
793	for($i=0; $i < count($aTxt); ++$i )
794	$this->texts[]=$aTxt[$i];
795	}
796	else
797	$this->texts[] = $aTxt;
798	}
799	}
800
801	// Add a line object (class PlotLine) to the graph
802	function AddLine($aLine,$aToY2=false) {
803	if( $aLine == null )
804	JpGraphError::RaiseL(25015);//("Graph::AddLine() You tried to add a null line to the graph.");
805
806	if( $aToY2 ) {
807	if( is_array($aLine) ) {
808	for($i=0; $i < count($aLine); ++$i )
809	$this->y2lines[]=$aLine[$i];
810	}
811	else
812	$this->y2lines[] = $aLine;
813	}
814	else {
815	if( is_array($aLine) ) {
816	for($i=0; $i<count($aLine); ++$i )
817	$this->lines[]=$aLine[$i];
818	}
819	else
820	$this->lines[] = $aLine;
821	}
822	}
823
824	// Add vertical or horizontal band
825	function AddBand($aBand,$aToY2=false) {
826	if( $aBand == null )
827	JpGraphError::RaiseL(25016);//(" Graph::AddBand() You tried to add a null band to the graph.");
828
829	if( $aToY2 ) {
830	if( is_array($aBand) ) {
831	for($i=0; $i < count($aBand); ++$i )
832	$this->y2bands[] = $aBand[$i];
833	}
834	else
835	$this->y2bands[] = $aBand;
836	}
837	else {
838	if( is_array($aBand) ) {
839	for($i=0; $i < count($aBand); ++$i )
840	$this->bands[] = $aBand[$i];
841	}
842	else
843	$this->bands[] = $aBand;
844	}
845	}
846
847	function SetBackgroundGradient($aFrom='navy',$aTo='silver',$aGradType=2,$aStyle=BGRAD_FRAME) {
848	$this->bkg_gradtype=$aGradType;
849	$this->bkg_gradstyle=$aStyle;
850	$this->bkg_gradfrom = $aFrom;
851	$this->bkg_gradto = $aTo;
852	}
853
854	// Set a country flag in the background
855	function SetBackgroundCFlag($aName,$aBgType=BGIMG_FILLPLOT,$aMix=100) {
856	$this->background_cflag = $aName;
857	$this->background_cflag_type = $aBgType;
858	$this->background_cflag_mix = $aMix;
859	}
860
861	// Alias for the above method
862	function SetBackgroundCountryFlag($aName,$aBgType=BGIMG_FILLPLOT,$aMix=100) {
863	$this->background_cflag = $aName;
864	$this->background_cflag_type = $aBgType;
865	$this->background_cflag_mix = $aMix;
866	}
867
868
869	// Specify a background image
870	function SetBackgroundImage($aFileName,$aBgType=BGIMG_FILLPLOT,$aImgFormat="auto") {
871
872	if( !USE_TRUECOLOR ) {
873	JpGraphError::RaiseL(25017);//("You are using GD 2.x and are trying to use a background images on a non truecolor image. To use background images with GD 2.x you <b>must</b> enable truecolor by setting the USE_TRUECOLOR constant to TRUE. Due to a bug in GD 2.0.1 using any truetype fonts with truecolor images will result in very poor quality fonts.");
874	}
875
876	// Get extension to determine image type
877	if( $aImgFormat == "auto" ) {
878	$e = explode('.',$aFileName);
879	if( !$e ) {
880	JpGraphError::RaiseL(25018,$aFileName);//('Incorrect file name for Graph::SetBackgroundImage() : '.$aFileName.' Must have a valid image extension (jpg,gif,png) when using autodetection of image type');
881	}
882
883	$valid_formats = array('png', 'jpg', 'gif');
884	$aImgFormat = strtolower($e[count($e)-1]);
885	if ($aImgFormat == 'jpeg') {
886	$aImgFormat = 'jpg';
887	}
888	elseif (!in_array($aImgFormat, $valid_formats) ) {
889	JpGraphError::RaiseL(25019,$aImgFormat);//('Unknown file extension ($aImgFormat) in Graph::SetBackgroundImage() for filename: '.$aFileName);
890	}
891	}
892
893	$this->background_image = $aFileName;
894	$this->background_image_type=$aBgType;
895	$this->background_image_format=$aImgFormat;
896	}
897
898	function SetBackgroundImageMix($aMix) {
899	$this->background_image_mix = $aMix ;
900	}
901
902	// Adjust background image position
903	function SetBackgroundImagePos($aXpos,$aYpos) {
904	$this->background_image_xpos = $aXpos ;
905	$this->background_image_ypos = $aYpos ;
906	}
907
908	// Specify axis style (boxed or single)
909	function SetAxisStyle($aStyle) {
910	$this->iAxisStyle = $aStyle ;
911	}
912
913	// Set a frame around the plot area
914	function SetBox($aDrawPlotFrame=true,$aPlotFrameColor=array(0,0,0),$aPlotFrameWeight=1) {
915	$this->boxed = $aDrawPlotFrame;
916	$this->box_weight = $aPlotFrameWeight;
917	$this->box_color = $aPlotFrameColor;
918	}
919
920	// Specify color for the plotarea (not the margins)
921	function SetColor($aColor) {
922	$this->plotarea_color=$aColor;
923	}
924
925	// Specify color for the margins (all areas outside the plotarea)
926	function SetMarginColor($aColor) {
927	$this->margin_color=$aColor;
928	}
929
930	// Set a frame around the entire image
931	function SetFrame($aDrawImgFrame=true,$aImgFrameColor=array(0,0,0),$aImgFrameWeight=1) {
932	$this->doframe = $aDrawImgFrame;
933	$this->frame_color = $aImgFrameColor;
934	$this->frame_weight = $aImgFrameWeight;
935	}
936
937	function SetFrameBevel($aDepth=3,$aBorder=false,$aBorderColor='black',$aColor1='white@0.4',$aColor2='darkgray@0.4',$aFlg=true) {
938	$this->framebevel = $aFlg ;
939	$this->framebeveldepth = $aDepth ;
940	$this->framebevelborder = $aBorder ;
941	$this->framebevelbordercolor = $aBorderColor ;
942	$this->framebevelcolor1 = $aColor1 ;
943	$this->framebevelcolor2 = $aColor2 ;
944
945	$this->doshadow = false ;
946	}
947
948	// Set the shadow around the whole image
949	function SetShadow($aShowShadow=true,$aShadowWidth=5,$aShadowColor=array(102,102,102)) {
950	$this->doshadow = $aShowShadow;
951	$this->shadow_color = $aShadowColor;
952	$this->shadow_width = $aShadowWidth;
953	$this->footer->iBottomMargin += $aShadowWidth;
954	$this->footer->iRightMargin += $aShadowWidth;
955	}
956
957	// Specify x,y scale. Note that if you manually specify the scale
958	// you must also specify the tick distance with a call to Ticks::Set()
959	function SetScale($aAxisType,$aYMin=1,$aYMax=1,$aXMin=1,$aXMax=1) {
960	$this->axtype = $aAxisType;
961
962	if( $aYMax < $aYMin \|\| $aXMax < $aXMin )
963	JpGraphError::RaiseL(25020);//('Graph::SetScale(): Specified Max value must be larger than the specified Min value.');
964
965	$yt=substr($aAxisType,-3,3);
966	if( $yt=="lin" )
967	$this->yscale = new LinearScale($aYMin,$aYMax);
968	elseif( $yt == "int" ) {
969	$this->yscale = new LinearScale($aYMin,$aYMax);
970	$this->yscale->SetIntScale();
971	}
972	elseif( $yt=="log" )
973	$this->yscale = new LogScale($aYMin,$aYMax);
974	else
975	JpGraphError::RaiseL(25021,$aAxisType);//("Unknown scale specification for Y-scale. ($aAxisType)");
976
977	$xt=substr($aAxisType,0,3);
978	if( $xt == "lin" \|\| $xt == "tex" ) {
979	$this->xscale = new LinearScale($aXMin,$aXMax,"x");
980	$this->xscale->textscale = ($xt == "tex");
981	}
982	elseif( $xt == "int" ) {
983	$this->xscale = new LinearScale($aXMin,$aXMax,"x");
984	$this->xscale->SetIntScale();
985	}
986	elseif( $xt == "dat" ) {
987	$this->xscale = new DateScale($aXMin,$aXMax,"x");
988	}
989	elseif( $xt == "log" )
990	$this->xscale = new LogScale($aXMin,$aXMax,"x");
991	else
992	JpGraphError::RaiseL(25022,$aAxisType);//(" Unknown scale specification for X-scale. ($aAxisType)");
993
994	$this->xaxis = new Axis($this->img,$this->xscale);
995	$this->yaxis = new Axis($this->img,$this->yscale);
996	$this->xgrid = new Grid($this->xaxis);
997	$this->ygrid = new Grid($this->yaxis);
998	$this->ygrid->Show();
999	}
1000
1001	// Specify secondary Y scale
1002	function SetY2Scale($aAxisType="lin",$aY2Min=1,$aY2Max=1) {
1003	if( $aAxisType=="lin" )
1004	$this->y2scale = new LinearScale($aY2Min,$aY2Max);
1005	elseif( $aAxisType == "int" ) {
1006	$this->y2scale = new LinearScale($aY2Min,$aY2Max);
1007	$this->y2scale->SetIntScale();
1008	}
1009	elseif( $aAxisType=="log" ) {
1010	$this->y2scale = new LogScale($aY2Min,$aY2Max);
1011	}
1012	else JpGraphError::RaiseL(25023,$aAxisType);//("JpGraph: Unsupported Y2 axis type: $aAxisType\nMust be one of (lin,log,int)");
1013
1014	$this->y2axis = new Axis($this->img,$this->y2scale);
1015	$this->y2axis->scale->ticks->SetDirection(SIDE_LEFT);
1016	$this->y2axis->SetLabelSide(SIDE_RIGHT);
1017	$this->y2axis->SetPos('max');
1018	$this->y2axis->SetTitleSide(SIDE_RIGHT);
1019
1020	// Deafult position is the max x-value
1021	$this->y2grid = new Grid($this->y2axis);
1022	}
1023
1024	// Set the delta position (in pixels) between the multiple Y-axis
1025	function SetYDeltaDist($aDist) {
1026	$this->iYAxisDeltaPos = $aDist;
1027	}
1028
1029	// Specify secondary Y scale
1030	function SetYScale($aN,$aAxisType="lin",$aYMin=1,$aYMax=1) {
1031
1032	if( $aAxisType=="lin" )
1033	$this->ynscale[$aN] = new LinearScale($aYMin,$aYMax);
1034	elseif( $aAxisType == "int" ) {
1035	$this->ynscale[$aN] = new LinearScale($aYMin,$aYMax);
1036	$this->ynscale[$aN]->SetIntScale();
1037	}
1038	elseif( $aAxisType=="log" ) {
1039	$this->ynscale[$aN] = new LogScale($aYMin,$aYMax);
1040	}
1041	else JpGraphError::RaiseL(25024,$aAxisType);//("JpGraph: Unsupported Y axis type: $aAxisType\nMust be one of (lin,log,int)");
1042
1043	$this->ynaxis[$aN] = new Axis($this->img,$this->ynscale[$aN]);
1044	$this->ynaxis[$aN]->scale->ticks->SetDirection(SIDE_LEFT);
1045	$this->ynaxis[$aN]->SetLabelSide(SIDE_RIGHT);
1046	}
1047
1048	// Specify density of ticks when autoscaling 'normal', 'dense', 'sparse', 'verysparse'
1049	// The dividing factor have been determined heuristically according to my aesthetic
1050	// sense (or lack off) y.m.m.v !
1051	function SetTickDensity($aYDensity=TICKD_NORMAL,$aXDensity=TICKD_NORMAL) {
1052	$this->xtick_factor=30;
1053	$this->ytick_factor=25;
1054	switch( $aYDensity ) {
1055	case TICKD_DENSE:
1056	$this->ytick_factor=12;
1057	break;
1058	case TICKD_NORMAL:
1059	$this->ytick_factor=25;
1060	break;
1061	case TICKD_SPARSE:
1062	$this->ytick_factor=40;
1063	break;
1064	case TICKD_VERYSPARSE:
1065	$this->ytick_factor=100;
1066	break;
1067	default:
1068	JpGraphError::RaiseL(25025,$densy);//("JpGraph: Unsupported Tick density: $densy");
1069	}
1070	switch( $aXDensity ) {
1071	case TICKD_DENSE:
1072	$this->xtick_factor=15;
1073	break;
1074	case TICKD_NORMAL:
1075	$this->xtick_factor=30;
1076	break;
1077	case TICKD_SPARSE:
1078	$this->xtick_factor=45;
1079	break;
1080	case TICKD_VERYSPARSE:
1081	$this->xtick_factor=60;
1082	break;
1083	default:
1084	JpGraphError::RaiseL(25025,$densx);//("JpGraph: Unsupported Tick density: $densx");
1085	}
1086	}
1087
1088
1089	// Get a string of all image map areas
1090	function GetCSIMareas() {
1091	if( !$this->iHasStroked )
1092	$this->Stroke(_CSIM_SPECIALFILE);
1093
1094	$csim = $this->title->GetCSIMAreas();
1095	$csim .= $this->subtitle->GetCSIMAreas();
1096	$csim .= $this->subsubtitle->GetCSIMAreas();
1097	$csim .= $this->legend->GetCSIMAreas();
1098
1099	if( $this->y2axis != NULL ) {
1100	$csim .= $this->y2axis->title->GetCSIMAreas();
1101	}
1102
1103	if( $this->texts != null ) {
1104	$n = count($this->texts);
1105	for($i=0; $i < $n; ++$i ) {
1106	$csim .= $this->texts[$i]->GetCSIMAreas();
1107	}
1108	}
1109
1110	if( $this->y2texts != null && $this->y2scale != null ) {
1111	$n = count($this->y2texts);
1112	for($i=0; $i < $n; ++$i ) {
1113	$csim .= $this->y2texts[$i]->GetCSIMAreas();
1114	}
1115	}
1116
1117	if( $this->yaxis != null && $this->xaxis != null ) {
1118	$csim .= $this->yaxis->title->GetCSIMAreas();
1119	$csim .= $this->xaxis->title->GetCSIMAreas();
1120	}
1121
1122	$n = count($this->plots);
1123	for( $i=0; $i < $n; ++$i )
1124	$csim .= $this->plots[$i]->GetCSIMareas();
1125
1126	$n = count($this->y2plots);
1127	for( $i=0; $i < $n; ++$i )
1128	$csim .= $this->y2plots[$i]->GetCSIMareas();
1129
1130	$n = count($this->ynaxis);
1131	for( $i=0; $i < $n; ++$i ) {
1132	$m = count($this->ynplots[$i]);
1133	for($j=0; $j < $m; ++$j ) {
1134	$csim .= $this->ynplots[$i][$j]->GetCSIMareas();
1135	}
1136	}
1137
1138	$n = count($this->iTables);
1139	for( $i=0; $i < $n; ++$i ) {
1140	$csim .= $this->iTables[$i]->GetCSIMareas();
1141	}
1142
1143	return $csim;
1144	}
1145
1146	// Get a complete <MAP>..</MAP> tag for the final image map
1147	function GetHTMLImageMap($aMapName) {
1148	$im = "<map name=\"$aMapName\" id=\"$aMapName\" >\n";
1149	$im .= $this->GetCSIMareas();
1150	$im .= "</map>";
1151	return $im;
1152	}
1153
1154	function CheckCSIMCache($aCacheName,$aTimeOut=60) {
1155	global $_SERVER;
1156
1157	if( $aCacheName=='auto' )
1158	$aCacheName=basename($_SERVER['PHP_SELF']);
1159
1160	$urlarg = $this->GetURLArguments();
1161	$this->csimcachename = CSIMCACHE_DIR.$aCacheName.$urlarg;
1162	$this->csimcachetimeout = $aTimeOut;
1163
1164	// First determine if we need to check for a cached version
1165	// This differs from the standard cache in the sense that the
1166	// image and CSIM map HTML file is written relative to the directory
1167	// the script executes in and not the specified cache directory.
1168	// The reason for this is that the cache directory is not necessarily
1169	// accessible from the HTTP server.
1170	if( $this->csimcachename != '' ) {
1171	$dir = dirname($this->csimcachename);
1172	$base = basename($this->csimcachename);
1173	$base = strtok($base,'.');
1174	$suffix = strtok('.');
1175	$basecsim = $dir.'/'.$base.'?'.$urlarg.'_csim_.html';
1176	$baseimg = $dir.'/'.$base.'?'.$urlarg.'.'.$this->img->img_format;
1177
1178	$timedout=false;
1179	// Does it exist at all ?
1180
1181	if( file_exists($basecsim) && file_exists($baseimg) ) {
1182	// Check that it hasn't timed out
1183	$diff=time()-filemtime($basecsim);
1184	if( $this->csimcachetimeout>0 && ($diff > $this->csimcachetimeout*60) ) {
1185	$timedout=true;
1186	@unlink($basecsim);
1187	@unlink($baseimg);
1188	}
1189	else {
1190	if ($fh = @fopen($basecsim, "r")) {
1191	fpassthru($fh);
1192	return true;
1193	}
1194	else
1195	JpGraphError::RaiseL(25027,$basecsim);//(" Can't open cached CSIM \"$basecsim\" for reading.");
1196	}
1197	}
1198	}
1199	return false;
1200	}
1201
1202	// Build the argument string to be used with the csim images
1203	function GetURLArguments() {
1204
1205	// This is a JPGRAPH internal defined that prevents
1206	// us from recursively coming here again
1207	$urlarg = _CSIM_DISPLAY.'=1';
1208
1209	// Now reconstruct any user URL argument
1210	reset($_GET);
1211	while( list($key,$value) = each($_GET) ) {
1212	if( is_array($value) ) {
1213	foreach ( $value as $k => $v ) {
1214	$urlarg .= '&'.$key.'%5B'.$k.'%5D='.urlencode($v);
1215	}
1216	}
1217	else {
1218	$urlarg .= '&'.$key.'='.urlencode($value);
1219	}
1220	}
1221
1222	// It's not ideal to convert POST argument to GET arguments
1223	// but there is little else we can do. One idea for the
1224	// future might be recreate the POST header in case.
1225	reset($_POST);
1226	while( list($key,$value) = each($_POST) ) {
1227	if( is_array($value) ) {
1228	foreach ( $value as $k => $v ) {
1229	$urlarg .= '&'.$key.'%5B'.$k.'%5D='.urlencode($v);
1230	}
1231	}
1232	else {
1233	$urlarg .= '&'.$key.'='.urlencode($value);
1234	}
1235	}
1236
1237	return $urlarg;
1238	}
1239
1240	function SetCSIMImgAlt($aAlt) {
1241	$this->iCSIMImgAlt = $aAlt;
1242	}
1243
1244	function StrokeCSIM($aScriptName='auto',$aCSIMName='',$aBorder=0) {
1245	if( $aCSIMName=='' ) {
1246	// create a random map name
1247	srand ((double) microtime() * 1000000);
1248	$r = rand(0,100000);
1249	$aCSIMName='__mapname'.$r.'__';
1250	}
1251
1252	if( $aScriptName=='auto' )
1253	$aScriptName=basename($_SERVER['PHP_SELF']);
1254
1255	$urlarg = $this->GetURLArguments();
1256
1257	if( empty($_GET[_CSIM_DISPLAY]) ) {
1258	// First determine if we need to check for a cached version
1259	// This differs from the standard cache in the sense that the
1260	// image and CSIM map HTML file is written relative to the directory
1261	// the script executes in and not the specified cache directory.
1262	// The reason for this is that the cache directory is not necessarily
1263	// accessible from the HTTP server.
1264	if( $this->csimcachename != '' ) {
1265	$dir = dirname($this->csimcachename);
1266	$base = basename($this->csimcachename);
1267	$base = strtok($base,'.');
1268	$suffix = strtok('.');
1269	$basecsim = $dir.'/'.$base.'?'.$urlarg.'_csim_.html';
1270	$baseimg = $base.'?'.$urlarg.'.'.$this->img->img_format;
1271
1272	// Check that apache can write to directory specified
1273
1274	if( file_exists($dir) && !is_writeable($dir) ) {
1275	JpgraphError::RaiseL(25028,$dir);//('Apache/PHP does not have permission to write to the CSIM cache directory ('.$dir.'). Check permissions.');
1276	}
1277
1278	// Make sure directory exists
1279	$this->cache->MakeDirs($dir);
1280
1281	// Write the image file
1282	$this->Stroke(CSIMCACHE_DIR.$baseimg);
1283
1284	// Construct wrapper HTML and write to file and send it back to browser
1285
1286	// In the src URL we must replace the '?' with its encoding to prevent the arguments
1287	// to be converted to real arguments.
1288	$tmp = str_replace('?','%3f',$baseimg);
1289	$htmlwrap = $this->GetHTMLImageMap($aCSIMName)."\n".
1290	'<img src="'.CSIMCACHE_HTTP_DIR.$tmp.'" ismap="ismap" usemap="#'.$aCSIMName.'" border="'.$aBorder.'" width="'.$this->img->width.'" height="'.$this->img->height."\" alt=\"".$this->iCSIMImgAlt."\" />\n";
1291
1292	if($fh = @fopen($basecsim,'w') ) {
1293	fwrite($fh,$htmlwrap);
1294	fclose($fh);
1295	echo $htmlwrap;
1296	}
1297	else
1298	JpGraphError::RaiseL(25029,$basecsim);//(" Can't write CSIM \"$basecsim\" for writing. Check free space and permissions.");
1299	}
1300	else {
1301
1302	if( $aScriptName=='' ) {
1303	JpGraphError::RaiseL(25030);//('Missing script name in call to StrokeCSIM(). You must specify the name of the actual image script as the first parameter to StrokeCSIM().');
1304	}
1305	echo $this->GetHTMLImageMap($aCSIMName);
1306	echo "<img src=\"".$aScriptName.'?'.$urlarg."\" ismap=\"ismap\" usemap=\"#".$aCSIMName.'" border="'.$aBorder.'" width="'.$this->img->width.'" height="'.$this->img->height."\" alt=\"".$this->iCSIMImgAlt."\" />\n";
1307	}
1308	}
1309	else {
1310	$this->Stroke();
1311	}
1312	}
1313
1314	function GetTextsYMinMax($aY2=false) {
1315	if( $aY2 )
1316	$txts = $this->y2texts;
1317	else
1318	$txts = $this->texts;
1319	$n = count($txts);
1320	$min=null;
1321	$max=null;
1322	for( $i=0; $i < $n; ++$i ) {
1323	if( $txts[$i]->iScalePosY !== null &&
1324	$txts[$i]->iScalePosX !== null ) {
1325	if( $min === null ) {
1326	$min = $max = $txts[$i]->iScalePosY ;
1327	}
1328	else {
1329	$min = min($min,$txts[$i]->iScalePosY);
1330	$max = max($max,$txts[$i]->iScalePosY);
1331	}
1332	}
1333	}
1334	if( $min !== null ) {
1335	return array($min,$max);
1336	}
1337	else
1338	return null;
1339	}
1340
1341	function GetTextsXMinMax($aY2=false) {
1342	if( $aY2 )
1343	$txts = $this->y2texts;
1344	else
1345	$txts = $this->texts;
1346	$n = count($txts);
1347	$min=null;
1348	$max=null;
1349	for( $i=0; $i < $n; ++$i ) {
1350	if( $txts[$i]->iScalePosY !== null &&
1351	$txts[$i]->iScalePosX !== null ) {
1352	if( $min === null ) {
1353	$min = $max = $txts[$i]->iScalePosX ;
1354	}
1355	else {
1356	$min = min($min,$txts[$i]->iScalePosX);
1357	$max = max($max,$txts[$i]->iScalePosX);
1358	}
1359	}
1360	}
1361	if( $min !== null ) {
1362	return array($min,$max);
1363	}
1364	else
1365	return null;
1366	}
1367
1368	function GetXMinMax() {
1369	list($min,$ymin) = $this->plots[0]->Min();
1370	list($max,$ymax) = $this->plots[0]->Max();
1371	foreach( $this->plots as $p ) {
1372	list($xmin,$ymin) = $p->Min();
1373	list($xmax,$ymax) = $p->Max();
1374	$min = Min($xmin,$min);
1375	$max = Max($xmax,$max);
1376	}
1377
1378	if( $this->y2axis != null ) {
1379	foreach( $this->y2plots as $p ) {
1380	list($xmin,$ymin) = $p->Min();
1381	list($xmax,$ymax) = $p->Max();
1382	$min = Min($xmin,$min);
1383	$max = Max($xmax,$max);
1384	}
1385	}
1386
1387	$n = count($this->ynaxis);
1388	for( $i=0; $i < $n; ++$i ) {
1389	if( $this->ynaxis[$i] != null) {
1390	foreach( $this->ynplots[$i] as $p ) {
1391	list($xmin,$ymin) = $p->Min();
1392	list($xmax,$ymax) = $p->Max();
1393	$min = Min($xmin,$min);
1394	$max = Max($xmax,$max);
1395	}
1396	}
1397	}
1398	return array($min,$max);
1399	}
1400
1401	function AdjustMarginsForTitles() {
1402	$totrequired =
1403	($this->title->t != '' ?
1404	$this->title->GetTextHeight($this->img) + $this->title->margin + 5 : 0 ) +
1405	($this->subtitle->t != '' ?
1406	$this->subtitle->GetTextHeight($this->img) + $this->subtitle->margin + 5 : 0 ) +
1407	($this->subsubtitle->t != '' ?
1408	$this->subsubtitle->GetTextHeight($this->img) + $this->subsubtitle->margin + 5 : 0 ) ;
1409
1410
1411	$btotrequired = 0;
1412	if($this->xaxis != null && !$this->xaxis->hide && !$this->xaxis->hide_labels ) {
1413	// Minimum bottom margin
1414	if( $this->xaxis->title->t != '' ) {
1415	if( $this->img->a == 90 )
1416	$btotrequired = $this->yaxis->title->GetTextHeight($this->img) + 5 ;
1417	else
1418	$btotrequired = $this->xaxis->title->GetTextHeight($this->img) + 5 ;
1419	}
1420	else
1421	$btotrequired = 0;
1422
1423	if( $this->img->a == 90 ) {
1424	$this->img->SetFont($this->yaxis->font_family,$this->yaxis->font_style,
1425	$this->yaxis->font_size);
1426	$lh = $this->img->GetTextHeight('Mg',$this->yaxis->label_angle);
1427	}
1428	else {
1429	$this->img->SetFont($this->xaxis->font_family,$this->xaxis->font_style,
1430	$this->xaxis->font_size);
1431	$lh = $this->img->GetTextHeight('Mg',$this->xaxis->label_angle);
1432	}
1433
1434	$btotrequired += $lh + 5;
1435	}
1436
1437	if( $this->img->a == 90 ) {
1438	// DO Nothing. It gets too messy to do this properly for 90 deg...
1439	}
1440	else{
1441	if( $this->img->top_margin < $totrequired ) {
1442	$this->SetMargin($this->img->left_margin,$this->img->right_margin,
1443	$totrequired,$this->img->bottom_margin);
1444	}
1445	if( $this->img->bottom_margin < $btotrequired ) {
1446	$this->SetMargin($this->img->left_margin,$this->img->right_margin,
1447	$this->img->top_margin,$btotrequired);
1448	}
1449	}
1450	}
1451
1452	// Stroke the graph
1453	// $aStrokeFileName If != "" the image will be written to this file and NOT
1454	// streamed back to the browser
1455	function Stroke($aStrokeFileName="") {
1456
1457	// Fist make a sanity check that user has specified a scale
1458	if( empty($this->yscale) ) {
1459	JpGraphError::RaiseL(25031);//('You must specify what scale to use with a call to Graph::SetScale().');
1460	}
1461
1462	// Start by adjusting the margin so that potential titles will fit.
1463	$this->AdjustMarginsForTitles();
1464
1465	// Setup scale constants
1466	if( $this->yscale ) $this->yscale->InitConstants($this->img);
1467	if( $this->xscale ) $this->xscale->InitConstants($this->img);
1468	if( $this->y2scale ) $this->y2scale->InitConstants($this->img);
1469
1470	$n=count($this->ynscale);
1471	for($i=0; $i < $n; ++$i) {
1472	if( $this->ynscale[$i] ) $this->ynscale[$i]->InitConstants($this->img);
1473	}
1474
1475	// If the filename is the predefined value = '_csim_special_'
1476	// we assume that the call to stroke only needs to do enough
1477	// to correctly generate the CSIM maps.
1478	// We use this variable to skip things we don't strictly need
1479	// to do to generate the image map to improve performance
1480	// a best we can. Therefor you will see a lot of tests !$_csim in the
1481	// code below.
1482	$_csim = ($aStrokeFileName===_CSIM_SPECIALFILE);
1483
1484	// We need to know if we have stroked the plot in the
1485	// GetCSIMareas. Otherwise the CSIM hasn't been generated
1486	// and in the case of GetCSIM called before stroke to generate
1487	// CSIM without storing an image to disk GetCSIM must call Stroke.
1488	$this->iHasStroked = true;
1489
1490	// Do any pre-stroke adjustment that is needed by the different plot types
1491	// (i.e bar plots want's to add an offset to the x-labels etc)
1492	for($i=0; $i < count($this->plots) ; ++$i ) {
1493	$this->plots[$i]->PreStrokeAdjust($this);
1494	$this->plots[$i]->DoLegend($this);
1495	}
1496
1497	// Any plots on the second Y scale?
1498	if( $this->y2scale != null ) {
1499	for($i=0; $i<count($this->y2plots) ; ++$i ) {
1500	$this->y2plots[$i]->PreStrokeAdjust($this);
1501	$this->y2plots[$i]->DoLegend($this);
1502	}
1503	}
1504
1505	// Any plots on the extra Y axises?
1506	$n = count($this->ynaxis);
1507	for($i=0; $i<$n ; ++$i ) {
1508	if( $this->ynplots == null \|\| $this->ynplots[$i] == null) {
1509	JpGraphError::RaiseL(25032,$i);//("No plots for Y-axis nbr:$i");
1510	}
1511	$m = count($this->ynplots[$i]);
1512	for($j=0; $j < $m; ++$j ) {
1513	$this->ynplots[$i][$j]->PreStrokeAdjust($this);
1514	$this->ynplots[$i][$j]->DoLegend($this);
1515	}
1516	}
1517
1518	// Bail out if any of the Y-axis not been specified and
1519	// has no plots. (This means it is impossible to do autoscaling and
1520	// no other scale was given so we can't possible draw anything). If you use manual
1521	// scaling you also have to supply the tick steps as well.
1522	if( (!$this->yscale->IsSpecified() && count($this->plots)==0) \|\|
1523	($this->y2scale!=null && !$this->y2scale->IsSpecified() && count($this->y2plots)==0) ) {
1524	//$e = "n=".count($this->y2plots)."\n";
1525	// $e = "Can't draw unspecified Y-scale.<br>\nYou have either:<br>\n";
1526	// $e .= "1. Specified an Y axis for autoscaling but have not supplied any plots<br>\n";
1527	// $e .= "2. Specified a scale manually but have forgot to specify the tick steps";
1528	JpGraphError::RaiseL(25026);
1529	}
1530
1531	// Bail out if no plots and no specified X-scale
1532	if( (!$this->xscale->IsSpecified() && count($this->plots)==0 && count($this->y2plots)==0) )
1533	JpGraphError::RaiseL(25034);//("<strong>JpGraph: Can't draw unspecified X-scale.</strong><br>No plots.<br>");
1534
1535	//Check if we should autoscale y-axis
1536	if( !$this->yscale->IsSpecified() && count($this->plots)>0 ) {
1537	list($min,$max) = $this->GetPlotsYMinMax($this->plots);
1538	$lres = $this->GetLinesYMinMax($this->lines);
1539	if( is_array($lres) ) {
1540	list($linmin,$linmax) = $lres ;
1541	$min = min($min,$linmin);
1542	$max = max($max,$linmax);
1543	}
1544	$tres = $this->GetTextsYMinMax();
1545	if( is_array($tres) ) {
1546	list($tmin,$tmax) = $tres ;
1547	$min = min($min,$tmin);
1548	$max = max($max,$tmax);
1549	}
1550	$this->yscale->AutoScale($this->img,$min,$max,
1551	$this->img->plotheight/$this->ytick_factor);
1552	}
1553	elseif( $this->yscale->IsSpecified() &&
1554	( $this->yscale->auto_ticks \|\| !$this->yscale->ticks->IsSpecified()) ) {
1555	// The tick calculation will use the user suplied min/max values to determine
1556	// the ticks. If auto_ticks is false the exact user specifed min and max
1557	// values will be used for the scale.
1558	// If auto_ticks is true then the scale might be slightly adjusted
1559	// so that the min and max values falls on an even major step.
1560	$min = $this->yscale->scale[0];
1561	$max = $this->yscale->scale[1];
1562	$this->yscale->AutoScale($this->img,$min,$max,
1563	$this->img->plotheight/$this->ytick_factor,
1564	$this->yscale->auto_ticks);
1565
1566	// Now make sure we show enough precision to accurate display the
1567	// labels. If this is not done then the user might end up with
1568	// a scale that might actually start with, say 13.5, butdue to rounding
1569	// the scale label will ony show 14.
1570	if( abs(floor($min)-$min) > 0 ) {
1571
1572	// If the user has set a format then we bail out
1573	if( $this->yscale->ticks->label_formatstr == '' && $this->yscale->ticks->label_dateformatstr == '' ) {
1574	$this->yscale->ticks->precision = abs( floor(log10( abs(floor($min)-$min))) )+1;
1575	}
1576	}
1577	}
1578
1579	if( $this->y2scale != null) {
1580	if( !$this->y2scale->IsSpecified() && count($this->y2plots)>0 ) {
1581	list($min,$max) = $this->GetPlotsYMinMax($this->y2plots);
1582
1583	$lres = $this->GetLinesYMinMax($this->y2lines);
1584	if( is_array($lres) ) {
1585	list($linmin,$linmax) = $lres ;
1586	$min = min($min,$linmin);
1587	$max = max($max,$linmax);
1588	}
1589	$tres = $this->GetTextsYMinMax(true);
1590	if( is_array($tres) ) {
1591	list($tmin,$tmax) = $tres ;
1592	$min = min($min,$tmin);
1593	$max = max($max,$tmax);
1594	}
1595	$this->y2scale->AutoScale($this->img,$min,$max,$this->img->plotheight/$this->ytick_factor);
1596	}
1597	elseif( $this->y2scale->IsSpecified() &&
1598	( $this->y2scale->auto_ticks \|\| !$this->y2scale->ticks->IsSpecified()) ) {
1599	// The tick calculation will use the user suplied min/max values to determine
1600	// the ticks. If auto_ticks is false the exact user specifed min and max
1601	// values will be used for the scale.
1602	// If auto_ticks is true then the scale might be slightly adjusted
1603	// so that the min and max values falls on an even major step.
1604	$min = $this->y2scale->scale[0];
1605	$max = $this->y2scale->scale[1];
1606	$this->y2scale->AutoScale($this->img,$min,$max,
1607	$this->img->plotheight/$this->ytick_factor,
1608	$this->y2scale->auto_ticks);
1609
1610	// Now make sure we show enough precision to accurate display the
1611	// labels. If this is not done then the user might end up with
1612	// a scale that might actually start with, say 13.5, butdue to rounding
1613	// the scale label will ony show 14.
1614	if( abs(floor($min)-$min) > 0 ) {
1615
1616	// If the user has set a format then we bail out
1617	if( $this->y2scale->ticks->label_formatstr == '' && $this->y2scale->ticks->label_dateformatstr == '' ) {
1618	$this->y2scale->ticks->precision = abs( floor(log10( abs(floor($min)-$min))) )+1;
1619	}
1620	}
1621
1622	}
1623	}
1624
1625	//
1626	// Autoscale the extra Y-axises
1627	//
1628	$n = count($this->ynaxis);
1629	for( $i=0; $i < $n; ++$i ) {
1630	if( $this->ynscale[$i] != null) {
1631	if( !$this->ynscale[$i]->IsSpecified() && count($this->ynplots[$i])>0 ) {
1632	list($min,$max) = $this->GetPlotsYMinMax($this->ynplots[$i]);
1633	$this->ynscale[$i]->AutoScale($this->img,$min,$max,$this->img->plotheight/$this->ytick_factor);
1634	}
1635	elseif( $this->ynscale[$i]->IsSpecified() &&
1636	( $this->ynscale[$i]->auto_ticks \|\| !$this->ynscale[$i]->ticks->IsSpecified()) ) {
1637	// The tick calculation will use the user suplied min/max values to determine
1638	// the ticks. If auto_ticks is false the exact user specifed min and max
1639	// values will be used for the scale.
1640	// If auto_ticks is true then the scale might be slightly adjusted
1641	// so that the min and max values falls on an even major step.
1642	$min = $this->ynscale[$i]->scale[0];
1643	$max = $this->ynscale[$i]->scale[1];
1644	$this->ynscale[$i]->AutoScale($this->img,$min,$max,
1645	$this->img->plotheight/$this->ytick_factor,
1646	$this->ynscale[$i]->auto_ticks);
1647
1648	// Now make sure we show enough precision to accurate display the
1649	// labels. If this is not done then the user might end up with
1650	// a scale that might actually start with, say 13.5, butdue to rounding
1651	// the scale label will ony show 14.
1652	if( abs(floor($min)-$min) > 0 ) {
1653
1654	// If the user has set a format then we bail out
1655	if( $this->ynscale[$i]->ticks->label_formatstr == '' && $this->ynscale[$i]->ticks->label_dateformatstr == '' ) {
1656	$this->ynscale[$i]->ticks->precision = abs( floor(log10( abs(floor($min)-$min))) )+1;
1657	}
1658	}
1659
1660	}
1661	}
1662	}
1663
1664	//Check if we should autoscale x-axis
1665	if( !$this->xscale->IsSpecified() ) {
1666	if( substr($this->axtype,0,4) == "text" ) {
1667	$max=0;
1668	$n = count($this->plots);
1669	for($i=0; $i < $n; ++$i ) {
1670	$p = $this->plots[$i];
1671	// We need some unfortunate sub class knowledge here in order
1672	// to increase number of data points in case it is a line plot
1673	// which has the barcenter set. If not it could mean that the
1674	// last point of the data is outside the scale since the barcenter
1675	// settings means that we will shift the entire plot half a tick step
1676	// to the right in oder to align with the center of the bars.
1677	if( class_exists('BarPlot',false) ) {
1678	$cl = strtolower(get_class($p));
1679	if( (class_exists('BarPlot',false) && ($p instanceof BarPlot)) \|\|
1680	empty($p->barcenter) )
1681	$max=max($max,$p->numpoints-1);
1682	else {
1683	$max=max($max,$p->numpoints);
1684	}
1685	}
1686	else {
1687	if( empty($p->barcenter) ) {
1688	$max=max($max,$p->numpoints-1);
1689	}
1690	else {
1691	$max=max($max,$p->numpoints);
1692	}
1693	}
1694	}
1695	$min=0;
1696	if( $this->y2axis != null ) {
1697	foreach( $this->y2plots as $p ) {
1698	$max=max($max,$p->numpoints-1);
1699	}
1700	}
1701	$n = count($this->ynaxis);
1702	for( $i=0; $i < $n; ++$i ) {
1703	if( $this->ynaxis[$i] != null) {
1704	foreach( $this->ynplots[$i] as $p ) {
1705	$max=max($max,$p->numpoints-1);
1706	}
1707	}
1708	}
1709
1710	$this->xscale->Update($this->img,$min,$max);
1711	$this->xscale->ticks->Set($this->xaxis->tick_step,1);
1712	$this->xscale->ticks->SupressMinorTickMarks();
1713	}
1714	else {
1715	list($min,$max) = $this->GetXMinMax();
1716
1717	$lres = $this->GetLinesXMinMax($this->lines);
1718	if( $lres ) {
1719	list($linmin,$linmax) = $lres ;
1720	$min = min($min,$linmin);
1721	$max = max($max,$linmax);
1722	}
1723
1724	$lres = $this->GetLinesXMinMax($this->y2lines);
1725	if( $lres ) {
1726	list($linmin,$linmax) = $lres ;
1727	$min = min($min,$linmin);
1728	$max = max($max,$linmax);
1729	}
1730
1731	$tres = $this->GetTextsXMinMax();
1732	if( $tres ) {
1733	list($tmin,$tmax) = $tres ;
1734	$min = min($min,$tmin);
1735	$max = max($max,$tmax);
1736	}
1737
1738	$tres = $this->GetTextsXMinMax(true);
1739	if( $tres ) {
1740	list($tmin,$tmax) = $tres ;
1741	$min = min($min,$tmin);
1742	$max = max($max,$tmax);
1743	}
1744
1745	$this->xscale->AutoScale($this->img,$min,$max,round($this->img->plotwidth/$this->xtick_factor));
1746	}
1747
1748	//Adjust position of y-axis and y2-axis to minimum/maximum of x-scale
1749	if( !is_numeric($this->yaxis->pos) && !is_string($this->yaxis->pos) )
1750	$this->yaxis->SetPos($this->xscale->GetMinVal());
1751	if( $this->y2axis != null ) {
1752	if( !is_numeric($this->y2axis->pos) && !is_string($this->y2axis->pos) )
1753	$this->y2axis->SetPos($this->xscale->GetMaxVal());
1754	$this->y2axis->SetTitleSide(SIDE_RIGHT);
1755	}
1756	$n = count($this->ynaxis);
1757	$nY2adj = $this->y2axis != null ? $this->iYAxisDeltaPos : 0;
1758	for( $i=0; $i < $n; ++$i ) {
1759	if( $this->ynaxis[$i] != null ) {
1760	if( !is_numeric($this->ynaxis[$i]->pos) && !is_string($this->ynaxis[$i]->pos) ) {
1761	$this->ynaxis[$i]->SetPos($this->xscale->GetMaxVal());
1762	$this->ynaxis[$i]->SetPosAbsDelta($i*$this->iYAxisDeltaPos + $nY2adj);
1763	}
1764	$this->ynaxis[$i]->SetTitleSide(SIDE_RIGHT);
1765	}
1766	}
1767
1768	}
1769	elseif( $this->xscale->IsSpecified() &&
1770	( $this->xscale->auto_ticks \|\| !$this->xscale->ticks->IsSpecified()) ) {
1771	// The tick calculation will use the user suplied min/max values to determine
1772	// the ticks. If auto_ticks is false the exact user specifed min and max
1773	// values will be used for the scale.
1774	// If auto_ticks is true then the scale might be slightly adjusted
1775	// so that the min and max values falls on an even major step.
1776	$min = $this->xscale->scale[0];
1777	$max = $this->xscale->scale[1];
1778	$this->xscale->AutoScale($this->img,$min,$max,
1779	round($this->img->plotwidth/$this->xtick_factor),
1780	false);
1781
1782	// Now make sure we show enough precision to accurate display the
1783	// labels. If this is not done then the user might end up with
1784	// a scale that might actually start with, say 13.5, butdue to rounding
1785	// the scale label will ony show 14.
1786	if( abs(floor($min)-$min) > 0 ) {
1787
1788	// If the user has set a format then we bail out
1789	if( $this->xscale->ticks->label_formatstr == '' && $this->xscale->ticks->label_dateformatstr == '' ) {
1790	$this->xscale->ticks->precision = abs( floor(log10( abs(floor($min)-$min))) )+1;
1791	}
1792	}
1793
1794
1795	if( $this->y2axis != null ) {
1796	if( !is_numeric($this->y2axis->pos) && !is_string($this->y2axis->pos) )
1797	$this->y2axis->SetPos($this->xscale->GetMaxVal());
1798	$this->y2axis->SetTitleSide(SIDE_RIGHT);
1799	}
1800
1801	}
1802
1803	// If we have a negative values and x-axis position is at 0
1804	// we need to supress the first and possible the last tick since
1805	// they will be drawn on top of the y-axis (and possible y2 axis)
1806	// The test below might seem strange the reasone being that if
1807	// the user hasn't specified a value for position this will not
1808	// be set until we do the stroke for the axis so as of now it
1809	// is undefined.
1810	// For X-text scale we ignore all this since the tick are usually
1811	// much further in and not close to the Y-axis. Hence the test
1812	// for 'text'
1813
1814	if( ($this->yaxis->pos==$this->xscale->GetMinVal() \|\|
1815	(is_string($this->yaxis->pos) && $this->yaxis->pos=='min')) &&
1816	!is_numeric($this->xaxis->pos) && $this->yscale->GetMinVal() < 0 &&
1817	substr($this->axtype,0,4) != 'text' && $this->xaxis->pos!="min" ) {
1818
1819	//$this->yscale->ticks->SupressZeroLabel(false);
1820	$this->xscale->ticks->SupressFirst();
1821	if( $this->y2axis != null ) {
1822	$this->xscale->ticks->SupressLast();
1823	}
1824	}
1825	elseif( !is_numeric($this->yaxis->pos) && $this->yaxis->pos=='max' ) {
1826	$this->xscale->ticks->SupressLast();
1827	}
1828
1829
1830	if( !$_csim ) {
1831	$this->StrokePlotArea();
1832	if( $this->iIconDepth == DEPTH_BACK ) {
1833	$this->StrokeIcons();
1834	}
1835	}
1836	$this->StrokeAxis(false);
1837
1838	// Stroke bands
1839	if( $this->bands != null && !$_csim)
1840	for($i=0; $i < count($this->bands); ++$i) {
1841	// Stroke all bands that asks to be in the background
1842	if( $this->bands[$i]->depth == DEPTH_BACK )
1843	$this->bands[$i]->Stroke($this->img,$this->xscale,$this->yscale);
1844	}
1845
1846	if( $this->y2bands != null && $this->y2scale != null && !$_csim )
1847	for($i=0; $i < count($this->y2bands); ++$i) {
1848	// Stroke all bands that asks to be in the foreground
1849	if( $this->y2bands[$i]->depth == DEPTH_BACK )
1850	$this->y2bands[$i]->Stroke($this->img,$this->xscale,$this->y2scale);
1851	}
1852
1853
1854	if( $this->grid_depth == DEPTH_BACK && !$_csim) {
1855	$this->ygrid->Stroke();
1856	$this->xgrid->Stroke();
1857	}
1858
1859	// Stroke Y2-axis
1860	if( $this->y2axis != null && !$_csim) {
1861	$this->y2axis->Stroke($this->xscale);
1862	$this->y2grid->Stroke();
1863	}
1864
1865	// Stroke yn-axis
1866	$n = count($this->ynaxis);
1867	for( $i=0; $i < $n; ++$i ) {
1868	$this->ynaxis[$i]->Stroke($this->xscale);
1869	}
1870
1871	$oldoff=$this->xscale->off;
1872	if(substr($this->axtype,0,4)=="text") {
1873	if( $this->text_scale_abscenteroff > -1 ) {
1874	// For a text scale the scale factor is the number of pixel per step.
1875	// Hence we can use the scale factor as a substitute for number of pixels
1876	// per major scale step and use that in order to adjust the offset so that
1877	// an object of width "abscenteroff" becomes centered.
1878	$this->xscale->off += round($this->xscale->scale_factor/2)-round($this->text_scale_abscenteroff/2);
1879	}
1880	else {
1881	$this->xscale->off +=
1882	ceil($this->xscale->scale_factor$this->text_scale_off$this->xscale->ticks->minor_step);
1883	}
1884	}
1885
1886	if( $this->iDoClipping ) {
1887	$oldimage = $this->img->CloneCanvasH();
1888	}
1889
1890	if( ! $this->y2orderback ) {
1891	// Stroke all plots for Y1 axis
1892	for($i=0; $i < count($this->plots); ++$i) {
1893	$this->plots[$i]->Stroke($this->img,$this->xscale,$this->yscale);
1894	$this->plots[$i]->StrokeMargin($this->img);
1895	}
1896	}
1897
1898	// Stroke all plots for Y2 axis
1899	if( $this->y2scale != null )
1900	for($i=0; $i< count($this->y2plots); ++$i ) {
1901	$this->y2plots[$i]->Stroke($this->img,$this->xscale,$this->y2scale);
1902	}
1903
1904	if( $this->y2orderback ) {
1905	// Stroke all plots for Y1 axis
1906	for($i=0; $i < count($this->plots); ++$i) {
1907	$this->plots[$i]->Stroke($this->img,$this->xscale,$this->yscale);
1908	$this->plots[$i]->StrokeMargin($this->img);
1909	}
1910	}
1911
1912	$n = count($this->ynaxis);
1913	for( $i=0; $i < $n; ++$i ) {
1914	$m = count($this->ynplots[$i]);
1915	for( $j=0; $j < $m; ++$j ) {
1916	$this->ynplots[$i][$j]->Stroke($this->img,$this->xscale,$this->ynscale[$i]);
1917	$this->ynplots[$i][$j]->StrokeMargin($this->img);
1918	}
1919	}
1920
1921	if( $this->iIconDepth == DEPTH_FRONT) {
1922	$this->StrokeIcons();
1923	}
1924
1925	if( $this->iDoClipping ) {
1926	// Clipping only supports graphs at 0 and 90 degrees
1927	if( $this->img->a == 0 ) {
1928	$this->img->CopyCanvasH($oldimage,$this->img->img,
1929	$this->img->left_margin,$this->img->top_margin,
1930	$this->img->left_margin,$this->img->top_margin,
1931	$this->img->plotwidth+1,$this->img->plotheight);
1932	}
1933	elseif( $this->img->a == 90 ) {
1934	$adj = ($this->img->height - $this->img->width)/2;
1935	$this->img->CopyCanvasH($oldimage,$this->img->img,
1936	$this->img->bottom_margin-$adj,$this->img->left_margin+$adj,
1937	$this->img->bottom_margin-$adj,$this->img->left_margin+$adj,
1938	$this->img->plotheight+1,$this->img->plotwidth);
1939	}
1940	else {
1941	JpGraphError::RaiseL(25035,$this->img->a);//('You have enabled clipping. Cliping is only supported for graphs at 0 or 90 degrees rotation. Please adjust you current angle (='.$this->img->a.' degrees) or disable clipping.');
1942	}
1943	$this->img->Destroy();
1944	$this->img->SetCanvasH($oldimage);
1945	}
1946
1947	$this->xscale->off=$oldoff;
1948
1949	if( $this->grid_depth == DEPTH_FRONT && !$_csim ) {
1950	$this->ygrid->Stroke();
1951	$this->xgrid->Stroke();
1952	}
1953
1954	// Stroke bands
1955	if( $this->bands!= null )
1956	for($i=0; $i < count($this->bands); ++$i) {
1957	// Stroke all bands that asks to be in the foreground
1958	if( $this->bands[$i]->depth == DEPTH_FRONT )
1959	$this->bands[$i]->Stroke($this->img,$this->xscale,$this->yscale);
1960	}
1961
1962	if( $this->y2bands!= null && $this->y2scale != null )
1963	for($i=0; $i < count($this->y2bands); ++$i) {
1964	// Stroke all bands that asks to be in the foreground
1965	if( $this->y2bands[$i]->depth == DEPTH_FRONT )
1966	$this->y2bands[$i]->Stroke($this->img,$this->xscale,$this->y2scale);
1967	}
1968
1969
1970	// Stroke any lines added
1971	if( $this->lines != null ) {
1972	for($i=0; $i < count($this->lines); ++$i) {
1973	$this->lines[$i]->Stroke($this->img,$this->xscale,$this->yscale);
1974	$this->lines[$i]->DoLegend($this);
1975	}
1976	}
1977
1978	if( $this->y2lines != null && $this->y2scale != null ) {
1979	for($i=0; $i < count($this->y2lines); ++$i) {
1980	$this->y2lines[$i]->Stroke($this->img,$this->xscale,$this->y2scale);
1981	$this->y2lines[$i]->DoLegend($this);
1982	}
1983	}
1984
1985	// Finally draw the axis again since some plots may have nagged
1986	// the axis in the edges.
1987	if( !$_csim ) {
1988	$this->StrokeAxis();
1989	}
1990
1991	if( $this->y2scale != null && !$_csim )
1992	$this->y2axis->Stroke($this->xscale,false);
1993
1994	if( !$_csim ) {
1995	$this->StrokePlotBox();
1996	}
1997
1998	// The titles and legends never gets rotated so make sure
1999	// that the angle is 0 before stroking them
2000	$aa = $this->img->SetAngle(0);
2001	$this->StrokeTitles();
2002	$this->footer->Stroke($this->img);
2003	$this->legend->Stroke($this->img);
2004	$this->img->SetAngle($aa);
2005	$this->StrokeTexts();
2006	$this->StrokeTables();
2007
2008	if( !$_csim ) {
2009
2010	$this->img->SetAngle($aa);
2011
2012	// Draw an outline around the image map
2013	if(_JPG_DEBUG) {
2014	$this->DisplayClientSideaImageMapAreas();
2015	}
2016
2017	// Should we do any final image transformation
2018	if( $this->iImgTrans ) {
2019	if( !class_exists('ImgTrans',false) ) {
2020	require_once('jpgraph_imgtrans.php');
2021	//JpGraphError::Raise('In order to use image transformation you must include the file jpgraph_imgtrans.php in your script.');
2022	}
2023
2024	$tform = new ImgTrans($this->img->img);
2025	$this->img->img = $tform->Skew3D($this->iImgTransHorizon,$this->iImgTransSkewDist,
2026	$this->iImgTransDirection,$this->iImgTransHighQ,
2027	$this->iImgTransMinSize,$this->iImgTransFillColor,
2028	$this->iImgTransBorder);
2029	}
2030
2031	// If the filename is given as the special "__handle"
2032	// then the image handler is returned and the image is NOT
2033	// streamed back
2034	if( $aStrokeFileName == _IMG_HANDLER ) {
2035	return $this->img->img;
2036	}
2037	else {
2038	// Finally stream the generated picture
2039	$this->cache->PutAndStream($this->img,$this->cache_name,$this->inline,$aStrokeFileName);
2040	}
2041	}
2042	}
2043
2044	function SetAxisLabelBackground($aType,$aXFColor='lightgray',$aXColor='black',$aYFColor='lightgray',$aYColor='black') {
2045	$this->iAxisLblBgType = $aType;
2046	$this->iXAxisLblBgFillColor = $aXFColor;
2047	$this->iXAxisLblBgColor = $aXColor;
2048	$this->iYAxisLblBgFillColor = $aYFColor;
2049	$this->iYAxisLblBgColor = $aYColor;
2050	}
2051
2052	//---------------
2053	// PRIVATE METHODS
2054
2055	function StrokeAxisLabelBackground() {
2056	// Types
2057	// 0 = No background
2058	// 1 = Only X-labels, length of axis
2059	// 2 = Only Y-labels, length of axis
2060	// 3 = As 1 but extends to width of graph
2061	// 4 = As 2 but extends to height of graph
2062	// 5 = Combination of 3 & 4
2063	// 6 = Combination of 1 & 2
2064
2065	$t = $this->iAxisLblBgType ;
2066	if( $t < 1 ) return;
2067	// Stroke optional X-axis label background color
2068	if( $t == 1 \|\| $t == 3 \|\| $t == 5 \|\| $t == 6 ) {
2069	$this->img->PushColor($this->iXAxisLblBgFillColor);
2070	if( $t == 1 \|\| $t == 6 ) {
2071	$xl = $this->img->left_margin;
2072	$yu = $this->img->height - $this->img->bottom_margin + 1;
2073	$xr = $this->img->width - $this->img->right_margin ;
2074	$yl = $this->img->height-1-$this->frame_weight;
2075	}
2076	else { // t==3 \|\| t==5
2077	$xl = $this->frame_weight;
2078	$yu = $this->img->height - $this->img->bottom_margin + 1;
2079	$xr = $this->img->width - 1 - $this->frame_weight;
2080	$yl = $this->img->height-1-$this->frame_weight;
2081	}
2082
2083	$this->img->FilledRectangle($xl,$yu,$xr,$yl);
2084	$this->img->PopColor();
2085
2086	// Check if we should add the vertical lines at left and right edge
2087	if( $this->iXAxisLblBgColor !== '' ) {
2088	// Hardcode to one pixel wide
2089	$this->img->SetLineWeight(1);
2090	$this->img->PushColor($this->iXAxisLblBgColor);
2091	if( $t == 1 \|\| $t == 6 ) {
2092	$this->img->Line($xl,$yu,$xl,$yl);
2093	$this->img->Line($xr,$yu,$xr,$yl);
2094	}
2095	else {
2096	$xl = $this->img->width - $this->img->right_margin ;
2097	$this->img->Line($xl,$yu-1,$xr,$yu-1);
2098	}
2099	$this->img->PopColor();
2100	}
2101	}
2102
2103	if( $t == 2 \|\| $t == 4 \|\| $t == 5 \|\| $t == 6 ) {
2104	$this->img->PushColor($this->iYAxisLblBgFillColor);
2105	if( $t == 2 \|\| $t == 6 ) {
2106	$xl = $this->frame_weight;
2107	$yu = $this->frame_weight+$this->img->top_margin;
2108	$xr = $this->img->left_margin - 1;
2109	$yl = $this->img->height - $this->img->bottom_margin + 1;
2110	}
2111	else {
2112	$xl = $this->frame_weight;
2113	$yu = $this->frame_weight;
2114	$xr = $this->img->left_margin - 1;
2115	$yl = $this->img->height-1-$this->frame_weight;
2116	}
2117
2118	$this->img->FilledRectangle($xl,$yu,$xr,$yl);
2119	$this->img->PopColor();
2120
2121	// Check if we should add the vertical lines at left and right edge
2122	if( $this->iXAxisLblBgColor !== '' ) {
2123	$this->img->PushColor($this->iXAxisLblBgColor);
2124	if( $t == 2 \|\| $t == 6 ) {
2125	$this->img->Line($xl,$yu-1,$xr,$yu-1);
2126	$this->img->Line($xl,$yl-1,$xr,$yl-1);
2127	}
2128	else {
2129	$this->img->Line($xr+1,$yu,$xr+1,$this->img->top_margin);
2130	}
2131	$this->img->PopColor();
2132	}
2133
2134	}
2135	}
2136
2137	function StrokeAxis($aStrokeLabels=true) {
2138
2139	if( $aStrokeLabels ) {
2140	$this->StrokeAxisLabelBackground();
2141	}
2142
2143	// Stroke axis
2144	if( $this->iAxisStyle != AXSTYLE_SIMPLE ) {
2145	switch( $this->iAxisStyle ) {
2146	case AXSTYLE_BOXIN :
2147	$toppos = SIDE_DOWN;
2148	$bottompos = SIDE_UP;
2149	$leftpos = SIDE_RIGHT;
2150	$rightpos = SIDE_LEFT;
2151	break;
2152	case AXSTYLE_BOXOUT :
2153	$toppos = SIDE_UP;
2154	$bottompos = SIDE_DOWN;
2155	$leftpos = SIDE_LEFT;
2156	$rightpos = SIDE_RIGHT;
2157	break;
2158	case AXSTYLE_YBOXIN:
2159	$toppos = FALSE;
2160	$bottompos = SIDE_UP;
2161	$leftpos = SIDE_RIGHT;
2162	$rightpos = SIDE_LEFT;
2163	break;
2164	case AXSTYLE_YBOXOUT:
2165	$toppos = FALSE;
2166	$bottompos = SIDE_DOWN;
2167	$leftpos = SIDE_LEFT;
2168	$rightpos = SIDE_RIGHT;
2169	break;
2170	default:
2171	JpGRaphError::RaiseL(25036,$this->iAxisStyle); //('Unknown AxisStyle() : '.$this->iAxisStyle);
2172	break;
2173	}
2174
2175	// By default we hide the first label so it doesn't cross the
2176	// Y-axis in case the positon hasn't been set by the user.
2177	// However, if we use a box we always want the first value
2178	// displayed so we make sure it will be displayed.
2179	$this->xscale->ticks->SupressFirst(false);
2180
2181	// Now draw the bottom X-axis
2182	$this->xaxis->SetPos('min');
2183	$this->xaxis->SetLabelSide(SIDE_DOWN);
2184	$this->xaxis->scale->ticks->SetSide($bottompos);
2185	$this->xaxis->Stroke($this->yscale,$aStrokeLabels);
2186
2187	if( $toppos !== FALSE ) {
2188	// We also want a top X-axis
2189	$this->xaxis = $this->xaxis;
2190	$this->xaxis->SetPos('max');
2191	$this->xaxis->SetLabelSide(SIDE_UP);
2192	// No title for the top X-axis
2193	if( $aStrokeLabels ) {
2194	$this->xaxis->title->Set('');
2195	}
2196	$this->xaxis->scale->ticks->SetSide($toppos);
2197	$this->xaxis->Stroke($this->yscale,$aStrokeLabels);
2198	}
2199
2200	// Stroke the left Y-axis
2201	$this->yaxis->SetPos('min');
2202	$this->yaxis->SetLabelSide(SIDE_LEFT);
2203	$this->yaxis->scale->ticks->SetSide($leftpos);
2204	$this->yaxis->Stroke($this->xscale,$aStrokeLabels);
2205
2206	// Stroke the right Y-axis
2207	$this->yaxis->SetPos('max');
2208	// No title for the right side
2209	if( $aStrokeLabels ) {
2210	$this->yaxis->title->Set('');
2211	}
2212	$this->yaxis->SetLabelSide(SIDE_RIGHT);
2213	$this->yaxis->scale->ticks->SetSide($rightpos);
2214	$this->yaxis->Stroke($this->xscale,$aStrokeLabels);
2215	}
2216	else {
2217	$this->xaxis->Stroke($this->yscale,$aStrokeLabels);
2218	$this->yaxis->Stroke($this->xscale,$aStrokeLabels);
2219	}
2220	}
2221
2222
2223	// Private helper function for backgound image
2224	static function LoadBkgImage($aImgFormat='',$aFile='',$aImgStr='') {
2225	if( $aImgStr != '' ) {
2226	return Image::CreateFromString($aImgStr);
2227	}
2228
2229	// Remove case sensitivity and setup appropriate function to create image
2230	// Get file extension. This should be the LAST '.' separated part of the filename
2231	$e = explode('.',$aFile);
2232	$ext = strtolower($e[count($e)-1]);
2233	if ($ext == "jpeg") {
2234	$ext = "jpg";
2235	}
2236
2237	if( trim($ext) == '' )
2238	$ext = 'png'; // Assume PNG if no extension specified
2239
2240	if( $aImgFormat == '' )
2241	$imgtag = $ext;
2242	else
2243	$imgtag = $aImgFormat;
2244
2245	$supported = imagetypes();
2246	if( ( $ext == 'jpg' && !($supported & IMG_JPG) ) \|\|
2247	( $ext == 'gif' && !($supported & IMG_GIF) ) \|\|
2248	( $ext == 'png' && !($supported & IMG_PNG) ) \|\|
2249	( $ext == 'bmp' && !($supported & IMG_WBMP) ) \|\|
2250	( $ext == 'xpm' && !($supported & IMG_XPM) ) ) {
2251
2252	JpGraphError::RaiseL(25037,$aFile);//('The image format of your background image ('.$aFile.') is not supported in your system configuration. ');
2253	}
2254
2255
2256	if( $imgtag == "jpg" \|\| $imgtag == "jpeg")
2257	{
2258	$f = "imagecreatefromjpeg";
2259	$imgtag = "jpg";
2260	}
2261	else
2262	{
2263	$f = "imagecreatefrom".$imgtag;
2264	}
2265
2266	// Compare specified image type and file extension
2267	if( $imgtag != $ext ) {
2268	//$t = "Background image seems to be of different type (has different file extension) than specified imagetype. Specified: '".$aImgFormat."'File: '".$aFile."'";
2269	JpGraphError::RaiseL(25038, $aImgFormat, $aFile);
2270	}
2271
2272	$img = @$f($aFile);
2273	if( !$img ) {
2274	JpGraphError::RaiseL(25039,$aFile);//(" Can't read background image: '".$aFile."'");
2275	}
2276	return $img;
2277	}
2278
2279	function StrokeBackgroundGrad() {
2280	if( $this->bkg_gradtype < 0 )
2281	return;
2282	$grad = new Gradient($this->img);
2283	if( $this->bkg_gradstyle == BGRAD_PLOT ) {
2284	$xl = $this->img->left_margin;
2285	$yt = $this->img->top_margin;
2286	$xr = $xl + $this->img->plotwidth+1 ;
2287	$yb = $yt + $this->img->plotheight ;
2288	$grad->FilledRectangle($xl,$yt,$xr,$yb,$this->bkg_gradfrom,$this->bkg_gradto,$this->bkg_gradtype);
2289	}
2290	else {
2291	$xl = 0;
2292	$yt = 0;
2293	$xr = $xl + $this->img->width - 1;
2294	$yb = $yt + $this->img->height ;
2295	if( $this->doshadow ) {
2296	$xr -= $this->shadow_width;
2297	$yb -= $this->shadow_width;
2298	}
2299	if( $this->doframe ) {
2300	$yt += $this->frame_weight;
2301	$yb -= $this->frame_weight;
2302	$xl += $this->frame_weight;
2303	$xr -= $this->frame_weight;
2304	}
2305	$aa = $this->img->SetAngle(0);
2306	$grad->FilledRectangle($xl,$yt,$xr,$yb,$this->bkg_gradfrom,$this->bkg_gradto,$this->bkg_gradtype);
2307	$aa = $this->img->SetAngle($aa);
2308	}
2309	}
2310
2311	function StrokeFrameBackground() {
2312	if( $this->background_image != "" && $this->background_cflag != "" ) {
2313	JpGraphError::RaiseL(25040);//('It is not possible to specify both a background image and a background country flag.');
2314	}
2315	if( $this->background_image != "" ) {
2316	$bkgimg = $this->LoadBkgImage($this->background_image_format,$this->background_image);
2317	}
2318	elseif( $this->background_cflag != "" ) {
2319	if( ! class_exists('FlagImages',false) ) {
2320	JpGraphError::RaiseL(25041);//('In order to use Country flags as backgrounds you must include the "jpgraph_flags.php" file.');
2321	}
2322	$fobj = new FlagImages(FLAGSIZE4);
2323	$dummy='';
2324	$bkgimg = $fobj->GetImgByName($this->background_cflag,$dummy);
2325	$this->background_image_mix = $this->background_cflag_mix;
2326	$this->background_image_type = $this->background_cflag_type;
2327	}
2328	else {
2329	return ;
2330	}
2331
2332	$bw = ImageSX($bkgimg);
2333	$bh = ImageSY($bkgimg);
2334
2335	// No matter what the angle is we always stroke the image and frame
2336	// assuming it is 0 degree
2337	$aa = $this->img->SetAngle(0);
2338
2339	switch( $this->background_image_type ) {
2340	case BGIMG_FILLPLOT: // Resize to just fill the plotarea
2341	$this->FillMarginArea();
2342	$this->StrokeFrame();
2343	// Special case to hande 90 degree rotated graph corectly
2344	if( $aa == 90 ) {
2345	$this->img->SetAngle(90);
2346	$this->FillPlotArea();
2347	$aa = $this->img->SetAngle(0);
2348	$adj = ($this->img->height - $this->img->width)/2;
2349	$this->img->CopyMerge($bkgimg,
2350	$this->img->bottom_margin-$adj,$this->img->left_margin+$adj,
2351	0,0,
2352	$this->img->plotheight+1,$this->img->plotwidth,
2353	$bw,$bh,$this->background_image_mix);
2354
2355	}
2356	else {
2357	$this->FillPlotArea();
2358	$this->img->CopyMerge($bkgimg,
2359	$this->img->left_margin,$this->img->top_margin,
2360	0,0,$this->img->plotwidth+1,$this->img->plotheight,
2361	$bw,$bh,$this->background_image_mix);
2362	}
2363	break;
2364	case BGIMG_FILLFRAME: // Fill the whole area from upper left corner, resize to just fit
2365	$hadj=0; $vadj=0;
2366	if( $this->doshadow ) {
2367	$hadj = $this->shadow_width;
2368	$vadj = $this->shadow_width;
2369	}
2370	$this->FillMarginArea();
2371	$this->FillPlotArea();
2372	$this->img->CopyMerge($bkgimg,0,0,0,0,$this->img->width-$hadj,$this->img->height-$vadj,
2373	$bw,$bh,$this->background_image_mix);
2374	$this->StrokeFrame();
2375	break;
2376	case BGIMG_COPY: // Just copy the image from left corner, no resizing
2377	$this->FillMarginArea();
2378	$this->FillPlotArea();
2379	$this->img->CopyMerge($bkgimg,0,0,0,0,$bw,$bh,
2380	$bw,$bh,$this->background_image_mix);
2381	$this->StrokeFrame();
2382	break;
2383	case BGIMG_CENTER: // Center original image in the plot area
2384	$this->FillMarginArea();
2385	$this->FillPlotArea();
2386	$centerx = round($this->img->plotwidth/2+$this->img->left_margin-$bw/2);
2387	$centery = round($this->img->plotheight/2+$this->img->top_margin-$bh/2);
2388	$this->img->CopyMerge($bkgimg,$centerx,$centery,0,0,$bw,$bh,
2389	$bw,$bh,$this->background_image_mix);
2390	$this->StrokeFrame();
2391	break;
2392	case BGIMG_FREE: // Just copy the image to the specified location
2393	$this->img->CopyMerge($bkgimg,
2394	$this->background_image_xpos,$this->background_image_ypos,
2395	0,0,$bw,$bh,$bw,$bh,$this->background_image_mix);
2396	$this->StrokeFrame(); // New
2397	break;
2398	default:
2399	JpGraphError::RaiseL(25042);//(" Unknown background image layout");
2400	}
2401	$this->img->SetAngle($aa);
2402	}
2403
2404	// Private
2405	// Draw a frame around the image
2406	function StrokeFrame() {
2407	if( !$this->doframe ) return;
2408
2409	if( $this->background_image_type <= 1 &&
2410	($this->bkg_gradtype < 0 \|\| ($this->bkg_gradtype > 0 && $this->bkg_gradstyle==BGRAD_PLOT)) ) {
2411	$c = $this->margin_color;
2412	}
2413	else {
2414	$c = false;
2415	}
2416
2417	if( $this->doshadow ) {
2418	$this->img->SetColor($this->frame_color);
2419	$this->img->ShadowRectangle(0,0,$this->img->width,$this->img->height,
2420	$c,$this->shadow_width,$this->shadow_color);
2421	}
2422	elseif( $this->framebevel ) {
2423	if( $c ) {
2424	$this->img->SetColor($this->margin_color);
2425	$this->img->FilledRectangle(0,0,$this->img->width-1,$this->img->height-1);
2426	}
2427	$this->img->Bevel(1,1,$this->img->width-2,$this->img->height-2,
2428	$this->framebeveldepth,
2429	$this->framebevelcolor1,$this->framebevelcolor2);
2430	if( $this->framebevelborder ) {
2431	$this->img->SetColor($this->framebevelbordercolor);
2432	$this->img->Rectangle(0,0,$this->img->width-1,$this->img->height-1);
2433	}
2434	}
2435	else {
2436	$this->img->SetLineWeight($this->frame_weight);
2437	if( $c ) {
2438	$this->img->SetColor($this->margin_color);
2439	$this->img->FilledRectangle(0,0,$this->img->width-1,$this->img->height-1);
2440	}
2441	$this->img->SetColor($this->frame_color);
2442	$this->img->Rectangle(0,0,$this->img->width-1,$this->img->height-1);
2443	}
2444	}
2445
2446	function FillMarginArea() {
2447	$hadj=0; $vadj=0;
2448	if( $this->doshadow ) {
2449	$hadj = $this->shadow_width;
2450	$vadj = $this->shadow_width;
2451	}
2452
2453	$this->img->SetColor($this->margin_color);
2454	// $this->img->FilledRectangle(0,0,$this->img->width-1-$hadj,$this->img->height-1-$vadj);
2455
2456	$this->img->FilledRectangle(0,0,$this->img->width-1-$hadj,$this->img->top_margin);
2457	$this->img->FilledRectangle(0,$this->img->top_margin,$this->img->left_margin,$this->img->height-1-$hadj);
2458	$this->img->FilledRectangle($this->img->left_margin+1,
2459	$this->img->height-$this->img->bottom_margin,
2460	$this->img->width-1-$hadj,
2461	$this->img->height-1-$hadj);
2462	$this->img->FilledRectangle($this->img->width-$this->img->right_margin,
2463	$this->img->top_margin+1,
2464	$this->img->width-1-$hadj,
2465	$this->img->height-$this->img->bottom_margin-1);
2466	}
2467
2468	function FillPlotArea() {
2469	$this->img->PushColor($this->plotarea_color);
2470	$this->img->FilledRectangle($this->img->left_margin,
2471	$this->img->top_margin,
2472	$this->img->width-$this->img->right_margin,
2473	$this->img->height-$this->img->bottom_margin);
2474	$this->img->PopColor();
2475	}
2476
2477	// Stroke the plot area with either a solid color or a background image
2478	function StrokePlotArea() {
2479	// Note: To be consistent we really should take a possible shadow
2480	// into account. However, that causes some problem for the LinearScale class
2481	// since in the current design it does not have any links to class Graph which
2482	// means it has no way of compensating for the adjusted plotarea in case of a
2483	// shadow. So, until I redesign LinearScale we can't compensate for this.
2484	// So just set the two adjustment parameters to zero for now.
2485	$boxadj = 0; //$this->doframe ? $this->frame_weight : 0 ;
2486	$adj = 0; //$this->doshadow ? $this->shadow_width : 0 ;
2487
2488	if( $this->background_image != "" \|\| $this->background_cflag != "" ) {
2489	$this->StrokeFrameBackground();
2490	}
2491	else {
2492	$aa = $this->img->SetAngle(0);
2493	$this->StrokeFrame();
2494	$aa = $this->img->SetAngle($aa);
2495	$this->StrokeBackgroundGrad();
2496	if( $this->bkg_gradtype < 0 \|\|
2497	($this->bkg_gradtype > 0 && $this->bkg_gradstyle==BGRAD_MARGIN) ) {
2498	$this->FillPlotArea();
2499	}
2500	}
2501	}
2502
2503	function StrokeIcons() {
2504	$n = count($this->iIcons);
2505	for( $i=0; $i < $n; ++$i ) {
2506	$this->iIcons[$i]->StrokeWithScale($this->img,$this->xscale,$this->yscale);
2507	}
2508	}
2509
2510	function StrokePlotBox() {
2511	// Should we draw a box around the plot area?
2512	if( $this->boxed ) {
2513	$this->img->SetLineWeight(1);
2514	$this->img->SetLineStyle('solid');
2515	$this->img->SetColor($this->box_color);
2516	for($i=0; $i < $this->box_weight; ++$i ) {
2517	$this->img->Rectangle(
2518	$this->img->left_margin-$i,$this->img->top_margin-$i,
2519	$this->img->width-$this->img->right_margin+$i,
2520	$this->img->height-$this->img->bottom_margin+$i);
2521	}
2522	}
2523	}
2524
2525	function SetTitleBackgroundFillStyle($aStyle,$aColor1='black',$aColor2='white') {
2526	$this->titlebkg_fillstyle = $aStyle;
2527	$this->titlebkg_scolor1 = $aColor1;
2528	$this->titlebkg_scolor2 = $aColor2;
2529	}
2530
2531	function SetTitleBackground($aBackColor='gray', $aStyle=TITLEBKG_STYLE1, $aFrameStyle=TITLEBKG_FRAME_NONE, $aFrameColor='black', $aFrameWeight=1, $aBevelHeight=3, $aEnable=true) {
2532	$this->titlebackground = $aEnable;
2533	$this->titlebackground_color = $aBackColor;
2534	$this->titlebackground_style = $aStyle;
2535	$this->titlebackground_framecolor = $aFrameColor;
2536	$this->titlebackground_framestyle = $aFrameStyle;
2537	$this->titlebackground_frameweight = $aFrameWeight;
2538	$this->titlebackground_bevelheight = $aBevelHeight ;
2539	}
2540
2541
2542	function StrokeTitles() {
2543
2544	$margin=3;
2545
2546	if( $this->titlebackground ) {
2547
2548	// Find out height
2549	$this->title->margin += 2 ;
2550	$h = $this->title->GetTextHeight($this->img)+$this->title->margin+$margin;
2551	if( $this->subtitle->t != "" && !$this->subtitle->hide ) {
2552	$h += $this->subtitle->GetTextHeight($this->img)+$margin+
2553	$this->subtitle->margin;
2554	$h += 2;
2555	}
2556	if( $this->subsubtitle->t != "" && !$this->subsubtitle->hide ) {
2557	$h += $this->subsubtitle->GetTextHeight($this->img)+$margin+
2558	$this->subsubtitle->margin;
2559	$h += 2;
2560	}
2561	$this->img->PushColor($this->titlebackground_color);
2562	if( $this->titlebackground_style === TITLEBKG_STYLE1 ) {
2563	// Inside the frame
2564	if( $this->framebevel ) {
2565	$x1 = $y1 = $this->framebeveldepth + 1 ;
2566	$x2 = $this->img->width - $this->framebeveldepth - 2 ;
2567	$this->title->margin += $this->framebeveldepth + 1 ;
2568	$h += $y1 ;
2569	$h += 2;
2570	}
2571	else {
2572	$x1 = $y1 = $this->frame_weight;
2573	$x2 = $this->img->width - 2*$x1;
2574	}
2575	}
2576	elseif( $this->titlebackground_style === TITLEBKG_STYLE2 ) {
2577	// Cover the frame as well
2578	$x1 = $y1 = 0;
2579	$x2 = $this->img->width - 1 ;
2580	}
2581	elseif( $this->titlebackground_style === TITLEBKG_STYLE3 ) {
2582	// Cover the frame as well (the difference is that
2583	// for style==3 a bevel frame border is on top
2584	// of the title background)
2585	$x1 = $y1 = 0;
2586	$x2 = $this->img->width - 1 ;
2587	$h += $this->framebeveldepth ;
2588	$this->title->margin += $this->framebeveldepth ;
2589	}
2590	else {
2591	JpGraphError::RaiseL(25043);//('Unknown title background style.');
2592	}
2593
2594	if( $this->titlebackground_framestyle === 3 ) {
2595	$h += $this->titlebackground_bevelheight*2 + 1 ;
2596	$this->title->margin += $this->titlebackground_bevelheight ;
2597	}
2598
2599	if( $this->doshadow ) {
2600	$x2 -= $this->shadow_width ;
2601	}
2602
2603	$indent=0;
2604	if( $this->titlebackground_framestyle == TITLEBKG_FRAME_BEVEL ) {
2605	$ind = $this->titlebackground_bevelheight;
2606	}
2607
2608	if( $this->titlebkg_fillstyle==TITLEBKG_FILLSTYLE_HSTRIPED ) {
2609	$this->img->FilledRectangle2($x1+$ind,$y1+$ind,$x2-$ind,$h-$ind,
2610	$this->titlebkg_scolor1,
2611	$this->titlebkg_scolor2);
2612	}
2613	elseif( $this->titlebkg_fillstyle==TITLEBKG_FILLSTYLE_VSTRIPED ) {
2614	$this->img->FilledRectangle2($x1+$ind,$y1+$ind,$x2-$ind,$h-$ind,
2615	$this->titlebkg_scolor1,
2616	$this->titlebkg_scolor2,2);
2617	}
2618	else {
2619	// Solid fill
2620	$this->img->FilledRectangle($x1,$y1,$x2,$h);
2621	}
2622	$this->img->PopColor();
2623
2624	$this->img->PushColor($this->titlebackground_framecolor);
2625	$this->img->SetLineWeight($this->titlebackground_frameweight);
2626	if( $this->titlebackground_framestyle == TITLEBKG_FRAME_FULL ) {
2627	// Frame background
2628	$this->img->Rectangle($x1,$y1,$x2,$h);
2629	}
2630	elseif( $this->titlebackground_framestyle == TITLEBKG_FRAME_BOTTOM ) {
2631	// Bottom line only
2632	$this->img->Line($x1,$h,$x2,$h);
2633	}
2634	elseif( $this->titlebackground_framestyle == TITLEBKG_FRAME_BEVEL ) {
2635	$this->img->Bevel($x1,$y1,$x2,$h,$this->titlebackground_bevelheight);
2636	}
2637	$this->img->PopColor();
2638
2639	// This is clumsy. But we neeed to stroke the whole graph frame if it is
2640	// set to bevel to get the bevel shading on top of the text background
2641	if( $this->framebevel && $this->doframe &&
2642	$this->titlebackground_style === 3 ) {
2643	$this->img->Bevel(1,1,$this->img->width-2,$this->img->height-2,
2644	$this->framebeveldepth,
2645	$this->framebevelcolor1,$this->framebevelcolor2);
2646	if( $this->framebevelborder ) {
2647	$this->img->SetColor($this->framebevelbordercolor);
2648	$this->img->Rectangle(0,0,$this->img->width-1,$this->img->height-1);
2649	}
2650	}
2651	}
2652
2653	// Stroke title
2654	$y = $this->title->margin;
2655	if( $this->title->halign == 'center' )
2656	$this->title->Center(0,$this->img->width,$y);
2657	elseif( $this->title->halign == 'left' ) {
2658	$this->title->SetPos($this->title->margin+2,$y);
2659	}
2660	elseif( $this->title->halign == 'right' ) {
2661	$indent = 0;
2662	if( $this->doshadow )
2663	$indent = $this->shadow_width+2;
2664	$this->title->SetPos($this->img->width-$this->title->margin-$indent,$y,'right');
2665	}
2666	$this->title->Stroke($this->img);
2667
2668	// ... and subtitle
2669	$y += $this->title->GetTextHeight($this->img) + $margin + $this->subtitle->margin;
2670	if( $this->subtitle->halign == 'center' )
2671	$this->subtitle->Center(0,$this->img->width,$y);
2672	elseif( $this->subtitle->halign == 'left' ) {
2673	$this->subtitle->SetPos($this->subtitle->margin+2,$y);
2674	}
2675	elseif( $this->subtitle->halign == 'right' ) {
2676	$indent = 0;
2677	if( $this->doshadow )
2678	$indent = $this->shadow_width+2;
2679	$this->subtitle->SetPos($this->img->width-$this->subtitle->margin-$indent,$y,'right');
2680	}
2681	$this->subtitle->Stroke($this->img);
2682
2683	// ... and subsubtitle
2684	$y += $this->subtitle->GetTextHeight($this->img) + $margin + $this->subsubtitle->margin;
2685	if( $this->subsubtitle->halign == 'center' )
2686	$this->subsubtitle->Center(0,$this->img->width,$y);
2687	elseif( $this->subsubtitle->halign == 'left' ) {
2688	$this->subsubtitle->SetPos($this->subsubtitle->margin+2,$y);
2689	}
2690	elseif( $this->subsubtitle->halign == 'right' ) {
2691	$indent = 0;
2692	if( $this->doshadow )
2693	$indent = $this->shadow_width+2;
2694	$this->subsubtitle->SetPos($this->img->width-$this->subsubtitle->margin-$indent,$y,'right');
2695	}
2696	$this->subsubtitle->Stroke($this->img);
2697
2698	// ... and fancy title
2699	$this->tabtitle->Stroke($this->img);
2700
2701	}
2702
2703	function StrokeTexts() {
2704	// Stroke any user added text objects
2705	if( $this->texts != null ) {
2706	for($i=0; $i < count($this->texts); ++$i) {
2707	$this->texts[$i]->StrokeWithScale($this->img,$this->xscale,$this->yscale);
2708	}
2709	}
2710
2711	if( $this->y2texts != null && $this->y2scale != null ) {
2712	for($i=0; $i < count($this->y2texts); ++$i) {
2713	$this->y2texts[$i]->StrokeWithScale($this->img,$this->xscale,$this->y2scale);
2714	}
2715	}
2716
2717	}
2718
2719	function StrokeTables() {
2720	if( $this->iTables != null ) {
2721	$n = count($this->iTables);
2722	for( $i=0; $i < $n; ++$i ) {
2723	$this->iTables[$i]->StrokeWithScale($this->img,$this->xscale,$this->yscale);
2724	}
2725	}
2726	}
2727
2728	function DisplayClientSideaImageMapAreas() {
2729	// Debug stuff - display the outline of the image map areas
2730	$csim='';
2731	foreach ($this->plots as $p) {
2732	$csim.= $p->GetCSIMareas();
2733	}
2734	$csim .= $this->legend->GetCSIMareas();
2735	if (preg_match_all("/area shape=\"(\w+)\" coords=\"([0-9\, ]+)\"/", $csim, $coords)) {
2736	$this->img->SetColor($this->csimcolor);
2737	$n = count($coords[0]);
2738	for ($i=0; $i < $n; $i++) {
2739	if ($coords[1][$i]=="poly") {
2740	preg_match_all('/\s([0-9]+)\s,\s([0-9]+)\s,*/',$coords[2][$i],$pts);
2741	$this->img->SetStartPoint($pts[1][count($pts[0])-1],$pts[2][count($pts[0])-1]);
2742	$m = count($pts[0]);
2743	for ($j=0; $j < $m; $j++) {
2744	$this->img->LineTo($pts[1][$j],$pts[2][$j]);
2745	}
2746	} else if ($coords[1][$i]=="rect") {
2747	$pts = preg_split('/,/', $coords[2][$i]);
2748	$this->img->SetStartPoint($pts[0],$pts[1]);
2749	$this->img->LineTo($pts[2],$pts[1]);
2750	$this->img->LineTo($pts[2],$pts[3]);
2751	$this->img->LineTo($pts[0],$pts[3]);
2752	$this->img->LineTo($pts[0],$pts[1]);
2753	}
2754	}
2755	}
2756	}
2757
2758	// Text scale offset in world coordinates
2759	function SetTextScaleOff($aOff) {
2760	$this->text_scale_off = $aOff;
2761	$this->xscale->text_scale_off = $aOff;
2762	}
2763
2764	// Text width of bar to be centered in absolute pixels
2765	function SetTextScaleAbsCenterOff($aOff) {
2766	$this->text_scale_abscenteroff = $aOff;
2767	}
2768
2769	// Get Y min and max values for added lines
2770	function GetLinesYMinMax( $aLines ) {
2771	$n = count($aLines);
2772	if( $n == 0 ) return false;
2773	$min = $aLines[0]->scaleposition ;
2774	$max = $min ;
2775	$flg = false;
2776	for( $i=0; $i < $n; ++$i ) {
2777	if( $aLines[$i]->direction == HORIZONTAL ) {
2778	$flg = true ;
2779	$v = $aLines[$i]->scaleposition ;
2780	if( $min > $v ) $min = $v ;
2781	if( $max < $v ) $max = $v ;
2782	}
2783	}
2784	return $flg ? array($min,$max) : false ;
2785	}
2786
2787	// Get X min and max values for added lines
2788	function GetLinesXMinMax( $aLines ) {
2789	$n = count($aLines);
2790	if( $n == 0 ) return false ;
2791	$min = $aLines[0]->scaleposition ;
2792	$max = $min ;
2793	$flg = false;
2794	for( $i=0; $i < $n; ++$i ) {
2795	if( $aLines[$i]->direction == VERTICAL ) {
2796	$flg = true ;
2797	$v = $aLines[$i]->scaleposition ;
2798	if( $min > $v ) $min = $v ;
2799	if( $max < $v ) $max = $v ;
2800	}
2801	}
2802	return $flg ? array($min,$max) : false ;
2803	}
2804
2805	// Get min and max values for all included plots
2806	function GetPlotsYMinMax($aPlots) {
2807	$n = count($aPlots);
2808	$i=0;
2809	do {
2810	list($xmax,$max) = $aPlots[$i]->Max();
2811	} while( ++$i < $n && !is_numeric($max) );
2812
2813	$i=0;
2814	do {
2815	list($xmin,$min) = $aPlots[$i]->Min();
2816	} while( ++$i < $n && !is_numeric($min) );
2817
2818	if( !is_numeric($min) \|\| !is_numeric($max) ) {
2819	JpGraphError::RaiseL(25044);//('Cannot use autoscaling since it is impossible to determine a valid min/max value of the Y-axis (only null values).');
2820	}
2821
2822	for($i=0; $i < $n; ++$i ) {
2823	list($xmax,$ymax)=$aPlots[$i]->Max();
2824	list($xmin,$ymin)=$aPlots[$i]->Min();
2825	if (is_numeric($ymax)) $max=max($max,$ymax);
2826	if (is_numeric($ymin)) $min=min($min,$ymin);
2827	}
2828	if( $min == '' ) $min = 0;
2829	if( $max == '' ) $max = 0;
2830	if( $min == 0 && $max == 0 ) {
2831	// Special case if all values are 0
2832	$min=0;$max=1;
2833	}
2834	return array($min,$max);
2835	}
2836
2837	} // Class
2838
2839	//===================================================
2840	// CLASS LineProperty
2841	// Description: Holds properties for a line
2842	//===================================================
2843	class LineProperty {
2844	public $iWeight=1, $iColor="black",$iStyle="solid",$iShow=true;
2845
2846	//---------------
2847	// PUBLIC METHODS
2848	function SetColor($aColor) {
2849	$this->iColor = $aColor;
2850	}
2851
2852	function SetWeight($aWeight) {
2853	$this->iWeight = $aWeight;
2854	}
2855
2856	function SetStyle($aStyle) {
2857	$this->iStyle = $aStyle;
2858	}
2859
2860	function Show($aShow=true) {
2861	$this->iShow=$aShow;
2862	}
2863
2864	function Stroke($aImg,$aX1,$aY1,$aX2,$aY2) {
2865	if( $this->iShow ) {
2866	$aImg->PushColor($this->iColor);
2867	$oldls = $aImg->line_style;
2868	$oldlw = $aImg->line_weight;
2869	$aImg->SetLineWeight($this->iWeight);
2870	$aImg->SetLineStyle($this->iStyle);
2871	$aImg->StyleLine($aX1,$aY1,$aX2,$aY2);
2872	$aImg->PopColor($this->iColor);
2873	$aImg->line_style = $oldls;
2874	$aImg->line_weight = $oldlw;
2875
2876	}
2877	}
2878	}
2879
2880	class GraphTabTitle extends Text{
2881	private $corner = 6 , $posx = 7, $posy = 4;
2882	private $fillcolor='lightyellow',$bordercolor='black';
2883	private $align = 'left', $width=TABTITLE_WIDTHFIT;
2884	function GraphTabTitle() {
2885	$this->t = '';
2886	$this->font_style = FS_BOLD;
2887	$this->hide = true;
2888	$this->color = 'darkred';
2889	}
2890
2891	function SetColor($aTxtColor,$aFillColor='lightyellow',$aBorderColor='black') {
2892	$this->color = $aTxtColor;
2893	$this->fillcolor = $aFillColor;
2894	$this->bordercolor = $aBorderColor;
2895	}
2896
2897	function SetFillColor($aFillColor) {
2898	$this->fillcolor = $aFillColor;
2899	}
2900
2901	function SetTabAlign($aAlign) {
2902	$this->align = $aAlign;
2903	}
2904
2905	function SetWidth($aWidth) {
2906	$this->width = $aWidth ;
2907	}
2908
2909	function Set($t) {
2910	$this->t = $t;
2911	$this->hide = false;
2912	}
2913
2914	function SetCorner($aD) {
2915	$this->corner = $aD ;
2916	}
2917
2918	function Stroke($aImg,$aDummy1=null,$aDummy2=null) {
2919	if( $this->hide )
2920	return;
2921	$this->boxed = false;
2922	$w = $this->GetWidth($aImg) + 2*$this->posx;
2923	$h = $this->GetTextHeight($aImg) + 2*$this->posy;
2924
2925	$x = $aImg->left_margin;
2926	$y = $aImg->top_margin;
2927
2928	if( $this->width === TABTITLE_WIDTHFIT ) {
2929	if( $this->align == 'left' ) {
2930	$p = array($x, $y,
2931	$x, $y-$h+$this->corner,
2932	$x + $this->corner,$y-$h,
2933	$x + $w - $this->corner, $y-$h,
2934	$x + $w, $y-$h+$this->corner,
2935	$x + $w, $y);
2936	}
2937	elseif( $this->align == 'center' ) {
2938	$x += round($aImg->plotwidth/2) - round($w/2);
2939	$p = array($x, $y,
2940	$x, $y-$h+$this->corner,
2941	$x + $this->corner, $y-$h,
2942	$x + $w - $this->corner, $y-$h,
2943	$x + $w, $y-$h+$this->corner,
2944	$x + $w, $y);
2945	}
2946	else {
2947	$x += $aImg->plotwidth -$w;
2948	$p = array($x, $y,
2949	$x, $y-$h+$this->corner,
2950	$x + $this->corner,$y-$h,
2951	$x + $w - $this->corner, $y-$h,
2952	$x + $w, $y-$h+$this->corner,
2953	$x + $w, $y);
2954	}
2955	}
2956	else {
2957	if( $this->width === TABTITLE_WIDTHFULL )
2958	$w = $aImg->plotwidth ;
2959	else
2960	$w = $this->width ;
2961
2962	// Make the tab fit the width of the plot area
2963	$p = array($x, $y,
2964	$x, $y-$h+$this->corner,
2965	$x + $this->corner,$y-$h,
2966	$x + $w - $this->corner, $y-$h,
2967	$x + $w, $y-$h+$this->corner,
2968	$x + $w, $y);
2969
2970	}
2971	if( $this->halign == 'left' ) {
2972	$aImg->SetTextAlign('left','bottom');
2973	$x += $this->posx;
2974	$y -= $this->posy;
2975	}
2976	elseif( $this->halign == 'center' ) {
2977	$aImg->SetTextAlign('center','bottom');
2978	$x += $w/2;
2979	$y -= $this->posy;
2980	}
2981	else {
2982	$aImg->SetTextAlign('right','bottom');
2983	$x += $w - $this->posx;
2984	$y -= $this->posy;
2985	}
2986
2987	$aImg->SetColor($this->fillcolor);
2988	$aImg->FilledPolygon($p);
2989
2990	$aImg->SetColor($this->bordercolor);
2991	$aImg->Polygon($p,true);
2992
2993	$aImg->SetColor($this->color);
2994	$aImg->SetFont($this->font_family,$this->font_style,$this->font_size);
2995	$aImg->StrokeText($x,$y,$this->t,0,'center');
2996	}
2997
2998	}
2999
3000	//===================================================
3001	// CLASS SuperScriptText
3002	// Description: Format a superscript text
3003	//===================================================
3004	class SuperScriptText extends Text {
3005	private $iSuper="";
3006	private $sfont_family="",$sfont_style="",$sfont_size=8;
3007	private $iSuperMargin=2,$iVertOverlap=4,$iSuperScale=0.65;
3008	private $iSDir=0;
3009	private $iSimple=false;
3010
3011	function SuperScriptText($aTxt="",$aSuper="",$aXAbsPos=0,$aYAbsPos=0) {
3012	parent::Text($aTxt,$aXAbsPos,$aYAbsPos);
3013	$this->iSuper = $aSuper;
3014	}
3015
3016	function FromReal($aVal,$aPrecision=2) {
3017	// Convert a floating point number to scientific notation
3018	$neg=1.0;
3019	if( $aVal < 0 ) {
3020	$neg = -1.0;
3021	$aVal = -$aVal;
3022	}
3023
3024	$l = floor(log10($aVal));
3025	$a = sprintf("%0.".$aPrecision."f",round($aVal / pow(10,$l),$aPrecision));
3026	$a *= $neg;
3027	if( $this->iSimple && ($a == 1 \|\| $a==-1) ) $a = '';
3028
3029	if( $a != '' )
3030	$this->t = $a.' * 10';
3031	else {
3032	if( $neg == 1 )
3033	$this->t = '10';
3034	else
3035	$this->t = '-10';
3036	}
3037	$this->iSuper = $l;
3038	}
3039
3040	function Set($aTxt,$aSuper="") {
3041	$this->t = $aTxt;
3042	$this->iSuper = $aSuper;
3043	}
3044
3045	function SetSuperFont($aFontFam,$aFontStyle=FS_NORMAL,$aFontSize=8) {
3046	$this->sfont_family = $aFontFam;
3047	$this->sfont_style = $aFontStyle;
3048	$this->sfont_size = $aFontSize;
3049	}
3050
3051	// Total width of text
3052	function GetWidth($aImg) {
3053	$aImg->SetFont($this->font_family,$this->font_style,$this->font_size);
3054	$w = $aImg->GetTextWidth($this->t);
3055	$aImg->SetFont($this->sfont_family,$this->sfont_style,$this->sfont_size);
3056	$w += $aImg->GetTextWidth($this->iSuper);
3057	$w += $this->iSuperMargin;
3058	return $w;
3059	}
3060
3061	// Hight of font (approximate the height of the text)
3062	function GetFontHeight($aImg) {
3063	$aImg->SetFont($this->font_family,$this->font_style,$this->font_size);
3064	$h = $aImg->GetFontHeight();
3065	$aImg->SetFont($this->sfont_family,$this->sfont_style,$this->sfont_size);
3066	$h += $aImg->GetFontHeight();
3067	return $h;
3068	}
3069
3070	// Hight of text
3071	function GetTextHeight($aImg) {
3072	$aImg->SetFont($this->font_family,$this->font_style,$this->font_size);
3073	$h = $aImg->GetTextHeight($this->t);
3074	$aImg->SetFont($this->sfont_family,$this->sfont_style,$this->sfont_size);
3075	$h += $aImg->GetTextHeight($this->iSuper);
3076	return $h;
3077	}
3078
3079	function Stroke($aImg,$ax=-1,$ay=-1) {
3080
3081	// To position the super script correctly we need different
3082	// cases to handle the alignmewnt specified since that will
3083	// determine how we can interpret the x,y coordinates
3084
3085	$w = parent::GetWidth($aImg);
3086	$h = parent::GetTextHeight($aImg);
3087	switch( $this->valign ) {
3088	case 'top':
3089	$sy = $this->y;
3090	break;
3091	case 'center':
3092	$sy = $this->y - $h/2;
3093	break;
3094	case 'bottom':
3095	$sy = $this->y - $h;
3096	break;
3097	default:
3098	JpGraphError::RaiseL(25052);//('PANIC: Internal error in SuperScript::Stroke(). Unknown vertical alignment for text');
3099	break;
3100	}
3101
3102	switch( $this->halign ) {
3103	case 'left':
3104	$sx = $this->x + $w;
3105	break;
3106	case 'center':
3107	$sx = $this->x + $w/2;
3108	break;
3109	case 'right':
3110	$sx = $this->x;
3111	break;
3112	default:
3113	JpGraphError::RaiseL(25053);//('PANIC: Internal error in SuperScript::Stroke(). Unknown horizontal alignment for text');
3114	break;
3115	}
3116
3117	$sx += $this->iSuperMargin;
3118	$sy += $this->iVertOverlap;
3119
3120	// Should we automatically determine the font or
3121	// has the user specified it explicetly?
3122	if( $this->sfont_family == "" ) {
3123	if( $this->font_family <= FF_FONT2 ) {
3124	if( $this->font_family == FF_FONT0 ) {
3125	$sff = FF_FONT0;
3126	}
3127	elseif( $this->font_family == FF_FONT1 ) {
3128	if( $this->font_style == FS_NORMAL )
3129	$sff = FF_FONT0;
3130	else
3131	$sff = FF_FONT1;
3132	}
3133	else {
3134	$sff = FF_FONT1;
3135	}
3136	$sfs = $this->font_style;
3137	$sfz = $this->font_size;
3138	}
3139	else {
3140	// TTF fonts
3141	$sff = $this->font_family;
3142	$sfs = $this->font_style;
3143	$sfz = floor($this->font_size*$this->iSuperScale);
3144	if( $sfz < 8 ) $sfz = 8;
3145	}
3146	$this->sfont_family = $sff;
3147	$this->sfont_style = $sfs;
3148	$this->sfont_size = $sfz;
3149	}
3150	else {
3151	$sff = $this->sfont_family;
3152	$sfs = $this->sfont_style;
3153	$sfz = $this->sfont_size;
3154	}
3155
3156	parent::Stroke($aImg,$ax,$ay);
3157
3158
3159	// For the builtin fonts we need to reduce the margins
3160	// since the bounding bx reported for the builtin fonts
3161	// are much larger than for the TTF fonts.
3162	if( $sff <= FF_FONT2 ) {
3163	$sx -= 2;
3164	$sy += 3;
3165	}
3166
3167	$aImg->SetTextAlign('left','bottom');
3168	$aImg->SetFont($sff,$sfs,$sfz);
3169	$aImg->PushColor($this->color);
3170	$aImg->StrokeText($sx,$sy,$this->iSuper,$this->iSDir,'left');
3171	$aImg->PopColor();
3172	}
3173	}
3174
3175
3176	//===================================================
3177	// CLASS Grid
3178	// Description: responsible for drawing grid lines in graph
3179	//===================================================
3180	class Grid {
3181	protected $img;
3182	protected $scale;
3183	protected $grid_color='#DDDDDD',$grid_mincolor='#DDDDDD';
3184	protected $type="solid";
3185	protected $show=false, $showMinor=false,$weight=1;
3186	protected $fill=false,$fillcolor=array('#EFEFEF','#BBCCFF');
3187	//---------------
3188	// CONSTRUCTOR
3189	function Grid($aAxis) {
3190	$this->scale = $aAxis->scale;
3191	$this->img = $aAxis->img;
3192	}
3193	//---------------
3194	// PUBLIC METHODS
3195	function SetColor($aMajColor,$aMinColor=false) {
3196	$this->grid_color=$aMajColor;
3197	if( $aMinColor === false )
3198	$aMinColor = $aMajColor ;
3199	$this->grid_mincolor = $aMinColor;
3200	}
3201
3202	function SetWeight($aWeight) {
3203	$this->weight=$aWeight;
3204	}
3205
3206	// Specify if grid should be dashed, dotted or solid
3207	function SetLineStyle($aType) {
3208	$this->type = $aType;
3209	}
3210
3211	// Decide if both major and minor grid should be displayed
3212	function Show($aShowMajor=true,$aShowMinor=false) {
3213	$this->show=$aShowMajor;
3214	$this->showMinor=$aShowMinor;
3215	}
3216
3217	function SetFill($aFlg=true,$aColor1='lightgray',$aColor2='lightblue') {
3218	$this->fill = $aFlg;
3219	$this->fillcolor = array( $aColor1, $aColor2 );
3220	}
3221
3222	// Display the grid
3223	function Stroke() {
3224	if( $this->showMinor && !$this->scale->textscale ) {
3225	$tmp = $this->grid_color;
3226	$this->grid_color = $this->grid_mincolor;
3227	$this->DoStroke($this->scale->ticks->ticks_pos);
3228
3229	$this->grid_color = $tmp;
3230	$this->DoStroke($this->scale->ticks->maj_ticks_pos);
3231	}
3232	else {
3233	$this->DoStroke($this->scale->ticks->maj_ticks_pos);
3234	}
3235	}
3236
3237	//--------------
3238	// Private methods
3239	// Draw the grid
3240	function DoStroke($aTicksPos) {
3241	if( !$this->show )
3242	return;
3243	$nbrgrids = count($aTicksPos);
3244
3245	if( $this->scale->type=="y" ) {
3246	$xl=$this->img->left_margin;
3247	$xr=$this->img->width-$this->img->right_margin;
3248
3249	if( $this->fill ) {
3250	// Draw filled areas
3251	$y2 = $aTicksPos[0];
3252	$i=1;
3253	while( $i < $nbrgrids ) {
3254	$y1 = $y2;
3255	$y2 = $aTicksPos[$i++];
3256	$this->img->SetColor($this->fillcolor[$i & 1]);
3257	$this->img->FilledRectangle($xl,$y1,$xr,$y2);
3258	}
3259	}
3260
3261	$this->img->SetColor($this->grid_color);
3262	$this->img->SetLineWeight($this->weight);
3263
3264	// Draw grid lines
3265	switch( $this->type ) {
3266	case "solid": $style = LINESTYLE_SOLID; break;
3267	case "dotted": $style = LINESTYLE_DOTTED; break;
3268	case "dashed": $style = LINESTYLE_DASHED; break;
3269	case "longdashed": $style = LINESTYLE_LONGDASH; break;
3270	default:
3271	$style = LINESTYLE_SOLID; break;
3272	}
3273
3274	for($i=0; $i < $nbrgrids; ++$i) {
3275	$y=$aTicksPos[$i];
3276	$this->img->StyleLine($xl,$y,$xr,$y,$style);
3277	}
3278	}
3279	elseif( $this->scale->type=="x" ) {
3280	$yu=$this->img->top_margin;
3281	$yl=$this->img->height-$this->img->bottom_margin;
3282	$limit=$this->img->width-$this->img->right_margin;
3283
3284	if( $this->fill ) {
3285	// Draw filled areas
3286	$x2 = $aTicksPos[0];
3287	$i=1;
3288	while( $i < $nbrgrids ) {
3289	$x1 = $x2;
3290	$x2 = min($aTicksPos[$i++],$limit) ;
3291	$this->img->SetColor($this->fillcolor[$i & 1]);
3292	$this->img->FilledRectangle($x1,$yu,$x2,$yl);
3293	}
3294	}
3295
3296	$this->img->SetColor($this->grid_color);
3297	$this->img->SetLineWeight($this->weight);
3298
3299	// We must also test for limit since we might have
3300	// an offset and the number of ticks is calculated with
3301	// assumption offset==0 so we might end up drawing one
3302	// to many gridlines
3303	$i=0;
3304	$x=$aTicksPos[$i];
3305	while( $i<count($aTicksPos) && ($x=$aTicksPos[$i]) <= $limit ) {
3306	if( $this->type == "solid" )
3307	$this->img->Line($x,$yl,$x,$yu);
3308	elseif( $this->type == "dotted" )
3309	$this->img->DashedLine($x,$yl,$x,$yu,1,6);
3310	elseif( $this->type == "dashed" )
3311	$this->img->DashedLine($x,$yl,$x,$yu,2,4);
3312	elseif( $this->type == "longdashed" )
3313	$this->img->DashedLine($x,$yl,$x,$yu,8,6);
3314	++$i;
3315	}
3316	}
3317	else {
3318	JpGraphError::RaiseL(25054,$this->scale->type);//('Internal error: Unknown grid axis ['.$this->scale->type.']');
3319	}
3320	return true;
3321	}
3322	} // Class
3323
3324	//===================================================
3325	// CLASS Axis
3326	// Description: Defines X and Y axis. Notes that at the
3327	// moment the code is not really good since the axis on
3328	// several occasion must know wheter it's an X or Y axis.
3329	// This was a design decision to make the code easier to
3330	// follow.
3331	//===================================================
3332	class AxisPrototype {
3333	public $scale=null;
3334	public $img=null;
3335	public $hide=false,$hide_labels=false;
3336	public $title=null;
3337	public $font_family=FF_FONT1,$font_style=FS_NORMAL,$font_size=12,$label_angle=0;
3338	public $tick_step=1;
3339	public $pos = false;
3340	public $ticks_label = array();
3341
3342	protected $weight=1;
3343	protected $color=array(0,0,0),$label_color=array(0,0,0);
3344	protected $ticks_label_colors=null;
3345	protected $show_first_label=true,$show_last_label=true;
3346	protected $label_step=1; // Used by a text axis to specify what multiple of major steps
3347	// should be labeled.
3348	protected $labelPos=0; // Which side of the axis should the labels be?
3349	protected $title_adjust,$title_margin,$title_side=SIDE_LEFT;
3350	protected $tick_label_margin=7;
3351	protected $label_halign = '',$label_valign = '', $label_para_align='left';
3352	protected $hide_line=false;
3353	protected $iDeltaAbsPos=0;
3354
3355	//---------------
3356	// CONSTRUCTOR
3357	function Axis($img,$aScale,$color=array(0,0,0)) {
3358	$this->img = $img;
3359	$this->scale = $aScale;
3360	$this->color = $color;
3361	$this->title=new Text("");
3362
3363	if( $aScale->type=="y" ) {
3364	$this->title_margin = 25;
3365	$this->title_adjust="middle";
3366	$this->title->SetOrientation(90);
3367	$this->tick_label_margin=7;
3368	$this->labelPos=SIDE_LEFT;
3369	}
3370	else {
3371	$this->title_margin = 5;
3372	$this->title_adjust="high";
3373	$this->title->SetOrientation(0);
3374	$this->tick_label_margin=7;
3375	$this->labelPos=SIDE_DOWN;
3376	$this->title_side=SIDE_DOWN;
3377	}
3378	}
3379	//---------------
3380	// PUBLIC METHODS
3381
3382	function SetLabelFormat($aFormStr) {
3383	$this->scale->ticks->SetLabelFormat($aFormStr);
3384	}
3385
3386	function SetLabelFormatString($aFormStr,$aDate=false) {
3387	$this->scale->ticks->SetLabelFormat($aFormStr,$aDate);
3388	}
3389
3390	function SetLabelFormatCallback($aFuncName) {
3391	$this->scale->ticks->SetFormatCallback($aFuncName);
3392	}
3393
3394	function SetLabelAlign($aHAlign,$aVAlign="top",$aParagraphAlign='left') {
3395	$this->label_halign = $aHAlign;
3396	$this->label_valign = $aVAlign;
3397	$this->label_para_align = $aParagraphAlign;
3398	}
3399
3400	// Don't display the first label
3401	function HideFirstTickLabel($aShow=false) {
3402	$this->show_first_label=$aShow;
3403	}
3404
3405	function HideLastTickLabel($aShow=false) {
3406	$this->show_last_label=$aShow;
3407	}
3408
3409	// Manually specify the major and (optional) minor tick position and labels
3410	function SetTickPositions($aMajPos,$aMinPos=NULL,$aLabels=NULL) {
3411	$this->scale->ticks->SetTickPositions($aMajPos,$aMinPos,$aLabels);
3412	}
3413
3414	// Manually specify major tick positions and optional labels
3415	function SetMajTickPositions($aMajPos,$aLabels=NULL) {
3416	$this->scale->ticks->SetTickPositions($aMajPos,NULL,$aLabels);
3417	}
3418
3419	// Hide minor or major tick marks
3420	function HideTicks($aHideMinor=true,$aHideMajor=true) {
3421	$this->scale->ticks->SupressMinorTickMarks($aHideMinor);
3422	$this->scale->ticks->SupressTickMarks($aHideMajor);
3423	}
3424
3425	// Hide zero label
3426	function HideZeroLabel($aFlag=true) {
3427	$this->scale->ticks->SupressZeroLabel();
3428	}
3429
3430	function HideFirstLastLabel() {
3431	// The two first calls to ticks method will supress
3432	// automatically generated scale values. However, that
3433	// will not affect manually specified value, e.g text-scales.
3434	// therefor we also make a kludge here to supress manually
3435	// specified scale labels.
3436	$this->scale->ticks->SupressLast();
3437	$this->scale->ticks->SupressFirst();
3438	$this->show_first_label = false;
3439	$this->show_last_label = false;
3440	}
3441
3442	// Hide the axis
3443	function Hide($aHide=true) {
3444	$this->hide=$aHide;
3445	}
3446
3447	// Hide the actual axis-line, but still print the labels
3448	function HideLine($aHide=true) {
3449	$this->hide_line = $aHide;
3450	}
3451
3452	function HideLabels($aHide=true) {
3453	$this->hide_labels = $aHide;
3454	}
3455
3456
3457	// Weight of axis
3458	function SetWeight($aWeight) {
3459	$this->weight = $aWeight;
3460	}
3461
3462	// Axis color
3463	function SetColor($aColor,$aLabelColor=false) {
3464	$this->color = $aColor;
3465	if( !$aLabelColor ) $this->label_color = $aColor;
3466	else $this->label_color = $aLabelColor;
3467	}
3468
3469	// Title on axis
3470	function SetTitle($aTitle,$aAdjustAlign="high") {
3471	$this->title->Set($aTitle);
3472	$this->title_adjust=$aAdjustAlign;
3473	}
3474
3475	// Specify distance from the axis
3476	function SetTitleMargin($aMargin) {
3477	$this->title_margin=$aMargin;
3478	}
3479
3480	// Which side of the axis should the axis title be?
3481	function SetTitleSide($aSideOfAxis) {
3482	$this->title_side = $aSideOfAxis;
3483	}
3484
3485	// Utility function to set the direction for tick marks
3486	function SetTickDirection($aDir) {
3487	// Will be deprecated from 1.7
3488	if( ERR_DEPRECATED )
3489	JpGraphError::RaiseL(25055);//('Axis::SetTickDirection() is deprecated. Use Axis::SetTickSide() instead');
3490	$this->scale->ticks->SetSide($aDir);
3491	}
3492
3493	function SetTickSide($aDir) {
3494	$this->scale->ticks->SetSide($aDir);
3495	}
3496
3497	// Specify text labels for the ticks. One label for each data point
3498	function SetTickLabels($aLabelArray,$aLabelColorArray=null) {
3499	$this->ticks_label = $aLabelArray;
3500	$this->ticks_label_colors = $aLabelColorArray;
3501	}
3502
3503	// How far from the axis should the labels be drawn
3504	function SetTickLabelMargin($aMargin) {
3505	if( ERR_DEPRECATED )
3506	JpGraphError::RaiseL(25056);//('SetTickLabelMargin() is deprecated. Use Axis::SetLabelMargin() instead.');
3507	$this->tick_label_margin=$aMargin;
3508	}
3509
3510	function SetLabelMargin($aMargin) {
3511	$this->tick_label_margin=$aMargin;
3512	}
3513
3514	// Specify that every $step of the ticks should be displayed starting
3515	// at $start
3516	// DEPRECATED FUNCTION: USE SetTextTickInterval() INSTEAD
3517	function SetTextTicks($step,$start=0) {
3518	JpGraphError::RaiseL(25057);//(" SetTextTicks() is deprecated. Use SetTextTickInterval() instead.");
3519	}
3520
3521	// Specify that every $step of the ticks should be displayed starting
3522	// at $start
3523	function SetTextTickInterval($aStep,$aStart=0) {
3524	$this->scale->ticks->SetTextLabelStart($aStart);
3525	$this->tick_step=$aStep;
3526	}
3527
3528	// Specify that every $step tick mark should have a label
3529	// should be displayed starting
3530	function SetTextLabelInterval($aStep) {
3531	if( $aStep < 1 )
3532	JpGraphError::RaiseL(25058);//(" Text label interval must be specified >= 1.");
3533	$this->label_step=$aStep;
3534	}
3535
3536	// Which side of the axis should the labels be on?
3537	function SetLabelPos($aSidePos) {
3538	// This will be deprecated from 1.7
3539	if( ERR_DEPRECATED )
3540	JpGraphError::RaiseL(25059);//('SetLabelPos() is deprecated. Use Axis::SetLabelSide() instead.');
3541	$this->labelPos=$aSidePos;
3542	}
3543
3544	function SetLabelSide($aSidePos) {
3545	$this->labelPos=$aSidePos;
3546	}
3547
3548	// Set the font
3549	function SetFont($aFamily,$aStyle=FS_NORMAL,$aSize=10) {
3550	$this->font_family = $aFamily;
3551	$this->font_style = $aStyle;
3552	$this->font_size = $aSize;
3553	}
3554
3555	// Position for axis line on the "other" scale
3556	function SetPos($aPosOnOtherScale) {
3557	$this->pos=$aPosOnOtherScale;
3558	}
3559
3560	// Set the position of the axis to be X-pixels delta to the right
3561	// of the max X-position (used to position the multiple Y-axis)
3562	function SetPosAbsDelta($aDelta) {
3563	$this->iDeltaAbsPos=$aDelta;
3564	}
3565
3566	// Specify the angle for the tick labels
3567	function SetLabelAngle($aAngle) {
3568	$this->label_angle = $aAngle;
3569	}
3570
3571	} // Class
3572
3573
3574	//===================================================
3575	// CLASS Axis
3576	// Description: Defines X and Y axis. Notes that at the
3577	// moment the code is not really good since the axis on
3578	// several occasion must know wheter it's an X or Y axis.
3579	// This was a design decision to make the code easier to
3580	// follow.
3581	//===================================================
3582	class Axis extends AxisPrototype {
3583
3584	function Axis($img,$aScale,$color=array(0,0,0)) {
3585	parent::Axis($img,$aScale,$color);
3586	}
3587
3588	// Stroke the axis.
3589	function Stroke($aOtherAxisScale,$aStrokeLabels=true) {
3590	if( $this->hide ) return;
3591	if( is_numeric($this->pos) ) {
3592	$pos=$aOtherAxisScale->Translate($this->pos);
3593	}
3594	else { // Default to minimum of other scale if pos not set
3595	if( ($aOtherAxisScale->GetMinVal() >= 0 && $this->pos==false) \|\| $this->pos=="min" ) {
3596	$pos = $aOtherAxisScale->scale_abs[0];
3597	}
3598	elseif($this->pos == "max") {
3599	$pos = $aOtherAxisScale->scale_abs[1];
3600	}
3601	else { // If negative set x-axis at 0
3602	$this->pos=0;
3603	$pos=$aOtherAxisScale->Translate(0);
3604	}
3605	}
3606	$pos += $this->iDeltaAbsPos;
3607	$this->img->SetLineWeight($this->weight);
3608	$this->img->SetColor($this->color);
3609	$this->img->SetFont($this->font_family,$this->font_style,$this->font_size);
3610	if( $this->scale->type == "x" ) {
3611	if( !$this->hide_line )
3612	$this->img->FilledRectangle($this->img->left_margin,$pos,
3613	$this->img->width-$this->img->right_margin,$pos+$this->weight-1);
3614	if( $this->title_side == SIDE_DOWN ) {
3615	$y = $pos + $this->img->GetFontHeight() + $this->title_margin + $this->title->margin;
3616	$yalign = 'top';
3617	}
3618	else {
3619	$y = $pos - $this->img->GetFontHeight() - $this->title_margin - $this->title->margin;
3620	$yalign = 'bottom';
3621	}
3622
3623	if( $this->title_adjust=='high' )
3624	$this->title->SetPos($this->img->width-$this->img->right_margin,$y,'right',$yalign);
3625	elseif( $this->title_adjust=='middle' \|\| $this->title_adjust=='center' )
3626	$this->title->SetPos(($this->img->width-$this->img->left_margin-$this->img->right_margin)/2+$this->img->left_margin,$y,'center',$yalign);
3627	elseif($this->title_adjust=='low')
3628	$this->title->SetPos($this->img->left_margin,$y,'left',$yalign);
3629	else {
3630	JpGraphError::RaiseL(25060,$this->title_adjust);//('Unknown alignment specified for X-axis title. ('.$this->title_adjust.')');
3631	}
3632	}
3633	elseif( $this->scale->type == "y" ) {
3634	// Add line weight to the height of the axis since
3635	// the x-axis could have a width>1 and we want the axis to fit nicely together.
3636	if( !$this->hide_line )
3637	$this->img->FilledRectangle($pos-$this->weight+1,$this->img->top_margin,
3638	$pos,$this->img->height-$this->img->bottom_margin+$this->weight-1);
3639	$x=$pos ;
3640	if( $this->title_side == SIDE_LEFT ) {
3641	$x -= $this->title_margin;
3642	$x -= $this->title->margin;
3643	$halign="right";
3644	}
3645	else {
3646	$x += $this->title_margin;
3647	$x += $this->title->margin;
3648	$halign="left";
3649	}
3650	// If the user has manually specified an hor. align
3651	// then we override the automatic settings with this
3652	// specifed setting. Since default is 'left' we compare
3653	// with that. (This means a manually set 'left' align
3654	// will have no effect.)
3655	if( $this->title->halign != 'left' )
3656	$halign = $this->title->halign;
3657	if( $this->title_adjust=="high" )
3658	$this->title->SetPos($x,$this->img->top_margin,$halign,"top");
3659	elseif($this->title_adjust=="middle" \|\| $this->title_adjust=="center")
3660	$this->title->SetPos($x,($this->img->height-$this->img->top_margin-$this->img->bottom_margin)/2+$this->img->top_margin,$halign,"center");
3661	elseif($this->title_adjust=="low")
3662	$this->title->SetPos($x,$this->img->height-$this->img->bottom_margin,$halign,"bottom");
3663	else
3664	JpGraphError::RaiseL(25061,$this->title_adjust);//('Unknown alignment specified for Y-axis title. ('.$this->title_adjust.')');
3665
3666	}
3667	$this->scale->ticks->Stroke($this->img,$this->scale,$pos);
3668	if( $aStrokeLabels ) {
3669	if( !$this->hide_labels )
3670	$this->StrokeLabels($pos);
3671	$this->title->Stroke($this->img);
3672	}
3673	}
3674
3675	//---------------
3676	// PRIVATE METHODS
3677	// Draw all the tick labels on major tick marks
3678	function StrokeLabels($aPos,$aMinor=false,$aAbsLabel=false) {
3679
3680	$this->img->SetColor($this->label_color);
3681	$this->img->SetFont($this->font_family,$this->font_style,$this->font_size);
3682	$yoff=$this->img->GetFontHeight()/2;
3683
3684	// Only draw labels at major tick marks
3685	$nbr = count($this->scale->ticks->maj_ticks_label);
3686
3687	// We have the option to not-display the very first mark
3688	// (Usefull when the first label might interfere with another
3689	// axis.)
3690	$i = $this->show_first_label ? 0 : 1 ;
3691	if( !$this->show_last_label ) --$nbr;
3692	// Now run through all labels making sure we don't overshoot the end
3693	// of the scale.
3694	$ncolor=0;
3695	if( isset($this->ticks_label_colors) )
3696	$ncolor=count($this->ticks_label_colors);
3697	while( $i<$nbr ) {
3698	// $tpos holds the absolute text position for the label
3699	$tpos=$this->scale->ticks->maj_ticklabels_pos[$i];
3700
3701	// Note. the $limit is only used for the x axis since we
3702	// might otherwise overshoot if the scale has been centered
3703	// This is due to us "loosing" the last tick mark if we center.
3704	if( $this->scale->type=="x" && $tpos > $this->img->width-$this->img->right_margin+1 ) {
3705	return;
3706	}
3707	// we only draw every $label_step label
3708	if( ($i % $this->label_step)==0 ) {
3709
3710	// Set specific label color if specified
3711	if( $ncolor > 0 )
3712	$this->img->SetColor($this->ticks_label_colors[$i % $ncolor]);
3713
3714	// If the label has been specified use that and in other case
3715	// just label the mark with the actual scale value
3716	$m=$this->scale->ticks->GetMajor();
3717
3718	// ticks_label has an entry for each data point and is the array
3719	// that holds the labels set by the user. If the user hasn't
3720	// specified any values we use whats in the automatically asigned
3721	// labels in the maj_ticks_label
3722	if( isset($this->ticks_label[$i*$m]) )
3723	$label=$this->ticks_label[$i*$m];
3724	else {
3725	if( $aAbsLabel )
3726	$label=abs($this->scale->ticks->maj_ticks_label[$i]);
3727	else
3728	$label=$this->scale->ticks->maj_ticks_label[$i];
3729	if( $this->scale->textscale && $this->scale->ticks->label_formfunc == '' ) {
3730	++$label;
3731	}
3732	}
3733
3734	if( $this->scale->type == "x" ) {
3735	if( $this->labelPos == SIDE_DOWN ) {
3736	if( $this->label_angle==0 \|\| $this->label_angle==90 ) {
3737	if( $this->label_halign=='' && $this->label_valign=='')
3738	$this->img->SetTextAlign('center','top');
3739	else
3740	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3741
3742	}
3743	else {
3744	if( $this->label_halign=='' && $this->label_valign=='')
3745	$this->img->SetTextAlign("right","top");
3746	else
3747	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3748	}
3749	$this->img->StrokeText($tpos,$aPos+$this->tick_label_margin+1,$label,
3750	$this->label_angle,$this->label_para_align);
3751	}
3752	else {
3753	if( $this->label_angle==0 \|\| $this->label_angle==90 ) {
3754	if( $this->label_halign=='' && $this->label_valign=='')
3755	$this->img->SetTextAlign("center","bottom");
3756	else
3757	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3758	}
3759	else {
3760	if( $this->label_halign=='' && $this->label_valign=='')
3761	$this->img->SetTextAlign("right","bottom");
3762	else
3763	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3764	}
3765	$this->img->StrokeText($tpos,$aPos-$this->tick_label_margin-1,$label,
3766	$this->label_angle,$this->label_para_align);
3767	}
3768	}
3769	else {
3770	// scale->type == "y"
3771	//if( $this->label_angle!=0 )
3772	//JpGraphError::Raise(" Labels at an angle are not supported on Y-axis");
3773	if( $this->labelPos == SIDE_LEFT ) { // To the left of y-axis
3774	if( $this->label_halign=='' && $this->label_valign=='')
3775	$this->img->SetTextAlign("right","center");
3776	else
3777	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3778	$this->img->StrokeText($aPos-$this->tick_label_margin,$tpos,$label,$this->label_angle,$this->label_para_align);
3779	}
3780	else { // To the right of the y-axis
3781	if( $this->label_halign=='' && $this->label_valign=='')
3782	$this->img->SetTextAlign("left","center");
3783	else
3784	$this->img->SetTextAlign($this->label_halign,$this->label_valign);
3785	$this->img->StrokeText($aPos+$this->tick_label_margin,$tpos,$label,$this->label_angle,$this->label_para_align);
3786	}
3787	}
3788	}
3789	++$i;
3790	}
3791	}
3792
3793	}
3794
3795
3796	//===================================================
3797	// CLASS Ticks
3798	// Description: Abstract base class for drawing linear and logarithmic
3799	// tick marks on axis
3800	//===================================================
3801	class Ticks {
3802	public $label_formatstr=''; // C-style format string to use for labels
3803	public $label_formfunc='';
3804	public $label_dateformatstr='';
3805	public $direction=1; // Should ticks be in(=1) the plot area or outside (=-1)
3806	public $supress_last=false,$supress_tickmarks=false,$supress_minor_tickmarks=false;
3807	public $maj_ticks_pos = array(), $maj_ticklabels_pos = array(),
3808	$ticks_pos = array(), $maj_ticks_label = array();
3809	public $precision;
3810
3811	protected $minor_abs_size=3, $major_abs_size=5;
3812	protected $scale;
3813	protected $is_set=false;
3814	protected $supress_zerolabel=false,$supress_first=false;
3815	protected $mincolor="",$majcolor="";
3816	protected $weight=1;
3817	protected $label_usedateformat=FALSE;
3818
3819	//---------------
3820	// CONSTRUCTOR
3821	function Ticks($aScale) {
3822	$this->scale=$aScale;
3823	$this->precision = -1;
3824	}
3825
3826	//---------------
3827	// PUBLIC METHODS
3828	// Set format string for automatic labels
3829	function SetLabelFormat($aFormatString,$aDate=FALSE) {
3830	$this->label_formatstr=$aFormatString;
3831	$this->label_usedateformat=$aDate;
3832	}
3833
3834	function SetLabelDateFormat($aFormatString) {
3835	$this->label_dateformatstr=$aFormatString;
3836	}
3837
3838	function SetFormatCallback($aCallbackFuncName) {
3839	$this->label_formfunc = $aCallbackFuncName;
3840	}
3841
3842	// Don't display the first zero label
3843	function SupressZeroLabel($aFlag=true) {
3844	$this->supress_zerolabel=$aFlag;
3845	}
3846
3847	// Don't display minor tick marks
3848	function SupressMinorTickMarks($aHide=true) {
3849	$this->supress_minor_tickmarks=$aHide;
3850	}
3851
3852	// Don't display major tick marks
3853	function SupressTickMarks($aHide=true) {
3854	$this->supress_tickmarks=$aHide;
3855	}
3856
3857	// Hide the first tick mark
3858	function SupressFirst($aHide=true) {
3859	$this->supress_first=$aHide;
3860	}
3861
3862	// Hide the last tick mark
3863	function SupressLast($aHide=true) {
3864	$this->supress_last=$aHide;
3865	}
3866
3867	// Size (in pixels) of minor tick marks
3868	function GetMinTickAbsSize() {
3869	return $this->minor_abs_size;
3870	}
3871
3872	// Size (in pixels) of major tick marks
3873	function GetMajTickAbsSize() {
3874	return $this->major_abs_size;
3875	}
3876
3877	function SetSize($aMajSize,$aMinSize=3) {
3878	$this->major_abs_size = $aMajSize;
3879	$this->minor_abs_size = $aMinSize;
3880	}
3881
3882	// Have the ticks been specified
3883	function IsSpecified() {
3884	return $this->is_set;
3885	}
3886
3887	// Specify number of decimals in automatic labels
3888	// Deprecated from 1.4. Use SetFormatString() instead
3889	function SetPrecision($aPrecision) {
3890	if( ERR_DEPRECATED )
3891	JpGraphError::RaiseL(25063);//('Ticks::SetPrecision() is deprecated. Use Ticks::SetLabelFormat() (or Ticks::SetFormatCallback()) instead');
3892	$this->precision=$aPrecision;
3893	}
3894
3895	function SetSide($aSide) {
3896	$this->direction=$aSide;
3897	}
3898
3899	// Which side of the axis should the ticks be on
3900	function SetDirection($aSide=SIDE_RIGHT) {
3901	$this->direction=$aSide;
3902	}
3903
3904	// Set colors for major and minor tick marks
3905	function SetMarkColor($aMajorColor,$aMinorColor="") {
3906	$this->SetColor($aMajorColor,$aMinorColor);
3907	}
3908
3909	function SetColor($aMajorColor,$aMinorColor="") {
3910	$this->majcolor=$aMajorColor;
3911
3912	// If not specified use same as major
3913	if( $aMinorColor=="" )
3914	$this->mincolor=$aMajorColor;
3915	else
3916	$this->mincolor=$aMinorColor;
3917	}
3918
3919	function SetWeight($aWeight) {
3920	$this->weight=$aWeight;
3921	}
3922
3923	} // Class
3924
3925	//===================================================
3926	// CLASS LinearTicks
3927	// Description: Draw linear ticks on axis
3928	//===================================================
3929	class LinearTicks extends Ticks {
3930	public $minor_step=1, $major_step=2;
3931	public $xlabel_offset=0,$xtick_offset=0;
3932	private $label_offset=0; // What offset should the displayed label have
3933	// i.e should we display 0,1,2 or 1,2,3,4 or 2,3,4 etc
3934	private $text_label_start=0;
3935	private $iManualTickPos = NULL, $iManualMinTickPos = NULL, $iManualTickLabels = NULL;
3936	private $iAdjustForDST = false; // If a date falls within the DST period add one hour to the diaplyed time
3937
3938	//---------------
3939	// CONSTRUCTOR
3940	function LinearTicks() {
3941	$this->precision = -1;
3942	}
3943
3944	//---------------
3945	// PUBLIC METHODS
3946
3947
3948	// Return major step size in world coordinates
3949	function GetMajor() {
3950	return $this->major_step;
3951	}
3952
3953	// Return minor step size in world coordinates
3954	function GetMinor() {
3955	return $this->minor_step;
3956	}
3957
3958	// Set Minor and Major ticks (in world coordinates)
3959	function Set($aMajStep,$aMinStep=false) {
3960	if( $aMinStep==false )
3961	$aMinStep=$aMajStep;
3962
3963	if( $aMajStep <= 0 \|\| $aMinStep <= 0 ) {
3964	JpGraphError::RaiseL(25064);
3965	//(" Minor or major step size is 0. Check that you haven't got an accidental SetTextTicks(0) in your code. If this is not the case you might have stumbled upon a bug in JpGraph. Please report this and if possible include the data that caused the problem.");
3966	}
3967
3968	$this->major_step=$aMajStep;
3969	$this->minor_step=$aMinStep;
3970	$this->is_set = true;
3971	}
3972
3973	function SetMajTickPositions($aMajPos,$aLabels=NULL) {
3974	$this->SetTickPositions($aMajPos,NULL,$aLabels);
3975	}
3976
3977	function SetTickPositions($aMajPos,$aMinPos=NULL,$aLabels=NULL) {
3978	if( !is_array($aMajPos) \|\| ($aMinPos!==NULL && !is_array($aMinPos)) ) {
3979	JpGraphError::RaiseL(25065);//('Tick positions must be specifued as an array()');
3980	return;
3981	}
3982	$n=count($aMajPos);
3983	if( is_array($aLabels) && (count($aLabels) != $n) ) {
3984	JpGraphError::RaiseL(25066);//('When manually specifying tick positions and labels the number of labels must be the same as the number of specified ticks.');
3985	return;
3986	}
3987	$this->iManualTickPos = $aMajPos;
3988	$this->iManualMinTickPos = $aMinPos;
3989	$this->iManualTickLabels = $aLabels;
3990	}
3991
3992	// Specify all the tick positions manually and possible also the exact labels
3993	function _doManualTickPos($aScale) {
3994	$n=count($this->iManualTickPos);
3995	$m=count($this->iManualMinTickPos);
3996	$doLbl=count($this->iManualTickLabels) > 0;
3997
3998	$this->maj_ticks_pos = array();
3999	$this->maj_ticklabels_pos = array();
4000	$this->ticks_pos = array();
4001
4002	// Now loop through the supplied positions and translate them to screen coordinates
4003	// and store them in the maj_label_positions
4004	$minScale = $aScale->scale[0];
4005	$maxScale = $aScale->scale[1];
4006	$j=0;
4007	for($i=0; $i < $n ; ++$i ) {
4008	// First make sure that the first tick is not lower than the lower scale value
4009	if( !isset($this->iManualTickPos[$i]) \|\|
4010	$this->iManualTickPos[$i] < $minScale \|\| $this->iManualTickPos[$i] > $maxScale) {
4011	continue;
4012	}
4013
4014
4015	$this->maj_ticks_pos[$j] = $aScale->Translate($this->iManualTickPos[$i]);
4016	$this->maj_ticklabels_pos[$j] = $this->maj_ticks_pos[$j];
4017
4018	// Set the minor tick marks the same as major if not specified
4019	if( $m <= 0 ) {
4020	$this->ticks_pos[$j] = $this->maj_ticks_pos[$j];
4021	}
4022
4023	if( $doLbl ) {
4024	$this->maj_ticks_label[$j] = $this->iManualTickLabels[$i];
4025	}
4026	else {
4027	$this->maj_ticks_label[$j]=$this->_doLabelFormat($this->iManualTickPos[$i],$i,$n);
4028	}
4029	++$j;
4030	}
4031
4032	// Some sanity check
4033	if( count($this->maj_ticks_pos) < 2 ) {
4034	JpGraphError::RaiseL(25067);//('Your manually specified scale and ticks is not correct. The scale seems to be too small to hold any of the specified tickl marks.');
4035	}
4036
4037	// Setup the minor tick marks
4038	$j=0;
4039	for($i=0; $i < $m; ++$i ) {
4040	if( empty($this->iManualMinTickPos[$i]) \|\|
4041	$this->iManualMinTickPos[$i] < $minScale \|\| $this->iManualMinTickPos[$i] > $maxScale)
4042	continue;
4043	$this->ticks_pos[$j] = $aScale->Translate($this->iManualMinTickPos[$i]);
4044	++$j;
4045	}
4046	}
4047
4048	function _doAutoTickPos($aScale) {
4049	$maj_step_abs = $aScale->scale_factor*$this->major_step;
4050	$min_step_abs = $aScale->scale_factor*$this->minor_step;
4051
4052	if( $min_step_abs==0 \|\| $maj_step_abs==0 ) {
4053	JpGraphError::RaiseL(25068);//("A plot has an illegal scale. This could for example be that you are trying to use text autoscaling to draw a line plot with only one point or that the plot area is too small. It could also be that no input data value is numeric (perhaps only '-' or 'x')");
4054	}
4055	// We need to make this an int since comparing it below
4056	// with the result from round() can give wrong result, such that
4057	// (40 < 40) == TRUE !!!
4058	$limit = (int)$aScale->scale_abs[1];
4059
4060	if( $aScale->textscale ) {
4061	// This can only be true for a X-scale (horizontal)
4062	// Define ticks for a text scale. This is slightly different from a
4063	// normal linear type of scale since the position might be adjusted
4064	// and the labels start at on
4065	$label = (float)$aScale->GetMinVal()+$this->text_label_start+$this->label_offset;
4066	$start_abs=$aScale->scale_factor*$this->text_label_start;
4067	$nbrmajticks=round(($aScale->GetMaxVal()-$aScale->GetMinVal()-$this->text_label_start )/$this->major_step)+1;
4068
4069	$x = $aScale->scale_abs[0]+$start_abs+$this->xlabel_offset*$min_step_abs;
4070	for( $i=0; $label <= $aScale->GetMaxVal()+$this->label_offset; ++$i ) {
4071	// Apply format to label
4072	$this->maj_ticks_label[$i]=$this->_doLabelFormat($label,$i,$nbrmajticks);
4073	$label+=$this->major_step;
4074
4075	// The x-position of the tick marks can be different from the labels.
4076	// Note that we record the tick position (not the label) so that the grid
4077	// happen upon tick marks and not labels.
4078	$xtick=$aScale->scale_abs[0]+$start_abs+$this->xtick_offset$min_step_abs+$i$maj_step_abs;
4079	$this->maj_ticks_pos[$i]=$xtick;
4080	$this->maj_ticklabels_pos[$i] = round($x);
4081	$x += $maj_step_abs;
4082	}
4083	}
4084	else {
4085	$label = $aScale->GetMinVal();
4086	$abs_pos = $aScale->scale_abs[0];
4087	$j=0; $i=0;
4088	$step = round($maj_step_abs/$min_step_abs);
4089	if( $aScale->type == "x" ) {
4090	// For a normal linear type of scale the major ticks will always be multiples
4091	// of the minor ticks. In order to avoid any rounding issues the major ticks are
4092	// defined as every "step" minor ticks and not calculated separately
4093	$nbrmajticks=round(($aScale->GetMaxVal()-$aScale->GetMinVal()-$this->text_label_start )/$this->major_step)+1;
4094	while( round($abs_pos) <= $limit ) {
4095	$this->ticks_pos[] = round($abs_pos);
4096	$this->ticks_label[] = $label;
4097	if( $step== 0 \|\| $i % $step == 0 && $j < $nbrmajticks ) {
4098	$this->maj_ticks_pos[$j] = round($abs_pos);
4099	$this->maj_ticklabels_pos[$j] = round($abs_pos);
4100	$this->maj_ticks_label[$j]=$this->_doLabelFormat($label,$j,$nbrmajticks);
4101	++$j;
4102	}
4103	++$i;
4104	$abs_pos += $min_step_abs;
4105	$label+=$this->minor_step;
4106	}
4107	}
4108	elseif( $aScale->type == "y" ) {
4109	$nbrmajticks=round(($aScale->GetMaxVal()-$aScale->GetMinVal())/$this->major_step)+1;
4110	while( round($abs_pos) >= $limit ) {
4111	$this->ticks_pos[$i] = round($abs_pos);
4112	$this->ticks_label[$i]=$label;
4113	if( $step== 0 \|\| $i % $step == 0 && $j < $nbrmajticks) {
4114	$this->maj_ticks_pos[$j] = round($abs_pos);
4115	$this->maj_ticklabels_pos[$j] = round($abs_pos);
4116	$this->maj_ticks_label[$j]=$this->_doLabelFormat($label,$j,$nbrmajticks);
4117	++$j;
4118	}
4119	++$i;
4120	$abs_pos += $min_step_abs;
4121	$label += $this->minor_step;
4122	}
4123	}
4124	}
4125	}
4126
4127	function AdjustForDST($aFlg=true) {
4128	$this->iAdjustForDST = $aFlg;
4129	}
4130
4131
4132	function _doLabelFormat($aVal,$aIdx,$aNbrTicks) {
4133
4134	// If precision hasn't been specified set it to a sensible value
4135	if( $this->precision==-1 ) {
4136	$t = log10($this->minor_step);
4137	if( $t > 0 )
4138	$precision = 0;
4139	else
4140	$precision = -floor($t);
4141	}
4142	else
4143	$precision = $this->precision;
4144
4145	if( $this->label_formfunc != '' ) {
4146	$f=$this->label_formfunc;
4147	$l = call_user_func($f,$aVal);
4148	}
4149	elseif( $this->label_formatstr != '' \|\| $this->label_dateformatstr != '' ) {
4150	if( $this->label_usedateformat ) {
4151	// Adjust the value to take daylight savings into account
4152	if (date("I",$aVal)==1 && $this->iAdjustForDST ) // DST
4153	$aVal+=3600;
4154
4155	$l = date($this->label_formatstr,$aVal);
4156	if( $this->label_formatstr == 'W' ) {
4157	// If we use week formatting then add a single 'w' in front of the
4158	// week number to differentiate it from dates
4159	$l = 'w'.$l;
4160	}
4161	}
4162	else {
4163	if( $this->label_dateformatstr !== '' ) {
4164	// Adjust the value to take daylight savings into account
4165	if (date("I",$aVal)==1 && $this->iAdjustForDST ) // DST
4166	$aVal+=3600;
4167
4168	$l = date($this->label_dateformatstr,$aVal);
4169	if( $this->label_formatstr == 'W' ) {
4170	// If we use week formatting then add a single 'w' in front of the
4171	// week number to differentiate it from dates
4172	$l = 'w'.$l;
4173	}
4174	}
4175	else
4176	$l = sprintf($this->label_formatstr,$aVal);
4177	}
4178	}
4179	else {
4180	$l = sprintf('%01.'.$precision.'f',round($aVal,$precision));
4181	}
4182
4183	if( ($this->supress_zerolabel && $l==0) \|\| ($this->supress_first && $aIdx==0) \|\|
4184	($this->supress_last && $aIdx==$aNbrTicks-1) ) {
4185	$l='';
4186	}
4187	return $l;
4188	}
4189
4190	// Stroke ticks on either X or Y axis
4191	function _StrokeTicks($aImg,$aScale,$aPos) {
4192	$hor = $aScale->type == 'x';
4193	$aImg->SetLineWeight($this->weight);
4194
4195	// We need to make this an int since comparing it below
4196	// with the result from round() can give wrong result, such that
4197	// (40 < 40) == TRUE !!!
4198	$limit = (int)$aScale->scale_abs[1];
4199
4200	// A text scale doesn't have any minor ticks
4201	if( !$aScale->textscale ) {
4202	// Stroke minor ticks
4203	$yu = $aPos - $this->direction*$this->GetMinTickAbsSize();
4204	$xr = $aPos + $this->direction*$this->GetMinTickAbsSize();
4205	$n = count($this->ticks_pos);
4206	for($i=0; $i < $n; ++$i ) {
4207	if( !$this->supress_tickmarks && !$this->supress_minor_tickmarks) {
4208	if( $this->mincolor!="" ) $aImg->PushColor($this->mincolor);
4209	if( $hor ) {
4210	//if( $this->ticks_pos[$i] <= $limit )
4211	$aImg->Line($this->ticks_pos[$i],$aPos,$this->ticks_pos[$i],$yu);
4212	}
4213	else {
4214	//if( $this->ticks_pos[$i] >= $limit )
4215	$aImg->Line($aPos,$this->ticks_pos[$i],$xr,$this->ticks_pos[$i]);
4216	}
4217	if( $this->mincolor!="" ) $aImg->PopColor();
4218	}
4219	}
4220	}
4221
4222	// Stroke major ticks
4223	$yu = $aPos - $this->direction*$this->GetMajTickAbsSize();
4224	$xr = $aPos + $this->direction*$this->GetMajTickAbsSize();
4225	$nbrmajticks=round(($aScale->GetMaxVal()-$aScale->GetMinVal()-$this->text_label_start )/$this->major_step)+1;
4226	$n = count($this->maj_ticks_pos);
4227	for($i=0; $i < $n ; ++$i ) {
4228	if(!($this->xtick_offset > 0 && $i==$nbrmajticks-1) && !$this->supress_tickmarks) {
4229	if( $this->majcolor!="" ) $aImg->PushColor($this->majcolor);
4230	if( $hor ) {
4231	//if( $this->maj_ticks_pos[$i] <= $limit )
4232	$aImg->Line($this->maj_ticks_pos[$i],$aPos,$this->maj_ticks_pos[$i],$yu);
4233	}
4234	else {
4235	//if( $this->maj_ticks_pos[$i] >= $limit )
4236	$aImg->Line($aPos,$this->maj_ticks_pos[$i],$xr,$this->maj_ticks_pos[$i]);
4237	}
4238	if( $this->majcolor!="" ) $aImg->PopColor();
4239	}
4240	}
4241
4242	}
4243
4244	// Draw linear ticks
4245	function Stroke($aImg,$aScale,$aPos) {
4246	if( $this->iManualTickPos != NULL )
4247	$this->_doManualTickPos($aScale);
4248	else
4249	$this->_doAutoTickPos($aScale);
4250	$this->_StrokeTicks($aImg,$aScale,$aPos, $aScale->type == 'x' );
4251	}
4252
4253	//---------------
4254	// PRIVATE METHODS
4255	// Spoecify the offset of the displayed tick mark with the tick "space"
4256	// Legal values for $o is [0,1] used to adjust where the tick marks and label
4257	// should be positioned within the major tick-size
4258	// $lo specifies the label offset and $to specifies the tick offset
4259	// this comes in handy for example in bar graphs where we wont no offset for the
4260	// tick but have the labels displayed halfway under the bars.
4261	function SetXLabelOffset($aLabelOff,$aTickOff=-1) {
4262	$this->xlabel_offset=$aLabelOff;
4263	if( $aTickOff==-1 ) // Same as label offset
4264	$this->xtick_offset=$aLabelOff;
4265	else
4266	$this->xtick_offset=$aTickOff;
4267	if( $aLabelOff>0 )
4268	$this->SupressLast(); // The last tick wont fit
4269	}
4270
4271	// Which tick label should we start with?
4272	function SetTextLabelStart($aTextLabelOff) {
4273	$this->text_label_start=$aTextLabelOff;
4274	}
4275
4276	} // Class
4277
4278	//===================================================
4279	// CLASS LinearScale
4280	// Description: Handle linear scaling between screen and world
4281	//===================================================
4282	class LinearScale {
4283	public $textscale=false; // Just a flag to let the Plot class find out if
4284	// we are a textscale or not. This is a cludge since
4285	// this information is available in Graph::axtype but
4286	// we don't have access to the graph object in the Plots
4287	// stroke method. So we let graph store the status here
4288	// when the linear scale is created. A real cludge...
4289	public $type; // is this x or y scale ?
4290	public $ticks=null; // Store ticks
4291	public $text_scale_off = 0;
4292	public $scale_abs=array(0,0);
4293	public $scale_factor; // Scale factor between world and screen
4294	public $off; // Offset between image edge and plot area
4295	public $scale=array(0,0);
4296	public $name = 'lin';
4297	public $auto_ticks=false; // When using manual scale should the ticks be automatically set?
4298	public $world_abs_size; // Plot area size in pixels (Needed public in jpgraph_radar.php)
4299	public $world_size; // Plot area size in world coordinates
4300	public $intscale=false; // Restrict autoscale to integers
4301	protected $autoscale_min=false; // Forced minimum value, auto determine max
4302	protected $autoscale_max=false; // Forced maximum value, auto determine min
4303	private $gracetop=0,$gracebottom=0;
4304	//---------------
4305	// CONSTRUCTOR
4306	function LinearScale($aMin=0,$aMax=0,$aType="y") {
4307	assert($aType=="x" \|\| $aType=="y" );
4308	assert($aMin<=$aMax);
4309
4310	$this->type=$aType;
4311	$this->scale=array($aMin,$aMax);
4312	$this->world_size=$aMax-$aMin;
4313	$this->ticks = new LinearTicks();
4314	}
4315
4316	//---------------
4317	// PUBLIC METHODS
4318	// Check if scale is set or if we should autoscale
4319	// We should do this is either scale or ticks has not been set
4320	function IsSpecified() {
4321	if( $this->GetMinVal()==$this->GetMaxVal() ) { // Scale not set
4322	return false;
4323	}
4324	return true;
4325	}
4326
4327	// Set the minimum data value when the autoscaling is used.
4328	// Usefull if you want a fix minimum (like 0) but have an
4329	// automatic maximum
4330	function SetAutoMin($aMin) {
4331	$this->autoscale_min=$aMin;
4332	}
4333
4334	// Set the minimum data value when the autoscaling is used.
4335	// Usefull if you want a fix minimum (like 0) but have an
4336	// automatic maximum
4337	function SetAutoMax($aMax) {
4338	$this->autoscale_max=$aMax;
4339	}
4340
4341	// If the user manually specifies a scale should the ticks
4342	// still be set automatically?
4343	function SetAutoTicks($aFlag=true) {
4344	$this->auto_ticks = $aFlag;
4345	}
4346
4347	// Specify scale "grace" value (top and bottom)
4348	function SetGrace($aGraceTop,$aGraceBottom=0) {
4349	if( $aGraceTop<0 \|\| $aGraceBottom < 0 )
4350	JpGraphError::RaiseL(25069);//(" Grace must be larger then 0");
4351	$this->gracetop=$aGraceTop;
4352	$this->gracebottom=$aGraceBottom;
4353	}
4354
4355	// Get the minimum value in the scale
4356	function GetMinVal() {
4357	return $this->scale[0];
4358	}
4359
4360	// get maximum value for scale
4361	function GetMaxVal() {
4362	return $this->scale[1];
4363	}
4364
4365	// Specify a new min/max value for sclae
4366	function Update($aImg,$aMin,$aMax) {
4367	$this->scale=array($aMin,$aMax);
4368	$this->world_size=$aMax-$aMin;
4369	$this->InitConstants($aImg);
4370	}
4371
4372	// Translate between world and screen
4373	function Translate($aCoord) {
4374	if( !is_numeric($aCoord) ) {
4375	if( $aCoord != '' && $aCoord != '-' && $aCoord != 'x' )
4376	JpGraphError::RaiseL(25070);//('Your data contains non-numeric values.');
4377	return 0;
4378	}
4379	else {
4380	return $this->off+($aCoord - $this->scale[0]) * $this->scale_factor;
4381	}
4382	}
4383
4384	// Relative translate (don't include offset) usefull when we just want
4385	// to know the relative position (in pixels) on the axis
4386	function RelTranslate($aCoord) {
4387	if( !is_numeric($aCoord) ) {
4388	if( $aCoord != '' && $aCoord != '-' && $aCoord != 'x' )
4389	JpGraphError::RaiseL(25070);//('Your data contains non-numeric values.');
4390	return 0;
4391	}
4392	else {
4393	return ($aCoord - $this->scale[0]) * $this->scale_factor;
4394	}
4395	}
4396
4397	// Restrict autoscaling to only use integers
4398	function SetIntScale($aIntScale=true) {
4399	$this->intscale=$aIntScale;
4400	}
4401
4402	// Calculate an integer autoscale
4403	function IntAutoScale($img,$min,$max,$maxsteps,$majend=true) {
4404	// Make sure limits are integers
4405	$min=floor($min);
4406	$max=ceil($max);
4407	if( abs($min-$max)==0 ) {
4408	--$min; ++$max;
4409	}
4410	$maxsteps = floor($maxsteps);
4411
4412	$gracetop=round(($this->gracetop/100.0)*abs($max-$min));
4413	$gracebottom=round(($this->gracebottom/100.0)*abs($max-$min));
4414	if( is_numeric($this->autoscale_min) ) {
4415	$min = ceil($this->autoscale_min);
4416	if( $min >= $max ) {
4417	JpGraphError::RaiseL(25071);//('You have specified a min value with SetAutoMin() which is larger than the maximum value used for the scale. This is not possible.');
4418	}
4419	}
4420
4421	if( is_numeric($this->autoscale_max) ) {
4422	$max = ceil($this->autoscale_max);
4423	if( $min >= $max ) {
4424	JpGraphError::RaiseL(25072);//('You have specified a max value with SetAutoMax() which is smaller than the miminum value used for the scale. This is not possible.');
4425	}
4426	}
4427
4428	if( abs($min-$max ) == 0 ) {
4429	++$max;
4430	--$min;
4431	}
4432
4433	$min -= $gracebottom;
4434	$max += $gracetop;
4435
4436	// First get tickmarks as multiples of 1, 10, ...
4437	if( $majend ) {
4438	list($num1steps,$adj1min,$adj1max,$maj1step) =
4439	$this->IntCalcTicks($maxsteps,$min,$max,1);
4440	}
4441	else {
4442	$adj1min = $min;
4443	$adj1max = $max;
4444	list($num1steps,$maj1step) =
4445	$this->IntCalcTicksFreeze($maxsteps,$min,$max,1);
4446	}
4447
4448	if( abs($min-$max) > 2 ) {
4449	// Then get tick marks as 2:s 2, 20, ...
4450	if( $majend ) {
4451	list($num2steps,$adj2min,$adj2max,$maj2step) =
4452	$this->IntCalcTicks($maxsteps,$min,$max,5);
4453	}
4454	else {
4455	$adj2min = $min;
4456	$adj2max = $max;
4457	list($num2steps,$maj2step) =
4458	$this->IntCalcTicksFreeze($maxsteps,$min,$max,5);
4459	}
4460	}
4461	else {
4462	$num2steps = 10000; // Dummy high value so we don't choose this
4463	}
4464
4465	if( abs($min-$max) > 5 ) {
4466	// Then get tickmarks as 5:s 5, 50, 500, ...
4467	if( $majend ) {
4468	list($num5steps,$adj5min,$adj5max,$maj5step) =
4469	$this->IntCalcTicks($maxsteps,$min,$max,2);
4470	}
4471	else {
4472	$adj5min = $min;
4473	$adj5max = $max;
4474	list($num5steps,$maj5step) =
4475	$this->IntCalcTicksFreeze($maxsteps,$min,$max,2);
4476	}
4477	}
4478	else {
4479	$num5steps = 10000; // Dummy high value so we don't choose this
4480	}
4481
4482	// Check to see whichof 1:s, 2:s or 5:s fit better with
4483	// the requested number of major ticks
4484	$match1=abs($num1steps-$maxsteps);
4485	$match2=abs($num2steps-$maxsteps);
4486	if( !empty($maj5step) && $maj5step > 1 )
4487	$match5=abs($num5steps-$maxsteps);
4488	else
4489	$match5=10000; // Dummy high value
4490
4491	// Compare these three values and see which is the closest match
4492	// We use a 0.6 weight to gravitate towards multiple of 5:s
4493	if( $match1 < $match2 ) {
4494	if( $match1 < $match5 )
4495	$r=1;
4496	else
4497	$r=3;
4498	}
4499	else {
4500	if( $match2 < $match5 )
4501	$r=2;
4502	else
4503	$r=3;
4504	}
4505	// Minsteps are always the same as maxsteps for integer scale
4506	switch( $r ) {
4507	case 1:
4508	$this->ticks->Set($maj1step,$maj1step);
4509	$this->Update($img,$adj1min,$adj1max);
4510	break;
4511	case 2:
4512	$this->ticks->Set($maj2step,$maj2step);
4513	$this->Update($img,$adj2min,$adj2max);
4514	break;
4515	case 3:
4516	$this->ticks->Set($maj5step,$maj5step);
4517	$this->Update($img,$adj5min,$adj5max);
4518	break;
4519	default:
4520	JpGraphError::RaiseL(25073,$r);//('Internal error. Integer scale algorithm comparison out of bound (r=$r)');
4521	}
4522	}
4523
4524
4525	// Calculate autoscale. Used if user hasn't given a scale and ticks
4526	// $maxsteps is the maximum number of major tickmarks allowed.
4527	function AutoScale($img,$min,$max,$maxsteps,$majend=true) {
4528	if( $this->intscale ) {
4529	$this->IntAutoScale($img,$min,$max,$maxsteps,$majend);
4530	return;
4531	}
4532	if( abs($min-$max) < 0.00001 ) {
4533	// We need some difference to be able to autoscale
4534	// make it 5% above and 5% below value
4535	if( $min==0 && $max==0 ) { // Special case
4536	$min=-1; $max=1;
4537	}
4538	else {
4539	$delta = (abs($max)+abs($min))*0.005;
4540	$min -= $delta;
4541	$max += $delta;
4542	}
4543	}
4544
4545	$gracetop=($this->gracetop/100.0)*abs($max-$min);
4546	$gracebottom=($this->gracebottom/100.0)*abs($max-$min);
4547	if( is_numeric($this->autoscale_min) ) {
4548	$min = $this->autoscale_min;
4549	if( $min >= $max ) {
4550	JpGraphError::RaiseL(25071);//('You have specified a min value with SetAutoMin() which is larger than the maximum value used for the scale. This is not possible.');
4551	}
4552	if( abs($min-$max ) < 0.00001 )
4553	$max *= 1.2;
4554	}
4555
4556	if( is_numeric($this->autoscale_max) ) {
4557	$max = $this->autoscale_max;
4558	if( $min >= $max ) {
4559	JpGraphError::RaiseL(25072);//('You have specified a max value with SetAutoMax() which is smaller than the miminum value used for the scale. This is not possible.');
4560	}
4561	if( abs($min-$max ) < 0.00001 )
4562	$min *= 0.8;
4563	}
4564
4565	$min -= $gracebottom;
4566	$max += $gracetop;
4567
4568
4569	// First get tickmarks as multiples of 0.1, 1, 10, ...
4570	if( $majend ) {
4571	list($num1steps,$adj1min,$adj1max,$min1step,$maj1step) =
4572	$this->CalcTicks($maxsteps,$min,$max,1,2);
4573	}
4574	else {
4575	$adj1min=$min;
4576	$adj1max=$max;
4577	list($num1steps,$min1step,$maj1step) =
4578	$this->CalcTicksFreeze($maxsteps,$min,$max,1,2,false);
4579	}
4580
4581	// Then get tick marks as 2:s 0.2, 2, 20, ...
4582	if( $majend ) {
4583	list($num2steps,$adj2min,$adj2max,$min2step,$maj2step) =
4584	$this->CalcTicks($maxsteps,$min,$max,5,2);
4585	}
4586	else {
4587	$adj2min=$min;
4588	$adj2max=$max;
4589	list($num2steps,$min2step,$maj2step) =
4590	$this->CalcTicksFreeze($maxsteps,$min,$max,5,2,false);
4591	}
4592
4593	// Then get tickmarks as 5:s 0.05, 0.5, 5, 50, ...
4594	if( $majend ) {
4595	list($num5steps,$adj5min,$adj5max,$min5step,$maj5step) =
4596	$this->CalcTicks($maxsteps,$min,$max,2,5);
4597	}
4598	else {
4599	$adj5min=$min;
4600	$adj5max=$max;
4601	list($num5steps,$min5step,$maj5step) =
4602	$this->CalcTicksFreeze($maxsteps,$min,$max,2,5,false);
4603	}
4604
4605	// Check to see whichof 1:s, 2:s or 5:s fit better with
4606	// the requested number of major ticks
4607	$match1=abs($num1steps-$maxsteps);
4608	$match2=abs($num2steps-$maxsteps);
4609	$match5=abs($num5steps-$maxsteps);
4610	// Compare these three values and see which is the closest match
4611	// We use a 0.8 weight to gravitate towards multiple of 5:s
4612	$r=$this->MatchMin3($match1,$match2,$match5,0.8);
4613	switch( $r ) {
4614	case 1:
4615	$this->Update($img,$adj1min,$adj1max);
4616	$this->ticks->Set($maj1step,$min1step);
4617	break;
4618	case 2:
4619	$this->Update($img,$adj2min,$adj2max);
4620	$this->ticks->Set($maj2step,$min2step);
4621	break;
4622	case 3:
4623	$this->Update($img,$adj5min,$adj5max);
4624	$this->ticks->Set($maj5step,$min5step);
4625	break;
4626	}
4627	}
4628
4629	//---------------
4630	// PRIVATE METHODS
4631
4632	// This method recalculates all constants that are depending on the
4633	// margins in the image. If the margins in the image are changed
4634	// this method should be called for every scale that is registred with
4635	// that image. Should really be installed as an observer of that image.
4636	function InitConstants($img) {
4637	if( $this->type=="x" ) {
4638	$this->world_abs_size=$img->width - $img->left_margin - $img->right_margin;
4639	$this->off=$img->left_margin;
4640	$this->scale_factor = 0;
4641	if( $this->world_size > 0 )
4642	$this->scale_factor=$this->world_abs_size/($this->world_size*1.0);
4643	}
4644	else { // y scale
4645	$this->world_abs_size=$img->height - $img->top_margin - $img->bottom_margin;
4646	$this->off=$img->top_margin+$this->world_abs_size;
4647	$this->scale_factor = 0;
4648	if( $this->world_size > 0 )
4649	$this->scale_factor=-$this->world_abs_size/($this->world_size*1.0);
4650	}
4651	$size = $this->world_size * $this->scale_factor;
4652	$this->scale_abs=array($this->off,$this->off + $size);
4653	}
4654
4655	// Initialize the conversion constants for this scale
4656	// This tries to pre-calculate as much as possible to speed up the
4657	// actual conversion (with Translate()) later on
4658	// $start =scale start in absolute pixels (for x-scale this is an y-position
4659	// and for an y-scale this is an x-position
4660	// $len =absolute length in pixels of scale
4661	function SetConstants($aStart,$aLen) {
4662	$this->world_abs_size=$aLen;
4663	$this->off=$aStart;
4664
4665	if( $this->world_size<=0 ) {
4666	// This should never ever happen !!
4667	JpGraphError::RaiseL(25074);
4668	//("You have unfortunately stumbled upon a bug in JpGraph. It seems like the scale range is ".$this->world_size." [for ".$this->type." scale] <br> Please report Bug #01 to jpgraph@aditus.nu and include the script that gave this error. This problem could potentially be caused by trying to use \"illegal\" values in the input data arrays (like trying to send in strings or only NULL values) which causes the autoscaling to fail.");
4669
4670	}
4671
4672	// scale_factor = number of pixels per world unit
4673	$this->scale_factor=$this->world_abs_size/($this->world_size*1.0);
4674
4675	// scale_abs = start and end points of scale in absolute pixels
4676	$this->scale_abs=array($this->off,$this->off+$this->world_size*$this->scale_factor);
4677	}
4678
4679
4680	// Calculate number of ticks steps with a specific division
4681	// $a is the divisor of 10**x to generate the first maj tick intervall
4682	// $a=1, $b=2 give major ticks with multiple of 10, ...,0.1,1,10,...
4683	// $a=5, $b=2 give major ticks with multiple of 2:s ...,0.2,2,20,...
4684	// $a=2, $b=5 give major ticks with multiple of 5:s ...,0.5,5,50,...
4685	// We return a vector of
4686	// [$numsteps,$adjmin,$adjmax,$minstep,$majstep]
4687	// If $majend==true then the first and last marks on the axis will be major
4688	// labeled tick marks otherwise it will be adjusted to the closest min tick mark
4689	function CalcTicks($maxsteps,$min,$max,$a,$b,$majend=true) {
4690	$diff=$max-$min;
4691	if( $diff==0 )
4692	$ld=0;
4693	else
4694	$ld=floor(log10($diff));
4695
4696	// Gravitate min towards zero if we are close
4697	if( $min>0 && $min < pow(10,$ld) ) $min=0;
4698
4699	//$majstep=pow(10,$ld-1)/$a;
4700	$majstep=pow(10,$ld)/$a;
4701	$minstep=$majstep/$b;
4702
4703	$adjmax=ceil($max/$minstep)*$minstep;
4704	$adjmin=floor($min/$minstep)*$minstep;
4705	$adjdiff = $adjmax-$adjmin;
4706	$numsteps=$adjdiff/$majstep;
4707
4708	while( $numsteps>$maxsteps ) {
4709	$majstep=pow(10,$ld)/$a;
4710	$numsteps=$adjdiff/$majstep;
4711	++$ld;
4712	}
4713
4714	$minstep=$majstep/$b;
4715	$adjmin=floor($min/$minstep)*$minstep;
4716	$adjdiff = $adjmax-$adjmin;
4717	if( $majend ) {
4718	$adjmin = floor($min/$majstep)*$majstep;
4719	$adjdiff = $adjmax-$adjmin;
4720	$adjmax = ceil($adjdiff/$majstep)*$majstep+$adjmin;
4721	}
4722	else
4723	$adjmax=ceil($max/$minstep)*$minstep;
4724
4725	return array($numsteps,$adjmin,$adjmax,$minstep,$majstep);
4726	}
4727
4728	function CalcTicksFreeze($maxsteps,$min,$max,$a,$b) {
4729	// Same as CalcTicks but don't adjust min/max values
4730	$diff=$max-$min;
4731	if( $diff==0 )
4732	$ld=0;
4733	else
4734	$ld=floor(log10($diff));
4735
4736	//$majstep=pow(10,$ld-1)/$a;
4737	$majstep=pow(10,$ld)/$a;
4738	$minstep=$majstep/$b;
4739	$numsteps=floor($diff/$majstep);
4740
4741	while( $numsteps > $maxsteps ) {
4742	$majstep=pow(10,$ld)/$a;
4743	$numsteps=floor($diff/$majstep);
4744	++$ld;
4745	}
4746	$minstep=$majstep/$b;
4747	return array($numsteps,$minstep,$majstep);
4748	}
4749
4750
4751	function IntCalcTicks($maxsteps,$min,$max,$a,$majend=true) {
4752	$diff=$max-$min;
4753	if( $diff==0 )
4754	JpGraphError::RaiseL(25075);//('Can\'t automatically determine ticks since min==max.');
4755	else
4756	$ld=floor(log10($diff));
4757
4758	// Gravitate min towards zero if we are close
4759	if( $min>0 && $min < pow(10,$ld) ) $min=0;
4760
4761	if( $ld == 0 ) $ld=1;
4762
4763	if( $a == 1 )
4764	$majstep = 1;
4765	else
4766	$majstep=pow(10,$ld)/$a;
4767	$adjmax=ceil($max/$majstep)*$majstep;
4768
4769	$adjmin=floor($min/$majstep)*$majstep;
4770	$adjdiff = $adjmax-$adjmin;
4771	$numsteps=$adjdiff/$majstep;
4772	while( $numsteps>$maxsteps ) {
4773	$majstep=pow(10,$ld)/$a;
4774	$numsteps=$adjdiff/$majstep;
4775	++$ld;
4776	}
4777
4778	$adjmin=floor($min/$majstep)*$majstep;
4779	$adjdiff = $adjmax-$adjmin;
4780	if( $majend ) {
4781	$adjmin = floor($min/$majstep)*$majstep;
4782	$adjdiff = $adjmax-$adjmin;
4783	$adjmax = ceil($adjdiff/$majstep)*$majstep+$adjmin;
4784	}
4785	else
4786	$adjmax=ceil($max/$majstep)*$majstep;
4787
4788	return array($numsteps,$adjmin,$adjmax,$majstep);
4789	}
4790
4791
4792	function IntCalcTicksFreeze($maxsteps,$min,$max,$a) {
4793	// Same as IntCalcTick but don't change min/max values
4794	$diff=$max-$min;
4795	if( $diff==0 )
4796	JpGraphError::RaiseL(25075);//('Can\'t automatically determine ticks since min==max.');
4797	else
4798	$ld=floor(log10($diff));
4799
4800	if( $ld == 0 ) $ld=1;
4801
4802	if( $a == 1 )
4803	$majstep = 1;
4804	else
4805	$majstep=pow(10,$ld)/$a;
4806
4807	$numsteps=floor($diff/$majstep);
4808	while( $numsteps > $maxsteps ) {
4809	$majstep=pow(10,$ld)/$a;
4810	$numsteps=floor($diff/$majstep);
4811	++$ld;
4812	}
4813
4814	return array($numsteps,$majstep);
4815	}
4816
4817
4818
4819	// Determine the minimum of three values witha weight for last value
4820	function MatchMin3($a,$b,$c,$weight) {
4821	if( $a < $b ) {
4822	if( $a < ($c*$weight) )
4823	return 1; // $a smallest
4824	else
4825	return 3; // $c smallest
4826	}
4827	elseif( $b < ($c*$weight) )
4828	return 2; // $b smallest
4829	return 3; // $c smallest
4830	}
4831	} // Class
4832
4833
4834	//===================================================
4835	// CLASS DisplayValue
4836	// Description: Used to print data values at data points
4837	//===================================================
4838	class DisplayValue {
4839	public $margin=5;
4840	public $show=false;
4841	public $valign="",$halign="center";
4842	public $format="%.1f",$negformat="";
4843	private $ff=FF_FONT1,$fs=FS_NORMAL,$fsize=10;
4844	private $iFormCallback='';
4845	private $angle=0;
4846	private $color="navy",$negcolor="";
4847	private $iHideZero=false;
4848
4849	function Show($aFlag=true) {
4850	$this->show=$aFlag;
4851	}
4852
4853	function SetColor($aColor,$aNegcolor="") {
4854	$this->color = $aColor;
4855	$this->negcolor = $aNegcolor;
4856	}
4857
4858	function SetFont($aFontFamily,$aFontStyle=FS_NORMAL,$aFontSize=10) {
4859	$this->ff=$aFontFamily;
4860	$this->fs=$aFontStyle;
4861	$this->fsize=$aFontSize;
4862	}
4863
4864	function ApplyFont($aImg) {
4865	$aImg->SetFont($this->ff,$this->fs,$this->fsize);
4866	}
4867
4868	function SetMargin($aMargin) {
4869	$this->margin = $aMargin;
4870	}
4871
4872	function SetAngle($aAngle) {
4873	$this->angle = $aAngle;
4874	}
4875
4876	function SetAlign($aHAlign,$aVAlign='') {
4877	$this->halign = $aHAlign;
4878	$this->valign = $aVAlign;
4879	}
4880
4881	function SetFormat($aFormat,$aNegFormat="") {
4882	$this->format= $aFormat;
4883	$this->negformat= $aNegFormat;
4884	}
4885
4886	function SetFormatCallback($aFunc) {
4887	$this->iFormCallback = $aFunc;
4888	}
4889
4890	function HideZero($aFlag=true) {
4891	$this->iHideZero=$aFlag;
4892	}
4893
4894	function Stroke($img,$aVal,$x,$y) {
4895
4896	if( $this->show )
4897	{
4898	if( $this->negformat=="" ) $this->negformat=$this->format;
4899	if( $this->negcolor=="" ) $this->negcolor=$this->color;
4900
4901	if( $aVal===NULL \|\| (is_string($aVal) && ($aVal=="" \|\| $aVal=="-" \|\| $aVal=="x" ) ) )
4902	return;
4903
4904	if( is_numeric($aVal) && $aVal==0 && $this->iHideZero ) {
4905	return;
4906	}
4907
4908	// Since the value is used in different cirumstances we need to check what
4909	// kind of formatting we shall use. For example, to display values in a line
4910	// graph we simply display the formatted value, but in the case where the user
4911	// has already specified a text string we don't fo anything.
4912	if( $this->iFormCallback != '' ) {
4913	$f = $this->iFormCallback;
4914	$sval = call_user_func($f,$aVal);
4915	}
4916	elseif( is_numeric($aVal) ) {
4917	if( $aVal >= 0 )
4918	$sval=sprintf($this->format,$aVal);
4919	else
4920	$sval=sprintf($this->negformat,$aVal);
4921	}
4922	else
4923	$sval=$aVal;
4924
4925	$y = $y-sign($aVal)*$this->margin;
4926
4927	$txt = new Text($sval,$x,$y);
4928	$txt->SetFont($this->ff,$this->fs,$this->fsize);
4929	if( $this->valign == "" ) {
4930	if( $aVal >= 0 )
4931	$valign = "bottom";
4932	else
4933	$valign = "top";
4934	}
4935	else
4936	$valign = $this->valign;
4937	$txt->Align($this->halign,$valign);
4938
4939	$txt->SetOrientation($this->angle);
4940	if( $aVal > 0 )
4941	$txt->SetColor($this->color);
4942	else
4943	$txt->SetColor($this->negcolor);
4944	$txt->Stroke($img);
4945	}
4946	}
4947	}
4948
4949	//===================================================
4950	// CLASS Plot
4951	// Description: Abstract base class for all concrete plot classes
4952	//===================================================
4953	class Plot {
4954	public $numpoints=0;
4955	public $value;
4956	public $legend='';
4957	public $coords=array();
4958	public $color="black";
4959	public $hidelegend=false;
4960	public $line_weight=1;
4961	public $csimtargets=array(),$csimwintargets=array(); // Array of targets for CSIM
4962	public $csimareas=""; // Resultant CSIM area tags
4963	public $csimalts=null; // ALT:s for corresponding target
4964	public $legendcsimtarget='',$legendcsimwintarget='';
4965	public $legendcsimalt='';
4966	protected $weight=1;
4967	protected $center=false;
4968	//---------------
4969	// CONSTRUCTOR
4970	function Plot($aDatay,$aDatax=false) {
4971	$this->numpoints = count($aDatay);
4972	if( $this->numpoints==0 )
4973	JpGraphError::RaiseL(25121);//("Empty input data array specified for plot. Must have at least one data point.");
4974	$this->coords[0]=$aDatay;
4975	if( is_array($aDatax) ) {
4976	$this->coords[1]=$aDatax;
4977	$n = count($aDatax);
4978	for($i=0; $i < $n; ++$i ) {
4979	if( !is_numeric($aDatax[$i]) ) {
4980	JpGraphError::RaiseL(25070);
4981	}
4982	}
4983	}
4984	$this->value = new DisplayValue();
4985	}
4986
4987	//---------------
4988	// PUBLIC METHODS
4989
4990	// Stroke the plot
4991	// "virtual" function which must be implemented by
4992	// the subclasses
4993	function Stroke($aImg,$aXScale,$aYScale) {
4994	JpGraphError::RaiseL(25122);//("JpGraph: Stroke() must be implemented by concrete subclass to class Plot");
4995	}
4996
4997	function HideLegend($f=true) {
4998	$this->hidelegend = $f;
4999	}
5000
5001	function DoLegend($graph) {
5002	if( !$this->hidelegend )
5003	$this->Legend($graph);
5004	}
5005
5006	function StrokeDataValue($img,$aVal,$x,$y) {
5007	$this->value->Stroke($img,$aVal,$x,$y);
5008	}
5009
5010	// Set href targets for CSIM
5011	function SetCSIMTargets($aTargets,$aAlts='',$aWinTargets='') {
5012	$this->csimtargets=$aTargets;
5013	$this->csimwintargets=$aWinTargets;
5014	$this->csimalts=$aAlts;
5015	}
5016
5017	// Get all created areas
5018	function GetCSIMareas() {
5019	return $this->csimareas;
5020	}
5021
5022	// "Virtual" function which gets called before any scale
5023	// or axis are stroked used to do any plot specific adjustment
5024	function PreStrokeAdjust($aGraph) {
5025	if( substr($aGraph->axtype,0,4) == "text" && (isset($this->coords[1])) )
5026	JpGraphError::RaiseL(25123);//("JpGraph: You can't use a text X-scale with specified X-coords. Use a \"int\" or \"lin\" scale instead.");
5027	return true;
5028	}
5029
5030	// Get minimum values in plot
5031	function Min() {
5032	if( isset($this->coords[1]) )
5033	$x=$this->coords[1];
5034	else
5035	$x="";
5036	if( $x != "" && count($x) > 0 ) {
5037	$xm=min($x);
5038	}
5039	else
5040	$xm=0;
5041	$y=$this->coords[0];
5042	$cnt = count($y);
5043	if( $cnt > 0 ) {
5044	/*
5045	if( ! isset($y[0]) ) {
5046	JpGraphError('The input data array must have consecutive values from position 0 and forward. The given y-array starts with empty values (NULL)');
5047	}
5048	$ym = $y[0];
5049	*/
5050	$i=0;
5051	while( $i<$cnt && !is_numeric($ym=$y[$i]) )
5052	$i++;
5053	while( $i < $cnt) {
5054	if( is_numeric($y[$i]) )
5055	$ym=min($ym,$y[$i]);
5056	++$i;
5057	}
5058	}
5059	else
5060	$ym="";
5061	return array($xm,$ym);
5062	}
5063
5064	// Get maximum value in plot
5065	function Max() {
5066	if( isset($this->coords[1]) )
5067	$x=$this->coords[1];
5068	else
5069	$x="";
5070
5071	if( $x!="" && count($x) > 0 )
5072	$xm=max($x);
5073	else {
5074	$xm = $this->numpoints-1;
5075	}
5076	$y=$this->coords[0];
5077	if( count($y) > 0 ) {
5078	/*
5079	if( !isset($y[0]) ) {
5080	JpGraphError::Raise('The input data array must have consecutive values from position 0 and forward. The given y-array starts with empty values (NULL)');
5081	// $y[0] = 0;
5082	// Change in 1.5.1 Don't treat this as an error any more. Just silently convert to 0
5083	// Change in 1.17 Treat his as an error again !! This is the right way to do !!
5084	}
5085	*/
5086	$cnt = count($y);
5087	$i=0;
5088	while( $i<$cnt && !is_numeric($ym=$y[$i]) )
5089	$i++;
5090	while( $i < $cnt ) {
5091	if( is_numeric($y[$i]) )
5092	$ym=max($ym,$y[$i]);
5093	++$i;
5094	}
5095	}
5096	else
5097	$ym="";
5098	return array($xm,$ym);
5099	}
5100
5101	function SetColor($aColor) {
5102	$this->color=$aColor;
5103	}
5104
5105	function SetLegend($aLegend,$aCSIM='',$aCSIMAlt='',$aCSIMWinTarget='') {
5106	$this->legend = $aLegend;
5107	$this->legendcsimtarget = $aCSIM;
5108	$this->legendcsimwintarget = $aCSIMWinTarget;
5109	$this->legendcsimalt = $aCSIMAlt;
5110	}
5111
5112	function SetWeight($aWeight) {
5113	$this->weight=$aWeight;
5114	}
5115
5116	function SetLineWeight($aWeight=1) {
5117	$this->line_weight=$aWeight;
5118	}
5119
5120	function SetCenter($aCenter=true) {
5121	$this->center = $aCenter;
5122	}
5123
5124	// This method gets called by Graph class to plot anything that should go
5125	// into the margin after the margin color has been set.
5126	function StrokeMargin($aImg) {
5127	return true;
5128	}
5129
5130	// Framework function the chance for each plot class to set a legend
5131	function Legend($aGraph) {
5132	if( $this->legend != "" )
5133	$aGraph->legend->Add($this->legend,$this->color,"",0,$this->legendcsimtarget,
5134	$this->legendcsimalt,$this->legendcsimwintarget);
5135	}
5136
5137	} // Class
5138
5139
5140	//===================================================
5141	// CLASS PlotLine
5142	// Description:
5143	// Data container class to hold properties for a static
5144	// line that is drawn directly in the plot area.
5145	// Usefull to add static borders inside a plot to show
5146	// for example set-values
5147	//===================================================
5148	class PlotLine {
5149	public $scaleposition, $direction=-1;
5150	protected $weight=1;
5151	protected $color="black";
5152	private $legend='',$hidelegend=false, $legendcsimtarget='', $legendcsimalt='',$legendcsimwintarget='';
5153	private $iLineStyle='solid';
5154
5155	//---------------
5156	// CONSTRUCTOR
5157	function PlotLine($aDir=HORIZONTAL,$aPos=0,$aColor="black",$aWeight=1) {
5158	$this->direction = $aDir;
5159	$this->color=$aColor;
5160	$this->weight=$aWeight;
5161	$this->scaleposition=$aPos;
5162	}
5163
5164	//---------------
5165	// PUBLIC METHODS
5166
5167	function SetLegend($aLegend,$aCSIM='',$aCSIMAlt='',$aCSIMWinTarget='') {
5168	$this->legend = $aLegend;
5169	$this->legendcsimtarget = $aCSIM;
5170	$this->legendcsimwintarget = $aCSIMWinTarget;
5171	$this->legendcsimalt = $aCSIMAlt;
5172	}
5173
5174	function HideLegend($f=true) {
5175	$this->hidelegend = $f;
5176	}
5177
5178	function SetPosition($aScalePosition) {
5179	$this->scaleposition=$aScalePosition;
5180	}
5181
5182	function SetDirection($aDir) {
5183	$this->direction = $aDir;
5184	}
5185
5186	function SetColor($aColor) {
5187	$this->color=$aColor;
5188	}
5189
5190	function SetWeight($aWeight) {
5191	$this->weight=$aWeight;
5192	}
5193
5194	function SetLineStyle($aStyle) {
5195	$this->iLineStyle = $aStyle;
5196	}
5197
5198	//---------------
5199	// PRIVATE METHODS
5200
5201	function DoLegend(&$graph) {
5202	if( !$this->hidelegend )
5203	$this->Legend($graph);
5204	}
5205
5206	// Framework function the chance for each plot class to set a legend
5207	function Legend(&$aGraph) {
5208	if( $this->legend != "" ) {
5209	$dummyPlotMark = new PlotMark();
5210	$lineStyle = 1;
5211	$aGraph->legend->Add($this->legend,$this->color,$dummyPlotMark,$lineStyle,
5212	$this->legendcsimtarget,$this->legendcsimalt,$this->legendcsimwintarget);
5213	}
5214	}
5215
5216	function PreStrokeAdjust($aGraph) {
5217	// Nothing to do
5218	}
5219
5220	function Stroke($aImg,$aXScale,$aYScale) {
5221	$aImg->SetColor($this->color);
5222	$aImg->SetLineWeight($this->weight);
5223	$oldStyle = $aImg->SetLineStyle($this->iLineStyle);
5224	if( $this->direction == VERTICAL ) {
5225	$ymin_abs=$aYScale->Translate($aYScale->GetMinVal());
5226	$ymax_abs=$aYScale->Translate($aYScale->GetMaxVal());
5227	$xpos_abs=$aXScale->Translate($this->scaleposition);
5228	$aImg->StyleLine($xpos_abs, $ymin_abs, $xpos_abs, $ymax_abs);
5229	}
5230	elseif( $this->direction == HORIZONTAL ) {
5231	$xmin_abs=$aXScale->Translate($aXScale->GetMinVal());
5232	$xmax_abs=$aXScale->Translate($aXScale->GetMaxVal());
5233	$ypos_abs=$aYScale->Translate($this->scaleposition);
5234	$aImg->StyleLine($xmin_abs, $ypos_abs, $xmax_abs, $ypos_abs);
5235	}
5236	else {
5237	JpGraphError::RaiseL(25125);//(" Illegal direction for static line");
5238	}
5239	$aImg->SetLineStyle($oldStyle);
5240	}
5241	}
5242
5243	// <EOF>
5244	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: