wineps: Fix a couple of typos in the path painting function.
[wine] / 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_Polyline
355  */
356 BOOL PSDRV_Polyline( PHYSDEV dev, const POINT* pt, INT count )
357 {
358     return PSDRV_PolyPolyline( dev, pt, (LPDWORD) &count, 1 );
359 }
360
361
362 /***********************************************************************
363  *           PSDRV_PolyPolygon
364  */
365 BOOL PSDRV_PolyPolygon( PHYSDEV dev, const POINT* pts, const INT* counts, UINT polygons )
366 {
367     DWORD polygon, total;
368     INT line;
369     POINT *dev_pts, *pt;
370
371     TRACE("\n");
372
373     for (polygon = total = 0; polygon < polygons; polygon++) total += counts[polygon];
374     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
375     memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
376     LPtoDP( dev->hdc, dev_pts, total );
377
378     pt = dev_pts;
379
380     PSDRV_WriteSpool(dev, "%PolyPolygon\n",13);
381     PSDRV_SetPen(dev);
382     PSDRV_SetClip(dev);
383
384     for(polygon = 0; polygon < polygons; polygon++) {
385         PSDRV_WriteMoveTo(dev, pt->x, pt->y);
386         pt++;
387         for(line = 1; line < counts[polygon]; line++, pt++)
388             PSDRV_WriteLineTo(dev, pt->x, pt->y);
389         PSDRV_WriteClosePath(dev);
390     }
391     HeapFree( GetProcessHeap(), 0, dev_pts );
392
393     if(GetPolyFillMode( dev->hdc ) == ALTERNATE)
394         PSDRV_Brush(dev, 1);
395     else /* WINDING */
396         PSDRV_Brush(dev, 0);
397
398     PSDRV_DrawLine(dev);
399     PSDRV_ResetClip(dev);
400     return TRUE;
401 }
402
403
404 /***********************************************************************
405  *           PSDRV_Polygon
406  */
407 BOOL PSDRV_Polygon( PHYSDEV dev, const POINT* pt, INT count )
408 {
409      return PSDRV_PolyPolygon( dev, pt, &count, 1 );
410 }
411
412
413 /***********************************************************************
414  *           PSDRV_PolyBezier
415  */
416 BOOL PSDRV_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD count )
417 {
418     DWORD i;
419     POINT *dev_pts;
420
421     TRACE("\n");
422
423     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
424     memcpy( dev_pts, pts, count * sizeof(*dev_pts) );
425     LPtoDP( dev->hdc, dev_pts, count );
426
427     PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
428     PSDRV_SetPen(dev);
429     PSDRV_SetClip(dev);
430     PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
431     for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
432     PSDRV_DrawLine(dev);
433     PSDRV_ResetClip(dev);
434     HeapFree( GetProcessHeap(), 0, dev_pts );
435     return TRUE;
436 }
437
438
439 /***********************************************************************
440  *           PSDRV_PolyBezierTo
441  */
442 BOOL PSDRV_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD count )
443 {
444     DWORD i;
445     POINT *dev_pts;
446
447     TRACE("\n");
448
449     count++;  /* add initial position */
450     if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
451     GetCurrentPositionEx( dev->hdc, dev_pts );
452     memcpy( dev_pts + 1, pts, (count - 1) * sizeof(*dev_pts) );
453     LPtoDP( dev->hdc, dev_pts, count );
454
455     PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
456     PSDRV_SetPen(dev);
457     PSDRV_SetClip(dev);
458     PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
459     for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
460     PSDRV_DrawLine(dev);
461     PSDRV_ResetClip(dev);
462     HeapFree( GetProcessHeap(), 0, dev_pts );
463     return TRUE;
464 }
465
466
467 /***********************************************************************
468  *           PSDRV_SetPixel
469  */
470 COLORREF PSDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
471 {
472     PSCOLOR pscolor;
473     POINT pt;
474
475     pt.x = x;
476     pt.y = y;
477     LPtoDP( dev->hdc, &pt, 1 );
478
479     PSDRV_SetClip(dev);
480     /* we bracket the setcolor in gsave/grestore so that we don't trash
481        the current pen colour */
482     PSDRV_WriteGSave(dev);
483     PSDRV_WriteRectangle( dev, pt.x, pt.y, 0, 0 );
484     PSDRV_CreateColor( dev, &pscolor, color );
485     PSDRV_WriteSetColor( dev, &pscolor );
486     PSDRV_WriteFill( dev );
487     PSDRV_WriteGRestore(dev);
488     PSDRV_ResetClip(dev);
489     return color;
490 }
491
492 /***********************************************************************
493  *           PSDRV_PaintRgn
494  */
495 BOOL PSDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
496 {
497     RGNDATA *rgndata = NULL;
498     RECT *pRect;
499     DWORD size, i;
500
501     TRACE("hdc=%p\n", dev->hdc);
502
503     size = GetRegionData(hrgn, 0, NULL);
504     rgndata = HeapAlloc( GetProcessHeap(), 0, size );
505     if(!rgndata) {
506         ERR("Can't allocate buffer\n");
507         return FALSE;
508     }
509     
510     GetRegionData(hrgn, size, rgndata);
511     if (rgndata->rdh.nCount == 0)
512         goto end;
513
514     LPtoDP(dev->hdc, (POINT*)rgndata->Buffer, rgndata->rdh.nCount * 2);
515
516     PSDRV_SetClip(dev);
517     for(i = 0, pRect = (RECT*)rgndata->Buffer; i < rgndata->rdh.nCount; i++, pRect++)
518         PSDRV_WriteRectangle(dev, pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
519
520     PSDRV_Brush(dev, 0);
521     PSDRV_WriteNewPath(dev);
522     PSDRV_ResetClip(dev);
523
524  end:
525     HeapFree(GetProcessHeap(), 0, rgndata);
526     return TRUE;
527 }
528
529 static BOOL paint_path( PHYSDEV dev, BOOL stroke, BOOL fill )
530 {
531     POINT *points;
532     BYTE *types;
533     BOOL ret = FALSE;
534     int i, size = GetPath( dev->hdc, NULL, NULL, 0 );
535
536     if (size == -1) return FALSE;
537     if (!size) return TRUE;
538     points = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*points) );
539     types = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*types) );
540     if (!points || !types) goto done;
541     if (GetPath( dev->hdc, points, types, size ) == -1) goto done;
542
543     if (stroke) PSDRV_SetPen(dev);
544     PSDRV_SetClip(dev);
545     for (i = 0; i < size; i++)
546     {
547         switch (types[i])
548         {
549         case PT_MOVETO:
550             PSDRV_WriteMoveTo( dev, points[i].x, points[i].y );
551             break;
552         case PT_LINETO:
553         case PT_LINETO | PT_CLOSEFIGURE:
554             PSDRV_WriteLineTo( dev, points[i].x, points[i].y );
555             if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
556             break;
557         case PT_BEZIERTO:
558         case PT_BEZIERTO | PT_CLOSEFIGURE:
559             PSDRV_WriteCurveTo( dev, points + i );
560             if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
561             i += 2;
562             break;
563         }
564     }
565     if (fill) PSDRV_Brush( dev, GetPolyFillMode(dev->hdc) == ALTERNATE );
566     if (stroke) PSDRV_DrawLine(dev);
567     else PSDRV_WriteNewPath(dev);
568     PSDRV_ResetClip(dev);
569
570 done:
571     HeapFree( GetProcessHeap(), 0, points );
572     HeapFree( GetProcessHeap(), 0, types );
573     return ret;
574 }
575
576 /***********************************************************************
577  *           PSDRV_FillPath
578  */
579 BOOL PSDRV_FillPath( PHYSDEV dev )
580 {
581     return paint_path( dev, FALSE, TRUE );
582 }
583
584 /***********************************************************************
585  *           PSDRV_StrokeAndFillPath
586  */
587 BOOL PSDRV_StrokeAndFillPath( PHYSDEV dev )
588 {
589     return paint_path( dev, TRUE, TRUE );
590 }
591
592 /***********************************************************************
593  *           PSDRV_StrokePath
594  */
595 BOOL PSDRV_StrokePath( PHYSDEV dev )
596 {
597     return paint_path( dev, TRUE, FALSE );
598 }