Code

untabified rrd_graph.c
authoroetiker <oetiker@a5681a0c-68f1-0310-ab6d-d61299d08faa>
Tue, 10 Apr 2007 05:43:34 +0000 (05:43 +0000)
committeroetiker <oetiker@a5681a0c-68f1-0310-ab6d-d61299d08faa>
Tue, 10 Apr 2007 05:43:34 +0000 (05:43 +0000)
git-svn-id: svn://svn.oetiker.ch/rrdtool/branches/1.2/program@1032 a5681a0c-68f1-0310-ab6d-d61299d08faa

src/rrd_graph.c

index a23fb107472d8a678f538cdb429cf8f33523d6d5..47c187ad981db4c6ec19046dd95a5639f6220d1c 100644 (file)
@@ -56,7 +56,7 @@ xlab_t xlab[] = {
     {180,         24*3600,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,12,          0,"%a %H:%M"},
     /*{300,             0,   TMT_HOUR,3,    TMT_HOUR,12,   TMT_HOUR,12,    12*3600,"%a %p"},  this looks silly*/
     {600,               0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a"},
-    {1200,             0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%d"},
+    {1200,               0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%d"},
     {1800,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a %d"},
     {2400,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a"},
     {3600,              0,   TMT_DAY,1,     TMT_WEEK,1,    TMT_WEEK,1,   7*24*3600,"Week %V"},
@@ -114,11 +114,11 @@ int
 xtr(image_desc_t *im,time_t mytime){
     static double pixie;
     if (mytime==0){
-       pixie = (double) im->xsize / (double)(im->end - im->start);
-       return im->xorigin;
+        pixie = (double) im->xsize / (double)(im->end - im->start);
+        return im->xorigin;
     }
     return (int)((double)im->xorigin 
-                + pixie * ( mytime - im->start ) );
+                 + pixie * ( mytime - im->start ) );
 }
 
 /* translate data values into y coordinates */
@@ -128,17 +128,17 @@ ytr(image_desc_t *im, double value){
     double yval;
     if (isnan(value)){
       if(!im->logarithmic)
-       pixie = (double) im->ysize / (im->maxval - im->minval);
+        pixie = (double) im->ysize / (im->maxval - im->minval);
       else 
-       pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
+        pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
       yval = im->yorigin;
     } else if(!im->logarithmic) {
       yval = im->yorigin - pixie * (value - im->minval);
     } else {
       if (value < im->minval) {
-       yval = im->yorigin;
+        yval = im->yorigin;
       } else {
-       yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
+        yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
       }
     }
     /* make sure we don't return anything too unreasonable. GD lib can
@@ -220,7 +220,7 @@ enum grc_en grc_conv(char *string){
     conv_if(AXIS,GRC_AXIS)
     conv_if(FRAME,GRC_FRAME)
 
-    return -1; 
+    return -1;        
 }
 
 enum text_prop_en text_prop_conv(char *string){
@@ -239,18 +239,18 @@ enum text_prop_en text_prop_conv(char *string){
 int
 im_free(image_desc_t *im)
 {
-    unsigned long      i,ii;
+    unsigned long        i,ii;
 
     if (im == NULL) return 0;
     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);
-         if (im->gdes[i].ds_namv){
-             for (ii=0;ii<im->gdes[i].ds_cnt;ii++)
-                 free(im->gdes[i].ds_namv[ii]);
-             free(im->gdes[i].ds_namv);
-         }
+        /* careful here, because a single pointer can occur several times */
+          free (im->gdes[i].data);
+          if (im->gdes[i].ds_namv){
+              for (ii=0;ii<im->gdes[i].ds_cnt;ii++)
+                  free(im->gdes[i].ds_namv[ii]);
+              free(im->gdes[i].ds_namv);
+          }
       }
       free (im->gdes[i].p_data);
       free (im->gdes[i].rpnp);
@@ -263,61 +263,61 @@ im_free(image_desc_t *im)
 /* find SI magnitude symbol for the given number*/
 void
 auto_scale(
-          image_desc_t *im,   /* image description */
-          double *value,
-          char **symb_ptr,
-          double *magfact
-          )
+           image_desc_t *im,   /* image description */
+           double *value,
+           char **symb_ptr,
+           double *magfact
+           )
 {
-       
+        
     char *symbol[] = {"a", /* 10e-18 Atto */
-                     "f", /* 10e-15 Femto */
-                     "p", /* 10e-12 Pico */
-                     "n", /* 10e-9  Nano */
-                     "u", /* 10e-6  Micro */
-                     "m", /* 10e-3  Milli */
-                     " ", /* Base */
-                     "k", /* 10e3   Kilo */
-                     "M", /* 10e6   Mega */
-                     "G", /* 10e9   Giga */
-                     "T", /* 10e12  Tera */
-                     "P", /* 10e15  Peta */
-                     "E"};/* 10e18  Exa */
+                      "f", /* 10e-15 Femto */
+                      "p", /* 10e-12 Pico */
+                      "n", /* 10e-9  Nano */
+                      "u", /* 10e-6  Micro */
+                      "m", /* 10e-3  Milli */
+                      " ", /* Base */
+                      "k", /* 10e3   Kilo */
+                      "M", /* 10e6   Mega */
+                      "G", /* 10e9   Giga */
+                      "T", /* 10e12  Tera */
+                      "P", /* 10e15  Peta */
+                      "E"};/* 10e18  Exa */
 
     int symbcenter = 6;
     int sindex;  
 
     if (*value == 0.0 || isnan(*value) ) {
-       sindex = 0;
-       *magfact = 1.0;
+        sindex = 0;
+        *magfact = 1.0;
     } else {
-       sindex = floor(log(fabs(*value))/log((double)im->base)); 
-       *magfact = pow((double)im->base, (double)sindex);
-       (*value) /= (*magfact);
+        sindex = floor(log(fabs(*value))/log((double)im->base)); 
+        *magfact = pow((double)im->base, (double)sindex);
+        (*value) /= (*magfact);
     }
     if ( sindex <= symbcenter && sindex >= -symbcenter) {
-       (*symb_ptr) = symbol[sindex+symbcenter];
+        (*symb_ptr) = symbol[sindex+symbcenter];
     }
     else {
-       (*symb_ptr) = "?";
+        (*symb_ptr) = "?";
     }
 }
 
 
 static char si_symbol[] = {
-                    'a', /* 10e-18 Atto */ 
-                    'f', /* 10e-15 Femto */
-                    'p', /* 10e-12 Pico */
-                    'n', /* 10e-9  Nano */
-                    'u', /* 10e-6  Micro */
-                    'm', /* 10e-3  Milli */
-                    ' ', /* Base */
-                    'k', /* 10e3   Kilo */
-                    'M', /* 10e6   Mega */
-                    'G', /* 10e9   Giga */
-                    'T', /* 10e12  Tera */
-                    'P', /* 10e15  Peta */
-                    'E', /* 10e18  Exa */
+                     'a', /* 10e-18 Atto */ 
+                     'f', /* 10e-15 Femto */
+                     'p', /* 10e-12 Pico */
+                     'n', /* 10e-9  Nano */
+                     'u', /* 10e-6  Micro */
+                     'm', /* 10e-3  Milli */
+                     ' ', /* Base */
+                     'k', /* 10e3   Kilo */
+                     'M', /* 10e6   Mega */
+                     'G', /* 10e9   Giga */
+                     'T', /* 10e12  Tera */
+                     'P', /* 10e15  Peta */
+                     'E', /* 10e18  Exa */
 };
 static const int si_symbcenter = 6;
 
@@ -333,10 +333,10 @@ si_unit(
     digits = floor( log( max( fabs(im->minval),fabs(im->maxval)))/log((double)im->base)); 
 
     if (im->unitsexponent != 9999) {
-       /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */
+        /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */
         viewdigits = floor(im->unitsexponent / 3);
     } else {
-       viewdigits = digits;
+        viewdigits = digits;
     }
 
     im->magfact = pow((double)im->base , digits);
@@ -348,10 +348,10 @@ si_unit(
     im->viewfactor = im->magfact / pow((double)im->base , viewdigits);
 
     if ( ((viewdigits+si_symbcenter) < sizeof(si_symbol)) &&
-                   ((viewdigits+si_symbcenter) >= 0) )
+                    ((viewdigits+si_symbcenter) >= 0) )
         im->symbol = si_symbol[(int)viewdigits+si_symbcenter];
     else
-       im->symbol = '?';
+        im->symbol = '?';
  }
 
 /*  move min and max values around to become sensible */
@@ -360,13 +360,13 @@ void
 expand_range(image_desc_t *im)
 {
     double sensiblevalues[] ={1000.0,900.0,800.0,750.0,700.0,
-                             600.0,500.0,400.0,300.0,250.0,
-                             200.0,125.0,100.0,90.0,80.0,
-                             75.0,70.0,60.0,50.0,40.0,30.0,
-                             25.0,20.0,10.0,9.0,8.0,
-                             7.0,6.0,5.0,4.0,3.5,3.0,
-                             2.5,2.0,1.8,1.5,1.2,1.0,
-                             0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.0,-1};
+                              600.0,500.0,400.0,300.0,250.0,
+                              200.0,125.0,100.0,90.0,80.0,
+                              75.0,70.0,60.0,50.0,40.0,30.0,
+                              25.0,20.0,10.0,9.0,8.0,
+                              7.0,6.0,5.0,4.0,3.5,3.0,
+                              2.5,2.0,1.8,1.5,1.2,1.0,
+                              0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.0,-1};
     
     double scaled_min,scaled_max;  
     double adj;
@@ -376,69 +376,69 @@ expand_range(image_desc_t *im)
     
 #ifdef DEBUG
     printf("Min: %6.2f Max: %6.2f MagFactor: %6.2f\n",
-          im->minval,im->maxval,im->magfact);
+           im->minval,im->maxval,im->magfact);
 #endif
 
     if (isnan(im->ygridstep)){
-       if(im->extra_flags & ALTAUTOSCALE) {
-           /* measure the amplitude of the function. Make sure that
-              graph boundaries are slightly higher then max/min vals
-              so we can see amplitude on the graph */
-             double delt, fact;
-
-             delt = im->maxval - im->minval;
-             adj = delt * 0.1;
-             fact = 2.0 * pow(10.0,
-                   floor(log10(max(fabs(im->minval), fabs(im->maxval))/im->magfact)) - 2);
-             if (delt < fact) {
-               adj = (fact - delt) * 0.55;
+        if(im->extra_flags & ALTAUTOSCALE) {
+            /* measure the amplitude of the function. Make sure that
+               graph boundaries are slightly higher then max/min vals
+               so we can see amplitude on the graph */
+              double delt, fact;
+
+              delt = im->maxval - im->minval;
+              adj = delt * 0.1;
+              fact = 2.0 * pow(10.0,
+                    floor(log10(max(fabs(im->minval), fabs(im->maxval))/im->magfact)) - 2);
+              if (delt < fact) {
+                adj = (fact - delt) * 0.55;
 #ifdef DEBUG
-             printf("Min: %6.2f Max: %6.2f delt: %6.2f fact: %6.2f adj: %6.2f\n", im->minval, im->maxval, delt, fact, adj);
+              printf("Min: %6.2f Max: %6.2f delt: %6.2f fact: %6.2f adj: %6.2f\n", im->minval, im->maxval, delt, fact, adj);
 #endif
-             }
-             im->minval -= adj;
-             im->maxval += adj;
-       }
-       else if(im->extra_flags & ALTAUTOSCALE_MAX) {
-           /* measure the amplitude of the function. Make sure that
-              graph boundaries are slightly higher than max vals
-              so we can see amplitude on the graph */
-             adj = (im->maxval - im->minval) * 0.1;
-             im->maxval += adj;
-       }
-       else {
-           scaled_min = im->minval / im->magfact;
-           scaled_max = im->maxval / im->magfact;
-           
-           for (i=1; sensiblevalues[i] > 0; i++){
-               if (sensiblevalues[i-1]>=scaled_min &&
-                   sensiblevalues[i]<=scaled_min)      
-                   im->minval = sensiblevalues[i]*(im->magfact);
-               
-               if (-sensiblevalues[i-1]<=scaled_min &&
-               -sensiblevalues[i]>=scaled_min)
-                   im->minval = -sensiblevalues[i-1]*(im->magfact);
-               
-               if (sensiblevalues[i-1] >= scaled_max &&
-                   sensiblevalues[i] <= scaled_max)
-                   im->maxval = sensiblevalues[i-1]*(im->magfact);
-               
-               if (-sensiblevalues[i-1]<=scaled_max &&
-                   -sensiblevalues[i] >=scaled_max)
-                   im->maxval = -sensiblevalues[i]*(im->magfact);
-           }
-       }
+              }
+              im->minval -= adj;
+              im->maxval += adj;
+        }
+        else if(im->extra_flags & ALTAUTOSCALE_MAX) {
+            /* measure the amplitude of the function. Make sure that
+               graph boundaries are slightly higher than max vals
+               so we can see amplitude on the graph */
+              adj = (im->maxval - im->minval) * 0.1;
+              im->maxval += adj;
+        }
+        else {
+            scaled_min = im->minval / im->magfact;
+            scaled_max = im->maxval / im->magfact;
+            
+            for (i=1; sensiblevalues[i] > 0; i++){
+                if (sensiblevalues[i-1]>=scaled_min &&
+                    sensiblevalues[i]<=scaled_min)        
+                    im->minval = sensiblevalues[i]*(im->magfact);
+                
+                if (-sensiblevalues[i-1]<=scaled_min &&
+                -sensiblevalues[i]>=scaled_min)
+                    im->minval = -sensiblevalues[i-1]*(im->magfact);
+                
+                if (sensiblevalues[i-1] >= scaled_max &&
+                    sensiblevalues[i] <= scaled_max)
+                    im->maxval = sensiblevalues[i-1]*(im->magfact);
+                
+                if (-sensiblevalues[i-1]<=scaled_max &&
+                    -sensiblevalues[i] >=scaled_max)
+                    im->maxval = -sensiblevalues[i]*(im->magfact);
+            }
+        }
     } else {
-       /* adjust min and max to the grid definition if there is one */
-       im->minval = (double)im->ylabfact * im->ygridstep * 
-           floor(im->minval / ((double)im->ylabfact * im->ygridstep));
-       im->maxval = (double)im->ylabfact * im->ygridstep * 
-           ceil(im->maxval /( (double)im->ylabfact * im->ygridstep));
+        /* adjust min and max to the grid definition if there is one */
+        im->minval = (double)im->ylabfact * im->ygridstep * 
+            floor(im->minval / ((double)im->ylabfact * im->ygridstep));
+        im->maxval = (double)im->ylabfact * im->ygridstep * 
+            ceil(im->maxval /( (double)im->ylabfact * im->ygridstep));
     }
     
 #ifdef DEBUG
     fprintf(stderr,"SCALED Min: %6.2f Max: %6.2f Factor: %6.2f\n",
-          im->minval,im->maxval,im->magfact);
+           im->minval,im->maxval,im->magfact);
 #endif
 }
 
@@ -459,8 +459,8 @@ apply_gridfit(image_desc_t *im)
     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 */
+         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;
@@ -535,11 +535,11 @@ reduce_data(
 #endif
 #ifdef DEBUG_REDUCE
 printf("Reducing %lu rows with factor %i time %lu to %lu, step %lu\n",
-                       row_cnt,reduce_factor,*start,*end,cur_step);
+                        row_cnt,reduce_factor,*start,*end,cur_step);
 for (col=0;col<row_cnt;col++) {
     printf("time %10lu: ",*start+(col+1)*cur_step);
     for (i=0;i<*ds_cnt;i++)
-       printf(" %8.2e",srcptr[*ds_cnt*col+i]);
+        printf(" %8.2e",srcptr[*ds_cnt*col+i]);
     printf("\n");
 }
 #endif
@@ -566,11 +566,11 @@ printf("start_offset: %lu  end_offset: %lu\n",start_offset,end_offset);
 printf("row_cnt before:  %lu\n",row_cnt);
 #endif
     if (start_offset) {
-       (*start) = (*start)-start_offset;
-       skiprows=reduce_factor-start_offset/cur_step;
-       srcptr+=skiprows* *ds_cnt;
+        (*start) = (*start)-start_offset;
+        skiprows=reduce_factor-start_offset/cur_step;
+        srcptr+=skiprows* *ds_cnt;
         for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
-       row_cnt-=skiprows;
+        row_cnt-=skiprows;
     }
 #ifdef DEBUG_REDUCE
 printf("row_cnt between: %lu\n",row_cnt);
@@ -580,9 +580,9 @@ printf("row_cnt between: %lu\n",row_cnt);
     ** used, the amount is end_offset/cur_step
     */
     if (end_offset) {
-       (*end) = (*end)-end_offset+(*step);
-       skiprows = end_offset/cur_step;
-       row_cnt-=skiprows;
+        (*end) = (*end)-end_offset+(*step);
+        skiprows = end_offset/cur_step;
+        row_cnt-=skiprows;
     }
 #ifdef DEBUG_REDUCE
 printf("row_cnt after:   %lu\n",row_cnt);
@@ -592,10 +592,10 @@ printf("row_cnt after:   %lu\n",row_cnt);
 /* if this gets triggered, something is REALLY WRONG ... we die immediately */
 
     if (row_cnt%reduce_factor) {
-       printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
-                               row_cnt,reduce_factor);
-       printf("BUG in reduce_data()\n");
-       exit(1);
+        printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
+                                row_cnt,reduce_factor);
+        printf("BUG in reduce_data()\n");
+        exit(1);
     }
 
     /* Now combine reduce_factor intervals at a time
@@ -603,59 +603,59 @@ printf("row_cnt after:   %lu\n",row_cnt);
     */
 
     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;
