git.oblomov.eu Git - wine/blob - graphics/path.c

   1 /*
   2  * Graphics paths (BeginPath, EndPath etc.)
   3  *
   4  * Copyright 1997, 1998 Martin Boehme
   5  *                 1999 Huw D M Davies
   6  */
   7
   8 #include <assert.h>
   9 #include <math.h>
  10 #include <string.h>
  11 #include "config.h"
  12 #if defined(HAVE_FLOAT_H)
  13 #include <float.h>
  14 #endif
  15
  16 #include "winbase.h"
  17 #include "wingdi.h"
  18 #include "winerror.h"
  19
  20 #include "dc.h"
  21 #include "debugtools.h"
  22 #include "path.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(gdi)
  25
  26 /* Notes on the implementation
  27  *
  28  * The implementation is based on dynamically resizable arrays of points and
  29  * flags. I dithered for a bit before deciding on this implementation, and
  30  * I had even done a bit of work on a linked list version before switching
  31  * to arrays. It's a bit of a tradeoff. When you use linked lists, the
  32  * implementation of FlattenPath is easier, because you can rip the
  33  * PT_BEZIERTO entries out of the middle of the list and link the
  34  * corresponding PT_LINETO entries in. However, when you use arrays,
  35  * PathToRegion becomes easier, since you can essentially just pass your array
  36  * of points to CreatePolyPolygonRgn. Also, if I'd used linked lists, I would
  37  * have had the extra effort of creating a chunk-based allocation scheme
  38  * in order to use memory effectively. That's why I finally decided to use
  39  * arrays. Note by the way that the array based implementation has the same
  40  * linear time complexity that linked lists would have since the arrays grow
  41  * exponentially.
  42  *
  43  * The points are stored in the path in device coordinates. This is
  44  * consistent with the way Windows does things (for instance, see the Win32
  45  * SDK documentation for GetPath).
  46  *
  47  * The word "stroke" appears in several places (e.g. in the flag
  48  * GdiPath.newStroke). A stroke consists of a PT_MOVETO followed by one or
  49  * more PT_LINETOs or PT_BEZIERTOs, up to, but not including, the next
  50  * PT_MOVETO. Note that this is not the same as the definition of a figure;
  51  * a figure can contain several strokes.
  52  *
  53  * I modified the drawing functions (MoveTo, LineTo etc.) to test whether
  54  * the path is open and to call the corresponding function in path.c if this
  55  * is the case. A more elegant approach would be to modify the function
  56  * pointers in the DC_FUNCTIONS structure; however, this would be a lot more
  57  * complex. Also, the performance degradation caused by my approach in the
  58  * case where no path is open is so small that it cannot be measured.
  59  *
  60  * Martin Boehme
  61  */
  62
  63 /* FIXME: A lot of stuff isn't implemented yet. There is much more to come. */
  64
  65 #define NUM_ENTRIES_INITIAL 16  /* Initial size of points / flags arrays  */
  66 #define GROW_FACTOR_NUMER    2  /* Numerator of grow factor for the array */
  67 #define GROW_FACTOR_DENOM    1  /* Denominator of grow factor             */
  68
  69
  70 static BOOL PATH_PathToRegion(GdiPath *pPath, INT nPolyFillMode,
  71    HRGN *pHrgn);
  72 static void   PATH_EmptyPath(GdiPath *pPath);
  73 static BOOL PATH_AddEntry(GdiPath *pPath, const POINT *pPoint,
  74    BYTE flags);
  75 static BOOL PATH_ReserveEntries(GdiPath *pPath, INT numEntries);
  76 static BOOL PATH_GetPathFromHDC(HDC hdc, GdiPath **ppPath);
  77 static BOOL PATH_DoArcPart(GdiPath *pPath, FLOAT_POINT corners[],
  78    double angleStart, double angleEnd, BOOL addMoveTo);
  79 static void PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
  80    double y, POINT *pPoint);
  81 static void PATH_NormalizePoint(FLOAT_POINT corners[], const FLOAT_POINT
  82    *pPoint, double *pX, double *pY);
  83
  84
  85 /***********************************************************************
  86  *           BeginPath16    (GDI.512)
  87  */
  88 BOOL16 WINAPI BeginPath16(HDC16 hdc)
  89 {
  90    return (BOOL16)BeginPath((HDC)hdc);
  91 }
  92
  93
  94 /***********************************************************************
  95  *           BeginPath    (GDI32.9)
  96  */
  97 BOOL WINAPI BeginPath(HDC hdc)
  98 {
  99    DC *dc = DC_GetDCPtr( hdc );
 100    GdiPath *pPath;
 101
 102    if(!dc) {
 103      SetLastError(ERROR_INVALID_HANDLE);
 104      return FALSE;
 105    }
 106
 107    if(dc->funcs->pBeginPath)
 108      return dc->funcs->pBeginPath(dc);
 109
 110    pPath = &dc->w.path;
 111
 112    /* If path is already open, do nothing */
 113    if(pPath->state==PATH_Open)
 114       return TRUE;
 115
 116    /* Make sure that path is empty */
 117    PATH_EmptyPath(pPath);
 118
 119    /* Initialize variables for new path */
 120    pPath->newStroke=TRUE;
 121    pPath->state=PATH_Open;
 122
 123    return TRUE;
 124 }
 125
 126
 127 /***********************************************************************
 128  *           EndPath16    (GDI.514)
 129  */
 130 BOOL16 WINAPI EndPath16(HDC16 hdc)
 131 {
 132    return (BOOL16)EndPath((HDC)hdc);
 133 }
 134
 135
 136 /***********************************************************************
 137  *           EndPath    (GDI32.78)
 138  */
 139 BOOL WINAPI EndPath(HDC hdc)
 140 {
 141    DC *dc = DC_GetDCPtr( hdc );
 142    GdiPath *pPath;
 143
 144    if(!dc) {
 145      SetLastError(ERROR_INVALID_HANDLE);
 146      return FALSE;
 147    }
 148
 149    if(dc->funcs->pEndPath)
 150      return dc->funcs->pEndPath(dc);
 151
 152    pPath = &dc->w.path;
 153
 154    /* Check that path is currently being constructed */
 155    if(pPath->state!=PATH_Open)
 156    {
 157       SetLastError(ERROR_CAN_NOT_COMPLETE);
 158       return FALSE;
 159    }
 160
 161    /* Set flag to indicate that path is finished */
 162    pPath->state=PATH_Closed;
 163
 164    return TRUE;
 165 }
 166
 167
 168 /***********************************************************************
 169  *           AbortPath16    (GDI.511)
 170  */
 171 BOOL16 WINAPI AbortPath16(HDC16 hdc)
 172 {
 173    return (BOOL16)AbortPath((HDC)hdc);
 174 }
 175
 176
 177 /******************************************************************************
 178  * AbortPath [GDI32.1]
 179  * Closes and discards paths from device context
 180  *
 181  * NOTES
 182  *    Check that SetLastError is being called correctly
 183  *
 184  * PARAMS
 185  *    hdc [I] Handle to device context
 186  *
 187  * RETURNS STD
 188  */
 189 BOOL WINAPI AbortPath( HDC hdc )
 190 {
 191    DC *dc = DC_GetDCPtr( hdc );
 192    GdiPath *pPath;
 193
 194    if(!dc) {
 195      SetLastError(ERROR_INVALID_HANDLE);
 196      return FALSE;
 197    }
 198
 199    if(dc->funcs->pAbortPath)
 200      return dc->funcs->pAbortPath(dc);
 201
 202    pPath = &dc->w.path;
 203
 204    /* Remove all entries from the path */
 205    PATH_EmptyPath(pPath);
 206
 207    return TRUE;
 208 }
 209
 210
 211 /***********************************************************************
 212  *           CloseFigure16    (GDI.513)
 213  */
 214 BOOL16 WINAPI CloseFigure16(HDC16 hdc)
 215 {
 216    return (BOOL16)CloseFigure((HDC)hdc);
 217 }
 218
 219
 220 /***********************************************************************
 221  *           CloseFigure    (GDI32.16)
 222  *
 223  * FIXME: Check that SetLastError is being called correctly
 224  */
 225 BOOL WINAPI CloseFigure(HDC hdc)
 226 {
 227    DC *dc = DC_GetDCPtr( hdc );
 228    GdiPath *pPath;
 229
 230    if(!dc) {
 231      SetLastError(ERROR_INVALID_HANDLE);
 232      return FALSE;
 233    }
 234
 235    if(dc->funcs->pCloseFigure)
 236      return dc->funcs->pCloseFigure(dc);
 237
 238    pPath = &dc->w.path;
 239
 240    /* Check that path is open */
 241    if(pPath->state!=PATH_Open)
 242    {
 243       SetLastError(ERROR_CAN_NOT_COMPLETE);
 244       return FALSE;
 245    }
 246
 247    /* Set PT_CLOSEFIGURE on the last entry and start a new stroke */
 248    if(pPath->numEntriesUsed)
 249    {
 250       pPath->pFlags[pPath->numEntriesUsed-1]|=PT_CLOSEFIGURE;
 251       pPath->newStroke=TRUE;
 252    }
 253
 254    return TRUE;
 255 }
 256
 257
 258 /***********************************************************************
 259  *           GetPath16    (GDI.517)
 260  */
 261 INT16 WINAPI GetPath16(HDC16 hdc, LPPOINT16 pPoints, LPBYTE pTypes,
 262    INT16 nSize)
 263 {
 264    FIXME("(%d,%p,%p): stub\n",hdc,pPoints,pTypes);
 265
 266    return 0;
 267 }
 268
 269
 270 /***********************************************************************
 271  *           GetPath    (GDI32.210)
 272  */
 273 INT WINAPI GetPath(HDC hdc, LPPOINT pPoints, LPBYTE pTypes,
 274    INT nSize)
 275 {
 276    GdiPath *pPath;
 277
 278    /* Get pointer to path */
 279    if(!PATH_GetPathFromHDC(hdc, &pPath))
 280    {
 281       SetLastError(ERROR_INVALID_PARAMETER);
 282       return -1;
 283    }
 284
 285    /* Check that path is closed */
 286    if(pPath->state!=PATH_Closed)
 287    {
 288       SetLastError(ERROR_CAN_NOT_COMPLETE);
 289       return -1;
 290    }
 291
 292    if(nSize==0)
 293       return pPath->numEntriesUsed;
 294    else if(nSize<pPath->numEntriesUsed)
 295    {
 296       SetLastError(ERROR_INVALID_PARAMETER);
 297       return -1;
 298    }
 299    else
 300    {
 301       memcpy(pPoints, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
 302       memcpy(pTypes, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
 303
 304       /* Convert the points to logical coordinates */
 305       if(!DPtoLP(hdc, pPoints, pPath->numEntriesUsed))
 306       {
 307          /* FIXME: Is this the correct value? */
 308          SetLastError(ERROR_CAN_NOT_COMPLETE);
 309          return -1;
 310       }
 311
 312       return pPath->numEntriesUsed;
 313    }
 314 }
 315
 316 /***********************************************************************
 317  *           PathToRegion16    (GDI.518)
 318  */
 319 HRGN16 WINAPI PathToRegion16(HDC16 hdc)
 320 {
 321   return (HRGN16) PathToRegion((HDC) hdc);
 322 }
 323
 324 /***********************************************************************
 325  *           PathToRegion    (GDI32.261)
 326  *
 327  * FIXME
 328  *   Check that SetLastError is being called correctly
 329  *
 330  * The documentation does not state this explicitly, but a test under Windows
 331  * shows that the region which is returned should be in device coordinates.
 332  */
 333 HRGN WINAPI PathToRegion(HDC hdc)
 334 {
 335    GdiPath *pPath;
 336    HRGN  hrgnRval;
 337
 338    /* Get pointer to path */
 339    if(!PATH_GetPathFromHDC(hdc, &pPath))
 340    {
 341       SetLastError(ERROR_INVALID_PARAMETER);
 342       return 0;
 343    }
 344
 345    /* Check that path is closed */
 346    if(pPath->state!=PATH_Closed)
 347    {
 348       SetLastError(ERROR_CAN_NOT_COMPLETE);
 349       return 0;
 350    }
 351
 352    /* FIXME: Should we empty the path even if conversion failed? */
 353    if(PATH_PathToRegion(pPath, GetPolyFillMode(hdc), &hrgnRval))
 354       PATH_EmptyPath(pPath);
 355    else
 356       hrgnRval=0;
 357
 358    return hrgnRval;
 359 }
 360
 361 static BOOL PATH_FillPath(HDC hdc, GdiPath *pPath)
 362 {
 363    INT   mapMode, graphicsMode;
 364    SIZE  ptViewportExt, ptWindowExt;
 365    POINT ptViewportOrg, ptWindowOrg;
 366    XFORM xform;
 367    HRGN  hrgn;
 368
 369    /* Check that path is closed */
 370    if(pPath->state!=PATH_Closed)
 371    {
 372       SetLastError(ERROR_CAN_NOT_COMPLETE);
 373       return FALSE;
 374    }
 375
 376    /* Construct a region from the path and fill it */
 377    if(PATH_PathToRegion(pPath, GetPolyFillMode(hdc), &hrgn))
 378    {
 379       /* Since PaintRgn interprets the region as being in logical coordinates
 380        * but the points we store for the path are already in device
 381        * coordinates, we have to set the mapping mode to MM_TEXT temporarily.
 382        * Using SaveDC to save information about the mapping mode / world
 383        * transform would be easier but would require more overhead, especially
 384        * now that SaveDC saves the current path.
 385        */
 386
 387       /* Save the information about the old mapping mode */
 388       mapMode=GetMapMode(hdc);
 389       GetViewportExtEx(hdc, &ptViewportExt);
 390       GetViewportOrgEx(hdc, &ptViewportOrg);
 391       GetWindowExtEx(hdc, &ptWindowExt);
 392       GetWindowOrgEx(hdc, &ptWindowOrg);
 393
 394       /* Save world transform
 395        * NB: The Windows documentation on world transforms would lead one to
 396        * believe that this has to be done only in GM_ADVANCED; however, my
 397        * tests show that resetting the graphics mode to GM_COMPATIBLE does
 398        * not reset the world transform.
 399        */
 400       GetWorldTransform(hdc, &xform);
 401
 402       /* Set MM_TEXT */
 403       SetMapMode(hdc, MM_TEXT);
 404       SetViewportOrgEx(hdc, 0, 0, NULL);
 405       SetWindowOrgEx(hdc, 0, 0, NULL);
 406
 407       /* Paint the region */
 408       PaintRgn(hdc, hrgn);
 409       DeleteObject(hrgn);
 410       /* Restore the old mapping mode */
 411       SetMapMode(hdc, mapMode);
 412       SetViewportExtEx(hdc, ptViewportExt.cx, ptViewportExt.cy, NULL);
 413       SetViewportOrgEx(hdc, ptViewportOrg.x, ptViewportOrg.y, NULL);
 414       SetWindowExtEx(hdc, ptWindowExt.cx, ptWindowExt.cy, NULL);
 415       SetWindowOrgEx(hdc, ptWindowOrg.x, ptWindowOrg.y, NULL);
 416
 417       /* Go to GM_ADVANCED temporarily to restore the world transform */
 418       graphicsMode=GetGraphicsMode(hdc);
 419       SetGraphicsMode(hdc, GM_ADVANCED);
 420       SetWorldTransform(hdc, &xform);
 421       SetGraphicsMode(hdc, graphicsMode);
 422       return TRUE;
 423    }
 424    return FALSE;
 425 }
 426
 427 /***********************************************************************
 428  *           FillPath16    (GDI.515)
 429  */
 430 BOOL16 WINAPI FillPath16(HDC16 hdc)
 431 {
 432   return (BOOL16) FillPath((HDC) hdc);
 433 }
 434
 435 /***********************************************************************
 436  *           FillPath    (GDI32.100)
 437  *
 438  * FIXME
 439  *    Check that SetLastError is being called correctly
 440  */
 441 BOOL WINAPI FillPath(HDC hdc)
 442 {
 443    DC *dc = DC_GetDCPtr( hdc );
 444
 445    if(!dc) {
 446      SetLastError(ERROR_INVALID_HANDLE);
 447      return FALSE;
 448    }
 449
 450    if(dc->funcs->pFillPath)
 451      return dc->funcs->pFillPath(dc);
 452
 453    if(!PATH_FillPath(hdc, &dc->w.path))
 454       return FALSE;
 455
 456    /* FIXME: Should the path be emptied even if conversion failed? */
 457    PATH_EmptyPath(&dc->w.path);
 458    return TRUE;
 459 }
 460
 461 /***********************************************************************
 462  *           SelectClipPath16    (GDI.519)
 463  */
 464 BOOL16 WINAPI SelectClipPath16(HDC16 hdc, INT16 iMode)
 465 {
 466   return (BOOL16) SelectClipPath((HDC) hdc, iMode);
 467 }
 468
 469 /***********************************************************************
 470  *           SelectClipPath    (GDI32.296)
 471  * FIXME
 472  *  Check that SetLastError is being called correctly
 473  */
 474 BOOL WINAPI SelectClipPath(HDC hdc, INT iMode)
 475 {
 476    GdiPath *pPath;
 477    HRGN  hrgnPath;
 478    BOOL  success;
 479    DC *dc = DC_GetDCPtr( hdc );
 480
 481    if(!dc) {
 482      SetLastError(ERROR_INVALID_HANDLE);
 483      return FALSE;
 484    }
 485
 486    if(dc->funcs->pSelectClipPath)
 487      return dc->funcs->pSelectClipPath(dc, iMode);
 488
 489    pPath = &dc->w.path;
 490
 491    /* Check that path is closed */
 492    if(pPath->state!=PATH_Closed)
 493    {
 494       SetLastError(ERROR_CAN_NOT_COMPLETE);
 495       return FALSE;
 496    }
 497
 498    /* Construct a region from the path */
 499    if(PATH_PathToRegion(pPath, GetPolyFillMode(hdc), &hrgnPath))
 500    {
 501       success = ExtSelectClipRgn( hdc, hrgnPath, iMode ) != ERROR;
 502       DeleteObject(hrgnPath);
 503
 504       /* Empty the path */
 505       if(success)
 506          PATH_EmptyPath(pPath);
 507       /* FIXME: Should this function delete the path even if it failed? */
 508
 509       return success;
 510    }
 511    else
 512       return FALSE;
 513 }
 514
 515
 516 /***********************************************************************
 517  * Exported functions
 518  */
 519
 520 /* PATH_InitGdiPath
 521  *
 522  * Initializes the GdiPath structure.
 523  */
 524 void PATH_InitGdiPath(GdiPath *pPath)
 525 {
 526    assert(pPath!=NULL);
 527
 528    pPath->state=PATH_Null;
 529    pPath->pPoints=NULL;
 530    pPath->pFlags=NULL;
 531    pPath->numEntriesUsed=0;
 532    pPath->numEntriesAllocated=0;
 533 }
 534
 535 /* PATH_DestroyGdiPath
 536  *
 537  * Destroys a GdiPath structure (frees the memory in the arrays).
 538  */
 539 void PATH_DestroyGdiPath(GdiPath *pPath)
 540 {
 541    assert(pPath!=NULL);
 542
 543    if (pPath->pPoints) HeapFree( GetProcessHeap(), 0, pPath->pPoints );
 544    if (pPath->pFlags) HeapFree( GetProcessHeap(), 0, pPath->pFlags );
 545 }
 546
 547 /* PATH_AssignGdiPath
 548  *
 549  * Copies the GdiPath structure "pPathSrc" to "pPathDest". A deep copy is
 550  * performed, i.e. the contents of the pPoints and pFlags arrays are copied,
 551  * not just the pointers. Since this means that the arrays in pPathDest may
 552  * need to be resized, pPathDest should have been initialized using
 553  * PATH_InitGdiPath (in C++, this function would be an assignment operator,
 554  * not a copy constructor).
 555  * Returns TRUE if successful, else FALSE.
 556  */
 557 BOOL PATH_AssignGdiPath(GdiPath *pPathDest, const GdiPath *pPathSrc)
 558 {
 559    assert(pPathDest!=NULL && pPathSrc!=NULL);
 560
 561    /* Make sure destination arrays are big enough */
 562    if(!PATH_ReserveEntries(pPathDest, pPathSrc->numEntriesUsed))
 563       return FALSE;
 564
 565    /* Perform the copy operation */
 566    memcpy(pPathDest->pPoints, pPathSrc->pPoints,
 567       sizeof(POINT)*pPathSrc->numEntriesUsed);
 568    memcpy(pPathDest->pFlags, pPathSrc->pFlags,
 569       sizeof(BYTE)*pPathSrc->numEntriesUsed);
 570
 571    pPathDest->state=pPathSrc->state;
 572    pPathDest->numEntriesUsed=pPathSrc->numEntriesUsed;
 573    pPathDest->newStroke=pPathSrc->newStroke;
 574
 575    return TRUE;
 576 }
 577
 578 /* PATH_MoveTo
 579  *
 580  * Should be called when a MoveTo is performed on a DC that has an
 581  * open path. This starts a new stroke. Returns TRUE if successful, else
 582  * FALSE.
 583  */
 584 BOOL PATH_MoveTo(HDC hdc)
 585 {
 586    GdiPath *pPath;
 587
 588    /* Get pointer to path */
 589    if(!PATH_GetPathFromHDC(hdc, &pPath))
 590       return FALSE;
 591
 592    /* Check that path is open */
 593    if(pPath->state!=PATH_Open)
 594       /* FIXME: Do we have to call SetLastError? */
 595       return FALSE;
 596
 597    /* Start a new stroke */
 598    pPath->newStroke=TRUE;
 599
 600    return TRUE;
 601 }
 602
 603 /* PATH_LineTo
 604  *
 605  * Should be called when a LineTo is performed on a DC that has an
 606  * open path. This adds a PT_LINETO entry to the path (and possibly
 607  * a PT_MOVETO entry, if this is the first LineTo in a stroke).
 608  * Returns TRUE if successful, else FALSE.
 609  */
 610 BOOL PATH_LineTo(HDC hdc, INT x, INT y)
 611 {
 612    GdiPath *pPath;
 613    POINT point, pointCurPos;
 614
 615    /* Get pointer to path */
 616    if(!PATH_GetPathFromHDC(hdc, &pPath))
 617       return FALSE;
 618
 619    /* Check that path is open */
 620    if(pPath->state!=PATH_Open)
 621       return FALSE;
 622
 623    /* Convert point to device coordinates */
 624    point.x=x;
 625    point.y=y;
 626    if(!LPtoDP(hdc, &point, 1))
 627       return FALSE;
 628
 629    /* Add a PT_MOVETO if necessary */
 630    if(pPath->newStroke)
 631    {
 632       pPath->newStroke=FALSE;
 633       if(!GetCurrentPositionEx(hdc, &pointCurPos) ||
 634          !LPtoDP(hdc, &pointCurPos, 1))
 635          return FALSE;
 636       if(!PATH_AddEntry(pPath, &pointCurPos, PT_MOVETO))
 637          return FALSE;
 638    }
 639
 640    /* Add a PT_LINETO entry */
 641    return PATH_AddEntry(pPath, &point, PT_LINETO);
 642 }
 643
 644 /* PATH_Rectangle
 645  *
 646  * Should be called when a call to Rectangle is performed on a DC that has
 647  * an open path. Returns TRUE if successful, else FALSE.
 648  */
 649 BOOL PATH_Rectangle(HDC hdc, INT x1, INT y1, INT x2, INT y2)
 650 {
 651    GdiPath *pPath;
 652    POINT corners[2], pointTemp;
 653    INT   temp;
 654
 655    /* Get pointer to path */
 656    if(!PATH_GetPathFromHDC(hdc, &pPath))
 657       return FALSE;
 658
 659    /* Check that path is open */
 660    if(pPath->state!=PATH_Open)
 661       return FALSE;
 662
 663    /* Convert points to device coordinates */
 664    corners[0].x=x1;
 665    corners[0].y=y1;
 666    corners[1].x=x2;
 667    corners[1].y=y2;
 668    if(!LPtoDP(hdc, corners, 2))
 669       return FALSE;
 670
 671    /* Make sure first corner is top left and second corner is bottom right */
 672    if(corners[0].x>corners[1].x)
 673    {
 674       temp=corners[0].x;
 675       corners[0].x=corners[1].x;
 676       corners[1].x=temp;
 677    }
 678    if(corners[0].y>corners[1].y)
 679    {
 680       temp=corners[0].y;
 681       corners[0].y=corners[1].y;
 682       corners[1].y=temp;
 683    }
 684
 685    /* In GM_COMPATIBLE, don't include bottom and right edges */
 686    if(GetGraphicsMode(hdc)==GM_COMPATIBLE)
 687    {
 688       corners[1].x--;
 689       corners[1].y--;
 690    }
 691
 692    /* Close any previous figure */
 693    if(!CloseFigure(hdc))
 694    {
 695       /* The CloseFigure call shouldn't have failed */
 696       assert(FALSE);
 697       return FALSE;
 698    }
 699
 700    /* Add four points to the path */
 701    pointTemp.x=corners[1].x;
 702    pointTemp.y=corners[0].y;
 703    if(!PATH_AddEntry(pPath, &pointTemp, PT_MOVETO))
 704       return FALSE;
 705    if(!PATH_AddEntry(pPath, corners, PT_LINETO))
 706       return FALSE;
 707    pointTemp.x=corners[0].x;
 708    pointTemp.y=corners[1].y;
 709    if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
 710       return FALSE;
 711    if(!PATH_AddEntry(pPath, corners+1, PT_LINETO))
 712       return FALSE;
 713
 714    /* Close the rectangle figure */
 715    if(!CloseFigure(hdc))
 716    {
 717       /* The CloseFigure call shouldn't have failed */
 718       assert(FALSE);
 719       return FALSE;
 720    }
 721
 722    return TRUE;
 723 }
 724
 725 /* PATH_Ellipse
 726  *
 727  * Should be called when a call to Ellipse is performed on a DC that has
 728  * an open path. This adds four Bezier splines representing the ellipse
 729  * to the path. Returns TRUE if successful, else FALSE.
 730  */
 731 BOOL PATH_Ellipse(HDC hdc, INT x1, INT y1, INT x2, INT y2)
 732 {
 733    /* TODO: This should probably be revised to call PATH_AngleArc */
 734    /* (once it exists) */
 735    return PATH_Arc(hdc, x1, y1, x2, y2, x1, (y1+y2)/2, x1, (y1+y2)/2);
 736 }
 737
 738 /* PATH_Arc
 739  *
 740  * Should be called when a call to Arc is performed on a DC that has
 741  * an open path. This adds up to five Bezier splines representing the arc
 742  * to the path. Returns TRUE if successful, else FALSE.
 743  */
 744 BOOL PATH_Arc(HDC hdc, INT x1, INT y1, INT x2, INT y2,
 745    INT xStart, INT yStart, INT xEnd, INT yEnd)
 746 {
 747    GdiPath     *pPath;
 748    DC          *pDC;
 749    double      angleStart, angleEnd, angleStartQuadrant, angleEndQuadrant=0.0;
 750                /* Initialize angleEndQuadrant to silence gcc's warning */
 751    double      x, y;
 752    FLOAT_POINT corners[2], pointStart, pointEnd;
 753    BOOL      start, end;
 754    INT       temp;
 755
 756    /* FIXME: This function should check for all possible error returns */
 757    /* FIXME: Do we have to respect newStroke? */
 758
 759    /* Get pointer to DC */
 760    pDC=DC_GetDCPtr(hdc);
 761    if(pDC==NULL)
 762       return FALSE;
 763
 764    /* Get pointer to path */
 765    if(!PATH_GetPathFromHDC(hdc, &pPath))
 766       return FALSE;
 767
 768    /* Check that path is open */
 769    if(pPath->state!=PATH_Open)
 770       return FALSE;
 771
 772    /* FIXME: Do we have to close the current figure? */
 773
 774    /* Check for zero height / width */
 775    /* FIXME: Only in GM_COMPATIBLE? */
 776    if(x1==x2 || y1==y2)
 777       return TRUE;
 778
 779    /* Convert points to device coordinates */
 780    corners[0].x=(FLOAT)x1;
 781    corners[0].y=(FLOAT)y1;
 782    corners[1].x=(FLOAT)x2;
 783    corners[1].y=(FLOAT)y2;
 784    pointStart.x=(FLOAT)xStart;
 785    pointStart.y=(FLOAT)yStart;
 786    pointEnd.x=(FLOAT)xEnd;
 787    pointEnd.y=(FLOAT)yEnd;
 788    INTERNAL_LPTODP_FLOAT(pDC, corners);
 789    INTERNAL_LPTODP_FLOAT(pDC, corners+1);
 790    INTERNAL_LPTODP_FLOAT(pDC, &pointStart);
 791    INTERNAL_LPTODP_FLOAT(pDC, &pointEnd);
 792
 793    /* Make sure first corner is top left and second corner is bottom right */
 794    if(corners[0].x>corners[1].x)
 795    {
 796       temp=corners[0].x;
 797       corners[0].x=corners[1].x;
 798       corners[1].x=temp;
 799    }
 800    if(corners[0].y>corners[1].y)
 801    {
 802       temp=corners[0].y;
 803       corners[0].y=corners[1].y;
 804       corners[1].y=temp;
 805    }
 806
 807    /* Compute start and end angle */
 808    PATH_NormalizePoint(corners, &pointStart, &x, &y);
 809    angleStart=atan2(y, x);
 810    PATH_NormalizePoint(corners, &pointEnd, &x, &y);
 811    angleEnd=atan2(y, x);
 812
 813    /* Make sure the end angle is "on the right side" of the start angle */
 814    if(GetArcDirection(hdc)==AD_CLOCKWISE)
 815    {
 816       if(angleEnd<=angleStart)
 817       {
 818          angleEnd+=2*M_PI;
 819          assert(angleEnd>=angleStart);
 820       }
 821    }
 822    else
 823    {
 824       if(angleEnd>=angleStart)
 825       {
 826          angleEnd-=2*M_PI;
 827          assert(angleEnd<=angleStart);
 828       }
 829    }
 830
 831    /* In GM_COMPATIBLE, don't include bottom and right edges */
 832    if(GetGraphicsMode(hdc)==GM_COMPATIBLE)
 833    {
 834       corners[1].x--;
 835       corners[1].y--;
 836    }
 837
 838    /* Add the arc to the path with one Bezier spline per quadrant that the
 839     * arc spans */
 840    start=TRUE;
 841    end=FALSE;
 842    do
 843    {
 844       /* Determine the start and end angles for this quadrant */
 845       if(start)
 846       {
 847          angleStartQuadrant=angleStart;
 848          if(GetArcDirection(hdc)==AD_CLOCKWISE)
 849             angleEndQuadrant=(floor(angleStart/M_PI_2)+1.0)*M_PI_2;
 850          else
 851             angleEndQuadrant=(ceil(angleStart/M_PI_2)-1.0)*M_PI_2;
 852       }
 853       else
 854       {
 855          angleStartQuadrant=angleEndQuadrant;
 856          if(GetArcDirection(hdc)==AD_CLOCKWISE)
 857             angleEndQuadrant+=M_PI_2;
 858          else
 859             angleEndQuadrant-=M_PI_2;
 860       }
 861
 862       /* Have we reached the last part of the arc? */
 863       if((GetArcDirection(hdc)==AD_CLOCKWISE &&
 864          angleEnd<angleEndQuadrant) ||
 865          (GetArcDirection(hdc)==AD_COUNTERCLOCKWISE &&
 866          angleEnd>angleEndQuadrant))
 867       {
 868          /* Adjust the end angle for this quadrant */
 869          angleEndQuadrant=angleEnd;
 870          end=TRUE;
 871       }
 872
 873       /* Add the Bezier spline to the path */
 874       PATH_DoArcPart(pPath, corners, angleStartQuadrant, angleEndQuadrant,
 875          start);
 876       start=FALSE;
 877    }  while(!end);
 878
 879    return TRUE;
 880 }
 881
 882 BOOL PATH_PolyBezierTo(HDC hdc, const POINT *pts, DWORD cbPoints)
 883 {
 884    GdiPath     *pPath;
 885    POINT       pt;
 886    INT         i;
 887
 888    if(!PATH_GetPathFromHDC(hdc, &pPath))
 889       return FALSE;
 890
 891    /* Check that path is open */
 892    if(pPath->state!=PATH_Open)
 893       return FALSE;
 894
 895    /* Add a PT_MOVETO if necessary */
 896    if(pPath->newStroke)
 897    {
 898       pPath->newStroke=FALSE;
 899       if(!GetCurrentPositionEx(hdc, &pt) ||
 900          !LPtoDP(hdc, &pt, 1))
 901          return FALSE;
 902       if(!PATH_AddEntry(pPath, &pt, PT_MOVETO))
 903          return FALSE;
 904    }
 905
 906    for(i = 0; i < cbPoints; i++) {
 907        pt = pts[i];
 908        if(!LPtoDP(hdc, &pt, 1))
 909            return FALSE;
 910        PATH_AddEntry(pPath, &pt, PT_BEZIERTO);
 911    }
 912    return TRUE;
 913 }
 914
 915 BOOL PATH_PolyBezier(HDC hdc, const POINT *pts, DWORD cbPoints)
 916 {
 917    GdiPath     *pPath;
 918    POINT       pt;
 919    INT         i;
 920
 921    if(!PATH_GetPathFromHDC(hdc, &pPath))
 922       return FALSE;
 923
 924    /* Check that path is open */
 925    if(pPath->state!=PATH_Open)
 926       return FALSE;
 927
 928    for(i = 0; i < cbPoints; i++) {
 929        pt = pts[i];
 930        if(!LPtoDP(hdc, &pt, 1))
 931            return FALSE;
 932        PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO : PT_BEZIERTO);
 933    }
 934    return TRUE;
 935 }
 936
 937 BOOL PATH_Polyline(HDC hdc, const POINT *pts, DWORD cbPoints)
 938 {
 939    GdiPath     *pPath;
 940    POINT       pt;
 941    INT         i;
 942
 943    if(!PATH_GetPathFromHDC(hdc, &pPath))
 944       return FALSE;
 945
 946    /* Check that path is open */
 947    if(pPath->state!=PATH_Open)
 948       return FALSE;
 949
 950    for(i = 0; i < cbPoints; i++) {
 951        pt = pts[i];
 952        if(!LPtoDP(hdc, &pt, 1))
 953            return FALSE;
 954        PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO : PT_LINETO);
 955    }
 956    return TRUE;
 957 }
 958
 959 BOOL PATH_PolylineTo(HDC hdc, const POINT *pts, DWORD cbPoints)
 960 {
 961    GdiPath     *pPath;
 962    POINT       pt;
 963    INT         i;
 964
 965    if(!PATH_GetPathFromHDC(hdc, &pPath))
 966       return FALSE;
 967
 968    /* Check that path is open */
 969    if(pPath->state!=PATH_Open)
 970       return FALSE;
 971
 972    /* Add a PT_MOVETO if necessary */
 973    if(pPath->newStroke)
 974    {
 975       pPath->newStroke=FALSE;
 976       if(!GetCurrentPositionEx(hdc, &pt) ||
 977          !LPtoDP(hdc, &pt, 1))
 978          return FALSE;
 979       if(!PATH_AddEntry(pPath, &pt, PT_MOVETO))
 980          return FALSE;
 981    }
 982
 983    for(i = 0; i < cbPoints; i++) {
 984        pt = pts[i];
 985        if(!LPtoDP(hdc, &pt, 1))
 986            return FALSE;
 987        PATH_AddEntry(pPath, &pt, PT_LINETO);
 988    }
 989
 990    return TRUE;
 991 }
 992
 993
 994 BOOL PATH_Polygon(HDC hdc, const POINT *pts, DWORD cbPoints)
 995 {
 996    GdiPath     *pPath;
 997    POINT       pt;
 998    INT         i;
 999
1000    if(!PATH_GetPathFromHDC(hdc, &pPath))
1001       return FALSE;
1002
1003    /* Check that path is open */
1004    if(pPath->state!=PATH_Open)
1005       return FALSE;
1006
1007    for(i = 0; i < cbPoints; i++) {
1008        pt = pts[i];
1009        if(!LPtoDP(hdc, &pt, 1))
1010            return FALSE;
1011        PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO :
1012                      ((i == cbPoints-1) ? PT_LINETO | PT_CLOSEFIGURE :
1013                       PT_LINETO));
1014    }
1015    return TRUE;
1016 }
1017
1018 BOOL PATH_PolyPolygon( HDC hdc, const POINT* pts, const INT* counts,
1019                        UINT polygons )
1020 {
1021    GdiPath     *pPath;
1022    POINT       pt, startpt;
1023    INT         poly, point, i;
1024
1025    if(!PATH_GetPathFromHDC(hdc, &pPath))
1026       return FALSE;
1027
1028    /* Check that path is open */
1029    if(pPath->state!=PATH_Open)
1030       return FALSE;
1031
1032    for(i = 0, poly = 0; poly < polygons; poly++) {
1033        for(point = 0; point < counts[poly]; point++, i++) {
1034            pt = pts[i];
1035            if(!LPtoDP(hdc, &pt, 1))
1036                return FALSE;
1037            if(point == 0) startpt = pt;
1038            PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
1039        }
1040        /* win98 adds an extra line to close the figure for some reason */
1041        PATH_AddEntry(pPath, &startpt, PT_LINETO | PT_CLOSEFIGURE);
1042    }
1043    return TRUE;
1044 }
1045
1046 BOOL PATH_PolyPolyline( HDC hdc, const POINT* pts, const DWORD* counts,
1047                         DWORD polylines )
1048 {
1049    GdiPath     *pPath;
1050    POINT       pt;
1051    INT         poly, point, i;
1052
1053    if(!PATH_GetPathFromHDC(hdc, &pPath))
1054       return FALSE;
1055
1056    /* Check that path is open */
1057    if(pPath->state!=PATH_Open)
1058       return FALSE;
1059
1060    for(i = 0, poly = 0; poly < polylines; poly++) {
1061        for(point = 0; point < counts[poly]; point++, i++) {
1062            pt = pts[i];
1063            if(!LPtoDP(hdc, &pt, 1))
1064                return FALSE;
1065            PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
1066        }
1067    }
1068    return TRUE;
1069 }
1070
1071 /***********************************************************************
1072  * Internal functions
1073  */
1074
1075
1076 /* PATH_AddFlatBezier
1077  *
1078  */
1079 static BOOL PATH_AddFlatBezier(GdiPath *pPath, POINT *pt, BOOL closed)
1080 {
1081     POINT *pts;
1082     INT no, i;
1083
1084     pts = GDI_Bezier( pt, 4, &no );
1085     if(!pts) return FALSE;
1086
1087     for(i = 1; i < no; i++)
1088         PATH_AddEntry(pPath, &pts[i],
1089             (i == no-1 && closed) ? PT_LINETO | PT_CLOSEFIGURE : PT_LINETO);
1090     HeapFree( GetProcessHeap(), 0, pts );
1091     return TRUE;
1092 }
1093
1094 /* PATH_FlattenPath
1095  *
1096  * Replaces Beziers with line segments
1097  *
1098  */
1099 static BOOL PATH_FlattenPath(GdiPath *pPath)
1100 {
1101     GdiPath newPath;
1102     INT srcpt;
1103
1104     memset(&newPath, 0, sizeof(newPath));
1105     newPath.state = PATH_Open;
1106     for(srcpt = 0; srcpt < pPath->numEntriesUsed; srcpt++) {
1107         switch(pPath->pFlags[srcpt] & ~PT_CLOSEFIGURE) {
1108         case PT_MOVETO:
1109         case PT_LINETO:
1110             PATH_AddEntry(&newPath, &pPath->pPoints[srcpt],
1111                           pPath->pFlags[srcpt]);
1112             break;
1113         case PT_BEZIERTO:
1114           PATH_AddFlatBezier(&newPath, &pPath->pPoints[srcpt-1],
1115                              pPath->pFlags[srcpt+2] & PT_CLOSEFIGURE);
1116             srcpt += 2;
1117             break;
1118         }
1119     }
1120     newPath.state = PATH_Closed;
1121     PATH_AssignGdiPath(pPath, &newPath);
1122     PATH_EmptyPath(&newPath);
1123     return TRUE;
1124 }
1125
1126 /* PATH_PathToRegion
1127  *
1128  * Creates a region from the specified path using the specified polygon
1129  * filling mode. The path is left unchanged. A handle to the region that
1130  * was created is stored in *pHrgn. If successful, TRUE is returned; if an
1131  * error occurs, SetLastError is called with the appropriate value and
1132  * FALSE is returned.
1133  */
1134 static BOOL PATH_PathToRegion(GdiPath *pPath, INT nPolyFillMode,
1135    HRGN *pHrgn)
1136 {
1137    int    numStrokes, iStroke, i;
1138    INT  *pNumPointsInStroke;
1139    HRGN hrgn;
1140
1141    assert(pPath!=NULL);
1142    assert(pHrgn!=NULL);
1143
1144    PATH_FlattenPath(pPath);
1145
1146    /* FIXME: What happens when number of points is zero? */
1147
1148    /* First pass: Find out how many strokes there are in the path */
1149    /* FIXME: We could eliminate this with some bookkeeping in GdiPath */
1150    numStrokes=0;
1151    for(i=0; i<pPath->numEntriesUsed; i++)
1152       if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1153          numStrokes++;
1154
1155    /* Allocate memory for number-of-points-in-stroke array */
1156    pNumPointsInStroke=(int *)HeapAlloc( GetProcessHeap(), 0,
1157                                         sizeof(int) * numStrokes );
1158    if(!pNumPointsInStroke)
1159    {
1160       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1161       return FALSE;
1162    }
1163
1164    /* Second pass: remember number of points in each polygon */
1165    iStroke=-1;  /* Will get incremented to 0 at beginning of first stroke */
1166    for(i=0; i<pPath->numEntriesUsed; i++)
1167    {
1168       /* Is this the beginning of a new stroke? */
1169       if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1170       {
1171          iStroke++;
1172          pNumPointsInStroke[iStroke]=0;
1173       }
1174
1175       pNumPointsInStroke[iStroke]++;
1176    }
1177
1178    /* Create a region from the strokes */
1179    hrgn=CreatePolyPolygonRgn(pPath->pPoints, pNumPointsInStroke,
1180       numStrokes, nPolyFillMode);
1181    if(hrgn==(HRGN)0)
1182    {
1183       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1184       return FALSE;
1185    }
1186
1187    /* Free memory for number-of-points-in-stroke array */
1188    HeapFree( GetProcessHeap(), 0, pNumPointsInStroke );
1189
1190    /* Success! */
1191    *pHrgn=hrgn;
1192    return TRUE;
1193 }
1194
1195 /* PATH_EmptyPath
1196  *
1197  * Removes all entries from the path and sets the path state to PATH_Null.
1198  */
1199 static void PATH_EmptyPath(GdiPath *pPath)
1200 {
1201    assert(pPath!=NULL);
1202
1203    pPath->state=PATH_Null;
1204    pPath->numEntriesUsed=0;
1205 }
1206
1207 /* PATH_AddEntry
1208  *
1209  * Adds an entry to the path. For "flags", pass either PT_MOVETO, PT_LINETO
1210  * or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
1211  * successful, FALSE otherwise (e.g. if not enough memory was available).
1212  */
1213 BOOL PATH_AddEntry(GdiPath *pPath, const POINT *pPoint, BYTE flags)
1214 {
1215    assert(pPath!=NULL);
1216
1217    /* FIXME: If newStroke is true, perhaps we want to check that we're
1218     * getting a PT_MOVETO
1219     */
1220    TRACE("(%ld,%ld) - %d\n", pPoint->x, pPoint->y, flags);
1221
1222    /* Check that path is open */
1223    if(pPath->state!=PATH_Open)
1224       return FALSE;
1225
1226    /* Reserve enough memory for an extra path entry */
1227    if(!PATH_ReserveEntries(pPath, pPath->numEntriesUsed+1))
1228       return FALSE;
1229
1230    /* Store information in path entry */
1231    pPath->pPoints[pPath->numEntriesUsed]=*pPoint;
1232    pPath->pFlags[pPath->numEntriesUsed]=flags;
1233
1234    /* If this is PT_CLOSEFIGURE, we have to start a new stroke next time */
1235    if((flags & PT_CLOSEFIGURE) == PT_CLOSEFIGURE)
1236       pPath->newStroke=TRUE;
1237
1238    /* Increment entry count */
1239    pPath->numEntriesUsed++;
1240
1241    return TRUE;
1242 }
1243
1244 /* PATH_ReserveEntries
1245  *
1246  * Ensures that at least "numEntries" entries (for points and flags) have
1247  * been allocated; allocates larger arrays and copies the existing entries
1248  * to those arrays, if necessary. Returns TRUE if successful, else FALSE.
1249  */
1250 static BOOL PATH_ReserveEntries(GdiPath *pPath, INT numEntries)
1251 {
1252    INT   numEntriesToAllocate;
1253    POINT *pPointsNew;
1254    BYTE    *pFlagsNew;
1255
1256    assert(pPath!=NULL);
1257    assert(numEntries>=0);
1258
1259    /* Do we have to allocate more memory? */
1260    if(numEntries > pPath->numEntriesAllocated)
1261    {
1262       /* Find number of entries to allocate. We let the size of the array
1263        * grow exponentially, since that will guarantee linear time
1264        * complexity. */
1265       if(pPath->numEntriesAllocated)
1266       {
1267          numEntriesToAllocate=pPath->numEntriesAllocated;
1268          while(numEntriesToAllocate<numEntries)
1269             numEntriesToAllocate=numEntriesToAllocate*GROW_FACTOR_NUMER/
1270                GROW_FACTOR_DENOM;
1271       }
1272       else
1273          numEntriesToAllocate=numEntries;
1274
1275       /* Allocate new arrays */
1276       pPointsNew=(POINT *)HeapAlloc( GetProcessHeap(), 0,
1277                                      numEntriesToAllocate * sizeof(POINT) );
1278       if(!pPointsNew)
1279          return FALSE;
1280       pFlagsNew=(BYTE *)HeapAlloc( GetProcessHeap(), 0,
1281                                    numEntriesToAllocate * sizeof(BYTE) );
1282       if(!pFlagsNew)
1283       {
1284          HeapFree( GetProcessHeap(), 0, pPointsNew );
1285          return FALSE;
1286       }
1287
1288       /* Copy old arrays to new arrays and discard old arrays */
1289       if(pPath->pPoints)
1290       {
1291          assert(pPath->pFlags);
1292
1293          memcpy(pPointsNew, pPath->pPoints,
1294              sizeof(POINT)*pPath->numEntriesUsed);
1295          memcpy(pFlagsNew, pPath->pFlags,
1296              sizeof(BYTE)*pPath->numEntriesUsed);
1297
1298          HeapFree( GetProcessHeap(), 0, pPath->pPoints );
1299          HeapFree( GetProcessHeap(), 0, pPath->pFlags );
1300       }
1301       pPath->pPoints=pPointsNew;
1302       pPath->pFlags=pFlagsNew;
1303       pPath->numEntriesAllocated=numEntriesToAllocate;
1304    }
1305
1306    return TRUE;
1307 }
1308
1309 /* PATH_GetPathFromHDC
1310  *
1311  * Retrieves a pointer to the GdiPath structure contained in an HDC and
1312  * places it in *ppPath. TRUE is returned if successful, FALSE otherwise.
1313  */
1314 static BOOL PATH_GetPathFromHDC(HDC hdc, GdiPath **ppPath)
1315 {
1316    DC *pDC;
1317
1318    pDC=DC_GetDCPtr(hdc);
1319    if(pDC)
1320    {
1321       *ppPath=&pDC->w.path;
1322       return TRUE;
1323    }
1324    else
1325       return FALSE;
1326 }
1327
1328 /* PATH_DoArcPart
1329  *
1330  * Creates a Bezier spline that corresponds to part of an arc and appends the
1331  * corresponding points to the path. The start and end angles are passed in
1332  * "angleStart" and "angleEnd"; these angles should span a quarter circle
1333  * at most. If "addMoveTo" is true, a PT_MOVETO entry for the first control
1334  * point is added to the path; otherwise, it is assumed that the current
1335  * position is equal to the first control point.
1336  */
1337 static BOOL PATH_DoArcPart(GdiPath *pPath, FLOAT_POINT corners[],
1338    double angleStart, double angleEnd, BOOL addMoveTo)
1339 {
1340    double  halfAngle, a;
1341    double  xNorm[4], yNorm[4];
1342    POINT point;
1343    int     i;
1344
1345    assert(fabs(angleEnd-angleStart)<=M_PI_2);
1346
1347    /* FIXME: Is there an easier way of computing this? */
1348
1349    /* Compute control points */
1350    halfAngle=(angleEnd-angleStart)/2.0;
1351    if(fabs(halfAngle)>1e-8)
1352    {
1353       a=4.0/3.0*(1-cos(halfAngle))/sin(halfAngle);
1354       xNorm[0]=cos(angleStart);
1355       yNorm[0]=sin(angleStart);
1356       xNorm[1]=xNorm[0] - a*yNorm[0];
1357       yNorm[1]=yNorm[0] + a*xNorm[0];
1358       xNorm[3]=cos(angleEnd);
1359       yNorm[3]=sin(angleEnd);
1360       xNorm[2]=xNorm[3] + a*yNorm[3];
1361       yNorm[2]=yNorm[3] - a*xNorm[3];
1362    }
1363    else
1364       for(i=0; i<4; i++)
1365       {
1366          xNorm[i]=cos(angleStart);
1367          yNorm[i]=sin(angleStart);
1368       }
1369
1370    /* Add starting point to path if desired */
1371    if(addMoveTo)
1372    {
1373       PATH_ScaleNormalizedPoint(corners, xNorm[0], yNorm[0], &point);
1374       if(!PATH_AddEntry(pPath, &point, PT_MOVETO))
1375          return FALSE;
1376    }
1377
1378    /* Add remaining control points */
1379    for(i=1; i<4; i++)
1380    {
1381       PATH_ScaleNormalizedPoint(corners, xNorm[i], yNorm[i], &point);
1382       if(!PATH_AddEntry(pPath, &point, PT_BEZIERTO))
1383          return FALSE;
1384    }
1385
1386    return TRUE;
1387 }
1388
1389 /* PATH_ScaleNormalizedPoint
1390  *
1391  * Scales a normalized point (x, y) with respect to the box whose corners are
1392  * passed in "corners". The point is stored in "*pPoint". The normalized
1393  * coordinates (-1.0, -1.0) correspond to corners[0], the coordinates
1394  * (1.0, 1.0) correspond to corners[1].
1395  */
1396 static void PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
1397    double y, POINT *pPoint)
1398 {
1399    pPoint->x=GDI_ROUND( (double)corners[0].x +
1400       (double)(corners[1].x-corners[0].x)*0.5*(x+1.0) );
1401    pPoint->y=GDI_ROUND( (double)corners[0].y +
1402       (double)(corners[1].y-corners[0].y)*0.5*(y+1.0) );
1403 }
1404
1405 /* PATH_NormalizePoint
1406  *
1407  * Normalizes a point with respect to the box whose corners are passed in
1408  * "corners". The normalized coordinates are stored in "*pX" and "*pY".
1409  */
1410 static void PATH_NormalizePoint(FLOAT_POINT corners[],
1411    const FLOAT_POINT *pPoint,
1412    double *pX, double *pY)
1413 {
1414    *pX=(double)(pPoint->x-corners[0].x)/(double)(corners[1].x-corners[0].x) *
1415       2.0 - 1.0;
1416    *pY=(double)(pPoint->y-corners[0].y)/(double)(corners[1].y-corners[0].y) *
1417       2.0 - 1.0;
1418 }
1419
1420 /*******************************************************************
1421  *      FlattenPath16 [GDI.516]
1422  *
1423  *
1424  */
1425 BOOL16 WINAPI FlattenPath16(HDC16 hdc)
1426 {
1427   return (BOOL16) FlattenPath((HDC) hdc);
1428 }
1429
1430 /*******************************************************************
1431  *      FlattenPath [GDI32.103]
1432  *
1433  *
1434  */
1435 BOOL WINAPI FlattenPath(HDC hdc)
1436 {
1437    DC *dc = DC_GetDCPtr( hdc );
1438    GdiPath *pPath;
1439    TRACE("%08x\n", hdc);
1440
1441    if(!dc) {
1442      SetLastError(ERROR_INVALID_HANDLE);
1443      return FALSE;
1444    }
1445
1446    if(dc->funcs->pFlattenPath)
1447      return dc->funcs->pFlattenPath(dc);
1448
1449     pPath = &dc->w.path;
1450     if(pPath->state != PATH_Closed)
1451         return FALSE;
1452    return PATH_FlattenPath(pPath);
1453 }
1454
1455
1456 static BOOL PATH_StrokePath(HDC hdc, GdiPath *pPath)
1457 {
1458     INT i;
1459     POINT ptLastMove = {0,0};
1460
1461     if(pPath->state != PATH_Closed)
1462         return FALSE;
1463
1464     SaveDC(hdc);
1465     SetMapMode(hdc, MM_TEXT);
1466     SetViewportOrgEx(hdc, 0, 0, NULL);
1467     SetWindowOrgEx(hdc, 0, 0, NULL);
1468     for(i = 0; i < pPath->numEntriesUsed; i++) {
1469         switch(pPath->pFlags[i]) {
1470         case PT_MOVETO:
1471             TRACE("Got PT_MOVETO (%ld, %ld)\n",
1472                   pPath->pPoints[i].x, pPath->pPoints[i].y);
1473             MoveToEx(hdc, pPath->pPoints[i].x, pPath->pPoints[i].y, NULL);
1474             ptLastMove = pPath->pPoints[i];
1475             break;
1476         case PT_LINETO:
1477         case (PT_LINETO | PT_CLOSEFIGURE):
1478             TRACE("Got PT_LINETO (%ld, %ld)\n",
1479                   pPath->pPoints[i].x, pPath->pPoints[i].y);
1480             LineTo(hdc, pPath->pPoints[i].x, pPath->pPoints[i].y);
1481             break;
1482         case PT_BEZIERTO:
1483             TRACE("Got PT_BEZIERTO\n");
1484             if(pPath->pFlags[i+1] != PT_BEZIERTO ||
1485                (pPath->pFlags[i+2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) {
1486                 ERR("Path didn't contain 3 successive PT_BEZIERTOs\n");
1487                 return FALSE;
1488             }
1489             PolyBezierTo(hdc, &pPath->pPoints[i], 3);
1490             i += 2;
1491             break;
1492         default:
1493             ERR("Got path flag %d\n", (INT)pPath->pFlags[i]);
1494             return FALSE;
1495         }
1496         if(pPath->pFlags[i] & PT_CLOSEFIGURE)
1497             LineTo(hdc, ptLastMove.x, ptLastMove.y);
1498     }
1499     RestoreDC(hdc, -1);
1500     return TRUE;
1501 }
1502
1503
1504 /*******************************************************************
1505  *      StrokeAndFillPath16 [GDI.520]
1506  *
1507  *
1508  */
1509 BOOL16 WINAPI StrokeAndFillPath16(HDC16 hdc)
1510 {
1511   return (BOOL16) StrokeAndFillPath((HDC) hdc);
1512 }
1513
1514 /*******************************************************************
1515  *      StrokeAndFillPath [GDI32.352]
1516  *
1517  *
1518  */
1519 BOOL WINAPI StrokeAndFillPath(HDC hdc)
1520 {
1521    DC *dc = DC_GetDCPtr( hdc );
1522    BOOL bRet;
1523
1524    if(!dc) {
1525      SetLastError(ERROR_INVALID_HANDLE);
1526      return FALSE;
1527    }
1528
1529    if(dc->funcs->pStrokeAndFillPath)
1530      return dc->funcs->pStrokeAndFillPath(dc);
1531
1532    bRet = PATH_FillPath(hdc, &dc->w.path);
1533    if(bRet) bRet = PATH_StrokePath(hdc, &dc->w.path);
1534    if(bRet) PATH_EmptyPath(&dc->w.path);
1535    return bRet;
1536 }
1537
1538 /*******************************************************************
1539  *      StrokePath16 [GDI.521]
1540  *
1541  *
1542  */
1543 BOOL16 WINAPI StrokePath16(HDC16 hdc)
1544 {
1545   return (BOOL16) StrokePath((HDC) hdc);
1546 }
1547
1548 /*******************************************************************
1549  *      StrokePath [GDI32.353]
1550  *
1551  *
1552  */
1553 BOOL WINAPI StrokePath(HDC hdc)
1554 {
1555     DC *dc = DC_GetDCPtr( hdc );
1556     GdiPath *pPath;
1557
1558     TRACE("(%08x)\n", hdc);
1559     if(!dc) {
1560         SetLastError(ERROR_INVALID_HANDLE);
1561         return FALSE;
1562     }
1563
1564     if(dc->funcs->pStrokePath)
1565         return dc->funcs->pStrokePath(dc);
1566
1567     pPath = &dc->w.path;
1568     PATH_StrokePath(hdc, pPath);
1569     PATH_EmptyPath(pPath);
1570     return TRUE;
1571 }
1572
1573 /*******************************************************************
1574  *      WidenPath16 [GDI.522]
1575  *
1576  *
1577  */
1578 BOOL16 WINAPI WidenPath16(HDC16 hdc)
1579 {
1580   return (BOOL16) WidenPath((HDC) hdc);
1581 }
1582
1583 /*******************************************************************
1584  *      WidenPath [GDI32.360]
1585  *
1586  *
1587  */
1588 BOOL WINAPI WidenPath(HDC hdc)
1589 {
1590    DC *dc = DC_GetDCPtr( hdc );
1591
1592    if(!dc) {
1593      SetLastError(ERROR_INVALID_HANDLE);
1594      return FALSE;
1595    }
1596
1597    if(dc->funcs->pWidenPath)
1598      return dc->funcs->pWidenPath(dc);
1599
1600    FIXME("stub\n");
1601    return 0;
1602 }