graphics.c 16.2 KB
Newer Older
Alexandre Julliard's avatar
Alexandre Julliard committed
1
/*
Alexandre Julliard's avatar
Alexandre Julliard committed
2
 *	PostScript driver graphics functions
Alexandre Julliard's avatar
Alexandre Julliard committed
3 4 5
 *
 *	Copyright 1998  Huw D M Davies
 *
6 7 8 9 10 11 12 13 14 15 16 17
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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
Alexandre Julliard's avatar
Alexandre Julliard committed
19
 */
20

21
#include <stdarg.h>
22
#include <stdio.h>
Alexandre Julliard's avatar
Alexandre Julliard committed
23
#include <string.h>
24
#include <math.h>
25
#include <float.h>
26 27 28
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
Alexandre Julliard's avatar
Alexandre Julliard committed
29
#include "psdrv.h"
30
#include "wine/debug.h"
Alexandre Julliard's avatar
Alexandre Julliard committed
31

32
WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
33

34 35 36 37 38
/***********************************************************************
 *           PSDRV_XWStoDS
 *
 * Performs a world-to-viewport transformation on the specified width.
 */
39
INT PSDRV_XWStoDS( PHYSDEV dev, INT width )
40 41 42 43 44 45 46
{
    POINT pt[2];

    pt[0].x = 0;
    pt[0].y = 0;
    pt[1].x = width;
    pt[1].y = 0;
47
    LPtoDP( dev->hdc, pt, 2 );
48 49 50
    return pt[1].x - pt[0].x;
}

51 52 53
/***********************************************************************
 *           PSDRV_DrawLine
 */
54
static void PSDRV_DrawLine( PHYSDEV dev )
55
{
56 57
    PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );

58 59 60 61
    if(physDev->pathdepth)
        return;

    if (physDev->pen.style == PS_NULL)
62
	PSDRV_WriteNewPath(dev);
63
    else
64
	PSDRV_WriteStroke(dev);
65
}
66

Alexandre Julliard's avatar
Alexandre Julliard committed
67 68 69
/***********************************************************************
 *           PSDRV_LineTo
 */
70
BOOL CDECL PSDRV_LineTo(PHYSDEV dev, INT x, INT y)
Alexandre Julliard's avatar
Alexandre Julliard committed
71
{
72
    POINT pt[2];
73

74
    TRACE("%d %d\n", x, y);
Alexandre Julliard's avatar
Alexandre Julliard committed
75

76
    GetCurrentPositionEx( dev->hdc, pt );
77 78
    pt[1].x = x;
    pt[1].y = y;
79
    LPtoDP( dev->hdc, pt, 2 );
80

81
    PSDRV_SetPen(dev);
82

83 84 85 86 87
    PSDRV_SetClip(dev);
    PSDRV_WriteMoveTo(dev, pt[0].x, pt[0].y );
    PSDRV_WriteLineTo(dev, pt[1].x, pt[1].y );
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
Alexandre Julliard's avatar
Alexandre Julliard committed
88 89 90 91

    return TRUE;
}

92

Alexandre Julliard's avatar
Alexandre Julliard committed
93 94 95
/***********************************************************************
 *           PSDRV_Rectangle
 */
96
BOOL CDECL PSDRV_Rectangle( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
Alexandre Julliard's avatar
Alexandre Julliard committed
97
{
98
    PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
99
    RECT rect;
Alexandre Julliard's avatar
Alexandre Julliard committed
100

101
    TRACE("%d %d - %d %d\n", left, top, right, bottom);
102

103
    SetRect(&rect, left, top, right, bottom);
104
    LPtoDP( dev->hdc, (POINT *)&rect, 2 );
105

106
    /* Windows does something truly hacky here.  If we're in passthrough mode
107 108
       and our rop is R2_NOP, then we output the string below.  This is used in
       Office 2k when inserting eps files */
109 110 111 112 113 114 115 116
    if (physDev->job.passthrough_state == passthrough_active && GetROP2(dev->hdc) == R2_NOP)
    {
        char buf[256];

        sprintf(buf, "N %d %d %d %d B\n", rect.right - rect.left, rect.bottom - rect.top, rect.left, rect.top);
        write_spool(dev, buf, strlen(buf));
        physDev->job.passthrough_state = passthrough_had_rect;
        return TRUE;
117 118
    }

119
    PSDRV_SetPen(dev);
120

121 122
    PSDRV_SetClip(dev);
    PSDRV_WriteRectangle(dev, rect.left, rect.top, rect.right - rect.left,
123
                         rect.bottom - rect.top );
124 125 126
    PSDRV_Brush(dev,0);
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
Alexandre Julliard's avatar
Alexandre Julliard committed
127 128 129 130
    return TRUE;
}


131 132 133
/***********************************************************************
 *           PSDRV_RoundRect
 */
134 135
BOOL CDECL PSDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
                            INT bottom, INT ell_width, INT ell_height )
