git.oblomov.eu Git - wine/blob - dlls/wineps.drv/graphics.c

   1 /*
   2  *      PostScript driver graphics functions
   3  *
   4  *      Copyright 1998  Huw D M Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #if defined(HAVE_FLOAT_H)
  27 # include <float.h>
  28 #endif
  29 #if !defined(PI)
  30 # define PI M_PI
  31 #endif
  32 #include "psdrv.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  36
  37 /***********************************************************************
  38  *           PSDRV_XWStoDS
  39  *
  40  * Performs a world-to-viewport transformation on the specified width.
  41  */
  42 INT PSDRV_XWStoDS( PHYSDEV dev, INT width )
  43 {
  44     POINT pt[2];
  45
  46     pt[0].x = 0;
  47     pt[0].y = 0;
  48     pt[1].x = width;
  49     pt[1].y = 0;
  50     LPtoDP( dev->hdc, pt, 2 );
  51     return pt[1].x - pt[0].x;
  52 }
  53
  54 /***********************************************************************
  55  *           PSDRV_DrawLine
  56  */
  57 static void PSDRV_DrawLine( PHYSDEV dev )
  58 {
  59     PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
  60
  61     if(physDev->pathdepth)
  62         return;
  63
  64     if (physDev->pen.style == PS_NULL)
  65         PSDRV_WriteNewPath(dev);
  66     else
  67         PSDRV_WriteStroke(dev);
  68 }
  69
  70 /***********************************************************************
  71  *           PSDRV_LineTo
  72  */
  73 BOOL PSDRV_LineTo(PHYSDEV dev, INT x, INT y)
  74 {
  75     POINT pt[2];
  76
  77     TRACE("%d %d\n", x, y);
  78
  79     GetCurrentPositionEx( dev->hdc, pt );
  80     pt[1].x = x;
  81     pt[1].y = y;
  82     LPtoDP( dev->hdc, pt, 2 );
  83
  84     PSDRV_SetPen(dev);
  85
  86     PSDRV_SetClip(dev);
  87     PSDRV_WriteMoveTo(dev, pt[0].x, pt[0].y );
  88     PSDRV_WriteLineTo(dev, pt[1].x, pt[1].y );
  89     PSDRV_DrawLine(dev);
  90     PSDRV_ResetClip(dev);
  91
  92     return TRUE;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           PSDRV_Rectangle
  98  */
  99 BOOL PSDRV_Rectangle( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
 100 {
 101     PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
 102     RECT rect;
 103
 104     TRACE("%d %d - %d %d\n", left, top, right, bottom);
 105
 106     rect.left = left;
 107     rect.top = top;
 108     rect.right = right;
 109     rect.bottom = bottom;
 110     LPtoDP( dev->hdc, (POINT *)&rect, 2 );
 111
 112     /* Windows does something truly hacky here.  If we're in passthrough mode
 113        and our rop is R2_NOP, then we output the string below.  This is used in
 114        Office 2k when inserting eps files */
 115     if(physDev->job.in_passthrough && !physDev->job.had_passthrough_rect && GetROP2(dev->hdc) == R2_NOP) {
 116       char buf[256];
 117       sprintf(buf, "N %d %d %d %d B\n", rect.right - rect.left, rect.bottom - rect.top, rect.left, rect.top);
 118       write_spool(dev, buf, strlen(buf));
 119       physDev->job.had_passthrough_rect = TRUE;
 120       return TRUE;
 121     }
 122
 123     PSDRV_SetPen(dev);
 124
 125     PSDRV_SetClip(dev);
 126     PSDRV_WriteRectangle(dev, rect.left, rect.top, rect.right - rect.left,
 127                          rect.bottom - rect.top );
 128     PSDRV_Brush(dev,0);
 129     PSDRV_DrawLine(dev);
 130     PSDRV_ResetClip(dev);
 131     return TRUE;
 132 }
 133
 134
 135 /***********************************************************************
 136  *           PSDRV_RoundRect
 137  */
 138 BOOL PSDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
 139                       INT bottom, INT ell_width, INT ell_height )
 140 {
 141     RECT rect[2];
 142
 143     rect[0].left   = left;
 144     rect[0].top    = top;
 145     rect[0].right  = right;
 146     rect[0].bottom = bottom;
 147     rect[1].left   = 0;
 148     rect[1].top    = 0;
 149     rect[1].right  = ell_width;
 150     rect[1].bottom = ell_height;
 151     LPtoDP( dev->hdc, (POINT *)rect, 4 );
 152
 153     left   = rect[0].left;
 154     top    = rect[0].top;
 155     right  = rect[0].right;
 156     bottom = rect[0].bottom;
 157     if (left > right) { INT tmp = left; left = right; right = tmp; }
 158     if (top > bottom) { INT tmp = top; top = bottom; bottom = tmp; }
 159
 160     ell_width  = rect[1].right - rect[1].left;
 161     ell_height = rect[1].bottom - rect[1].top;
 162     if (ell_width > right - left) ell_width = right - left;
 163     if (ell_height > bottom - top) ell_height = bottom - top;
 164
 165     PSDRV_WriteSpool(dev, "%RoundRect\n",11);
 166     PSDRV_SetPen(dev);
 167
 168     PSDRV_SetClip(dev);
 169     PSDRV_WriteMoveTo( dev, left, top + ell_height/2 );
 170     PSDRV_WriteArc( dev, left + ell_width/2, top + ell_height/2, ell_width,
 171                     ell_height, 90.0, 180.0);
 172     PSDRV_WriteLineTo( dev, right - ell_width/2, top );
 173     PSDRV_WriteArc( dev, right - ell_width/2, top + ell_height/2, ell_width,
 174                     ell_height, 0.0, 90.0);
 175     PSDRV_WriteLineTo( dev, right, bottom - ell_height/2 );
 176     PSDRV_WriteArc( dev, right - ell_width/2, bottom - ell_height/2, ell_width,
 177                     ell_height, -90.0, 0.0);
 178     PSDRV_WriteLineTo( dev, right - ell_width/2, bottom);
 179     PSDRV_WriteArc( dev, left + ell_width/2, bottom - ell_height/2, ell_width,
 180                     ell_height, 180.0, -90.0);
 181     PSDRV_WriteClosePath( dev );
 182
 183     PSDRV_Brush(dev,0);
 184     PSDRV_DrawLine(dev);
 185     PSDRV_ResetClip(dev);
 186     return TRUE;
 187 }
 188
 189 /***********************************************************************
 190  *           PSDRV_DrawArc
 191  *
 192  * Does the work of Arc, Chord and Pie. lines is 0, 1 or 2 respectively.
 193  */
 194 static BOOL PSDRV_DrawArc( PHYSDEV dev, INT left, INT top,
 195                            INT right, INT bottom, INT xstart, INT ystart,
 196                            INT xend, INT yend, int lines )
 197 {
 198     INT x, y, h, w;
 199     double start_angle, end_angle, ratio;
 200     RECT rect;
 201     POINT start, end;
 202
 203     rect.left = left;
 204     rect.top = top;
 205     rect.right = right;
 206     rect.bottom = bottom;
 207     LPtoDP( dev->hdc, (POINT *)&rect, 2 );
 208     start.x = xstart;
 209     start.y = ystart;
 210     end.x = xend;
 211     end.y = yend;
 212     LPtoDP( dev->hdc, &start, 1 );
 213     LPtoDP( dev->hdc, &end, 1 );
 214
 215     x = (rect.left + rect.right) / 2;
 216     y = (rect.top + rect.bottom) / 2;
 217     w = rect.right - rect.left;
 218     h = rect.bottom - rect.top;
 219
 220     if(w < 0) w = -w;
 221     if(h < 0) h = -h;
 222     ratio = ((double)w)/h;
 223
 224     /* angle is the angle after the rectangle is transformed to a square and is
 225        measured anticlockwise from the +ve x-axis */
 226
 227     start_angle = atan2((double)(y - start.y) * ratio, (double)(start.x - x));
 228     end_angle = atan2((double)(y - end.y) * ratio, (double)(end.x - x));
 229
 230     start_angle *= 180.0 / PI;
 231     end_angle *= 180.0 / PI;
 232
 233     PSDRV_WriteSpool(dev,"%DrawArc\n", 9);
 234     PSDRV_SetPen(dev);
 235
 236     PSDRV_SetClip(dev);
 237     if(lines == 2) /* pie */
 238         PSDRV_WriteMoveTo(dev, x, y);
 239     else
 240         PSDRV_WriteNewPath( dev );
 241
 242     PSDRV_WriteArc(dev, x, y, w, h, start_angle, end_angle);
 243     if(lines == 1 || lines == 2) { /* chord or pie */
 244         PSDRV_WriteClosePath(dev);
 245         PSDRV_Brush(dev,0);
 246     }
 247     PSDRV_DrawLine(dev);
 248     PSDRV_ResetClip(dev);
 249
 250     return TRUE;
 251 }
 252
 253
 254 /***********************************************************************
 255  *           PSDRV_Arc
 256  */
 257 BOOL PSDRV_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 258                 INT xstart, INT ystart, INT xend, INT yend )
 259 {
 260     return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 0 );
 261 }
 262
 263 /***********************************************************************
 264  *           PSDRV_Chord
 265  */
 266 BOOL PSDRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 267                   INT xstart, INT ystart, INT xend, INT yend )
 268 {
 269     return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 1 );
 270 }
 271
 272
 273 /***********************************************************************
 274  *           PSDRV_Pie
 275  */
 276 BOOL PSDRV_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 277                 INT xstart, INT ystart, INT xend, INT yend )
 278 {
 279     return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 2 );
 280 }
 281
 282
 283 /***********************************************************************
 284  *           PSDRV_Ellipse
 285  */
 286 BOOL PSDRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom)
 287 {
 288     INT x, y, w, h;
 289     RECT rect;
 290
 291     TRACE("%d %d - %d %d\n", left, top, right, bottom);
 292
 293     rect.left   = left;
 294     rect.top    = top;
 295     rect.right  = right;
 296     rect.bottom = bottom;
 297     LPtoDP( dev->hdc, (POINT *)&rect, 2 );
 298
 299     x = (rect.left + rect.right) / 2;
 300     y = (rect.top + rect.bottom) / 2;
 301     w = rect.right - rect.left;
 302     h = rect.bottom - rect.top;
 303
 304     PSDRV_WriteSpool(dev, "%Ellipse\n", 9);
 305     PSDRV_SetPen(dev);
 306
 307     PSDRV_SetClip(dev);
 308     PSDRV_WriteNewPath(dev);
 309     PSDRV_WriteArc(dev, x, y, w, h, 0.0, 360.0);
 310     PSDRV_WriteClosePath(dev);
 311     PSDRV_Brush(dev,0);
 312     PSDRV_DrawLine(dev);
 313     PSDRV_ResetClip(dev);
 314     return TRUE;
 315 }
 316
 317
 318 /***********************************************************************
 319  *           PSDRV_PolyPolyline
 320  */
 321 BOOL PSDRV_PolyPolyline( PHYSDEV dev, const POINT* pts, const DWORD* counts, DWORD polylines )
 322 {
 323     DWORD polyline, line, total;
 324     POINT *dev_pts, *pt;
 325
 326     TRACE("\n");
 327
 328     for (polyline = total = 0; polyline < polylines; polyline++) total += counts[polyline];
 329     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
 330     memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
 331     LPtoDP( dev->hdc, dev_pts, total );
 332
 333     pt = dev_pts;
 334
 335     PSDRV_WriteSpool(dev, "%PolyPolyline\n",14);
 336     PSDRV_SetPen(dev);
 337     PSDRV_SetClip(dev);
 338
 339     for(polyline = 0; polyline < polylines; polyline++) {
 340         PSDRV_WriteMoveTo(dev, pt->x, pt->y);
 341         pt++;
 342         for(line = 1; line < counts[polyline]; line++, pt++)
 343             PSDRV_WriteLineTo(dev, pt->x, pt->y);
 344     }
 345     HeapFree( GetProcessHeap(), 0, dev_pts );
 346
 347     PSDRV_DrawLine(dev);
 348     PSDRV_ResetClip(dev);
 349     return TRUE;
 350 }
 351
 352
 353 /***********************************************************************
 354  *           PSDRV_PolyPolygon
 355  */
 356 BOOL PSDRV_PolyPolygon( PHYSDEV dev, const POINT* pts, const INT* counts, UINT polygons )
 357 {
 358     DWORD polygon, total;
 359     INT line;
 360     POINT *dev_pts, *pt;
 361
 362     TRACE("\n");
 363
 364     for (polygon = total = 0; polygon < polygons; polygon++) total += counts[polygon];
 365     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
 366     memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
 367     LPtoDP( dev->hdc, dev_pts, total );
 368
 369     pt = dev_pts;
 370
 371     PSDRV_WriteSpool(dev, "%PolyPolygon\n",13);
 372     PSDRV_SetPen(dev);
 373     PSDRV_SetClip(dev);
 374
 375     for(polygon = 0; polygon < polygons; polygon++) {
 376         PSDRV_WriteMoveTo(dev, pt->x, pt->y);
 377         pt++;
 378         for(line = 1; line < counts[polygon]; line++, pt++)
 379             PSDRV_WriteLineTo(dev, pt->x, pt->y);
 380         PSDRV_WriteClosePath(dev);
 381     }
 382     HeapFree( GetProcessHeap(), 0, dev_pts );
 383
 384     if(GetPolyFillMode( dev->hdc ) == ALTERNATE)
 385         PSDRV_Brush(dev, 1);
 386     else /* WINDING */
 387         PSDRV_Brush(dev, 0);
 388
 389     PSDRV_DrawLine(dev);
 390     PSDRV_ResetClip(dev);
 391     return TRUE;
 392 }
 393
 394
 395 /***********************************************************************
 396  *           PSDRV_PolyBezier
 397  */
 398 BOOL PSDRV_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD count )
 399 {
 400     DWORD i;
 401     POINT *dev_pts;
 402
 403     TRACE("\n");
 404
 405     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
 406     memcpy( dev_pts, pts, count * sizeof(*dev_pts) );
 407     LPtoDP( dev->hdc, dev_pts, count );
 408
 409     PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
 410     PSDRV_SetPen(dev);
 411     PSDRV_SetClip(dev);
 412     PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
 413     for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
 414     PSDRV_DrawLine(dev);
 415     PSDRV_ResetClip(dev);
 416     HeapFree( GetProcessHeap(), 0, dev_pts );
 417     return TRUE;
 418 }
 419
 420
 421 /***********************************************************************
 422  *           PSDRV_PolyBezierTo
 423  */
 424 BOOL PSDRV_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD count )
 425 {
 426     DWORD i;
 427     POINT *dev_pts;
 428
 429     TRACE("\n");
 430
 431     count++;  /* add initial position */
 432     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
 433     GetCurrentPositionEx( dev->hdc, dev_pts );
 434     memcpy( dev_pts + 1, pts, (count - 1) * sizeof(*dev_pts) );
 435     LPtoDP( dev->hdc, dev_pts, count );
 436
 437     PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
 438     PSDRV_SetPen(dev);
 439     PSDRV_SetClip(dev);
 440     PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
 441     for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
 442     PSDRV_DrawLine(dev);
 443     PSDRV_ResetClip(dev);
 444     HeapFree( GetProcessHeap(), 0, dev_pts );
 445     return TRUE;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           PSDRV_SetPixel
 451  */
 452 COLORREF PSDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
 453 {
 454     PSCOLOR pscolor;
 455     POINT pt;
 456
 457     pt.x = x;
 458     pt.y = y;
 459     LPtoDP( dev->hdc, &pt, 1 );
 460
 461     PSDRV_SetClip(dev);
 462     /* we bracket the setcolor in gsave/grestore so that we don't trash
 463        the current pen colour */
 464     PSDRV_WriteGSave(dev);
 465     PSDRV_WriteRectangle( dev, pt.x, pt.y, 0, 0 );
 466     PSDRV_CreateColor( dev, &pscolor, color );
 467     PSDRV_WriteSetColor( dev, &pscolor );
 468     PSDRV_WriteFill( dev );
 469     PSDRV_WriteGRestore(dev);
 470     PSDRV_ResetClip(dev);
 471     return color;
 472 }
 473
 474 /***********************************************************************
 475  *           PSDRV_PaintRgn
 476  */
 477 BOOL PSDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
 478 {
 479     RGNDATA *rgndata = NULL;
 480     RECT *pRect;
 481     DWORD size, i;
 482
 483     TRACE("hdc=%p\n", dev->hdc);
 484
 485     size = GetRegionData(hrgn, 0, NULL);
 486     rgndata = HeapAlloc( GetProcessHeap(), 0, size );
 487     if(!rgndata) {
 488         ERR("Can't allocate buffer\n");
 489         return FALSE;
 490     }
 491
 492     GetRegionData(hrgn, size, rgndata);
 493     if (rgndata->rdh.nCount == 0)
 494         goto end;
 495
 496     LPtoDP(dev->hdc, (POINT*)rgndata->Buffer, rgndata->rdh.nCount * 2);
 497
 498     PSDRV_SetClip(dev);
 499     for(i = 0, pRect = (RECT*)rgndata->Buffer; i < rgndata->rdh.nCount; i++, pRect++)
 500         PSDRV_WriteRectangle(dev, pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
 501
 502     PSDRV_Brush(dev, 0);
 503     PSDRV_WriteNewPath(dev);
 504     PSDRV_ResetClip(dev);
 505
 506  end:
 507     HeapFree(GetProcessHeap(), 0, rgndata);
 508     return TRUE;
 509 }
 510
 511 static BOOL paint_path( PHYSDEV dev, BOOL stroke, BOOL fill )
 512 {
 513     POINT *points;
 514     BYTE *types;
 515     BOOL ret = FALSE;
 516     int i, size = GetPath( dev->hdc, NULL, NULL, 0 );
 517
 518     if (size == -1) return FALSE;
 519     if (!size) return TRUE;
 520     points = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*points) );
 521     types = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*types) );
 522     if (!points || !types) goto done;
 523     if (GetPath( dev->hdc, points, types, size ) == -1) goto done;
 524     LPtoDP( dev->hdc, points, size );
 525
 526     if (stroke) PSDRV_SetPen(dev);
 527     PSDRV_SetClip(dev);
 528     for (i = 0; i < size; i++)
 529     {
 530         switch (types[i])
 531         {
 532         case PT_MOVETO:
 533             PSDRV_WriteMoveTo( dev, points[i].x, points[i].y );
 534             break;
 535         case PT_LINETO:
 536         case PT_LINETO | PT_CLOSEFIGURE:
 537             PSDRV_WriteLineTo( dev, points[i].x, points[i].y );
 538             if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
 539             break;
 540         case PT_BEZIERTO:
 541         case PT_BEZIERTO | PT_CLOSEFIGURE:
 542             PSDRV_WriteCurveTo( dev, points + i );
 543             if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
 544             i += 2;
 545             break;
 546         }
 547     }
 548     if (fill) PSDRV_Brush( dev, GetPolyFillMode(dev->hdc) == ALTERNATE );
 549     if (stroke) PSDRV_DrawLine(dev);
 550     else PSDRV_WriteNewPath(dev);
 551     PSDRV_ResetClip(dev);
 552
 553 done:
 554     HeapFree( GetProcessHeap(), 0, points );
 555     HeapFree( GetProcessHeap(), 0, types );
 556     return ret;
 557 }
 558
 559 /***********************************************************************
 560  *           PSDRV_FillPath
 561  */
 562 BOOL PSDRV_FillPath( PHYSDEV dev )
 563 {
 564     return paint_path( dev, FALSE, TRUE );
 565 }
 566
 567 /***********************************************************************
 568  *           PSDRV_StrokeAndFillPath
 569  */
 570 BOOL PSDRV_StrokeAndFillPath( PHYSDEV dev )
 571 {
 572     return paint_path( dev, TRUE, TRUE );
 573 }
 574
 575 /***********************************************************************
 576  *           PSDRV_StrokePath
 577  */
 578 BOOL PSDRV_StrokePath( PHYSDEV dev )
 579 {
 580     return paint_path( dev, TRUE, FALSE );
 581 }