src/rrd_gfx.c

   1 /****************************************************************************
   2  * RRDtool 1.1.x  Copyright Tobias Oetiker, 1997 - 2002
   3  ****************************************************************************
   4  * rrd_gfx.c  graphics wrapper for rrdtool
   5   **************************************************************************/
   6
   7 /* #define DEBUG */
   8
   9 #ifdef DEBUG
  10 # define DPRINT(x)    (void)(printf x, printf("\n"))
  11 #else
  12 # define DPRINT(x)
  13 #endif
  14 #include "rrd_tool.h"
  15 #include <png.h>
  16 #include <ft2build.h>
  17 #include FT_FREETYPE_H
  18
  19 #include "rrd_gfx.h"
  20 #include "rrd_afm.h"
  21
  22 /* lines are better drawn on the pixle than between pixles */
  23 #define LINEOFFSET 0.5
  24
  25 static
  26 gfx_node_t *gfx_new_node( gfx_canvas_t *canvas,enum gfx_en type){
  27   gfx_node_t *node = art_new(gfx_node_t,1);
  28   if (node == NULL) return NULL;
  29   node->type = type;
  30   node->color = 0x0;        /* color of element  0xRRGGBBAA  alpha 0xff is solid*/
  31   node->size =0.0;         /* font size, line width */
  32   node->path = NULL;        /* path */
  33   node->points = 0;
  34   node->points_max =0;
  35   node->closed_path = 0;
  36   node->svp = NULL;         /* svp */
  37   node->filename = NULL;             /* font or image filename */
  38   node->text = NULL;
  39   node->x = 0.0;
  40   node->y = 0.0;          /* position */
  41   node->angle = 0;
  42   node->halign = GFX_H_NULL; /* text alignement */
  43   node->valign = GFX_V_NULL; /* text alignement */
  44   node->tabwidth = 0.0;
  45   node->next = NULL;
  46   if (canvas->lastnode != NULL){
  47       canvas->lastnode->next = node;
  48   }
  49   if (canvas->firstnode == NULL){
  50       canvas->firstnode = node;
  51   }
  52   canvas->lastnode = node;
  53   return node;
  54 }
  55
  56 gfx_canvas_t *gfx_new_canvas (void) {
  57     gfx_canvas_t *canvas = art_new(gfx_canvas_t,1);
  58     canvas->firstnode = NULL;
  59     canvas->lastnode = NULL;
  60     canvas->imgformat = IF_PNG; /* we default to PNG output */
  61     canvas->interlaced = 0;
  62     canvas->zoom = 1.0;
  63     return canvas;
  64 }
  65
  66 /* create a new line */
  67 gfx_node_t  *gfx_new_line(gfx_canvas_t *canvas,
  68                            double X0, double Y0,
  69                            double X1, double Y1,
  70                            double width, gfx_color_t color){
  71   return gfx_new_dashed_line(canvas, X0, Y0, X1, Y1, width, color, 0, 0);
  72 }
  73
  74 gfx_node_t  *gfx_new_dashed_line(gfx_canvas_t *canvas,
  75                            double X0, double Y0,
  76                            double X1, double Y1,
  77                            double width, gfx_color_t color,
  78                            double dash_on, double dash_off){
  79
  80   gfx_node_t *node;
  81   ArtVpath *vec;
  82   node = gfx_new_node(canvas,GFX_LINE);
  83   if (node == NULL) return NULL;
  84   vec = art_new(ArtVpath, 3);
  85   if (vec == NULL) return NULL;
  86   vec[0].code = ART_MOVETO_OPEN; vec[0].x=X0+LINEOFFSET; vec[0].y=Y0+LINEOFFSET;
  87   vec[1].code = ART_LINETO; vec[1].x=X1+LINEOFFSET; vec[1].y=Y1+LINEOFFSET;
  88   vec[2].code = ART_END;
  89
  90   node->points = 3;
  91   node->points_max = 3;
  92   node->color = color;
  93   node->size  = width;
  94   node->dash_on = dash_on;
  95   node->dash_off = dash_off;
  96   node->path  = vec;
  97   return node;
  98 }
  99
 100 /* create a new area */
 101 gfx_node_t   *gfx_new_area   (gfx_canvas_t *canvas,
 102                               double X0, double Y0,
 103                               double X1, double Y1,
 104                               double X2, double Y2,
 105                               gfx_color_t color) {
 106
 107   gfx_node_t *node;
 108   ArtVpath *vec;
 109   node = gfx_new_node(canvas,GFX_AREA);
 110   if (node == NULL) return NULL;
 111   vec = art_new(ArtVpath, 5);
 112   if (vec == NULL) return NULL;
 113   vec[0].code = ART_MOVETO; vec[0].x=X0; vec[0].y=Y0;
 114   vec[1].code = ART_LINETO; vec[1].x=X1; vec[1].y=Y1;
 115   vec[2].code = ART_LINETO; vec[2].x=X2; vec[2].y=Y2;
 116   vec[3].code = ART_LINETO; vec[3].x=X0; vec[3].y=Y0;
 117   vec[4].code = ART_END;
 118
 119   node->points = 5;
 120   node->points_max = 5;
 121   node->color = color;
 122   node->path  = vec;
 123
 124   return node;
 125 }
 126
 127 /* add a point to a line or to an area */
 128 int           gfx_add_point  (gfx_node_t *node,
 129                               double x, double y){
 130   if (node == NULL) return 1;
 131   if (node->type == GFX_AREA) {
 132     double X0 = node->path[0].x;
 133     double Y0 = node->path[0].y;
 134     node->points -= 2;
 135     art_vpath_add_point (&(node->path),
 136                          &(node->points),
 137                          &(node->points_max),
 138                          ART_LINETO,
 139                          x,y);
 140     art_vpath_add_point (&(node->path),
 141                          &(node->points),
 142                          &(node->points_max),
 143                          ART_LINETO,
 144                          X0,Y0);
 145     art_vpath_add_point (&(node->path),
 146                          &(node->points),
 147                          &(node->points_max),
 148                          ART_END,
 149                          0,0);
 150   } else if (node->type == GFX_LINE) {
 151     node->points -= 1;
 152     art_vpath_add_point (&(node->path),
 153                          &(node->points),
 154                          &(node->points_max),
 155                          ART_LINETO,
 156                          x+LINEOFFSET,y+LINEOFFSET);
 157     art_vpath_add_point (&(node->path),
 158                          &(node->points),
 159                          &(node->points_max),
 160                          ART_END,
 161                          0,0);
 162
 163   } else {
 164     /* can only add point to areas and lines */
 165     return 1;
 166   }
 167   return 0;
 168 }
 169
 170 void           gfx_close_path  (gfx_node_t *node) {
 171     node->closed_path = 1;
 172 }
 173
 174 /* create a text node */
 175 gfx_node_t   *gfx_new_text   (gfx_canvas_t *canvas,
 176                               double x, double y, gfx_color_t color,
 177                               char* font, double size,
 178                               double tabwidth, double angle,
 179                               enum gfx_h_align_en h_align,
 180                               enum gfx_v_align_en v_align,
 181                               char* text){
 182    gfx_node_t *node = gfx_new_node(canvas,GFX_TEXT);
 183    if (angle != 0.0){
 184        /* currently we only support 0 and 270 */
 185        angle = 270.0;
 186    }
 187
 188    node->text = strdup(text);
 189    node->size = size;
 190    node->filename = strdup(font);
 191    node->x = x;
 192    node->y = y;
 193    node->angle = angle;
 194    node->color = color;
 195    node->tabwidth = tabwidth;
 196    node->halign = h_align;
 197    node->valign = v_align;
 198 #if 0
 199   /* debugging: show text anchor */
 200    gfx_new_line(canvas, x - 3, y + 0, x, y, 0.2, 0x00FF0000);
 201    gfx_new_line(canvas, x - 0, y + 3, x, y, 0.2, 0x00FF0000);
 202 #endif
 203    return node;
 204 }
 205
 206 int           gfx_render(gfx_canvas_t *canvas,
 207                               art_u32 width, art_u32 height,
 208                               gfx_color_t background, FILE *fp){
 209   switch (canvas->imgformat) {
 210   case IF_PNG:
 211     return gfx_render_png (canvas, width, height, background, fp);
 212   case IF_SVG:
 213     return gfx_render_svg (canvas, width, height, background, fp);
 214   case IF_EPS:
 215     return gfx_render_eps (canvas, width, height, background, fp);
 216   default:
 217     return -1;
 218   }
 219 }
 220
 221 double gfx_get_text_width ( gfx_canvas_t *canvas,
 222                             double start, char* font, double size,
 223                             double tabwidth, char* text){
 224   switch (canvas->imgformat) {
 225   case IF_PNG:
 226     return gfx_get_text_width_libart (canvas, start, font, size, tabwidth, text);
 227   case IF_SVG: /* fall through */
 228   case IF_EPS:
 229     return afm_get_text_width(start, font, size, tabwidth, text);
 230   default:
 231     return size * strlen(text);
 232   }
 233 }
 234
 235 double gfx_get_text_width_libart ( gfx_canvas_t *canvas,
 236                             double start, char* font, double size,
 237                             double tabwidth, char* text){
 238
 239   FT_GlyphSlot  slot;
 240   FT_UInt       previous=0;
 241   FT_UInt       glyph_index=0;
 242   FT_Bool       use_kerning;
 243   int           error;
 244   FT_Face       face;
 245   FT_Library    library=NULL;
 246   double        text_width=0;
 247   FT_Init_FreeType( &library );
 248   error = FT_New_Face( library, font, 0, &face );
 249   if ( error ) return -1;
 250   error = FT_Set_Char_Size(face,  size*64,size*64,  100,100);
 251   if ( error ) return -1;
 252
 253   use_kerning = FT_HAS_KERNING(face);
 254   slot = face->glyph;
 255   for(;*text;text++) {
 256     previous = glyph_index;
 257     glyph_index = FT_Get_Char_Index( face, *text);
 258
 259     if (use_kerning && previous && glyph_index){
 260       FT_Vector  delta;
 261       FT_Get_Kerning( face, previous, glyph_index,
 262                       0, &delta );
 263       text_width += (double)delta.x / 64.0;
 264
 265     }
 266     error = FT_Load_Glyph( face, glyph_index, 0 );
 267     if ( error ) {
 268       FT_Done_FreeType(library);
 269       return -1;
 270     }
 271     if (! previous) {
 272       text_width -= (double)slot->metrics.horiBearingX / 64.0; /* add just char width */
 273     }
 274     text_width += (double)slot->metrics.horiAdvance / 64.0;
 275   }
 276   text_width -= (double)slot->metrics.horiAdvance / 64.0; /* remove last step */
 277   text_width += (double)slot->metrics.width / 64.0; /* add just char width */
 278   text_width += (double)slot->metrics.horiBearingX / 64.0; /* add just char width */
 279   FT_Done_FreeType(library);
 280   return text_width;
 281 }
 282
 283 static int gfx_save_png (art_u8 *buffer, FILE *fp,
 284                      long width, long height, long bytes_per_pixel);
 285 /* render grafics into png image */
 286 int           gfx_render_png (gfx_canvas_t *canvas,
 287                               art_u32 width, art_u32 height,
 288                               gfx_color_t background, FILE *fp){
 289
 290
 291     FT_Library    library;
 292     gfx_node_t *node = canvas->firstnode;
 293     art_u8 red = background >> 24, green = (background >> 16) & 0xff;
 294     art_u8 blue = (background >> 8) & 0xff, alpha = ( background & 0xff );
 295     unsigned long pys_width = width * canvas->zoom;
 296     unsigned long pys_height = height * canvas->zoom;
 297     const int bytes_per_pixel = 3;
 298     unsigned long rowstride = pys_width*bytes_per_pixel; /* bytes per pixel */
 299     art_u8 *buffer = art_new (art_u8, rowstride*pys_height);
 300     art_rgb_run_alpha (buffer, red, green, blue, alpha, pys_width*pys_height);
 301     FT_Init_FreeType( &library );
 302     while(node){
 303         switch (node->type) {
 304         case GFX_LINE:
 305         case GFX_AREA: {
 306             ArtVpath *vec;
 307             double dst[6];
 308             ArtSVP *svp;
 309             if (node->closed_path) {
 310                 /* libart uses end==start for closed as indicator of closed path */
 311                 gfx_add_point(node, node->path[0].x, node->path[0].y);
 312                 node->closed_path = 0;
 313             }
 314             art_affine_scale(dst,canvas->zoom,canvas->zoom);
 315             vec = art_vpath_affine_transform(node->path,dst);
 316             if(node->type == GFX_LINE){
 317                 svp = art_svp_vpath_stroke ( vec, ART_PATH_STROKE_JOIN_ROUND,
 318                                              ART_PATH_STROKE_CAP_ROUND,
 319                                              node->size*canvas->zoom,1,1);
 320             } else {
 321                 svp = art_svp_from_vpath ( vec );
 322             }
 323             art_free(vec);
 324             art_rgb_svp_alpha (svp ,0,0, pys_width, pys_height,
 325                                node->color, buffer, rowstride, NULL);
 326             art_free(svp);
 327             break;
 328         }
 329         case GFX_TEXT: {
 330             int  error;
 331             float text_width=0.0, text_height = 0.0;
 332             unsigned char *text;
 333             art_u8 fcolor[3],falpha;
 334             FT_Face       face;
 335             FT_GlyphSlot  slot;
 336             FT_UInt       previous=0;
 337             FT_UInt       glyph_index=0;
 338             FT_Bool       use_kerning;
 339
 340             float pen_x = 0.0 , pen_y = 0.0;
 341             /* double x,y; */
 342             long   ix,iy,iz;
 343
 344             fcolor[0] = node->color >> 24;
 345             fcolor[1] = (node->color >> 16) & 0xff;
 346             fcolor[2] = (node->color >> 8) & 0xff;
 347             falpha = node->color & 0xff;
 348             error = FT_New_Face( library,
 349                                  (char *)node->filename,
 350                                  0,
 351                                  &face );
 352             if ( error ) break;
 353             use_kerning = FT_HAS_KERNING(face);
 354
 355             error = FT_Set_Char_Size(face,   /* handle to face object            */
 356                                      (long)(node->size*64),
 357                                      (long)(node->size*64),
 358                                      (long)(100*canvas->zoom),
 359                                      (long)(100*canvas->zoom));
 360             if ( error ) break;
 361             pen_x = node->x * canvas->zoom;
 362             pen_y = node->y * canvas->zoom;
 363             slot = face->glyph;
 364
 365             for(text=(unsigned char *)node->text;*text;text++) {
 366                 previous = glyph_index;
 367                 glyph_index = FT_Get_Char_Index( face, *text);
 368
 369                 if (use_kerning && previous && glyph_index){
 370                     FT_Vector  delta;
 371                     FT_Get_Kerning( face, previous, glyph_index,
 372                                     0, &delta );
 373                     text_width += (double)delta.x / 64.0;
 374
 375                 }
 376                 error = FT_Load_Glyph( face, glyph_index, 0 );
 377                 if ( error ) break;
 378                 if (previous == 0){
 379                   pen_x -= (double)slot->metrics.horiBearingX / 64.0; /* adjust pos for first char */
 380                   text_width -= (double)slot->metrics.horiBearingX / 64.0; /* add just char width */
 381                 }
 382                 if ( text_height < (double)slot->metrics.horiBearingY / 64.0 ) {
 383                   text_height = (double)slot->metrics.horiBearingY / 64.0;
 384                 }
 385                 text_width += (double)slot->metrics.horiAdvance / 64.0;
 386             }
 387             text_width -= (double)slot->metrics.horiAdvance / 64.0; /* remove last step */
 388             text_width += (double)slot->metrics.width / 64.0; /* add just char width */
 389             text_width += (double)slot->metrics.horiBearingX / 64.0; /* add just char width */
 390
 391             switch(node->halign){
 392             case GFX_H_RIGHT:  pen_x -= text_width; break;
 393             case GFX_H_CENTER: pen_x -= text_width / 2.0; break;
 394             case GFX_H_LEFT: break;
 395             case GFX_H_NULL: break;
 396             }
 397
 398             switch(node->valign){
 399             case GFX_V_TOP:    pen_y += text_height; break;
 400             case GFX_V_CENTER: pen_y += text_height / 2.0; break;
 401             case GFX_V_BOTTOM: break;
 402             case GFX_V_NULL: break;
 403             }
 404
 405             glyph_index=0;
 406             for(text=(unsigned char *)node->text;*text;text++) {
 407                 int gr;
 408                 previous = glyph_index;
 409                 glyph_index = FT_Get_Char_Index( face, *text);
 410
 411                 if (use_kerning && previous && glyph_index){
 412                     FT_Vector  delta;
 413                     FT_Get_Kerning( face, previous, glyph_index,
 414                                     0, &delta );
 415                     pen_x += (double)delta.x / 64.0;
 416
 417                 }
 418                 error = FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER );
 419                 if ( error ) break;
 420                 gr = slot->bitmap.num_grays -1;
 421                 for (iy=0; iy < slot->bitmap.rows; iy++){
 422                     long buf_y = iy+(pen_y+0.5)-slot->bitmap_top;
 423                     if (buf_y < 0 || buf_y >= pys_height) continue;
 424                     buf_y *= rowstride;
 425                     for (ix=0;ix < slot->bitmap.width;ix++){
 426                         long buf_x = ix + (pen_x + 0.5) + (double)slot->bitmap_left ;
 427                         art_u8 font_alpha;
 428
 429                         if (buf_x < 0 || buf_x >= pys_width) continue;
 430                         buf_x *=  bytes_per_pixel ;
 431                         font_alpha =  *(slot->bitmap.buffer + iy * slot->bitmap.width + ix);
 432                         font_alpha =  (art_u8)((double)font_alpha / gr * falpha);
 433                         for (iz = 0; iz < 3; iz++){
 434                             art_u8 *orig = buffer + buf_y + buf_x + iz;
 435                             *orig =  (art_u8)((double)*orig / gr * ( gr - font_alpha) +
 436                                               (double)fcolor[iz] / gr * (font_alpha));
 437                         }
 438                     }
 439                 }
 440                 pen_x += (double)slot->metrics.horiAdvance / 64.0;
 441             }
 442         }
 443         }
 444         node = node->next;
 445     }
 446     gfx_save_png(buffer,fp , pys_width,pys_height,bytes_per_pixel);
 447     art_free(buffer);
 448     FT_Done_FreeType( library );
 449     return 0;
 450 }
 451
 452 /* free memory used by nodes this will also remove memory required for
 453    associated paths and svcs ... but not for text strings */
 454 int
 455 gfx_destroy    (gfx_canvas_t *canvas){
 456   gfx_node_t *next,*node = canvas->firstnode;
 457   while(node){
 458     next = node->next;
 459     art_free(node->path);
 460     art_free(node->svp);
 461     free(node->text);
 462     free(node->filename);
 463     art_free(node);
 464     node = next;
 465   }
 466   return 0;
 467 }
 468
 469 static int gfx_save_png (art_u8 *buffer, FILE *fp,  long width, long height, long bytes_per_pixel){
 470   png_structp png_ptr = NULL;
 471   png_infop   info_ptr = NULL;
 472   int i;
 473   png_bytep *row_pointers;
 474   int rowstride = width * bytes_per_pixel;
 475   png_text text[2];
 476
 477   if (fp == NULL)
 478     return (1);
 479
 480   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
 481   if (png_ptr == NULL)
 482    {
 483       return (1);
 484    }
 485    row_pointers = (png_bytepp)png_malloc(png_ptr,
 486                                      height*sizeof(png_bytep));
 487
 488   info_ptr = png_create_info_struct(png_ptr);
 489
 490   if (info_ptr == NULL)
 491     {
 492       png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
 493       return (1);
 494     }
 495
 496   if (setjmp(png_jmpbuf(png_ptr)))
 497     {
 498       /* If we get here, we had a problem writing the file */
 499       png_destroy_write_struct(&png_ptr, &info_ptr);
 500       return (1);
 501     }
 502
 503   png_init_io(png_ptr, fp);
 504   png_set_IHDR (png_ptr, info_ptr,width, height,
 505                 8, PNG_COLOR_TYPE_RGB,
 506                 PNG_INTERLACE_NONE,
 507                 PNG_COMPRESSION_TYPE_DEFAULT,
 508                 PNG_FILTER_TYPE_DEFAULT);
 509
 510   text[0].key = "Software";
 511   text[0].text = "RRDtool, Tobias Oetiker <tobi@oetike.ch>, http://tobi.oetiker.ch";
 512   text[0].compression = PNG_TEXT_COMPRESSION_NONE;
 513   png_set_text (png_ptr, info_ptr, text, 1);
 514
 515   /* Write header data */
 516   png_write_info (png_ptr, info_ptr);
 517
 518   for (i = 0; i < height; i++)
 519     row_pointers[i] = (png_bytep) (buffer + i*rowstride);
 520
 521   png_write_image(png_ptr, row_pointers);
 522   png_write_end(png_ptr, info_ptr);
 523   png_destroy_write_struct(&png_ptr, &info_ptr);
 524   return 1;
 525 }
 526
 527
 528 /* ------- SVG -------
 529    SVG reference:
 530    http://www.w3.org/TR/SVG/
 531 */
 532 static int svg_indent = 0;
 533 static int svg_single_line = 0;
 534 static const char *svg_default_font = "Helvetica";
 535
 536 static void svg_print_indent(FILE *fp)
 537 {
 538   int i;
 539    for (i = svg_indent - svg_single_line; i > 0; i--) {
 540      putc(' ', fp);
 541      putc(' ', fp);
 542    }
 543 }
 544
 545 static void svg_start_tag(FILE *fp, const char *name)
 546 {
 547    svg_print_indent(fp);
 548    putc('<', fp);
 549    fputs(name, fp);
 550    svg_indent++;
 551 }
 552
 553 static void svg_close_tag_single_line(FILE *fp)
 554 {
 555    svg_single_line++;
 556    putc('>', fp);
 557 }
 558
 559 static void svg_close_tag(FILE *fp)
 560 {
 561    putc('>', fp);
 562    if (!svg_single_line)
 563      putc('\n', fp);
 564 }
 565
 566 static void svg_end_tag(FILE *fp, const char *name)
 567 {
 568    /* name is NULL if closing empty-node tag */
 569    svg_indent--;
 570    if (svg_single_line)
 571      svg_single_line--;
 572    else if (name)
 573      svg_print_indent(fp);
 574    if (name != NULL) {
 575      fputs("</", fp);
 576      fputs(name, fp);
 577    } else {
 578      putc('/', fp);
 579    }
 580    svg_close_tag(fp);
 581 }
 582
 583 static void svg_close_tag_empty_node(FILE *fp)
 584 {
 585    svg_end_tag(fp, NULL);
 586 }
 587
 588 static void svg_write_text(FILE *fp, const char *text)
 589 {
 590    const unsigned char *p, *start, *last;
 591    unsigned int ch;
 592    p = (const unsigned char*)text;
 593    if (!p)
 594      return;
 595    /* trim leading spaces */
 596    while (*p == ' ')
 597      p++;
 598    start = p;
 599    /* trim trailing spaces */
 600    last = p - 1;
 601    while ((ch = *p) != 0) {
 602      if (ch != ' ')
 603        last = p;
 604      p++;
 605   }
 606   /* encode trimmed text */
 607   p = start;
 608   while (p <= last) {
 609     ch = *p++;
 610     ch = afm_host2unicode(ch); /* unsafe macro */
 611     switch (ch) {
 612     case '&': fputs("&amp;", fp); break;
 613     case '<': fputs("&lt;", fp); break;
 614     case '>': fputs("&gt;", fp); break;
 615     case '"': fputs("&quot;", fp); break;
 616     default:
 617       if (ch >= 127)
 618         fprintf(fp, "&#%d;", ch);
 619       else
 620         putc(ch, fp);
 621      }
 622    }
 623 }
 624
 625 static void svg_write_number(FILE *fp, double d)
 626 {
 627    /* omit decimals if integer to reduce filesize */
 628    char buf[60], *p;
 629    snprintf(buf, sizeof(buf), "%.2f", d);
 630    p = buf; /* doesn't trust snprintf return value */
 631    while (*p)
 632      p++;
 633    while (--p > buf) {
 634      char ch = *p;
 635      if (ch == '0') {
 636        *p = '\0'; /* zap trailing zeros */
 637        continue;
 638      }
 639      if (ch == '.')
 640        *p = '\0'; /* zap trailing dot */
 641      break;
 642    }
 643    fputs(buf, fp);
 644 }
 645
 646 static int svg_color_is_black(int c)
 647 {
 648   /* gfx_color_t is RRGGBBAA */
 649   return c == 0x000000FF;
 650 }
 651
 652 static void svg_write_color(FILE *fp, gfx_color_t c, const char *attr)
 653 {
 654   /* gfx_color_t is RRGGBBAA, svg can use #RRGGBB and #RGB like html */
 655   gfx_color_t rrggbb = (int)((c >> 8) & 0xFFFFFF);
 656   gfx_color_t opacity = c & 0xFF;
 657   fprintf(fp, " %s=\"", attr);
 658   if ((rrggbb & 0x0F0F0F) == ((rrggbb >> 4) & 0x0F0F0F)) {
 659      /* css2 short form, #rgb is #rrggbb, not #r0g0b0 */
 660     fprintf(fp, "#%03lX",
 661           ( ((rrggbb >> 8) & 0xF00)
 662           | ((rrggbb >> 4) & 0x0F0)
 663           | ( rrggbb       & 0x00F)));
 664    } else {
 665     fprintf(fp, "#%06lX", rrggbb);
 666    }
 667   fputs("\"", fp);
 668   if (opacity != 0xFF) {
 669     fprintf(fp, " stroke-opacity=\"");
 670     svg_write_number(fp, opacity / 255.0);
 671     fputs("\"", fp);
 672  }
 673 }
 674
 675 static void svg_common_path_attributes(FILE *fp, gfx_node_t *node)
 676 {
 677   fputs(" stroke-width=\"", fp);
 678   svg_write_number(fp, node->size);
 679   fputs("\"", fp);
 680   svg_write_color(fp, node->color, "stroke");
 681   fputs(" fill=\"none\"", fp);
 682   if (node->dash_on > 0 && node->dash_off > 0) {
 683     fputs(" stroke-dasharray=\"", fp);
 684     svg_write_number(fp, node->dash_on);
 685     fputs(",", fp);
 686     svg_write_number(fp, node->dash_off);
 687     fputs("\"", fp);
 688   }
 689 }
 690
 691 static int svg_is_int_step(double a, double b)
 692 {
 693    double diff = fabs(a - b);
 694    return floor(diff) == diff;
 695 }
 696
 697 static int svg_path_straight_segment(FILE *fp,
 698      double lastA, double currentA, double currentB,
 699      gfx_node_t *node,
 700      int segment_idx, int isx, char absChar, char relChar)
 701 {
 702    if (!svg_is_int_step(lastA, currentA)) {
 703      putc(absChar, fp);
 704      svg_write_number(fp, currentA);
 705      return 0;
 706    }
 707    if (segment_idx < node->points - 1) {
 708      ArtVpath *vec = node->path + segment_idx + 1;
 709      if (vec->code == ART_LINETO) {
 710        double nextA = (isx ? vec->x : vec->y) - LINEOFFSET;
 711        double nextB = (isx ? vec->y : vec->x) - LINEOFFSET;
 712        if (nextB == currentB
 713            && ((currentA >= lastA) == (nextA >= currentA))
 714            && svg_is_int_step(currentA, nextA)) {
 715          return 1; /* skip to next as it is a straight line  */
 716        }
 717      }
 718    }
 719    putc(relChar, fp);
 720    svg_write_number(fp, currentA - lastA);
 721    return 0;
 722 }
 723
 724 static void svg_path(FILE *fp, gfx_node_t *node, int multi)
 725 {
 726    int i;
 727    double lastX = 0, lastY = 0;
 728    /* for straight lines <path..> tags take less space than
 729       <line..> tags because of the efficient packing
 730       in the 'd' attribute */
 731    svg_start_tag(fp, "path");
 732   if (!multi)
 733     svg_common_path_attributes(fp, node);
 734    fputs(" d=\"", fp);
 735    /* specification of the 'd' attribute: */
 736    /* http://www.w3.org/TR/SVG/paths.html#PathDataGeneralInformation */
 737    for (i = 0; i < node->points; i++) {
 738      ArtVpath *vec = node->path + i;
 739      double x = vec->x - LINEOFFSET;
 740      double y = vec->y - LINEOFFSET;
 741      switch (vec->code) {
 742      case ART_MOVETO_OPEN: /* fall-through */
 743      case ART_MOVETO:
 744        putc('M', fp);
 745        svg_write_number(fp, x);
 746        putc(',', fp);
 747        svg_write_number(fp, y);
 748        break;
 749      case ART_LINETO:
 750        /* try optimize filesize by using minimal lineto commands */
 751        /* without introducing rounding errors. */
 752        if (x == lastX) {
 753          if (svg_path_straight_segment(fp, lastY, y, x, node, i, 0, 'V', 'v'))
 754            continue;
 755        } else if (y == lastY) {
 756          if (svg_path_straight_segment(fp, lastX, x, y, node, i, 1, 'H', 'h'))
 757            continue;
 758        } else {
 759          putc('L', fp);
 760          svg_write_number(fp, x);
 761          putc(',', fp);
 762          svg_write_number(fp, y);
 763        }
 764        break;
 765      case ART_CURVETO: break; /* unsupported */
 766      case ART_END: break; /* nop */
 767      }
 768      lastX = x;
 769      lastY = y;
 770    }
 771   if (node->closed_path)
 772     fputs(" Z", fp);
 773    fputs("\"", fp);
 774    svg_close_tag_empty_node(fp);
 775 }
 776
 777 static void svg_multi_path(FILE *fp, gfx_node_t **nodeR)
 778 {
 779    /* optimize for multiple paths with the same color, penwidth, etc. */
 780    int num = 1;
 781    gfx_node_t *node = *nodeR;
 782    gfx_node_t *next = node->next;
 783    while (next) {
 784      if (next->type != node->type
 785          || next->size != node->size
 786         || next->color != node->color
 787         || next->dash_on != node->dash_on
 788         || next->dash_off != node->dash_off)
 789        break;
 790      next = next->next;
 791      num++;
 792    }
 793    if (num == 1) {
 794      svg_path(fp, node, 0);
 795      return;
 796    }
 797    svg_start_tag(fp, "g");
 798   svg_common_path_attributes(fp, node);
 799    svg_close_tag(fp);
 800    while (num && node) {
 801      svg_path(fp, node, 1);
 802      if (!--num)
 803        break;
 804      node = node->next;
 805      *nodeR = node;
 806    }
 807    svg_end_tag(fp, "g");
 808 }
 809
 810 static void svg_area(FILE *fp, gfx_node_t *node)
 811 {
 812    int i;
 813    double startX = 0, startY = 0;
 814    svg_start_tag(fp, "polygon");
 815   fputs(" ", fp);
 816   svg_write_color(fp, node->color, "fill");
 817   fputs(" points=\"", fp);
 818    for (i = 0; i < node->points; i++) {
 819      ArtVpath *vec = node->path + i;
 820      double x = vec->x - LINEOFFSET;
 821      double y = vec->y - LINEOFFSET;
 822      switch (vec->code) {
 823        case ART_MOVETO_OPEN: /* fall-through */
 824        case ART_MOVETO:
 825          svg_write_number(fp, x);
 826          putc(',', fp);
 827          svg_write_number(fp, y);
 828          startX = x;
 829          startY = y;
 830          break;
 831        case ART_LINETO:
 832          if (i == node->points - 2
 833                         && node->path[i + 1].code == ART_END
 834              && fabs(x - startX) < 0.001 && fabs(y - startY) < 0.001) {
 835            break; /* poly area always closed, no need for last point */
 836          }
 837          putc(' ', fp);
 838          svg_write_number(fp, x);
 839          putc(',', fp);
 840          svg_write_number(fp, y);
 841          break;
 842        case ART_CURVETO: break; /* unsupported */
 843        case ART_END: break; /* nop */
 844      }
 845    }
 846    fputs("\"", fp);
 847    svg_close_tag_empty_node(fp);
 848 }
 849
 850 static void svg_text(FILE *fp, gfx_node_t *node)
 851 {
 852    double x = node->x - LINEOFFSET;
 853    double y = node->y - LINEOFFSET;
 854    if (node->angle != 0) {
 855      svg_start_tag(fp, "g");
 856      fputs(" transform=\"translate(", fp);
 857      svg_write_number(fp, x);
 858      fputs(",", fp);
 859      svg_write_number(fp, y);
 860      fputs(") rotate(", fp);
 861      svg_write_number(fp, node->angle);
 862      fputs(")\"", fp);
 863      x = y = 0;
 864      svg_close_tag(fp);
 865    }
 866    switch (node->valign) {
 867    case GFX_V_TOP:  y += node->size; break;
 868    case GFX_V_CENTER: y += node->size / 2; break;
 869    case GFX_V_BOTTOM: break;
 870    case GFX_V_NULL: break;
 871    }
 872    svg_start_tag(fp, "text");
 873    fputs(" x=\"", fp);
 874    svg_write_number(fp, x);
 875    fputs("\" y=\"", fp);
 876    svg_write_number(fp, y);
 877   if (strcmp(node->filename, svg_default_font))
 878     fprintf(fp, " font-family=\"%s\"", node->filename);
 879    fputs("\" font-size=\"", fp);
 880    svg_write_number(fp, node->size);
 881    fputs("\"", fp);
 882   if (!svg_color_is_black(node->color))
 883     svg_write_color(fp, node->color, "fill");
 884    switch (node->halign) {
 885    case GFX_H_RIGHT:  fputs(" text-anchor=\"end\"", fp); break;
 886    case GFX_H_CENTER: fputs(" text-anchor=\"middle\"", fp); break;
 887    case GFX_H_LEFT: break;
 888    case GFX_H_NULL: break;
 889    }
 890    svg_close_tag_single_line(fp);
 891    /* support for node->tabwidth missing */
 892    svg_write_text(fp, node->text);
 893    svg_end_tag(fp, "text");
 894    if (node->angle != 0)
 895      svg_end_tag(fp, "g");
 896 }
 897
 898 int       gfx_render_svg (gfx_canvas_t *canvas,
 899                  art_u32 width, art_u32 height,
 900                  gfx_color_t background, FILE *fp){
 901    gfx_node_t *node = canvas->firstnode;
 902    fputs(
 903 "<?xml version=\"1.0\" standalone=\"no\"?>\n"
 904 "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\"\n"
 905 "   \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n"
 906 "<!--\n"
 907 "   SVG file created by RRDtool,\n"
 908 "   Tobias Oetiker <tobi@oetike.ch>, http://tobi.oetiker.ch\n"
 909 "\n"
 910 "   The width/height attributes in the outhermost svg node\n"
 911 "   are just default sizes for the browser which is used\n"
 912 "   if the svg file is openened directly without being\n"
 913 "   embedded in an html file.\n"
 914 "   The viewBox is the local coord system for rrdtool.\n"
 915 "-->\n", fp);
 916    svg_start_tag(fp, "svg");
 917    fputs(" width=\"", fp);
 918   svg_write_number(fp, width * canvas->zoom);
 919    fputs("\" height=\"", fp);
 920   svg_write_number(fp, height * canvas->zoom);
 921    fputs("\" x=\"0\" y=\"0\" viewBox=\"", fp);
 922    svg_write_number(fp, -LINEOFFSET);
 923    fputs(" ", fp);
 924    svg_write_number(fp, -LINEOFFSET);
 925    fputs(" ", fp);
 926    svg_write_number(fp, width - LINEOFFSET);
 927    fputs(" ", fp);
 928    svg_write_number(fp, height - LINEOFFSET);
 929    fputs("\" preserveAspectRatio=\"xMidYMid\"", fp);
 930   fprintf(fp, " font-family=\"%s\"", svg_default_font); /* default font */
 931   fputs(" stroke-linecap=\"round\" stroke-linejoin=\"round\"", fp);
 932    svg_close_tag(fp);
 933    svg_start_tag(fp, "rect");
 934    fprintf(fp, " x=\"0\" y=\"0\" width=\"%d\" height=\"%d\"", width, height);
 935   svg_write_color(fp, background, "fill");
 936    svg_close_tag_empty_node(fp);
 937    while (node) {
 938      switch (node->type) {
 939      case GFX_LINE:
 940        svg_multi_path(fp, &node);
 941        break;
 942      case GFX_AREA:
 943        svg_area(fp, node);
 944        break;
 945      case GFX_TEXT:
 946        svg_text(fp, node);
 947      }
 948      node = node->next;
 949    }
 950    svg_end_tag(fp, "svg");
 951    return 0;
 952 }
 953
 954 /* ------- EPS -------
 955    EPS and Postscript references:
 956    http://partners.adobe.com/asn/developer/technotes/postscript.html
 957 */
 958
 959 typedef struct eps_font
 960 {
 961   const char *ps_font;
 962   int id;
 963   struct eps_font *next;
 964 } eps_font;
 965
 966 typedef struct eps_state
 967 {
 968   FILE *fp;
 969   gfx_canvas_t *canvas;
 970   art_u32 page_width, page_height;
 971   eps_font *font_list;
 972   /*--*/
 973   gfx_color_t color;
 974   const char *font;
 975   double font_size;
 976   double line_width;
 977   int linecap, linejoin;
 978 } eps_state;
 979
 980 static void eps_set_color(eps_state *state, gfx_color_t color)
 981 {
 982    /* gfx_color_t is RRGGBBAA */
 983   if (state->color == color)
 984     return;
 985   fprintf(state->fp, "%d %d %d Rgb\n",
 986       (int)((color >> 24) & 255),
 987       (int)((color >> 16) & 255),
 988       (int)((color >>  8) & 255));
 989   state->color = color;
 990 }
 991
 992 static int eps_add_font(eps_state *state, gfx_node_t *node)
 993 {
 994   /* The fonts list could be postponed to the end using
 995      (atend), but let's be nice and have them in the header. */
 996   const char *ps_font = afm_get_font_postscript_name(node->filename);
 997   eps_font *ef;
 998   for (ef = state->font_list; ef; ef = ef->next) {
 999     if (!strcmp(ps_font, ef->ps_font))
1000       return 0;
1001   }
1002   ef = malloc(sizeof(eps_font));
1003   if (ef == NULL) {
1004     rrd_set_error("malloc for eps_font");
1005     return -1;
1006   }
1007   ef->next = state->font_list;
1008   ef->ps_font = ps_font;
1009   state->font_list = ef;
1010   return 0;
1011 }
1012
1013 static void eps_list_fonts(eps_state *state, const char *dscName)
1014 {
1015   eps_font *ef;
1016   int lineLen = strlen(dscName);
1017   if (!state->font_list)
1018     return;
1019   fputs(dscName, state->fp);
1020   for (ef = state->font_list; ef; ef = ef->next) {
1021     int nameLen = strlen(ef->ps_font);
1022     if (lineLen + nameLen > 100 && lineLen) {
1023       fputs("\n", state->fp);
1024       fputs("%%- \n", state->fp);
1025       lineLen = 5;
1026     } else {
1027       fputs(" ", state->fp);
1028       lineLen++;
1029     }
1030     fputs(ef->ps_font, state->fp);
1031     lineLen += nameLen;
1032   }
1033   fputs("\n", state->fp);
1034 }
1035
1036 static void eps_define_fonts(eps_state *state)
1037 {
1038   eps_font *ef;
1039   if (!state->font_list)
1040     return;
1041   for (ef = state->font_list; ef; ef = ef->next) {
1042     /* PostScript¨ LANGUAGE REFERENCE third edition
1043        page 349 */
1044     fprintf(state->fp,
1045         "%%\n"
1046         "/%s findfont dup length dict begin\n"
1047         "{ 1 index /FID ne {def} {pop pop} ifelse } forall\n"
1048         "/Encoding ISOLatin1Encoding def\n"
1049         "currentdict end\n"
1050         "/%s-ISOLatin1 exch definefont pop\n"
1051         "/SetFont-%s { /%s-ISOLatin1 findfont exch scalefont setfont } bd\n",
1052         ef->ps_font, ef->ps_font, ef->ps_font, ef->ps_font);
1053   }
1054 }
1055
1056 static int eps_prologue(eps_state *state)
1057 {
1058   gfx_node_t *node;
1059   fputs(
1060     "%!PS-Adobe-3.0 EPSF-3.0\n"
1061     "%%Creator: RRDtool 1.1.x, Tobias Oetiker, http://tobi.oetiker.ch\n"
1062     /* can't like weird chars here */
1063     "%%Title: (RRDTool output)\n"
1064     "%%DocumentData: Clean7Bit\n"
1065     "", state->fp);
1066   fprintf(state->fp, "%%%%BoundingBox: 0 0 %d %d\n",
1067     state->page_width, state->page_height);
1068   for (node = state->canvas->firstnode; node; node = node->next) {
1069     if (node->type == GFX_TEXT && eps_add_font(state, node) == -1)
1070       return -1;
1071   }
1072   eps_list_fonts(state, "%%DocumentFonts:");
1073   eps_list_fonts(state, "%%DocumentNeededFonts:");
1074   fputs(
1075       "%%EndComments\n"
1076       "%%BeginProlog\n"
1077       "%%EndProlog\n" /* must have, or BoundingBox is ignored */
1078       "/bd { bind def } bind def\n"
1079       "", state->fp);
1080   fprintf(state->fp, "/X { %.2f add } bd\n", LINEOFFSET);
1081   fputs(
1082       "/X2 {X exch X exch} bd\n"
1083       "/M {X2 moveto} bd\n"
1084       "/L {X2 lineto} bd\n"
1085       "/m {moveto} bd\n"
1086       "/l {lineto} bd\n"
1087       "/S {stroke} bd\n"
1088       "/CP {closepath} bd\n"
1089       "/WS {setlinewidth stroke} bd\n"
1090       "/F {fill} bd\n"
1091       "/TaL { } bd\n"
1092       "/TaC {dup stringwidth pop neg 2 div 0 rmoveto } bd\n"
1093       "/TaR {dup stringwidth pop neg 0 rmoveto } bd\n"
1094       "/TL {moveto TaL show} bd\n"
1095       "/TC {moveto TaC show} bd\n"
1096       "/TR {moveto TaR show} bd\n"
1097       "/Rgb { 255.0 div 3 1 roll\n"
1098       "       255.0 div 3 1 roll \n"
1099       "       255.0 div 3 1 roll setrgbcolor } bd\n"
1100       "", state->fp);
1101   eps_define_fonts(state);
1102   return 0;
1103 }
1104
1105 static void eps_write_linearea(eps_state *state, gfx_node_t *node)
1106 {
1107   int i;
1108   FILE *fp = state->fp;
1109   int useOffset = 0;
1110   eps_set_color(state, node->color);
1111   if (node->type == GFX_LINE) {
1112     if (state->linecap != 1) {
1113       fputs("1 setlinecap\n", fp);
1114       state->linecap = 1;
1115     }
1116     if (state->linejoin != 1) {
1117       fputs("1 setlinejoin\n", fp);
1118       state->linejoin = 1;
1119     }
1120   }
1121   for (i = 0; i < node->points; i++) {
1122     ArtVpath *vec = node->path + i;
1123     double x = vec->x;
1124     double y = state->page_height - vec->y;
1125     if (vec->code == ART_MOVETO_OPEN || vec->code == ART_MOVETO)
1126       useOffset = (fabs(x - floor(x) - 0.5) < 0.01 && fabs(y - floor(y) - 0.5) < 0.01);
1127     if (useOffset) {
1128       x -= LINEOFFSET;
1129       y -= LINEOFFSET;
1130     }
1131     switch (vec->code) {
1132     case ART_MOVETO_OPEN: /* fall-through */
1133     case ART_MOVETO:
1134       svg_write_number(fp, x);
1135       fputc(' ', fp);
1136       svg_write_number(fp, y);
1137       fputc(' ', fp);
1138       fputs(useOffset ? "M\n" : "m\n", fp);
1139       break;
1140     case ART_LINETO:
1141       svg_write_number(fp, x);
1142       fputc(' ', fp);
1143       svg_write_number(fp, y);
1144       fputc(' ', fp);
1145       fputs(useOffset ? "L\n" : "l\n", fp);
1146       break;
1147     case ART_CURVETO: break; /* unsupported */
1148     case ART_END: break; /* nop */
1149     }
1150   }
1151   if (node->type == GFX_LINE) {
1152     if (node->closed_path)
1153       fputs("CP ", fp);
1154     if (node->size != state->line_width) {
1155       state->line_width = node->size;
1156       svg_write_number(fp, state->line_width);
1157       fputs(" WS\n", fp);
1158     } else {
1159       fputs("S\n", fp);
1160     }
1161    } else {
1162     fputs("F\n", fp);
1163    }
1164 }
1165
1166 static void eps_write_text(eps_state *state, gfx_node_t *node)
1167 {
1168   FILE *fp = state->fp;
1169   const unsigned char *p;
1170   const char *ps_font = afm_get_font_postscript_name(node->filename);
1171   char align = 'L';
1172   double x = node->x;
1173   double y = state->page_height - node->y, ydelta = 0;
1174   int lineLen = 0;
1175   eps_set_color(state, node->color);
1176   if (strcmp(ps_font, state->font) || node->size != state->font_size) {
1177     state->font = ps_font;
1178     state->font_size = node->size;
1179     svg_write_number(fp, state->font_size);
1180     fprintf(fp, " SetFont-%s\n", state->font);
1181   }
1182   fputs("(", fp);
1183   lineLen = 20;
1184   for (p = (const unsigned char*)node->text; *p; p++) {
1185     if (lineLen > 70) {
1186       fputs("\\\n", fp); /* backslash and \n */
1187       lineLen = 0;
1188     }
1189     switch (*p) {
1190       case '(':
1191       case ')':
1192       case '\\':
1193       case '\n':
1194       case '\r':
1195       case '\t':
1196         fputc('\\', fp);
1197         lineLen++;
1198         /* fall-through */
1199       default:
1200         if (*p >= 126)
1201           fprintf(fp, "\\%03o", *p);
1202         else
1203           fputc(*p, fp);
1204         lineLen++;
1205     }
1206   }
1207   fputs(") ", fp);
1208   switch(node->valign){
1209   case GFX_V_TOP:    ydelta = -node->size; break;
1210   case GFX_V_CENTER: ydelta = -node->size / 3.0; break;
1211   case GFX_V_BOTTOM: break;
1212   case GFX_V_NULL: break;
1213   }
1214   if (node->angle == 0)
1215     y += ydelta;
1216   switch (node->halign) {
1217   case GFX_H_RIGHT:  align = 'R'; break;
1218   case GFX_H_CENTER: align = 'C'; break;
1219   case GFX_H_LEFT: align= 'L'; break;
1220   case GFX_H_NULL: align= 'L'; break;
1221   }
1222   if (node->angle != 0) {
1223     fputs("\n", fp);
1224     fputs("  gsave ", fp);
1225     svg_write_number(fp, x);
1226     fputc(' ', fp);
1227     svg_write_number(fp, y);
1228     fputs(" translate ", fp);
1229     svg_write_number(fp, -node->angle);
1230     fputs(" rotate 0 ", fp);
1231     svg_write_number(fp, ydelta);
1232     fputs(" moveto ", fp);
1233     fprintf(fp, "Ta%c", align);
1234     fputs(" show grestore\n", fp);
1235   } else {
1236     svg_write_number(fp, x);
1237     fputc(' ', fp);
1238     svg_write_number(fp, y);
1239     fputs(" T", fp);
1240     fputc(align, fp);
1241     fputc('\n', fp);
1242   }
1243 }
1244
1245 static int eps_write_content(eps_state *state)
1246 {
1247   gfx_node_t *node;
1248   fputs("%\n", state->fp);
1249   for (node = state->canvas->firstnode; node; node = node->next) {
1250     switch (node->type) {
1251     case GFX_LINE:
1252     case GFX_AREA:
1253       eps_write_linearea(state, node);
1254       break;
1255     case GFX_TEXT:
1256       eps_write_text(state, node);
1257       break;
1258     }
1259   }
1260   return 0;
1261 }
1262
1263 int       gfx_render_eps (gfx_canvas_t *canvas,
1264                  art_u32 width, art_u32 height,
1265                  gfx_color_t background, FILE *fp){
1266   struct eps_state state;
1267   state.fp = fp;
1268   state.canvas = canvas;
1269   state.page_width = width;
1270   state.page_height = height;
1271   state.font = "no-default-font";
1272   state.font_size = -1;
1273   state.color = 0; /* black */
1274   state.font_list = NULL;
1275   state.linecap = -1;
1276   state.linejoin = -1;
1277   if (eps_prologue(&state) == -1)
1278     return -1;
1279   eps_set_color(&state, background);
1280   fprintf(fp, "0 0 M 0 %d L %d %d L %d 0 L fill\n",
1281       height, width, height, width);
1282   if (eps_write_content(&state) == -1)
1283     return 0;
1284   fputs("showpage\n", fp);
1285   fputs("%%EOF\n", fp);
1286   while (state.font_list) {
1287     eps_font *next = state.font_list->next;
1288     free(state.font_list);
1289     state.font_list = next;
1290   }
1291   return 0;
1292 }