136
{
137 138
    RECT rect[2];

139 140
    SetRect(&rect[0], left, top, right, bottom);
    SetRect(&rect[1], 0, 0, ell_width, ell_height);
141
    LPtoDP( dev->hdc, (POINT *)rect, 4 );
142 143 144 145 146 147 148 149 150 151 152 153

    left   = rect[0].left;
    top    = rect[0].top;
    right  = rect[0].right;
    bottom = rect[0].bottom;
    if (left > right) { INT tmp = left; left = right; right = tmp; }
    if (top > bottom) { INT tmp = top; top = bottom; bottom = tmp; }

    ell_width  = rect[1].right - rect[1].left;
    ell_height = rect[1].bottom - rect[1].top;
    if (ell_width > right - left) ell_width = right - left;
    if (ell_height > bottom - top) ell_height = bottom - top;
154

155 156
    PSDRV_WriteSpool(dev, "%RoundRect\n",11);
    PSDRV_SetPen(dev);
157

158 159 160
    PSDRV_SetClip(dev);
    PSDRV_WriteMoveTo( dev, left, top + ell_height/2 );
    PSDRV_WriteArc( dev, left + ell_width/2, top + ell_height/2, ell_width,
161
		    ell_height, 90.0, 180.0);
162 163
    PSDRV_WriteLineTo( dev, right - ell_width/2, top );
    PSDRV_WriteArc( dev, right - ell_width/2, top + ell_height/2, ell_width,
164
		    ell_height, 0.0, 90.0);
165 166
    PSDRV_WriteLineTo( dev, right, bottom - ell_height/2 );
    PSDRV_WriteArc( dev, right - ell_width/2, bottom - ell_height/2, ell_width,
167
		    ell_height, -90.0, 0.0);
168 169
    PSDRV_WriteLineTo( dev, right - ell_width/2, bottom);
    PSDRV_WriteArc( dev, left + ell_width/2, bottom - ell_height/2, ell_width,
170
		    ell_height, 180.0, -90.0);
171
    PSDRV_WriteClosePath( dev );
172

173 174 175
    PSDRV_Brush(dev,0);
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
176 177 178 179 180 181 182 183
    return TRUE;
}

/***********************************************************************
 *           PSDRV_DrawArc
 *
 * Does the work of Arc, Chord and Pie. lines is 0, 1 or 2 respectively.
 */
184
static BOOL PSDRV_DrawArc( PHYSDEV dev, INT left, INT top,
185 186
                           INT right, INT bottom, INT xstart, INT ystart,
                           INT xend, INT yend, int lines )
187
{
188
    INT x, y, h, w;
189
    double start_angle, end_angle, ratio;
190
    RECT rect;
191
    POINT start, end;
192

193
    SetRect(&rect, left, top, right, bottom);
194
    LPtoDP( dev->hdc, (POINT *)&rect, 2 );
195 196 197 198
    start.x = xstart;
    start.y = ystart;
    end.x = xend;
    end.y = yend;
199 200
    LPtoDP( dev->hdc, &start, 1 );
    LPtoDP( dev->hdc, &end, 1 );
201

202 203 204 205
    x = (rect.left + rect.right) / 2;
    y = (rect.top + rect.bottom) / 2;
    w = rect.right - rect.left;
    h = rect.bottom - rect.top;
206 207 208 209 210 211 212 213

    if(w < 0) w = -w;
    if(h < 0) h = -h;
    ratio = ((double)w)/h;

    /* angle is the angle after the rectangle is transformed to a square and is
       measured anticlockwise from the +ve x-axis */

214 215
    start_angle = atan2((double)(y - start.y) * ratio, (double)(start.x - x));
    end_angle = atan2((double)(y - end.y) * ratio, (double)(end.x - x));
216

217 218
    start_angle *= 180.0 / M_PI;
    end_angle *= 180.0 / M_PI;
219

220 221
    PSDRV_WriteSpool(dev,"%DrawArc\n", 9);
    PSDRV_SetPen(dev);
222

223
    PSDRV_SetClip(dev);
224
    if(lines == 2) /* pie */
225
        PSDRV_WriteMoveTo(dev, x, y);
226
    else
227
        PSDRV_WriteNewPath( dev );
228

229
    PSDRV_WriteArc(dev, x, y, w, h, start_angle, end_angle);
230
    if(lines == 1 || lines == 2) { /* chord or pie */
231 232
        PSDRV_WriteClosePath(dev);
	PSDRV_Brush(dev,0);
233
    }
234 235
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
236

237 238 239 240 241 242 243
    return TRUE;
}


