X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_graph.c;h=67fce90cb304134558c3ffb80c348ad71323d852;hp=f0ec67e880b1930d1b7cf7f3e85a2d054f5d34d0;hb=aa4b49144558b7683f39bc7e803d69427ff3993e;hpb=5d406a5f504148a9e494ea09b25d9b8d79543516

diff --git a/src/rrd_graph.c b/src/rrd_graph.c
index f0ec67e..67fce90 100644
--- a/src/rrd_graph.c
+++ b/src/rrd_graph.c
@@ -1,7 +1,7 @@
 /****************************************************************************
- * RRDtool 1.1.x  Copyright Tobias Oetiker, 1997 - 2002
+ * RRDtool 1.2rc5  Copyright by Tobi Oetiker, 1997-2005
  ****************************************************************************
- * rrd__graph.c  make creates ne rrds
+ * rrd__graph.c  produce graphs from data in rrdfiles
  ****************************************************************************/
 
 
@@ -9,7 +9,7 @@
 
 #include "rrd_tool.h"
 
-#ifdef WIN32
+#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
 #include <io.h>
 #include <fcntl.h>
 #endif
@@ -23,27 +23,22 @@
 #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
+/* 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[] = {
@@ -101,11 +96,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       */
 };
 
 
@@ -185,8 +180,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);
 }
@@ -222,8 +220,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;	
 }
@@ -241,14 +239,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);
@@ -601,7 +598,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;
@@ -679,13 +676,13 @@ 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 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;
@@ -697,6 +694,7 @@ data_fetch( image_desc_t *im )
 		continue;
 	    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)) {
@@ -729,9 +727,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,
@@ -743,8 +742,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; }
 	}
@@ -822,6 +821,28 @@ data_calc( image_desc_t *im){
 	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.
@@ -855,19 +876,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;
@@ -906,14 +930,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"
@@ -978,68 +1003,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:
-	    case GF_XPORT:
-		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;
 	    }
 	}
     }
@@ -1053,29 +1083,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;
 }
@@ -1092,7 +1126,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;
@@ -1145,7 +1179,7 @@ find_next_time(
 {
     struct tm tm;
     time_t madetime;
-    tm = *localtime(&current);
+    localtime_r(&current, &tm);
     do {
 	switch(baseint){
 	case TMT_SECOND:
@@ -1250,14 +1284,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 {
@@ -1281,8 +1316,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
@@ -1290,12 +1326,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
@@ -1319,7 +1354,10 @@ 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;
 	}
@@ -1334,7 +1372,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;
@@ -1345,7 +1382,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;
@@ -1353,11 +1390,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';
@@ -1378,15 +1428,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;
@@ -1414,7 +1460,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);
@@ -1426,7 +1472,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 += 
@@ -1434,15 +1480,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;
@@ -1587,7 +1630,7 @@ int draw_horizontal_grid(image_desc_t *im)
 			      MGRIDWIDTH, im->graph_col[GRC_MGRID],
 			      im->grid_dash_on, im->grid_dash_off);	       
 	       
-	    } else {		
+	    } else if (!(im->extra_flags & NOMINOR)) {		
 	       gfx_new_dashed_line ( im->canvas,
 			      X0-1,Y0,
 			      X1+1,Y0,
@@ -1690,7 +1733,7 @@ vertical_grid(
     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 */
@@ -1717,27 +1760,30 @@ vertical_grid(
    
 
     /* paint the minor grid */
-    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);
-       
+    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 */
@@ -1756,18 +1802,19 @@ vertical_grid(
        
     }
     /* 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
@@ -1790,21 +1837,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 */
@@ -1813,9 +1860,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
@@ -1867,86 +1912,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);
+                    }
+            }
+    }
+}
 
 
 /*****************************************************
@@ -1979,6 +2015,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,
@@ -2025,8 +2062,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
@@ -2052,18 +2097,32 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
 	Xtitle   =0,	Ytitle   =0,
 	Xylabel  =0,	Yylabel  =0,
 	Xmain    =0,	Ymain    =0,
+#ifdef WITH_PIECHART
 	Xpie     =0,	Ypie     =0,
+#endif
 	Xxlabel  =0,	Yxlabel  =0,
 #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) {
+	im->xorigin =0;
+	im->ximg = im->xsize;
+        im->yimg = im->ysize;
+        im->yorigin = im->ysize;
+	return 0;
     }
 
+    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') {
 	/* The title is placed "inbetween" two text lines so it
 	** automatically has some vertical spacing.  The horizontal
@@ -2073,8 +2132,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) {
@@ -2082,19 +2141,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
@@ -2107,12 +2168,22 @@ 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 = Xylabel + Xmain + 2 * Xspacing;
+
+#ifdef WITH_PIECHART
+    im->ximg  += Xpie;
+#endif
+
     if (Xmain) im->ximg += Xspacing;
+#ifdef WITH_PIECHART
     if (Xpie) im->ximg += Xspacing;
+#endif
+
     im->xorigin = Xspacing + Xylabel;
+
     if (Xtitle > im->ximg) im->ximg = Xtitle;
-    if (Xvertical) {
+
+    if (Xvertical) { /* unit description */
 	im->ximg += Xvertical;
 	im->xorigin += Xvertical;
     }
