2 * PostScript driver graphics functions
4 * Copyright 1998 Huw D M Davies
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.
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.
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
27 #if defined(HAVE_FLOAT_H)
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(psdrv
);
41 /***********************************************************************
44 * Performs a world-to-viewport transformation on the specified width.
46 INT
PSDRV_XWStoDS( PHYSDEV dev
, INT width
)
54 LPtoDP( dev
->hdc
, pt
, 2 );
55 return pt
[1].x
- pt
[0].x
;
58 /***********************************************************************
61 static void PSDRV_DrawLine( PHYSDEV dev
)
63 PSDRV_PDEVICE
*physDev
= get_psdrv_dev( dev
);
65 if(physDev
->pathdepth
)
68 if (physDev
->pen
.style
== PS_NULL
)
69 PSDRV_WriteNewPath(dev
);
71 PSDRV_WriteStroke(dev
);
74 /***********************************************************************
77 BOOL
PSDRV_LineTo(PHYSDEV dev
, INT x
, INT y
)
81 TRACE("%d %d\n", x
, y
);
83 GetCurrentPositionEx( dev
->hdc
, pt
);
86 LPtoDP( dev
->hdc
, pt
, 2 );
91 PSDRV_WriteMoveTo(dev
, pt
[0].x
, pt
[0].y
);
92 PSDRV_WriteLineTo(dev
, pt
[1].x
, pt
[1].y
);
100 /***********************************************************************
103 BOOL
PSDRV_Rectangle( PHYSDEV dev
, INT left
, INT top
, INT right
, INT bottom
)
105 PSDRV_PDEVICE
*physDev
= get_psdrv_dev( dev
);
108 TRACE("%d %d - %d %d\n", left
, top
, right
, bottom
);
110 SetRect(&rect
, left
, top
, right
, bottom
);
111 LPtoDP( dev
->hdc
, (POINT
*)&rect
, 2 );
113 /* Windows does something truly hacky here. If we're in passthrough mode
114 and our rop is R2_NOP, then we output the string below. This is used in
115 Office 2k when inserting eps files */
116 if (physDev
->job
.passthrough_state
== passthrough_active
&& GetROP2(dev
->hdc
) == R2_NOP
)
120 sprintf(buf
, "N %d %d %d %d B\n", rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, rect
.left
, rect
.top
);
121 write_spool(dev
, buf
, strlen(buf
));
122 physDev
->job
.passthrough_state
= passthrough_had_rect
;
129 PSDRV_WriteRectangle(dev
, rect
.left
, rect
.top
, rect
.right
- rect
.left
,
130 rect
.bottom
- rect
.top
);
133 PSDRV_ResetClip(dev
);
138 /***********************************************************************
141 BOOL
PSDRV_RoundRect( PHYSDEV dev
, INT left
, INT top
, INT right
,
142 INT bottom
, INT ell_width
, INT ell_height
)
146 SetRect(&rect
[0], left
, top
, right
, bottom
);
147 SetRect(&rect
[1], 0, 0, ell_width
, ell_height
);
148 LPtoDP( dev
->hdc
, (POINT
*)rect
, 4 );
152 right
= rect
[0].right
;
153 bottom
= rect
[0].bottom
;
154 if (left
> right
) { INT tmp
= left
; left
= right
; right
= tmp
; }
155 if (top
> bottom
) { INT tmp
= top
; top
= bottom
; bottom
= tmp
; }
157 ell_width
= rect
[1].right
- rect
[1].left
;
158 ell_height
= rect
[1].bottom
- rect
[1].top
;
159 if (ell_width
> right
- left
) ell_width
= right
- left
;
160 if (ell_height
> bottom
- top
) ell_height
= bottom
- top
;
162 PSDRV_WriteSpool(dev
, "%RoundRect\n",11);
166 PSDRV_WriteMoveTo( dev
, left
, top
+ ell_height
/2 );
167 PSDRV_WriteArc( dev
, left
+ ell_width
/2, top
+ ell_height
/2, ell_width
,
168 ell_height
, 90.0, 180.0);
169 PSDRV_WriteLineTo( dev
, right
- ell_width
/2, top
);
170 PSDRV_WriteArc( dev
, right
- ell_width
/2, top
+ ell_height
/2, ell_width
,
171 ell_height
, 0.0, 90.0);
172 PSDRV_WriteLineTo( dev
, right
, bottom
- ell_height
/2 );
173 PSDRV_WriteArc( dev
, right
- ell_width
/2, bottom
- ell_height
/2, ell_width
,
174 ell_height
, -90.0, 0.0);
175 PSDRV_WriteLineTo( dev
, right
- ell_width
/2, bottom
);
176 PSDRV_WriteArc( dev
, left
+ ell_width
/2, bottom
- ell_height
/2, ell_width
,
177 ell_height
, 180.0, -90.0);
178 PSDRV_WriteClosePath( dev
);
182 PSDRV_ResetClip(dev
);
186 /***********************************************************************
189 * Does the work of Arc, Chord and Pie. lines is 0, 1 or 2 respectively.
191 static BOOL
PSDRV_DrawArc( PHYSDEV dev
, INT left
, INT top
,
192 INT right
, INT bottom
, INT xstart
, INT ystart
,
193 INT xend
, INT yend
, int lines
)
196 double start_angle
, end_angle
, ratio
;
200 SetRect(&rect
, left
, top
, right
, bottom
);
201 LPtoDP( dev
->hdc
, (POINT
*)&rect
, 2 );
206 LPtoDP( dev
->hdc
, &start
, 1 );
207 LPtoDP( dev
->hdc
, &end
, 1 );
209 x
= (rect
.left
+ rect
.right
) / 2;
210 y
= (rect
.top
+ rect
.bottom
) / 2;
211 w
= rect
.right
- rect
.left
;
212 h
= rect
.bottom
- rect
.top
;
216 ratio
= ((double)w
)/h
;
218 /* angle is the angle after the rectangle is transformed to a square and is
219 measured anticlockwise from the +ve x-axis */
221 start_angle
= atan2((double)(y
- start
.y
) * ratio
, (double)(start
.x
- x
));
222 end_angle
= atan2((double)(y
- end
.y
) * ratio
, (double)(end
.x
- x
));
224 start_angle
*= 180.0 / PI
;
225 end_angle
*= 180.0 / PI
;
227 PSDRV_WriteSpool(dev
,"%DrawArc\n", 9);
231 if(lines
== 2) /* pie */
232 PSDRV_WriteMoveTo(dev
, x
, y
);
234 PSDRV_WriteNewPath( dev
);
236 PSDRV_WriteArc(dev
, x
, y
, w
, h
, start_angle
, end_angle
);
237 if(lines
== 1 || lines
== 2) { /* chord or pie */
238 PSDRV_WriteClosePath(dev
);
242 PSDRV_ResetClip(dev
);
248 /***********************************************************************
251 BOOL
PSDRV_Arc( PHYSDEV dev
, INT left
, INT top
, INT right
, INT bottom
,
252 INT xstart
, INT ystart
, INT xend
, INT yend
)
254 return PSDRV_DrawArc( dev
, left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
, 0 );
257 /***********************************************************************
260 BOOL
PSDRV_Chord( PHYSDEV dev
, INT left
, INT top
, INT right
, INT bottom
,
261 INT xstart
, INT ystart
, INT xend
, INT yend
)
263 return PSDRV_DrawArc( dev
, left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
, 1 );
267 /***********************************************************************
270 BOOL
PSDRV_Pie( PHYSDEV dev
, INT left
, INT top
, INT right
, INT bottom
,
271 INT xstart
, INT ystart
, INT xend
, INT yend
)
273 return PSDRV_DrawArc( dev
, left
, top
, right
, bottom
, xstart
, ystart
, xend
, yend
, 2 );
277 /***********************************************************************
280 BOOL
PSDRV_Ellipse( PHYSDEV dev
, INT left
, INT top
, INT right
, INT bottom
)
285 TRACE("%d %d - %d %d\n", left
, top
, right
, bottom
);
287 SetRect(&rect
, left
, top
, right
, bottom
);
288 LPtoDP( dev
->hdc
, (POINT
*)&rect
, 2 );
290 x
= (rect
.left
+ rect
.right
) / 2;
291 y
= (rect
.top
+ rect
.bottom
) / 2;
292 w
= rect
.right
- rect
.left
;
293 h
= rect
.bottom
- rect
.top
;
295 PSDRV_WriteSpool(dev
, "%Ellipse\n", 9);
299 PSDRV_WriteNewPath(dev
);
300 PSDRV_WriteArc(dev
, x
, y
, w
, h
, 0.0, 360.0);
301 PSDRV_WriteClosePath(dev
);
304 PSDRV_ResetClip(dev
);
309 /***********************************************************************
312 BOOL
PSDRV_PolyPolyline( PHYSDEV dev
, const POINT
* pts
, const DWORD
* counts
, DWORD polylines
)
314 DWORD polyline
, line
, total
;
319 for (polyline
= total
= 0; polyline
< polylines
; polyline
++) total
+= counts
[polyline
];
320 if (!(dev_pts
= HeapAlloc( GetProcessHeap(), 0, total
* sizeof(*dev_pts
) ))) return FALSE
;
321 memcpy( dev_pts
, pts
, total
* sizeof(*dev_pts
) );
322 LPtoDP( dev
->hdc
, dev_pts
, total
);
326 PSDRV_WriteSpool(dev
, "%PolyPolyline\n",14);
330 for(polyline
= 0; polyline
< polylines
; polyline
++) {
331 PSDRV_WriteMoveTo(dev
, pt
->x
, pt
->y
);
333 for(line
= 1; line
< counts
[polyline
]; line
++, pt
++)
334 PSDRV_WriteLineTo(dev
, pt
->x
, pt
->y
);
336 HeapFree( GetProcessHeap(), 0, dev_pts
);
339 PSDRV_ResetClip(dev
);
344 /***********************************************************************
347 BOOL
PSDRV_PolyPolygon( PHYSDEV dev
, const POINT
* pts
, const INT
* counts
, UINT polygons
)
349 DWORD polygon
, total
;
355 for (polygon
= total
= 0; polygon
< polygons
; polygon
++) total
+= counts
[polygon
];
356 if (!(dev_pts
= HeapAlloc( GetProcessHeap(), 0, total
* sizeof(*dev_pts
) ))) return FALSE
;
357 memcpy( dev_pts
, pts
, total
* sizeof(*dev_pts
) );
358 LPtoDP( dev
->hdc
, dev_pts
, total
);
362 PSDRV_WriteSpool(dev
, "%PolyPolygon\n",13);
366 for(polygon
= 0; polygon
< polygons
; polygon
++) {
367 PSDRV_WriteMoveTo(dev
, pt
->x
, pt
->y
);
369 for(line
= 1; line
< counts
[polygon
]; line
++, pt
++)
370 PSDRV_WriteLineTo(dev
, pt
->x
, pt
->y
);
371 PSDRV_WriteClosePath(dev
);
373 HeapFree( GetProcessHeap(), 0, dev_pts
);
375 if(GetPolyFillMode( dev
->hdc
) == ALTERNATE
)
381 PSDRV_ResetClip(dev
);
386 /***********************************************************************
389 BOOL
PSDRV_PolyBezier( PHYSDEV dev
, const POINT
*pts
, DWORD count
)
396 if (!(dev_pts
= HeapAlloc( GetProcessHeap(), 0, count
* sizeof(*dev_pts
) ))) return FALSE
;
397 memcpy( dev_pts
, pts
, count
* sizeof(*dev_pts
) );
398 LPtoDP( dev
->hdc
, dev_pts
, count
);
400 PSDRV_WriteSpool(dev
, "%PolyBezier\n",12);
403 PSDRV_WriteMoveTo(dev
, dev_pts
[0].x
, dev_pts
[0].y
);
404 for (i
= 1; i
< count
; i
+= 3) PSDRV_WriteCurveTo( dev
, dev_pts
+ i
);
406 PSDRV_ResetClip(dev
);
407 HeapFree( GetProcessHeap(), 0, dev_pts
);
412 /***********************************************************************
415 BOOL
PSDRV_PolyBezierTo( PHYSDEV dev
, const POINT
*pts
, DWORD count
)
422 count
++; /* add initial position */
423 if (!(dev_pts
= HeapAlloc( GetProcessHeap(), 0, count
* sizeof(*dev_pts
) ))) return FALSE
;
424 GetCurrentPositionEx( dev
->hdc
, dev_pts
);
425 memcpy( dev_pts
+ 1, pts
, (count
- 1) * sizeof(*dev_pts
) );
426 LPtoDP( dev
->hdc
, dev_pts
, count
);
428 PSDRV_WriteSpool(dev
, "%PolyBezier\n",12);
431 PSDRV_WriteMoveTo(dev
, dev_pts
[0].x
, dev_pts
[0].y
);
432 for (i
= 1; i
< count
; i
+= 3) PSDRV_WriteCurveTo( dev
, dev_pts
+ i
);
434 PSDRV_ResetClip(dev
);
435 HeapFree( GetProcessHeap(), 0, dev_pts
);
440 /***********************************************************************
443 COLORREF
PSDRV_SetPixel( PHYSDEV dev
, INT x
, INT y
, COLORREF color
)
450 LPtoDP( dev
->hdc
, &pt
, 1 );
453 /* we bracket the setcolor in gsave/grestore so that we don't trash
454 the current pen colour */
455 PSDRV_WriteGSave(dev
);
456 PSDRV_WriteRectangle( dev
, pt
.x
, pt
.y
, 0, 0 );
457 PSDRV_CreateColor( dev
, &pscolor
, color
);
458 PSDRV_WriteSetColor( dev
, &pscolor
);
459 PSDRV_WriteFill( dev
);
460 PSDRV_WriteGRestore(dev
);
461 PSDRV_ResetClip(dev
);
465 /***********************************************************************
468 BOOL
PSDRV_PaintRgn( PHYSDEV dev
, HRGN hrgn
)
470 RGNDATA
*rgndata
= NULL
;
474 TRACE("hdc=%p\n", dev
->hdc
);
476 size
= GetRegionData(hrgn
, 0, NULL
);
477 rgndata
= HeapAlloc( GetProcessHeap(), 0, size
);
479 ERR("Can't allocate buffer\n");
483 GetRegionData(hrgn
, size
, rgndata
);
484 if (rgndata
->rdh
.nCount
== 0)
487 LPtoDP(dev
->hdc
, (POINT
*)rgndata
->Buffer
, rgndata
->rdh
.nCount
* 2);
490 for(i
= 0, pRect
= (RECT
*)rgndata
->Buffer
; i
< rgndata
->rdh
.nCount
; i
++, pRect
++)
491 PSDRV_WriteRectangle(dev
, pRect
->left
, pRect
->top
, pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
494 PSDRV_WriteNewPath(dev
);
495 PSDRV_ResetClip(dev
);
498 HeapFree(GetProcessHeap(), 0, rgndata
);
502 static BOOL
paint_path( PHYSDEV dev
, BOOL stroke
, BOOL fill
)
507 int i
, size
= GetPath( dev
->hdc
, NULL
, NULL
, 0 );
509 if (size
== -1) return FALSE
;
512 AbortPath( dev
->hdc
);
515 points
= HeapAlloc( GetProcessHeap(), 0, size
* sizeof(*points
) );
516 types
= HeapAlloc( GetProcessHeap(), 0, size
* sizeof(*types
) );
517 if (!points
|| !types
) goto done
;
518 if (GetPath( dev
->hdc
, points
, types
, size
) == -1) goto done
;
519 LPtoDP( dev
->hdc
, points
, size
);
521 if (stroke
) PSDRV_SetPen(dev
);
523 for (i
= 0; i
< size
; i
++)
528 PSDRV_WriteMoveTo( dev
, points
[i
].x
, points
[i
].y
);
531 case PT_LINETO
| PT_CLOSEFIGURE
:
532 PSDRV_WriteLineTo( dev
, points
[i
].x
, points
[i
].y
);
533 if (types
[i
] & PT_CLOSEFIGURE
) PSDRV_WriteClosePath( dev
);
536 case PT_BEZIERTO
| PT_CLOSEFIGURE
:
537 PSDRV_WriteCurveTo( dev
, points
+ i
);
538 if (types
[i
] & PT_CLOSEFIGURE
) PSDRV_WriteClosePath( dev
);
543 if (fill
) PSDRV_Brush( dev
, GetPolyFillMode(dev
->hdc
) == ALTERNATE
);
544 if (stroke
) PSDRV_DrawLine(dev
);
545 else PSDRV_WriteNewPath(dev
);
546 PSDRV_ResetClip(dev
);
547 AbortPath( dev
->hdc
);
550 HeapFree( GetProcessHeap(), 0, points
);
551 HeapFree( GetProcessHeap(), 0, types
);
555 /***********************************************************************
558 BOOL
PSDRV_FillPath( PHYSDEV dev
)
560 return paint_path( dev
, FALSE
, TRUE
);
563 /***********************************************************************
564 * PSDRV_StrokeAndFillPath
566 BOOL
PSDRV_StrokeAndFillPath( PHYSDEV dev
)
568 return paint_path( dev
, TRUE
, TRUE
);
571 /***********************************************************************
574 BOOL
PSDRV_StrokePath( PHYSDEV dev
)
576 return paint_path( dev
, TRUE
, FALSE
);