-
-           for (i=0;i<reduce_factor;i++) {
-               if (isnan(srcptr[i*(*ds_cnt)+col])) {
-                   continue;
-               }
-               validval++;
-               if (isnan(newval)) newval = srcptr[i*(*ds_cnt)+col];
-               else {
-                   switch (cf) {
-                       case CF_HWPREDICT:
-                       case CF_DEVSEASONAL:
-                       case CF_DEVPREDICT:
-                       case CF_SEASONAL:
-                       case CF_AVERAGE:
-                           newval += srcptr[i*(*ds_cnt)+col];
-                           break;
-                       case CF_MINIMUM:
-                           newval = min (newval,srcptr[i*(*ds_cnt)+col]);
-                           break;
-                       case CF_FAILURES: 
-                       /* an interval contains a failure if any subintervals contained a failure */
-                       case CF_MAXIMUM:
-                           newval = max (newval,srcptr[i*(*ds_cnt)+col]);
-                           break;
-                       case CF_LAST:
-                           newval = srcptr[i*(*ds_cnt)+col];
-                           break;
-                   }
-               }
-           }
-           if (validval == 0){newval = DNAN;} else{
-               switch (cf) {
-                   case CF_HWPREDICT:
-           case CF_DEVSEASONAL:
-                   case CF_DEVPREDICT:
-                   case CF_SEASONAL:
-                   case CF_AVERAGE:                
-                      newval /= validval;
-                       break;
-                   case CF_MINIMUM:
-                   case CF_FAILURES:
-                   case CF_MAXIMUM:
-                   case CF_LAST:
-                       break;
-               }
-           }
-           *dstptr++=newval;
-       }
-       srcptr+=(*ds_cnt)*reduce_factor;
-       row_cnt-=reduce_factor;
+        for (col=0;col<(*ds_cnt);col++) {
+            rrd_value_t newval=DNAN;
+            unsigned long validval=0;
+
+            for (i=0;i<reduce_factor;i++) {
+                if (isnan(srcptr[i*(*ds_cnt)+col])) {
+                    continue;
+                }
+                validval++;
+                if (isnan(newval)) newval = srcptr[i*(*ds_cnt)+col];
+                else {
+                    switch (cf) {
+                        case CF_HWPREDICT:
+                        case CF_DEVSEASONAL:
+                        case CF_DEVPREDICT:
+                        case CF_SEASONAL:
+                        case CF_AVERAGE:
+                            newval += srcptr[i*(*ds_cnt)+col];
+                            break;
+                        case CF_MINIMUM:
+                            newval = min (newval,srcptr[i*(*ds_cnt)+col]);
+                            break;
+                        case CF_FAILURES: 
+                        /* an interval contains a failure if any subintervals contained a failure */
+                        case CF_MAXIMUM:
+                            newval = max (newval,srcptr[i*(*ds_cnt)+col]);
+                            break;
+                        case CF_LAST:
+                            newval = srcptr[i*(*ds_cnt)+col];
+                            break;
+                    }
+                }
+            }
+            if (validval == 0){newval = DNAN;} else{
+                switch (cf) {
+                    case CF_HWPREDICT:
+                case CF_DEVSEASONAL:
+                    case CF_DEVPREDICT:
+                    case CF_SEASONAL:
+                    case CF_AVERAGE:                
+                       newval /= validval;
+                        break;
+                    case CF_MINIMUM:
+                    case CF_FAILURES:
+                     case CF_MAXIMUM:
+                    case CF_LAST:
+                        break;
+                }
+            }
+            *dstptr++=newval;
+        }
+        srcptr+=(*ds_cnt)*reduce_factor;
+        row_cnt-=reduce_factor;
     }
     /* If we had to alter the endtime, we didn't have enough
     ** source rows to fill the last row. Fill it with NaN.
@@ -665,11 +665,11 @@ printf("row_cnt after:   %lu\n",row_cnt);
     row_cnt = ((*end)-(*start))/ *step;
     srcptr = *data;
     printf("Done reducing. Currently %lu rows, time %lu to %lu, step %lu\n",
-                               row_cnt,*start,*end,*step);
+                                row_cnt,*start,*end,*step);
 for (col=0;col<row_cnt;col++) {
     printf("time %10lu: ",*start+(col+1)*(*step));
     for (i=0;i<*ds_cnt;i++)
-       printf(" %8.2e",srcptr[*ds_cnt*col+i]);
+        printf(" %8.2e",srcptr[*ds_cnt*col+i]);
     printf("\n");
 }
 #endif
@@ -683,79 +683,79 @@ int
 data_fetch(image_desc_t *im )
 {
     int i,ii;
-    int                skip;
+    int                skip;
 
     /* pull the data from the rrd files ... */
     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++) {
-           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)
-                       && (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
-                       && (im->gdes[i].start_orig == im->gdes[ii].start_orig)
-                       && (im->gdes[i].end_orig   == im->gdes[ii].end_orig)
-                       && (im->gdes[i].step_orig  == im->gdes[ii].step_orig)) {
-               /* 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;
-               im->gdes[i].ds_cnt = im->gdes[ii].ds_cnt;
-               im->gdes[i].ds_namv = im->gdes[ii].ds_namv;             
-               im->gdes[i].data = im->gdes[ii].data;
-               im->gdes[i].data_first = 0;
-               skip=1;
-           }
-           if (skip) 
-               break;
-       }
-       if (! skip) {
-           unsigned long  ft_step = im->gdes[i].step ; /* ft_step will record what we got from fetch */
-           
-           if((rrd_fetch_fn(im->gdes[i].rrd,
-                            im->gdes[i].cf,
-                            &im->gdes[i].start,
-                            &im->gdes[i].end,
-                            &ft_step,
-                            &im->gdes[i].ds_cnt,
-                            &im->gdes[i].ds_namv,
-                            &im->gdes[i].data)) == -1){                
-               return -1;
-           }
-           im->gdes[i].data_first = 1;     
-       
-           if (ft_step < im->gdes[i].step) {
-               reduce_data(im->gdes[i].cf_reduce,
-                           ft_step,
-                           &im->gdes[i].start,
-                           &im->gdes[i].end,
-                           &im->gdes[i].step,
-                           &im->gdes[i].ds_cnt,
-                           &im->gdes[i].data);
-           } else {
-               im->gdes[i].step = ft_step;
-           }
-       }
-       
+        /* 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++) {
+            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)
+                        && (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
+                        && (im->gdes[i].start_orig == im->gdes[ii].start_orig)
+                        && (im->gdes[i].end_orig   == im->gdes[ii].end_orig)
+                        && (im->gdes[i].step_orig  == im->gdes[ii].step_orig)) {
+                /* 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;
+                im->gdes[i].ds_cnt = im->gdes[ii].ds_cnt;
+                im->gdes[i].ds_namv = im->gdes[ii].ds_namv;                
+                im->gdes[i].data = im->gdes[ii].data;
+                im->gdes[i].data_first = 0;
+                skip=1;
+            }
+            if (skip) 
+                break;
+        }
+        if (! skip) {
+            unsigned long  ft_step = im->gdes[i].step ; /* ft_step will record what we got from fetch */
+            
+            if((rrd_fetch_fn(im->gdes[i].rrd,
+                             im->gdes[i].cf,
+                             &im->gdes[i].start,
+                             &im->gdes[i].end,
+                             &ft_step,
+                             &im->gdes[i].ds_cnt,
+                             &im->gdes[i].ds_namv,
+                             &im->gdes[i].data)) == -1){                
+                return -1;
+            }
+            im->gdes[i].data_first = 1;            
+        
+            if (ft_step < im->gdes[i].step) {
+                reduce_data(im->gdes[i].cf_reduce,
+                            ft_step,
+                            &im->gdes[i].start,
+                            &im->gdes[i].end,
+                            &im->gdes[i].step,
+                            &im->gdes[i].ds_cnt,
+                            &im->gdes[i].data);
+            } else {
+                im->gdes[i].step = ft_step;
+            }
+        }
+        
         /* 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; }
-       }
-       if (im->gdes[i].ds== -1){
-           rrd_set_error("No DS called '%s' in '%s'",
-                         im->gdes[i].ds_nam,im->gdes[i].rrd);
-           return -1; 
-       }
-       
+        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; }
+        }
+        if (im->gdes[i].ds== -1){
+            rrd_set_error("No DS called '%s' in '%s'",
+                          im->gdes[i].ds_nam,im->gdes[i].rrd);
+            return -1; 
+        }
+        
     }
     return 0;
 }
@@ -777,13 +777,13 @@ long
 find_var(image_desc_t *im, char *key){
     long ii;
     for(ii=0;ii<im->gdes_c-1;ii++){
-       if((im->gdes[ii].gf == GF_DEF 
-           || im->gdes[ii].gf == GF_VDEF
-           || im->gdes[ii].gf == GF_CDEF) 
-          && (strcmp(im->gdes[ii].vname,key) == 0)){
-           return ii; 
-       }          
-    }              
+        if((im->gdes[ii].gf == GF_DEF 
+            || im->gdes[ii].gf == GF_VDEF
+            || im->gdes[ii].gf == GF_CDEF) 
+           && (strcmp(im->gdes[ii].vname,key) == 0)){
+            return ii; 
+        }           
+    }                        
     return -1;
 }
 
@@ -794,11 +794,11 @@ lcd(long *num){
     long rest;
     int i;
     for (i=0;num[i+1]!=0;i++){
-       do { 
-           rest=num[i] % num[i+1];
-           num[i]=num[i+1]; num[i+1]=rest;
-       } while (rest!=0);
-       num[i+1] = num[i];
+        do { 
+            rest=num[i] % num[i+1];
+            num[i]=num[i+1]; num[i+1]=rest;
+        } while (rest!=0);
+        num[i+1] = num[i];
     }
 /*    return i==0?num[i]:num[i-1]; */
       return num[i];
@@ -818,180 +818,180 @@ data_calc( image_desc_t *im){
     rpnstack_init(&rpnstack);
 
     for (gdi=0;gdi<im->gdes_c;gdi++){
-       /* Look for GF_VDEF and GF_CDEF in the same loop,
-        * 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.
-                */
-               im->gdes[gdi].ds_cnt = 0;
-               if (vdef_calc(im,gdi)) {
-                   rrd_set_error("Error processing VDEF '%s'"
-                       ,im->gdes[gdi].vname
-                       );
-                   rpnstack_free(&rpnstack);
-                   return -1;
-               }
-               break;
-           case GF_CDEF:
-               im->gdes[gdi].ds_cnt = 1;
-               im->gdes[gdi].ds = 0;
-               im->gdes[gdi].data_first = 1;
-               im->gdes[gdi].start = 0;
-               im->gdes[gdi].end = 0;
-               steparray=NULL;
-               stepcnt = 0;
-               dataidx=-1;
-
-               /* Find the variables in the expression.
-                * - VDEF variables are substituted by their values
-                *   and the opcode is changed into OP_NUMBER.
-                * - CDEF variables are analized for their step size,
-                *   the lowest common denominator of all the step
-                *   sizes of the data sources involved is calculated
-                *   and the resulting number is the step size for the
-                *   resulting data source.
-                */
-               for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
-                   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) { /* this is a VDEF data source */
+        /* Look for GF_VDEF and GF_CDEF in the same loop,
+         * 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.
+                 */
+                im->gdes[gdi].ds_cnt = 0;
+                if (vdef_calc(im,gdi)) {
+                    rrd_set_error("Error processing VDEF '%s'"
+                        ,im->gdes[gdi].vname
+                        );
+                    rpnstack_free(&rpnstack);
+                    return -1;
+                }
+                break;
+            case GF_CDEF:
+                im->gdes[gdi].ds_cnt = 1;
+                im->gdes[gdi].ds = 0;
+                im->gdes[gdi].data_first = 1;
+                im->gdes[gdi].start = 0;
+                im->gdes[gdi].end = 0;
+                steparray=NULL;
+                stepcnt = 0;
+                dataidx=-1;
+
+                /* Find the variables in the expression.
+                 * - VDEF variables are substituted by their values
+                 *   and the opcode is changed into OP_NUMBER.
+                 * - CDEF variables are analized for their step size,
+                 *   the lowest common denominator of all the step
+                 *   sizes of the data sources involved is calculated
+                 *   and the resulting number is the step size for the
+                 *   resulting data source.
+                 */
+                for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
+                    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) { /* this is a VDEF data source */
 #if 0
-                           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: 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);
 #endif
-                           im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
-                           im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
-                       } else { /* normal variables and PREF(variables) */
-
-                           /* add one entry to the array that keeps track of the step sizes of the
-                            * data sources going into the CDEF. */
-                           if ((steparray =
-                                rrd_realloc(steparray,
-                                                        (++stepcnt+1)*sizeof(*steparray)))==NULL){
-                                rrd_set_error("realloc steparray");
-                                rpnstack_free(&rpnstack);
-                                return -1;
-                           };
-
-                           steparray[stepcnt-1] = im->gdes[ptr].step;
-
-                           /* adjust start and end of cdef (gdi) so
-                            * that it runs from the latest start point
-                            * to the earliest endpoint of any of the
-                            * rras involved (ptr)
-                            */
-
-                           if(im->gdes[gdi].start < im->gdes[ptr].start)
-                               im->gdes[gdi].start = im->gdes[ptr].start;
-
-                           if(im->gdes[gdi].end == 0 ||
-                                       im->gdes[gdi].end > im->gdes[ptr].end)
-                               im->gdes[gdi].end = im->gdes[ptr].end;
-               
-                           /* store pointer to the first element of
-                            * the rra providing data for variable,
-                            * further save step size and data source
-                            * count of this rra
-                            */ 
+                            im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
+                            im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
+                        } else { /* normal variables and PREF(variables) */
+
+                            /* add one entry to the array that keeps track of the step sizes of the
+                             * data sources going into the CDEF. */
+                            if ((steparray =
+                                 rrd_realloc(steparray,
+                                                         (++stepcnt+1)*sizeof(*steparray)))==NULL){
+                                  rrd_set_error("realloc steparray");
+                                  rpnstack_free(&rpnstack);
+                                 return -1;
+                            };
+
+                            steparray[stepcnt-1] = im->gdes[ptr].step;
+
+                            /* adjust start and end of cdef (gdi) so
+                             * that it runs from the latest start point
+                             * to the earliest endpoint of any of the
+                             * rras involved (ptr)
+                             */
+
+                            if(im->gdes[gdi].start < im->gdes[ptr].start)
+                                im->gdes[gdi].start = im->gdes[ptr].start;
+
+                            if(im->gdes[gdi].end == 0 ||
+                                        im->gdes[gdi].end > im->gdes[ptr].end)
+                                im->gdes[gdi].end = im->gdes[ptr].end;
+                
+                            /* store pointer to the first element of
+                             * the rra providing data for variable,
+                             * further save step size and data source
+                             * count of this rra
+                             */ 
                             im->gdes[gdi].rpnp[rpi].data   = im->gdes[ptr].data + im->gdes[ptr].ds;
-                           im->gdes[gdi].rpnp[rpi].step   = im->gdes[ptr].step;
-                           im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
+                            im->gdes[gdi].rpnp[rpi].step   = im->gdes[ptr].step;
+                            im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
 
-                           /* backoff the *.data ptr; this is done so
-                            * rpncalc() function doesn't have to treat
-                            * the first case differently
-                            */
-                       } /* if ds_cnt != 0 */
-                   } /* if OP_VARIABLE */
-               } /* loop through all rpi */
+                            /* backoff the *.data ptr; this is done so
+                             * rpncalc() function doesn't have to treat
+                             * the first case differently
+                             */
+                        } /* if ds_cnt != 0 */
+                    } /* if OP_VARIABLE */
+                } /* loop through all rpi */
 
                 /* 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 ||
-                       im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
-                       long ptr  = im->gdes[gdi].rpnp[rpi].ptr;
-                       long diff = im->gdes[gdi].start - im->gdes[ptr].start;
+                    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;
+                        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;
+                            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"
-                               " or CDEF variables are not supported");
-                   rpnstack_free(&rpnstack);
-                   return -1;    
-               }
-               steparray[stepcnt]=0;
-               /* Now find the resulting step.  All steps in all
-                * used RRAs have to be visited
-                */
-               im->gdes[gdi].step = lcd(steparray);
-               free(steparray);
-               if((im->gdes[gdi].data = malloc((
-                               (im->gdes[gdi].end-im->gdes[gdi].start) 
-                                   / im->gdes[gdi].step)
-                                   * sizeof(double)))==NULL){
-                   rrd_set_error("malloc im->gdes[gdi].data");
-                   rpnstack_free(&rpnstack);
-                   return -1;
-               }
-       
-               /* Step through the new cdef results array and
-                * calculate the values
-                */
-               for (now = im->gdes[gdi].start + im->gdes[gdi].step;
-                               now<=im->gdes[gdi].end;
-                               now += im->gdes[gdi].step)
-               {
-                   rpnp_t  *rpnp = im -> gdes[gdi].rpnp;
-
-                   /* 3rd arg of rpn_calc is for OP_VARIABLE lookups;
-                    * in this case we are advancing by timesteps;
-                    * we use the fact that time_t is a synonym for long
-                    */
-                   if (rpn_calc(rpnp,&rpnstack,(long) now, 
-                               im->gdes[gdi].data,++dataidx) == -1) {
-                       /* rpn_calc sets the error string */
-                       rpnstack_free(&rpnstack); 
-                       return -1;
-                   } 
-               } /* enumerate over time steps within a CDEF */
-               break;
-           default:
-               continue;
-       }
+                if(steparray == NULL){
+                    rrd_set_error("rpn expressions without DEF"
+                                " or CDEF variables are not supported");
+                    rpnstack_free(&rpnstack);
+                    return -1;    
+                }
+                steparray[stepcnt]=0;
+                /* Now find the resulting step.  All steps in all
+                 * used RRAs have to be visited
+                 */
+                im->gdes[gdi].step = lcd(steparray);
+                free(steparray);
+                if((im->gdes[gdi].data = malloc((
+                                (im->gdes[gdi].end-im->gdes[gdi].start) 
+                                    / im->gdes[gdi].step)
+                                    * sizeof(double)))==NULL){
+                    rrd_set_error("malloc im->gdes[gdi].data");
+                    rpnstack_free(&rpnstack);
+                    return -1;
+                }
+        
+                /* Step through the new cdef results array and
+                 * calculate the values
+                 */
+                for (now = im->gdes[gdi].start + im->gdes[gdi].step;
+                                now<=im->gdes[gdi].end;
+                                now += im->gdes[gdi].step)
+                {
+                    rpnp_t  *rpnp = im -> gdes[gdi].rpnp;
+
+                    /* 3rd arg of rpn_calc is for OP_VARIABLE lookups;
+                     * in this case we are advancing by timesteps;
+                     * we use the fact that time_t is a synonym for long
+                     */
+                    if (rpn_calc(rpnp,&rpnstack,(long) now, 
+                                im->gdes[gdi].data,++dataidx) == -1) {
+                        /* rpn_calc sets the error string */
+                        rpnstack_free(&rpnstack); 
+                        return -1;
+                    
+                } /* enumerate over time steps within a CDEF */
+                break;
+            default:
+                continue;
+        }
     } /* enumerate over CDEFs */
     rpnstack_free(&rpnstack);
     return 0;
@@ -1002,8 +1002,8 @@ int
 data_proc( image_desc_t *im ){
     long i,ii;
     double pixstep = (double)(im->end-im->start)
-       /(double)im->xsize; /* how much time 
-                              passes in one pixel */
+        /(double)im->xsize; /* how much time 
+                               passes in one pixel */
     double paintval;
     double minval=DNAN,maxval=DNAN;
     
@@ -1011,77 +1011,77 @@ data_proc( image_desc_t *im ){
 
     /* 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)) {
-           if((im->gdes[i].p_data = malloc((im->xsize +1)
-                                       * sizeof(rrd_value_t)))==NULL){
-               rrd_set_error("malloc data_proc");
-               return -1;
-           }
-       }
-    }
-
-    for (i=0;i<im->xsize;i++) {        /* for each pixel */
-       long vidx;
-       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:
-               case GF_TICK:
-                   if (!im->gdes[ii].stack)
-                       paintval = 0.0;
-                   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 ) &&
-                             ! (im->logarithmic && paintval <= 0.0)) 
-                                       minval = paintval;
-                           if (isnan(maxval) || paintval >  maxval)
-                               maxval = paintval;
-                       }
-                   } else {
-                       im->gdes[ii].p_data[i] = DNAN;
-                   }
-                   break;
-               case GF_STACK:
+        if((im->gdes[i].gf==GF_LINE) ||
+                (im->gdes[i].gf==GF_AREA) ||
+                (im->gdes[i].gf==GF_TICK)) {
+            if((im->gdes[i].p_data = malloc((im->xsize +1)
+                                        * sizeof(rrd_value_t)))==NULL){
+                rrd_set_error("malloc data_proc");
+                return -1;
+            }
+        }
+    }
+
+    for (i=0;i<im->xsize;i++) {        /* for each pixel */
+        long vidx;
+        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:
+                case GF_TICK:
+                    if (!im->gdes[ii].stack)
+                        paintval = 0.0;
+                    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 ) &&
+                              ! (im->logarithmic && paintval <= 0.0)) 
+                                        minval = paintval;
+                            if (isnan(maxval) || paintval >  maxval)
+                                maxval = paintval;
+                        }
+                    } else {
+                        im->gdes[ii].p_data[i] = DNAN;
+                    }
+                    break;
+                case GF_STACK:
                     rrd_set_error("STACK should already be turned into LINE or AREA here");
                     return -1;
                     break;