/***********************************************************************
 *           PSDRV_Arc
 */
244 245
BOOL CDECL PSDRV_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
                      INT xstart, INT ystart, INT xend, INT yend )
246
{
247
    return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 0 );
248 249 250 251 252
}

/***********************************************************************
 *           PSDRV_Chord
 */
253 254
BOOL CDECL PSDRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
                        INT xstart, INT ystart, INT xend, INT yend )
255
{
256
    return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 1 );
257 258 259 260 261 262
}


/***********************************************************************
 *           PSDRV_Pie
 */
263 264
BOOL CDECL PSDRV_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
                      INT xstart, INT ystart, INT xend, INT yend )
265
{
266
    return PSDRV_DrawArc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 2 );
267 268 269
}


Alexandre Julliard's avatar
Alexandre Julliard committed
270 271 272
/***********************************************************************
 *           PSDRV_Ellipse
 */
273
BOOL CDECL PSDRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom)
Alexandre Julliard's avatar
Alexandre Julliard committed
274
{
275
    INT x, y, w, h;
276
    RECT rect;
Alexandre Julliard's avatar
Alexandre Julliard committed
277

278
    TRACE("%d %d - %d %d\n", left, top, right, bottom);
Alexandre Julliard's avatar
Alexandre Julliard committed
279

280
    SetRect(&rect, left, top, right, bottom);
281
    LPtoDP( dev->hdc, (POINT *)&rect, 2 );
Alexandre Julliard's avatar
Alexandre Julliard committed
282

283 284 285 286
    x = (rect.left + rect.right) / 2;
    y = (rect.top + rect.bottom) / 2;
    w = rect.right - rect.left;
    h = rect.bottom - rect.top;
Alexandre Julliard's avatar
Alexandre Julliard committed
287

288 289
    PSDRV_WriteSpool(dev, "%Ellipse\n", 9);
    PSDRV_SetPen(dev);
290

291 292 293 294 295 296 297
    PSDRV_SetClip(dev);
    PSDRV_WriteNewPath(dev);
    PSDRV_WriteArc(dev, x, y, w, h, 0.0, 360.0);
    PSDRV_WriteClosePath(dev);
    PSDRV_Brush(dev,0);
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
Alexandre Julliard's avatar
Alexandre Julliard committed
298 299
    return TRUE;
}
Alexandre Julliard's avatar
Alexandre Julliard committed
300 301 302


/***********************************************************************
303
 *           PSDRV_PolyPolyline
Alexandre Julliard's avatar
Alexandre Julliard committed
304
 */
305
BOOL CDECL PSDRV_PolyPolyline( PHYSDEV dev, const POINT* pts, const DWORD* counts, DWORD polylines )
Alexandre Julliard's avatar
Alexandre Julliard committed
306
{
307 308
    DWORD polyline, line, total;
    POINT *dev_pts, *pt;
309

310
    TRACE("\n");
311

312 313 314
    for (polyline = total = 0; polyline < polylines; polyline++) total += counts[polyline];
    if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
    memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
315
    LPtoDP( dev->hdc, dev_pts, total );
316 317

    pt = dev_pts;
318

319 320 321
    PSDRV_WriteSpool(dev, "%PolyPolyline\n",14);
    PSDRV_SetPen(dev);
    PSDRV_SetClip(dev);
322

323
    for(polyline = 0; polyline < polylines; polyline++) {
324
        PSDRV_WriteMoveTo(dev, pt->x, pt->y);
325
	pt++;
326
        for(line = 1; line < counts[polyline]; line++, pt++)
327
            PSDRV_WriteLineTo(dev, pt->x, pt->y);
328
    }
329
    HeapFree( GetProcessHeap(), 0, dev_pts );
330

331 332
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
Alexandre Julliard's avatar
Alexandre Julliard committed
333
    return TRUE;
334
}
335 336