@@ -2128,9 +2199,15 @@ graph_size_location(image_desc_t *im, int elements, int piechart )
     */
 
     /* reserve space for main and/or pie */
+
     im->yimg = Ymain + Yxlabel;
+
+#ifdef WITH_PIECHART
     if (im->yimg < Ypie) im->yimg = Ypie;
+#endif
+
     im->yorigin = im->yimg - Yxlabel;
+
     /* reserve space for the title *or* some padding above the graph */
     if (Ytitle) {
 	im->yimg += Ytitle;
@@ -2156,8 +2233,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.
@@ -2169,6 +2248,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;
 }
@@ -2179,27 +2259,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) {
@@ -2207,6 +2290,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
@@ -2215,10 +2299,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)
@@ -2232,14 +2322,20 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
   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
@@ -2253,7 +2349,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,
@@ -2266,13 +2364,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){
@@ -2285,6 +2385,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
     case GF_HRULE:
     case GF_VRULE:
     case GF_XPORT:
+    case GF_SHIFT:
       break;
     case GF_TICK:
       for (ii = 0; ii < im->xsize; ii++)
@@ -2317,83 +2418,78 @@ graph_paint(image_desc_t *im, char ***calcpr)
           
         }
       } /* for */
-      
-      if (im->gdes[i].col != 0x0){               
+
+      /* *******************************************************
+                   ___ 
+		  |   |    ___
+              ____|   |   |   |
+              |       |___|
+       -------|---------------------------------------      
+                      
+      if we know the value of y at time t was a then 
+      we draw a square from t-1 to t with the value a.
+
+      ********************************************************* */
+      if (im->gdes[i].col != 0x0){   
         /* GF_LINE and friend */
         if(stack_gf == GF_LINE ){
           node = NULL;
           for(ii=1;ii<im->xsize;ii++){
-            if ( ! isnan(im->gdes[i].p_data[ii-1])
-                 && ! isnan(im->gdes[i].p_data[ii])){
-              if (node == NULL){
-                node = gfx_new_line(im->canvas,
-                                    ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
+	    if (isnan(im->gdes[i].p_data[ii])){
+		node = NULL;
+		continue;
+	    }
+            if ( node == NULL ) {
+                 node = gfx_new_line(im->canvas,
+                                    ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii]),
                                     ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]),
                                     im->gdes[i].linewidth,
                                     im->gdes[i].col);
-              } else {
-                gfx_add_point(node,ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]));
-              }
-            } else {
-              node = NULL;
-            }
+             } else {
+               gfx_add_point(node,ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii]));
+               gfx_add_point(node,ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]));
+             };
+
           }
         } else {
-          int area_start=-1;
-          node = NULL;
           for(ii=1;ii<im->xsize;ii++){
-            /* open an area */
-            if ( ! isnan(im->gdes[i].p_data[ii-1])
-                 && ! isnan(im->gdes[i].p_data[ii])){
-              if (node == NULL){
-                float ybase = 0.0;
-                if (im->gdes[i].gf == GF_STACK) {
-                  ybase = ytr(im,lastgdes->p_data[ii-1]);
-                } else {
-                  ybase =  ytr(im,areazero);
-                }
-                area_start = ii-1;
-                node = gfx_new_area(im->canvas,
-                                    ii-1+im->xorigin,ybase,
-                                    ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
-                                    ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]),
-                                    im->gdes[i].col
-                                    );
-              } else {
-                gfx_add_point(node,ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]));
-              }
+	    /* keep things simple for now, just draw these bars
+	       do not try to build a big and complex area */
+	    float ybase;
+	    if ( isnan(im->gdes[i].p_data[ii]) ) {
+		continue;
+	    }
+ 	    if ( im->gdes[i].stack ) {
+                  ybase = ytr(im,lastgdes->p_data[ii]);
+            } else {
+                  ybase = ytr(im,areazero);
             }