-               default:
-                   break;
-           }
-       }
+                default:
+                    break;
+            }
+        }
     }
 
     /* if min or max have not been asigned a value this is because
@@ -1089,31 +1089,31 @@ data_proc( image_desc_t *im ){
        lets set these to dummy values then ... */
 
     if (im->logarithmic) {
-       if (isnan(minval)) minval = 0.2;
-       if (isnan(maxval)) maxval = 5.1;
+        if (isnan(minval)) minval = 0.2;
+        if (isnan(maxval)) maxval = 5.1;
     }
     else {
-       if (isnan(minval)) minval = 0.0;
-       if (isnan(maxval)) maxval = 1.0;
+        if (isnan(minval)) minval = 0.0;
+        if (isnan(maxval)) maxval = 1.0;
     }
     
     /* adjust min and max values */
     if (isnan(im->minval) 
-       /* don't adjust low-end with log scale */ /* why not? */
-       || ((!im->rigid) && im->minval > minval)
-       ) {
-       if (im->logarithmic)
-           im->minval = minval * 0.5;
-       else
-           im->minval = minval;
+        /* don't adjust low-end with log scale */ /* why not? */
+        || ((!im->rigid) && im->minval > minval)
+        ) {
+        if (im->logarithmic)
+            im->minval = minval * 0.5;
+        else
+            im->minval = minval;
     }
     if (isnan(im->maxval) 
-       || (!im->rigid && im->maxval < maxval)
-       ) {
-       if (im->logarithmic)
-           im->maxval = maxval * 2.0;
-       else
-           im->maxval = maxval;
+        || (!im->rigid && im->maxval < maxval)
+        ) {
+        if (im->logarithmic)
+            im->maxval = maxval * 2.0;
+        else
+            im->maxval = maxval;
     }
     /* make sure min is smaller than max */
     if (im->minval > im->maxval) {
@@ -1122,14 +1122,14 @@ data_proc( image_desc_t *im ){
                       
     /* 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.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;
 }
@@ -1149,43 +1149,43 @@ find_first_time(
     localtime_r(&start, &tm);
     switch(baseint){
     case TMT_SECOND:
-       tm.tm_sec -= tm.tm_sec % basestep; break;
+        tm.tm_sec -= tm.tm_sec % basestep; break;
     case TMT_MINUTE: 
-       tm.tm_sec=0;
-       tm.tm_min -= tm.tm_min % basestep; 
-       break;
+        tm.tm_sec=0;
+        tm.tm_min -= tm.tm_min % basestep; 
+        break;
     case TMT_HOUR:
-       tm.tm_sec=0;
-       tm.tm_min = 0;
-       tm.tm_hour -= tm.tm_hour % basestep; break;
+        tm.tm_sec=0;
+        tm.tm_min = 0;
+        tm.tm_hour -= tm.tm_hour % basestep; break;
     case TMT_DAY:
-       /* we do NOT look at the basestep for this ... */
-       tm.tm_sec=0;
-       tm.tm_min = 0;
-       tm.tm_hour = 0; break;
+        /* we do NOT look at the basestep for this ... */
+        tm.tm_sec=0;
+        tm.tm_min = 0;
+        tm.tm_hour = 0; break;
     case TMT_WEEK:
-       /* we do NOT look at the basestep for this ... */
-       tm.tm_sec=0;
-       tm.tm_min = 0;
-       tm.tm_hour = 0;
-       tm.tm_mday -= tm.tm_wday -1;    /* -1 because we want the monday */
-       if (tm.tm_wday==0) tm.tm_mday -= 7; /* we want the *previous* monday */
-       break;
+        /* we do NOT look at the basestep for this ... */
+        tm.tm_sec=0;
+        tm.tm_min = 0;
+        tm.tm_hour = 0;
+        tm.tm_mday -= tm.tm_wday -1;        /* -1 because we want the monday */
+        if (tm.tm_wday==0) tm.tm_mday -= 7; /* we want the *previous* monday */
+        break;
     case TMT_MONTH:
-       tm.tm_sec=0;
-       tm.tm_min = 0;
-       tm.tm_hour = 0;
-       tm.tm_mday = 1;
-       tm.tm_mon -= tm.tm_mon % basestep; break;
+        tm.tm_sec=0;
+        tm.tm_min = 0;
+        tm.tm_hour = 0;
+        tm.tm_mday = 1;
+        tm.tm_mon -= tm.tm_mon % basestep; break;
 
     case TMT_YEAR:
-       tm.tm_sec=0;
-       tm.tm_min = 0;
-       tm.tm_hour = 0;
-       tm.tm_mday = 1;
-       tm.tm_mon = 0;
-       tm.tm_year -= (tm.tm_year+1900) % basestep;
-       
+        tm.tm_sec=0;
+        tm.tm_min = 0;
+        tm.tm_hour = 0;
+        tm.tm_mday = 1;
+        tm.tm_mon = 0;
+        tm.tm_year -= (tm.tm_year+1900) % basestep;
+        
     }
     return mktime(&tm);
 }
@@ -1201,27 +1201,27 @@ find_next_time(
     time_t madetime;
     localtime_r(&current, &tm);
     do {
-       switch(baseint){
-       case TMT_SECOND:
-           tm.tm_sec += basestep; break;
-       case TMT_MINUTE: 
-           tm.tm_min += basestep; break;
-       case TMT_HOUR:
-           tm.tm_hour += basestep; break;
-       case TMT_DAY:
-           tm.tm_mday += basestep; break;
-       case TMT_WEEK:
-           tm.tm_mday += 7*basestep; break;
-       case TMT_MONTH:
-           tm.tm_mon += basestep; break;
-       case TMT_YEAR:
-           tm.tm_year += basestep;     
-       }
-       madetime = mktime(&tm);
+        switch(baseint){
+        case TMT_SECOND:
+            tm.tm_sec += basestep; break;
+        case TMT_MINUTE: 
+            tm.tm_min += basestep; break;
+        case TMT_HOUR:
+            tm.tm_hour += basestep; break;
+        case TMT_DAY:
+            tm.tm_mday += basestep; break;
+        case TMT_WEEK:
+            tm.tm_mday += 7*basestep; break;
+        case TMT_MONTH:
+            tm.tm_mon += basestep; break;
+        case TMT_YEAR:
+            tm.tm_year += basestep;        
+        }
+        madetime = mktime(&tm);
     } while (madetime == -1); /* this is necessary to skip impssible times
-                                like the daylight saving time skips */
+                                 like the daylight saving time skips */
     return madetime;
-         
+          
 }
 
 
@@ -1235,7 +1235,7 @@ print_calc(image_desc_t *im, char ***prdata)
     struct tm tmvdef;
     int graphelement = 0;
     long vidx;
-    int max_ii;        
+    int max_ii;        
     double magfact = -1;
     char *si_symb = "";
     char *percent_s;
@@ -1245,153 +1245,153 @@ print_calc(image_desc_t *im, char ***prdata)
     localtime_r(&now,&tmvdef);
     if (im->imginfo) prlines++;
     for(i=0;i<im->gdes_c;i++){
-       switch(im->gdes[i].gf){
-       case GF_PRINT:
-           prlines++;
-           if(((*prdata) = rrd_realloc((*prdata),prlines*sizeof(char *)))==NULL){
-               rrd_set_error("realloc prdata");
-               return 0;
-           }
-       case GF_GPRINT:
-           /* PRINT and GPRINT can now print VDEF generated values.
-            * There's no need to do any calculations on them as these
-            * calculations were already made.
-            */
-           vidx = im->gdes[i].vidx;
-           if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
-               printval = im->gdes[vidx].vf.val;
-               localtime_r(&im->gdes[vidx].vf.when,&tmvdef);
-           } else { /* need to calculate max,min,avg etcetera */
-               max_ii =((im->gdes[vidx].end 
-                       - im->gdes[vidx].start)
-                       / im->gdes[vidx].step
-                       * im->gdes[vidx].ds_cnt);
-               printval = DNAN;
-               validsteps = 0;
-               for(    ii=im->gdes[vidx].ds;
-                       ii < max_ii;
-                       ii+=im->gdes[vidx].ds_cnt){
-                   if (! finite(im->gdes[vidx].data[ii]))
-                       continue;
-                   if (isnan(printval)){
-                       printval = im->gdes[vidx].data[ii];
-                       validsteps++;
-                       continue;
-                   }
-
-                   switch (im->gdes[i].cf){
-                       case CF_HWPREDICT:
-                       case CF_DEVPREDICT:
-                       case CF_DEVSEASONAL:
-                       case CF_SEASONAL:
-                       case CF_AVERAGE:
-                           validsteps++;
-                           printval += im->gdes[vidx].data[ii];
-                           break;
-                       case CF_MINIMUM:
-                           printval = min( printval, im->gdes[vidx].data[ii]);
-                           break;
-                       case CF_FAILURES:
-                       case CF_MAXIMUM:
-                           printval = max( printval, im->gdes[vidx].data[ii]);
-                           break;
-                       case CF_LAST:
-                           printval = im->gdes[vidx].data[ii];
-                   }
-               }
-               if (im->gdes[i].cf==CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
-                   if (validsteps > 1) {
-                       printval = (printval / validsteps);
-                   }
-               }
-           } /* prepare printval */
-
-           if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
-               /* Magfact is set to -1 upon entry to print_calc.  If it
-                * is still less than 0, then we need to run auto_scale.
-                * Otherwise, put the value into the correct units.  If
-                * the value is 0, then do not set the symbol or magnification
-                * so next the calculation will be performed again. */
-               if (magfact < 0.0) {
-                   auto_scale(im,&printval,&si_symb,&magfact);
-                   if (printval == 0.0)
-                       magfact = -1.0;
-               } else {
-                   printval /= magfact;
-               }
-               *(++percent_s) = 's';
-           } else if (strstr(im->gdes[i].format,"%s") != NULL) {
-               auto_scale(im,&printval,&si_symb,&magfact);
-           }
+            vidx = im->gdes[i].vidx;
+        switch(im->gdes[i].gf){
+        case GF_PRINT:
+            prlines++;
+            if(((*prdata) = rrd_realloc((*prdata),prlines*sizeof(char *)))==NULL){
+                rrd_set_error("realloc prdata");
+                return 0;
+            }
+        case GF_GPRINT:
+            /* PRINT and GPRINT can now print VDEF generated values.
+             * There's no need to do any calculations on them as these
+             * calculations were already made.
+             */
+            if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
+                printval = im->gdes[vidx].vf.val;
+                localtime_r(&im->gdes[vidx].vf.when,&tmvdef);
+            } else { /* need to calculate max,min,avg etcetera */
+                max_ii =((im->gdes[vidx].end 
+                        - im->gdes[vidx].start)
+                        / im->gdes[vidx].step
+                        * im->gdes[vidx].ds_cnt);
+                printval = DNAN;
+                validsteps = 0;
+                for(        ii=im->gdes[vidx].ds;
+                        ii < max_ii;
+                        ii+=im->gdes[vidx].ds_cnt){
+                    if (! finite(im->gdes[vidx].data[ii]))
+                        continue;
+                    if (isnan(printval)){
+                        printval = im->gdes[vidx].data[ii];
+                        validsteps++;
+                        continue;
+                    }
+
+                    switch (im->gdes[i].cf){
+                        case CF_HWPREDICT:
+                        case CF_DEVPREDICT:
+                        case CF_DEVSEASONAL:
+                        case CF_SEASONAL:
+                        case CF_AVERAGE:
+                            validsteps++;
+                            printval += im->gdes[vidx].data[ii];
+                            break;
+                        case CF_MINIMUM:
+                            printval = min( printval, im->gdes[vidx].data[ii]);
+                            break;
+                        case CF_FAILURES:
+                        case CF_MAXIMUM:
+                            printval = max( printval, im->gdes[vidx].data[ii]);
+                            break;
+                        case CF_LAST:
+                            printval = im->gdes[vidx].data[ii];
+                    }
+                }
+                if (im->gdes[i].cf==CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
+                    if (validsteps > 1) {
+                        printval = (printval / validsteps);
+                    }
+                }
+            } /* prepare printval */
+
+            if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
+                /* Magfact is set to -1 upon entry to print_calc.  If it
+                 * is still less than 0, then we need to run auto_scale.
+                 * Otherwise, put the value into the correct units.  If
+                 * the value is 0, then do not set the symbol or magnification
+                 * so next the calculation will be performed again. */
+                if (magfact < 0.0) {
+                    auto_scale(im,&printval,&si_symb,&magfact);
+                    if (printval == 0.0)
+                        magfact = -1.0;
+                } else {
+                    printval /= magfact;
+                }
+                *(++percent_s) = 's';
+            } else if (strstr(im->gdes[i].format,"%s") != NULL) {
+                auto_scale(im,&printval,&si_symb,&magfact);
+            }
 
             if (im->gdes[i].gf == GF_PRINT){
-               (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
-               (*prdata)[prlines-1] = NULL;
+                (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
+                (*prdata)[prlines-1] = NULL;
                 if (im->gdes[i].strftm){
-                       strftime((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
+                        strftime((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
                 } else {
-                 if (bad_format(im->gdes[i].format)) {
-                       rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
-                       return -1;
-                 }
+                     if (bad_format(im->gdes[i].format)) {
+                          rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
+                        return -1;
+                  }
 
 #ifdef HAVE_SNPRINTF
-                 snprintf((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,printval,si_symb);
+                  snprintf((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,printval,si_symb);
 #else
-                 sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
+                  sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
 #endif
                }
              } else {
-               /* GF_GPRINT */
+                /* GF_GPRINT */
 
                 if (im->gdes[i].strftm){
-                       strftime(im->gdes[i].legend,FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
+                        strftime(im->gdes[i].legend,FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
                 } else {
-                 if (bad_format(im->gdes[i].format)) {
-                       rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
-                       return -1;
-                 }
+                    if (bad_format(im->gdes[i].format)) {
+                        rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
+                        return -1;
+                  }
 #ifdef HAVE_SNPRINTF
-                 snprintf(im->gdes[i].legend,FMT_LEG_LEN-2,im->gdes[i].format,printval,si_symb);
+                  snprintf(im->gdes[i].legend,FMT_LEG_LEN-2,im->gdes[i].format,printval,si_symb);
 #else
-                 sprintf(im->gdes[i].legend,im->gdes[i].format,printval,si_symb);
+                  sprintf(im->gdes[i].legend,im->gdes[i].format,printval,si_symb);
 #endif
                 }
-               graphelement = 1;               
-           }       
-           break;
-       case GF_LINE:
-       case GF_AREA:
-       case GF_TICK:
-           graphelement = 1;
-           break;
-       case GF_HRULE:
+                graphelement = 1;               
+            }            
+            break;
+        case GF_LINE:
+        case GF_AREA:
+        case GF_TICK:
+            graphelement = 1;
+            break;
+        case GF_HRULE:
             if(isnan(im->gdes[i].yrule)) { /* we must set this here or the legend printer can not decide to print the legend */
                im->gdes[i].yrule=im->gdes[vidx].vf.val;
             };
-           graphelement = 1;
-           break;
-       case GF_VRULE:
+            graphelement = 1;
+            break;
+        case GF_VRULE:
             if(im->gdes[i].xrule == 0) { /* again ... the legend printer needs it*/
               im->gdes[i].xrule = im->gdes[vidx].vf.when;
             };
-           graphelement = 1;
-           break;
+            graphelement = 1;
+            break;
         case GF_COMMENT:
-       case GF_DEF:
-       case GF_CDEF:       
-       case GF_VDEF:       
+        case GF_DEF:
+        case GF_CDEF:            
+        case GF_VDEF:            
 #ifdef WITH_PIECHART
-       case GF_PART:
+        case GF_PART:
 #endif
-       case GF_SHIFT:
-       case GF_XPORT:
-           break;
-       case GF_STACK:
+        case GF_SHIFT:
+        case GF_XPORT:
+            break;
+        case GF_STACK:
             rrd_set_error("STACK should already be turned into LINE or AREA here");
             return -1;
             break;
-       }
+        }
     }
     return graphelement;
 }
@@ -1421,46 +1421,46 @@ leg_place(image_desc_t *im)
     }
 
     for(i=0;i<im->gdes_c;i++){
-       fill_last = fill;
+        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 ? */ 
-       /* 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';
-       } else {
-           prt_fctn = '\0';
-       }
-       /* only valid control codes */
+        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 ? */ 
+        /* 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';
+        } else {
+            prt_fctn = '\0';
+        }
+        /* only valid control codes */
         if (prt_fctn != 'l' && 
-           prt_fctn != 'n' && /* a synonym for l */
-           prt_fctn != 'r' &&
-           prt_fctn != 'j' &&
-           prt_fctn != 'c' &&
-           prt_fctn != 's' &&
+            prt_fctn != 'n' && /* a synonym for l */
+            prt_fctn != 'r' &&
+            prt_fctn != 'j' &&
+            prt_fctn != 'c' &&
+            prt_fctn != 's' &&
             prt_fctn != 't' &&
             prt_fctn != '\0' &&
             prt_fctn != 'g' ) {
-              free(legspace);
-              rrd_set_error("Unknown control code at the end of '%s\\%c'",im->gdes[i].legend,prt_fctn);
-                      return -1;
+               free(legspace);
+               rrd_set_error("Unknown control code at the end of '%s\\%c'",im->gdes[i].legend,prt_fctn);
+                      return -1;
 
-       }
+        }
 
         /* remove exess space */
         if ( prt_fctn == 'n' ){
@@ -1468,89 +1468,89 @@ leg_place(image_desc_t *im)
         }
 
         while (prt_fctn=='g' && 
-              leg_cc > 0 && 
-              im->gdes[i].legend[leg_cc-1]==' '){
-          leg_cc--;
-          im->gdes[i].legend[leg_cc]='\0';
-       }
-       if (leg_cc != 0 ){
-          legspace[i]=(prt_fctn=='g' ? 0 : interleg);
-          
-          if (fill > 0){ 
-              /* no interleg space if string ends in \g */
-              fill += legspace[i];
-           }
-          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, 0);
-           leg_c++;
-       } else {
-          legspace[i]=0;
-       }
+               leg_cc > 0 && 
+               im->gdes[i].legend[leg_cc-1]==' '){
+           leg_cc--;
+           im->gdes[i].legend[leg_cc]='\0';
+        }
+        if (leg_cc != 0 ){
+           legspace[i]=(prt_fctn=='g' ? 0 : interleg);
+           
+           if (fill > 0){ 
+                /* no interleg space if string ends in \g */
+               fill += legspace[i];
+            }
+           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, 0);
+            leg_c++;
+        } else {
+           legspace[i]=0;
+        }
         /* who said there was a special tag ... ?*/
-       if (prt_fctn=='g') {    
-          prt_fctn = '\0';
-       }
-       if (prt_fctn == '\0') {
-           if (i == im->gdes_c -1 ) prt_fctn ='l';
-           
-           /* is it time to place the legends ? */
-           if (fill > im->ximg - 2*border){
-               if (leg_c > 1) {
-                   /* go back one */
-                   i--; 
-                   fill = fill_last;
-                   leg_c--;
-                   prt_fctn = 'j';
-               } else {
-                   prt_fctn = 'l';
-               }
-               
-           }
-       }
-
-
-       if (prt_fctn != '\0'){  
-           leg_x = border;
-           if (leg_c >= 2 && prt_fctn == 'j') {
-               glue = (im->ximg - fill - 2* border) / (leg_c-1);
-           } else {
-               glue = 0;
-           }
-           if (prt_fctn =='c') leg_x =  (im->ximg - fill) / 2.0;
-           if (prt_fctn =='r') leg_x =  im->ximg - fill - border;
-
-           for(ii=mark;ii<=i;ii++){
-               if(im->gdes[ii].legend[0]=='\0')
-                   continue; /* skip empty legends */
-               im->gdes[ii].leg_x = leg_x;
-               im->gdes[ii].leg_y = leg_y;
-               leg_x += 
-                gfx_get_text_width(im->canvas, leg_x,
-                                     im->text_prop[TEXT_PROP_LEGEND].font,
-                                     im->text_prop[TEXT_PROP_LEGEND].size,
-                                     im->tabwidth,
-                                     im->gdes[ii].legend, 0) 
-                  + legspace[ii]
-                  + glue;
-           }                   
+        if (prt_fctn=='g') {    
+           prt_fctn = '\0';
+        }
+        if (prt_fctn == '\0') {
+            if (i == im->gdes_c -1 ) prt_fctn ='l';
+            
+            /* is it time to place the legends ? */
+            if (fill > im->ximg - 2*border){
+                if (leg_c > 1) {
+                    /* go back one */
+                    i--; 
+                    fill = fill_last;
+                    leg_c--;
+                    prt_fctn = 'j';
+                } else {
+                    prt_fctn = 'l';
+                }
+                
+            }
+        }
+
+
+        if (prt_fctn != '\0'){        
+            leg_x = border;
+            if (leg_c >= 2 && prt_fctn == 'j') {
+                glue = (im->ximg - fill - 2* border) / (leg_c-1);
+            } else {
+                glue = 0;
+            }
+            if (prt_fctn =='c') leg_x =  (im->ximg - fill) / 2.0;
+            if (prt_fctn =='r') leg_x =  im->ximg - fill - border;
+
+            for(ii=mark;ii<=i;ii++){
+                if(im->gdes[ii].legend[0]=='\0')
+                    continue; /* skip empty legends */
+                im->gdes[ii].leg_x = leg_x;
+                im->gdes[ii].leg_y = leg_y;
+                leg_x += 
+                 gfx_get_text_width(im->canvas, leg_x,
+                                      im->text_prop[TEXT_PROP_LEGEND].font,
+                                      im->text_prop[TEXT_PROP_LEGEND].size,
+                                      im->tabwidth,
+                                      im->gdes[ii].legend, 0) 
+                   + legspace[ii]
+                   + glue;
+            }                        
             leg_y_prev = leg_y;
             /* only add y space if there was text on the line */
             if (leg_x > border || prt_fctn == 's')            
-              leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
-           if (prt_fctn == 's')
-               leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;    
-           fill = 0;
-           leg_c = 0;
-           mark = ii;
-       }          
+               leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
+            if (prt_fctn == 's')
+               leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;           
+            fill = 0;
+            leg_c = 0;
+            mark = ii;
+        }           
     }
     im->yimg = leg_y_prev;
     /* if we did place some legends we have to add vertical space */
     if (leg_y != im->yimg){
-       im->yimg += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
+        im->yimg += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
     }
     free(legspace);
   }
