X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_graph.c;h=0279d49d524cbee22831a1546e6528b5195e8fea;hp=27627178a49747790fcf57ddcd332954ce6aebef;hb=99b9b7fd0cad0edea57c08fdf939d368c4c0ec45;hpb=7c88491f1f8cf72acdf6dca93c967f6b2fde91e9

diff --git a/src/rrd_graph.c b/src/rrd_graph.c
index 2762717..0279d49 100644
--- a/src/rrd_graph.c
+++ b/src/rrd_graph.c
@@ -1,41 +1,47 @@
 /****************************************************************************
- * RRDtool 1.1.x  Copyright Tobias Oetiker, 1997 - 2002
+ * RRDtool 1.2rc2  Copyright by Tobi Oetiker, 1997-2005
  ****************************************************************************
- * rrd__graph.c  make creates ne rrds
+ * rrd__graph.c  produce graphs from data in rrdfiles
  ****************************************************************************/
 
-#if 0
-#include "rrd_tool.h"
-#endif
 
 #include <sys/stat.h>
+
+#include "rrd_tool.h"
+
 #ifdef WIN32
 #include <io.h>
 #include <fcntl.h>
 #endif
 
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
+
 #include "rrd_graph.h"
-#include "rrd_graph_helper.h"
 
 /* some constant definitions */
 
 
-#ifndef RRD_DEFAULT_FONT
 #ifdef WIN32
-#define RRD_DEFAULT_FONT "c:/winnt/fonts/COUR.TTF"
-#else
-#define RRD_DEFAULT_FONT "/usr/share/fonts/truetype/openoffice/ariosor.ttf" 
-/* #define RRD_DEFAULT_FONT "/usr/share/fonts/truetype/Arial.ttf" */
-#endif
+char rrd_win_default_font[80];
 #endif
 
+#ifndef RRD_DEFAULT_FONT
+/* there is special code later to pick Cour.ttf when running on windows */
+#define RRD_DEFAULT_FONT "VeraMono.ttf"
+#endif
 
 text_prop_t text_prop[] = {   
-     { 10.0, RRD_DEFAULT_FONT }, /* default */
-     { 12.0, RRD_DEFAULT_FONT }, /* title */
-     { 8.0,  RRD_DEFAULT_FONT },  /* axis */
-     { 10.0, RRD_DEFAULT_FONT },  /* unit */
-     { 10.0, RRD_DEFAULT_FONT }  /* legend */
+     { 9.0, RRD_DEFAULT_FONT }, /* default */
+     { 11.0, RRD_DEFAULT_FONT }, /* title */
+     { 8.0,  RRD_DEFAULT_FONT }, /* axis */
+     { 9.0, RRD_DEFAULT_FONT }, /* unit */
+     { 9.0, RRD_DEFAULT_FONT }  /* legend */
 };
 
 xlab_t xlab[] = {
@@ -93,11 +99,11 @@ gfx_color_t graph_col[] =   /* default colors */
      0xF0F0F0FF,   /* background */
      0xD0D0D0FF,   /* shade A    */
      0xA0A0A0FF,   /* shade B    */
-     0x909090FF,   /* grid       */
-     0xE05050FF,   /* major grid */
+     0x90909080,   /* grid       */
+     0xE0505080,   /* major grid */
      0x000000FF,   /* font       */ 
-     0x000000FF,   /* frame      */
-     0xFF0000FF  /* arrow      */
+     0xFF0000FF,   /* arrow      */
+     0x404040FF    /* axis       */
 };
 
 
@@ -123,7 +129,7 @@ xtr(image_desc_t *im,time_t mytime){
 }
 
 /* translate data values into y coordinates */
-int
+double
 ytr(image_desc_t *im, double value){
     static double pixie;
     double yval;
@@ -134,26 +140,25 @@ ytr(image_desc_t *im, double value){
 	pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
       yval = im->yorigin;
     } else if(!im->logarithmic) {
-      yval = im->yorigin - pixie * (value - im->minval) + 0.5;
+      yval = im->yorigin - pixie * (value - im->minval);
     } else {
       if (value < im->minval) {
 	yval = im->yorigin;
       } else {
-	yval = im->yorigin - pixie * (log10(value) - log10(im->minval)) + 0.5;
+	yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
       }
     }
     /* make sure we don't return anything too unreasonable. GD lib can
        get terribly slow when drawing lines outside its scope. This is 
        especially problematic in connection with the rigid option */
     if (! im->rigid) {
-      return (int)yval;
-    } else if ((int)yval > im->yorigin) {
-      return im->yorigin+2;
-    } else if ((int) yval < im->yorigin - im->ysize){
-      return im->yorigin - im->ysize - 2;
-    } else {
-      return (int)yval;
+      /* keep yval as-is */
+    } else if (yval > im->yorigin) {
+      yval = im->yorigin+2;
+    } else if (yval < im->yorigin - im->ysize){
+      yval = im->yorigin - im->ysize - 2;
     } 
+    return yval;
 }
 
 
@@ -178,7 +183,11 @@ enum gf_en gf_conv(char *string){
     conv_if(DEF,GF_DEF)
     conv_if(CDEF,GF_CDEF)
     conv_if(VDEF,GF_VDEF)
+#ifdef WITH_PIECHART
     conv_if(PART,GF_PART)
+#endif
+    conv_if(XPORT,GF_XPORT)
+    conv_if(SHIFT,GF_SHIFT)
     
     return (-1);
 }
@@ -187,6 +196,8 @@ enum gfx_if_en if_conv(char *string){
     
     conv_if(PNG,IF_PNG)
     conv_if(SVG,IF_SVG)
+    conv_if(EPS,IF_EPS)
+    conv_if(PDF,IF_PDF)
 
     return (-1);
 }
@@ -212,8 +223,8 @@ enum grc_en grc_conv(char *string){
     conv_if(GRID,GRC_GRID)
     conv_if(MGRID,GRC_MGRID)
     conv_if(FONT,GRC_FONT)
-    conv_if(FRAME,GRC_FRAME)
     conv_if(ARROW,GRC_ARROW)
+    conv_if(AXIS,GRC_AXIS)
 
     return -1;	
 }
