app/render_gnomeprint.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1998, 1999 Alexander Larsson
   3  *
   4  * render_gnomeprint.[ch] -- gnome-print renderer for dia
   5  * Copyright (C) 1999 James Henstridge
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <string.h>
  23 #include <time.h>
  24 #include <math.h>
  25 #include <unistd.h>
  26
  27 #include "config.h"
  28 #include "intl.h"
  29 #include "render_gnomeprint.h"
  30 #include "message.h"
  31 #include "diagramdata.h"
  32
  33 static void begin_render(RendererGPrint *renderer, DiagramData *data);
  34 static void end_render(RendererGPrint *renderer);
  35 static void set_linewidth(RendererGPrint *renderer, real linewidth);
  36 static void set_linecaps(RendererGPrint *renderer, LineCaps mode);
  37 static void set_linejoin(RendererGPrint *renderer, LineJoin mode);
  38 static void set_linestyle(RendererGPrint *renderer, LineStyle mode);
  39 static void set_dashlength(RendererGPrint *renderer, real length);
  40 static void set_fillstyle(RendererGPrint *renderer, FillStyle mode);
  41 static void set_font(RendererGPrint *renderer, Font *font, real height);
  42 static void draw_line(RendererGPrint *renderer,
  43                       Point *start, Point *end,
  44                       Color *line_color);
  45 static void draw_polyline(RendererGPrint *renderer,
  46                           Point *points, int num_points,
  47                           Color *line_color);
  48 static void draw_polygon(RendererGPrint *renderer,
  49                          Point *points, int num_points,
  50                          Color *line_color);
  51 static void fill_polygon(RendererGPrint *renderer,
  52                          Point *points, int num_points,
  53                          Color *line_color);
  54 static void draw_rect(RendererGPrint *renderer,
  55                       Point *ul_corner, Point *lr_corner,
  56                       Color *color);
  57 static void fill_rect(RendererGPrint *renderer,
  58                       Point *ul_corner, Point *lr_corner,
  59                       Color *color);
  60 static void draw_arc(RendererGPrint *renderer,
  61                      Point *center,
  62                      real width, real height,
  63                      real angle1, real angle2,
  64                      Color *color);
  65 static void fill_arc(RendererGPrint *renderer,
  66                      Point *center,
  67                      real width, real height,
  68                      real angle1, real angle2,
  69                      Color *color);
  70 static void draw_ellipse(RendererGPrint *renderer,
  71                          Point *center,
  72                          real width, real height,
  73                          Color *color);
  74 static void fill_ellipse(RendererGPrint *renderer,
  75                          Point *center,
  76                          real width, real height,
  77                          Color *color);
  78 static void draw_bezier(RendererGPrint *renderer,
  79                         BezPoint *points,
  80                         int numpoints,
  81                         Color *color);
  82 static void fill_bezier(RendererGPrint *renderer,
  83                         BezPoint *points, /* Last point must be same as first point */
  84                         int numpoints,
  85                         Color *color);
  86 static void draw_string(RendererGPrint *renderer,
  87                         const char *text,
  88                         Point *pos, Alignment alignment,
  89                         Color *color);
  90 static void draw_image(RendererGPrint *renderer,
  91                        Point *point,
  92                        real width, real height,
  93                        DiaImage image);
  94
  95 static RenderOps GPrintRenderOps = {
  96   (BeginRenderFunc) begin_render,
  97   (EndRenderFunc) end_render,
  98
  99   (SetLineWidthFunc) set_linewidth,
 100   (SetLineCapsFunc) set_linecaps,
 101   (SetLineJoinFunc) set_linejoin,
 102   (SetLineStyleFunc) set_linestyle,
 103   (SetDashLengthFunc) set_dashlength,
 104   (SetFillStyleFunc) set_fillstyle,
 105   (SetFontFunc) set_font,
 106
 107   (DrawLineFunc) draw_line,
 108   (DrawPolyLineFunc) draw_polyline,
 109
 110   (DrawPolygonFunc) draw_polygon,
 111   (FillPolygonFunc) fill_polygon,
 112
 113   (DrawRectangleFunc) draw_rect,
 114   (FillRectangleFunc) fill_rect,
 115
 116   (DrawArcFunc) draw_arc,
 117   (FillArcFunc) fill_arc,
 118
 119   (DrawEllipseFunc) draw_ellipse,
 120   (FillEllipseFunc) fill_ellipse,
 121
 122   (DrawBezierFunc) draw_bezier,
 123   (FillBezierFunc) fill_bezier,
 124
 125   (DrawStringFunc) draw_string,
 126
 127   (DrawImageFunc) draw_image,
 128 };
 129
 130 RendererGPrint *
 131 new_gnomeprint_renderer(Diagram *dia, GnomePrintContext *ctx)
 132 {
 133   RendererGPrint *renderer;
 134
 135   renderer = g_new(RendererGPrint, 1);
 136   renderer->renderer.ops = &GPrintRenderOps;
 137   renderer->renderer.is_interactive = 0;
 138   renderer->renderer.interactive_ops = NULL;
 139
 140   renderer->ctx = ctx;
 141   renderer->font = NULL;
 142
 143   renderer->dash_length = 1.0;
 144   renderer->dot_length = 0.2;
 145   renderer->saved_line_style = LINESTYLE_SOLID;
 146
 147   return renderer;
 148 }
 149
 150 static void
 151 begin_render(RendererGPrint *renderer, DiagramData *data)
 152 {
 153   /*gnome_print_gsave(renderer->ctx);
 154     gnome_print_scale(renderer->ctx, 28.346, -28.346);
 155     gnome_print_translate(renderer->ctx, -left, -bottom);*/
 156 }
 157
 158 static void
 159 end_render(RendererGPrint *renderer)
 160 {
 161   if (renderer->font)
 162     gtk_object_unref(GTK_OBJECT(renderer->font));
 163   renderer->font = NULL;
 164   /*gnome_print_showpage(renderer->ctx);
 165     gnome_print_grestore(renderer->ctx);*/
 166 }
 167
 168 static void
 169 set_linewidth(RendererGPrint *renderer, real linewidth)
 170 {  /* 0 == hairline **/
 171   gnome_print_setlinewidth(renderer->ctx, linewidth);
 172 }
 173
 174 static void
 175 set_linecaps(RendererGPrint *renderer, LineCaps mode)
 176 {
 177   int ps_mode;
 178
 179   switch(mode) {
 180   case LINECAPS_BUTT:
 181     ps_mode = 0;
 182     break;
 183   case LINECAPS_ROUND:
 184     ps_mode = 1;
 185     break;
 186   case LINECAPS_PROJECTING:
 187     ps_mode = 2;
 188     break;
 189   default:
 190     ps_mode = 0;
 191   }
 192
 193   gnome_print_setlinecap(renderer->ctx, ps_mode);
 194 }
 195
 196 static void
 197 set_linejoin(RendererGPrint *renderer, LineJoin mode)
 198 {
 199   int ps_mode;
 200
 201   switch(mode) {
 202   case LINEJOIN_MITER:
 203     ps_mode = 0;
 204     break;
 205   case LINEJOIN_ROUND:
 206     ps_mode = 1;
 207     break;
 208   case LINEJOIN_BEVEL:
 209     ps_mode = 2;
 210     break;
 211   default:
 212     ps_mode = 0;
 213   }
 214
 215   gnome_print_setlinejoin(renderer->ctx, ps_mode);
 216 }
 217
 218 static void
 219 set_linestyle(RendererGPrint *renderer, LineStyle mode)
 220 {
 221   real hole_width;
 222   double dashes[6];
 223
 224   renderer->saved_line_style = mode;
 225
 226   switch(mode) {
 227   case LINESTYLE_SOLID:
 228     gnome_print_setdash(renderer->ctx, 0, dashes, 0);
 229     break;
 230   case LINESTYLE_DASHED:
 231     dashes[0] = renderer->dash_length;
 232     gnome_print_setdash(renderer->ctx, 1, dashes, 0);
 233     break;
 234   case LINESTYLE_DASH_DOT:
 235     hole_width = (renderer->dash_length - renderer->dot_length) / 2.0;
 236     dashes[0] = renderer->dash_length;
 237     dashes[1] = hole_width;
 238     dashes[2] = renderer->dot_length;
 239     dashes[3] = hole_width;
 240     gnome_print_setdash(renderer->ctx, 4, dashes, 0);
 241     break;
 242   case LINESTYLE_DASH_DOT_DOT:
 243     hole_width = (renderer->dash_length - 2.0*renderer->dot_length) / 3.0;
 244     dashes[0] = renderer->dash_length;
 245     dashes[1] = hole_width;
 246     dashes[2] = renderer->dot_length;
 247     dashes[3] = hole_width;
 248     dashes[4] = renderer->dot_length;
 249     dashes[5] = hole_width;
 250     gnome_print_setdash(renderer->ctx, 6, dashes, 0);
 251     break;
 252   case LINESTYLE_DOTTED:
 253     dashes[0] = renderer->dot_length;
 254     gnome_print_setdash(renderer->ctx, 1, dashes, 0);
 255     break;
 256   }
 257 }
 258
 259 static void
 260 set_dashlength(RendererGPrint *renderer, real length)
 261 {  /* dot = 20% of len */
 262   if (length<0.001)
 263     length = 0.001;
 264
 265   renderer->dash_length = length;
 266   renderer->dot_length = length*0.2;
 267
 268   set_linestyle(renderer, renderer->saved_line_style);
 269 }
 270
 271 static void
 272 set_fillstyle(RendererGPrint *renderer, FillStyle mode)
 273 {
 274   switch(mode) {
 275   case FILLSTYLE_SOLID:
 276     break;
 277   default:
 278     message_error("eps_renderer: Unsupported fill mode specified!\n");
 279   }
 280 }
 281
 282 static void
 283 set_font(RendererGPrint *renderer, Font *font, real height)
 284 {
 285   GnomeFont *gfont;
 286
 287   if (renderer->font)
 288     gtk_object_unref(GTK_OBJECT(renderer->font));
 289   gfont = gnome_font_new(font_get_psfontname(font), height);
 290   if (!gfont)
 291     gfont = gnome_font_new("Courier", height);
 292   gnome_print_setfont(renderer->ctx, gfont);
 293   renderer->font = gfont;
 294 }
 295
 296 static void
 297 draw_line(RendererGPrint *renderer,
 298           Point *start, Point *end,
 299           Color *line_color)
 300 {
 301   gnome_print_setrgbcolor(renderer->ctx,
 302                           (double) line_color->red,
 303                           (double) line_color->green,
 304                           (double) line_color->blue);
 305
 306   gnome_print_newpath(renderer->ctx);
 307   gnome_print_moveto(renderer->ctx, start->x, start->y);
 308   gnome_print_lineto(renderer->ctx, end->x, end->y);
 309   gnome_print_stroke(renderer->ctx);
 310 }
 311
 312 static void
 313 draw_polyline(RendererGPrint *renderer,
 314               Point *points, int num_points,
 315               Color *line_color)
 316 {
 317   int i;
 318
 319   gnome_print_setrgbcolor(renderer->ctx,
 320                           (double) line_color->red,
 321                           (double) line_color->green,
 322                           (double) line_color->blue);
 323
 324   gnome_print_newpath(renderer->ctx);
 325   gnome_print_moveto(renderer->ctx, points[0].x, points[0].y);
 326
 327   for (i=1;i<num_points;i++) {
 328     gnome_print_lineto(renderer->ctx, points[i].x, points[i].y);
 329   }
 330
 331   gnome_print_stroke(renderer->ctx);
 332 }
 333
 334 static void
 335 draw_polygon(RendererGPrint *renderer,
 336               Point *points, int num_points,
 337               Color *line_color)
 338 {
 339   int i;
 340
 341   gnome_print_setrgbcolor(renderer->ctx,
 342                           (double) line_color->red,
 343                           (double) line_color->green,
 344                           (double) line_color->blue);
 345
 346   gnome_print_newpath(renderer->ctx);
 347   gnome_print_moveto(renderer->ctx, points[0].x, points[0].y);
 348
 349   for (i=1;i<num_points;i++) {
 350     gnome_print_lineto(renderer->ctx, points[i].x, points[i].y);
 351   }
 352
 353   gnome_print_closepath(renderer->ctx);
 354   gnome_print_stroke(renderer->ctx);
 355 }
 356
 357 static void
 358 fill_polygon(RendererGPrint *renderer,
 359               Point *points, int num_points,
 360               Color *line_color)
 361 {
 362   int i;
 363
 364   gnome_print_setrgbcolor(renderer->ctx,
 365                           (double) line_color->red,
 366                           (double) line_color->green,
 367                           (double) line_color->blue);
 368
 369   gnome_print_newpath(renderer->ctx);
 370   gnome_print_moveto(renderer->ctx, points[0].x, points[0].y);
 371
 372   for (i=1;i<num_points;i++) {
 373     gnome_print_lineto(renderer->ctx, points[i].x, points[i].y);
 374   }
 375
 376   gnome_print_fill(renderer->ctx);
 377 }
 378
 379 static void
 380 draw_rect(RendererGPrint *renderer,
 381           Point *ul_corner, Point *lr_corner,
 382           Color *color)
 383 {
 384   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 385                           (double)color->green, (double)color->blue);
 386
 387   gnome_print_newpath(renderer->ctx);
 388   gnome_print_moveto(renderer->ctx, ul_corner->x, ul_corner->y);
 389   gnome_print_lineto(renderer->ctx, ul_corner->x, lr_corner->y);
 390   gnome_print_lineto(renderer->ctx, lr_corner->x, lr_corner->y);
 391   gnome_print_lineto(renderer->ctx, lr_corner->x, ul_corner->y);
 392   gnome_print_closepath(renderer->ctx);
 393   gnome_print_stroke(renderer->ctx);
 394 }
 395
 396 static void
 397 fill_rect(RendererGPrint *renderer,
 398           Point *ul_corner, Point *lr_corner,
 399           Color *color)
 400 {
 401   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 402                           (double)color->green, (double)color->blue);
 403
 404   gnome_print_newpath(renderer->ctx);
 405   gnome_print_moveto(renderer->ctx, ul_corner->x, ul_corner->y);
 406   gnome_print_lineto(renderer->ctx, ul_corner->x, lr_corner->y);
 407   gnome_print_lineto(renderer->ctx, lr_corner->x, lr_corner->y);
 408   gnome_print_lineto(renderer->ctx, lr_corner->x, ul_corner->y);
 409   gnome_print_fill(renderer->ctx);
 410 }
 411
 412 #define SEG_ANGLE M_PI_4
 413
 414 static void
 415 draw_arc(RendererGPrint *renderer,
 416          Point *center,
 417          real width, real height,
 418          real angle1, real angle2,
 419          Color *color)
 420 {
 421   real arcangle;
 422   int nsegs, i;
 423   real theta, theta_2, sin_theta_2, cos_theta_2, x1, y1, rangle1, rangle2;
 424   real w_2 = width/2, h_2 = height/2;
 425
 426   if (angle2 < angle1) angle2 += 360;
 427   rangle1 = (360 - angle2) * M_PI / 180.0;
 428   rangle2 = (360 - angle1) * M_PI / 180.0;
 429   arcangle = rangle2 - rangle1;
 430   nsegs = (int)ceil(arcangle / SEG_ANGLE); /* how many bezier segments? */
 431   theta = arcangle / nsegs;
 432   theta_2 = theta / 2;
 433   sin_theta_2 = sin(theta_2);
 434   cos_theta_2 = cos(theta_2);
 435   x1 = (4 - cos_theta_2)/3;   /* coordinates of control point */
 436   y1 = (1 - cos_theta_2)*(cos_theta_2 - 3)/(3*sin_theta_2);
 437
 438   gnome_print_newpath(renderer->ctx);
 439   gnome_print_moveto(renderer->ctx, center->x + w_2 * cos(rangle1),
 440                      center->y + h_2 * sin(rangle1));
 441   for (i = 0; i < nsegs; i++) {
 442     real phi = arcangle * i / nsegs + theta_2 + rangle1;
 443     real sin_phi = sin(phi), cos_phi = cos(phi);
 444
 445     gnome_print_curveto(renderer->ctx,
 446                 w_2*(cos_phi*x1 - sin_phi*y1) + center->x,
 447                 h_2*(sin_phi*x1 + cos_phi*y1) + center->y,
 448                 w_2*(cos_phi*x1 + sin_phi*y1) + center->x,
 449                 h_2*(sin_phi*x1 - cos_phi*y1) + center->y,
 450                 w_2*(cos_phi*cos_theta_2 - sin_phi*sin_theta_2) + center->x,
 451                 h_2*(sin_phi*cos_theta_2 + cos_phi*sin_theta_2) + center->y);
 452   }
 453   gnome_print_stroke(renderer->ctx);
 454 }
 455
 456 static void
 457 fill_arc(RendererGPrint *renderer,
 458          Point *center,
 459          real width, real height,
 460          real angle1, real angle2,
 461          Color *color)
 462 {
 463   real arcangle;
 464   int nsegs, i;
 465   real theta, theta_2, sin_theta_2, cos_theta_2, x1, y1, rangle1, rangle2;
 466   real w_2 = width/2, h_2 = height/2;
 467
 468   if (angle2 < angle1) angle2 += 360;
 469   rangle1 = (360 - angle2) * M_PI / 180.0;
 470   rangle2 = (360 - angle1) * M_PI / 180.0;
 471   arcangle = rangle2 - rangle1;
 472   nsegs = (int)ceil(arcangle / SEG_ANGLE); /* how many bezier segments? */
 473   theta = arcangle / nsegs;
 474   theta_2 = theta / 2;
 475   sin_theta_2 = sin(theta_2);
 476   cos_theta_2 = cos(theta_2);
 477   x1 = (4 - cos_theta_2)/3;   /* coordinates of control point */
 478   y1 = (1 - cos_theta_2)*(cos_theta_2 - 3)/(3*sin_theta_2);
 479
 480   gnome_print_newpath(renderer->ctx);
 481   gnome_print_moveto(renderer->ctx, center->x, center->y);
 482   gnome_print_lineto(renderer->ctx, center->x + w_2 * cos(rangle1),
 483                      center->y + h_2 * sin(rangle1));
 484   for (i = 0; i < nsegs; i++) {
 485     real phi = arcangle * i / nsegs + theta_2 + rangle1;
 486     real sin_phi = sin(phi), cos_phi = cos(phi);
 487
 488     gnome_print_curveto(renderer->ctx,
 489                 w_2*(cos_phi*x1 - sin_phi*y1) + center->x,
 490                 h_2*(sin_phi*x1 + cos_phi*y1) + center->y,
 491                 w_2*(cos_phi*x1 + sin_phi*y1) + center->x,
 492                 h_2*(sin_phi*x1 - cos_phi*y1) + center->y,
 493                 w_2*(cos_phi*cos_theta_2 - sin_phi*sin_theta_2) + center->x,
 494                 h_2*(sin_phi*cos_theta_2 + cos_phi*sin_theta_2) + center->y);
 495   }
 496   gnome_print_fill(renderer->ctx);
 497 }
 498
 499 /* This constant is equal to sqrt(2)/3*(8*cos(pi/8) - 4 - 1/sqrt(2)) - 1.
 500  * Its use should be quite obvious.
 501  */
 502 #define ELLIPSE_CTRL1 0.26521648984
 503 /* this constant is equal to 1/sqrt(2)*(1-ELLIPSE_CTRL1).
 504  * Its use should also be quite obvious.
 505  */
 506 #define ELLIPSE_CTRL2 0.519570402739
 507 #define ELLIPSE_CTRL3 M_SQRT1_2
 508 /* this constant is equal to 1/sqrt(2)*(1+ELLIPSE_CTRL1).
 509  * Its use should also be quite obvious.
 510  */
 511 #define ELLIPSE_CTRL4 0.894643159635
 512
 513 static void
 514 draw_ellipse(RendererGPrint *renderer,
 515              Point *center,
 516              real width, real height,
 517              Color *color)
 518 {
 519   real x1 = center->x - width/2,  x2 = center->x + width/2;
 520   real y1 = center->y - height/2, y2 = center->y + height/2;
 521   real cw1 = ELLIPSE_CTRL1 * width / 2, cw2 = ELLIPSE_CTRL2 * width / 2;
 522   real cw3 = ELLIPSE_CTRL3 * width / 2, cw4 = ELLIPSE_CTRL4 * width / 2;
 523   real ch1 = ELLIPSE_CTRL1 * height / 2, ch2 = ELLIPSE_CTRL2 * height / 2;
 524   real ch3 = ELLIPSE_CTRL3 * height / 2, ch4 = ELLIPSE_CTRL4 * height / 2;
 525
 526   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 527                           (double)color->green, (double)color->blue);
 528
 529   gnome_print_newpath(renderer->ctx);
 530   gnome_print_moveto(renderer->ctx, x1, center->y);
 531   gnome_print_curveto(renderer->ctx,
 532                       x1,              center->y - ch1,
 533                       center->x - cw4, center->y - ch2,
 534                       center->x - cw3, center->y - ch3);
 535   gnome_print_curveto(renderer->ctx,
 536                       center->x - cw2, center->y - ch4,
 537                       center->x - cw1, y1,
 538                       center->x,       y1);
 539   gnome_print_curveto(renderer->ctx,
 540                       center->x + cw1, y1,
 541                       center->x + cw2, center->y - ch4,
 542                       center->x + cw3, center->y - ch3);
 543   gnome_print_curveto(renderer->ctx,
 544                       center->x + cw4, center->y - ch2,
 545                       x2,              center->y - ch1,
 546                       x2,              center->y);
 547   gnome_print_curveto(renderer->ctx,
 548                       x2,              center->y + ch1,
 549                       center->x + cw4, center->y + ch2,
 550                       center->x + cw3, center->y + ch3);
 551   gnome_print_curveto(renderer->ctx,
 552                       center->x + cw2, center->y + ch4,
 553                       center->x + cw1, y2,
 554                       center->x,       y2);
 555   gnome_print_curveto(renderer->ctx,
 556                       center->x - cw1, y2,
 557                       center->x - cw2, center->y + ch4,
 558                       center->x - cw3, center->y + ch3);
 559   gnome_print_curveto(renderer->ctx,
 560                       center->x - cw4, center->y + ch2,
 561                       x1,              center->y + ch1,
 562                       x1,              center->y);
 563   gnome_print_closepath(renderer->ctx);
 564   gnome_print_stroke(renderer->ctx);
 565 }
 566
 567 static void
 568 fill_ellipse(RendererGPrint *renderer,
 569              Point *center,
 570              real width, real height,
 571              Color *color)
 572 {
 573   real x1 = center->x - width/2,  x2 = center->x + width/2;
 574   real y1 = center->y - height/2, y2 = center->y + height/2;
 575   real cw1 = ELLIPSE_CTRL1 * width / 2, cw2 = ELLIPSE_CTRL2 * width / 2;
 576   real cw3 = ELLIPSE_CTRL3 * width / 2, cw4 = ELLIPSE_CTRL4 * width / 2;
 577   real ch1 = ELLIPSE_CTRL1 * height / 2, ch2 = ELLIPSE_CTRL2 * height / 2;
 578   real ch3 = ELLIPSE_CTRL3 * height / 2, ch4 = ELLIPSE_CTRL4 * height / 2;
 579
 580   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 581                           (double)color->green, (double)color->blue);
 582
 583   gnome_print_newpath(renderer->ctx);
 584   gnome_print_moveto(renderer->ctx, x1, center->y);
 585   gnome_print_curveto(renderer->ctx,
 586                       x1,              center->y - ch1,
 587                       center->x - cw4, center->y - ch2,
 588                       center->x - cw3, center->y - ch3);
 589   gnome_print_curveto(renderer->ctx,
 590                       center->x - cw2, center->y - ch4,
 591                       center->x - cw1, y1,
 592                       center->x,       y1);
 593   gnome_print_curveto(renderer->ctx,
 594                       center->x + cw1, y1,
 595                       center->x + cw2, center->y - ch4,
 596                       center->x + cw3, center->y - ch3);
 597   gnome_print_curveto(renderer->ctx,
 598                       center->x + cw4, center->y - ch2,
 599                       x2,              center->y - ch1,
 600                       x2,              center->y);
 601   gnome_print_curveto(renderer->ctx,
 602                       x2,              center->y + ch1,
 603                       center->x + cw4, center->y + ch2,
 604                       center->x + cw3, center->y + ch3);
 605   gnome_print_curveto(renderer->ctx,
 606                       center->x + cw2, center->y + ch4,
 607                       center->x + cw1, y2,
 608                       center->x,       y2);
 609   gnome_print_curveto(renderer->ctx,
 610                       center->x - cw1, y2,
 611                       center->x - cw2, center->y + ch4,
 612                       center->x - cw3, center->y + ch3);
 613   gnome_print_curveto(renderer->ctx,
 614                       center->x - cw4, center->y + ch2,
 615                       x1,              center->y + ch1,
 616                       x1,              center->y);
 617   gnome_print_fill(renderer->ctx);
 618 }
 619
 620 static void
 621 draw_bezier(RendererGPrint *renderer,
 622             BezPoint *points,
 623             int numpoints, /* numpoints = 4+3*n, n=>0 */
 624             Color *color)
 625 {
 626   int i;
 627
 628   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 629                           (double)color->green, (double)color->blue);
 630
 631   if (points[0].type != BEZ_MOVE_TO)
 632     g_warning("first BezPoint must be a BEZ_MOVE_TO");
 633
 634   gnome_print_newpath(renderer->ctx);
 635   gnome_print_moveto(renderer->ctx, points[0].p1.x, points[0].p1.y);
 636
 637   for (i = 1; i < numpoints; i++)
 638     switch (points[i].type) {
 639     case BEZ_MOVE_TO:
 640       g_warning("only first BezPoint can be a BEZ_MOVE_TO");
 641       break;
 642     case BEZ_LINE_TO:
 643       gnome_print_lineto(renderer->ctx, points[i].p1.x, points[i].p1.y);
 644       break;
 645     case BEZ_CURVE_TO:
 646       gnome_print_curveto(renderer->ctx,
 647                           points[i].p1.x, points[i].p1.y,
 648                           points[i].p2.x, points[i].p2.y,
 649                           points[i].p3.x, points[i].p3.y);
 650       break;
 651     }
 652
 653   gnome_print_stroke(renderer->ctx);
 654 }
 655
 656 static void
 657 fill_bezier(RendererGPrint *renderer,
 658             BezPoint *points, /* Last point must be same as first point */
 659             int numpoints,
 660             Color *color)
 661 {
 662   int i;
 663
 664   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 665                           (double)color->green, (double)color->blue);
 666
 667   if (points[0].type != BEZ_MOVE_TO)
 668     g_warning("first BezPoint must be a BEZ_MOVE_TO");
 669
 670   gnome_print_newpath(renderer->ctx);
 671   gnome_print_moveto(renderer->ctx, points[0].p1.x, points[0].p1.y);
 672
 673   for (i = 1; i < numpoints; i++)
 674     switch (points[i].type) {
 675     case BEZ_MOVE_TO:
 676       g_warning("only first BezPoint can be a BEZ_MOVE_TO");
 677       break;
 678     case BEZ_LINE_TO:
 679       gnome_print_lineto(renderer->ctx, points[i].p1.x, points[i].p1.y);
 680       break;
 681     case BEZ_CURVE_TO:
 682       gnome_print_curveto(renderer->ctx,
 683                           points[i].p1.x, points[i].p1.y,
 684                           points[i].p2.x, points[i].p2.y,
 685                           points[i].p3.x, points[i].p3.y);
 686       break;
 687     }
 688
 689   gnome_print_fill(renderer->ctx);
 690 }
 691
 692 static void
 693 draw_string(RendererGPrint *renderer,
 694             const char *text,
 695             Point *pos, Alignment alignment,
 696             Color *color)
 697 {
 698   gnome_print_setrgbcolor(renderer->ctx, (double)color->red,
 699                           (double)color->green, (double)color->blue);
 700
 701   switch (alignment) {
 702   case ALIGN_LEFT:
 703     gnome_print_moveto(renderer->ctx, pos->x, pos->y);
 704     break;
 705   case ALIGN_CENTER:
 706     gnome_print_moveto(renderer->ctx, pos->x -
 707                        gnome_font_get_width_string(renderer->font, text) / 2,
 708                        pos->y);
 709     break;
 710   case ALIGN_RIGHT:
 711     gnome_print_moveto(renderer->ctx, pos->x -
 712                        gnome_font_get_width_string(renderer->font, text),
 713                        pos->y);
 714     break;
 715   }
 716
 717   gnome_print_gsave(renderer->ctx);
 718   gnome_print_scale(renderer->ctx, 1, -1);
 719   gnome_print_show(renderer->ctx, text);
 720   gnome_print_grestore(renderer->ctx);
 721 }
 722
 723 static void
 724 draw_image(RendererGPrint *renderer,
 725            Point *point,
 726            real width, real height,
 727            DiaImage image)
 728 {
 729   int img_width, img_height;
 730   int x, y;
 731   real ratio;
 732   guint8 *rgb_data;
 733   guint8 *mask_data;
 734
 735   img_width = dia_image_width(image);
 736   img_height = dia_image_height(image);
 737
 738   rgb_data = dia_image_rgb_data(image);
 739   mask_data = dia_image_mask_data(image);
 740
 741 #define ALPHA_TO_WHITE
 742   if (mask_data) {
 743     for (x = 0; x < img_width; x++) {
 744       for (y = 0; y < img_height; y++) {
 745         int index = x*img_height+y;
 746         if (mask_data[index] < 128) {
 747 #ifdef ALPHA_TO_WHITE
 748           rgb_data[index] = 255-(mask_data[index]*(255-rgb_data[index])/255);
 749           rgb_data[index+1] = 255-(mask_data[index]*(255-rgb_data[index+1])/255);
 750           rgb_data[index+2] = 255-(mask_data[index]*(255-rgb_data[index+2])/255);
 751 #else
 752           rgb_data[index] = rgb_data[index+1] =
 753             rgb_data[index+2] = 255;
 754 #endif
 755         }
 756       }
 757     }
 758   }
 759
 760   ratio = height/width;
 761
 762   gnome_print_gsave(renderer->ctx);
 763   if (1) { /* Color output */
 764     gnome_print_translate(renderer->ctx, point->x, point->y + height);
 765     gnome_print_scale(renderer->ctx, width, -height);
 766     gnome_print_rgbimage(renderer->ctx, rgb_data, img_width, img_height,
 767                          img_width * 3);
 768   }
 769   gnome_print_grestore(renderer->ctx);
 770   g_free(mask_data);
 771   g_free(rgb_data);
 772 }
 773