@@ -1578,70 +1578,70 @@ calc_horizontal_grid(image_desc_t   *im)
     range =  im->maxval - im->minval;
     scaledrange = range / im->magfact;
 
-       /* does the scale of this graph make it impossible to put lines
-          on it? If so, give up. */
-       if (isnan(scaledrange)) {
-               return 0;
-       }
+        /* does the scale of this graph make it impossible to put lines
+           on it? If so, give up. */
+        if (isnan(scaledrange)) {
+                return 0;
+        }
 
     /* find grid spaceing */
     pixel=1;
     if(isnan(im->ygridstep)){
-       if(im->extra_flags & ALTYGRID) {
-           /* find the value with max number of digits. Get number of digits */
-           decimals = ceil(log10(max(fabs(im->maxval), fabs(im->minval))*im->viewfactor/im->magfact));
-           if(decimals <= 0) /* everything is small. make place for zero */
-               decimals = 1;
-           
-           im->ygrid_scale.gridstep = pow((double)10, floor(log10(range*im->viewfactor/im->magfact)))/im->viewfactor*im->magfact;
-           
-           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/im->ygrid_scale.gridstep < 5)
+        if(im->extra_flags & ALTYGRID) {
+            /* find the value with max number of digits. Get number of digits */
+            decimals = ceil(log10(max(fabs(im->maxval), fabs(im->minval))*im->viewfactor/im->magfact));
+            if(decimals <= 0) /* everything is small. make place for zero */
+                decimals = 1;
+            
+            im->ygrid_scale.gridstep = pow((double)10, floor(log10(range*im->viewfactor/im->magfact)))/im->viewfactor*im->magfact;
+            
+            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/im->ygrid_scale.gridstep < 5)
                 im->ygrid_scale.gridstep /= 10;
-           if(range/im->ygrid_scale.gridstep > 15)
+            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 {
-               im->ygrid_scale.gridstep /= 5;
-               im->ygrid_scale.labfact = 5;
-           }
-           fractionals = floor(log10(im->ygrid_scale.gridstep*(double)im->ygrid_scale.labfact*im->viewfactor/im->magfact));
-           if(fractionals < 0) { /* small amplitude. */
-               int len = decimals - fractionals + 1;
-               if (im->unitslength < len+2) im->unitslength = len+2;
-               sprintf(im->ygrid_scale.labfmt, "%%%d.%df%s", len, -fractionals,(im->symbol != ' ' ? " %c" : ""));
-           } else {
-               int len = decimals + 1;
-               if (im->unitslength < len+2) im->unitslength = len+2;
-               sprintf(im->ygrid_scale.labfmt, "%%%d.0f%s", len, ( im->symbol != ' ' ? " %c" : "" ));
-           }
-       }
-       else {
-           for(i=0;ylab[i].grid > 0;i++){
-               pixel = im->ysize / (scaledrange / ylab[i].grid);
-               gridind = i;
-               if (pixel > 7)
+            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 {
+                im->ygrid_scale.gridstep /= 5;
+                im->ygrid_scale.labfact = 5;
+            }
+            fractionals = floor(log10(im->ygrid_scale.gridstep*(double)im->ygrid_scale.labfact*im->viewfactor/im->magfact));
+            if(fractionals < 0) { /* small amplitude. */
+                int len = decimals - fractionals + 1;
+                if (im->unitslength < len+2) im->unitslength = len+2;
+                sprintf(im->ygrid_scale.labfmt, "%%%d.%df%s", len, -fractionals,(im->symbol != ' ' ? " %c" : ""));
+            } else {
+                int len = decimals + 1;
+                if (im->unitslength < len+2) im->unitslength = len+2;
+                sprintf(im->ygrid_scale.labfmt, "%%%d.0f%s", len, ( im->symbol != ' ' ? " %c" : "" ));
+            }
+        }
+        else {
+            for(i=0;ylab[i].grid > 0;i++){
+                pixel = im->ysize / (scaledrange / ylab[i].grid);
+                   gridind = i;
+                if (pixel > 7)
                     break;
-           }
-           
-           for(i=0; i<4;i++) {
-              if (pixel * ylab[gridind].lfac[i] >=  2.5 * im->text_prop[TEXT_PROP_AXIS].size) {
-                 im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
-                 break;
+            }
+            
+            for(i=0; i<4;i++) {
+               if (pixel * ylab[gridind].lfac[i] >=  2.5 * im->text_prop[TEXT_PROP_AXIS].size) {
+                  im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
+                  break;
                }
-           } 
-           
-           im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
-       }
+            
+            
+            im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
+        }
     } else {
-       im->ygrid_scale.gridstep = im->ygridstep;
-       im->ygrid_scale.labfact = im->ylabfact;
+        im->ygrid_scale.gridstep = im->ygridstep;
+        im->ygrid_scale.labfact = im->ylabfact;
     }
     return 1;
 }
@@ -1664,57 +1664,57 @@ int draw_horizontal_grid(image_desc_t *im)
        double Y0=ytr(im,im->ygrid_scale.gridstep*i);
        double YN=ytr(im,im->ygrid_scale.gridstep*(i+1));
        if ( Y0 >= im->yorigin-im->ysize
-                && Y0 <= im->yorigin){       
-           /* Make sure at least 2 grid labels are shown, even if it doesn't agree
-              with the chosen settings. Add a label if required by settings, or if
-              there is only one label so far and the next grid line is out of bounds. */
-           if(i % im->ygrid_scale.labfact == 0 || ( nlabels==1 && (YN < im->yorigin-im->ysize || YN > im->yorigin) )){         
-               if (im->symbol == ' ') {
-                   if(im->extra_flags & ALTYGRID) {
-                       sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i);
+                 && Y0 <= im->yorigin){       
+            /* Make sure at least 2 grid labels are shown, even if it doesn't agree
+               with the chosen settings. Add a label if required by settings, or if
+               there is only one label so far and the next grid line is out of bounds. */
+            if(i % im->ygrid_scale.labfact == 0 || ( nlabels==1 && (YN < im->yorigin-im->ysize || YN > im->yorigin) )){                
+                if (im->symbol == ' ') {
+                     if(im->extra_flags & ALTYGRID) {
+                        sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i);
                     } else {
                         if(MaxY < 10) {
-                          sprintf(graph_label,"%4.1f",scaledstep*(double)i);
-                       } else {
-                          sprintf(graph_label,"%4.0f",scaledstep*(double)i);
-                       }
+                           sprintf(graph_label,"%4.1f",scaledstep*(double)i);
+                          } else {
+                           sprintf(graph_label,"%4.0f",scaledstep*(double)i);
+                        }
                     }
-               }else {
-                   char sisym = ( i == 0  ? ' ' : im->symbol);
-                   if(im->extra_flags & ALTYGRID) {
-                       sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i,sisym);
+                }else {
+                    char sisym = ( i == 0  ? ' ' : im->symbol);
+                     if(im->extra_flags & ALTYGRID) {
+                        sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i,sisym);
                     } else {
-                       if(MaxY < 10){
-                         sprintf(graph_label,"%4.1f %c",scaledstep*(double)i, sisym);
-                       } else {
-                         sprintf(graph_label,"%4.0f %c",scaledstep*(double)i, sisym);
-                       }
+                          if(MaxY < 10){
+                             sprintf(graph_label,"%4.1f %c",scaledstep*(double)i, sisym);
+                        } else {
+                             sprintf(graph_label,"%4.0f %c",scaledstep*(double)i, sisym);
+                        }
                     }
-               }
-               nlabels++;
-
-              gfx_new_text ( im->canvas,
-                             X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
-                             im->graph_col[GRC_FONT],
-                             im->text_prop[TEXT_PROP_AXIS].font,
-                             im->text_prop[TEXT_PROP_AXIS].size,
-                             im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
-                             graph_label );
-              gfx_new_dashed_line ( im->canvas,
-                             X0-2,Y0,
-                             X1+2,Y0,
-                             MGRIDWIDTH, im->graph_col[GRC_MGRID],
-                             im->grid_dash_on, im->grid_dash_off);            
-              
-           } else if (!(im->extra_flags & NOMINOR)) {          
-              gfx_new_dashed_line ( im->canvas,
-                             X0-1,Y0,
-                             X1+1,Y0,
-                             GRIDWIDTH, im->graph_col[GRC_GRID],
-                             im->grid_dash_on, im->grid_dash_off);            
-              
-           }       
-       }       
+                }
+                nlabels++;
+
+               gfx_new_text ( im->canvas,
+                              X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
+                              im->graph_col[GRC_FONT],
+                              im->text_prop[TEXT_PROP_AXIS].font,
+                              im->text_prop[TEXT_PROP_AXIS].size,
+                              im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
+                              graph_label );
+               gfx_new_dashed_line ( im->canvas,
+                              X0-2,Y0,
+                              X1+2,Y0,
+                              MGRIDWIDTH, im->graph_col[GRC_MGRID],
+                              im->grid_dash_on, im->grid_dash_off);               
+               
+            } else if (!(im->extra_flags & NOMINOR)) {                
+               gfx_new_dashed_line ( im->canvas,
+                              X0-1,Y0,
+                              X1+1,Y0,
+                              GRIDWIDTH, im->graph_col[GRC_GRID],
+                              im->grid_dash_on, im->grid_dash_off);               
+               
+            }            
+        }        
     } 
     return 1;
 }