@@ -231,14 +242,13 @@ enum text_prop_en text_prop_conv(char *string){
 
 #undef conv_if
 
-
-
 int
 im_free(image_desc_t *im)
 {
-    long i,ii;
+    unsigned long	i,ii;
+
     if (im == NULL) return 0;
-    for(i=0;i<im->gdes_c;i++){
+    for(i=0;i<(unsigned)im->gdes_c;i++){
       if (im->gdes[i].data_first){
 	/* careful here, because a single pointer can occur several times */
 	  free (im->gdes[i].data);
@@ -431,7 +441,73 @@ expand_range(image_desc_t *im)
 #endif
 }
 
-    
+void
+apply_gridfit(image_desc_t *im)
+{
+  if (isnan(im->minval) || isnan(im->maxval))
+    return;
+  ytr(im,DNAN);
+  if (im->logarithmic) {
+    double ya, yb, ypix, ypixfrac;
+    double log10_range = log10(im->maxval) - log10(im->minval);
+    ya = pow((double)10, floor(log10(im->minval)));
+    while (ya < im->minval)
+      ya *= 10;
+    if (ya > im->maxval)
+      return; /* don't have y=10^x gridline */
+    yb = ya * 10;
+    if (yb <= im->maxval) {
+      /* we have at least 2 y=10^x gridlines.
+	 Make sure distance between them in pixels
+	 are an integer by expanding im->maxval */
+      double y_pixel_delta = ytr(im, ya) - ytr(im, yb);
+      double factor = y_pixel_delta / floor(y_pixel_delta);
+      double new_log10_range = factor * log10_range;
+      double new_ymax_log10 = log10(im->minval) + new_log10_range;
+      im->maxval = pow(10, new_ymax_log10);
+      ytr(im, DNAN); /* reset precalc */
+      log10_range = log10(im->maxval) - log10(im->minval);
+    }
+    /* make sure first y=10^x gridline is located on 
+       integer pixel position by moving scale slightly 
+       downwards (sub-pixel movement) */
+    ypix = ytr(im, ya) + im->ysize; /* add im->ysize so it always is positive */
+    ypixfrac = ypix - floor(ypix);
+    if (ypixfrac > 0 && ypixfrac < 1) {
+      double yfrac = ypixfrac / im->ysize;
+      im->minval = pow(10, log10(im->minval) - yfrac * log10_range);
+      im->maxval = pow(10, log10(im->maxval) - yfrac * log10_range);
+      ytr(im, DNAN); /* reset precalc */
+    }
+  } else {
+    /* Make sure we have an integer pixel distance between
+       each minor gridline */
+    double ypos1 = ytr(im, im->minval);
+    double ypos2 = ytr(im, im->minval + im->ygrid_scale.gridstep);
+    double y_pixel_delta = ypos1 - ypos2;
+    double factor = y_pixel_delta / floor(y_pixel_delta);
+    double new_range = factor * (im->maxval - im->minval);
+    double gridstep = im->ygrid_scale.gridstep;
+    double minor_y, minor_y_px, minor_y_px_frac;
+    im->maxval = im->minval + new_range;
+    ytr(im, DNAN); /* reset precalc */
+    /* make sure first minor gridline is on integer pixel y coord */
+    minor_y = gridstep * floor(im->minval / gridstep);
+    while (minor_y < im->minval)
+      minor_y += gridstep;
+    minor_y_px = ytr(im, minor_y) + im->ysize; /* ensure > 0 by adding ysize */
+    minor_y_px_frac = minor_y_px - floor(minor_y_px);
+    if (minor_y_px_frac > 0 && minor_y_px_frac < 1) {
+      double yfrac = minor_y_px_frac / im->ysize;
+      double range = im->maxval - im->minval;
+      im->minval = im->minval - yfrac * range;
+      im->maxval = im->maxval - yfrac * range;
+      ytr(im, DNAN); /* reset precalc */
+    }
+    calc_horizontal_grid(im); /* recalc with changed im->maxval */
+  }
+}
+
 /* reduce data reimplementation by Alex */
 
 void
@@ -525,7 +601,7 @@ printf("row_cnt after:   %lu\n",row_cnt);
     ** into one interval for the destination.
     */
 
-    for (dst_row=0;row_cnt>=reduce_factor;dst_row++) {
+    for (dst_row=0;(long int)row_cnt>=reduce_factor;dst_row++) {
 	for (col=0;col<(*ds_cnt);col++) {
 	    rrd_value_t newval=DNAN;
 	    unsigned long validval=0;
@@ -603,25 +679,31 @@ for (col=0;col<row_cnt;col++) {
    relevant rrds ... */
 
 int
-data_fetch( image_desc_t *im )
+data_fetch(image_desc_t *im )
 {
-    int       i,ii;
-    int skip;
+    int i,ii;
+    int		skip;
+
     /* pull the data from the log files ... */
-    for (i=0;i<im->gdes_c;i++){
+    for (i=0;i< (int)im->gdes_c;i++){
 	/* only GF_DEF elements fetch data */
 	if (im->gdes[i].gf != GF_DEF) 
 	    continue;
 
 	skip=0;
 	/* do we have it already ?*/
-	for (ii=0;ii<i;ii++){
+	for (ii=0;ii<i;ii++) {
 	    if (im->gdes[ii].gf != GF_DEF) 
 		continue;
-	    if((strcmp(im->gdes[i].rrd,im->gdes[ii].rrd) == 0)
-		&& (im->gdes[i].cf == im->gdes[ii].cf)){
-		/* OK the data it is here already ... 
-		 * we just copy the header portion */
+	    if ((strcmp(im->gdes[i].rrd, im->gdes[ii].rrd) == 0)
+			&& (im->gdes[i].cf    == im->gdes[ii].cf)
+			&& (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
+			&& (im->gdes[i].start == im->gdes[ii].start)
+			&& (im->gdes[i].end   == im->gdes[ii].end)
+			&& (im->gdes[i].step  == im->gdes[ii].step)) {
+		/* OK, the data is already there.
+		** Just copy the header portion
+		*/
 		im->gdes[i].start = im->gdes[ii].start;
 		im->gdes[i].end = im->gdes[ii].end;
 		im->gdes[i].step = im->gdes[ii].step;
@@ -648,9 +730,10 @@ data_fetch( image_desc_t *im )
 		return -1;
 	    }
 	    im->gdes[i].data_first = 1;	    
+	    im->gdes[i].step = im->step;
 	
 	    if (ft_step < im->gdes[i].step) {
-		reduce_data(im->gdes[i].cf,
+		reduce_data(im->gdes[i].cf_reduce,
 			    ft_step,
 			    &im->gdes[i].start,
 			    &im->gdes[i].end,
@@ -662,8 +745,8 @@ data_fetch( image_desc_t *im )
 	    }
 	}
 	
-        /* lets see if the required data source is realy there */
-	for(ii=0;ii<im->gdes[i].ds_cnt;ii++){
+        /* lets see if the required data source is really there */
+	for(ii=0;ii<(int)im->gdes[i].ds_cnt;ii++){
 	    if(strcmp(im->gdes[i].ds_namv[ii],im->gdes[i].ds_nam) == 0){
 		im->gdes[i].ds=ii; }
 	}
@@ -739,6 +822,30 @@ data_calc( image_desc_t *im){
 	 * so CDEFs can use VDEFs and vice versa
 	 */
 	switch (im->gdes[gdi].gf) {
+	    case GF_XPORT:
+	      break;
+	    case GF_SHIFT: {
+		graph_desc_t	*vdp = &im->gdes[im->gdes[gdi].vidx];
+		
+		/* remove current shift */
+		vdp->start -= vdp->shift;
+		vdp->end -= vdp->shift;
+		
+		/* vdef */
+		if (im->gdes[gdi].shidx >= 0) 
+			vdp->shift = im->gdes[im->gdes[gdi].shidx].vf.val;
+		/* constant */
+		else
+			vdp->shift = im->gdes[gdi].shval;
+
+		/* normalize shift to multiple of consolidated step */
+		vdp->shift = (vdp->shift / (long)vdp->step) * (long)vdp->step;
+
+		/* apply shift */
+		vdp->start += vdp->shift;
+		vdp->end += vdp->shift;
+		break;
+	    }
 	    case GF_VDEF:
 		/* A VDEF has no DS.  This also signals other parts
 		 * of rrdtool that this is a VDEF value, not a CDEF.
@@ -772,19 +879,22 @@ data_calc( image_desc_t *im){
 		 *   resulting data source.
 		 */
 		for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
-		    if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE){
+		if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE ||
+		   im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
 			long ptr = im->gdes[gdi].rpnp[rpi].ptr;
 			if (im->gdes[ptr].ds_cnt == 0) {
 #if 0
-printf("DEBUG: inside CDEF '%s' processing VDEF '%s'\n",
+			printf("DEBUG: inside CDEF '%s' processing VDEF '%s'\n",
 	im->gdes[gdi].vname,
 	im->gdes[ptr].vname);
-printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
+			printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 #endif
 			    im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
 			    im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
 			} else {
-			    if ((steparray = rrd_realloc(steparray, (++stepcnt+1)*sizeof(*steparray)))==NULL){
+			if ((steparray =
+				 rrd_realloc(steparray,
+							 (++stepcnt+1)*sizeof(*steparray)))==NULL){
 				rrd_set_error("realloc steparray");
 				rpnstack_free(&rpnstack);
 				return -1;
@@ -823,14 +933,15 @@ printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 
                 /* move the data pointers to the correct period */
                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
-                    if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE){
+		if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE ||
+		   im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
                         long ptr = im->gdes[gdi].rpnp[rpi].ptr;
-                        if(im->gdes[gdi].start > im->gdes[ptr].start) {
-                            im->gdes[gdi].rpnp[rpi].data += im->gdes[gdi].rpnp[rpi].ds_cnt;
-                        }
+			long diff = im->gdes[gdi].start - im->gdes[ptr].start;
+
+                        if(diff > 0)
+			    im->gdes[gdi].rpnp[rpi].data += (diff / im->gdes[ptr].step) * im->gdes[ptr].ds_cnt;
                      }
                 }
-        
 
 		if(steparray == NULL){
 		    rrd_set_error("rpn expressions without DEF"
@@ -895,67 +1006,73 @@ data_proc( image_desc_t *im ){
     unsigned long gr_time;    
 
     /* memory for the processed data */
-    for(i=0;i<im->gdes_c;i++){
-      if((im->gdes[i].gf==GF_LINE) ||
-	 (im->gdes[i].gf==GF_AREA) ||
-	 (im->gdes[i].gf==GF_TICK) ||
-	 (im->gdes[i].gf==GF_STACK)){
-	if((im->gdes[i].p_data = malloc((im->xsize +1)
+    for(i=0;i<im->gdes_c;i++) {
+	if((im->gdes[i].gf==GF_LINE) ||
+		(im->gdes[i].gf==GF_AREA) ||
+		(im->gdes[i].gf==GF_TICK) ||
+		(im->gdes[i].gf==GF_STACK)) {
+	    if((im->gdes[i].p_data = malloc((im->xsize +1)
 					* sizeof(rrd_value_t)))==NULL){
-	  rrd_set_error("malloc data_proc");
-	  return -1;
+		rrd_set_error("malloc data_proc");
+		return -1;
+	    }
 	}
-      }
     }
-    
-    for(i=0;i<im->xsize;i++){
+
+    for (i=0;i<im->xsize;i++) {	/* for each pixel */
 	long vidx;
-	gr_time = im->start+pixstep*i; /* time of the 
-					  current step */
+	gr_time = im->start+pixstep*i; /* time of the current step */
 	paintval=0.0;
 	
-	for(ii=0;ii<im->gdes_c;ii++){
-	  double value;
-	    switch(im->gdes[ii].gf){
-	    case GF_LINE:
-	    case GF_AREA:
+	for (ii=0;ii<im->gdes_c;ii++) {
+	    double value;
+	    switch (im->gdes[ii].gf) {
+		case GF_LINE:
+		case GF_AREA:
 		case GF_TICK:
-		paintval = 0.0;
-	    case GF_STACK:
-		vidx = im->gdes[ii].vidx;
-
-		value =
-		    im->gdes[vidx].data[
-			((unsigned long)floor(
-	(double)(gr_time-im->gdes[vidx].start) / im->gdes[vidx].step
-					     )
-                        )	*im->gdes[vidx].ds_cnt
-				+im->gdes[vidx].ds];
-
-		if (! isnan(value)) {
-		  paintval += value;
-		  im->gdes[ii].p_data[i] = paintval;
-		  /* GF_TICK: the data values are not relevant for min and max */
-		  if (finite(paintval) && im->gdes[ii].gf != GF_TICK ){
-  		   if (isnan(minval) || paintval <  minval)
-		     minval = paintval;
-		   if (isnan(maxval) || paintval >  maxval)
-		     maxval = paintval;
-		  }
-		} else {
-		  im->gdes[ii].p_data[i] = DNAN;
-		}
-		break;
-	    case GF_PRINT:
-	    case GF_GPRINT:
-	    case GF_COMMENT:
-	    case GF_HRULE:
-	    case GF_VRULE:
-	    case GF_DEF:	       
-	    case GF_CDEF:
-	    case GF_VDEF:
-	    case GF_PART:
-		break;
+		    if (!im->gdes[ii].stack)
+			paintval = 0.0;
+		case GF_STACK:
+		    value = im->gdes[ii].yrule;
+		    if (isnan(value) || (im->gdes[ii].gf == GF_TICK)) {
+			/* The time of the data doesn't necessarily match
+			** the time of the graph. Beware.
+			*/
+			vidx = im->gdes[ii].vidx;
+			if (im->gdes[vidx].gf == GF_VDEF) {
+			    value = im->gdes[vidx].vf.val;
+			} else if (((long int)gr_time >= (long int)im->gdes[vidx].start) &&
+				   ((long int)gr_time <= (long int)im->gdes[vidx].end) ) {
+			    value = im->gdes[vidx].data[
+				(unsigned long) floor(
+				    (double)(gr_time - im->gdes[vidx].start)
+						/ im->gdes[vidx].step)
+				* im->gdes[vidx].ds_cnt
+				+ im->gdes[vidx].ds
+			    ];
+			} else {
+			    value = DNAN;
+			}
+		    };
+
+		    if (! isnan(value)) {
+			paintval += value;
+			im->gdes[ii].p_data[i] = paintval;
+			/* GF_TICK: the data values are not
+			** relevant for min and max
+			*/
+			if (finite(paintval) && im->gdes[ii].gf != GF_TICK ) {
+			    if (isnan(minval) || paintval <  minval)
+				minval = paintval;
+			    if (isnan(maxval) || paintval >  maxval)
+				maxval = paintval;
+			}
+		    } else {
+			im->gdes[ii].p_data[i] = DNAN;
+		    }
+		    break;
+		default:
+		    break;
 	    }
 	}
     }
@@ -969,29 +1086,33 @@ data_proc( image_desc_t *im ){
     
     /* adjust min and max values */
     if (isnan(im->minval) 
-	|| ((!im->logarithmic && !im->rigid) /* don't adjust low-end with log scale */
-	    && im->minval > minval))
+	/* don't adjust low-end with log scale */
+	|| ((!im->logarithmic && !im->rigid) && im->minval > minval)
+	)
 	im->minval = minval;
     if (isnan(im->maxval) 
-	|| (!im->rigid 
-	    && im->maxval < maxval)){
+	|| (!im->rigid && im->maxval < maxval)
+	) {
 	if (im->logarithmic)
 	    im->maxval = maxval * 1.1;
 	else
 	    im->maxval = maxval;
     }
+    /* make sure min is smaller than max */
+    if (im->minval > im->maxval) {
+            im->minval = 0.99 * im->maxval;
+    }
+                      
     /* make sure min and max are not equal */
     if (im->minval == im->maxval) {
-      im->maxval *= 1.01; 
-      if (! im->logarithmic) {
-	im->minval *= 0.99;
-      }
-      
-      /* make sure min and max are not both zero */
-      if (im->maxval == 0.0) {
+	im->maxval *= 1.01; 
+	if (! im->logarithmic) {
+	    im->minval *= 0.99;
+	}
+	/* make sure min and max are not both zero */
+	if (im->maxval == 0.0) {
 	    im->maxval = 1.0;
-      }
-        
+	}
     }
     return 0;
 }
@@ -1008,7 +1129,7 @@ find_first_time(
     )
 {
     struct tm tm;
-    tm = *localtime(&start);
+    localtime_r(&start, &tm);
     switch(baseint){
     case TMT_SECOND:
 	tm.tm_sec -= tm.tm_sec % basestep; break;
@@ -1061,7 +1182,7 @@ find_next_time(
 {
     struct tm tm;
     time_t madetime;
-    tm = *localtime(&current);
+    localtime_r(&current, &tm);
     do {
 	switch(baseint){
 	case TMT_SECOND:
@@ -1166,14 +1287,15 @@ print_calc(image_desc_t *im, char ***prdata)
 	    } /* prepare printval */
 
 	    if (!strcmp(im->gdes[i].format,"%c")) { /* VDEF time print */
+		char ctime_buf[128]; /* PS: for ctime_r, must be >= 26 chars */
 		if (im->gdes[i].gf == GF_PRINT){
 		    (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
 		    sprintf((*prdata)[prlines-2],"%s (%lu)",
-					ctime(&printtime),printtime);
+					ctime_r(&printtime,ctime_buf),printtime);
 		    (*prdata)[prlines-1] = NULL;
 		} else {
 		    sprintf(im->gdes[i].legend,"%s (%lu)",
-					ctime(&printtime),printtime);
+					ctime_r(&printtime,ctime_buf),printtime);
 		    graphelement = 1;
 		}
 	    } else {
@@ -1197,8 +1319,9 @@ print_calc(image_desc_t *im, char ***prdata)
 
 	    if (im->gdes[i].gf == GF_PRINT){
 		(*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
+		(*prdata)[prlines-1] = NULL;
 		if (bad_format(im->gdes[i].format)) {
-			rrd_set_error("bad format for [G]PRINT in '%s'", im->gdes[i].format);
+			rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
 			return -1;
 		}
 #ifdef HAVE_SNPRINTF
@@ -1206,12 +1329,11 @@ print_calc(image_desc_t *im, char ***prdata)
 #else
 		sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
 #endif
-		(*prdata)[prlines-1] = NULL;
 	    } else {
 		/* GF_GPRINT */
 
 		if (bad_format(im->gdes[i].format)) {
-			rrd_set_error("bad format for [G]PRINT in '%s'", im->gdes[i].format);
+			rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
 			return -1;
 		}
 #ifdef HAVE_SNPRINTF
@@ -1235,7 +1357,11 @@ print_calc(image_desc_t *im, char ***prdata)
 	case GF_DEF:
 	case GF_CDEF:	    
 	case GF_VDEF:	    
+#ifdef WITH_PIECHART
 	case GF_PART:
+#endif
+	case GF_SHIFT:
+	case GF_XPORT:
 	    break;
 	}
     }
@@ -1249,7 +1375,6 @@ leg_place(image_desc_t *im)
 {
     /* graph labels */
     int   interleg = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
-    int   box =im->text_prop[TEXT_PROP_LEGEND].size*1.5;
     int   border = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
     int   fill=0, fill_last;
     int   leg_c = 0;
@@ -1260,7 +1385,7 @@ leg_place(image_desc_t *im)
     char  prt_fctn; /*special printfunctions */
     int  *legspace;
 
-  if( !(im->extra_flags & NOLEGEND) ) {
+  if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
     if ((legspace = malloc(im->gdes_c*sizeof(int)))==NULL){
        rrd_set_error("malloc for legspace");
        return -1;
@@ -1268,11 +1393,24 @@ leg_place(image_desc_t *im)
 
     for(i=0;i<im->gdes_c;i++){
 	fill_last = fill;
+        
+        /* hid legends for rules which are not displayed */
+        
+	if(!(im->extra_flags & FORCE_RULES_LEGEND)) {
+		if (im->gdes[i].gf == GF_HRULE &&
+		    (im->gdes[i].yrule < im->minval || im->gdes[i].yrule > im->maxval))
+		    im->gdes[i].legend[0] = '\0';
+
+		if (im->gdes[i].gf == GF_VRULE &&
+		    (im->gdes[i].xrule < im->start || im->gdes[i].xrule > im->end))
+		    im->gdes[i].legend[0] = '\0';
+	}
 
 	leg_cc = strlen(im->gdes[i].legend);
 	
 	/* is there a controle code ant the end of the legend string ? */ 
-	if (leg_cc >= 2 && im->gdes[i].legend[leg_cc-2] == '\\') {
+	/* and it is not a tab \\t */
+	if (leg_cc >= 2 && im->gdes[i].legend[leg_cc-2] == '\\' && im->gdes[i].legend[leg_cc-1] != 't') {
 	    prt_fctn = im->gdes[i].legend[leg_cc-1];
 	    leg_cc -= 2;
 	    im->gdes[i].legend[leg_cc] = '\0';
@@ -1293,15 +1431,11 @@ leg_place(image_desc_t *im)
  	       /* no interleg space if string ends in \g */
 	       fill += legspace[i];
 	    }
-	    if (im->gdes[i].gf != GF_GPRINT && 
-		im->gdes[i].gf != GF_COMMENT) { 
-		fill += box; 	   
-	    }
 	   fill += gfx_get_text_width(im->canvas, fill+border,
 				      im->text_prop[TEXT_PROP_LEGEND].font,
 				      im->text_prop[TEXT_PROP_LEGEND].size,
 				      im->tabwidth,
-				      im->gdes[i].legend);
+				      im->gdes[i].legend, 0);
 	    leg_c++;
 	} else {
 	   legspace[i]=0;
@@ -1329,7 +1463,7 @@ leg_place(image_desc_t *im)
 	}
 
 
-	if (prt_fctn != '\0'){
+	if (prt_fctn != '\0'){	
 	    leg_x = border;
 	    if (leg_c >= 2 && prt_fctn == 'j') {
 		glue = (im->ximg - fill - 2* border) / (leg_c-1);
@@ -1341,7 +1475,7 @@ leg_place(image_desc_t *im)
 
 	    for(ii=mark;ii<=i;ii++){
 		if(im->gdes[ii].legend[0]=='\0')
-		    continue;
+		    continue; /* skip empty legends */
 		im->gdes[ii].leg_x = leg_x;
 		im->gdes[ii].leg_y = leg_y;
 	        leg_x += 
@@ -1349,15 +1483,12 @@ leg_place(image_desc_t *im)
 				      im->text_prop[TEXT_PROP_LEGEND].font,
 				      im->text_prop[TEXT_PROP_LEGEND].size,
 				      im->tabwidth,
-				      im->gdes[ii].legend) 
+				      im->gdes[ii].legend, 0) 
 		   + legspace[ii]
 		   + glue;
-		if (im->gdes[ii].gf != GF_GPRINT && 
-		    im->gdes[ii].gf != GF_COMMENT) 
-		    leg_x += box; 	   
-	    }	    
-	    leg_y = leg_y + im->text_prop[TEXT_PROP_LEGEND].size*1.2;
-	    if (prt_fctn == 's') leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size*1.2;	   
+	    }	                
+	    leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.7;
+	    if (prt_fctn == 's') leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;	   
 	    fill = 0;
 	    leg_c = 0;
 	    mark = ii;
@@ -1378,21 +1509,15 @@ leg_place(image_desc_t *im)
 
 
 int
-horizontal_grid(image_desc_t   *im)
+calc_horizontal_grid(image_desc_t   *im)
 {
     double   range;
     double   scaledrange;
     int      pixel,i;
-    int      sgrid,egrid;
-    double   gridstep;
-    double   scaledstep;
-    char     graph_label[100];
-    double   X0,X1,Y0;
-    int      labfact,gridind;
+    int      gridind;
     int      decimals, fractionals;
-    char     labfmt[64];
 
-    labfact=2;
+    im->ygrid_scale.labfact=2;
     gridind=-1;
     range =  im->maxval - im->minval;
     scaledrange = range / im->magfact;
@@ -1414,25 +1539,25 @@ horizontal_grid(image_desc_t   *im)
 	    
 	    fractionals = floor(log10(range));
 	    if(fractionals < 0) /* small amplitude. */
-		sprintf(labfmt, "%%%d.%df", decimals - fractionals + 1, -fractionals + 1);
+		sprintf(im->ygrid_scale.labfmt, "%%%d.%df", decimals - fractionals + 1, -fractionals + 1);
 	    else
-		sprintf(labfmt, "%%%d.1f", decimals + 1);
-	    gridstep = pow((double)10, (double)fractionals);
-	    if(gridstep == 0) /* range is one -> 0.1 is reasonable scale */
-		gridstep = 0.1;
+		sprintf(im->ygrid_scale.labfmt, "%%%d.1f", decimals + 1);
+	    im->ygrid_scale.gridstep = pow((double)10, (double)fractionals);
+	    if(im->ygrid_scale.gridstep == 0) /* range is one -> 0.1 is reasonable scale */
+		im->ygrid_scale.gridstep = 0.1;
 	    /* should have at least 5 lines but no more then 15 */
-	    if(range/gridstep < 5)
-                gridstep /= 10;
-	    if(range/gridstep > 15)
-                gridstep *= 10;
-	    if(range/gridstep > 5) {
-		labfact = 1;
-		if(range/gridstep > 8)
-		    labfact = 2;
+	    if(range/im->ygrid_scale.gridstep < 5)
+                im->ygrid_scale.gridstep /= 10;
+	    if(range/im->ygrid_scale.gridstep > 15)
+                im->ygrid_scale.gridstep *= 10;
+	    if(range/im->ygrid_scale.gridstep > 5) {
+		im->ygrid_scale.labfact = 1;
+		if(range/im->ygrid_scale.gridstep > 8)
+		    im->ygrid_scale.labfact = 2;
 	    }
 	    else {
-		gridstep /= 5;
-		labfact = 5;
+		im->ygrid_scale.gridstep /= 5;
+		im->ygrid_scale.labfact = 5;
 	    }
 	}
 	else {
@@ -1446,33 +1571,40 @@ horizontal_grid(image_desc_t   *im)
 	    
 	    for(i=0; i<4;i++) {
 	       if (pixel * ylab[gridind].lfac[i] >=  2 * im->text_prop[TEXT_PROP_AXIS].size) {
-		  labfact =  ylab[gridind].lfac[i];
+		  im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
 		  break;
 	       }		          
 	    } 
 	    
-	    gridstep = ylab[gridind].grid * im->magfact;
+	    im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
 	}
     } else {
-	gridstep = im->ygridstep;
-	labfact = im->ylabfact;
+	im->ygrid_scale.gridstep = im->ygridstep;
+	im->ygrid_scale.labfact = im->ylabfact;
     }
-    
-   X0=im->xorigin;
-   X1=im->xorigin+im->xsize;
+    return 1;
+}
+
+int draw_horizontal_grid(image_desc_t *im)
+{
+    int      i;
+    double   scaledstep;
+    char     graph_label[100];
+    double X0=im->xorigin;
+    double X1=im->xorigin+im->xsize;
    
-    sgrid = (int)( im->minval / gridstep - 1);
-    egrid = (int)( im->maxval / gridstep + 1);
-    scaledstep = gridstep/im->magfact;
+    int sgrid = (int)( im->minval / im->ygrid_scale.gridstep - 1);
+    int egrid = (int)( im->maxval / im->ygrid_scale.gridstep + 1);
+    scaledstep = im->ygrid_scale.gridstep/im->magfact;
     for (i = sgrid; i <= egrid; i++){
-       Y0=ytr(im,gridstep*i);
+       double Y0=ytr(im,im->ygrid_scale.gridstep*i);
        if ( Y0 >= im->yorigin-im->ysize
 	         && Y0 <= im->yorigin){       
-	    if(i % labfact == 0){		
+	    if(i % im->ygrid_scale.labfact == 0){		
 		if (i==0 || im->symbol == ' ') {
 		    if(scaledstep < 1){
 			if(im->extra_flags & ALTYGRID) {
-			    sprintf(graph_label,labfmt,scaledstep*i);
+			    sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*i);
 			}
 			else {
 			    sprintf(graph_label,"%4.1f",scaledstep*i);
@@ -1495,16 +1627,18 @@ horizontal_grid(image_desc_t   *im)
 			      im->text_prop[TEXT_PROP_AXIS].size,
 			      im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
 			      graph_label );
-	       gfx_new_line ( im->canvas,
+	       gfx_new_dashed_line ( im->canvas,
 			      X0-2,Y0,
 			      X1+2,Y0,
-			      MGRIDWIDTH, im->graph_col[GRC_MGRID] );	       
+			      MGRIDWIDTH, im->graph_col[GRC_MGRID],
+			      im->grid_dash_on, im->grid_dash_off);	       
 	       
-	    } else {		
-	       gfx_new_line ( im->canvas,
+	    } else if (!(im->extra_flags & NOMINOR)) {		
+	       gfx_new_dashed_line ( im->canvas,
 			      X0-1,Y0,
 			      X1+1,Y0,
-			      GRIDWIDTH, im->graph_col[GRC_GRID] );	       
+			      GRIDWIDTH, im->graph_col[GRC_GRID],
+			      im->grid_dash_on, im->grid_dash_off);	       
 	       
 	    }	    
 	}	
@@ -1555,10 +1689,11 @@ horizontal_log_grid(image_desc_t   *im)
 	while(yloglab[minoridx][++i] > 0){	    
 	   Y0 = ytr(im,value * yloglab[minoridx][i]);
 	   if (Y0 <= im->yorigin - im->ysize) break;
-	   gfx_new_line ( im->canvas,
+	   gfx_new_dashed_line ( im->canvas,
 			  X0-1,Y0,
 			  X1+1,Y0,
-			  GRIDWIDTH, im->graph_col[GRC_GRID] );
+			  GRIDWIDTH, im->graph_col[GRC_GRID],
+			  im->grid_dash_on, im->grid_dash_off);
 	}
     }
 
@@ -1572,10 +1707,11 @@ horizontal_log_grid(image_desc_t   *im)
 	while(yloglab[majoridx][++i] > 0){	    
 	   Y0 = ytr(im,value * yloglab[majoridx][i]);    
 	   if (Y0 <= im->yorigin - im->ysize) break;
-	   gfx_new_line ( im->canvas,
+	   gfx_new_dashed_line ( im->canvas,
 			  X0-2,Y0,
 			  X1+2,Y0,
-			  MGRIDWIDTH, im->graph_col[GRC_MGRID] );
+			  MGRIDWIDTH, im->graph_col[GRC_MGRID],
+			  im->grid_dash_on, im->grid_dash_off);
 	   
 	   sprintf(graph_label,"%3.0e",value * yloglab[majoridx][i]);
 	   gfx_new_text ( im->canvas,
@@ -1596,11 +1732,11 @@ vertical_grid(
     image_desc_t   *im )
 {   
     int xlab_sel;		/* which sort of label and grid ? */
-    time_t ti, tilab;
+    time_t ti, tilab, timajor;
     long factor;
     char graph_label[100];
     double X0,Y0,Y1; /* points for filled graph and more*/
-   
+    struct tm tm;
 
     /* the type of time grid is determined by finding
        the number of seconds per pixel in the graph */
@@ -1627,17 +1763,30 @@ vertical_grid(
    
 
     /* paint the minor grid */
-    for(ti = find_first_time(im->start,
-			    im->xlab_user.gridtm,
-			    im->xlab_user.gridst);
-	ti < im->end; 
-	ti = find_next_time(ti,im->xlab_user.gridtm,im->xlab_user.gridst)
-	){
-	/* are we inside the graph ? */
-	if (ti < im->start || ti > im->end) continue;
-       X0 = xtr(im,ti);       
-       gfx_new_line(im->canvas,X0,Y0+1, X0,Y1-1,GRIDWIDTH, im->graph_col[GRC_GRID]);
-       
+    if (!(im->extra_flags & NOMINOR))
+    {
+        for(ti = find_first_time(im->start,
+                                im->xlab_user.gridtm,
+                                im->xlab_user.gridst),
+            timajor = find_first_time(im->start,
+                                im->xlab_user.mgridtm,
+                                im->xlab_user.mgridst);
+            ti < im->end; 
+            ti = find_next_time(ti,im->xlab_user.gridtm,im->xlab_user.gridst)
+            ){
+            /* are we inside the graph ? */
+            if (ti < im->start || ti > im->end) continue;
+            while (timajor < ti) {
+                timajor = find_next_time(timajor,
+                        im->xlab_user.mgridtm, im->xlab_user.mgridst);
+            }
+            if (ti == timajor) continue; /* skip as falls on major grid line */
+           X0 = xtr(im,ti);       
+           gfx_new_dashed_line(im->canvas,X0,Y0+1, X0,Y1-1,GRIDWIDTH,
+               im->graph_col[GRC_GRID],
+               im->grid_dash_on, im->grid_dash_off);
+           
+        }
     }
 
     /* paint the major grid */
@@ -1650,22 +1799,25 @@ vertical_grid(
 	/* are we inside the graph ? */
 	if (ti < im->start || ti > im->end) continue;
        X0 = xtr(im,ti);
-       gfx_new_line(im->canvas,X0,Y0+2, X0,Y1-2,MGRIDWIDTH, im->graph_col[GRC_MGRID]);
+       gfx_new_dashed_line(im->canvas,X0,Y0+3, X0,Y1-2,MGRIDWIDTH,
+	   im->graph_col[GRC_MGRID],
+	   im->grid_dash_on, im->grid_dash_off);
        
     }
     /* paint the labels below the graph */
-    for(ti = find_first_time(im->start,
+    for(ti = find_first_time(im->start - im->xlab_user.precis/2,
 			    im->xlab_user.labtm,
 			    im->xlab_user.labst);
-	ti <= im->end; 
+	ti <= im->end - im->xlab_user.precis/2; 
 	ti = find_next_time(ti,im->xlab_user.labtm,im->xlab_user.labst)
 	){
         tilab= ti + im->xlab_user.precis/2; /* correct time for the label */
 	/* are we inside the graph ? */
-	if (ti < im->start || ti > im->end) continue;
+	if (tilab < im->start || tilab > im->end) continue;
 
 #if HAVE_STRFTIME
-	strftime(graph_label,99,im->xlab_user.stst,localtime(&tilab));
+	localtime_r(&tilab, &tm);
+	strftime(graph_label,99,im->xlab_user.stst, &tm);
 #else
 # error "your libc has no strftime I guess we'll abort the exercise here."
 #endif
@@ -1688,21 +1840,21 @@ axis_paint(
 	   )
 {   
     /* draw x and y axis */
-    gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
+    /* gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
 		      im->xorigin+im->xsize,im->yorigin-im->ysize,
-		      GRIDWIDTH, im->graph_col[GRC_GRID]);
+		      GRIDWIDTH, im->graph_col[GRC_AXIS]);
        
        gfx_new_line ( im->canvas, im->xorigin,im->yorigin-im->ysize,
 		         im->xorigin+im->xsize,im->yorigin-im->ysize,
-		         GRIDWIDTH, im->graph_col[GRC_GRID]);
+		         GRIDWIDTH, im->graph_col[GRC_AXIS]); */
    
        gfx_new_line ( im->canvas, im->xorigin-4,im->yorigin,
 		         im->xorigin+im->xsize+4,im->yorigin,
-		         MGRIDWIDTH, im->graph_col[GRC_GRID]);
+		         MGRIDWIDTH, im->graph_col[GRC_AXIS]);
    
        gfx_new_line ( im->canvas, im->xorigin,im->yorigin+4,
 		         im->xorigin,im->yorigin-im->ysize-4,
-		         MGRIDWIDTH, im->graph_col[GRC_GRID]);
+		         MGRIDWIDTH, im->graph_col[GRC_AXIS]);
    
     
     /* arrow for X axis direction */
@@ -1711,9 +1863,7 @@ axis_paint(
 		   im->xorigin+im->xsize+3,  im->yorigin+4,
 		   im->xorigin+im->xsize+8,  im->yorigin+0.5, /* LINEOFFSET */
 		   im->graph_col[GRC_ARROW]);
-   
-   
-   
+
 }
 
 void
@@ -1750,7 +1900,7 @@ grid_paint(image_desc_t   *im)
 	if(im->logarithmic){
 		res = horizontal_log_grid(im);
 	} else {
-		res = horizontal_grid(im);
+		res = draw_horizontal_grid(im);
 	}
 
 	/* dont draw horizontal grid if there is no min and max val */
@@ -1765,86 +1915,77 @@ grid_paint(image_desc_t   *im)
 	}
     }
 
-    /* yaxis description */
-	if (im->canvas->imgformat != IF_PNG) {
-	    gfx_new_text( im->canvas,
-			  7, (im->yorigin - im->ysize/2),
-			  im->graph_col[GRC_FONT],
-			  im->text_prop[TEXT_PROP_AXIS].font,
-			  im->text_prop[TEXT_PROP_AXIS].size, im->tabwidth, 270.0,
-			  GFX_H_CENTER, GFX_V_CENTER,
-			  im->ylegend);
-	} else {
-	    /* horrible hack until we can actually print vertically */
-	    {
-		int n;
-		int l=strlen(im->ylegend);
-		char s[2];
-		for (n=0;n<strlen(im->ylegend);n++) {
-		    s[0]=im->ylegend[n];
-		    s[1]='\0';
-		    gfx_new_text(im->canvas,7,im->text_prop[TEXT_PROP_AXIS].size*(l-n),
-			im->graph_col[GRC_FONT],
-			im->text_prop[TEXT_PROP_AXIS].font,
-			im->text_prop[TEXT_PROP_AXIS].size, im->tabwidth, 270.0,
-			GFX_H_CENTER, GFX_V_CENTER,
-			s);
-		}
-	    }
-	}
-   
+    /* yaxis unit description */
+    gfx_new_text( im->canvas,
+                  7, (im->yorigin - im->ysize/2),
+                  im->graph_col[GRC_FONT],
+                  im->text_prop[TEXT_PROP_UNIT].font,
+                  im->text_prop[TEXT_PROP_UNIT].size, im->tabwidth, 
+                  RRDGRAPH_YLEGEND_ANGLE,
+                  GFX_H_LEFT, GFX_V_CENTER,
+                  im->ylegend);
+
     /* graph title */
     gfx_new_text( im->canvas,
-		  im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size,
+		  im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.2,
 		  im->graph_col[GRC_FONT],
 		  im->text_prop[TEXT_PROP_TITLE].font,
 		  im->text_prop[TEXT_PROP_TITLE].size, im->tabwidth, 0.0,
 		  GFX_H_CENTER, GFX_V_CENTER,
 		  im->title);
-
+    
     /* graph labels */
-    if( !(im->extra_flags & NOLEGEND) ) {
-      for(i=0;i<im->gdes_c;i++){
-	if(im->gdes[i].legend[0] =='\0')
-	    continue;
-	 
-	/* im->gdes[i].leg_y is the bottom of the legend */
-		X0 = im->gdes[i].leg_x;
-		Y0 = im->gdes[i].leg_y;
-		/* Box needed? */
-		if (	   im->gdes[i].gf != GF_GPRINT
-			&& im->gdes[i].gf != GF_COMMENT) {
-		    int boxH, boxV;
-
-		    boxH = gfx_get_text_width(im->canvas, 0,
-				im->text_prop[TEXT_PROP_AXIS].font,
-				im->text_prop[TEXT_PROP_AXIS].size,
-				im->tabwidth,"M") * 1.25;
-		    boxV = boxH;
-
-		    node = gfx_new_area(im->canvas,
-				X0,Y0-boxV,
-				X0,Y0,
-				X0+boxH,Y0,
-				im->gdes[i].col);
-		    gfx_add_point ( node, X0+boxH, Y0-boxV );
-		    node = gfx_new_line(im->canvas,
-				X0,Y0-boxV, X0,Y0,
-				1,0x000000FF);
-		    gfx_add_point(node,X0+boxH,Y0);
-		    gfx_add_point(node,X0+boxH,Y0-boxV);
-		    gfx_close_path(node);
-		    X0 += boxH / 1.25 * 2;
-		}
-		gfx_new_text ( im->canvas, X0, Y0,
+    if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
+            for(i=0;i<im->gdes_c;i++){
+                    if(im->gdes[i].legend[0] =='\0')
+                            continue;
+                    
+                    /* im->gdes[i].leg_y is the bottom of the legend */
+                    X0 = im->gdes[i].leg_x;
+                    Y0 = im->gdes[i].leg_y;
+                    gfx_new_text ( im->canvas, X0, Y0,
 				   im->graph_col[GRC_FONT],
-				   im->text_prop[TEXT_PROP_AXIS].font,
-				   im->text_prop[TEXT_PROP_AXIS].size,
+				   im->text_prop[TEXT_PROP_LEGEND].font,
+				   im->text_prop[TEXT_PROP_LEGEND].size,
 				   im->tabwidth,0.0, GFX_H_LEFT, GFX_V_BOTTOM,
 				   im->gdes[i].legend );
-	      }
-	   }
-	}
+		    /* The legend for GRAPH items starts with "M " to have
+                       enough space for the box */
+                    if (	   im->gdes[i].gf != GF_PRINT &&
+				   im->gdes[i].gf != GF_GPRINT &&
+                                   im->gdes[i].gf != GF_COMMENT) {
+                            int boxH, boxV;
+                            
+                            boxH = gfx_get_text_width(im->canvas, 0,
+                                                      im->text_prop[TEXT_PROP_LEGEND].font,
+                                                      im->text_prop[TEXT_PROP_LEGEND].size,
+                                                      im->tabwidth,"M", 0)*1.2;
+                            boxV = boxH;
+                            
+                            /* make sure transparent colors show up all the same */
+			    node = gfx_new_area(im->canvas,
+                                                X0,Y0-boxV,
+                                                X0,Y0,
+                                                X0+boxH,Y0,
+                                                im->graph_col[GRC_CANVAS]);
+                            gfx_add_point ( node, X0+boxH, Y0-boxV );
+
+                            node = gfx_new_area(im->canvas,
+                                                X0,Y0-boxV,
+                                                X0,Y0,
+                                                X0+boxH,Y0,
+                                                im->gdes[i].col);
+                            gfx_add_point ( node, X0+boxH, Y0-boxV );
+                            node = gfx_new_line(im->canvas,
+                                                X0,Y0-boxV, X0,Y0,
+                                                1,im->graph_col[GRC_FONT]);
+                            gfx_add_point(node,X0+boxH,Y0);
+                            gfx_add_point(node,X0+boxH,Y0-boxV);
+                            gfx_close_path(node);
+                    }
+            }
+    }
+}
 
 
 /*****************************************************
@@ -1877,6 +2018,7 @@ int lazy_check(image_desc_t *im){
     return size;
 }
 
+#ifdef WITH_PIECHART
 void
 pie_part(image_desc_t *im, gfx_color_t color,
 	    double PieCenterX, double PieCenterY, double Radius,
@@ -1923,8 +2065,16 @@ pie_part(image_desc_t *im, gfx_color_t color,
     }
 }
 
+#endif
+
 int
-graph_size_location(image_desc_t *im, int elements, int piechart )
+graph_size_location(image_desc_t *im, int elements
+
+#ifdef WITH_PIECHART
+, int piechart
+#endif
+
+ )
 {
     /* The actual size of the image to draw is determined from
     ** several sources.  The size given on the command line is
@@ -1955,11 +2105,19 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
 #if 0
 	Xlegend  =0,	Ylegend  =0,
 #endif
-	Xspacing =10,	Yspacing =10;
+        Xspacing =10,  Yspacing =10;
 
-    if (im->ylegend[0] != '\0') {
-	Xvertical = im->text_prop[TEXT_PROP_LEGEND].size *2;
-	Yvertical = im->text_prop[TEXT_PROP_LEGEND].size * (strlen(im->ylegend)+1);
+    if (im->extra_flags & ONLY_GRAPH) {
+       Xspacing =0;
+       Yspacing =0;
+    } else {
+        if (im->ylegend[0] != '\0') {
+           Xvertical = im->text_prop[TEXT_PROP_UNIT].size *2;
+           Yvertical = gfx_get_text_width(im->canvas, 0,
+                                          im->text_prop[TEXT_PROP_UNIT].font,
+                                          im->text_prop[TEXT_PROP_UNIT].size,
+                                          im->tabwidth,im->ylegend, 0);
+        }
     }
 
     if (im->title[0] != '\0') {
@@ -1971,8 +2129,8 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
 		im->text_prop[TEXT_PROP_TITLE].font,
 		im->text_prop[TEXT_PROP_TITLE].size,
 		im->tabwidth,
-		im->title) + 2*Xspacing;
-	Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2;
+		im->title, 0) + 2*Xspacing;
+	Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.5;
     }
 
     if (elements) {
@@ -1980,19 +2138,21 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
 	Ymain=im->ysize;
 	if (im->draw_x_grid) {
 	    Xxlabel=Xmain;
-	    Yxlabel=im->text_prop[TEXT_PROP_LEGEND].size *2;
+	    Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
 	}
 	if (im->draw_y_grid) {
-	    Xylabel=im->text_prop[TEXT_PROP_LEGEND].size *6;
+	    Xylabel=im->text_prop[TEXT_PROP_AXIS].size *6;
 	    Yylabel=Ymain;
 	}
     }
 
+#ifdef WITH_PIECHART
     if (piechart) {
 	im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
 	Xpie=im->piesize;
 	Ypie=im->piesize;
     }
+#endif
 
     /* Now calculate the total size.  Insert some spacing where
        desired.  im->xorigin and im->yorigin need to correspond
@@ -2005,10 +2165,21 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
     ** forget about it at all; the legend will have to fit in the
     ** size already allocated.
     */
-    im->ximg = Xylabel + Xmain + Xpie + Xspacing;
+    im->ximg = Xmain;
+
+    if ( !(im->extra_flags & ONLY_GRAPH) ) {
+        im->ximg = Xylabel + Xmain + Xpie + 2 * Xspacing;
+    }
+
     if (Xmain) im->ximg += Xspacing;
     if (Xpie) im->ximg += Xspacing;
-    im->xorigin = Xspacing + Xylabel;
+
+    if (im->extra_flags & ONLY_GRAPH) {
+       im->xorigin = 0;
+    } else {
+       im->xorigin = Xspacing + Xylabel;
+    }
+
     if (Xtitle > im->ximg) im->ximg = Xtitle;
     if (Xvertical) {
 	im->ximg += Xvertical;
@@ -2026,9 +2197,21 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
     */
 
     /* reserve space for main and/or pie */
-    im->yimg = Ymain + Yxlabel;
+
+    if (im->extra_flags & ONLY_GRAPH) {
+        im->yimg = Ymain;
+    } else {
+        im->yimg = Ymain + Yxlabel;
+    }
+
     if (im->yimg < Ypie) im->yimg = Ypie;
-    im->yorigin = im->yimg - Yxlabel;
+
+    if (im->extra_flags & ONLY_GRAPH) {
+        im->yorigin = im->yimg;
+    } else {
+        im->yorigin = im->yimg - Yxlabel;
+    }
+
     /* reserve space for the title *or* some padding above the graph */
     if (Ytitle) {
 	im->yimg += Ytitle;
@@ -2054,8 +2237,10 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
     if (Xlegend > im->ximg) {
 	im->ximg = Xlegend;
 	/* reposition Pie */
+    }
 #endif
 
+#ifdef WITH_PIECHART
     /* The pie is placed in the upper right hand corner,
     ** just below the title (if any) and with sufficient
     ** padding.
@@ -2067,6 +2252,7 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
 	im->pie_x = im->ximg/2;
         im->pie_y = im->yorigin-Ypie/2;
     }
+#endif
 
     return 0;
 }
@@ -2077,27 +2263,30 @@ graph_paint(image_desc_t *im, char ***calcpr)
 {
   int i,ii;
   int lazy =     lazy_check(im);
+#ifdef WITH_PIECHART
   int piechart = 0;
   double PieStart=0.0;
+#endif
   FILE  *fo;
   gfx_node_t *node;
   
   double areazero = 0.0;
   enum gf_en stack_gf = GF_PRINT;
   graph_desc_t *lastgdes = NULL;    
-  
+
   /* if we are lazy and there is nothing to PRINT ... quit now */
   if (lazy && im->prt_c==0) return 0;
-  
+
   /* pull the data from the rrd files ... */
   
   if(data_fetch(im)==-1)
     return -1;
-  
+
   /* evaluate VDEF and CDEF operations ... */
   if(data_calc(im)==-1)
     return -1;
-  
+
+#ifdef WITH_PIECHART  
   /* check if we need to draw a piechart */
   for(i=0;i<im->gdes_c;i++){
     if (im->gdes[i].gf == GF_PART) {
@@ -2105,6 +2294,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
       break;
     }
   }
+#endif
 
   /* calculate and PRINT and GPRINT definitions. We have to do it at
    * this point because it will affect the length of the legends
@@ -2113,10 +2303,16 @@ graph_paint(image_desc_t *im, char ***calcpr)
    */
   i=print_calc(im,calcpr);
   if(i<0) return -1;
-  if(((i==0)&&(piechart==0)) || lazy) return 0;
+  if(((i==0)
+#ifdef WITH_PIECHART
+&&(piechart==0)
+#endif
+) || lazy) return 0;
 
+#ifdef WITH_PIECHART
   /* If there's only the pie chart to draw, signal this */
   if (i==0) piechart=2;
+#endif
   
   /* get actual drawing data and find min and max values*/
   if(data_proc(im)==-1)
@@ -2128,11 +2324,22 @@ graph_paint(image_desc_t *im, char ***calcpr)
     expand_range(im);   /* make sure the upper and lower limit are
                            sensible values */
 
+  if (!calc_horizontal_grid(im))
+    return -1;
+
+  if (im->gridfit)
+    apply_gridfit(im);
+
+
 /**************************************************************
  *** Calculating sizes and locations became a bit confusing ***
  *** so I moved this into a separate function.              ***
  **************************************************************/
-  if(graph_size_location(im,i,piechart)==-1)
+  if(graph_size_location(im,i
+#ifdef WITH_PIECHART
+,piechart
+#endif
+)==-1)
     return -1;
 
   /* the actual graph is created by going through the individual
@@ -2146,7 +2353,9 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
   gfx_add_point(node,0, im->yimg);
 
+#ifdef WITH_PIECHART
   if (piechart != 2) {
+#endif
     node=gfx_new_area ( im->canvas,
                       im->xorigin,             im->yorigin, 
                       im->xorigin + im->xsize, im->yorigin,
@@ -2159,13 +2368,15 @@ graph_paint(image_desc_t *im, char ***calcpr)
       areazero = im->minval;
     if (im->maxval < 0.0)
       areazero = im->maxval;
-  
-    axis_paint(im);
-  }
+#ifdef WITH_PIECHART
+   }
+#endif
 
+#ifdef WITH_PIECHART
   if (piechart) {
     pie_part(im,im->graph_col[GRC_CANVAS],im->pie_x,im->pie_y,im->piesize*0.5,0,2*M_PI);
   }
+#endif
 
   for(i=0;i<im->gdes_c;i++){
     switch(im->gdes[i].gf){
@@ -2177,6 +2388,8 @@ graph_paint(image_desc_t *im, char ***calcpr)
     case GF_COMMENT:
     case GF_HRULE:
     case GF_VRULE:
+    case GF_XPORT:
+    case GF_SHIFT:
       break;
     case GF_TICK:
       for (ii = 0; ii < im->xsize; ii++)
@@ -2239,7 +2452,12 @@ graph_paint(image_desc_t *im, char ***calcpr)
                  && ! isnan(im->gdes[i].p_data[ii])){
               if (node == NULL){
                 float ybase = 0.0;
+/*
                 if (im->gdes[i].gf == GF_STACK) {
+*/
+		if ( (im->gdes[i].gf == GF_STACK)
+		  || (im->gdes[i].stack) ) {
+
                   ybase = ytr(im,lastgdes->p_data[ii-1]);
                 } else {
                   ybase =  ytr(im,areazero);
@@ -2258,7 +2476,11 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
             if ( node != NULL && (ii+1==im->xsize || isnan(im->gdes[i].p_data[ii]) )){
               /* GF_AREA STACK type*/
+/*
               if (im->gdes[i].gf == GF_STACK ) {
+*/
+	      if ( (im->gdes[i].gf == GF_STACK)
+		|| (im->gdes[i].stack) ) {
                 int iii;
                 for (iii=ii-1;iii>area_start;iii--){
                   gfx_add_point(node,iii+im->xorigin,ytr(im,lastgdes->p_data[iii]));
@@ -2274,18 +2496,16 @@ graph_paint(image_desc_t *im, char ***calcpr)
       /* make sure we do not run into trouble when stacking on NaN */
       for(ii=0;ii<im->xsize;ii++){
         if (isnan(im->gdes[i].p_data[ii])) {
-          double ybase = 0.0;
-          if (lastgdes) {
-            ybase = ytr(im,lastgdes->p_data[ii-1]);
-          };
-          if (isnan(ybase) || !lastgdes ){
-            ybase =  ytr(im,areazero);
+          if (lastgdes && (im->gdes[i].gf == GF_STACK)) {
+            im->gdes[i].p_data[ii] = lastgdes->p_data[ii];
+          } else {
+            im->gdes[i].p_data[ii] =  ytr(im,areazero);
           }
-          im->gdes[i].p_data[ii] = ybase;
         }
       } 
       lastgdes = &(im->gdes[i]);                         
       break;
+#ifdef WITH_PIECHART
     case GF_PART:
       if(isnan(im->gdes[i].yrule)) /* fetch variable */
 	im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
@@ -2298,14 +2518,23 @@ graph_paint(image_desc_t *im, char ***calcpr)
 	PieStart += im->gdes[i].yrule;
       }
       break;
+#endif
+	
     } /* switch */
   }
+#ifdef WITH_PIECHART
   if (piechart==2) {
     im->draw_x_grid=0;
     im->draw_y_grid=0;
   }
+#endif
+
+  if( !(im->extra_flags & ONLY_GRAPH) )  
+      axis_paint(im);
+
   /* grid_paint also does the text */
-  grid_paint(im);
+  if( !(im->extra_flags & ONLY_GRAPH) )  
+    grid_paint(im);
   
   /* the RULES are the last thing to paint ... */
   for(i=0;i<im->gdes_c;i++){    
@@ -2340,15 +2569,15 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
   
   if (strcmp(im->graphfile,"-")==0) {
+    fo = im->graphhandle ? im->graphhandle : stdout;
 #ifdef WIN32
     /* Change translation mode for stdout to BINARY */
-    _setmode( _fileno( stdout ), O_BINARY );
+    _setmode( _fileno( fo ), O_BINARY );
 #endif
-    fo = stdout;
   } else {
     if ((fo = fopen(im->graphfile,"wb")) == NULL) {
       rrd_set_error("Opening '%s' for write: %s",im->graphfile,
-                    strerror(errno));
+                    rrd_strerror(errno));
       return (-1);
     }
   }
@@ -2366,13 +2595,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
 int
 gdes_alloc(image_desc_t *im){
 
-    long def_step = (im->end-im->start)/im->xsize;
-    
-    if (im->step > def_step) /* step can be increassed ... no decreassed */
-      def_step = im->step;
-
     im->gdes_c++;
-    
     if ((im->gdes = (graph_desc_t *) rrd_realloc(im->gdes, (im->gdes_c)
 					   * sizeof(graph_desc_t)))==NULL){
 	rrd_set_error("realloc graph_descs");
@@ -2380,7 +2603,9 @@ gdes_alloc(image_desc_t *im){
     }
 
 
-    im->gdes[im->gdes_c-1].step=def_step; 
+    im->gdes[im->gdes_c-1].step=im->step;
+    im->gdes[im->gdes_c-1].stack=0;
+    im->gdes[im->gdes_c-1].debug=0;
     im->gdes[im->gdes_c-1].start=im->start; 
     im->gdes[im->gdes_c-1].end=im->end; 
     im->gdes[im->gdes_c-1].vname[0]='\0'; 
@@ -2389,11 +2614,15 @@ gdes_alloc(image_desc_t *im){
     im->gdes[im->gdes_c-1].data_first=0;
     im->gdes[im->gdes_c-1].p_data=NULL;
     im->gdes[im->gdes_c-1].rpnp=NULL;
+    im->gdes[im->gdes_c-1].shift=0;
     im->gdes[im->gdes_c-1].col = 0x0;
     im->gdes[im->gdes_c-1].legend[0]='\0';
+    im->gdes[im->gdes_c-1].format[0]='\0';
     im->gdes[im->gdes_c-1].rrd[0]='\0';
     im->gdes[im->gdes_c-1].ds=-1;    
     im->gdes[im->gdes_c-1].p_data=NULL;    
+    im->gdes[im->gdes_c-1].yrule=DNAN;
+    im->gdes[im->gdes_c-1].xrule=0;
     return 0;
 }
 
@@ -2421,7 +2650,6 @@ scan_for_col(char *input, int len, char *output)
     output[outp] = '\0';
     return inp;
 }
-
 /* Some surgery done on this function, it became ridiculously big.
 ** Things moved:
 ** - initializing     now in rrd_graph_init()
@@ -2429,24 +2657,32 @@ scan_for_col(char *input, int len, char *output)
 ** - script parsing   now in rrd_graph_script()
 */
 int 
-rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
+rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *stream, double *ymin, double *ymax)
 {
     image_desc_t   im;
-
+            
     rrd_graph_init(&im);
-
+    im.graphhandle = stream;
+    
     rrd_graph_options(argc,argv,&im);
-    if (rrd_test_error()) return -1;
+    if (rrd_test_error()) {
+	im_free(&im);
+	return -1;
+    }
     
     if (strlen(argv[optind])>=MAXPATH) {
 	rrd_set_error("filename (including path) too long");
+	im_free(&im);
 	return -1;
     }
     strncpy(im.graphfile,argv[optind],MAXPATH-1);
     im.graphfile[MAXPATH-1]='\0';
 
-    rrd_graph_script(argc,argv,&im);
-    if (rrd_test_error()) return -1;
+    rrd_graph_script(argc,argv,&im,1);
+    if (rrd_test_error()) {
+	im_free(&im);
+	return -1;
+    }
 
     /* Everything is now read and the actual work can start */
 
@@ -2462,6 +2698,8 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 
     *xsize=im.ximg;
     *ysize=im.yimg;
+    *ymin=im.minval;
+    *ymax=im.maxval;
     if (im.imginfo) {
 	char *filename;
 	if (!(*prdata)) {
@@ -2491,7 +2729,14 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 void
 rrd_graph_init(image_desc_t *im)
 {
-    int i;
+    unsigned int i;
+
+#ifdef HAVE_TZSET
+    tzset();
+#endif
+#ifdef HAVE_SETLOCALE
+    setlocale(LC_TIME,"");
+#endif
 
     im->xlab_user.minsec = -1;
     im->ximg=0;
@@ -2506,6 +2751,7 @@ rrd_graph_init(image_desc_t *im)
     im->unitsexponent= 9999;
     im->extra_flags= 0;
     im->rigid = 0;
+    im->gridfit = 1;
     im->imginfo = NULL;
     im->lazy = 0;
     im->logarithmic = 0;
@@ -2517,13 +2763,28 @@ rrd_graph_init(image_desc_t *im)
     im->gdes_c = 0;
     im->gdes = NULL;
     im->canvas = gfx_new_canvas();
-
+    im->grid_dash_on = 1;
+    im->grid_dash_off = 1;
+    im->tabwidth = 40.0;
+    
     for(i=0;i<DIM(graph_col);i++)
         im->graph_col[i]=graph_col[i];
-
+#ifdef WIN32
+    {
+            char *windir; 
+            windir = getenv("windir");
+            /* %windir% is something like D:\windows or C:\winnt */
+            if (windir != NULL) {
+                    strcpy(rrd_win_default_font,windir);
+                    strcat(rrd_win_default_font,"\\fonts\\cour.ttf");
+                    for(i=0;i<DIM(text_prop);i++)
+                            strcpy(text_prop[i].font,rrd_win_default_font);
+            }
+    }
+#endif
     for(i=0;i<DIM(text_prop);i++){        
       im->text_prop[i].size = text_prop[i].size;
-      im->text_prop[i].font = text_prop[i].font;
+      strcpy(im->text_prop[i].font,text_prop[i].font);
     }
 }
 
@@ -2535,7 +2796,7 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
     char		scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
     time_t		start_tmp=0,end_tmp=0;
     long		long_tmp;
-    struct time_value	start_tv, end_tv;
+    struct rrd_time_value	start_tv, end_tv;
     gfx_color_t         color;
 
     parsetime("end-24h", &start_tv);
@@ -2565,42 +2826,62 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
 	    {"lazy",       no_argument,       0,  'z'},
             {"zoom",       required_argument, 0,  'm'},
 	    {"no-legend",  no_argument,       0,  'g'},
-	    {"alt-y-grid", no_argument,       0,   257 },
-	    {"alt-autoscale", no_argument,    0,   258 },
-	    {"alt-autoscale-max", no_argument,    0,   259 },
-	    {"units-exponent",required_argument, 0,  260},
-	    {"step",       required_argument, 0,   261},
+	    {"force-rules-legend",no_argument,0,  'F'},
+            {"only-graph", no_argument,       0,  'j'},
+	    {"alt-y-grid", no_argument,       0,  'Y'},
+            {"no-minor",   no_argument,       0,  'I'},
+	    {"alt-autoscale", no_argument,    0,  'A'},
+	    {"alt-autoscale-max", no_argument, 0, 'M'},
+	    {"units-exponent",required_argument, 0, 'X'},
+	    {"step",       required_argument, 0,    'S'},
+            {"tabwidth",   required_argument, 0,    'T'},            
+	    {"no-gridfit", no_argument,       0,   'N'},
 	    {0,0,0,0}};
 	int option_index = 0;
 	int opt;
 
 
 	opt = getopt_long(argc, argv, 
-			  "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:z:g",
+			 "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:I:zgjFYAMX:S:NT:",
 			  long_options, &option_index);
 
 	if (opt == EOF)
 	    break;
 	
 	switch(opt) {
-	case 257:
+        case 'I':
+            im->extra_flags |= NOMINOR;
+            break;
+	case 'Y':
 	    im->extra_flags |= ALTYGRID;
 	    break;
-	case 258:
+	case 'A':
 	    im->extra_flags |= ALTAUTOSCALE;
 	    break;
-	case 259:
+	case 'M':
 	    im->extra_flags |= ALTAUTOSCALE_MAX;
 	    break;
+        case 'j':
+           im->extra_flags |= ONLY_GRAPH;
+           break;
 	case 'g':
 	    im->extra_flags |= NOLEGEND;
 	    break;
-	case 260:
+	case 'F':
+	    im->extra_flags |= FORCE_RULES_LEGEND;
+	    break;
+	case 'X':
 	    im->unitsexponent = atoi(optarg);
 	    break;
-	case 261:
+	case 'T':
+	    im->tabwidth = atof(optarg);
+	    break;
+	case 'S':
 	    im->step =  atoi(optarg);
 	    break;
+	case 262:
+	    im->gridfit = 0;
+	    break;
 	case 's':
 	    if ((parsetime_error = parsetime(optarg, &start_tv))) {
 	        rrd_set_error( "start time: %s", parsetime_error );
@@ -2630,13 +2911,13 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
 		      &im->xlab_user.precis,
 		      &stroff) == 7 && stroff != 0){
                 strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 1);
-		if((im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
+		if((int)(im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_gtm);
 		    return;
-		} else if ((im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
+		} else if ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_mtm);
 		    return;
-		} else if ((im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
+		} else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_ltm);
 		    return;
 		} 
@@ -2713,7 +2994,7 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
 	    im->imginfo = optarg;
 	    break;
     	case 'a':
-	    if((im->canvas->imgformat = if_conv(optarg)) == -1) {
+	    if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
 		rrd_set_error("unsupported graphics format '%s'",optarg);
 		return;
 	    }
@@ -2742,35 +3023,26 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
             }
             break;        
         case 'n':{
-			/* originally this used char *prop = "" and
-			** char *font = "dummy" however this results
-			** in a SEG fault, at least on RH7.1
-			**
-			** The current implementation isn't proper
-			** either, font is never freed and prop uses
-			** a fixed width string
-			*/
-	    char prop[100];
+	    char prop[15];
 	    double size = 1;
-	    char *font;
+	    char font[1024];
 
-	    font=malloc(255);
 	    if(sscanf(optarg,
-				"%10[A-Z]:%lf:%s",
+				"%10[A-Z]:%lf:%1000s",
 				prop,&size,font) == 3){
 		int sindex;
 		if((sindex=text_prop_conv(prop)) != -1){
 		    im->text_prop[sindex].size=size;              
-		    im->text_prop[sindex].font=font;
+		    strcpy(im->text_prop[sindex].font,font);
 		    if (sindex==0) { /* the default */
 			im->text_prop[TEXT_PROP_TITLE].size=size;
-			im->text_prop[TEXT_PROP_TITLE].font=font;
+			strcpy(im->text_prop[TEXT_PROP_TITLE].font,font);
 			im->text_prop[TEXT_PROP_AXIS].size=size;
-			im->text_prop[TEXT_PROP_AXIS].font=font;
+			strcpy(im->text_prop[TEXT_PROP_AXIS].font,font);
 			im->text_prop[TEXT_PROP_UNIT].size=size;
-			im->text_prop[TEXT_PROP_UNIT].font=font;
+			strcpy(im->text_prop[TEXT_PROP_UNIT].font,font);
 			im->text_prop[TEXT_PROP_LEGEND].size=size;
-			im->text_prop[TEXT_PROP_LEGEND].font=font;
+			strcpy(im->text_prop[TEXT_PROP_LEGEND].font,font);
 		    }
 		} else {
 		    rrd_set_error("invalid fonttag '%s'",prop);
@@ -2831,235 +3103,9 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
     
     im->start = start_tmp;
     im->end = end_tmp;
+    im->step = max((long)im->step, (im->end-im->start)/im->xsize);
 }
 
-void
-rrd_graph_script(int argc, char *argv[], image_desc_t *im)
-{
-    int		i;
-    char	symname[100];
-    int		linepass = 0; /* stack must follow LINE*, AREA or STACK */    
-
-    for (i=optind+1;i<argc;i++) {
-	int		argstart=0;
-	int		strstart=0;
-	graph_desc_t	*gdp;
-	char		*line;
-	char		funcname[10],vname[MAX_VNAME_LEN+1],sep[1];
-	double		d;
-	double          linewidth;
-	int		j,k,l,m;
-
-	/* Each command is one element from *argv[], we call this "line".
-	**
-	** Each command defines the most current gdes inside struct im.
-	** In stead of typing "im->gdes[im->gdes_c-1]" we use "gdp".
-	*/
-	gdes_alloc(im);
-	gdp=&im->gdes[im->gdes_c-1];
-	line=argv[i];
-
-	/* function:newvname=string[:ds-name:CF]	for xDEF
-	** function:vname[#color[:string]]		for LINEx,AREA,STACK
-	** function:vname#color[:num[:string]]		for TICK
-	** function:vname-or-num#color[:string]		for xRULE,PART
-	** function:vname:CF:string			for xPRINT
-	** function:string				for COMMENT
-	*/
-	argstart=0;
-
-	sscanf(line, "%10[A-Z0-9]:%n", funcname,&argstart);
-	if (argstart==0) {
-	    rrd_set_error("Cannot parse function in line: %s",line);
-	    im_free(im);
-	    return;
-	}
-        if(sscanf(funcname,"LINE%lf",&linewidth)){
-                im->gdes[im->gdes_c-1].gf = GF_LINE;
-                im->gdes[im->gdes_c-1].linewidth = linewidth;
-        } else {
-  	  if ((gdp->gf=gf_conv(funcname))==-1) {
-	      rrd_set_error("'%s' is not a valid function name",funcname);
-	      im_free(im);
-	      return;
-	  }
-        }
-
-	/* If the error string is set, we exit at the end of the switch */
-	switch (gdp->gf) {
-	    case GF_COMMENT:
-		if (rrd_graph_legend(gdp,&line[argstart])==0)
-		    rrd_set_error("Cannot parse comment in line: %s",line);
-		break;
-	    case GF_PART:
-	    case GF_VRULE:
-	    case GF_HRULE:
-		j=k=l=m=0;
-		sscanf(&line[argstart], "%lf%n#%n", &d, &j, &k);
-		sscanf(&line[argstart], DEF_NAM_FMT "%n#%n", vname, &l, &m);
-		if (k+m==0) {
-		    rrd_set_error("Cannot parse name or num in line: %s",line);
-		    break;
-		}
-		if (j!=0) {
-		    gdp->xrule=d;
-		    gdp->yrule=d;
-		    argstart+=j;
-		} else if (!rrd_graph_check_vname(im,vname,line)) {
-		    gdp->xrule=0;
-		    gdp->yrule=DNAN;
-		    argstart+=l;
-		} else break; /* exit due to wrong vname */
-		if ((j=rrd_graph_color(im,&line[argstart],line,0))==0) break;
-		argstart+=j;
-		if (strlen(&line[argstart])!=0) {
-		    if (rrd_graph_legend(gdp,&line[++argstart])==0)
-			rrd_set_error("Cannot parse comment in line: %s",line);
-		}
-		break;
-	    case GF_STACK:
-		if (linepass==0) {
-		    rrd_set_error("STACK must follow another graphing element");
-		    break;
-		}
-	    case GF_LINE:
-	    case GF_AREA:
-	    case GF_TICK:
-		j=k=0;
-		linepass=1;
-		sscanf(&line[argstart],DEF_NAM_FMT"%n%1[#:]%n",vname,&j,sep,&k);
-		if (j+1!=k)
-		    rrd_set_error("Cannot parse vname in line: %s",line);
-		else if (rrd_graph_check_vname(im,vname,line))
-		    rrd_set_error("Undefined vname '%s' in line: %s",line);
-		else
-		    k=rrd_graph_color(im,&line[argstart],line,1);
-		if (rrd_test_error()) break;
-		argstart=argstart+j+k;
-		if ((strlen(&line[argstart])!=0)&&(gdp->gf==GF_TICK)) {
-		    j=0;
-		    sscanf(&line[argstart], ":%lf%n", &gdp->yrule,&j);
-		    argstart+=j;
-		}
-		if (strlen(&line[argstart])!=0)
-		    if (rrd_graph_legend(gdp,&line[++argstart])==0)
-			rrd_set_error("Cannot parse legend in line: %s",line);
-		break;
-	    case GF_PRINT:
-		im->prt_c++;
-	    case GF_GPRINT:
-		j=0;
-		sscanf(&line[argstart], DEF_NAM_FMT ":%n",gdp->vname,&j);
-		if (j==0) {
-		    rrd_set_error("Cannot parse vname in line: '%s'",line);
-		    break;
-		}
-		argstart+=j;
-		if (rrd_graph_check_vname(im,gdp->vname,line)) return;
-		j=0;
-		sscanf(&line[argstart], CF_NAM_FMT ":%n",symname,&j);
-
-		k=(j!=0)?rrd_graph_check_CF(im,symname,line):1;
-#define VIDX im->gdes[gdp->vidx]
-		switch (k) {
-		    case -1: /* looks CF but is not really CF */
-			if (VIDX.gf == GF_VDEF) rrd_clear_error();
-			break;
-		    case  0: /* CF present and correct */
-			if (VIDX.gf == GF_VDEF)
-			    rrd_set_error("Don't use CF when printing VDEF");
-			argstart+=j;
-			break;
-		    case  1: /* CF not present */
-			if (VIDX.gf == GF_VDEF) rrd_clear_error();
-			else rrd_set_error("Printing DEF or CDEF needs CF");
-			break;
-		    default:
-			rrd_set_error("Oops, bug in GPRINT scanning");
-		}
-#undef VIDX
-		if (rrd_test_error()) break;
-
-		if (strlen(&line[argstart])!=0) {
-		    if (rrd_graph_legend(gdp,&line[argstart])==0)
-			rrd_set_error("Cannot parse legend in line: %s",line);
-		} else rrd_set_error("No legend in (G)PRINT line: %s",line);
-		strcpy(gdp->format, gdp->legend);
-		break;
-	    case GF_DEF:
-	    case GF_VDEF:
-	    case GF_CDEF:
-		j=0;
-		sscanf(&line[argstart], DEF_NAM_FMT "=%n",gdp->vname,&j);
-		if (j==0) {
-		    rrd_set_error("Could not parse line: %s",line);
-		    break;
-		}
-		if (find_var(im,gdp->vname)!=-1) {
-		    rrd_set_error("Variable '%s' in line '%s' already in use\n",
-							gdp->vname,line);
-		    break;
-		}
-		argstart+=j;
-		switch (gdp->gf) {
-		    case GF_DEF:
-			argstart+=scan_for_col(&line[argstart],MAXPATH,gdp->rrd);
-			j=k=0;
-			sscanf(&line[argstart],
-				":" DS_NAM_FMT ":" CF_NAM_FMT "%n%*s%n",
-				gdp->ds_nam, symname, &j, &k);
-			if ((j==0)||(k!=0)) {
-			    rrd_set_error("Cannot parse DS or CF in '%s'",line);
-			    break;
-			}
-			rrd_graph_check_CF(im,symname,line);
-			break;
-		    case GF_VDEF:
-			j=0;
-			sscanf(&line[argstart],DEF_NAM_FMT ",%n",vname,&j);
-			if (j==0) {
-			    rrd_set_error("Cannot parse vname in line '%s'",line);
-			    break;
-			}
-			argstart+=j;
-			if (rrd_graph_check_vname(im,vname,line)) return;
-			if (       im->gdes[gdp->vidx].gf != GF_DEF
-				&& im->gdes[gdp->vidx].gf != GF_CDEF) {
-			    rrd_set_error("variable '%s' not DEF nor "
-				"CDEF in VDEF '%s'", vname,gdp->vname);
-			    break;
-			}
-			vdef_parse(gdp,&line[argstart+strstart]);
-			break;
-		    case GF_CDEF:
-			if (strstr(&line[argstart],":")!=NULL) {
-			    rrd_set_error("Error in RPN, line: %s",line);
-			    break;
-			}
-			if ((gdp->rpnp = rpn_parse(
-						(void *)im,
-						&line[argstart],
-						&find_var_wrapper)
-				)==NULL)
-			    rrd_set_error("invalid rpn expression in: %s",line);
-			break;
-		    default: break;
-		}
-		break;
-	    default: rrd_set_error("Big oops");
-	}
-	if (rrd_test_error()) {
-	    im_free(im);
-	    return;
-	}
-    }
-
-    if (im->gdes_c==0){
-	rrd_set_error("can't make a graph without contents");
-	im_free(im); /* ??? is this set ??? */
-	return; 
-    }
-}
 int
 rrd_graph_check_vname(image_desc_t *im, char *varname, char *err)
 {
@@ -3110,54 +3156,44 @@ rrd_graph_color(image_desc_t *im, char *var, char *err, int optional)
 	return n;
     }
 }
-int
-rrd_graph_check_CF(image_desc_t *im, char *symname, char *err)
-{
-    if ((im->gdes[im->gdes_c-1].cf=cf_conv(symname))==-1) {
-	rrd_set_error("Unknown CF '%s' in %s",symname,err);
-	return -1;
-    }
-    return 0;
-}
-int
-rrd_graph_legend(graph_desc_t *gdp, char *line)
-{
-    int i;
 
-    i=scan_for_col(line,FMT_LEG_LEN,gdp->legend);
 
-    return (strlen(&line[i])==0);
+int bad_format(char *fmt) {
+    char *ptr;
+    int n=0;
+    ptr = fmt;
+    while (*ptr != '\0')
+        if (*ptr++ == '%') {
+ 
+             /* line cannot end with percent char */
+             if (*ptr == '\0') return 1;
+ 
+             /* '%s', '%S' and '%%' are allowed */
+             if (*ptr == 's' || *ptr == 'S' || *ptr == '%') ptr++;
+
+             /* or else '% 6.2lf' and such are allowed */
+             else {
+   
+                 /* optional padding character */
+                 if (*ptr == ' ' || *ptr == '+' || *ptr == '-') ptr++;
+  
+                 /* This should take care of 'm.n' with all three optional */
+                 while (*ptr >= '0' && *ptr <= '9') ptr++;
+                 if (*ptr == '.') ptr++;
+                 while (*ptr >= '0' && *ptr <= '9') ptr++;
+  
+                 /* Either 'le', 'lf' or 'lg' must follow here */
+                 if (*ptr++ != 'l') return 1;
+                 if (*ptr == 'e' || *ptr == 'f' || *ptr == 'g') ptr++;
+                 else return 1;
+                 n++;
+            }
+         }
+      
+      return (n!=1); 
 }
 
 
-int bad_format(char *fmt) {
-	char *ptr;
-	int n=0;
-
-	ptr = fmt;
-	while (*ptr != '\0') {
-		if (*ptr == '%') {ptr++;
-			if (*ptr == '\0') return 1;
-			while ((*ptr >= '0' && *ptr <= '9') || *ptr == '.') { 
-				ptr++;
-			}
-			if (*ptr == '\0') return 1;
-			if (*ptr == 'l') {
-				ptr++;
-				n++;
-				if (*ptr == '\0') return 1;
-				if (*ptr == 'e' || *ptr == 'f') { 
-					ptr++; 
-					} else { return 1; }
-			}
-			else if (*ptr == 's' || *ptr == 'S' || *ptr == '%') { ++ptr; }
-			else { return 1; }
-		} else {
-			++ptr;
-		}
-	}
-	return (n!=1);
-}
 int
 vdef_parse(gdes,str)
 struct graph_desc_t *gdes;
@@ -3172,12 +3208,12 @@ char *str;
     
     n=0;
     sscanf(str,"%le,%29[A-Z]%n",&param,func,&n);
-    if (n==strlen(str)) { /* matched */
+    if (n== (int)strlen(str)) { /* matched */
 	;
     } else {
 	n=0;
 	sscanf(str,"%29[A-Z]%n",func,&n);
-	if (n==strlen(str)) { /* matched */
+	if (n== (int)strlen(str)) { /* matched */
 	    param=DNAN;
 	} else {
 	    rrd_set_error("Unknown function string '%s' in VDEF '%s'"
@@ -3244,6 +3280,8 @@ char *str;
     };
     return 0;
 }
+
+
 int
 vdef_calc(im,gdi)
 image_desc_t *im;
@@ -3284,6 +3322,7 @@ printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
 		field = (steps-1)*dst->vf.param/100;
 		dst->vf.val  = array[field];
 		dst->vf.when = 0;	/* no time component */
+		free(array);
 #if 0
 for(step=0;step<steps;step++)
 printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');