-
-            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 ) {
-                int iii;
-                for (iii=ii-1;iii>area_start;iii--){
-                  gfx_add_point(node,iii+im->xorigin,ytr(im,lastgdes->p_data[iii]));
-                }
-              } else {
-                gfx_add_point(node,ii+im->xorigin,ytr(im,areazero));
-              };
-              node=NULL;
-            };
+            if ( ybase == im->gdes[i].p_data[ii] ){
+		continue;
+	    }
+            node = gfx_new_area(im->canvas,
+                                ii-1+im->xorigin,ybase,
+                                ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii]),
+                                ii+im->xorigin,ytr(im,im->gdes[i].p_data[ii]),				
+                                im->gdes[i].col
+                               );
+            gfx_add_point(node,ii+im->xorigin,ybase);
           }             
         } /* else GF_LINE */
       } /* if color != 0x0 */
       /* 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].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;
@@ -2406,14 +2502,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++){    
@@ -2448,15 +2553,15 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
   
   if (strcmp(im->graphfile,"-")==0) {
-#ifdef WIN32
+    fo = im->graphhandle ? im->graphhandle : stdout;
+#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
     /* 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);
     }
   }
@@ -2474,13 +2579,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");
@@ -2488,7 +2587,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'; 
@@ -2497,11 +2598,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;
 }
 
@@ -2536,32 +2641,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;
-
-#ifdef HAVE_TZSET
-    tzset();
-#endif
-#ifdef HAVE_SETLOCALE
-    setlocale(LC_TIME,"");
-#endif
-            
             
     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 */
 
@@ -2577,6 +2682,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)) {
@@ -2606,7 +2713,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;
@@ -2635,13 +2749,41 @@ rrd_graph_init(image_desc_t *im)
     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];
 
+#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+    {
+            char *windir; 
+	    char rrd_win_default_font[1000];
+            windir = getenv("windir");
+            /* %windir% is something like D:\windows or C:\winnt */
+            if (windir != NULL) {
+                    strncpy(rrd_win_default_font,windir,999);
+                    rrd_win_default_font[999] = '\0';
+                    strcat(rrd_win_default_font,"\\fonts\\cour.ttf");
+                    for(i=0;i<DIM(text_prop);i++){
+                            strncpy(text_prop[i].font,rrd_win_default_font,sizeof(text_prop[i].font)-1);
+                            text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
+                     }
+    }
+#endif
+    {
+            char *deffont; 
+            deffont = getenv("RRD_DEFAULT_FONT");
+            /* %windir% is something like D:\windows or C:\winnt */
+            if (deffont != NULL) {
+                 for(i=0;i<DIM(text_prop);i++){
+                	strncpy(text_prop[i].font,deffont,sizeof(text_prop[i].font)-1);
+			text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
+		 }
+            }
+    }
     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);
     }
 }
 