@@ -1728,8 +1728,8 @@ double frexp10(double x, double *e) {
     iexp = floor(log(fabs(x)) / log(10));
     mnt = x / pow(10.0, iexp);
     if(mnt >= 10.0) {
-       iexp++;
-       mnt = x / pow(10.0, iexp);
+        iexp++;
+        mnt = x / pow(10.0, iexp);
     }
     *e = iexp;
     return mnt;
@@ -1769,20 +1769,20 @@ int
 horizontal_log_grid(image_desc_t   *im)   
 {
     double yloglab[][10] = {
-       {1.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
-       {1.0, 5.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
-       {1.0, 2.0, 5.0, 7.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0},
-       {1.0, 2.0, 4.0, 6.0, 8.0, 10., 0.0, 0.0, 0.0, 0.0},
-       {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.},
-       {0,0,0,0,0, 0,0,0,0,0} /* last line */ };
+        {1.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+        {1.0, 5.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+        {1.0, 2.0, 5.0, 7.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0},
+        {1.0, 2.0, 4.0, 6.0, 8.0, 10., 0.0, 0.0, 0.0, 0.0},
+        {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.},
+        {0,0,0,0,0, 0,0,0,0,0} /* last line */ };
 
     int i, j, val_exp, min_exp;
-    double nex;                /* number of decades in data */
-    double logscale;   /* scale in logarithmic space */
-    int exfrac = 1;    /* decade spacing */
-    int mid = -1;      /* row in yloglab for major grid */
-    double mspac;      /* smallest major grid spacing (pixels) */
-    int flab;          /* first value in yloglab to use */
+    double nex;                /* number of decades in data */
+    double logscale;        /* scale in logarithmic space */
+    int exfrac = 1;        /* decade spacing */
+    int mid = -1;        /* row in yloglab for major grid */
+    double mspac;        /* smallest major grid spacing (pixels) */
+    int flab;                /* first value in yloglab to use */
     double value, tmp, pre_value;
     double X0,X1,Y0;   
     char graph_label[100];
@@ -1792,24 +1792,24 @@ horizontal_log_grid(image_desc_t   *im)
 
     /* major spacing for data with high dynamic range */
     while(logscale * exfrac < 3 * im->text_prop[TEXT_PROP_LEGEND].size) {
-       if(exfrac == 1) exfrac = 3;
-       else exfrac += 3;
+        if(exfrac == 1) exfrac = 3;
+        else exfrac += 3;
     }
 
     /* major spacing for less dynamic data */
     do {
-       /* search best row in yloglab */
-       mid++;
-       for(i = 0; yloglab[mid][i + 1] < 10.0; i++);
-       mspac = logscale * log10(10.0 / yloglab[mid][i]);
+        /* search best row in yloglab */
+        mid++;
+        for(i = 0; yloglab[mid][i + 1] < 10.0; i++);
+        mspac = logscale * log10(10.0 / yloglab[mid][i]);
     } while(mspac > 2 * im->text_prop[TEXT_PROP_LEGEND].size && yloglab[mid][0] > 0);
     if(mid) mid--;
 
     /* find first value in yloglab */
     for(flab = 0; yloglab[mid][flab] < 10 && frexp10(im->minval, &tmp) > yloglab[mid][flab] ; flab++);
     if(yloglab[mid][flab] == 10.0) {
-       tmp += 1.0;
-       flab = 0;
+        tmp += 1.0;
+        flab = 0;
     }
     val_exp = tmp;
     if(val_exp % exfrac) val_exp += abs(-val_exp % exfrac);
@@ -1821,155 +1821,155 @@ horizontal_log_grid(image_desc_t   *im)
     pre_value = DNAN;
     while(1) {       
 
-       value = yloglab[mid][flab] * pow(10.0, val_exp);
+        value = yloglab[mid][flab] * pow(10.0, val_exp);
         if (  AlmostEqual2sComplement(value,pre_value,4) ) break; /* it seems we are not converging */
 
         pre_value = value;
 
-       Y0 = ytr(im, value);
-       if(Y0 <= im->yorigin - im->ysize) break;
-
-       /* major grid line */
-       gfx_new_dashed_line ( im->canvas,
-           X0-2,Y0,
-           X1+2,Y0,
-           MGRIDWIDTH, im->graph_col[GRC_MGRID],
-           im->grid_dash_on, im->grid_dash_off);
-
-       /* label */
-       if (im->extra_flags & FORCE_UNITS_SI) {
-           int scale;
-           double pvalue;
-           char symbol;
-
-           scale = floor(val_exp / 3.0);
-           if( value >= 1.0 ) pvalue = pow(10.0, val_exp % 3);
-           else pvalue = pow(10.0, ((val_exp + 1) % 3) + 2);
-           pvalue *= yloglab[mid][flab];
-
-           if ( ((scale+si_symbcenter) < (int)sizeof(si_symbol)) &&
-               ((scale+si_symbcenter) >= 0) )
-               symbol = si_symbol[scale+si_symbcenter];
-           else
-               symbol = '?';
-
-               sprintf(graph_label,"%3.0f %c", pvalue, symbol);
+        Y0 = ytr(im, value);
+        if(Y0 <= im->yorigin - im->ysize) break;
+
+        /* major grid line */
+        gfx_new_dashed_line ( im->canvas,
+            X0-2,Y0,
+            X1+2,Y0,
+            MGRIDWIDTH, im->graph_col[GRC_MGRID],
+            im->grid_dash_on, im->grid_dash_off);
+
+        /* label */
+        if (im->extra_flags & FORCE_UNITS_SI) {
+            int scale;
+            double pvalue;
+            char symbol;
+
+            scale = floor(val_exp / 3.0);
+            if( value >= 1.0 ) pvalue = pow(10.0, val_exp % 3);
+            else pvalue = pow(10.0, ((val_exp + 1) % 3) + 2);
+            pvalue *= yloglab[mid][flab];
+
+            if ( ((scale+si_symbcenter) < (int)sizeof(si_symbol)) &&
+                ((scale+si_symbcenter) >= 0) )
+                symbol = si_symbol[scale+si_symbcenter];
+            else
+                symbol = '?';
+
+                sprintf(graph_label,"%3.0f %c", pvalue, symbol);
         } else
-           sprintf(graph_label,"%3.0e", value);
-       gfx_new_text ( im->canvas,
-           X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
-           im->graph_col[GRC_FONT],
-           im->text_prop[TEXT_PROP_AXIS].font,
-           im->text_prop[TEXT_PROP_AXIS].size,
-           im->tabwidth,0.0, GFX_H_RIGHT, GFX_V_CENTER,
-           graph_label );
-
-       /* minor grid */
-       if(mid < 4 && exfrac == 1) {
-           /* find first and last minor line behind current major line
-            * i is the first line and j tha last */
-           if(flab == 0) {
-               min_exp = val_exp - 1;
-               for(i = 1; yloglab[mid][i] < 10.0; i++);
-               i = yloglab[mid][i - 1] + 1;
-               j = 10;
-           }
-           else {
-               min_exp = val_exp;
-               i = yloglab[mid][flab - 1] + 1;
-               j = yloglab[mid][flab];
-           }
-
-           /* draw minor lines below current major line */
-           for(; i < j; i++) {
-
-               value = i * pow(10.0, min_exp);
-               if(value < im->minval) continue;
-
-               Y0 = ytr(im, value);
-               if(Y0 <= im->yorigin - im->ysize) break;
-
-               /* draw lines */
-               gfx_new_dashed_line ( im->canvas,
-                   X0-1,Y0,
-                   X1+1,Y0,
-                   GRIDWIDTH, im->graph_col[GRC_GRID],
-                   im->grid_dash_on, im->grid_dash_off);
-           }
-       }
-       else if(exfrac > 1) {
-           for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
-               value = pow(10.0, i);
-               if(value < im->minval) continue;
-
-               Y0 = ytr(im, value);
-               if(Y0 <= im->yorigin - im->ysize) break;
-
-               /* draw lines */
-               gfx_new_dashed_line ( im->canvas,
-                   X0-1,Y0,
-                   X1+1,Y0,
-                   GRIDWIDTH, im->graph_col[GRC_GRID],
-                   im->grid_dash_on, im->grid_dash_off);
-           }
-       }
-
-       /* next decade */
-       if(yloglab[mid][++flab] == 10.0) {
-           flab = 0;
-           val_exp += exfrac;
-       }
+            sprintf(graph_label,"%3.0e", value);
+        gfx_new_text ( im->canvas,
+            X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
+            im->graph_col[GRC_FONT],
+            im->text_prop[TEXT_PROP_AXIS].font,
+            im->text_prop[TEXT_PROP_AXIS].size,
+            im->tabwidth,0.0, GFX_H_RIGHT, GFX_V_CENTER,
+            graph_label );
+
+        /* minor grid */
+        if(mid < 4 && exfrac == 1) {
+            /* find first and last minor line behind current major line
+             * i is the first line and j tha last */
+            if(flab == 0) {
+                min_exp = val_exp - 1;
+                for(i = 1; yloglab[mid][i] < 10.0; i++);
+                i = yloglab[mid][i - 1] + 1;
+                j = 10;
+            }
+            else {
+                min_exp = val_exp;
+                i = yloglab[mid][flab - 1] + 1;
+                j = yloglab[mid][flab];
+            }
+
+            /* draw minor lines below current major line */
+            for(; i < j; i++) {
+
+                value = i * pow(10.0, min_exp);
+                if(value < im->minval) continue;
+
+                Y0 = ytr(im, value);
+                if(Y0 <= im->yorigin - im->ysize) break;
+
+                /* draw lines */
+                gfx_new_dashed_line ( im->canvas,
+                    X0-1,Y0,
+                    X1+1,Y0,
+                    GRIDWIDTH, im->graph_col[GRC_GRID],
+                    im->grid_dash_on, im->grid_dash_off);
+            }
+        }
+        else if(exfrac > 1) {
+            for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
+                value = pow(10.0, i);
+                if(value < im->minval) continue;
+
+                Y0 = ytr(im, value);
+                if(Y0 <= im->yorigin - im->ysize) break;
+
+                /* draw lines */
+                gfx_new_dashed_line ( im->canvas,
+                    X0-1,Y0,
+                    X1+1,Y0,
+                    GRIDWIDTH, im->graph_col[GRC_GRID],
+                    im->grid_dash_on, im->grid_dash_off);
+            }
+        }
+
+        /* next decade */
+        if(yloglab[mid][++flab] == 10.0) {
+            flab = 0;
+            val_exp += exfrac;
+        }
     }
 
     /* draw minor lines after highest major line */
     if(mid < 4 && exfrac == 1) {
-       /* find first and last minor line below current major line
-        * i is the first line and j tha last */
-       if(flab == 0) {
-           min_exp = val_exp - 1;
-           for(i = 1; yloglab[mid][i] < 10.0; i++);
-           i = yloglab[mid][i - 1] + 1;
-           j = 10;
-       }
-       else {
-           min_exp = val_exp;
-           i = yloglab[mid][flab - 1] + 1;
-           j = yloglab[mid][flab];
-       }
-
-       /* draw minor lines below current major line */
-       for(; i < j; i++) {
-
-           value = i * pow(10.0, min_exp);
-           if(value < im->minval) continue;
-
-           Y0 = ytr(im, value);
-           if(Y0 <= im->yorigin - im->ysize) break;
-
-           /* draw lines */
-           gfx_new_dashed_line ( im->canvas,
-               X0-1,Y0,
-               X1+1,Y0,
-               GRIDWIDTH, im->graph_col[GRC_GRID],
-               im->grid_dash_on, im->grid_dash_off);
-       }
+        /* find first and last minor line below current major line
+         * i is the first line and j tha last */
+        if(flab == 0) {
+            min_exp = val_exp - 1;
+            for(i = 1; yloglab[mid][i] < 10.0; i++);
+            i = yloglab[mid][i - 1] + 1;
+            j = 10;
+        }
+        else {
+            min_exp = val_exp;
+            i = yloglab[mid][flab - 1] + 1;
+            j = yloglab[mid][flab];
+        }
+
+        /* draw minor lines below current major line */
+        for(; i < j; i++) {
+
+            value = i * pow(10.0, min_exp);
+            if(value < im->minval) continue;
+
+            Y0 = ytr(im, value);
+            if(Y0 <= im->yorigin - im->ysize) break;
+
+            /* draw lines */
+            gfx_new_dashed_line ( im->canvas,
+                X0-1,Y0,
+                X1+1,Y0,
+                GRIDWIDTH, im->graph_col[GRC_GRID],
+                im->grid_dash_on, im->grid_dash_off);
+        }
     }
     /* fancy minor gridlines */
     else if(exfrac > 1) {
-       for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
-           value = pow(10.0, i);
-           if(value < im->minval) continue;
-
-           Y0 = ytr(im, value);
-           if(Y0 <= im->yorigin - im->ysize) break;
-
-           /* draw lines */
-           gfx_new_dashed_line ( im->canvas,
-               X0-1,Y0,
-               X1+1,Y0,
-               GRIDWIDTH, im->graph_col[GRC_GRID],
-               im->grid_dash_on, im->grid_dash_off);
-       }
+        for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
+            value = pow(10.0, i);
+            if(value < im->minval) continue;
+
+            Y0 = ytr(im, value);
+            if(Y0 <= im->yorigin - im->ysize) break;
+
+            /* draw lines */
+            gfx_new_dashed_line ( im->canvas,
+                X0-1,Y0,
+                X1+1,Y0,
+                GRIDWIDTH, im->graph_col[GRC_GRID],
+                im->grid_dash_on, im->grid_dash_off);
+        }
     }
 
     return 1;
@@ -1980,7 +1980,7 @@ void
 vertical_grid(
     image_desc_t   *im )
 {   
-    int xlab_sel;              /* which sort of label and grid ? */
+    int xlab_sel;                /* which sort of label and grid ? */
     time_t ti, tilab, timajor;
     long factor;
     char graph_label[100];
@@ -1992,20 +1992,20 @@ vertical_grid(
     
     
     if(im->xlab_user.minsec == -1){
-       factor=(im->end - im->start)/im->xsize;
-       xlab_sel=0;
-       while ( xlab[xlab_sel+1].minsec != -1 
-               && xlab[xlab_sel+1].minsec <= factor) { xlab_sel++; }   /* pick the last one */
-       while ( xlab[xlab_sel-1].minsec == xlab[xlab_sel].minsec
-               && xlab[xlab_sel].length > (im->end - im->start)) { xlab_sel--; }       /* go back to the smallest size */
-       im->xlab_user.gridtm = xlab[xlab_sel].gridtm;
-       im->xlab_user.gridst = xlab[xlab_sel].gridst;
-       im->xlab_user.mgridtm = xlab[xlab_sel].mgridtm;
-       im->xlab_user.mgridst = xlab[xlab_sel].mgridst;
-       im->xlab_user.labtm = xlab[xlab_sel].labtm;
-       im->xlab_user.labst = xlab[xlab_sel].labst;
-       im->xlab_user.precis = xlab[xlab_sel].precis;
-       im->xlab_user.stst = xlab[xlab_sel].stst;
+        factor=(im->end - im->start)/im->xsize;
+        xlab_sel=0;
+        while ( xlab[xlab_sel+1].minsec != -1 
+                && xlab[xlab_sel+1].minsec <= factor) { xlab_sel++; }        /* pick the last one */
+        while ( xlab[xlab_sel-1].minsec == xlab[xlab_sel].minsec
+                && xlab[xlab_sel].length > (im->end - im->start)) { xlab_sel--; }        /* go back to the smallest size */
+        im->xlab_user.gridtm = xlab[xlab_sel].gridtm;
+        im->xlab_user.gridst = xlab[xlab_sel].gridst;
+        im->xlab_user.mgridtm = xlab[xlab_sel].mgridtm;
+        im->xlab_user.mgridst = xlab[xlab_sel].mgridst;
+        im->xlab_user.labtm = xlab[xlab_sel].labtm;
+        im->xlab_user.labst = xlab[xlab_sel].labst;
+        im->xlab_user.precis = xlab[xlab_sel].precis;
+        im->xlab_user.stst = xlab[xlab_sel].stst;
     }
     
     /* y coords are the same for every line ... */
@@ -2042,43 +2042,43 @@ vertical_grid(
 
     /* paint the major grid */
     for(ti = find_first_time(im->start,
-                           im->xlab_user.mgridtm,
-                           im->xlab_user.mgridst);
-       ti < im->end; 
-       ti = find_next_time(ti,im->xlab_user.mgridtm,im->xlab_user.mgridst)
-       ){
-       /* are we inside the graph ? */
-       if (ti < im->start || ti > im->end) continue;
+                            im->xlab_user.mgridtm,
+                            im->xlab_user.mgridst);
+        ti < im->end; 
+        ti = find_next_time(ti,im->xlab_user.mgridtm,im->xlab_user.mgridst)
+        ){
+        /* are we inside the graph ? */
+        if (ti < im->start || ti > im->end) continue;
        X0 = xtr(im,ti);
        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);
+           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 - im->xlab_user.precis/2,
-                           im->xlab_user.labtm,
-                           im->xlab_user.labst);
-       ti <= im->end - im->xlab_user.precis/2; 
-       ti = find_next_time(ti,im->xlab_user.labtm,im->xlab_user.labst)
-       ){
+                            im->xlab_user.labtm,
+                            im->xlab_user.labst);
+        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 (tilab < im->start || tilab > im->end) continue;
+        /* are we inside the graph ? */
+        if (tilab < im->start || tilab > im->end) continue;
 
 #if HAVE_STRFTIME
-       localtime_r(&tilab, &tm);
-       strftime(graph_label,99,im->xlab_user.stst, &tm);
+        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
        gfx_new_text ( im->canvas,
-                     xtr(im,tilab), Y0+im->text_prop[TEXT_PROP_AXIS].size*1.4+5,
-                     im->graph_col[GRC_FONT],
-                     im->text_prop[TEXT_PROP_AXIS].font,
-                     im->text_prop[TEXT_PROP_AXIS].size,
-                     im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_BOTTOM,
-                     graph_label );
+                      xtr(im,tilab), Y0+im->text_prop[TEXT_PROP_AXIS].size*1.4+5,
+                      im->graph_col[GRC_FONT],
+                      im->text_prop[TEXT_PROP_AXIS].font,
+                      im->text_prop[TEXT_PROP_AXIS].size,
+                      im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_BOTTOM,
+                      graph_label );
        
     }
 
@@ -2088,38 +2088,38 @@ vertical_grid(
 void 
 axis_paint(
    image_desc_t   *im
-          )
+           )
 {   
     /* draw x and y axis */
     /* gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
-                     im->xorigin+im->xsize,im->yorigin-im->ysize,
-                     GRIDWIDTH, im->graph_col[GRC_AXIS]);
+                      im->xorigin+im->xsize,im->yorigin-im->ysize,
+                      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_AXIS]); */
+                         im->xorigin+im->xsize,im->yorigin-im->ysize,
+                         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_AXIS]);
+                         im->xorigin+im->xsize+4,im->yorigin,
+                         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_AXIS]);
+                         im->xorigin,im->yorigin-im->ysize-4,
+                         MGRIDWIDTH, im->graph_col[GRC_AXIS]);
    
     
     /* arrow for X and Y axis direction */
     gfx_new_area ( im->canvas, 
-                  im->xorigin+im->xsize+2,  im->yorigin-2,
-                  im->xorigin+im->xsize+2,  im->yorigin+3,
-                  im->xorigin+im->xsize+7,  im->yorigin+0.5, /* LINEOFFSET */
-                  im->graph_col[GRC_ARROW]);
+                   im->xorigin+im->xsize+2,  im->yorigin-2,
+                   im->xorigin+im->xsize+2,  im->yorigin+3,
+                   im->xorigin+im->xsize+7,  im->yorigin+0.5, /* LINEOFFSET */
+                   im->graph_col[GRC_ARROW]);
 
     gfx_new_area ( im->canvas, 
-                  im->xorigin-2,  im->yorigin-im->ysize-2,
-                  im->xorigin+3,  im->yorigin-im->ysize-2,
-                  im->xorigin+0.5,    im->yorigin-im->ysize-7, /* LINEOFFSET */
-                  im->graph_col[GRC_ARROW]);
+                   im->xorigin-2,  im->yorigin-im->ysize-2,
+                   im->xorigin+3,  im->yorigin-im->ysize-2,
+                   im->xorigin+0.5,    im->yorigin-im->ysize-7, /* LINEOFFSET */
+                   im->graph_col[GRC_ARROW]);
 
 }
 
@@ -2154,22 +2154,22 @@ grid_paint(image_desc_t   *im)
       vertical_grid(im);
     
     if (im->draw_y_grid == 1){
-       if(im->logarithmic){
-               res = horizontal_log_grid(im);
-       } else {
-               res = draw_horizontal_grid(im);
-       }
-       
-       /* dont draw horizontal grid if there is no min and max val */
-       if (! res ) {
-         char *nodata = "No Data found";
-          gfx_new_text(im->canvas,im->ximg/2, (2*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, 0.0, GFX_H_CENTER, GFX_V_CENTER,
-                       nodata );          
-       }
+        if(im->logarithmic){
+                res = horizontal_log_grid(im);
+        } else {
+                res = draw_horizontal_grid(im);
+        }
+        
+        /* dont draw horizontal grid if there is no min and max val */
+        if (! res ) {
+          char *nodata = "No Data found";
+           gfx_new_text(im->canvas,im->ximg/2, (2*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, 0.0, GFX_H_CENTER, GFX_V_CENTER,
+                        nodata );           
+        }
     }
 
     /* yaxis unit description */
@@ -2184,30 +2184,30 @@ grid_paint(image_desc_t   *im)
 
     /* graph title */
     gfx_new_text( im->canvas,
-                 im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.3+4,
-                 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);
+                  im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.3+4,
+                  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);
     /* rrdtool 'logo' */
     gfx_new_text( im->canvas,
-                 im->ximg-7, 7,
-                 ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
-                 im->text_prop[TEXT_PROP_AXIS].font,
-                 5.5, im->tabwidth, 270,
-                 GFX_H_RIGHT, GFX_V_TOP,
-                 "RRDTOOL / TOBI OETIKER");
+                  im->ximg-7, 7,
+                  ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
+                  im->text_prop[TEXT_PROP_AXIS].font,
+                  5.5, im->tabwidth, 270,
+                  GFX_H_RIGHT, GFX_V_TOP,
+                  "RRDTOOL / TOBI OETIKER");
 
     /* graph watermark */
     if(im->watermark[0] != '\0') {
         gfx_new_text( im->canvas,
                   im->ximg/2, im->yimg-6,
-                 ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
-                 im->text_prop[TEXT_PROP_AXIS].font,
-                 5.5, im->tabwidth, 0,
-                 GFX_H_CENTER, GFX_V_BOTTOM,
-                 im->watermark);
+                  ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
+                  im->text_prop[TEXT_PROP_AXIS].font,
+                  5.5, im->tabwidth, 0,
+                  GFX_H_CENTER, GFX_V_BOTTOM,
+                  im->watermark);
     }
     
     /* graph labels */
@@ -2220,15 +2220,15 @@ grid_paint(image_desc_t   *im)
                     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_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
