git.oblomov.eu Git - wine/blob - dlls/gdi32/path.c

   1 /*
   2  * Graphics paths (BeginPath, EndPath etc.)
   3  *
   4  * Copyright 1997, 1998 Martin Boehme
   5  *                 1999 Huw D M Davies
   6  * Copyright 2005 Dmitry Timoshkov
   7  * Copyright 2011 Alexandre Julliard
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <assert.h>
  28 #include <math.h>
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #if defined(HAVE_FLOAT_H)
  33 #include <float.h>
  34 #endif
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wingdi.h"
  39 #include "winerror.h"
  40
  41 #include "gdi_private.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  45
  46 /* Notes on the implementation
  47  *
  48  * The implementation is based on dynamically resizable arrays of points and
  49  * flags. I dithered for a bit before deciding on this implementation, and
  50  * I had even done a bit of work on a linked list version before switching
  51  * to arrays. It's a bit of a tradeoff. When you use linked lists, the
  52  * implementation of FlattenPath is easier, because you can rip the
  53  * PT_BEZIERTO entries out of the middle of the list and link the
  54  * corresponding PT_LINETO entries in. However, when you use arrays,
  55  * PathToRegion becomes easier, since you can essentially just pass your array
  56  * of points to CreatePolyPolygonRgn. Also, if I'd used linked lists, I would
  57  * have had the extra effort of creating a chunk-based allocation scheme
  58  * in order to use memory effectively. That's why I finally decided to use
  59  * arrays. Note by the way that the array based implementation has the same
  60  * linear time complexity that linked lists would have since the arrays grow
  61  * exponentially.
  62  *
  63  * The points are stored in the path in device coordinates. This is
  64  * consistent with the way Windows does things (for instance, see the Win32
  65  * SDK documentation for GetPath).
  66  *
  67  * The word "stroke" appears in several places (e.g. in the flag
  68  * GdiPath.newStroke). A stroke consists of a PT_MOVETO followed by one or
  69  * more PT_LINETOs or PT_BEZIERTOs, up to, but not including, the next
  70  * PT_MOVETO. Note that this is not the same as the definition of a figure;
  71  * a figure can contain several strokes.
  72  *
  73  * Martin Boehme
  74  */
  75
  76 #define NUM_ENTRIES_INITIAL 16  /* Initial size of points / flags arrays  */
  77
  78 /* A floating point version of the POINT structure */
  79 typedef struct tagFLOAT_POINT
  80 {
  81    double x, y;
  82 } FLOAT_POINT;
  83
  84 struct gdi_path
  85 {
  86     POINT       *points;
  87     BYTE        *flags;
  88     int          count;
  89     int          allocated;
  90     BOOL         newStroke;
  91 };
  92
  93 struct path_physdev
  94 {
  95     struct gdi_physdev dev;
  96     struct gdi_path   *path;
  97 };
  98
  99 static inline struct path_physdev *get_path_physdev( PHYSDEV dev )
 100 {
 101     return (struct path_physdev *)dev;
 102 }
 103
 104 static inline void pop_path_driver( DC *dc, struct path_physdev *physdev )
 105 {
 106     pop_dc_driver( dc, &physdev->dev );
 107     HeapFree( GetProcessHeap(), 0, physdev );
 108 }
 109
 110 static inline struct path_physdev *find_path_physdev( DC *dc )
 111 {
 112     PHYSDEV dev;
 113
 114     for (dev = dc->physDev; dev->funcs != &null_driver; dev = dev->next)
 115         if (dev->funcs == &path_driver) return get_path_physdev( dev );
 116     return NULL;
 117 }
 118
 119 void free_gdi_path( struct gdi_path *path )
 120 {
 121     HeapFree( GetProcessHeap(), 0, path->points );
 122     HeapFree( GetProcessHeap(), 0, path->flags );
 123     HeapFree( GetProcessHeap(), 0, path );
 124 }
 125
 126 static struct gdi_path *alloc_gdi_path( int count )
 127 {
 128     struct gdi_path *path = HeapAlloc( GetProcessHeap(), 0, sizeof(*path) );
 129
 130     if (!path)
 131     {
 132         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 133         return NULL;
 134     }
 135     count = max( NUM_ENTRIES_INITIAL, count );
 136     path->points = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*path->points) );
 137     path->flags = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*path->flags) );
 138     if (!path->points || !path->flags)
 139     {
 140         free_gdi_path( path );
 141         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 142         return NULL;
 143     }
 144     path->count = 0;
 145     path->allocated = count;
 146     path->newStroke = TRUE;
 147     return path;
 148 }
 149
 150 static struct gdi_path *copy_gdi_path( const struct gdi_path *src_path )
 151 {
 152     struct gdi_path *path = HeapAlloc( GetProcessHeap(), 0, sizeof(*path) );
 153
 154     if (!path)
 155     {
 156         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 157         return NULL;
 158     }
 159     path->count = path->allocated = src_path->count;
 160     path->newStroke = src_path->newStroke;
 161     path->points = HeapAlloc( GetProcessHeap(), 0, path->count * sizeof(*path->points) );
 162     path->flags = HeapAlloc( GetProcessHeap(), 0, path->count * sizeof(*path->flags) );
 163     if (!path->points || !path->flags)
 164     {
 165         free_gdi_path( path );
 166         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 167         return NULL;
 168     }
 169     memcpy( path->points, src_path->points, path->count * sizeof(*path->points) );
 170     memcpy( path->flags, src_path->flags, path->count * sizeof(*path->flags) );
 171     return path;
 172 }
 173
 174 /* Performs a world-to-viewport transformation on the specified point (which
 175  * is in floating point format).
 176  */
 177 static inline void INTERNAL_LPTODP_FLOAT( HDC hdc, FLOAT_POINT *point, int count )
 178 {
 179     DC *dc = get_dc_ptr( hdc );
 180     double x, y;
 181
 182     while (count--)
 183     {
 184         x = point->x;
 185         y = point->y;
 186         point->x = x * dc->xformWorld2Vport.eM11 + y * dc->xformWorld2Vport.eM21 + dc->xformWorld2Vport.eDx;
 187         point->y = x * dc->xformWorld2Vport.eM12 + y * dc->xformWorld2Vport.eM22 + dc->xformWorld2Vport.eDy;
 188         point++;
 189     }
 190     release_dc_ptr( dc );
 191 }
 192
 193 static inline INT int_from_fixed(FIXED f)
 194 {
 195     return (f.fract >= 0x8000) ? (f.value + 1) : f.value;
 196 }
 197
 198
 199 /* PATH_ReserveEntries
 200  *
 201  * Ensures that at least "numEntries" entries (for points and flags) have
 202  * been allocated; allocates larger arrays and copies the existing entries
 203  * to those arrays, if necessary. Returns TRUE if successful, else FALSE.
 204  */
 205 static BOOL PATH_ReserveEntries(struct gdi_path *pPath, INT count)
 206 {
 207     POINT *pPointsNew;
 208     BYTE    *pFlagsNew;
 209
 210     assert(count>=0);
 211
 212     /* Do we have to allocate more memory? */
 213     if(count > pPath->allocated)
 214     {
 215         /* Find number of entries to allocate. We let the size of the array
 216          * grow exponentially, since that will guarantee linear time
 217          * complexity. */
 218         count = max( pPath->allocated * 2, count );
 219
 220         pPointsNew = HeapReAlloc( GetProcessHeap(), 0, pPath->points, count * sizeof(POINT) );
 221         if (!pPointsNew) return FALSE;
 222         pPath->points = pPointsNew;
 223
 224         pFlagsNew = HeapReAlloc( GetProcessHeap(), 0, pPath->flags, count * sizeof(BYTE) );
 225         if (!pFlagsNew) return FALSE;
 226         pPath->flags = pFlagsNew;
 227
 228         pPath->allocated = count;
 229     }
 230     return TRUE;
 231 }
 232
 233 /* PATH_AddEntry
 234  *
 235  * Adds an entry to the path. For "flags", pass either PT_MOVETO, PT_LINETO
 236  * or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
 237  * successful, FALSE otherwise (e.g. if not enough memory was available).
 238  */
 239 static BOOL PATH_AddEntry(struct gdi_path *pPath, const POINT *pPoint, BYTE flags)
 240 {
 241     /* FIXME: If newStroke is true, perhaps we want to check that we're
 242      * getting a PT_MOVETO
 243      */
 244     TRACE("(%d,%d) - %d\n", pPoint->x, pPoint->y, flags);
 245
 246     /* Reserve enough memory for an extra path entry */
 247     if(!PATH_ReserveEntries(pPath, pPath->count+1))
 248         return FALSE;
 249
 250     /* Store information in path entry */
 251     pPath->points[pPath->count]=*pPoint;
 252     pPath->flags[pPath->count]=flags;
 253
 254     pPath->count++;
 255
 256     return TRUE;
 257 }
 258
 259 /* add a number of points, converting them to device coords */
 260 /* return a pointer to the first type byte so it can be fixed up if necessary */
 261 static BYTE *add_log_points( struct path_physdev *physdev, const POINT *points, DWORD count, BYTE type )
 262 {
 263     BYTE *ret;
 264     struct gdi_path *path = physdev->path;
 265
 266     if (!PATH_ReserveEntries( path, path->count + count )) return NULL;
 267
 268     ret = &path->flags[path->count];
 269     memcpy( &path->points[path->count], points, count * sizeof(*points) );
 270     LPtoDP( physdev->dev.hdc, &path->points[path->count], count );
 271     memset( ret, type, count );
 272     path->count += count;
 273     return ret;
 274 }
 275
 276 /* start a new path stroke if necessary */
 277 static BOOL start_new_stroke( struct path_physdev *physdev )
 278 {
 279     POINT pos;
 280     struct gdi_path *path = physdev->path;
 281
 282     if (!path->newStroke && path->count &&
 283         !(path->flags[path->count - 1] & PT_CLOSEFIGURE))
 284         return TRUE;
 285
 286     path->newStroke = FALSE;
 287     GetCurrentPositionEx( physdev->dev.hdc, &pos );
 288     return add_log_points( physdev, &pos, 1, PT_MOVETO ) != NULL;
 289 }
 290
 291 /* PATH_CheckCorners
 292  *
 293  * Helper function for RoundRect() and Rectangle()
 294  */
 295 static void PATH_CheckCorners( HDC hdc, POINT corners[], INT x1, INT y1, INT x2, INT y2 )
 296 {
 297     INT temp;
 298
 299     /* Convert points to device coordinates */
 300     corners[0].x=x1;
 301     corners[0].y=y1;
 302     corners[1].x=x2;
 303     corners[1].y=y2;
 304     LPtoDP( hdc, corners, 2 );
 305
 306     /* Make sure first corner is top left and second corner is bottom right */
 307     if(corners[0].x>corners[1].x)
 308     {
 309         temp=corners[0].x;
 310         corners[0].x=corners[1].x;
 311         corners[1].x=temp;
 312     }
 313     if(corners[0].y>corners[1].y)
 314     {
 315         temp=corners[0].y;
 316         corners[0].y=corners[1].y;
 317         corners[1].y=temp;
 318     }
 319
 320     /* In GM_COMPATIBLE, don't include bottom and right edges */
 321     if (GetGraphicsMode( hdc ) == GM_COMPATIBLE)
 322     {
 323         corners[1].x--;
 324         corners[1].y--;
 325     }
 326 }
 327
 328 /* PATH_AddFlatBezier
 329  */
 330 static BOOL PATH_AddFlatBezier(struct gdi_path *pPath, POINT *pt, BOOL closed)
 331 {
 332     POINT *pts;
 333     INT no, i;
 334
 335     pts = GDI_Bezier( pt, 4, &no );
 336     if(!pts) return FALSE;
 337
 338     for(i = 1; i < no; i++)
 339         PATH_AddEntry(pPath, &pts[i], (i == no-1 && closed) ? PT_LINETO | PT_CLOSEFIGURE : PT_LINETO);
 340     HeapFree( GetProcessHeap(), 0, pts );
 341     return TRUE;
 342 }
 343
 344 /* PATH_FlattenPath
 345  *
 346  * Replaces Beziers with line segments
 347  *
 348  */
 349 static struct gdi_path *PATH_FlattenPath(const struct gdi_path *pPath)
 350 {
 351     struct gdi_path *new_path;
 352     INT srcpt;
 353
 354     if (!(new_path = alloc_gdi_path( pPath->count ))) return NULL;
 355
 356     for(srcpt = 0; srcpt < pPath->count; srcpt++) {
 357         switch(pPath->flags[srcpt] & ~PT_CLOSEFIGURE) {
 358         case PT_MOVETO:
 359         case PT_LINETO:
 360             if (!PATH_AddEntry(new_path, &pPath->points[srcpt], pPath->flags[srcpt]))
 361             {
 362                 free_gdi_path( new_path );
 363                 return NULL;
 364             }
 365             break;
 366         case PT_BEZIERTO:
 367             if (!PATH_AddFlatBezier(new_path, &pPath->points[srcpt-1],
 368                                     pPath->flags[srcpt+2] & PT_CLOSEFIGURE))
 369             {
 370                 free_gdi_path( new_path );
 371                 return NULL;
 372             }
 373             srcpt += 2;
 374             break;
 375         }
 376     }
 377     return new_path;
 378 }
 379
 380 /* PATH_PathToRegion
 381  *
 382  * Creates a region from the specified path using the specified polygon
 383  * filling mode. The path is left unchanged.
 384  */
 385 static HRGN PATH_PathToRegion(const struct gdi_path *pPath, INT nPolyFillMode)
 386 {
 387     struct gdi_path *rgn_path;
 388     int    numStrokes, iStroke, i;
 389     INT  *pNumPointsInStroke;
 390     HRGN hrgn;
 391
 392     if (!(rgn_path = PATH_FlattenPath( pPath ))) return 0;
 393
 394     /* FIXME: What happens when number of points is zero? */
 395
 396     /* First pass: Find out how many strokes there are in the path */
 397     /* FIXME: We could eliminate this with some bookkeeping in GdiPath */
 398     numStrokes=0;
 399     for(i=0; i<rgn_path->count; i++)
 400         if((rgn_path->flags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
 401             numStrokes++;
 402
 403     /* Allocate memory for number-of-points-in-stroke array */
 404     pNumPointsInStroke=HeapAlloc( GetProcessHeap(), 0, sizeof(int) * numStrokes );
 405     if(!pNumPointsInStroke)
 406     {
 407         free_gdi_path( rgn_path );
 408         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 409         return 0;
 410     }
 411
 412     /* Second pass: remember number of points in each polygon */
 413     iStroke=-1;  /* Will get incremented to 0 at beginning of first stroke */
 414     for(i=0; i<rgn_path->count; i++)
 415     {
 416         /* Is this the beginning of a new stroke? */
 417         if((rgn_path->flags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
 418         {
 419             iStroke++;
 420             pNumPointsInStroke[iStroke]=0;
 421         }
 422
 423         pNumPointsInStroke[iStroke]++;
 424     }
 425
 426     /* Create a region from the strokes */
 427     hrgn=CreatePolyPolygonRgn(rgn_path->points, pNumPointsInStroke,
 428                               numStrokes, nPolyFillMode);
 429
 430     HeapFree( GetProcessHeap(), 0, pNumPointsInStroke );
 431     free_gdi_path( rgn_path );
 432     return hrgn;
 433 }
 434
 435 /* PATH_ScaleNormalizedPoint
 436  *
 437  * Scales a normalized point (x, y) with respect to the box whose corners are
 438  * passed in "corners". The point is stored in "*pPoint". The normalized
 439  * coordinates (-1.0, -1.0) correspond to corners[0], the coordinates
 440  * (1.0, 1.0) correspond to corners[1].
 441  */
 442 static void PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
 443    double y, POINT *pPoint)
 444 {
 445     pPoint->x=GDI_ROUND( (double)corners[0].x + (double)(corners[1].x-corners[0].x)*0.5*(x+1.0) );
 446     pPoint->y=GDI_ROUND( (double)corners[0].y + (double)(corners[1].y-corners[0].y)*0.5*(y+1.0) );
 447 }
 448
 449 /* PATH_NormalizePoint
 450  *
 451  * Normalizes a point with respect to the box whose corners are passed in
 452  * "corners". The normalized coordinates are stored in "*pX" and "*pY".
 453  */
 454 static void PATH_NormalizePoint(FLOAT_POINT corners[],
 455    const FLOAT_POINT *pPoint,
 456    double *pX, double *pY)
 457 {
 458     *pX=(double)(pPoint->x-corners[0].x)/(double)(corners[1].x-corners[0].x) * 2.0 - 1.0;
 459     *pY=(double)(pPoint->y-corners[0].y)/(double)(corners[1].y-corners[0].y) * 2.0 - 1.0;
 460 }
 461
 462 /* PATH_DoArcPart
 463  *
 464  * Creates a Bezier spline that corresponds to part of an arc and appends the
 465  * corresponding points to the path. The start and end angles are passed in
 466  * "angleStart" and "angleEnd"; these angles should span a quarter circle
 467  * at most. If "startEntryType" is non-zero, an entry of that type for the first
 468  * control point is added to the path; otherwise, it is assumed that the current
 469  * position is equal to the first control point.
 470  */
 471 static BOOL PATH_DoArcPart(struct gdi_path *pPath, FLOAT_POINT corners[],
 472    double angleStart, double angleEnd, BYTE startEntryType)
 473 {
 474     double  halfAngle, a;
 475     double  xNorm[4], yNorm[4];
 476     POINT point;
 477     int     i;
 478
 479     assert(fabs(angleEnd-angleStart)<=M_PI_2);
 480
 481     /* FIXME: Is there an easier way of computing this? */
 482
 483     /* Compute control points */
 484     halfAngle=(angleEnd-angleStart)/2.0;
 485     if(fabs(halfAngle)>1e-8)
 486     {
 487         a=4.0/3.0*(1-cos(halfAngle))/sin(halfAngle);
 488         xNorm[0]=cos(angleStart);
 489         yNorm[0]=sin(angleStart);
 490         xNorm[1]=xNorm[0] - a*yNorm[0];
 491         yNorm[1]=yNorm[0] + a*xNorm[0];
 492         xNorm[3]=cos(angleEnd);
 493         yNorm[3]=sin(angleEnd);
 494         xNorm[2]=xNorm[3] + a*yNorm[3];
 495         yNorm[2]=yNorm[3] - a*xNorm[3];
 496     }
 497     else
 498         for(i=0; i<4; i++)
 499         {
 500             xNorm[i]=cos(angleStart);
 501             yNorm[i]=sin(angleStart);
 502         }
 503
 504     /* Add starting point to path if desired */
 505     if(startEntryType)
 506     {
 507         PATH_ScaleNormalizedPoint(corners, xNorm[0], yNorm[0], &point);
 508         if(!PATH_AddEntry(pPath, &point, startEntryType))
 509             return FALSE;
 510     }
 511
 512     /* Add remaining control points */
 513     for(i=1; i<4; i++)
 514     {
 515         PATH_ScaleNormalizedPoint(corners, xNorm[i], yNorm[i], &point);
 516         if(!PATH_AddEntry(pPath, &point, PT_BEZIERTO))
 517             return FALSE;
 518     }
 519
 520     return TRUE;
 521 }
 522
 523
 524 /***********************************************************************
 525  *           BeginPath    (GDI32.@)
 526  */
 527 BOOL WINAPI BeginPath(HDC hdc)
 528 {
 529     BOOL ret = FALSE;
 530     DC *dc = get_dc_ptr( hdc );
 531
 532     if (dc)
 533     {
 534         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pBeginPath );
 535         ret = physdev->funcs->pBeginPath( physdev );
 536         release_dc_ptr( dc );
 537     }
 538     return ret;
 539 }
 540
 541
 542 /***********************************************************************
 543  *           EndPath    (GDI32.@)
 544  */
 545 BOOL WINAPI EndPath(HDC hdc)
 546 {
 547     BOOL ret = FALSE;
 548     DC *dc = get_dc_ptr( hdc );
 549
 550     if (dc)
 551     {
 552         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEndPath );
 553         ret = physdev->funcs->pEndPath( physdev );
 554         release_dc_ptr( dc );
 555     }
 556     return ret;
 557 }
 558
 559
 560 /******************************************************************************
 561  * AbortPath [GDI32.@]
 562  * Closes and discards paths from device context
 563  *
 564  * NOTES
 565  *    Check that SetLastError is being called correctly
 566  *
 567  * PARAMS
 568  *    hdc [I] Handle to device context
 569  *
 570  * RETURNS
 571  *    Success: TRUE
 572  *    Failure: FALSE
 573  */
 574 BOOL WINAPI AbortPath( HDC hdc )
 575 {
 576     BOOL ret = FALSE;
 577     DC *dc = get_dc_ptr( hdc );
 578
 579     if (dc)
 580     {
 581         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pAbortPath );
 582         ret = physdev->funcs->pAbortPath( physdev );
 583         release_dc_ptr( dc );
 584     }
 585     return ret;
 586 }
 587
 588
 589 /***********************************************************************
 590  *           CloseFigure    (GDI32.@)
 591  *
 592  * FIXME: Check that SetLastError is being called correctly
 593  */
 594 BOOL WINAPI CloseFigure(HDC hdc)
 595 {
 596     BOOL ret = FALSE;
 597     DC *dc = get_dc_ptr( hdc );
 598
 599     if (dc)
 600     {
 601         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pCloseFigure );
 602         ret = physdev->funcs->pCloseFigure( physdev );
 603         release_dc_ptr( dc );
 604     }
 605     return ret;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           GetPath    (GDI32.@)
 611  */
 612 INT WINAPI GetPath(HDC hdc, LPPOINT pPoints, LPBYTE pTypes, INT nSize)
 613 {
 614    INT ret = -1;
 615    DC *dc = get_dc_ptr( hdc );
 616
 617    if(!dc) return -1;
 618
 619    if (!dc->path)
 620    {
 621       SetLastError(ERROR_CAN_NOT_COMPLETE);
 622       goto done;
 623    }
 624
 625    if(nSize==0)
 626       ret = dc->path->count;
 627    else if(nSize<dc->path->count)
 628    {
 629       SetLastError(ERROR_INVALID_PARAMETER);
 630       goto done;
 631    }
 632    else
 633    {
 634       memcpy(pPoints, dc->path->points, sizeof(POINT)*dc->path->count);
 635       memcpy(pTypes, dc->path->flags, sizeof(BYTE)*dc->path->count);
 636
 637       /* Convert the points to logical coordinates */
 638       if(!DPtoLP(hdc, pPoints, dc->path->count))
 639       {
 640          /* FIXME: Is this the correct value? */
 641          SetLastError(ERROR_CAN_NOT_COMPLETE);
 642         goto done;
 643       }
 644      else ret = dc->path->count;
 645    }
 646  done:
 647    release_dc_ptr( dc );
 648    return ret;
 649 }
 650
 651
 652 /***********************************************************************
 653  *           PathToRegion    (GDI32.@)
 654  *
 655  * FIXME
 656  *   Check that SetLastError is being called correctly
 657  *
 658  * The documentation does not state this explicitly, but a test under Windows
 659  * shows that the region which is returned should be in device coordinates.
 660  */
 661 HRGN WINAPI PathToRegion(HDC hdc)
 662 {
 663    HRGN  hrgnRval = 0;
 664    DC *dc = get_dc_ptr( hdc );
 665
 666    /* Get pointer to path */
 667    if(!dc) return 0;
 668
 669    if (!dc->path) SetLastError(ERROR_CAN_NOT_COMPLETE);
 670    else
 671    {
 672        if ((hrgnRval = PATH_PathToRegion(dc->path, GetPolyFillMode(hdc))))
 673        {
 674            /* FIXME: Should we empty the path even if conversion failed? */
 675            free_gdi_path( dc->path );
 676            dc->path = NULL;
 677        }
 678    }
 679    release_dc_ptr( dc );
 680    return hrgnRval;
 681 }
 682
 683 static BOOL PATH_FillPath( HDC hdc, const struct gdi_path *pPath )
 684 {
 685    INT   mapMode, graphicsMode;
 686    SIZE  ptViewportExt, ptWindowExt;
 687    POINT ptViewportOrg, ptWindowOrg;
 688    XFORM xform;
 689    HRGN  hrgn;
 690
 691    /* Construct a region from the path and fill it */
 692    if ((hrgn = PATH_PathToRegion(pPath, GetPolyFillMode(hdc))))
 693    {
 694       /* Since PaintRgn interprets the region as being in logical coordinates
 695        * but the points we store for the path are already in device
 696        * coordinates, we have to set the mapping mode to MM_TEXT temporarily.
 697        * Using SaveDC to save information about the mapping mode / world
 698        * transform would be easier but would require more overhead, especially
 699        * now that SaveDC saves the current path.
 700        */
 701
 702       /* Save the information about the old mapping mode */
 703       mapMode=GetMapMode(hdc);
 704       GetViewportExtEx(hdc, &ptViewportExt);
 705       GetViewportOrgEx(hdc, &ptViewportOrg);
 706       GetWindowExtEx(hdc, &ptWindowExt);
 707       GetWindowOrgEx(hdc, &ptWindowOrg);
 708
 709       /* Save world transform
 710        * NB: The Windows documentation on world transforms would lead one to
 711        * believe that this has to be done only in GM_ADVANCED; however, my
 712        * tests show that resetting the graphics mode to GM_COMPATIBLE does
 713        * not reset the world transform.
 714        */
 715       GetWorldTransform(hdc, &xform);
 716
 717       /* Set MM_TEXT */
 718       SetMapMode(hdc, MM_TEXT);
 719       SetViewportOrgEx(hdc, 0, 0, NULL);
 720       SetWindowOrgEx(hdc, 0, 0, NULL);
 721       graphicsMode=GetGraphicsMode(hdc);
 722       SetGraphicsMode(hdc, GM_ADVANCED);
 723       ModifyWorldTransform(hdc, &xform, MWT_IDENTITY);
 724       SetGraphicsMode(hdc, graphicsMode);
 725
 726       /* Paint the region */
 727       PaintRgn(hdc, hrgn);
 728       DeleteObject(hrgn);
 729       /* Restore the old mapping mode */
 730       SetMapMode(hdc, mapMode);
 731       SetViewportExtEx(hdc, ptViewportExt.cx, ptViewportExt.cy, NULL);
 732       SetViewportOrgEx(hdc, ptViewportOrg.x, ptViewportOrg.y, NULL);
 733       SetWindowExtEx(hdc, ptWindowExt.cx, ptWindowExt.cy, NULL);
 734       SetWindowOrgEx(hdc, ptWindowOrg.x, ptWindowOrg.y, NULL);
 735
 736       /* Go to GM_ADVANCED temporarily to restore the world transform */
 737       graphicsMode=GetGraphicsMode(hdc);
 738       SetGraphicsMode(hdc, GM_ADVANCED);
 739       SetWorldTransform(hdc, &xform);
 740       SetGraphicsMode(hdc, graphicsMode);
 741       return TRUE;
 742    }
 743    return FALSE;
 744 }
 745
 746
 747 /***********************************************************************
 748  *           FillPath    (GDI32.@)
 749  *
 750  * FIXME
 751  *    Check that SetLastError is being called correctly
 752  */
 753 BOOL WINAPI FillPath(HDC hdc)
 754 {
 755     BOOL ret = FALSE;
 756     DC *dc = get_dc_ptr( hdc );
 757
 758     if (dc)
 759     {
 760         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pFillPath );
 761         ret = physdev->funcs->pFillPath( physdev );
 762         release_dc_ptr( dc );
 763     }
 764     return ret;
 765 }
 766
 767
 768 /***********************************************************************
 769  *           SelectClipPath    (GDI32.@)
 770  * FIXME
 771  *  Check that SetLastError is being called correctly
 772  */
 773 BOOL WINAPI SelectClipPath(HDC hdc, INT iMode)
 774 {
 775     BOOL ret = FALSE;
 776     DC *dc = get_dc_ptr( hdc );
 777
 778     if (dc)
 779     {
 780         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSelectClipPath );
 781         ret = physdev->funcs->pSelectClipPath( physdev, iMode );
 782         release_dc_ptr( dc );
 783     }
 784     return ret;
 785 }
 786
 787
 788 /***********************************************************************
 789  *           pathdrv_BeginPath
 790  */
 791 static BOOL pathdrv_BeginPath( PHYSDEV dev )
 792 {
 793     /* path already open, nothing to do */
 794     return TRUE;
 795 }
 796
 797
 798 /***********************************************************************
 799  *           pathdrv_AbortPath
 800  */
 801 static BOOL pathdrv_AbortPath( PHYSDEV dev )
 802 {
 803     struct path_physdev *physdev = get_path_physdev( dev );
 804     DC *dc = get_dc_ptr( dev->hdc );
 805
 806     if (!dc) return FALSE;
 807     free_gdi_path( physdev->path );
 808     pop_path_driver( dc, physdev );
 809     release_dc_ptr( dc );
 810     return TRUE;
 811 }
 812
 813
 814 /***********************************************************************
 815  *           pathdrv_EndPath
 816  */
 817 static BOOL pathdrv_EndPath( PHYSDEV dev )
 818 {
 819     struct path_physdev *physdev = get_path_physdev( dev );
 820     DC *dc = get_dc_ptr( dev->hdc );
 821
 822     if (!dc) return FALSE;
 823     dc->path = physdev->path;
 824     pop_path_driver( dc, physdev );
 825     release_dc_ptr( dc );
 826     return TRUE;
 827 }
 828
 829
 830 /***********************************************************************
 831  *           pathdrv_CreateDC
 832  */
 833 static BOOL pathdrv_CreateDC( PHYSDEV *dev, LPCWSTR driver, LPCWSTR device,
 834                               LPCWSTR output, const DEVMODEW *devmode )
 835 {
 836     struct path_physdev *physdev = HeapAlloc( GetProcessHeap(), 0, sizeof(*physdev) );
 837     DC *dc;
 838
 839     if (!physdev) return FALSE;
 840     dc = get_dc_ptr( (*dev)->hdc );
 841     push_dc_driver( dev, &physdev->dev, &path_driver );
 842     release_dc_ptr( dc );
 843     return TRUE;
 844 }
 845
 846
 847 /*************************************************************
 848  *           pathdrv_DeleteDC
 849  */
 850 static BOOL pathdrv_DeleteDC( PHYSDEV dev )
 851 {
 852     assert( 0 );  /* should never be called */
 853     return TRUE;
 854 }
 855
 856
 857 BOOL PATH_SavePath( DC *dst, DC *src )
 858 {
 859     struct path_physdev *physdev;
 860
 861     if (src->path)
 862     {
 863         if (!(dst->path = copy_gdi_path( src->path ))) return FALSE;
 864     }
 865     else if ((physdev = find_path_physdev( src )))
 866     {
 867         if (!(dst->path = copy_gdi_path( physdev->path ))) return FALSE;
 868         dst->path_open = TRUE;
 869     }
 870     else dst->path = NULL;
 871     return TRUE;
 872 }
 873
 874 BOOL PATH_RestorePath( DC *dst, DC *src )
 875 {
 876     struct path_physdev *physdev = find_path_physdev( dst );
 877
 878     if (src->path && src->path_open)
 879     {
 880         if (!physdev)
 881         {
 882             if (!path_driver.pCreateDC( &dst->physDev, NULL, NULL, NULL, NULL )) return FALSE;
 883             physdev = get_path_physdev( dst->physDev );
 884         }
 885         else free_gdi_path( physdev->path );
 886
 887         physdev->path = src->path;
 888         src->path_open = FALSE;
 889         src->path = NULL;
 890     }
 891     else if (physdev)
 892     {
 893         free_gdi_path( physdev->path );
 894         pop_path_driver( dst, physdev );
 895     }
 896     if (dst->path) free_gdi_path( dst->path );
 897     dst->path = src->path;
 898     src->path = NULL;
 899     return TRUE;
 900 }
 901
 902
 903 /*************************************************************
 904  *           pathdrv_MoveTo
 905  */
 906 static BOOL pathdrv_MoveTo( PHYSDEV dev, INT x, INT y )
 907 {
 908     struct path_physdev *physdev = get_path_physdev( dev );
 909     physdev->path->newStroke = TRUE;
 910     return TRUE;
 911 }
 912
 913
 914 /*************************************************************
 915  *           pathdrv_LineTo
 916  */
 917 static BOOL pathdrv_LineTo( PHYSDEV dev, INT x, INT y )
 918 {
 919     struct path_physdev *physdev = get_path_physdev( dev );
 920     POINT point;
 921
 922     if (!start_new_stroke( physdev )) return FALSE;
 923     point.x = x;
 924     point.y = y;
 925     return add_log_points( physdev, &point, 1, PT_LINETO ) != NULL;
 926 }
 927
 928
 929 /*************************************************************
 930  *           pathdrv_RoundRect
 931  *
 932  * FIXME: it adds the same entries to the path as windows does, but there
 933  * is an error in the bezier drawing code so that there are small pixel-size
 934  * gaps when the resulting path is drawn by StrokePath()
 935  */
 936 static BOOL pathdrv_RoundRect( PHYSDEV dev, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height )
 937 {
 938     struct path_physdev *physdev = get_path_physdev( dev );
 939     POINT corners[2], pointTemp;
 940     FLOAT_POINT ellCorners[2];
 941
 942     PATH_CheckCorners(dev->hdc,corners,x1,y1,x2,y2);
 943
 944    /* Add points to the roundrect path */
 945    ellCorners[0].x = corners[1].x-ell_width;
 946    ellCorners[0].y = corners[0].y;
 947    ellCorners[1].x = corners[1].x;
 948    ellCorners[1].y = corners[0].y+ell_height;
 949    if(!PATH_DoArcPart(physdev->path, ellCorners, 0, -M_PI_2, PT_MOVETO))
 950       return FALSE;
 951    pointTemp.x = corners[0].x+ell_width/2;
 952    pointTemp.y = corners[0].y;
 953    if(!PATH_AddEntry(physdev->path, &pointTemp, PT_LINETO))
 954       return FALSE;
 955    ellCorners[0].x = corners[0].x;
 956    ellCorners[1].x = corners[0].x+ell_width;
 957    if(!PATH_DoArcPart(physdev->path, ellCorners, -M_PI_2, -M_PI, FALSE))
 958       return FALSE;
 959    pointTemp.x = corners[0].x;
 960    pointTemp.y = corners[1].y-ell_height/2;
 961    if(!PATH_AddEntry(physdev->path, &pointTemp, PT_LINETO))
 962       return FALSE;
 963    ellCorners[0].y = corners[1].y-ell_height;
 964    ellCorners[1].y = corners[1].y;
 965    if(!PATH_DoArcPart(physdev->path, ellCorners, M_PI, M_PI_2, FALSE))
 966       return FALSE;
 967    pointTemp.x = corners[1].x-ell_width/2;
 968    pointTemp.y = corners[1].y;
 969    if(!PATH_AddEntry(physdev->path, &pointTemp, PT_LINETO))
 970       return FALSE;
 971    ellCorners[0].x = corners[1].x-ell_width;
 972    ellCorners[1].x = corners[1].x;
 973    if(!PATH_DoArcPart(physdev->path, ellCorners, M_PI_2, 0, FALSE))
 974       return FALSE;
 975
 976    /* Close the roundrect figure */
 977    return CloseFigure( dev->hdc );
 978 }
 979
 980
 981 /*************************************************************
 982  *           pathdrv_Rectangle
 983  */
 984 static BOOL pathdrv_Rectangle( PHYSDEV dev, INT x1, INT y1, INT x2, INT y2 )
 985 {
 986     struct path_physdev *physdev = get_path_physdev( dev );
 987     POINT corners[2], pointTemp;
 988
 989     PATH_CheckCorners(dev->hdc,corners,x1,y1,x2,y2);
 990
 991    /* Add four points to the path */
 992    pointTemp.x=corners[1].x;
 993    pointTemp.y=corners[0].y;
 994    if(!PATH_AddEntry(physdev->path, &pointTemp, PT_MOVETO))
 995       return FALSE;
 996    if(!PATH_AddEntry(physdev->path, corners, PT_LINETO))
 997       return FALSE;
 998    pointTemp.x=corners[0].x;
 999    pointTemp.y=corners[1].y;
1000    if(!PATH_AddEntry(physdev->path, &pointTemp, PT_LINETO))
1001       return FALSE;
1002    if(!PATH_AddEntry(physdev->path, corners+1, PT_LINETO))
1003       return FALSE;
1004
1005    /* Close the rectangle figure */
1006    return CloseFigure( dev->hdc );
1007 }
1008
1009
1010 /* PATH_Arc
1011  *
1012  * Should be called when a call to Arc is performed on a DC that has
1013  * an open path. This adds up to five Bezier splines representing the arc
1014  * to the path. When 'lines' is 1, we add 1 extra line to get a chord,
1015  * when 'lines' is 2, we add 2 extra lines to get a pie, and when 'lines' is
1016  * -1 we add 1 extra line from the current DC position to the starting position
1017  * of the arc before drawing the arc itself (arcto). Returns TRUE if successful,
1018  * else FALSE.
1019  */
1020 static BOOL PATH_Arc( PHYSDEV dev, INT x1, INT y1, INT x2, INT y2,
1021                       INT xStart, INT yStart, INT xEnd, INT yEnd, INT lines )
1022 {
1023     struct path_physdev *physdev = get_path_physdev( dev );
1024     double angleStart, angleEnd, angleStartQuadrant, angleEndQuadrant=0.0;
1025                /* Initialize angleEndQuadrant to silence gcc's warning */
1026     double x, y;
1027     FLOAT_POINT corners[2], pointStart, pointEnd;
1028     POINT centre;
1029     BOOL start, end;
1030     INT temp, direction = GetArcDirection(dev->hdc);
1031
1032    /* FIXME: Do we have to respect newStroke? */
1033
1034    /* Check for zero height / width */
1035    /* FIXME: Only in GM_COMPATIBLE? */
1036    if(x1==x2 || y1==y2)
1037       return TRUE;
1038
1039    /* Convert points to device coordinates */
1040    corners[0].x = x1;
1041    corners[0].y = y1;
1042    corners[1].x = x2;
1043    corners[1].y = y2;
1044    pointStart.x = xStart;
1045    pointStart.y = yStart;
1046    pointEnd.x = xEnd;
1047    pointEnd.y = yEnd;
1048    INTERNAL_LPTODP_FLOAT(dev->hdc, corners, 2);
1049    INTERNAL_LPTODP_FLOAT(dev->hdc, &pointStart, 1);
1050    INTERNAL_LPTODP_FLOAT(dev->hdc, &pointEnd, 1);
1051
1052    /* Make sure first corner is top left and second corner is bottom right */
1053    if(corners[0].x>corners[1].x)
1054    {
1055       temp=corners[0].x;
1056       corners[0].x=corners[1].x;
1057       corners[1].x=temp;
1058    }
1059    if(corners[0].y>corners[1].y)
1060    {
1061       temp=corners[0].y;
1062       corners[0].y=corners[1].y;
1063       corners[1].y=temp;
1064    }
1065
1066    /* Compute start and end angle */
1067    PATH_NormalizePoint(corners, &pointStart, &x, &y);
1068    angleStart=atan2(y, x);
1069    PATH_NormalizePoint(corners, &pointEnd, &x, &y);
1070    angleEnd=atan2(y, x);
1071
1072    /* Make sure the end angle is "on the right side" of the start angle */
1073    if (direction == AD_CLOCKWISE)
1074    {
1075       if(angleEnd<=angleStart)
1076       {
1077          angleEnd+=2*M_PI;
1078          assert(angleEnd>=angleStart);
1079       }
1080    }
1081    else
1082    {
1083       if(angleEnd>=angleStart)
1084       {
1085          angleEnd-=2*M_PI;
1086          assert(angleEnd<=angleStart);
1087       }
1088    }
1089
1090    /* In GM_COMPATIBLE, don't include bottom and right edges */
1091    if (GetGraphicsMode(dev->hdc) == GM_COMPATIBLE)
1092    {
1093       corners[1].x--;
1094       corners[1].y--;
1095    }
1096
1097    /* arcto: Add a PT_MOVETO only if this is the first entry in a stroke */
1098    if (lines==-1 && !start_new_stroke( physdev )) return FALSE;
1099
1100    /* Add the arc to the path with one Bezier spline per quadrant that the
1101     * arc spans */
1102    start=TRUE;
1103    end=FALSE;
1104    do
1105    {
1106       /* Determine the start and end angles for this quadrant */
1107       if(start)
1108       {
1109          angleStartQuadrant=angleStart;
1110          if (direction == AD_CLOCKWISE)
1111             angleEndQuadrant=(floor(angleStart/M_PI_2)+1.0)*M_PI_2;
1112          else
1113             angleEndQuadrant=(ceil(angleStart/M_PI_2)-1.0)*M_PI_2;
1114       }
1115       else
1116       {
1117          angleStartQuadrant=angleEndQuadrant;
1118          if (direction == AD_CLOCKWISE)
1119             angleEndQuadrant+=M_PI_2;
1120          else
1121             angleEndQuadrant-=M_PI_2;
1122       }
1123
1124       /* Have we reached the last part of the arc? */
1125       if((direction == AD_CLOCKWISE && angleEnd<angleEndQuadrant) ||
1126          (direction == AD_COUNTERCLOCKWISE && angleEnd>angleEndQuadrant))
1127       {
1128          /* Adjust the end angle for this quadrant */
1129          angleEndQuadrant=angleEnd;
1130          end=TRUE;
1131       }
1132
1133       /* Add the Bezier spline to the path */
1134       PATH_DoArcPart(physdev->path, corners, angleStartQuadrant, angleEndQuadrant,
1135          start ? (lines==-1 ? PT_LINETO : PT_MOVETO) : FALSE);
1136       start=FALSE;
1137    }  while(!end);
1138
1139    /* chord: close figure. pie: add line and close figure */
1140    if(lines==1)
1141    {
1142       return CloseFigure(dev->hdc);
1143    }
1144    else if(lines==2)
1145    {
1146       centre.x = (corners[0].x+corners[1].x)/2;
1147       centre.y = (corners[0].y+corners[1].y)/2;
1148       if(!PATH_AddEntry(physdev->path, &centre, PT_LINETO | PT_CLOSEFIGURE))
1149          return FALSE;
1150    }
1151
1152    return TRUE;
1153 }
1154
1155
1156 /*************************************************************
1157  *           pathdrv_AngleArc
1158  */
1159 static BOOL pathdrv_AngleArc( PHYSDEV dev, INT x, INT y, DWORD radius, FLOAT eStartAngle, FLOAT eSweepAngle)
1160 {
1161     INT x1, y1, x2, y2, arcdir;
1162     BOOL ret;
1163
1164     x1 = GDI_ROUND( x + cos(eStartAngle*M_PI/180) * radius );
1165     y1 = GDI_ROUND( y - sin(eStartAngle*M_PI/180) * radius );
1166     x2 = GDI_ROUND( x + cos((eStartAngle+eSweepAngle)*M_PI/180) * radius );
1167     y2 = GDI_ROUND( y - sin((eStartAngle+eSweepAngle)*M_PI/180) * radius );
1168     arcdir = SetArcDirection( dev->hdc, eSweepAngle >= 0 ? AD_COUNTERCLOCKWISE : AD_CLOCKWISE);
1169     ret = PATH_Arc( dev, x-radius, y-radius, x+radius, y+radius, x1, y1, x2, y2, -1 );
1170     SetArcDirection( dev->hdc, arcdir );
1171     return ret;
1172 }
1173
1174
1175 /*************************************************************
1176  *           pathdrv_Arc
1177  */
1178 static BOOL pathdrv_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
1179                          INT xstart, INT ystart, INT xend, INT yend )
1180 {
1181     return PATH_Arc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 0 );
1182 }
1183
1184
1185 /*************************************************************
1186  *           pathdrv_ArcTo
1187  */
1188 static BOOL pathdrv_ArcTo( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
1189                            INT xstart, INT ystart, INT xend, INT yend )
1190 {
1191     return PATH_Arc( dev, left, top, right, bottom, xstart, ystart, xend, yend, -1 );
1192 }
1193
1194
1195 /*************************************************************
1196  *           pathdrv_Chord
1197  */
1198 static BOOL pathdrv_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
1199                            INT xstart, INT ystart, INT xend, INT yend )
1200 {
1201     return PATH_Arc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 1);
1202 }
1203
1204
1205 /*************************************************************
1206  *           pathdrv_Pie
1207  */
1208 static BOOL pathdrv_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
1209                          INT xstart, INT ystart, INT xend, INT yend )
1210 {
1211     return PATH_Arc( dev, left, top, right, bottom, xstart, ystart, xend, yend, 2 );
1212 }
1213
1214
1215 /*************************************************************
1216  *           pathdrv_Ellipse
1217  */
1218 static BOOL pathdrv_Ellipse( PHYSDEV dev, INT x1, INT y1, INT x2, INT y2 )
1219 {
1220     return PATH_Arc( dev, x1, y1, x2, y2, x1, (y1+y2)/2, x1, (y1+y2)/2, 0 ) && CloseFigure( dev->hdc );
1221 }
1222
1223
1224 /*************************************************************
1225  *           pathdrv_PolyBezierTo
1226  */
1227 static BOOL pathdrv_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD cbPoints )
1228 {
1229     struct path_physdev *physdev = get_path_physdev( dev );
1230
1231     if (!start_new_stroke( physdev )) return FALSE;
1232     return add_log_points( physdev, pts, cbPoints, PT_BEZIERTO ) != NULL;
1233 }
1234
1235
1236 /*************************************************************
1237  *           pathdrv_PolyBezier
1238  */
1239 static BOOL pathdrv_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD cbPoints )
1240 {
1241     struct path_physdev *physdev = get_path_physdev( dev );
1242     BYTE *type = add_log_points( physdev, pts, cbPoints, PT_BEZIERTO );
1243
1244     if (!type) return FALSE;
1245     type[0] = PT_MOVETO;
1246     return TRUE;
1247 }
1248
1249
1250 /*************************************************************
1251  *           pathdrv_PolyDraw
1252  */
1253 static BOOL pathdrv_PolyDraw( PHYSDEV dev, const POINT *pts, const BYTE *types, DWORD cbPoints )
1254 {
1255     struct path_physdev *physdev = get_path_physdev( dev );
1256     POINT lastmove, orig_pos;
1257     INT i;
1258
1259     GetCurrentPositionEx( dev->hdc, &orig_pos );
1260     lastmove = orig_pos;
1261
1262     for(i = physdev->path->count - 1; i >= 0; i--){
1263         if(physdev->path->flags[i] == PT_MOVETO){
1264             lastmove = physdev->path->points[i];
1265             DPtoLP(dev->hdc, &lastmove, 1);
1266             break;
1267         }
1268     }
1269
1270     for(i = 0; i < cbPoints; i++)
1271     {
1272         switch (types[i])
1273         {
1274         case PT_MOVETO:
1275             MoveToEx( dev->hdc, pts[i].x, pts[i].y, NULL );
1276             break;
1277         case PT_LINETO:
1278         case PT_LINETO | PT_CLOSEFIGURE:
1279             LineTo( dev->hdc, pts[i].x, pts[i].y );
1280             break;
1281         case PT_BEZIERTO:
1282             if ((i + 2 < cbPoints) && (types[i + 1] == PT_BEZIERTO) &&
1283                 (types[i + 2] & ~PT_CLOSEFIGURE) == PT_BEZIERTO)
1284             {
1285                 PolyBezierTo( dev->hdc, &pts[i], 3 );
1286                 i += 2;
1287                 break;
1288             }
1289             /* fall through */
1290         default:
1291             if (i)  /* restore original position */
1292             {
1293                 if (!(types[i - 1] & PT_CLOSEFIGURE)) lastmove = pts[i - 1];
1294                 if (lastmove.x != orig_pos.x || lastmove.y != orig_pos.y)
1295                     MoveToEx( dev->hdc, orig_pos.x, orig_pos.y, NULL );
1296             }
1297             return FALSE;
1298         }
1299
1300         if(types[i] & PT_CLOSEFIGURE){
1301             physdev->path->flags[physdev->path->count-1] |= PT_CLOSEFIGURE;
1302             MoveToEx( dev->hdc, lastmove.x, lastmove.y, NULL );
1303         }
1304     }
1305
1306     return TRUE;
1307 }
1308
1309
1310 /*************************************************************
1311  *           pathdrv_Polyline
1312  */
1313 static BOOL pathdrv_Polyline( PHYSDEV dev, const POINT *pts, INT cbPoints )
1314 {
1315     struct path_physdev *physdev = get_path_physdev( dev );
1316     BYTE *type = add_log_points( physdev, pts, cbPoints, PT_LINETO );
1317
1318     if (!type) return FALSE;
1319     if (cbPoints) type[0] = PT_MOVETO;
1320     return TRUE;
1321 }
1322
1323
1324 /*************************************************************
1325  *           pathdrv_PolylineTo
1326  */
1327 static BOOL pathdrv_PolylineTo( PHYSDEV dev, const POINT *pts, INT cbPoints )
1328 {
1329     struct path_physdev *physdev = get_path_physdev( dev );
1330
1331     if (!start_new_stroke( physdev )) return FALSE;
1332     return add_log_points( physdev, pts, cbPoints, PT_LINETO ) != NULL;
1333 }
1334
1335
1336 /*************************************************************
1337  *           pathdrv_Polygon
1338  */
1339 static BOOL pathdrv_Polygon( PHYSDEV dev, const POINT *pts, INT cbPoints )
1340 {
1341     struct path_physdev *physdev = get_path_physdev( dev );
1342     BYTE *type = add_log_points( physdev, pts, cbPoints, PT_LINETO );
1343
1344     if (!type) return FALSE;
1345     if (cbPoints) type[0] = PT_MOVETO;
1346     if (cbPoints > 1) type[cbPoints - 1] = PT_LINETO | PT_CLOSEFIGURE;
1347     return TRUE;
1348 }
1349
1350
1351 /*************************************************************
1352  *           pathdrv_PolyPolygon
1353  */
1354 static BOOL pathdrv_PolyPolygon( PHYSDEV dev, const POINT* pts, const INT* counts, UINT polygons )
1355 {
1356     struct path_physdev *physdev = get_path_physdev( dev );
1357     UINT poly;
1358     BYTE *type;
1359
1360     for(poly = 0; poly < polygons; poly++) {
1361         type = add_log_points( physdev, pts, counts[poly], PT_LINETO );
1362         if (!type) return FALSE;
1363         type[0] = PT_MOVETO;
1364         /* win98 adds an extra line to close the figure for some reason */
1365         add_log_points( physdev, pts, 1, PT_LINETO | PT_CLOSEFIGURE );
1366         pts += counts[poly];
1367     }
1368     return TRUE;
1369 }
1370
1371
1372 /*************************************************************
1373  *           pathdrv_PolyPolyline
1374  */
1375 static BOOL pathdrv_PolyPolyline( PHYSDEV dev, const POINT* pts, const DWORD* counts, DWORD polylines )
1376 {
1377     struct path_physdev *physdev = get_path_physdev( dev );
1378     UINT poly, count;
1379     BYTE *type;
1380
1381     for (poly = count = 0; poly < polylines; poly++) count += counts[poly];
1382
1383     type = add_log_points( physdev, pts, count, PT_LINETO );
1384     if (!type) return FALSE;
1385
1386     /* make the first point of each polyline a PT_MOVETO */
1387     for (poly = 0; poly < polylines; poly++, type += counts[poly]) *type = PT_MOVETO;
1388     return TRUE;
1389 }
1390
1391
1392 /**********************************************************************
1393  *      PATH_BezierTo
1394  *
1395  * internally used by PATH_add_outline
1396  */
1397 static void PATH_BezierTo(struct gdi_path *pPath, POINT *lppt, INT n)
1398 {
1399     if (n < 2) return;
1400
1401     if (n == 2)
1402     {
1403         PATH_AddEntry(pPath, &lppt[1], PT_LINETO);
1404     }
1405     else if (n == 3)
1406     {
1407         PATH_AddEntry(pPath, &lppt[0], PT_BEZIERTO);
1408         PATH_AddEntry(pPath, &lppt[1], PT_BEZIERTO);
1409         PATH_AddEntry(pPath, &lppt[2], PT_BEZIERTO);
1410     }
1411     else
1412     {
1413         POINT pt[3];
1414         INT i = 0;
1415
1416         pt[2] = lppt[0];
1417         n--;
1418
1419         while (n > 2)
1420         {
1421             pt[0] = pt[2];
1422             pt[1] = lppt[i+1];
1423             pt[2].x = (lppt[i+2].x + lppt[i+1].x) / 2;
1424             pt[2].y = (lppt[i+2].y + lppt[i+1].y) / 2;
1425             PATH_BezierTo(pPath, pt, 3);
1426             n--;
1427             i++;
1428         }
1429
1430         pt[0] = pt[2];
1431         pt[1] = lppt[i+1];
1432         pt[2] = lppt[i+2];
1433         PATH_BezierTo(pPath, pt, 3);
1434     }
1435 }
1436
1437 static BOOL PATH_add_outline(struct path_physdev *physdev, INT x, INT y,
1438                              TTPOLYGONHEADER *header, DWORD size)
1439 {
1440     TTPOLYGONHEADER *start;
1441     POINT pt;
1442
1443     start = header;
1444
1445     while ((char *)header < (char *)start + size)
1446     {
1447         TTPOLYCURVE *curve;
1448
1449         if (header->dwType != TT_POLYGON_TYPE)
1450         {
1451             FIXME("Unknown header type %d\n", header->dwType);
1452             return FALSE;
1453         }
1454
1455         pt.x = x + int_from_fixed(header->pfxStart.x);
1456         pt.y = y - int_from_fixed(header->pfxStart.y);
1457         PATH_AddEntry(physdev->path, &pt, PT_MOVETO);
1458
1459         curve = (TTPOLYCURVE *)(header + 1);
1460
1461         while ((char *)curve < (char *)header + header->cb)
1462         {
1463             /*TRACE("curve->wType %d\n", curve->wType);*/
1464
1465             switch(curve->wType)
1466             {
1467             case TT_PRIM_LINE:
1468             {
1469                 WORD i;
1470
1471                 for (i = 0; i < curve->cpfx; i++)
1472                 {
1473                     pt.x = x + int_from_fixed(curve->apfx[i].x);
1474                     pt.y = y - int_from_fixed(curve->apfx[i].y);
1475                     PATH_AddEntry(physdev->path, &pt, PT_LINETO);
1476                 }
1477                 break;
1478             }
1479
1480             case TT_PRIM_QSPLINE:
1481             case TT_PRIM_CSPLINE:
1482             {
1483                 WORD i;
1484                 POINTFX ptfx;
1485                 POINT *pts = HeapAlloc(GetProcessHeap(), 0, (curve->cpfx + 1) * sizeof(POINT));
1486
1487                 if (!pts) return FALSE;
1488
1489                 ptfx = *(POINTFX *)((char *)curve - sizeof(POINTFX));
1490
1491                 pts[0].x = x + int_from_fixed(ptfx.x);
1492                 pts[0].y = y - int_from_fixed(ptfx.y);
1493
1494                 for(i = 0; i < curve->cpfx; i++)
1495                 {
1496                     pts[i + 1].x = x + int_from_fixed(curve->apfx[i].x);
1497                     pts[i + 1].y = y - int_from_fixed(curve->apfx[i].y);
1498                 }
1499
1500                 PATH_BezierTo(physdev->path, pts, curve->cpfx + 1);
1501
1502                 HeapFree(GetProcessHeap(), 0, pts);
1503                 break;
1504             }
1505
1506             default:
1507                 FIXME("Unknown curve type %04x\n", curve->wType);
1508                 return FALSE;
1509             }
1510
1511             curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
1512         }
1513
1514         header = (TTPOLYGONHEADER *)((char *)header + header->cb);
1515     }
1516
1517     return CloseFigure(physdev->dev.hdc);
1518 }
1519
1520 /*************************************************************
1521  *           pathdrv_ExtTextOut
1522  */
1523 static BOOL pathdrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprc,
1524                                 LPCWSTR str, UINT count, const INT *dx )
1525 {
1526     struct path_physdev *physdev = get_path_physdev( dev );
1527     unsigned int idx;
1528     POINT offset = {0, 0};
1529
1530     if (!count) return TRUE;
1531
1532     for (idx = 0; idx < count; idx++)
1533     {
1534         static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
1535         GLYPHMETRICS gm;
1536         DWORD dwSize;
1537         void *outline;
1538
1539         dwSize = GetGlyphOutlineW(dev->hdc, str[idx], GGO_GLYPH_INDEX | GGO_NATIVE,
1540                                   &gm, 0, NULL, &identity);
1541         if (dwSize == GDI_ERROR) return FALSE;
1542
1543         /* add outline only if char is printable */
1544         if(dwSize)
1545         {
1546             outline = HeapAlloc(GetProcessHeap(), 0, dwSize);
1547             if (!outline) return FALSE;
1548
1549             GetGlyphOutlineW(dev->hdc, str[idx], GGO_GLYPH_INDEX | GGO_NATIVE,
1550                              &gm, dwSize, outline, &identity);
1551
1552             PATH_add_outline(physdev, x + offset.x, y + offset.y, outline, dwSize);
1553
1554             HeapFree(GetProcessHeap(), 0, outline);
1555         }
1556
1557         if (dx)
1558         {
1559             if(flags & ETO_PDY)
1560             {
1561                 offset.x += dx[idx * 2];
1562                 offset.y += dx[idx * 2 + 1];
1563             }
1564             else
1565                 offset.x += dx[idx];
1566         }
1567         else
1568         {
1569             offset.x += gm.gmCellIncX;
1570             offset.y += gm.gmCellIncY;
1571         }
1572     }
1573     return TRUE;
1574 }
1575
1576
1577 /*************************************************************
1578  *           pathdrv_CloseFigure
1579  */
1580 static BOOL pathdrv_CloseFigure( PHYSDEV dev )
1581 {
1582     struct path_physdev *physdev = get_path_physdev( dev );
1583
1584     /* Set PT_CLOSEFIGURE on the last entry and start a new stroke */
1585     /* It is not necessary to draw a line, PT_CLOSEFIGURE is a virtual closing line itself */
1586     if (physdev->path->count)
1587         physdev->path->flags[physdev->path->count - 1] |= PT_CLOSEFIGURE;
1588     return TRUE;
1589 }
1590
1591
1592 /*******************************************************************
1593  *      FlattenPath [GDI32.@]
1594  *
1595  *
1596  */
1597 BOOL WINAPI FlattenPath(HDC hdc)
1598 {
1599     BOOL ret = FALSE;
1600     DC *dc = get_dc_ptr( hdc );
1601
1602     if (dc)
1603     {
1604         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pFlattenPath );
1605         ret = physdev->funcs->pFlattenPath( physdev );
1606         release_dc_ptr( dc );
1607     }
1608     return ret;
1609 }
1610
1611
1612 static BOOL PATH_StrokePath( HDC hdc, const struct gdi_path *pPath )
1613 {
1614     INT i, nLinePts, nAlloc;
1615     POINT *pLinePts;
1616     POINT ptViewportOrg, ptWindowOrg;
1617     SIZE szViewportExt, szWindowExt;
1618     DWORD mapMode, graphicsMode;
1619     XFORM xform;
1620     BOOL ret = TRUE;
1621
1622     /* Save the mapping mode info */
1623     mapMode=GetMapMode(hdc);
1624     GetViewportExtEx(hdc, &szViewportExt);
1625     GetViewportOrgEx(hdc, &ptViewportOrg);
1626     GetWindowExtEx(hdc, &szWindowExt);
1627     GetWindowOrgEx(hdc, &ptWindowOrg);
1628     GetWorldTransform(hdc, &xform);
1629
1630     /* Set MM_TEXT */
1631     SetMapMode(hdc, MM_TEXT);
1632     SetViewportOrgEx(hdc, 0, 0, NULL);
1633     SetWindowOrgEx(hdc, 0, 0, NULL);
1634     graphicsMode=GetGraphicsMode(hdc);
1635     SetGraphicsMode(hdc, GM_ADVANCED);
1636     ModifyWorldTransform(hdc, &xform, MWT_IDENTITY);
1637     SetGraphicsMode(hdc, graphicsMode);
1638
1639     /* Allocate enough memory for the worst case without beziers (one PT_MOVETO
1640      * and the rest PT_LINETO with PT_CLOSEFIGURE at the end) plus some buffer
1641      * space in case we get one to keep the number of reallocations small. */
1642     nAlloc = pPath->count + 1 + 300;
1643     pLinePts = HeapAlloc(GetProcessHeap(), 0, nAlloc * sizeof(POINT));
1644     nLinePts = 0;
1645
1646     for(i = 0; i < pPath->count; i++) {
1647         if((i == 0 || (pPath->flags[i-1] & PT_CLOSEFIGURE)) &&
1648            (pPath->flags[i] != PT_MOVETO)) {
1649             ERR("Expected PT_MOVETO %s, got path flag %d\n",
1650                 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1651                 pPath->flags[i]);
1652             ret = FALSE;
1653             goto end;
1654         }
1655         switch(pPath->flags[i]) {
1656         case PT_MOVETO:
1657             TRACE("Got PT_MOVETO (%d, %d)\n",
1658                   pPath->points[i].x, pPath->points[i].y);
1659             if(nLinePts >= 2)
1660                 Polyline(hdc, pLinePts, nLinePts);
1661             nLinePts = 0;
1662             pLinePts[nLinePts++] = pPath->points[i];
1663             break;
1664         case PT_LINETO:
1665         case (PT_LINETO | PT_CLOSEFIGURE):
1666             TRACE("Got PT_LINETO (%d, %d)\n",
1667                   pPath->points[i].x, pPath->points[i].y);
1668             pLinePts[nLinePts++] = pPath->points[i];
1669             break;
1670         case PT_BEZIERTO:
1671             TRACE("Got PT_BEZIERTO\n");
1672             if(pPath->flags[i+1] != PT_BEZIERTO ||
1673                (pPath->flags[i+2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) {
1674                 ERR("Path didn't contain 3 successive PT_BEZIERTOs\n");
1675                 ret = FALSE;
1676                 goto end;
1677             } else {
1678                 INT nBzrPts, nMinAlloc;
1679                 POINT *pBzrPts = GDI_Bezier(&pPath->points[i-1], 4, &nBzrPts);
1680                 /* Make sure we have allocated enough memory for the lines of
1681                  * this bezier and the rest of the path, assuming we won't get
1682                  * another one (since we won't reallocate again then). */
1683                 nMinAlloc = nLinePts + (pPath->count - i) + nBzrPts;
1684                 if(nAlloc < nMinAlloc)
1685                 {
1686                     nAlloc = nMinAlloc * 2;
1687                     pLinePts = HeapReAlloc(GetProcessHeap(), 0, pLinePts,
1688                                            nAlloc * sizeof(POINT));
1689                 }
1690                 memcpy(&pLinePts[nLinePts], &pBzrPts[1],
1691                        (nBzrPts - 1) * sizeof(POINT));
1692                 nLinePts += nBzrPts - 1;
1693                 HeapFree(GetProcessHeap(), 0, pBzrPts);
1694                 i += 2;
1695             }
1696             break;
1697         default:
1698             ERR("Got path flag %d\n", pPath->flags[i]);
1699             ret = FALSE;
1700             goto end;
1701         }
1702         if(pPath->flags[i] & PT_CLOSEFIGURE)
1703             pLinePts[nLinePts++] = pLinePts[0];
1704     }
1705     if(nLinePts >= 2)
1706         Polyline(hdc, pLinePts, nLinePts);
1707
1708  end:
1709     HeapFree(GetProcessHeap(), 0, pLinePts);
1710
1711     /* Restore the old mapping mode */
1712     SetMapMode(hdc, mapMode);
1713     SetWindowExtEx(hdc, szWindowExt.cx, szWindowExt.cy, NULL);
1714     SetWindowOrgEx(hdc, ptWindowOrg.x, ptWindowOrg.y, NULL);
1715     SetViewportExtEx(hdc, szViewportExt.cx, szViewportExt.cy, NULL);
1716     SetViewportOrgEx(hdc, ptViewportOrg.x, ptViewportOrg.y, NULL);
1717
1718     /* Go to GM_ADVANCED temporarily to restore the world transform */
1719     graphicsMode=GetGraphicsMode(hdc);
1720     SetGraphicsMode(hdc, GM_ADVANCED);
1721     SetWorldTransform(hdc, &xform);
1722     SetGraphicsMode(hdc, graphicsMode);
1723
1724     /* If we've moved the current point then get its new position
1725        which will be in device (MM_TEXT) co-ords, convert it to
1726        logical co-ords and re-set it.  This basically updates
1727        dc->CurPosX|Y so that their values are in the correct mapping
1728        mode.
1729     */
1730     if(i > 0) {
1731         POINT pt;
1732         GetCurrentPositionEx(hdc, &pt);
1733         DPtoLP(hdc, &pt, 1);
1734         MoveToEx(hdc, pt.x, pt.y, NULL);
1735     }
1736
1737     return ret;
1738 }
1739
1740 #define round(x) ((int)((x)>0?(x)+0.5:(x)-0.5))
1741
1742 static struct gdi_path *PATH_WidenPath(DC *dc)
1743 {
1744     INT i, j, numStrokes, penWidth, penWidthIn, penWidthOut, size, penStyle;
1745     struct gdi_path *flat_path, *pNewPath, **pStrokes = NULL, *pUpPath, *pDownPath;
1746     EXTLOGPEN *elp;
1747     DWORD obj_type, joint, endcap, penType;
1748
1749     size = GetObjectW( dc->hPen, 0, NULL );
1750     if (!size) {
1751         SetLastError(ERROR_CAN_NOT_COMPLETE);
1752         return NULL;
1753     }
1754
1755     elp = HeapAlloc( GetProcessHeap(), 0, size );
1756     GetObjectW( dc->hPen, size, elp );
1757
1758     obj_type = GetObjectType(dc->hPen);
1759     if(obj_type == OBJ_PEN) {
1760         penStyle = ((LOGPEN*)elp)->lopnStyle;
1761     }
1762     else if(obj_type == OBJ_EXTPEN) {
1763         penStyle = elp->elpPenStyle;
1764     }
1765     else {
1766         SetLastError(ERROR_CAN_NOT_COMPLETE);
1767         HeapFree( GetProcessHeap(), 0, elp );
1768         return NULL;
1769     }
1770
1771     penWidth = elp->elpWidth;
1772     HeapFree( GetProcessHeap(), 0, elp );
1773
1774     endcap = (PS_ENDCAP_MASK & penStyle);
1775     joint = (PS_JOIN_MASK & penStyle);
1776     penType = (PS_TYPE_MASK & penStyle);
1777
1778     /* The function cannot apply to cosmetic pens */
1779     if(obj_type == OBJ_EXTPEN && penType == PS_COSMETIC) {
1780         SetLastError(ERROR_CAN_NOT_COMPLETE);
1781         return NULL;
1782     }
1783
1784     if (!(flat_path = PATH_FlattenPath( dc->path ))) return NULL;
1785
1786     penWidthIn = penWidth / 2;
1787     penWidthOut = penWidth / 2;
1788     if(penWidthIn + penWidthOut < penWidth)
1789         penWidthOut++;
1790
1791     numStrokes = 0;
1792
1793     for(i = 0, j = 0; i < flat_path->count; i++, j++) {
1794         POINT point;
1795         if((i == 0 || (flat_path->flags[i-1] & PT_CLOSEFIGURE)) &&
1796             (flat_path->flags[i] != PT_MOVETO)) {
1797             ERR("Expected PT_MOVETO %s, got path flag %c\n",
1798                 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1799                 flat_path->flags[i]);
1800             free_gdi_path( flat_path );
1801             return NULL;
1802         }
1803         switch(flat_path->flags[i]) {
1804             case PT_MOVETO:
1805                 numStrokes++;
1806                 j = 0;
1807                 if(numStrokes == 1)
1808                     pStrokes = HeapAlloc(GetProcessHeap(), 0, sizeof(*pStrokes));
1809                 else
1810                     pStrokes = HeapReAlloc(GetProcessHeap(), 0, pStrokes, numStrokes * sizeof(*pStrokes));
1811                 if(!pStrokes) return NULL;
1812                 pStrokes[numStrokes - 1] = alloc_gdi_path(0);
1813                 /* fall through */
1814             case PT_LINETO:
1815             case (PT_LINETO | PT_CLOSEFIGURE):
1816                 point.x = flat_path->points[i].x;
1817                 point.y = flat_path->points[i].y;
1818                 PATH_AddEntry(pStrokes[numStrokes - 1], &point, flat_path->flags[i]);
1819                 break;
1820             case PT_BEZIERTO:
1821                 /* should never happen because of the FlattenPath call */
1822                 ERR("Should never happen\n");
1823                 break;
1824             default:
1825                 ERR("Got path flag %c\n", flat_path->flags[i]);
1826                 return NULL;
1827         }
1828     }
1829
1830     pNewPath = alloc_gdi_path( flat_path->count );
1831
1832     for(i = 0; i < numStrokes; i++) {
1833         pUpPath = alloc_gdi_path( pStrokes[i]->count );
1834         pDownPath = alloc_gdi_path( pStrokes[i]->count );
1835
1836         for(j = 0; j < pStrokes[i]->count; j++) {
1837             /* Beginning or end of the path if not closed */
1838             if((!(pStrokes[i]->flags[pStrokes[i]->count - 1] & PT_CLOSEFIGURE)) && (j == 0 || j == pStrokes[i]->count - 1) ) {
1839                 /* Compute segment angle */
1840                 double xo, yo, xa, ya, theta;
1841                 POINT pt;
1842                 FLOAT_POINT corners[2];
1843                 if(j == 0) {
1844                     xo = pStrokes[i]->points[j].x;
1845                     yo = pStrokes[i]->points[j].y;
1846                     xa = pStrokes[i]->points[1].x;
1847                     ya = pStrokes[i]->points[1].y;
1848                 }
1849                 else {
1850                     xa = pStrokes[i]->points[j - 1].x;
1851                     ya = pStrokes[i]->points[j - 1].y;
1852                     xo = pStrokes[i]->points[j].x;
1853                     yo = pStrokes[i]->points[j].y;
1854                 }
1855                 theta = atan2( ya - yo, xa - xo );
1856                 switch(endcap) {
1857                     case PS_ENDCAP_SQUARE :
1858                         pt.x = xo + round(sqrt(2) * penWidthOut * cos(M_PI_4 + theta));
1859                         pt.y = yo + round(sqrt(2) * penWidthOut * sin(M_PI_4 + theta));
1860                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO) );
1861                         pt.x = xo + round(sqrt(2) * penWidthIn * cos(- M_PI_4 + theta));
1862                         pt.y = yo + round(sqrt(2) * penWidthIn * sin(- M_PI_4 + theta));
1863                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1864                         break;
1865                     case PS_ENDCAP_FLAT :
1866                         pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1867                         pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1868                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1869                         pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1870                         pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1871                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1872                         break;
1873                     case PS_ENDCAP_ROUND :
1874                     default :
1875                         corners[0].x = xo - penWidthIn;
1876                         corners[0].y = yo - penWidthIn;
1877                         corners[1].x = xo + penWidthOut;
1878                         corners[1].y = yo + penWidthOut;
1879                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI_2 , theta + 3 * M_PI_4, (j == 0 ? PT_MOVETO : FALSE));
1880                         PATH_DoArcPart(pUpPath ,corners, theta + 3 * M_PI_4 , theta + M_PI, FALSE);
1881                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI, theta +  5 * M_PI_4, FALSE);
1882                         PATH_DoArcPart(pUpPath ,corners, theta + 5 * M_PI_4 , theta + 3 * M_PI_2, FALSE);
1883                         break;
1884                 }
1885             }
1886             /* Corpse of the path */
1887             else {
1888                 /* Compute angle */
1889                 INT previous, next;
1890                 double xa, ya, xb, yb, xo, yo;
1891                 double alpha, theta, miterWidth;
1892                 DWORD _joint = joint;
1893                 POINT pt;
1894                 struct gdi_path *pInsidePath, *pOutsidePath;
1895                 if(j > 0 && j < pStrokes[i]->count - 1) {
1896                     previous = j - 1;
1897                     next = j + 1;
1898                 }
1899                 else if (j == 0) {
1900                     previous = pStrokes[i]->count - 1;
1901                     next = j + 1;
1902                 }
1903                 else {
1904                     previous = j - 1;
1905                     next = 0;
1906                 }
1907                 xo = pStrokes[i]->points[j].x;
1908                 yo = pStrokes[i]->points[j].y;
1909                 xa = pStrokes[i]->points[previous].x;
1910                 ya = pStrokes[i]->points[previous].y;
1911                 xb = pStrokes[i]->points[next].x;
1912                 yb = pStrokes[i]->points[next].y;
1913                 theta = atan2( yo - ya, xo - xa );
1914                 alpha = atan2( yb - yo, xb - xo ) - theta;
1915                 if (alpha > 0) alpha -= M_PI;
1916                 else alpha += M_PI;
1917                 if(_joint == PS_JOIN_MITER && dc->miterLimit < fabs(1 / sin(alpha/2))) {
1918                     _joint = PS_JOIN_BEVEL;
1919                 }
1920                 if(alpha > 0) {
1921                     pInsidePath = pUpPath;
1922                     pOutsidePath = pDownPath;
1923                 }
1924                 else if(alpha < 0) {
1925                     pInsidePath = pDownPath;
1926                     pOutsidePath = pUpPath;
1927                 }
1928                 else {
1929                     continue;
1930                 }
1931                 /* Inside angle points */
1932                 if(alpha > 0) {
1933                     pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1934                     pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1935                 }
1936                 else {
1937                     pt.x = xo + round( penWidthIn * cos(theta + M_PI_2) );
1938                     pt.y = yo + round( penWidthIn * sin(theta + M_PI_2) );
1939                 }
1940                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1941                 if(alpha > 0) {
1942                     pt.x = xo + round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1943                     pt.y = yo + round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1944                 }
1945                 else {
1946                     pt.x = xo - round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1947                     pt.y = yo - round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1948                 }
1949                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1950                 /* Outside angle point */
1951                 switch(_joint) {
1952                      case PS_JOIN_MITER :
1953                         miterWidth = fabs(penWidthOut / cos(M_PI_2 - fabs(alpha) / 2));
1954                         pt.x = xo + round( miterWidth * cos(theta + alpha / 2) );
1955                         pt.y = yo + round( miterWidth * sin(theta + alpha / 2) );
1956                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1957                         break;
1958                     case PS_JOIN_BEVEL :
1959                         if(alpha > 0) {
1960                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1961                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1962                         }
1963                         else {
1964                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1965                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1966                         }
1967                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1968                         if(alpha > 0) {
1969                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1970                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1971                         }
1972                         else {
1973                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1974                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1975                         }
1976                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1977                         break;
1978                     case PS_JOIN_ROUND :
1979                     default :
1980                         if(alpha > 0) {
1981                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1982                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1983                         }
1984                         else {
1985                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1986                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1987                         }
1988                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1989                         pt.x = xo + round( penWidthOut * cos(theta + alpha / 2) );
1990                         pt.y = yo + round( penWidthOut * sin(theta + alpha / 2) );
1991                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1992                         if(alpha > 0) {
1993                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1994                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1995                         }
1996                         else {
1997                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1998                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1999                         }
2000                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
2001                         break;
2002                 }
2003             }
2004         }
2005         for(j = 0; j < pUpPath->count; j++) {
2006             POINT pt;
2007             pt.x = pUpPath->points[j].x;
2008             pt.y = pUpPath->points[j].y;
2009             PATH_AddEntry(pNewPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
2010         }
2011         for(j = 0; j < pDownPath->count; j++) {
2012             POINT pt;
2013             pt.x = pDownPath->points[pDownPath->count - j - 1].x;
2014             pt.y = pDownPath->points[pDownPath->count - j - 1].y;
2015             PATH_AddEntry(pNewPath, &pt, ( (j == 0 && (pStrokes[i]->flags[pStrokes[i]->count - 1] & PT_CLOSEFIGURE)) ? PT_MOVETO : PT_LINETO));
2016         }
2017
2018         free_gdi_path( pStrokes[i] );
2019         free_gdi_path( pUpPath );
2020         free_gdi_path( pDownPath );
2021     }
2022     HeapFree(GetProcessHeap(), 0, pStrokes);
2023     free_gdi_path( flat_path );
2024     return pNewPath;
2025 }
2026
2027
2028 /*******************************************************************
2029  *      StrokeAndFillPath [GDI32.@]
2030  *
2031  *
2032  */
2033 BOOL WINAPI StrokeAndFillPath(HDC hdc)
2034 {
2035     BOOL ret = FALSE;
2036     DC *dc = get_dc_ptr( hdc );
2037
2038     if (dc)
2039     {
2040         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStrokeAndFillPath );
2041         ret = physdev->funcs->pStrokeAndFillPath( physdev );
2042         release_dc_ptr( dc );
2043     }
2044     return ret;
2045 }
2046
2047
2048 /*******************************************************************
2049  *      StrokePath [GDI32.@]
2050  *
2051  *
2052  */
2053 BOOL WINAPI StrokePath(HDC hdc)
2054 {
2055     BOOL ret = FALSE;
2056     DC *dc = get_dc_ptr( hdc );
2057
2058     if (dc)
2059     {
2060         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStrokePath );
2061         ret = physdev->funcs->pStrokePath( physdev );
2062         release_dc_ptr( dc );
2063     }
2064     return ret;
2065 }
2066
2067
2068 /*******************************************************************
2069  *      WidenPath [GDI32.@]
2070  *
2071  *
2072  */
2073 BOOL WINAPI WidenPath(HDC hdc)
2074 {
2075     BOOL ret = FALSE;
2076     DC *dc = get_dc_ptr( hdc );
2077
2078     if (dc)
2079     {
2080         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pWidenPath );
2081         ret = physdev->funcs->pWidenPath( physdev );
2082         release_dc_ptr( dc );
2083     }
2084     return ret;
2085 }
2086
2087
2088 /***********************************************************************
2089  *           null driver fallback implementations
2090  */
2091
2092 BOOL nulldrv_BeginPath( PHYSDEV dev )
2093 {
2094     DC *dc = get_nulldrv_dc( dev );
2095     struct path_physdev *physdev;
2096     struct gdi_path *path = alloc_gdi_path(0);
2097
2098     if (!path) return FALSE;
2099     if (!path_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
2100     {
2101         free_gdi_path( path );
2102         return FALSE;
2103     }
2104     physdev = get_path_physdev( dc->physDev );
2105     physdev->path = path;
2106     if (dc->path) free_gdi_path( dc->path );
2107     dc->path = NULL;
2108     return TRUE;
2109 }
2110
2111 BOOL nulldrv_EndPath( PHYSDEV dev )
2112 {
2113     SetLastError( ERROR_CAN_NOT_COMPLETE );
2114     return FALSE;
2115 }
2116
2117 BOOL nulldrv_AbortPath( PHYSDEV dev )
2118 {
2119     DC *dc = get_nulldrv_dc( dev );
2120
2121     if (dc->path) free_gdi_path( dc->path );
2122     dc->path = NULL;
2123     return TRUE;
2124 }
2125
2126 BOOL nulldrv_CloseFigure( PHYSDEV dev )
2127 {
2128     SetLastError( ERROR_CAN_NOT_COMPLETE );
2129     return FALSE;
2130 }
2131
2132 BOOL nulldrv_SelectClipPath( PHYSDEV dev, INT mode )
2133 {
2134     BOOL ret;
2135     HRGN hrgn;
2136     DC *dc = get_nulldrv_dc( dev );
2137
2138     if (!dc->path)
2139     {
2140         SetLastError( ERROR_CAN_NOT_COMPLETE );
2141         return FALSE;
2142     }
2143     if (!(hrgn = PATH_PathToRegion( dc->path, GetPolyFillMode(dev->hdc)))) return FALSE;
2144     ret = ExtSelectClipRgn( dev->hdc, hrgn, mode ) != ERROR;
2145     if (ret)
2146     {
2147         free_gdi_path( dc->path );
2148         dc->path = NULL;
2149     }
2150     /* FIXME: Should this function delete the path even if it failed? */
2151     DeleteObject( hrgn );
2152     return ret;
2153 }
2154
2155 BOOL nulldrv_FillPath( PHYSDEV dev )
2156 {
2157     DC *dc = get_nulldrv_dc( dev );
2158
2159     if (!dc->path)
2160     {
2161         SetLastError( ERROR_CAN_NOT_COMPLETE );
2162         return FALSE;
2163     }
2164     if (!PATH_FillPath( dev->hdc, dc->path )) return FALSE;
2165     /* FIXME: Should the path be emptied even if conversion failed? */
2166     free_gdi_path( dc->path );
2167     dc->path = NULL;
2168     return TRUE;
2169 }
2170
2171 BOOL nulldrv_StrokeAndFillPath( PHYSDEV dev )
2172 {
2173     DC *dc = get_nulldrv_dc( dev );
2174
2175     if (!dc->path)
2176     {
2177         SetLastError( ERROR_CAN_NOT_COMPLETE );
2178         return FALSE;
2179     }
2180     if (!PATH_FillPath( dev->hdc, dc->path )) return FALSE;
2181     if (!PATH_StrokePath( dev->hdc, dc->path )) return FALSE;
2182     free_gdi_path( dc->path );
2183     dc->path = NULL;
2184     return TRUE;
2185 }
2186
2187 BOOL nulldrv_StrokePath( PHYSDEV dev )
2188 {
2189     DC *dc = get_nulldrv_dc( dev );
2190
2191     if (!dc->path)
2192     {
2193         SetLastError( ERROR_CAN_NOT_COMPLETE );
2194         return FALSE;
2195     }
2196     if (!PATH_StrokePath( dev->hdc, dc->path )) return FALSE;
2197     free_gdi_path( dc->path );
2198     dc->path = NULL;
2199     return TRUE;
2200 }
2201
2202 BOOL nulldrv_FlattenPath( PHYSDEV dev )
2203 {
2204     DC *dc = get_nulldrv_dc( dev );
2205     struct gdi_path *path;
2206
2207     if (!dc->path)
2208     {
2209         SetLastError( ERROR_CAN_NOT_COMPLETE );
2210         return FALSE;
2211     }
2212     if (!(path = PATH_FlattenPath( dc->path ))) return FALSE;
2213     free_gdi_path( dc->path );
2214     dc->path = path;
2215     return TRUE;
2216 }
2217
2218 BOOL nulldrv_WidenPath( PHYSDEV dev )
2219 {
2220     DC *dc = get_nulldrv_dc( dev );
2221     struct gdi_path *path;
2222
2223     if (!dc->path)
2224     {
2225         SetLastError( ERROR_CAN_NOT_COMPLETE );
2226         return FALSE;
2227     }
2228     if (!(path = PATH_WidenPath( dc ))) return FALSE;
2229     free_gdi_path( dc->path );
2230     dc->path = path;
2231     return TRUE;
2232 }
2233
2234 const struct gdi_dc_funcs path_driver =
2235 {
2236     NULL,                               /* pAbortDoc */
2237     pathdrv_AbortPath,                  /* pAbortPath */
2238     NULL,                               /* pAlphaBlend */
2239     pathdrv_AngleArc,                   /* pAngleArc */
2240     pathdrv_Arc,                        /* pArc */
2241     pathdrv_ArcTo,                      /* pArcTo */
2242     pathdrv_BeginPath,                  /* pBeginPath */
2243     NULL,                               /* pBlendImage */
2244     NULL,                               /* pChoosePixelFormat */
2245     pathdrv_Chord,                      /* pChord */
2246     pathdrv_CloseFigure,                /* pCloseFigure */
2247     NULL,                               /* pCopyBitmap */
2248     NULL,                               /* pCreateBitmap */
2249     NULL,                               /* pCreateCompatibleDC */
2250     pathdrv_CreateDC,                   /* pCreateDC */
2251     NULL,                               /* pDeleteBitmap */
2252     pathdrv_DeleteDC,                   /* pDeleteDC */
2253     NULL,                               /* pDeleteObject */
2254     NULL,                               /* pDescribePixelFormat */
2255     NULL,                               /* pDeviceCapabilities */
2256     pathdrv_Ellipse,                    /* pEllipse */
2257     NULL,                               /* pEndDoc */
2258     NULL,                               /* pEndPage */
2259     pathdrv_EndPath,                    /* pEndPath */
2260     NULL,                               /* pEnumFonts */
2261     NULL,                               /* pEnumICMProfiles */
2262     NULL,                               /* pExcludeClipRect */
2263     NULL,                               /* pExtDeviceMode */
2264     NULL,                               /* pExtEscape */
2265     NULL,                               /* pExtFloodFill */
2266     NULL,                               /* pExtSelectClipRgn */
2267     pathdrv_ExtTextOut,                 /* pExtTextOut */
2268     NULL,                               /* pFillPath */
2269     NULL,                               /* pFillRgn */
2270     NULL,                               /* pFlattenPath */
2271     NULL,                               /* pFontIsLinked */
2272     NULL,                               /* pFrameRgn */
2273     NULL,                               /* pGdiComment */
2274     NULL,                               /* pGdiRealizationInfo */
2275     NULL,                               /* pGetBoundsRect */
2276     NULL,                               /* pGetCharABCWidths */
2277     NULL,                               /* pGetCharABCWidthsI */
2278     NULL,                               /* pGetCharWidth */
2279     NULL,                               /* pGetDeviceCaps */
2280     NULL,                               /* pGetDeviceGammaRamp */
2281     NULL,                               /* pGetFontData */
2282     NULL,                               /* pGetFontUnicodeRanges */
2283     NULL,                               /* pGetGlyphIndices */
2284     NULL,                               /* pGetGlyphOutline */
2285     NULL,                               /* pGetICMProfile */
2286     NULL,                               /* pGetImage */
2287     NULL,                               /* pGetKerningPairs */
2288     NULL,                               /* pGetNearestColor */
2289     NULL,                               /* pGetOutlineTextMetrics */
2290     NULL,                               /* pGetPixel */
2291     NULL,                               /* pGetPixelFormat */
2292     NULL,                               /* pGetSystemPaletteEntries */
2293     NULL,                               /* pGetTextCharsetInfo */
2294     NULL,                               /* pGetTextExtentExPoint */
2295     NULL,                               /* pGetTextExtentExPointI */
2296     NULL,                               /* pGetTextFace */
2297     NULL,                               /* pGetTextMetrics */
2298     NULL,                               /* pGradientFill */
2299     NULL,                               /* pIntersectClipRect */
2300     NULL,                               /* pInvertRgn */
2301     pathdrv_LineTo,                     /* pLineTo */
2302     NULL,                               /* pModifyWorldTransform */
2303     pathdrv_MoveTo,                     /* pMoveTo */
2304     NULL,                               /* pOffsetClipRgn */
2305     NULL,                               /* pOffsetViewportOrg */
2306     NULL,                               /* pOffsetWindowOrg */
2307     NULL,                               /* pPaintRgn */
2308     NULL,                               /* pPatBlt */
2309     pathdrv_Pie,                        /* pPie */
2310     pathdrv_PolyBezier,                 /* pPolyBezier */
2311     pathdrv_PolyBezierTo,               /* pPolyBezierTo */
2312     pathdrv_PolyDraw,                   /* pPolyDraw */
2313     pathdrv_PolyPolygon,                /* pPolyPolygon */
2314     pathdrv_PolyPolyline,               /* pPolyPolyline */
2315     pathdrv_Polygon,                    /* pPolygon */
2316     pathdrv_Polyline,                   /* pPolyline */
2317     pathdrv_PolylineTo,                 /* pPolylineTo */
2318     NULL,                               /* pPutImage */
2319     NULL,                               /* pRealizeDefaultPalette */
2320     NULL,                               /* pRealizePalette */
2321     pathdrv_Rectangle,                  /* pRectangle */
2322     NULL,                               /* pResetDC */
2323     NULL,                               /* pRestoreDC */
2324     pathdrv_RoundRect,                  /* pRoundRect */
2325     NULL,                               /* pSaveDC */
2326     NULL,                               /* pScaleViewportExt */
2327     NULL,                               /* pScaleWindowExt */
2328     NULL,                               /* pSelectBitmap */
2329     NULL,                               /* pSelectBrush */
2330     NULL,                               /* pSelectClipPath */
2331     NULL,                               /* pSelectFont */
2332     NULL,                               /* pSelectPalette */
2333     NULL,                               /* pSelectPen */
2334     NULL,                               /* pSetArcDirection */
2335     NULL,                               /* pSetBkColor */
2336     NULL,                               /* pSetBkMode */
2337     NULL,                               /* pSetDCBrushColor */
2338     NULL,                               /* pSetDCPenColor */
2339     NULL,                               /* pSetDIBColorTable */
2340     NULL,                               /* pSetDIBitsToDevice */
2341     NULL,                               /* pSetDeviceClipping */
2342     NULL,                               /* pSetDeviceGammaRamp */
2343     NULL,                               /* pSetLayout */
2344     NULL,                               /* pSetMapMode */
2345     NULL,                               /* pSetMapperFlags */
2346     NULL,                               /* pSetPixel */
2347     NULL,                               /* pSetPixelFormat */
2348     NULL,                               /* pSetPolyFillMode */
2349     NULL,                               /* pSetROP2 */
2350     NULL,                               /* pSetRelAbs */
2351     NULL,                               /* pSetStretchBltMode */
2352     NULL,                               /* pSetTextAlign */
2353     NULL,                               /* pSetTextCharacterExtra */
2354     NULL,                               /* pSetTextColor */
2355     NULL,                               /* pSetTextJustification */
2356     NULL,                               /* pSetViewportExt */
2357     NULL,                               /* pSetViewportOrg */
2358     NULL,                               /* pSetWindowExt */
2359     NULL,                               /* pSetWindowOrg */
2360     NULL,                               /* pSetWorldTransform */
2361     NULL,                               /* pStartDoc */
2362     NULL,                               /* pStartPage */
2363     NULL,                               /* pStretchBlt */
2364     NULL,                               /* pStretchDIBits */
2365     NULL,                               /* pStrokeAndFillPath */
2366     NULL,                               /* pStrokePath */
2367     NULL,                               /* pSwapBuffers */
2368     NULL,                               /* pUnrealizePalette */
2369     NULL,                               /* pWidenPath */
2370     NULL,                               /* pwglCopyContext */
2371     NULL,                               /* pwglCreateContext */
2372     NULL,                               /* pwglCreateContextAttribsARB */
2373     NULL,                               /* pwglDeleteContext */
2374     NULL,                               /* pwglGetProcAddress */
2375     NULL,                               /* pwglMakeContextCurrentARB */
2376     NULL,                               /* pwglMakeCurrent */
2377     NULL,                               /* pwglSetPixelFormatWINE */
2378     NULL,                               /* pwglShareLists */
2379     NULL,                               /* pwglUseFontBitmapsA */
2380     NULL,                               /* pwglUseFontBitmapsW */
2381     GDI_PRIORITY_PATH_DRV               /* priority */
2382 };