@@ -2653,7 +2795,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);
@@ -2683,41 +2825,57 @@ 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},
-	    {"no-gridfit", no_argument,       0,   262},
+	    {"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;
-
+        int col_start,col_end;
 
 	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:
@@ -2752,13 +2910,14 @@ 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){
+		im->xlab_form[sizeof(im->xlab_form)-1] = '\0'; 
+		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;
 		} 
@@ -2835,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;
 	    }
@@ -2850,13 +3009,25 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
 	    break;
         case 'c':
             if(sscanf(optarg,
-                      "%10[A-Z]#%8lx",
-                      col_nam,&color) == 2){
+                      "%10[A-Z]#%n%8lx%n",
+                      col_nam,&col_start,&color,&col_end) == 2){
                 int ci;
+		int col_len = col_end - col_start;
+		switch (col_len){
+			case 6:
+		        	color = (color << 8) + 0xff /* shift left by 8 */;
+				break;
+			case 8:
+				break;
+			default:
+		                rrd_set_error("the color format is #RRGGBB[AA]");
+				return;
+		}
                 if((ci=grc_conv(col_nam)) != -1){
                     im->graph_col[ci]=color;
                 }  else {
                   rrd_set_error("invalid color name '%s'",col_nam);
+		  return;
                 }
             } else {
                 rrd_set_error("invalid color def format");
@@ -2864,35 +3035,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);
@@ -2953,548 +3115,7 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
     
     im->start = start_tmp;
     im->end = end_tmp;