+                                   im->graph_col[GRC_FONT],
+                                   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 &&
+                    if (           im->gdes[i].gf != GF_PRINT &&
+                                   im->gdes[i].gf != GF_GPRINT &&
                                    im->gdes[i].gf != GF_COMMENT) {
                             int boxH, boxV;
                             
@@ -2239,7 +2239,7 @@ grid_paint(image_desc_t   *im)
                             boxV = boxH*1.1;
                             
                             /* make sure transparent colors show up the same way as in the graph */
-                            node = gfx_new_area(im->canvas,
+                             node = gfx_new_area(im->canvas,
                                                 X0,Y0-boxV,
                                                 X0,Y0,
                                                 X0+boxH,Y0,
@@ -2271,7 +2271,7 @@ grid_paint(image_desc_t   *im)
 
 int lazy_check(image_desc_t *im){
     FILE *fd = NULL;
-       int size = 1;
+        int size = 1;
     struct stat  imgstat;
     
     if (im->lazy == 0) return 0; /* no lazy option */
@@ -2280,16 +2280,16 @@ int lazy_check(image_desc_t *im){
     /* one pixel in the existing graph is more then what we would
        change here ... */
     if (time(NULL) - imgstat.st_mtime > 
-       (im->end - im->start) / im->xsize) 
+        (im->end - im->start) / im->xsize) 
       return 0;
     if ((fd = fopen(im->graphfile,"rb")) == NULL) 
       return 0; /* the file does not exist */
     switch (im->canvas->imgformat) {
     case IF_PNG:
-          size = PngSize(fd,&(im->ximg),&(im->yimg));
-          break;
+           size = PngSize(fd,&(im->ximg),&(im->yimg));
+           break;
     default:
-          size = 1;
+           size = 1;
     }
     fclose(fd);
     return size;
@@ -2298,15 +2298,15 @@ int lazy_check(image_desc_t *im){
 #ifdef WITH_PIECHART
 void
 pie_part(image_desc_t *im, gfx_color_t color,
-           double PieCenterX, double PieCenterY, double Radius,
-           double startangle, double endangle)
+            double PieCenterX, double PieCenterY, double Radius,
+            double startangle, double endangle)
 {
     gfx_node_t *node;
     double angle;
     double step=M_PI/50; /* Number of iterations for the circle;
-                        ** 10 is definitely too low, more than
-                        ** 50 seems to be overkill
-                        */
+                         ** 10 is definitely too low, more than
+                         ** 50 seems to be overkill
+                         */
 
     /* Strange but true: we have to work clockwise or else
     ** anti aliasing nor transparency don't work.
@@ -2323,22 +2323,22 @@ pie_part(image_desc_t *im, gfx_color_t color,
     /* Hidden feature: Radius decreases each full circle */
     angle=startangle;
     while (angle>=2*M_PI) {
-       angle  -= 2*M_PI;
-       Radius *= 0.8;
+        angle  -= 2*M_PI;
+        Radius *= 0.8;
     }
 
     node=gfx_new_area(im->canvas,
-               PieCenterX+sin(startangle)*Radius,
-               PieCenterY-cos(startangle)*Radius,
-               PieCenterX,
-               PieCenterY,
-               PieCenterX+sin(endangle)*Radius,
-               PieCenterY-cos(endangle)*Radius,
-               color);
+                PieCenterX+sin(startangle)*Radius,
+                PieCenterY-cos(startangle)*Radius,
+                PieCenterX,
+                PieCenterY,
+                PieCenterX+sin(endangle)*Radius,
+                PieCenterY-cos(endangle)*Radius,
+                color);
     for (angle=endangle;angle-startangle>=step;angle-=step) {
-       gfx_add_point(node,
-               PieCenterX+sin(angle)*Radius,
-               PieCenterY-cos(angle)*Radius );
+        gfx_add_point(node,
+                PieCenterX+sin(angle)*Radius,
+                PieCenterY-cos(angle)*Radius );
     }
 }
 
@@ -2375,28 +2375,28 @@ graph_size_location(image_desc_t *im, int elements
     ** |                 watermark                   |
     ** +---------------------------------------------+
     */
-    int Xvertical=0,   
-                       Ytitle   =0,
-       Xylabel  =0,    
-       Xmain    =0,    Ymain    =0,
+    int Xvertical=0,        
+                        Ytitle   =0,
+        Xylabel  =0,        
+        Xmain    =0,        Ymain    =0,
 #ifdef WITH_PIECHART
-       Xpie     =0,    Ypie     =0,
+        Xpie     =0,        Ypie     =0,
 #endif
-                       Yxlabel  =0,
+                        Yxlabel  =0,
 #if 0
-       Xlegend  =0,    Ylegend  =0,
+        Xlegend  =0,        Ylegend  =0,
 #endif
         Xspacing =15,  Yspacing =15,
        
                       Ywatermark =4;
 
     if (im->extra_flags & ONLY_GRAPH) {
-       im->xorigin =0;
-       im->ximg = im->xsize;
+        im->xorigin =0;
+        im->ximg = im->xsize;
         im->yimg = im->ysize;
         im->yorigin = im->ysize;
         ytr(im,DNAN); 
-       return 0;
+        return 0;
     }
 
     if (im->ylegend[0] != '\0' ) {
@@ -2405,39 +2405,39 @@ graph_size_location(image_desc_t *im, int elements
 
 
     if (im->title[0] != '\0') {
-       /* The title is placed "inbetween" two text lines so it
-       ** automatically has some vertical spacing.  The horizontal
-       ** spacing is added here, on each side.
-       */
-       /* don't care for the with of the title
-               Xtitle = gfx_get_text_width(im->canvas, 0,
-               im->text_prop[TEXT_PROP_TITLE].font,
-               im->text_prop[TEXT_PROP_TITLE].size,
-               im->tabwidth,
-               im->title, 0) + 2*Xspacing; */
-       Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.6+10;
+        /* The title is placed "inbetween" two text lines so it
+        ** automatically has some vertical spacing.  The horizontal
+        ** spacing is added here, on each side.
+        */
+        /* don't care for the with of the title
+                Xtitle = gfx_get_text_width(im->canvas, 0,
+                im->text_prop[TEXT_PROP_TITLE].font,
+                im->text_prop[TEXT_PROP_TITLE].size,
+                im->tabwidth,
+                im->title, 0) + 2*Xspacing; */
+        Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.6+10;
     }
 
     if (elements) {
-       Xmain=im->xsize;
-       Ymain=im->ysize;
-       if (im->draw_x_grid) {
-           Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
-       }
-       if (im->draw_y_grid || im->forceleftspace ) {
-           Xylabel=gfx_get_text_width(im->canvas, 0,
-                       im->text_prop[TEXT_PROP_AXIS].font,
-                       im->text_prop[TEXT_PROP_AXIS].size,
-                       im->tabwidth,
-                       "0", 0) * im->unitslength;
-       }
+        Xmain=im->xsize;
+        Ymain=im->ysize;
+        if (im->draw_x_grid) {
+            Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
+        }
+        if (im->draw_y_grid || im->forceleftspace ) {
+            Xylabel=gfx_get_text_width(im->canvas, 0,
+                        im->text_prop[TEXT_PROP_AXIS].font,
+                        im->text_prop[TEXT_PROP_AXIS].size,
+                        im->tabwidth,
+                        "0", 0) * im->unitslength;
+        }
     }
 
 #ifdef WITH_PIECHART
     if (piechart) {
-       im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
-       Xpie=im->piesize;
-       Ypie=im->piesize;
+        im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
+        Xpie=im->piesize;
+        Ypie=im->piesize;
     }
 #endif
 
@@ -2469,8 +2469,8 @@ graph_size_location(image_desc_t *im, int elements
        if (Xtitle > im->ximg) im->ximg = Xtitle; */
 
     if (Xvertical) { /* unit description */
-       im->ximg += Xvertical;
-       im->xorigin += Xvertical;
+        im->ximg += Xvertical;
+        im->xorigin += Xvertical;
     }
     xtr(im,0);
 
@@ -2496,11 +2496,11 @@ graph_size_location(image_desc_t *im, int elements
 
     /* reserve space for the title *or* some padding above the graph */
     if (Ytitle) {
-       im->yimg += Ytitle;
-       im->yorigin += Ytitle;
+        im->yimg += Ytitle;
+        im->yorigin += Ytitle;
     } else {
-       im->yimg += 1.5*Yspacing;
-       im->yorigin += 1.5*Yspacing;
+        im->yimg += 1.5*Yspacing;
+        im->yorigin += 1.5*Yspacing;
     }
     /* reserve space for padding below the graph */
     im->yimg += Yspacing;
@@ -2509,16 +2509,16 @@ graph_size_location(image_desc_t *im, int elements
     ** Adjust im->yimg to match the space requirements.
     */
     if(leg_place(im)==-1)
-       return -1;
-       
+        return -1;
+        
     if (im->watermark[0] != '\0') {
         im->yimg += Ywatermark;
     }
 
 #if 0
     if (Xlegend > im->ximg) {
-       im->ximg = Xlegend;
-       /* reposition Pie */
+        im->ximg = Xlegend;
+        /* reposition Pie */
     }
 #endif
 
@@ -2528,10 +2528,10 @@ graph_size_location(image_desc_t *im, int elements
     ** padding.
     */
     if (elements) {
-       im->pie_x = im->ximg - Xspacing - Xpie/2;
+        im->pie_x = im->ximg - Xspacing - Xpie/2;
         im->pie_y = im->yorigin-Ymain+Ypie/2;
     } else {
-       im->pie_x = im->ximg/2;
+        im->pie_x = im->ximg/2;
         im->pie_y = im->yorigin-Ypie/2;
     }
 #endif
@@ -2635,7 +2635,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
   node=gfx_new_area ( im->canvas,
                       0, 0,
                       0, im->yimg,
-                     im->ximg, im->yimg,                      
+                      im->ximg, im->yimg,                      
                       im->graph_col[GRC_BACK]);
 
   gfx_add_point(node,im->ximg, 0);
@@ -2684,19 +2684,19 @@ graph_paint(image_desc_t *im, char ***calcpr)
           if (!isnan(im->gdes[i].p_data[ii]) && 
               im->gdes[i].p_data[ii] != 0.0)
            { 
-             if (im -> gdes[i].yrule > 0 ) {
-                     gfx_new_line(im->canvas,
+              if (im -> gdes[i].yrule > 0 ) {
+                      gfx_new_line(im->canvas,
                                    im -> xorigin + ii, im->yorigin,
-                                  im -> xorigin + ii, im->yorigin - im -> gdes[i].yrule * im -> ysize,
-                                  1.0,
-                                  im -> gdes[i].col );
+                                   im -> xorigin + ii, im->yorigin - im -> gdes[i].yrule * im -> ysize,
+                                   1.0,
+                                   im -> gdes[i].col );
               } else if ( im -> gdes[i].yrule < 0 ) {
-                     gfx_new_line(im->canvas,
+                      gfx_new_line(im->canvas,
                                    im -> xorigin + ii, im->yorigin - im -> ysize,
-                                  im -> xorigin + ii, im->yorigin - ( 1 - im -> gdes[i].yrule ) * im -> ysize,
-                                  1.0,
-                                  im -> gdes[i].col );
-             
+                                   im -> xorigin + ii, im->yorigin - ( 1 - im -> gdes[i].yrule ) * im -> ysize,
+                                   1.0,
+                                   im -> gdes[i].col );
+              
               }
            }
         }
@@ -2717,7 +2717,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
 
       /* *******************************************************
        a           ___. (a,t) 
-                 |   |    ___
+                    |   |    ___
               ____|   |   |   |
               |       |___|
        -------|--t-1--t--------------------------------      
@@ -2732,45 +2732,45 @@ graph_paint(image_desc_t *im, char ***calcpr)
           double last_y=0.0;
           node = NULL;
           for(ii=1;ii<im->xsize;ii++){
-           if (isnan(im->gdes[i].p_data[ii]) || (im->slopemode==1 && isnan(im->gdes[i].p_data[ii-1]))){
-               node = NULL;
-               continue;
-           }
+            if (isnan(im->gdes[i].p_data[ii]) || (im->slopemode==1 && isnan(im->gdes[i].p_data[ii-1]))){
+                node = NULL;
+                continue;
+            }
             if ( node == NULL ) {
-               last_y = ytr(im,im->gdes[i].p_data[ii]);
-               if ( im->slopemode == 0 ){
+                     last_y = ytr(im,im->gdes[i].p_data[ii]);
+                if ( im->slopemode == 0 ){
                   node = gfx_new_line(im->canvas,
                                     ii-1+im->xorigin,last_y,
                                     ii+im->xorigin,last_y,
                                     im->gdes[i].linewidth,
                                     im->gdes[i].col);
-               } else {
+                } else {
                   node = gfx_new_line(im->canvas,
                                     ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
                                     ii+im->xorigin,last_y,
                                     im->gdes[i].linewidth,
                                     im->gdes[i].col);
-               }
+                }
              } else {
                double new_y = ytr(im,im->gdes[i].p_data[ii]);
-              if ( im->slopemode==0 && ! AlmostEqual2sComplement(new_y,last_y,4)){
+               if ( im->slopemode==0 && ! AlmostEqual2sComplement(new_y,last_y,4)){
                    gfx_add_point(node,ii-1+im->xorigin,new_y);
-              };
+               };
                last_y = new_y;
                gfx_add_point(node,ii+im->xorigin,new_y);
              };
 
           }
         } else {
-         int idxI=-1;
-         double *foreY=malloc(sizeof(double)*im->xsize*2);
-         double *foreX=malloc(sizeof(double)*im->xsize*2);
-         double *backY=malloc(sizeof(double)*im->xsize*2);
-         double *backX=malloc(sizeof(double)*im->xsize*2);
-         int drawem = 0;
+          int idxI=-1;
+          double *foreY=malloc(sizeof(double)*im->xsize*2);
+          double *foreX=malloc(sizeof(double)*im->xsize*2);
+          double *backY=malloc(sizeof(double)*im->xsize*2);
+          double *backX=malloc(sizeof(double)*im->xsize*2);
+          int drawem = 0;
           for(ii=0;ii<=im->xsize;ii++){
-           double ybase,ytop;
-           if ( idxI > 0 && ( drawem != 0 || ii==im->xsize)){
+            double ybase,ytop;
+            if ( idxI > 0 && ( drawem != 0 || ii==im->xsize)){
                int cntI=1;
                int lastI=0;
                while (cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
@@ -2800,34 +2800,34 @@ graph_paint(image_desc_t *im, char ***calcpr)
             }
             if (ii == im->xsize) break;
             
-           /* keep things simple for now, just draw these bars
-              do not try to build a big and complex area */
-
-                                                             
-           if ( im->slopemode == 0 && ii==0){
-               continue;
-           }
-           if ( isnan(im->gdes[i].p_data[ii]) ) {
-               drawem = 1;
-               continue;
-           }
+            /* keep things simple for now, just draw these bars
+               do not try to build a big and complex area */
+
+                                                               
+            if ( im->slopemode == 0 && ii==0){
+                continue;
+            }
+            if ( isnan(im->gdes[i].p_data[ii]) ) {
+                drawem = 1;
+                continue;
+            }
             ytop = ytr(im,im->gdes[i].p_data[ii]);
-           if ( lastgdes && im->gdes[i].stack ) {
+             if ( lastgdes && im->gdes[i].stack ) {
                   ybase = ytr(im,lastgdes->p_data[ii]);
             } else {
                   ybase = ytr(im,areazero);
             }
             if ( ybase == ytop ){
-               drawem = 1;
-               continue;       
-           }
-           /* every area has to be wound clock-wise,
-              so we have to make sur base remains base  */             
-           if (ybase > ytop){
-               double extra = ytop;
-               ytop = ybase;
-               ybase = extra;
-           }
+                drawem = 1;
+                continue;        
+            }
+            /* every area has to be wound clock-wise,
+               so we have to make sur base remains base  */                
+            if (ybase > ytop){
+                double extra = ytop;
+                ytop = ybase;
+                ybase = extra;
+            }
             if ( im->slopemode == 0 ){
                     backY[++idxI] = ybase-0.2;
                     backX[idxI] = ii+im->xorigin-1;
@@ -2861,14 +2861,14 @@ graph_paint(image_desc_t *im, char ***calcpr)
 #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;
+        im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
      
-      if (finite(im->gdes[i].yrule)) { /* even the fetched var can be NaN */
-       pie_part(im,im->gdes[i].col,
-               im->pie_x,im->pie_y,im->piesize*0.4,
-               M_PI*2.0*PieStart/100.0,
-               M_PI*2.0*(PieStart+im->gdes[i].yrule)/100.0);
-       PieStart += im->gdes[i].yrule;
+      if (finite(im->gdes[i].yrule)) {        /* even the fetched var can be NaN */
+        pie_part(im,im->gdes[i].col,
+                im->pie_x,im->pie_y,im->piesize*0.4,
+                M_PI*2.0*PieStart/100.0,
+                M_PI*2.0*(PieStart+im->gdes[i].yrule)/100.0);
+        PieStart += im->gdes[i].yrule;
       }
       break;
 #endif
@@ -2876,7 +2876,7 @@ graph_paint(image_desc_t *im, char ***calcpr)
       rrd_set_error("STACK should already be turned into LINE or AREA here");
       return -1;
       break;
-       
+        
     } /* switch */
   }
 #ifdef WITH_PIECHART
@@ -2950,9 +2950,9 @@ gdes_alloc(image_desc_t *im){
 
     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");
-       return -1;
+                                           * sizeof(graph_desc_t)))==NULL){
+        rrd_set_error("realloc graph_descs");
+        return -1;
     }
 
 
@@ -2993,18 +2993,18 @@ scan_for_col(const char *const input, int len, char *const output)
 {
     int inp,outp=0;
     for (inp=0; 
-        inp < len &&
-          input[inp] != ':' &&
-          input[inp] != '\0';
-        inp++){
+         inp < len &&
+           input[inp] != ':' &&
+           input[inp] != '\0';
+         inp++){
       if (input[inp] == '\\' &&
-         input[inp+1] != '\0' && 
-         (input[inp+1] == '\\' ||
-          input[inp+1] == ':')){
-       output[outp++] = input[++inp];
+          input[inp+1] != '\0' && 
+          (input[inp+1] == '\\' ||
+           input[inp+1] == ':')){
+        output[outp++] = input[++inp];
       }
       else {
-       output[outp++] = input[inp];
+        output[outp++] = input[inp];
       }
     }
     output[outp] = '\0';
@@ -3025,30 +3025,30 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *s
     
     rrd_graph_options(argc,argv,&im);
     if (rrd_test_error()) {
-       im_free(&im);
-       return -1;
+        im_free(&im);
+        return -1;
     }
     
     if (strlen(argv[optind])>=MAXPATH) {
-       rrd_set_error("filename (including path) too long");
-       im_free(&im);
-       return -1;
+        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,1);
     if (rrd_test_error()) {
-       im_free(&im);
-       return -1;
+        im_free(&im);
+        return -1;
     }
 
     /* Everything is now read and the actual work can start */
 
     (*prdata)=NULL;
     if (graph_paint(&im,prdata)==-1){
-       im_free(&im);
-       return -1;
+        im_free(&im);
+        return -1;
     }
 
     /* The image is generated and needs to be output.
@@ -3060,26 +3060,26 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *s
     *ymin=im.minval;
     *ymax=im.maxval;
     if (im.imginfo) {
-       char *filename;
-       if (!(*prdata)) {
-           /* maybe prdata is not allocated yet ... lets do it now */
-           if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
-               rrd_set_error("malloc imginfo");
-               return -1; 
-           };
-       }
-       if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
-        ==NULL){
-           rrd_set_error("malloc imginfo");
-           return -1;
-       }
-       filename=im.graphfile+strlen(im.graphfile);
-       while(filename > im.graphfile) {
-           if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
-           filename--;
-       }
-
-       sprintf((*prdata)[0],im.imginfo,filename,(long)(im.canvas->zoom*im.ximg),(long)(im.canvas->zoom*im.yimg));
+        char *filename;
+        if (!(*prdata)) {
+            /* maybe prdata is not allocated yet ... lets do it now */
+            if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
+                rrd_set_error("malloc imginfo");
+                return -1; 
+            };
+        }
+        if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
+         ==NULL){
+            rrd_set_error("malloc imginfo");
+            return -1;
+        }
+        filename=im.graphfile+strlen(im.graphfile);
+        while(filename > im.graphfile) {
+            if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
+            filename--;
+        }
+
+        sprintf((*prdata)[0],im.imginfo,filename,(long)(im.canvas->zoom*im.ximg),(long)(im.canvas->zoom*im.yimg));
     }
     im_free(&im);
     return 0;
@@ -3143,14 +3143,14 @@ rrd_graph_init(image_desc_t *im)
 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
     {
             char *windir; 
-           char rrd_win_default_font[1000];
+            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,500);
                     rrd_win_default_font[500] = '\0';
                     strcat(rrd_win_default_font,"\\fonts\\");
-                   strcat(rrd_win_default_font,RRD_DEFAULT_FONT);         
+                    strcat(rrd_win_default_font,RRD_DEFAULT_FONT);         
                     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';
@@ -3163,9 +3163,9 @@ rrd_graph_init(image_desc_t *im)
             deffont = getenv("RRD_DEFAULT_FONT");
             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';
-                }
+                        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++){        
@@ -3177,12 +3177,12 @@ rrd_graph_init(image_desc_t *im)
 void
 rrd_graph_options(int argc, char *argv[],image_desc_t *im)
 {
-    int                        stroff;    
-    char               *parsetime_error = NULL;
-    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 rrd_time_value      start_tv, end_tv;
+    int                        stroff;    
+    char                *parsetime_error = NULL;
+    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 rrd_time_value        start_tv, end_tv;
     gfx_color_t         color;
     optind = 0; opterr = 0;  /* initialize getopt */
 
@@ -3194,273 +3194,273 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
     #define LONGOPT_UNITS_SI 255
 
     while (1){
-       static struct option long_options[] =
-       {
-           {"start",      required_argument, 0,  's'},
-           {"end",        required_argument, 0,  'e'},
-           {"x-grid",     required_argument, 0,  'x'},
-           {"y-grid",     required_argument, 0,  'y'},
-           {"vertical-label",required_argument,0,'v'},
-           {"width",      required_argument, 0,  'w'},
-           {"height",     required_argument, 0,  'h'},
-           {"interlaced", no_argument,       0,  'i'},
-           {"upper-limit",required_argument, 0,  'u'},
-           {"lower-limit",required_argument, 0,  'l'},
-           {"rigid",      no_argument,       0,  'r'},
-           {"base",       required_argument, 0,  'b'},
-           {"logarithmic",no_argument,       0,  'o'},
-           {"color",      required_argument, 0,  'c'},
+        static struct option long_options[] =
+        {
+            {"start",      required_argument, 0,  's'},
+            {"end",        required_argument, 0,  'e'},
+            {"x-grid",     required_argument, 0,  'x'},
+            {"y-grid",     required_argument, 0,  'y'},
+            {"vertical-label",required_argument,0,'v'},
+            {"width",      required_argument, 0,  'w'},
+            {"height",     required_argument, 0,  'h'},
+            {"interlaced", no_argument,       0,  'i'},
+            {"upper-limit",required_argument, 0,  'u'},
+            {"lower-limit",required_argument, 0,  'l'},
+            {"rigid",      no_argument,       0,  'r'},
+            {"base",       required_argument, 0,  'b'},
+            {"logarithmic",no_argument,       0,  'o'},
+            {"color",      required_argument, 0,  'c'},
             {"font",       required_argument, 0,  'n'},
-           {"title",      required_argument, 0,  't'},
-           {"imginfo",    required_argument, 0,  'f'},
-           {"imgformat",  required_argument, 0,  'a'},
-           {"lazy",       no_argument,       0,  'z'},
+            {"title",      required_argument, 0,  't'},
+            {"imginfo",    required_argument, 0,  'f'},
+            {"imgformat",  required_argument, 0,  'a'},
+            {"lazy",       no_argument,       0,  'z'},
             {"zoom",       required_argument, 0,  'm'},
-           {"no-legend",  no_argument,       0,  'g'},
-           {"force-rules-legend",no_argument,0,  'F'},
+            {"no-legend",  no_argument,       0,  'g'},
+            {"force-rules-legend",no_argument,0,  'F'},
             {"only-graph", no_argument,       0,  'j'},
-           {"alt-y-grid", no_argument,       0,  'Y'},
+            {"alt-y-grid", no_argument,       0,  'Y'},
             {"no-minor",   no_argument,       0,  'I'},
-           {"slope-mode", no_argument,       0,  'E'},
-           {"alt-autoscale", no_argument,    0,  'A'},
-           {"alt-autoscale-max", no_argument, 0, 'M'},
+            {"slope-mode", no_argument,              0,  'E'},
+            {"alt-autoscale", no_argument,    0,  'A'},
+            {"alt-autoscale-max", no_argument, 0, 'M'},
             {"no-gridfit", no_argument,       0,   'N'},
-           {"units-exponent",required_argument, 0, 'X'},
-           {"units-length",required_argument, 0, 'L'},
+            {"units-exponent",required_argument, 0, 'X'},
+            {"units-length",required_argument, 0, 'L'},
             {"units",      required_argument, 0,  LONGOPT_UNITS_SI },
-           {"step",       required_argument, 0,    'S'},
+            {"step",       required_argument, 0,    'S'},
             {"tabwidth",   required_argument, 0,    'T'},            
-           {"font-render-mode", required_argument, 0, 'R'},
-           {"font-smoothing-threshold", required_argument, 0, 'B'},
-           {"watermark",  required_argument, 0,  'W'},
-           {"alt-y-mrtg", no_argument,       0,  1000}, /* this has no effect it is just here to save old apps from crashing when they use it */
-           {0,0,0,0}};
-       int option_index = 0;
-       int opt;
+            {"font-render-mode", required_argument, 0, 'R'},
+            {"font-smoothing-threshold", required_argument, 0, 'B'},
+            {"watermark",  required_argument, 0,  'W'},
+            {"alt-y-mrtg", no_argument,       0,  1000}, /* this has no effect it is just here to save old apps from crashing when they use it */
+            {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:I:zgjFYAMEX:L:S:T:NR:B:W:",
-                         long_options, &option_index);
+        opt = getopt_long(argc, argv, 
+                         "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:I:zgjFYAMEX:L:S:T:NR:B:W:",
+                          long_options, &option_index);
 
-       if (opt == EOF)
-           break;
-       
-       switch(opt) {
+        if (opt == EOF)
+            break;
+        
+        switch(opt) {
         case 'I':
             im->extra_flags |= NOMINOR;
             break;
-       case 'Y':
-           im->extra_flags |= ALTYGRID;
-           break;
-       case 'A':
-           im->extra_flags |= ALTAUTOSCALE;
-           break;
-       case 'M':
-           im->extra_flags |= ALTAUTOSCALE_MAX;
-           break;
+        case 'Y':
+            im->extra_flags |= ALTYGRID;
+            break;
+        case 'A':
+            im->extra_flags |= ALTAUTOSCALE;
+            break;
+        case 'M':
+            im->extra_flags |= ALTAUTOSCALE_MAX;
+            break;
         case 'j':
            im->extra_flags |= ONLY_GRAPH;
            break;
-       case 'g':
-           im->extra_flags |= NOLEGEND;
-           break;
-       case 'F':
-           im->extra_flags |= FORCE_RULES_LEGEND;
-           break;
-       case LONGOPT_UNITS_SI:
-           if(im->extra_flags & FORCE_UNITS) {
-               rrd_set_error("--units can only be used once!");
-               return;
-           }
-           if(strcmp(optarg,"si")==0)
-               im->extra_flags |= FORCE_UNITS_SI;
-           else {
-               rrd_set_error("invalid argument for --units: %s", optarg );
-               return;
-           }
-           break;
-       case 'X':
-           im->unitsexponent = atoi(optarg);
-           break;
-       case 'L':
-           im->unitslength = atoi(optarg);
+        case 'g':
+            im->extra_flags |= NOLEGEND;
+            break;
+        case 'F':
+            im->extra_flags |= FORCE_RULES_LEGEND;
+            break;
+        case LONGOPT_UNITS_SI:
+            if(im->extra_flags & FORCE_UNITS) {
+                rrd_set_error("--units can only be used once!");
+                return;
+            }
+            if(strcmp(optarg,"si")==0)
+                im->extra_flags |= FORCE_UNITS_SI;
+            else {
+                rrd_set_error("invalid argument for --units: %s", optarg );
+                return;
+            }
+            break;
+        case 'X':
+            im->unitsexponent = atoi(optarg);
+            break;
+        case 'L':
+            im->unitslength = atoi(optarg);
             im->forceleftspace = 1;
-           break;
-       case 'T':
-           im->tabwidth = atof(optarg);
-           break;
-       case 'S':
-           im->step =  atoi(optarg);
-           break;
-       case 'N':
-           im->gridfit = 0;
-           break;
-       case 's':
-           if ((parsetime_error = parsetime(optarg, &start_tv))) {
-               rrd_set_error( "start time: %s", parsetime_error );
-               return;
-           }
-           break;
-       case 'e':
-           if ((parsetime_error = parsetime(optarg, &end_tv))) {
-               rrd_set_error( "end time: %s", parsetime_error );
-               return;
-           }
-           break;
-       case 'x':
-           if(strcmp(optarg,"none") == 0){
-             im->draw_x_grid=0;
-             break;
-           };
-               
-           if(sscanf(optarg,
-                     "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
-                     scan_gtm,
-                     &im->xlab_user.gridst,
-                     scan_mtm,
-                     &im->xlab_user.mgridst,
-                     scan_ltm,
-                     &im->xlab_user.labst,
-                     &im->xlab_user.precis,
-                     &stroff) == 7 && stroff != 0){
+            break;
+        case 'T':
+            im->tabwidth = atof(optarg);
+            break;
+        case 'S':
+            im->step =  atoi(optarg);
+            break;
+        case 'N':
+            im->gridfit = 0;
+            break;
+        case 's':
+            if ((parsetime_error = parsetime(optarg, &start_tv))) {
+                rrd_set_error( "start time: %s", parsetime_error );
+                return;
+            }
+            break;
+        case 'e':
+            if ((parsetime_error = parsetime(optarg, &end_tv))) {
+                rrd_set_error( "end time: %s", parsetime_error );
+                return;
+            }
+            break;
+        case 'x':
+            if(strcmp(optarg,"none") == 0){
+              im->draw_x_grid=0;
+              break;
+            };
+                
+            if(sscanf(optarg,
+                      "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
+                      scan_gtm,
+                      &im->xlab_user.gridst,
+                      scan_mtm,
+                      &im->xlab_user.mgridst,
+                      scan_ltm,
+                      &im->xlab_user.labst,
+                      &im->xlab_user.precis,
+                      &stroff) == 7 && stroff != 0){
                 strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 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 ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
-                   rrd_set_error("unknown keyword %s",scan_mtm);
-                   return;
-               } else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
-                   rrd_set_error("unknown keyword %s",scan_ltm);
-                   return;
-               } 
-               im->xlab_user.minsec = 1;
-               im->xlab_user.stst = im->xlab_form;
-           } else {
-               rrd_set_error("invalid x-grid format");
-               return;
-           }
-           break;
-       case 'y':
-
-           if(strcmp(optarg,"none") == 0){
-             im->draw_y_grid=0;
-             break;
-           };
-
-           if(sscanf(optarg,
-                     "%lf:%d",
-                     &im->ygridstep,
-                     &im->ylabfact) == 2) {
-               if(im->ygridstep<=0){
-                   rrd_set_error("grid step must be > 0");
-                   return;
-               } else if (im->ylabfact < 1){
-                   rrd_set_error("label factor must be > 0");
-                   return;
-               } 
-           } else {
-               rrd_set_error("invalid y-grid format");
-               return;
-           }
-           break;
-       case 'v':
-           strncpy(im->ylegend,optarg,150);
-           im->ylegend[150]='\0';
-           break;
-       case 'u':
-           im->maxval = atof(optarg);
-           break;
-       case 'l':
-           im->minval = atof(optarg);
-           break;
-       case 'b':
-           im->base = atol(optarg);
-           if(im->base != 1024 && im->base != 1000 ){
-               rrd_set_error("the only sensible value for base apart from 1000 is 1024");
-               return;
-           }
-           break;
-       case 'w':
-           long_tmp = atol(optarg);
-           if (long_tmp < 10) {
-               rrd_set_error("width below 10 pixels");
-               return;
-           }
-           im->xsize = long_tmp;
-           break;
-       case 'h':
-           long_tmp = atol(optarg);
-           if (long_tmp < 10) {
-               rrd_set_error("height below 10 pixels");
-               return;
-           }
-           im->ysize = long_tmp;
-           break;
-       case 'i':
-           im->canvas->interlaced = 1;
-           break;
-       case 'r':
-           im->rigid = 1;
-           break;
-       case 'f':
-           im->imginfo = optarg;
-           break;
-       case 'a':
-           if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
-               rrd_set_error("unsupported graphics format '%s'",optarg);
-               return;
-           }
-           break;
-       case 'z':
-           im->lazy = 1;
-           break;
-       case 'E':
-           im->slopemode = 1;
-           break;
-
-       case 'o':
-           im->logarithmic = 1;
-           break;
+                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 ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
+                    rrd_set_error("unknown keyword %s",scan_mtm);
+                    return;
+                } else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
+                    rrd_set_error("unknown keyword %s",scan_ltm);
+                    return;
+                
+                im->xlab_user.minsec = 1;
+                im->xlab_user.stst = im->xlab_form;
+            } else {
+                rrd_set_error("invalid x-grid format");
+                return;
+            }
+            break;
+        case 'y':
+
+            if(strcmp(optarg,"none") == 0){
+              im->draw_y_grid=0;
+              break;
+            };
+
+            if(sscanf(optarg,
+                      "%lf:%d",
+                      &im->ygridstep,
+                      &im->ylabfact) == 2) {
+                if(im->ygridstep<=0){
+                    rrd_set_error("grid step must be > 0");
+                    return;
+                } else if (im->ylabfact < 1){
+                    rrd_set_error("label factor must be > 0");
+                    return;
+                
+            } else {
+                rrd_set_error("invalid y-grid format");
+                return;
+            }
+            break;
+        case 'v':
+            strncpy(im->ylegend,optarg,150);
+            im->ylegend[150]='\0';
+            break;
+        case 'u':
+            im->maxval = atof(optarg);
+            break;
+        case 'l':
+            im->minval = atof(optarg);
+            break;
+        case 'b':
+            im->base = atol(optarg);
+            if(im->base != 1024 && im->base != 1000 ){
+                rrd_set_error("the only sensible value for base apart from 1000 is 1024");
+                return;
+            }
+            break;
+        case 'w':
+            long_tmp = atol(optarg);
+            if (long_tmp < 10) {
+                rrd_set_error("width below 10 pixels");
+                return;
+            }
+            im->xsize = long_tmp;
+            break;
+        case 'h':
+            long_tmp = atol(optarg);
+            if (long_tmp < 10) {
+                rrd_set_error("height below 10 pixels");
+                return;
+            }
+            im->ysize = long_tmp;
+            break;
+        case 'i':
+            im->canvas->interlaced = 1;
+            break;
+        case 'r':
+            im->rigid = 1;
+            break;
+        case 'f':
+            im->imginfo = optarg;
+            break;
+            case 'a':
+            if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
+                rrd_set_error("unsupported graphics format '%s'",optarg);
+                return;
+            }
+            break;
+        case 'z':
+            im->lazy = 1;
+            break;
+        case 'E':
+            im->slopemode = 1;
+            break;
+
+        case 'o':
+            im->logarithmic = 1;
+            break;
         case 'c':
             if(sscanf(optarg,
                       "%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 3:
-                               color = (
-                                       ((color & 0xF00) * 0x110000) |
-                                       ((color & 0x0F0) * 0x011000) |
-                                       ((color & 0x00F) * 0x001100) |
-                                       0x000000FF
-                                       );
-                               break;
-                       case 4:
-                               color = (
-                                       ((color & 0xF000) * 0x11000) |
-                                       ((color & 0x0F00) * 0x01100) |
-                                       ((color & 0x00F0) * 0x00110) |
-                                       ((color & 0x000F) * 0x00011)
-                                       );
-                               break;
-                       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;
-               }
+                int col_len = col_end - col_start;
+                switch (col_len){
+                        case 3:
+                                color = (
+                                        ((color & 0xF00) * 0x110000) |
+                                        ((color & 0x0F0) * 0x011000) |
+                                        ((color & 0x00F) * 0x001100) |
+                                        0x000000FF
+                                        );
+                                break;
+                        case 4:
+                                color = (
+                                        ((color & 0xF000) * 0x11000) |
+                                        ((color & 0x0F00) * 0x01100) |
+                                        ((color & 0x00F0) * 0x00110) |
+                                        ((color & 0x000F) * 0x00011)
+                                        );
+                                break;
+                        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;
+                  return;
                 }
             } else {
                 rrd_set_error("invalid color def format");
@@ -3468,76 +3468,76 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
             }
             break;        
         case 'n':{
-           char prop[15];
-           double size = 1;
-           char font[1024] = "";
-
-           if(sscanf(optarg,
-                               "%10[A-Z]:%lf:%1000s",
-                               prop,&size,font) >= 2){
-               int sindex,propidx;
-               if((sindex=text_prop_conv(prop)) != -1){
-                  for (propidx=sindex;propidx<TEXT_PROP_LAST;propidx++){                     
-                     if (size > 0){
-                         im->text_prop[propidx].size=size;              
+            char prop[15];
+            double size = 1;
+            char font[1024] = "";
+
+            if(sscanf(optarg,
+                                "%10[A-Z]:%lf:%1000s",
+                                prop,&size,font) >= 2){
+                int sindex,propidx;
+                if((sindex=text_prop_conv(prop)) != -1){
+                  for (propidx=sindex;propidx<TEXT_PROP_LAST;propidx++){                        
+                        if (size > 0){
+                              im->text_prop[propidx].size=size;              
                       }
-                     if (strlen(font) > 0){
-                         strcpy(im->text_prop[propidx].font,font);
+                       if (strlen(font) > 0){
+                          strcpy(im->text_prop[propidx].font,font);
                       }
                       if (propidx==sindex && sindex != 0) break;
                   }
-               } else {
-                   rrd_set_error("invalid fonttag '%s'",prop);
-                   return;
-               }
-           } else {
-               rrd_set_error("invalid text property format");
-               return;
-           }
-           break;          
-       }
+                } else {
+                    rrd_set_error("invalid fonttag '%s'",prop);
+                    return;
+                }
+            } else {
+                rrd_set_error("invalid text property format");
+                return;
+            }
+            break;          
+        }
         case 'm':
-           im->canvas->zoom = atof(optarg);
-           if (im->canvas->zoom <= 0.0) {
-               rrd_set_error("zoom factor must be > 0");
-               return;
-           }
+            im->canvas->zoom = atof(optarg);
+            if (im->canvas->zoom <= 0.0) {
+                rrd_set_error("zoom factor must be > 0");
+                return;
+            }
           break;
-       case 't':
-           strncpy(im->title,optarg,150);
-           im->title[150]='\0';
-           break;
-
-       case 'R':
-               if ( strcmp( optarg, "normal" ) == 0 )
-                       im->canvas->aa_type = AA_NORMAL;
-               else if ( strcmp( optarg, "light" ) == 0 )
-                       im->canvas->aa_type = AA_LIGHT;
-               else if ( strcmp( optarg, "mono" ) == 0 )
-                       im->canvas->aa_type = AA_NONE;
-               else
-               {
-                       rrd_set_error("unknown font-render-mode '%s'", optarg );
-                       return;
-               }
-               break;
-
-       case 'B':
-           im->canvas->font_aa_threshold = atof(optarg);
-               break;
+        case 't':
+            strncpy(im->title,optarg,150);
+            im->title[150]='\0';
+            break;
+
+        case 'R':
+                if ( strcmp( optarg, "normal" ) == 0 )
+                        im->canvas->aa_type = AA_NORMAL;
+                else if ( strcmp( optarg, "light" ) == 0 )
+                        im->canvas->aa_type = AA_LIGHT;
+                else if ( strcmp( optarg, "mono" ) == 0 )
+                        im->canvas->aa_type = AA_NONE;
+                else
+                {
+                        rrd_set_error("unknown font-render-mode '%s'", optarg );
+                        return;
+                }
+                break;
+
+        case 'B':
+            im->canvas->font_aa_threshold = atof(optarg);
+                break;
 
         case 'W':
             strncpy(im->watermark,optarg,100);
             im->watermark[99]='\0';
             break;
 
-       case '?':
+        case '?':
             if (optopt != 0)
                 rrd_set_error("unknown option '%c'", optopt);
             else
                 rrd_set_error("unknown option '%s'",argv[optind-1]);
             return;
-       }
+        }
     }
     
     if (optind >= argc) {
@@ -3546,24 +3546,24 @@ rrd_graph_options(int argc, char *argv[],image_desc_t *im)
     }
 
     if (im->logarithmic == 1 && im->minval <= 0){
-       rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");    
-       return;
+        rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");        
+        return;
     }
 
     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
-       /* error string is set in parsetime.c */
-       return;
+        /* error string is set in parsetime.c */
+        return;
     }  
     
     if (start_tmp < 3600*24*365*10){
-       rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
-       return;
+        rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
+        return;
     }
     
     if (end_tmp < start_tmp) {
-       rrd_set_error("start (%ld) should be less than end (%ld)", 
-              start_tmp, end_tmp);
-       return;
+        rrd_set_error("start (%ld) should be less than end (%ld)", 
+               start_tmp, end_tmp);
+        return;
     }
     
     im->start = start_tmp;
@@ -3579,37 +3579,37 @@ rrd_graph_color(image_desc_t *im, char *var, char *err, int optional)
 
     color=strstr(var,"#");
     if (color==NULL) {
-       if (optional==0) {
-           rrd_set_error("Found no color in %s",err);
-           return 0;
-       }
-       return 0;
+        if (optional==0) {
+            rrd_set_error("Found no color in %s",err);
+            return 0;
+        }
+        return 0;
     } else {
-       int n=0;
-       char *rest;
-       gfx_color_t    col;
-
-       rest=strstr(color,":");
-       if (rest!=NULL)
-           n=rest-color;
-       else
-           n=strlen(color);
-
-       switch (n) {
-           case 7:
-               sscanf(color,"#%6lx%n",&col,&n);
+        int n=0;
+        char *rest;
+        gfx_color_t    col;
+
+        rest=strstr(color,":");
+        if (rest!=NULL)
+            n=rest-color;
+        else
+            n=strlen(color);
+
+        switch (n) {
+            case 7:
+                sscanf(color,"#%6lx%n",&col,&n);
                 col = (col << 8) + 0xff /* shift left by 8 */;
-               if (n!=7) rrd_set_error("Color problem in %s",err);
-               break;
-           case 9:
-               sscanf(color,"#%8lx%n",&col,&n);
-               if (n==9) break;
-           default:
-               rrd_set_error("Color problem in %s",err);
-       }
-       if (rrd_test_error()) return 0;
-       gdp->col = col;
-       return n;
+                if (n!=7) rrd_set_error("Color problem in %s",err);
+                break;
+            case 9:
+                sscanf(color,"#%8lx%n",&col,&n);
+                if (n==9) break;
+            default:
+                rrd_set_error("Color problem in %s",err);
+        }
+        if (rrd_test_error()) return 0;
+        gdp->col = col;
+        return n;
     }
 }
 
