secur32: Handle padding only records in schan_DecryptMessage().
[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_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 }