-}
-
-/* rrd_name_or_num()
-**
-** Scans for a VDEF-variable or a number
-**
-** Returns an integer describing what was found:
-**
-** 0: error
-** 1: found an integer; it is returned in both l and d
-** 2: found a float; it is returned in d
-** 3: found a vname; its index is returned in l
-**
-** l and d are undefined unless described above
-*/
-static int
-rrd_name_or_num(image_desc_t *im, char *param, long *l, double *d)
-{
-    int i1=0,i2=0,i3=0,i4=0,i5=0,i6=0;
-    char vname[MAX_VNAME_LEN+1];
-
-    sscanf(param, "%li%n%*s%n", l,&i1,&i2);
-    sscanf(param, "%lf%n%*s%n", d,&i3,&i4);
-    sscanf(param, DEF_NAM_FMT "%n%*s%n", vname, &i5,&i6);
-
-    if ( (i1) && (!i2) ) return 1;
-    if ( (i3) && (!i4) ) return 2;
-    if ( (i5) && (!i6) ) {
-	if ((*l = find_var(im,vname))!=-1) return 3;
-    }
-    return 0;
-}
-
-/* rrd_vname_color()
-**
-** Parses "[<vname|number>][#color]" where at least one
-** of the optional strings must exist.
-**
-** Returns an integer describing what was found.
-** If the result is 0, the rrd_error string may be set.
-**
-** ...CVVVV 
-** ---------:-----------------------------------
-** 00000000 : error
-** ....0000 : a value/variable was not found
-** ....0001 : an integer number was found, returned in both l and d
-** ....0010 : a floating point number was found, returned in d
-** ....0011 : reserved for future values
-** ....01xx : reserved for future values
-** ....1000 : an existing  DEF vname was found, idx returned in l
-** ....1001 : an existing CDEF vname was found, idx returned in l
-** ....1010 : an existing VDEF vname was found, idx returned in l
-** ....1011 : reserved for future variables
-** ....11xx : reserved for future variables
-** ...0.... : a color was not found, returned in color
-** ...1.... : a color was found, returned in color
-*/
-static int
-rrd_vname_color(image_desc_t *im, char * param,
-			long *l,
-			double *d,
-			gfx_color_t *color)
-{
-    int result=0,i=0;
-
-    if (param[0]!='#') { /* vname or num present or empty string */
-	char *s,*c=param;
-	while ((*c!='\0')&&(*c!='#')) c++,i++;
-	if (*c!='\0') {
-	    s=malloc(i+1);
-	    if (s==NULL) {
-		rrd_set_error("Out of memory in function rrd_vname_color");
-		return 0;
-	    }
-	    strncpy(s,param,i);
-	    s[i]='\0';
-	    result=rrd_name_or_num(im, s, l, d);
-	    if (!result) {
-		rrd_set_error("Use of uninitialized vname %s",s);
-		free(s);
-	    }
-	} else {
-	    result=rrd_name_or_num(im, param, l, d);
-	    if (!result) {
-		rrd_set_error("Use of uninitialized vname %s",param);
-	    }
-	}
-	switch (result) {
-	    case 0: return 0; /* error set above */
-	    case 1:
-	    case 2: break;
-	    case 3:
-		switch (im->gdes[*l].gf) {
-		    case GF_DEF:	result=0x08;break;
-		    case GF_CDEF:	result=0x09;break;
-		    case GF_VDEF:	result=0x0A;break;
-		    default:
-			rrd_set_error("Unexpected GF result from function "
-			"rrd_name_or_num() called from rrd_vname_color");
-			return 0;
-		}
-		break;
-	    default:
-		rrd_set_error("Unexpected result from function "
-			"rrd_name_or_num() called from rrd_vname_color");
-		return 0;
-	}
-    }
-    /* Parse color, if any. */
-    if (param[i] == '\0') return result;
-    else {
-	unsigned int r=0,g=0,b=0,a=0xFF;
-	int i1=0,i2=0;
-	sscanf(&param[i], "#%02x%02x%02x%n%02x%n",
-				&r,&g,&b,&i1,&a,&i2);
-	if (!i1) {
-	    rrd_set_error("Unparsable color %s",&param[i]);
-	    return 0;
-	}
-	if (i2) i1=i2;
-	i2=0;
-	sscanf(&param[i+i1],"%*s%n",&i2);
-	if (i2) {
-	    rrd_set_error("Garbage after color %s",param[i]);
-	    return 0;
-	}
-	*color=r<<24|g<<16|b<<8|a;
-	return result|0x10;
-    }
-}
-
-/* rrd_find_function()
-**
-** Checks if the parameter is a valid function and
-** if so, returns it in the graph description pointer.
-**
-** The return value is a boolean; true if found
-*/
-static int
-rrd_find_function(char *param, graph_desc_t *gdp)
-{
-    size_t i1=0,i2=0;
-    char funcname[11];
-
-    sscanf(param,"%10[A-Z]%n%*1[1-3]%n",funcname,(int *)&i1,(int *)&i2);
-    gdp->gf=gf_conv(funcname);
-    if ((int)gdp->gf == -1) {
-	rrd_set_error("'%s' is not a valid function name",funcname);
-	return 0;
-    }
-    if (gdp->gf==GF_LINE) {
-	if (i2) {
-	    gdp->linewidth=param[i1]-'0';
-	} else {
-	    rrd_set_error("LINE should have a width");
-	    return 0;
-	}
-    } else {
-	if (i2) {
-	    rrd_set_error("Only LINE should have a width: %s",param);
-	    return 0;
-	} else {
-	    i2=i1;
-	}
-    }
-    if (strlen(param) != i2) {
-	rrd_set_error("Garbage after function name: %s",param);
-	return 0;
-    }
-    return 1;
-}
-/* rrd_split_line()
-**
-** Takes a string as input; splits this line into multiple
-** parameters on each ":" boundary.
-**
-** If this function returns successful, the caller will have
-** to free() the allocated memory for param.
-**
-** The input string is destroyed, its memory is used by the
-** output array.
-*/
-static int
-rrd_split_line(char *line,char ***param)
-{
-    int i=0,n=0;
-    char *c=line;
-
-    /* scan the amount of colons in the line.  We need
-    ** at most this amount+1 pointers for the array. If
-    ** any colons are escaped we waste some space.
-    */
-    if (*c!='\0') n=1;
-    while (*c != '\0')
-	if (*c++ == ':') n++;
-
-    if (n==0) {
-	rrd_set_error("No line to split. rrd_split_line was given the empty string.");
-	return -1;
-    }
-
-    /* Allocate memory for an array of n char pointers */
-    *param=calloc(n,sizeof(char *));
-    if (*param==NULL) {
-	rrd_set_error("Memory allocation failed inside rrd_split_line");
-	return -1;
-    }
-
-    /* split the line and fill the array */
-    c = line;
-    i=0;
-    (*param)[i] = c;
-    while (*c != '\0') {
-	switch (*c) {
-	    case '\\':
-		c++;
-		if (*c=='\0') {
-		    free(*param);
-		    rrd_set_error("Lone backslash found inside rrd_split_line");
-		    return -1;
-		}
-		c++;
-		break;
-	    case ':':
-		*c = '\0';
-		c++;
-		i++;
-		(*param)[i] = c;
-		break;
-	    default:
-		c++;
-	}
-    }
-    i++; /* i separators means i+1 parameters */
-
-    return i;
-}
-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 */    
-    char **	param;
-    int		paramcnt,paramused;
-
-    for (i=optind+1;i<argc;i++) {
-	int		argstart=0;
-	int		strstart=0;
-	graph_desc_t	*gdp;
-	char		*line;
-	char	tmpline[256];
-	char		vname[MAX_VNAME_LEN+1],sep[1];
-/*	double		d;	*/
-	int		j,k,l/*,m*/;
-
-	/* Each command is one element from *argv[].  This command is
-	** split at every unescaped colon.
-	**
-	** 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];
-	strcpy(tmpline,argv[i]);
-	line=tmpline;
-	if ((paramcnt=rrd_split_line(argv[i],&param))==-1) return;
-	paramused=0;
-
-#ifdef DEBUG
-	printf("DEBUG: after splitting line:\n");
-	for (j=0;j<paramcnt;j++)
-	    printf("DEBUG: %3i: %s\n",j,param[j]);
-#endif
-
-	if (!rrd_find_function(param[paramused],gdp)) {
-	    im_free(im);
-	    free(param);
-	    return;
-	}
-	paramused++;
-
-	/* 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
-	*/
-
-/*TEMP*/argstart=strlen(param[paramused-1])+1;
-
-	/* If anything fails just use rrd_set_error() and break from the
-	** switch.  Just after the switch we call rrd_test_error() and
-	** clean up if it is set.
-	*/
-	switch (gdp->gf) {
-	    case GF_XPORT:
-	        break;
-	    case GF_COMMENT:
-		if (paramcnt<2) {
-		    rrd_set_error("Not enough parameters for %s",param[0]);
-		    break;
-		}
-		if (strlen(param[1])>FMT_LEG_LEN) {
-		    rrd_set_error("Comment too long: %s:%s",param[0],param[1]);
-		    break;
-		}
-		strcpy(gdp->legend,param[1]);
-		paramused++;
-		break;
-	    case GF_PART:
-	    case GF_VRULE:
-	    case GF_HRULE:
-		if (paramcnt<2) {
-		    rrd_set_error("No name or number in %s",param[0]);
-		    break;
-		}
-		j=rrd_vname_color(im,param[1],
-				&gdp->xrule,&gdp->yrule,&gdp->col);
-		paramused++;
-		if (!j) break; /* error string set by function */
-		switch (j&0x0F) {
-		    case 0x00:
-			rrd_set_error("Cannot parse name nor number "
-				"in %s:%s",param[0],param[1]);
-			break;
-		    case 0x08:
-		    case 0x09:
-			rrd_set_error("Cannot use DEF or CDEF based "
-				"variable in %s:%s",param[0],param[1]);
-			break;
-		    case 0x0A:
-			gdp->vidx=gdp->xrule;
-			gdp->xrule=0;
-			gdp->yrule=DNAN;
-			break;
-		    case 0x01:
-		    case 0x02:
-			break;
-		    default:
-			rrd_set_error("Unexpected result while parsing "
-				"%s:%s, program error",param[0],param[1]);
-		}
-		if (rrd_test_error()) break;
-
-		if (paramcnt>paramused) {
-		    if (strlen(param[paramused])>FMT_LEG_LEN) {
-			rrd_set_error("Comment too long: %s:%s",
-						param[0],param[1]);
-			break;
-		    }
-		    strcpy(gdp->legend,param[paramused]);
-		    paramused++;
-		}
-		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;
-		if (paramcnt<2) {
-		    rrd_set_error("Nothing following %s",param[0]);
-		    break;
-		}
-		sscanf(param[1], DEF_NAM_FMT "=%n",gdp->vname,&j);
-		if (j==0) {
-		    rrd_set_error("Could not parse %s:%s",param[0],param[1]);
-		    break;
-		}
-		if (find_var(im,gdp->vname)!=-1) {
-		    rrd_set_error("Variable '%s' in %s:%s' already in use\n",
-						gdp->vname,param[0],param[1]);
-		    break;
-		}
-		paramused++;
-		argstart+=j;
-		switch (gdp->gf) {
-		    case GF_DEF:
-			if (strlen(&param[1][j])>MAXPATH) {
-			    rrd_set_error("Path too long: %s:%s",param[0],param[1]);
-			    break;
-			}
-			strcpy(gdp->rrd,&param[1][j]);
-
-			if (paramcnt<3) {
-			    rrd_set_error("No DS for %s:%s",param[0],param[1]);
-			    break;
-			}
-			j=k=0;
-			sscanf(param[2],DS_NAM_FMT "%n%*s%n",gdp->ds_nam,&j,&k);
-			if ((j==0)||(k!=0)) {
-			    rrd_set_error("Cannot parse DS in %s:%s:%s",
-						param[0],param[1],param[2]);
-			    break;
-			}
-			paramused++;
-			if (paramcnt<4) {
-			    rrd_set_error("No CF for %s:%s:%s",
-					param[0],param[1],param[2]);
-			    break;
-			}
-			j=k=0;
-			sscanf(param[3],CF_NAM_FMT "%n%*s%n",symname,&j,&k);
-			if ((j==0)||(k!=0)) {
-			    rrd_set_error("Cannot parse CF in %s:%s:%s:%s",
-					param[0],param[1],param[2],param[3]);
-			    break;
-			}
-			if ((gdp->cf = cf_conv(symname))==-1) {
-			    rrd_set_error("Unknown CF '%s' in %s:%s:%s:%s",
-					param[0],param[1],param[2],param[3]);
-			    break;
-			}
-			paramused++;
-			if (paramcnt>paramused) {
-			    k=0;l=0;
-			    sscanf(param[4],
-					"step=%lu%n%*s%n",
-                                &gdp->step,&k,&l);
-                            if ((k==0)||(l!=0)) {
-                                rrd_set_error("Cannot parse step in "
-							"%s:%s:%s:%s:%s",
-				param[0],param[1],param[2],param[3],param[4]);
-				break;
-                            }
-			    paramused++;
-			}
-			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; 
-    }
+    im->step = max((long)im->step, (im->end-im->start)/im->xsize);
 }
 
 int
@@ -3547,24 +3168,6 @@ 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) {
@@ -3591,9 +3194,9 @@ int bad_format(char *fmt) {
                  if (*ptr == '.') ptr++;
                  while (*ptr >= '0' && *ptr <= '9') ptr++;
   
-                 /* Either 'le' or 'lf' must follow here */
+                 /* Either 'le', 'lf' or 'lg' must follow here */
                  if (*ptr++ != 'l') return 1;
-                 if (*ptr == 'e' || *ptr == 'f') ptr++;
+                 if (*ptr == 'e' || *ptr == 'f' || *ptr == 'g') ptr++;
                  else return 1;
                  n++;
             }
@@ -3617,12 +3220,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'"
@@ -3731,6 +3334,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?'*':' ');