@@ -3628,10 +3628,10 @@ int bad_format(char *fmt) {
              if (*ptr == 's' || *ptr == 'S' || *ptr == '%') ptr++;
 
              /* %c is allowed (but use only with vdef!) */
-            else if (*ptr == 'c') {
-               ptr++;
-               n=1;
-            }
+             else if (*ptr == 'c') {
+                ptr++;
+                n=1;
+             }
 
              /* or else '% 6.2lf' and such are allowed */
              else {
@@ -3663,87 +3663,87 @@ const char *const str;
     /* A VDEF currently is either "func" or "param,func"
      * so the parsing is rather simple.  Change if needed.
      */
-    double     param;
-    char       func[30];
-    int                n;
+    double        param;
+    char        func[30];
+    int                n;
     
     n=0;
     sscanf(str,"%le,%29[A-Z]%n",&param,func,&n);
     if (n== (int)strlen(str)) { /* matched */
-       ;
+        ;
     } else {
-       n=0;
-       sscanf(str,"%29[A-Z]%n",func,&n);
-       if (n== (int)strlen(str)) { /* matched */
-           param=DNAN;
-       } else {
-           rrd_set_error("Unknown function string '%s' in VDEF '%s'"
-               ,str
-               ,gdes->vname
-               );
-           return -1;
-       }
-    }
-    if         (!strcmp("PERCENT",func)) gdes->vf.op = VDEF_PERCENT;
-    else if    (!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
-    else if    (!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
-    else if    (!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
-    else if    (!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
-    else if    (!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
-    else if    (!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
+        n=0;
+        sscanf(str,"%29[A-Z]%n",func,&n);
+        if (n== (int)strlen(str)) { /* matched */
+            param=DNAN;
+        } else {
+            rrd_set_error("Unknown function string '%s' in VDEF '%s'"
+                ,str
+                ,gdes->vname
+                );
+            return -1;
+        }
+    }
+    if                (!strcmp("PERCENT",func)) gdes->vf.op = VDEF_PERCENT;
+    else if        (!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
+    else if        (!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
+    else if        (!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
+    else if        (!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
+    else if        (!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
+    else if        (!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
     else if     (!strcmp("LSLSLOPE", func)) gdes->vf.op = VDEF_LSLSLOPE;
     else if     (!strcmp("LSLINT",   func)) gdes->vf.op = VDEF_LSLINT;
     else if     (!strcmp("LSLCORREL",func)) gdes->vf.op = VDEF_LSLCORREL;
     else {
-       rrd_set_error("Unknown function '%s' in VDEF '%s'\n"
-           ,func
-           ,gdes->vname
-           );
-       return -1;
+        rrd_set_error("Unknown function '%s' in VDEF '%s'\n"
+            ,func
+            ,gdes->vname
+            );
+        return -1;
     };
 
     switch (gdes->vf.op) {
-       case VDEF_PERCENT:
-           if (isnan(param)) { /* no parameter given */
-               rrd_set_error("Function '%s' needs parameter in VDEF '%s'\n"
-                   ,func
-                   ,gdes->vname
-                   );
-               return -1;
-           };
-           if (param>=0.0 && param<=100.0) {
-               gdes->vf.param = param;
-               gdes->vf.val   = DNAN;  /* undefined */
-               gdes->vf.when  = 0;     /* undefined */
-           } else {
-               rrd_set_error("Parameter '%f' out of range in VDEF '%s'\n"
-                   ,param
-                   ,gdes->vname
-                   );
-               return -1;
-           };
-           break;
-       case VDEF_MAXIMUM:
-       case VDEF_AVERAGE:
-       case VDEF_MINIMUM:
-       case VDEF_TOTAL:
-       case VDEF_FIRST:
-       case VDEF_LAST:
-       case VDEF_LSLSLOPE:
-       case VDEF_LSLINT:
-       case VDEF_LSLCORREL:
-           if (isnan(param)) {
-               gdes->vf.param = DNAN;
-               gdes->vf.val   = DNAN;
-               gdes->vf.when  = 0;
-           } else {
-               rrd_set_error("Function '%s' needs no parameter in VDEF '%s'\n"
-                   ,func
-                   ,gdes->vname
-                   );
-               return -1;
-           };
-           break;
+        case VDEF_PERCENT:
+            if (isnan(param)) { /* no parameter given */
+                rrd_set_error("Function '%s' needs parameter in VDEF '%s'\n"
+                    ,func
+                    ,gdes->vname
+                    );
+                return -1;
+            };
+            if (param>=0.0 && param<=100.0) {
+                gdes->vf.param = param;
+                gdes->vf.val   = DNAN;        /* undefined */
+                gdes->vf.when  = 0;        /* undefined */
+            } else {
+                rrd_set_error("Parameter '%f' out of range in VDEF '%s'\n"
+                    ,param
+                    ,gdes->vname
+                    );
+                return -1;
+            };
+            break;
+        case VDEF_MAXIMUM:
+        case VDEF_AVERAGE:
+        case VDEF_MINIMUM:
+        case VDEF_TOTAL:
+        case VDEF_FIRST:
+        case VDEF_LAST:
+        case VDEF_LSLSLOPE:
+        case VDEF_LSLINT:
+        case VDEF_LSLCORREL:
+            if (isnan(param)) {
+                gdes->vf.param = DNAN;
+                gdes->vf.val   = DNAN;
+                gdes->vf.when  = 0;
+            } else {
+                rrd_set_error("Function '%s' needs no parameter in VDEF '%s'\n"
+                    ,func
+                    ,gdes->vname
+                    );
+                return -1;
+            };
+            break;
     };
     return 0;
 }
@@ -3754,9 +3754,9 @@ vdef_calc(im,gdi)
 image_desc_t *im;
 int gdi;
 {
-    graph_desc_t       *src,*dst;
-    rrd_value_t                *data;
-    long               step,steps;
+    graph_desc_t        *src,*dst;
+    rrd_value_t                *data;
+    long                step,steps;
 
     dst = &im->gdes[gdi];
     src = &im->gdes[dst->vidx];
@@ -3772,166 +3772,166 @@ printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
 #endif
 
     switch (dst->vf.op) {
-       case VDEF_PERCENT: {
-               rrd_value_t *   array;
-               int             field;
-
-
-               if ((array = malloc(steps*sizeof(double)))==NULL) {
-                   rrd_set_error("malloc VDEV_PERCENT");
-                   return -1;
-               }
-               for (step=0;step < steps; step++) {
-                   array[step]=data[step*src->ds_cnt];
-               }
-               qsort(array,step,sizeof(double),vdef_percent_compar);
-
-               field = (steps-1)*dst->vf.param/100;
-               dst->vf.val  = array[field];
-               dst->vf.when = 0;       /* no time component */
-               free(array);
+        case VDEF_PERCENT: {
+                rrd_value_t *        array;
+                int                field;
+
+
+                if ((array = malloc(steps*sizeof(double)))==NULL) {
+                    rrd_set_error("malloc VDEV_PERCENT");
+                    return -1;
+                }
+                for (step=0;step < steps; step++) {
+                    array[step]=data[step*src->ds_cnt];
+                }
+                qsort(array,step,sizeof(double),vdef_percent_compar);
+
+                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?'*':' ');
 #endif
-           }
-           break;
-       case VDEF_MAXIMUM:
-           step=0;
-           while (step != steps && isnan(data[step*src->ds_cnt])) step++;
-           if (step == steps) {
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           } else {
-               dst->vf.val  = data[step*src->ds_cnt];
-               dst->vf.when = src->start + (step+1)*src->step;
-           }
-           while (step != steps) {
-               if (finite(data[step*src->ds_cnt])) {
-                   if (data[step*src->ds_cnt] > dst->vf.val) {
-                       dst->vf.val  = data[step*src->ds_cnt];
-                       dst->vf.when = src->start + (step+1)*src->step;
-                   }
-               }
-               step++;
-           }
-           break;
-       case VDEF_TOTAL:
-       case VDEF_AVERAGE: {
-           int cnt=0;
-           double sum=0.0;
-           for (step=0;step<steps;step++) {
-               if (finite(data[step*src->ds_cnt])) {
-                   sum += data[step*src->ds_cnt];
-                   cnt ++;
-               };
-           }
-           if (cnt) {
-               if (dst->vf.op == VDEF_TOTAL) {
-                   dst->vf.val  = sum*src->step;
-                   dst->vf.when = 0;   /* no time component */
-               } else {
-                   dst->vf.val = sum/cnt;
-                   dst->vf.when = 0;   /* no time component */
-               };
-           } else {
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           }
-           }
-           break;
-       case VDEF_MINIMUM:
-           step=0;
-           while (step != steps && isnan(data[step*src->ds_cnt])) step++;
-           if (step == steps) {
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           } else {
-               dst->vf.val  = data[step*src->ds_cnt];
-               dst->vf.when = src->start + (step+1)*src->step;
-           }
-           while (step != steps) {
-               if (finite(data[step*src->ds_cnt])) {
-                   if (data[step*src->ds_cnt] < dst->vf.val) {
-                       dst->vf.val  = data[step*src->ds_cnt];
-                       dst->vf.when = src->start + (step+1)*src->step;
-                   }
-               }
-               step++;
-           }
-           break;
-       case VDEF_FIRST:
-           /* The time value returned here is one step before the
-            * actual time value.  This is the start of the first
-            * non-NaN interval.
-            */
-           step=0;
-           while (step != steps && isnan(data[step*src->ds_cnt])) step++;
-           if (step == steps) { /* all entries were NaN */
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           } else {
-               dst->vf.val  = data[step*src->ds_cnt];
-               dst->vf.when = src->start + step*src->step;
-           }
-           break;
-       case VDEF_LAST:
-           /* The time value returned here is the
-            * actual time value.  This is the end of the last
-            * non-NaN interval.
-            */
-           step=steps-1;
-           while (step >= 0 && isnan(data[step*src->ds_cnt])) step--;
-           if (step < 0) { /* all entries were NaN */
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           } else {
-               dst->vf.val  = data[step*src->ds_cnt];
-               dst->vf.when = src->start + (step+1)*src->step;
-           }
-           break;
-       case VDEF_LSLSLOPE:
-       case VDEF_LSLINT:
-       case VDEF_LSLCORREL:{
-           /* Bestfit line by linear least squares method */ 
-
-           int cnt=0;
-           double SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl ;
-           SUMx = 0; SUMy = 0; SUMxy = 0; SUMxx = 0; SUMyy = 0;
-
-           for (step=0;step<steps;step++) {
-               if (finite(data[step*src->ds_cnt])) {
-                   cnt++;
-                   SUMx  += step;
-                   SUMxx += step * step;
-                   SUMxy += step * data[step*src->ds_cnt];
-                   SUMy  += data[step*src->ds_cnt];
-                   SUMyy  += data[step*src->ds_cnt]*data[step*src->ds_cnt];
-               };
-           }
-
-           slope = ( SUMx*SUMy - cnt*SUMxy ) / ( SUMx*SUMx - cnt*SUMxx );
-           y_intercept = ( SUMy - slope*SUMx ) / cnt;
-           correl = (SUMxy - (SUMx*SUMy)/cnt) / sqrt((SUMxx - (SUMx*SUMx)/cnt)*(SUMyy - (SUMy*SUMy)/cnt));
-
-           if (cnt) {
-                   if (dst->vf.op == VDEF_LSLSLOPE) {
-                       dst->vf.val  = slope;
-                       dst->vf.when = 0;
-                   } else if (dst->vf.op == VDEF_LSLINT)  {
-                       dst->vf.val = y_intercept;
-                       dst->vf.when = 0;
-                   } else if (dst->vf.op == VDEF_LSLCORREL)  {
-                       dst->vf.val = correl;
-                       dst->vf.when = 0;
-                   };
-               
-           } else {
-               dst->vf.val  = DNAN;
-               dst->vf.when = 0;
-           }
-       }
-       break;
+            }
+            break;
+        case VDEF_MAXIMUM:
+            step=0;
+            while (step != steps && isnan(data[step*src->ds_cnt])) step++;
+            if (step == steps) {
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            } else {
+                dst->vf.val  = data[step*src->ds_cnt];
+                dst->vf.when = src->start + (step+1)*src->step;
+            }
+            while (step != steps) {
+                if (finite(data[step*src->ds_cnt])) {
+                    if (data[step*src->ds_cnt] > dst->vf.val) {
+                        dst->vf.val  = data[step*src->ds_cnt];
+                        dst->vf.when = src->start + (step+1)*src->step;
+                    }
+                }
+                step++;
+            }
+            break;
+        case VDEF_TOTAL:
+        case VDEF_AVERAGE: {
+            int cnt=0;
+            double sum=0.0;
+            for (step=0;step<steps;step++) {
+                if (finite(data[step*src->ds_cnt])) {
+                    sum += data[step*src->ds_cnt];
+                    cnt ++;
+                };
+            }
+            if (cnt) {
+                if (dst->vf.op == VDEF_TOTAL) {
+                    dst->vf.val  = sum*src->step;
+                    dst->vf.when = 0;        /* no time component */
+                } else {
+                    dst->vf.val = sum/cnt;
+                    dst->vf.when = 0;        /* no time component */
+                };
+            } else {
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            }
+            }
+            break;
+        case VDEF_MINIMUM:
+            step=0;
+            while (step != steps && isnan(data[step*src->ds_cnt])) step++;
+            if (step == steps) {
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            } else {
+                dst->vf.val  = data[step*src->ds_cnt];
+                dst->vf.when = src->start + (step+1)*src->step;
+            }
+            while (step != steps) {
+                if (finite(data[step*src->ds_cnt])) {
+                    if (data[step*src->ds_cnt] < dst->vf.val) {
+                        dst->vf.val  = data[step*src->ds_cnt];
+                        dst->vf.when = src->start + (step+1)*src->step;
+                    }
+                }
+                step++;
+            }
+            break;
+        case VDEF_FIRST:
+            /* The time value returned here is one step before the
+             * actual time value.  This is the start of the first
+             * non-NaN interval.
+             */
+            step=0;
+            while (step != steps && isnan(data[step*src->ds_cnt])) step++;
+            if (step == steps) { /* all entries were NaN */
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            } else {
+                dst->vf.val  = data[step*src->ds_cnt];
+                dst->vf.when = src->start + step*src->step;
+            }
+            break;
+        case VDEF_LAST:
+            /* The time value returned here is the
+             * actual time value.  This is the end of the last
+             * non-NaN interval.
+             */
+            step=steps-1;
+            while (step >= 0 && isnan(data[step*src->ds_cnt])) step--;
+            if (step < 0) { /* all entries were NaN */
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            } else {
+                dst->vf.val  = data[step*src->ds_cnt];
+                dst->vf.when = src->start + (step+1)*src->step;
+            }
+            break;
+        case VDEF_LSLSLOPE:
+        case VDEF_LSLINT:
+        case VDEF_LSLCORREL:{
+            /* Bestfit line by linear least squares method */ 
+
+            int cnt=0;
+            double SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl ;
+            SUMx = 0; SUMy = 0; SUMxy = 0; SUMxx = 0; SUMyy = 0;
+
+            for (step=0;step<steps;step++) {
+                if (finite(data[step*src->ds_cnt])) {
+                    cnt++;
+                    SUMx  += step;
+                    SUMxx += step * step;
+                    SUMxy += step * data[step*src->ds_cnt];
+                    SUMy  += data[step*src->ds_cnt];
+                    SUMyy  += data[step*src->ds_cnt]*data[step*src->ds_cnt];
+                };
+            }
+
+            slope = ( SUMx*SUMy - cnt*SUMxy ) / ( SUMx*SUMx - cnt*SUMxx );
+            y_intercept = ( SUMy - slope*SUMx ) / cnt;
+            correl = (SUMxy - (SUMx*SUMy)/cnt) / sqrt((SUMxx - (SUMx*SUMx)/cnt)*(SUMyy - (SUMy*SUMy)/cnt));
+
+            if (cnt) {
+                    if (dst->vf.op == VDEF_LSLSLOPE) {
+                        dst->vf.val  = slope;
+                        dst->vf.when = 0;
+                    } else if (dst->vf.op == VDEF_LSLINT)  {
+                        dst->vf.val = y_intercept;
+                        dst->vf.when = 0;
+                    } else if (dst->vf.op == VDEF_LSLCORREL)  {
+                        dst->vf.val = correl;
+                        dst->vf.when = 0;
+                    };
+                
+            } else {
+                dst->vf.val  = DNAN;
+                dst->vf.when = 0;
+            }
+        }
+        break;
     }
     return 0;
 }