Alexandre Julliard's avatar
Alexandre Julliard committed
337
/***********************************************************************
338
 *           PSDRV_PolyPolygon
Alexandre Julliard's avatar
Alexandre Julliard committed
339
 */
340
BOOL CDECL PSDRV_PolyPolygon( PHYSDEV dev, const POINT* pts, const INT* counts, UINT polygons )
Alexandre Julliard's avatar
Alexandre Julliard committed
341
{
342 343
    DWORD polygon, total;
    INT line;
344
    POINT *dev_pts, *pt;
345

346
    TRACE("\n");
Alexandre Julliard's avatar
Alexandre Julliard committed
347

348 349 350
    for (polygon = total = 0; polygon < polygons; polygon++) total += counts[polygon];
    if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
    memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
351
    LPtoDP( dev->hdc, dev_pts, total );
352 353

    pt = dev_pts;
354

355 356 357
    PSDRV_WriteSpool(dev, "%PolyPolygon\n",13);
    PSDRV_SetPen(dev);
    PSDRV_SetClip(dev);
358

359
    for(polygon = 0; polygon < polygons; polygon++) {
360
        PSDRV_WriteMoveTo(dev, pt->x, pt->y);
361
	pt++;
362
        for(line = 1; line < counts[polygon]; line++, pt++)
363 364
            PSDRV_WriteLineTo(dev, pt->x, pt->y);
	PSDRV_WriteClosePath(dev);
365
    }
366
    HeapFree( GetProcessHeap(), 0, dev_pts );
Alexandre Julliard's avatar
Alexandre Julliard committed
367

368 369
    if(GetPolyFillMode( dev->hdc ) == ALTERNATE)
        PSDRV_Brush(dev, 1);
370
    else /* WINDING */
371
        PSDRV_Brush(dev, 0);
372

373 374
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
Alexandre Julliard's avatar
Alexandre Julliard committed
375 376 377
    return TRUE;
}

378

379 380 381
/***********************************************************************
 *           PSDRV_PolyBezier
 */
382
BOOL CDECL PSDRV_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD count )
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
{
    DWORD i;
    POINT *dev_pts;

    TRACE("\n");

    if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
    memcpy( dev_pts, pts, count * sizeof(*dev_pts) );
    LPtoDP( dev->hdc, dev_pts, count );

    PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
    PSDRV_SetPen(dev);
    PSDRV_SetClip(dev);
    PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
    for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
    HeapFree( GetProcessHeap(), 0, dev_pts );
    return TRUE;
}


/***********************************************************************
 *           PSDRV_PolyBezierTo
 */
408
BOOL CDECL PSDRV_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD count )
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
{
    DWORD i;
    POINT *dev_pts;

    TRACE("\n");

    count++;  /* add initial position */
    if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dev_pts) ))) return FALSE;
    GetCurrentPositionEx( dev->hdc, dev_pts );
    memcpy( dev_pts + 1, pts, (count - 1) * sizeof(*dev_pts) );
    LPtoDP( dev->hdc, dev_pts, count );

    PSDRV_WriteSpool(dev, "%PolyBezier\n",12);
    PSDRV_SetPen(dev);
    PSDRV_SetClip(dev);
    PSDRV_WriteMoveTo(dev, dev_pts[0].x, dev_pts[0].y );
    for (i = 1; i < count; i += 3) PSDRV_WriteCurveTo( dev, dev_pts + i );
    PSDRV_DrawLine(dev);
    PSDRV_ResetClip(dev);
    HeapFree( GetProcessHeap(), 0, dev_pts );
    return TRUE;
}


433 434 435
/***********************************************************************
 *           PSDRV_SetPixel
 */
436
COLORREF CDECL PSDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
437 438
{
    PSCOLOR pscolor;
439
    POINT pt;
440

441 442
    pt.x = x;
    pt.y = y;
443
    LPtoDP( dev->hdc, &pt, 1 );
444

445
    PSDRV_SetClip(dev);
446 447
    /* we bracket the setcolor in gsave/grestore so that we don't trash
       the current pen colour */
448 449 450 451 452 453 454
    PSDRV_WriteGSave(dev);
    PSDRV_WriteRectangle( dev, pt.x, pt.y, 0, 0 );
    PSDRV_CreateColor( dev, &pscolor, color );
    PSDRV_WriteSetColor( dev, &pscolor );
    PSDRV_WriteFill( dev );
    PSDRV_WriteGRestore(dev);
    PSDRV_ResetClip(dev);
455 456
    return color;
}
457 458 459 460

/***********************************************************************
 *           PSDRV_PaintRgn
 */
461
BOOL CDECL PSDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
462 463 464 465 466
{
    RGNDATA *rgndata = NULL;
    RECT *pRect;
    DWORD size, i;

467
    TRACE("hdc=%p\n", dev->hdc);
468 469 470 471 472 473 474 475 476 477 478 479

    size = GetRegionData(hrgn, 0, NULL);
    rgndata = HeapAlloc( GetProcessHeap(), 0, size );
    if(!rgndata) {
        ERR("Can't allocate buffer\n");
        return FALSE;
    }
    
    GetRegionData(hrgn, size, rgndata);
    if (rgndata->rdh.nCount == 0)
        goto end;

480
    LPtoDP(dev->hdc, (POINT*)rgndata->Buffer, rgndata->rdh.nCount * 2);
481

482
    PSDRV_SetClip(dev);
483
    for(i = 0, pRect = (RECT*)rgndata->Buffer; i < rgndata->rdh.nCount; i++, pRect++)
484
        PSDRV_WriteRectangle(dev, pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
485

486
    PSDRV_Brush(dev, 0);
487
    PSDRV_WriteNewPath(dev);
488
    PSDRV_ResetClip(dev);
489 490 491 492 493

 end:
    HeapFree(GetProcessHeap(), 0, rgndata);
    return TRUE;
}
494 495 496 497 498 499 500 501 502

static BOOL paint_path( PHYSDEV dev, BOOL stroke, BOOL fill )
{
    POINT *points;
    BYTE *types;
    BOOL ret = FALSE;
    int i, size = GetPath( dev->hdc, NULL, NULL, 0 );

    if (size == -1) return FALSE;
503 504 505 506 507
    if (!size)
    {
        AbortPath( dev->hdc );
        return TRUE;
    }
508 509 510 511
    points = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*points) );
    types = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*types) );
    if (!points || !types) goto done;
    if (GetPath( dev->hdc, points, types, size ) == -1) goto done;
512
    LPtoDP( dev->hdc, points, size );
513

514
    if (stroke) PSDRV_SetPen(dev);
515 516 517
    PSDRV_SetClip(dev);
    for (i = 0; i < size; i++)
    {
518
        switch (types[i])
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
        {
        case PT_MOVETO:
            PSDRV_WriteMoveTo( dev, points[i].x, points[i].y );
            break;
        case PT_LINETO:
        case PT_LINETO | PT_CLOSEFIGURE:
            PSDRV_WriteLineTo( dev, points[i].x, points[i].y );
            if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
            break;
        case PT_BEZIERTO:
        case PT_BEZIERTO | PT_CLOSEFIGURE:
            PSDRV_WriteCurveTo( dev, points + i );
            if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
            i += 2;
            break;
        }
    }
    if (fill) PSDRV_Brush( dev, GetPolyFillMode(dev->hdc) == ALTERNATE );
    if (stroke) PSDRV_DrawLine(dev);
    else PSDRV_WriteNewPath(dev);
    PSDRV_ResetClip(dev);
540
    AbortPath( dev->hdc );
541 542 543 544 545 546 547 548 549 550

done:
    HeapFree( GetProcessHeap(), 0, points );
    HeapFree( GetProcessHeap(), 0, types );
    return ret;
}

/***********************************************************************
 *           PSDRV_FillPath
 */
551
BOOL CDECL PSDRV_FillPath( PHYSDEV dev )
552 553 554 555 556 557 558
{
    return paint_path( dev, FALSE, TRUE );
}

/***********************************************************************
 *           PSDRV_StrokeAndFillPath
 */
559
BOOL CDECL PSDRV_StrokeAndFillPath( PHYSDEV dev )
560 561 562 563 564 565 566
{
    return paint_path( dev, TRUE, TRUE );
}

/***********************************************************************
 *           PSDRV_StrokePath
 */
567
BOOL CDECL PSDRV_StrokePath( PHYSDEV dev )
568 569 570
{
    return paint_path( dev, TRUE, FALSE );
}