reactos/subsystems/win32/win32k/objects/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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22 /*
  23  *
  24  * Addaped for the use in ReactOS.
  25  *
  26  */
  27 /*
  28  * PROJECT:         ReactOS win32 kernel mode subsystem
  29  * LICENSE:         GPL - See COPYING in the top level directory
  30  * FILE:            subsystems/win32/win32k/objects/path.c
  31  * PURPOSE:         Path support
  32  * PROGRAMMER:
  33  */
  34
  35 #include <w32k.h>
  36 #include "math.h"
  37
  38 #define NDEBUG
  39 #include <debug.h>
  40
  41 #define NUM_ENTRIES_INITIAL 16  /* Initial size of points / flags arrays  */
  42 #define GROW_FACTOR_NUMER    2  /* Numerator of grow factor for the array */
  43 #define GROW_FACTOR_DENOM    1  /* Denominator of grow factor             */
  44
  45 BOOL FASTCALL PATH_AddEntry (PPATH pPath, const POINT *pPoint, BYTE flags);
  46 BOOL FASTCALL PATH_AddFlatBezier (PPATH pPath, POINT *pt, BOOL closed);
  47 BOOL FASTCALL PATH_DoArcPart (PPATH pPath, FLOAT_POINT corners[], double angleStart, double angleEnd, BYTE startEntryType);
  48 BOOL FASTCALL PATH_FillPath( PDC dc, PPATH pPath );
  49 BOOL FASTCALL PATH_FlattenPath (PPATH pPath);
  50 VOID FASTCALL PATH_NormalizePoint (FLOAT_POINT corners[], const FLOAT_POINT *pPoint, double *pX, double *pY);
  51
  52 BOOL FASTCALL PATH_ReserveEntries (PPATH pPath, INT numEntries);
  53 VOID FASTCALL PATH_ScaleNormalizedPoint (FLOAT_POINT corners[], double x, double y, POINT *pPoint);
  54 BOOL FASTCALL PATH_StrokePath(DC *dc, PPATH pPath);
  55 BOOL PATH_CheckCorners(DC *dc, POINT corners[], INT x1, INT y1, INT x2, INT y2);
  56
  57 VOID FASTCALL IntGetCurrentPositionEx(PDC dc, LPPOINT pt);
  58
  59 /***********************************************************************
  60  * Internal functions
  61  */
  62
  63 BOOL
  64 FASTCALL
  65 PATH_Delete(HPATH hPath)
  66 {
  67   PPATH pPath;
  68   if (!hPath) return FALSE;
  69   pPath = PATH_LockPath( hPath );
  70   if (!pPath) return FALSE;
  71   PATH_DestroyGdiPath( pPath );
  72   PATH_UnlockPath( pPath );
  73   PATH_FreeExtPathByHandle(hPath);
  74   return TRUE;
  75 }
  76
  77
  78 VOID
  79 FASTCALL
  80 IntGdiCloseFigure(PPATH pPath)
  81 {
  82    ASSERT(pPath->state == PATH_Open);
  83
  84    // FIXME: Shouldn't we draw a line to the beginning of the figure?
  85    // Set PT_CLOSEFIGURE on the last entry and start a new stroke
  86    if(pPath->numEntriesUsed)
  87    {
  88       pPath->pFlags[pPath->numEntriesUsed-1]|=PT_CLOSEFIGURE;
  89       pPath->newStroke=TRUE;
  90    }
  91 }
  92
  93 /* PATH_FillPath
  94  *
  95  *
  96  */
  97 BOOL
  98 FASTCALL
  99 PATH_FillPath( PDC dc, PPATH pPath )
 100 {
 101   INT   mapMode, graphicsMode;
 102   SIZE  ptViewportExt, ptWindowExt;
 103   POINTL ptViewportOrg, ptWindowOrg;
 104   XFORM xform;
 105   HRGN  hrgn;
 106   PDC_ATTR pdcattr = dc->pdcattr;
 107
 108   if( pPath->state != PATH_Closed )
 109   {
 110     SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
 111     return FALSE;
 112   }
 113
 114   if( PATH_PathToRegion( pPath, pdcattr->jFillMode, &hrgn ))
 115   {
 116     /* Since PaintRgn interprets the region as being in logical coordinates
 117      * but the points we store for the path are already in device
 118      * coordinates, we have to set the mapping mode to MM_TEXT temporarily.
 119      * Using SaveDC to save information about the mapping mode / world
 120      * transform would be easier but would require more overhead, especially
 121      * now that SaveDC saves the current path.
 122      */
 123
 124     /* Save the information about the old mapping mode */
 125     mapMode = pdcattr->iMapMode;
 126     ptViewportExt = pdcattr->szlViewportExt;
 127     ptViewportOrg = pdcattr->ptlViewportOrg;
 128     ptWindowExt   = pdcattr->szlWindowExt;
 129     ptWindowOrg   = pdcattr->ptlWindowOrg;
 130
 131     /* Save world transform
 132      * NB: The Windows documentation on world transforms would lead one to
 133      * believe that this has to be done only in GM_ADVANCED; however, my
 134      * tests show that resetting the graphics mode to GM_COMPATIBLE does
 135      * not reset the world transform.
 136      */
 137     MatrixS2XForm(&xform, &dc->dclevel.mxWorldToPage);
 138
 139     /* Set MM_TEXT */
 140 //    IntGdiSetMapMode( dc, MM_TEXT );
 141 //    pdcattr->ptlViewportOrg.x = 0;
 142 //    pdcattr->ptlViewportOrg.y = 0;
 143 //    pdcattr->ptlWindowOrg.x = 0;
 144 //    pdcattr->ptlWindowOrg.y = 0;
 145
 146     graphicsMode = pdcattr->iGraphicsMode;
 147 //    pdcattr->iGraphicsMode = GM_ADVANCED;
 148 //    IntGdiModifyWorldTransform( dc, &xform, MWT_IDENTITY );
 149 //    pdcattr->iGraphicsMode =  graphicsMode;
 150
 151     /* Paint the region */
 152     IntGdiPaintRgn( dc, hrgn );
 153     GreDeleteObject( hrgn );
 154     /* Restore the old mapping mode */
 155 //    IntGdiSetMapMode( dc, mapMode );
 156 //    pdcattr->szlViewportExt = ptViewportExt;
 157 //    pdcattr->ptlViewportOrg = ptViewportOrg;
 158 //    pdcattr->szlWindowExt   = ptWindowExt;
 159 //    pdcattr->ptlWindowOrg   = ptWindowOrg;
 160
 161     /* Go to GM_ADVANCED temporarily to restore the world transform */
 162     graphicsMode = pdcattr->iGraphicsMode;
 163 //    pdcattr->iGraphicsMode = GM_ADVANCED;
 164 //    IntGdiModifyWorldTransform( dc, &xform, MWT_MAX+1 );
 165 //    pdcattr->iGraphicsMode = graphicsMode;
 166     return TRUE;
 167   }
 168   return FALSE;
 169 }
 170
 171 /* PATH_InitGdiPath
 172  *
 173  * Initializes the GdiPath structure.
 174  */
 175 VOID
 176 FASTCALL
 177 PATH_InitGdiPath ( PPATH pPath )
 178 {
 179   ASSERT(pPath!=NULL);
 180
 181   pPath->state=PATH_Null;
 182   pPath->pPoints=NULL;
 183   pPath->pFlags=NULL;
 184   pPath->numEntriesUsed=0;
 185   pPath->numEntriesAllocated=0;
 186 }
 187
 188 /* PATH_DestroyGdiPath
 189  *
 190  * Destroys a GdiPath structure (frees the memory in the arrays).
 191  */
 192 VOID
 193 FASTCALL
 194 PATH_DestroyGdiPath ( PPATH pPath )
 195 {
 196   ASSERT(pPath!=NULL);
 197
 198   if (pPath->pPoints) ExFreePoolWithTag(pPath->pPoints, TAG_PATH);
 199   if (pPath->pFlags) ExFreePoolWithTag(pPath->pFlags, TAG_PATH);
 200 }
 201
 202 /* PATH_AssignGdiPath
 203  *
 204  * Copies the GdiPath structure "pPathSrc" to "pPathDest". A deep copy is
 205  * performed, i.e. the contents of the pPoints and pFlags arrays are copied,
 206  * not just the pointers. Since this means that the arrays in pPathDest may
 207  * need to be resized, pPathDest should have been initialized using
 208  * PATH_InitGdiPath (in C++, this function would be an assignment operator,
 209  * not a copy constructor).
 210  * Returns TRUE if successful, else FALSE.
 211  */
 212 BOOL
 213 FASTCALL
 214 PATH_AssignGdiPath ( PPATH pPathDest, const PPATH pPathSrc )
 215 {
 216   ASSERT(pPathDest!=NULL && pPathSrc!=NULL);
 217
 218   /* Make sure destination arrays are big enough */
 219   if ( !PATH_ReserveEntries(pPathDest, pPathSrc->numEntriesUsed) )
 220     return FALSE;
 221
 222   /* Perform the copy operation */
 223   memcpy(pPathDest->pPoints, pPathSrc->pPoints,
 224     sizeof(POINT)*pPathSrc->numEntriesUsed);
 225   memcpy(pPathDest->pFlags, pPathSrc->pFlags,
 226     sizeof(BYTE)*pPathSrc->numEntriesUsed);
 227
 228   pPathDest->state=pPathSrc->state;
 229   pPathDest->numEntriesUsed=pPathSrc->numEntriesUsed;
 230   pPathDest->newStroke=pPathSrc->newStroke;
 231   return TRUE;
 232 }
 233
 234 /* PATH_MoveTo
 235  *
 236  * Should be called when a MoveTo is performed on a DC that has an
 237  * open path. This starts a new stroke. Returns TRUE if successful, else
 238  * FALSE.
 239  */
 240 BOOL
 241 FASTCALL
 242 PATH_MoveTo ( PDC dc )
 243 {
 244   PPATH pPath = PATH_LockPath( dc->dclevel.hPath );
 245   if (!pPath) return FALSE;
 246
 247   /* Check that path is open */
 248   if ( pPath->state != PATH_Open )
 249   {
 250     PATH_UnlockPath( pPath );
 251     /* FIXME: Do we have to call SetLastError? */
 252     return FALSE;
 253   }
 254   /* Start a new stroke */
 255   pPath->newStroke = TRUE;
 256   PATH_UnlockPath( pPath );
 257   return TRUE;
 258 }
 259
 260 /* PATH_LineTo
 261  *
 262  * Should be called when a LineTo is performed on a DC that has an
 263  * open path. This adds a PT_LINETO entry to the path (and possibly
 264  * a PT_MOVETO entry, if this is the first LineTo in a stroke).
 265  * Returns TRUE if successful, else FALSE.
 266  */
 267 BOOL
 268 FASTCALL
 269 PATH_LineTo ( PDC dc, INT x, INT y )
 270 {
 271   BOOL Ret;
 272   PPATH pPath;
 273   POINT point, pointCurPos;
 274
 275   pPath = PATH_LockPath( dc->dclevel.hPath );
 276   if (!pPath) return FALSE;
 277
 278   /* Check that path is open */
 279   if ( pPath->state != PATH_Open )
 280   {
 281     PATH_UnlockPath( pPath );
 282     return FALSE;
 283   }
 284
 285   /* Convert point to device coordinates */
 286   point.x=x;
 287   point.y=y;
 288   CoordLPtoDP ( dc, &point );
 289
 290   /* Add a PT_MOVETO if necessary */
 291   if ( pPath->newStroke )
 292   {
 293     pPath->newStroke = FALSE;
 294     IntGetCurrentPositionEx ( dc, &pointCurPos );
 295     CoordLPtoDP ( dc, &pointCurPos );
 296     if ( !PATH_AddEntry(pPath, &pointCurPos, PT_MOVETO) )
 297     {
 298       PATH_UnlockPath( pPath );
 299       return FALSE;
 300     }
 301   }
 302
 303   /* Add a PT_LINETO entry */
 304   Ret = PATH_AddEntry(pPath, &point, PT_LINETO);
 305   PATH_UnlockPath( pPath );
 306   return Ret;
 307 }
 308
 309 /* PATH_Rectangle
 310  *
 311  * Should be called when a call to Rectangle is performed on a DC that has
 312  * an open path. Returns TRUE if successful, else FALSE.
 313  */
 314 BOOL
 315 FASTCALL
 316 PATH_Rectangle ( PDC dc, INT x1, INT y1, INT x2, INT y2 )
 317 {
 318   PPATH pPath;
 319   POINT corners[2], pointTemp;
 320   INT   temp;
 321
 322   pPath = PATH_LockPath( dc->dclevel.hPath );
 323   if (!pPath) return FALSE;
 324
 325   /* Check that path is open */
 326   if ( pPath->state != PATH_Open )
 327   {
 328     PATH_UnlockPath( pPath );
 329     return FALSE;
 330   }
 331
 332   /* Convert points to device coordinates */
 333   corners[0].x=x1;
 334   corners[0].y=y1;
 335   corners[1].x=x2;
 336   corners[1].y=y2;
 337   IntLPtoDP ( dc, corners, 2 );
 338
 339   /* Make sure first corner is top left and second corner is bottom right */
 340   if ( corners[0].x > corners[1].x )
 341   {
 342     temp=corners[0].x;
 343     corners[0].x=corners[1].x;
 344     corners[1].x=temp;
 345   }
 346   if ( corners[0].y > corners[1].y )
 347   {
 348     temp=corners[0].y;
 349     corners[0].y=corners[1].y;
 350     corners[1].y=temp;
 351   }
 352
 353   /* In GM_COMPATIBLE, don't include bottom and right edges */
 354   if (dc->pdcattr->iGraphicsMode == GM_COMPATIBLE)
 355   {
 356     corners[1].x--;
 357     corners[1].y--;
 358   }
 359
 360   /* Close any previous figure */
 361   IntGdiCloseFigure(pPath);
 362
 363   /* Add four points to the path */
 364   pointTemp.x=corners[1].x;
 365   pointTemp.y=corners[0].y;
 366   if ( !PATH_AddEntry(pPath, &pointTemp, PT_MOVETO) )
 367   {
 368     PATH_UnlockPath( pPath );
 369     return FALSE;
 370   }
 371   if ( !PATH_AddEntry(pPath, corners, PT_LINETO) )
 372   {
 373     PATH_UnlockPath( pPath );
 374     return FALSE;
 375   }
 376   pointTemp.x=corners[0].x;
 377   pointTemp.y=corners[1].y;
 378   if ( !PATH_AddEntry(pPath, &pointTemp, PT_LINETO) )
 379   {
 380     PATH_UnlockPath( pPath );
 381     return FALSE;
 382   }
 383   if ( !PATH_AddEntry(pPath, corners+1, PT_LINETO) )
 384   {
 385     PATH_UnlockPath( pPath );
 386     return FALSE;
 387   }
 388
 389   /* Close the rectangle figure */
 390   IntGdiCloseFigure(pPath) ;
 391   PATH_UnlockPath( pPath );
 392   return TRUE;
 393 }
 394
 395 /* PATH_RoundRect
 396  *
 397  * Should be called when a call to RoundRect is performed on a DC that has
 398  * an open path. Returns TRUE if successful, else FALSE.
 399  *
 400  * FIXME: it adds the same entries to the path as windows does, but there
 401  * is an error in the bezier drawing code so that there are small pixel-size
 402  * gaps when the resulting path is drawn by StrokePath()
 403  */
 404 BOOL FASTCALL PATH_RoundRect(DC *dc, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height)
 405 {
 406    PPATH pPath;
 407    POINT corners[2], pointTemp;
 408    FLOAT_POINT ellCorners[2];
 409
 410    pPath = PATH_LockPath( dc->dclevel.hPath );
 411    if (!pPath) return FALSE;
 412
 413    /* Check that path is open */
 414    if(pPath->state!=PATH_Open)
 415    {
 416       PATH_UnlockPath( pPath );
 417       return FALSE;
 418    }
 419
 420    if(!PATH_CheckCorners(dc,corners,x1,y1,x2,y2))
 421    {
 422       PATH_UnlockPath( pPath );
 423       return FALSE;
 424    }
 425
 426    /* Add points to the roundrect path */
 427    ellCorners[0].x = corners[1].x-ell_width;
 428    ellCorners[0].y = corners[0].y;
 429    ellCorners[1].x = corners[1].x;
 430    ellCorners[1].y = corners[0].y+ell_height;
 431    if(!PATH_DoArcPart(pPath, ellCorners, 0, -M_PI_2, PT_MOVETO))
 432    {
 433       PATH_UnlockPath( pPath );
 434       return FALSE;
 435    }
 436    pointTemp.x = corners[0].x+ell_width/2;
 437    pointTemp.y = corners[0].y;
 438    if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
 439    {
 440       PATH_UnlockPath( pPath );
 441       return FALSE;
 442    }
 443    ellCorners[0].x = corners[0].x;
 444    ellCorners[1].x = corners[0].x+ell_width;
 445    if(!PATH_DoArcPart(pPath, ellCorners, -M_PI_2, -M_PI, FALSE))
 446    {
 447       PATH_UnlockPath( pPath );
 448       return FALSE;
 449    }
 450    pointTemp.x = corners[0].x;
 451    pointTemp.y = corners[1].y-ell_height/2;
 452    if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
 453    {
 454       PATH_UnlockPath( pPath );
 455       return FALSE;
 456    }
 457    ellCorners[0].y = corners[1].y-ell_height;
 458    ellCorners[1].y = corners[1].y;
 459    if(!PATH_DoArcPart(pPath, ellCorners, M_PI, M_PI_2, FALSE))
 460    {
 461       PATH_UnlockPath( pPath );
 462       return FALSE;
 463    }
 464    pointTemp.x = corners[1].x-ell_width/2;
 465    pointTemp.y = corners[1].y;
 466    if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
 467    {
 468       PATH_UnlockPath( pPath );
 469       return FALSE;
 470    }
 471    ellCorners[0].x = corners[1].x-ell_width;
 472    ellCorners[1].x = corners[1].x;
 473    if(!PATH_DoArcPart(pPath, ellCorners, M_PI_2, 0, FALSE))
 474    {
 475       PATH_UnlockPath( pPath );
 476       return FALSE;
 477    }
 478
 479    IntGdiCloseFigure(pPath);
 480    PATH_UnlockPath( pPath );
 481    return TRUE;
 482 }
 483
 484 /* PATH_Ellipse
 485  *
 486  * Should be called when a call to Ellipse is performed on a DC that has
 487  * an open path. This adds four Bezier splines representing the ellipse
 488  * to the path. Returns TRUE if successful, else FALSE.
 489  */
 490 BOOL
 491 FASTCALL
 492 PATH_Ellipse ( PDC dc, INT x1, INT y1, INT x2, INT y2 )
 493 {
 494   PPATH pPath;
 495   /* TODO: This should probably be revised to call PATH_AngleArc */
 496   /* (once it exists) */
 497   BOOL Ret = PATH_Arc ( dc, x1, y1, x2, y2, x1, (y1+y2)/2, x1, (y1+y2)/2, GdiTypeArc );
 498   if (Ret)
 499   {
 500      pPath = PATH_LockPath( dc->dclevel.hPath );
 501      if (!pPath) return FALSE;
 502      IntGdiCloseFigure(pPath);
 503      PATH_UnlockPath( pPath );
 504   }
 505   return Ret;
 506 }
 507
 508 /* PATH_Arc
 509  *
 510  * Should be called when a call to Arc is performed on a DC that has
 511  * an open path. This adds up to five Bezier splines representing the arc
 512  * to the path. When 'lines' is 1, we add 1 extra line to get a chord,
 513  * when 'lines' is 2, we add 2 extra lines to get a pie, and when 'lines' is
 514  * -1 we add 1 extra line from the current DC position to the starting position
 515  * of the arc before drawing the arc itself (arcto). Returns TRUE if successful,
 516  * else FALSE.
 517  */
 518 BOOL
 519 FASTCALL
 520 PATH_Arc ( PDC dc, INT x1, INT y1, INT x2, INT y2,
 521    INT xStart, INT yStart, INT xEnd, INT yEnd, INT lines)
 522 {
 523   double  angleStart, angleEnd, angleStartQuadrant, angleEndQuadrant=0.0;
 524           /* Initialize angleEndQuadrant to silence gcc's warning */
 525   double  x, y;
 526   FLOAT_POINT corners[2], pointStart, pointEnd;
 527   POINT   centre, pointCurPos;
 528   BOOL    start, end, Ret = TRUE;
 529   INT     temp;
 530   BOOL    clockwise;
 531   PPATH   pPath;
 532
 533   /* FIXME: This function should check for all possible error returns */
 534   /* FIXME: Do we have to respect newStroke? */
 535
 536   ASSERT ( dc );
 537
 538   pPath = PATH_LockPath( dc->dclevel.hPath );
 539   if (!pPath) return FALSE;
 540
 541   clockwise = ((dc->dclevel.flPath & DCPATH_CLOCKWISE) != 0);
 542
 543   /* Check that path is open */
 544   if ( pPath->state != PATH_Open )
 545   {
 546     Ret = FALSE;
 547     goto ArcExit;
 548   }
 549
 550   /* Check for zero height / width */
 551   /* FIXME: Only in GM_COMPATIBLE? */
 552   if ( x1==x2 || y1==y2 )
 553   {
 554     Ret = TRUE;
 555     goto ArcExit;
 556   }
 557   /* Convert points to device coordinates */
 558   corners[0].x=(FLOAT)x1;
 559   corners[0].y=(FLOAT)y1;
 560   corners[1].x=(FLOAT)x2;
 561   corners[1].y=(FLOAT)y2;
 562   pointStart.x=(FLOAT)xStart;
 563   pointStart.y=(FLOAT)yStart;
 564   pointEnd.x=(FLOAT)xEnd;
 565   pointEnd.y=(FLOAT)yEnd;
 566   INTERNAL_LPTODP_FLOAT(dc, corners);
 567   INTERNAL_LPTODP_FLOAT(dc, corners+1);
 568   INTERNAL_LPTODP_FLOAT(dc, &pointStart);
 569   INTERNAL_LPTODP_FLOAT(dc, &pointEnd);
 570
 571   /* Make sure first corner is top left and second corner is bottom right */
 572   if ( corners[0].x > corners[1].x )
 573   {
 574     temp=corners[0].x;
 575     corners[0].x=corners[1].x;
 576     corners[1].x=temp;
 577   }
 578   if ( corners[0].y > corners[1].y )
 579   {
 580     temp=corners[0].y;
 581     corners[0].y=corners[1].y;
 582     corners[1].y=temp;
 583   }
 584
 585   /* Compute start and end angle */
 586   PATH_NormalizePoint(corners, &pointStart, &x, &y);
 587   angleStart=atan2(y, x);
 588   PATH_NormalizePoint(corners, &pointEnd, &x, &y);
 589   angleEnd=atan2(y, x);
 590
 591   /* Make sure the end angle is "on the right side" of the start angle */
 592   if ( clockwise )
 593   {
 594     if ( angleEnd <= angleStart )
 595     {
 596       angleEnd+=2*M_PI;
 597       ASSERT(angleEnd>=angleStart);
 598     }
 599   }
 600   else
 601   {
 602     if(angleEnd>=angleStart)
 603     {
 604       angleEnd-=2*M_PI;
 605       ASSERT(angleEnd<=angleStart);
 606     }
 607   }
 608
 609   /* In GM_COMPATIBLE, don't include bottom and right edges */
 610   if (dc->pdcattr->iGraphicsMode == GM_COMPATIBLE )
 611   {
 612     corners[1].x--;
 613     corners[1].y--;
 614   }
 615
 616   /* arcto: Add a PT_MOVETO only if this is the first entry in a stroke */
 617   if(lines==GdiTypeArcTo && pPath->newStroke) // -1
 618   {
 619      pPath->newStroke=FALSE;
 620      IntGetCurrentPositionEx ( dc, &pointCurPos );
 621      CoordLPtoDP(dc, &pointCurPos);
 622      if(!PATH_AddEntry(pPath, &pointCurPos, PT_MOVETO))
 623      {
 624        Ret = FALSE;
 625        goto ArcExit;
 626      }
 627   }
 628
 629   /* Add the arc to the path with one Bezier spline per quadrant that the
 630    * arc spans */
 631   start=TRUE;
 632   end=FALSE;
 633   do
 634   {
 635     /* Determine the start and end angles for this quadrant */
 636     if(start)
 637     {
 638       angleStartQuadrant=angleStart;
 639       if ( clockwise )
 640         angleEndQuadrant=(floor(angleStart/M_PI_2)+1.0)*M_PI_2;
 641       else
 642         angleEndQuadrant=(ceil(angleStart/M_PI_2)-1.0)*M_PI_2;
 643     }
 644     else
 645     {
 646       angleStartQuadrant=angleEndQuadrant;
 647       if ( clockwise )
 648         angleEndQuadrant+=M_PI_2;
 649       else
 650         angleEndQuadrant-=M_PI_2;
 651     }
 652
 653     /* Have we reached the last part of the arc? */
 654     if ( (clockwise && angleEnd<angleEndQuadrant)
 655       || (!clockwise && angleEnd>angleEndQuadrant)
 656       )
 657     {
 658       /* Adjust the end angle for this quadrant */
 659      angleEndQuadrant = angleEnd;
 660      end = TRUE;
 661     }
 662
 663     /* Add the Bezier spline to the path */
 664     PATH_DoArcPart ( pPath, corners, angleStartQuadrant, angleEndQuadrant,
 665        start ? (lines==GdiTypeArcTo ? PT_LINETO : PT_MOVETO) : FALSE ); // -1
 666     start = FALSE;
 667   } while(!end);
 668
 669   /* chord: close figure. pie: add line and close figure */
 670   if (lines==GdiTypeChord) // 1
 671   {
 672       IntGdiCloseFigure(pPath);
 673   }
 674   else if (lines==GdiTypePie) // 2
 675   {
 676       centre.x = (corners[0].x+corners[1].x)/2;
 677       centre.y = (corners[0].y+corners[1].y)/2;
 678       if(!PATH_AddEntry(pPath, &centre, PT_LINETO | PT_CLOSEFIGURE))
 679          Ret = FALSE;
 680   }
 681 ArcExit:
 682   PATH_UnlockPath( pPath );
 683   return Ret;
 684 }
 685
 686 BOOL
 687 FASTCALL
 688 PATH_PolyBezierTo ( PDC dc, const POINT *pts, DWORD cbPoints )
 689 {
 690   POINT pt;
 691   ULONG i;
 692   PPATH pPath;
 693
 694   ASSERT ( dc );
 695   ASSERT ( pts );
 696   ASSERT ( cbPoints );
 697
 698    pPath = PATH_LockPath( dc->dclevel.hPath );
 699    if (!pPath) return FALSE;
 700
 701   /* Check that path is open */
 702   if ( pPath->state != PATH_Open )
 703   {
 704     PATH_UnlockPath( pPath );
 705     return FALSE;
 706   }
 707
 708   /* Add a PT_MOVETO if necessary */
 709   if ( pPath->newStroke )
 710   {
 711     pPath->newStroke=FALSE;
 712     IntGetCurrentPositionEx ( dc, &pt );
 713     CoordLPtoDP ( dc, &pt );
 714     if ( !PATH_AddEntry(pPath, &pt, PT_MOVETO) )
 715     {
 716         PATH_UnlockPath( pPath );
 717         return FALSE;
 718     }
 719   }
 720
 721   for(i = 0; i < cbPoints; i++)
 722   {
 723     pt = pts[i];
 724     CoordLPtoDP ( dc, &pt );
 725     PATH_AddEntry(pPath, &pt, PT_BEZIERTO);
 726   }
 727   PATH_UnlockPath( pPath );
 728   return TRUE;
 729 }
 730
 731 BOOL
 732 FASTCALL
 733 PATH_PolyBezier ( PDC dc, const POINT *pts, DWORD cbPoints )
 734 {
 735   POINT   pt;
 736   ULONG   i;
 737   PPATH   pPath;
 738
 739   ASSERT ( dc );
 740   ASSERT ( pts );
 741   ASSERT ( cbPoints );
 742
 743   pPath = PATH_LockPath( dc->dclevel.hPath );
 744   if (!pPath) return FALSE;
 745
 746    /* Check that path is open */
 747   if ( pPath->state != PATH_Open )
 748   {
 749     PATH_UnlockPath( pPath );
 750     return FALSE;
 751   }
 752
 753   for ( i = 0; i < cbPoints; i++ )
 754   {
 755     pt = pts[i];
 756     CoordLPtoDP ( dc, &pt );
 757     PATH_AddEntry ( pPath, &pt, (i == 0) ? PT_MOVETO : PT_BEZIERTO );
 758   }
 759   PATH_UnlockPath( pPath );
 760   return TRUE;
 761 }
 762
 763 BOOL
 764 FASTCALL
 765 PATH_Polyline ( PDC dc, const POINT *pts, DWORD cbPoints )
 766 {
 767   POINT   pt;
 768   ULONG   i;
 769   PPATH   pPath;
 770
 771   ASSERT ( dc );
 772   ASSERT ( pts );
 773   ASSERT ( cbPoints );
 774
 775   pPath = PATH_LockPath( dc->dclevel.hPath );
 776   if (!pPath) return FALSE;
 777
 778   /* Check that path is open */
 779   if ( pPath->state != PATH_Open )
 780   {
 781     PATH_UnlockPath( pPath );
 782     return FALSE;
 783   }
 784   for ( i = 0; i < cbPoints; i++ )
 785   {
 786     pt = pts[i];
 787     CoordLPtoDP ( dc, &pt );
 788     PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO : PT_LINETO);
 789   }
 790   PATH_UnlockPath( pPath );
 791   return TRUE;
 792 }
 793
 794 BOOL
 795 FASTCALL
 796 PATH_PolylineTo ( PDC dc, const POINT *pts, DWORD cbPoints )
 797 {
 798   POINT   pt;
 799   ULONG   i;
 800   PPATH   pPath;
 801
 802   ASSERT ( dc );
 803   ASSERT ( pts );
 804   ASSERT ( cbPoints );
 805
 806   pPath = PATH_LockPath( dc->dclevel.hPath );
 807   if (!pPath) return FALSE;
 808
 809   /* Check that path is open */
 810   if ( pPath->state != PATH_Open )
 811   {
 812     PATH_UnlockPath( pPath );
 813     return FALSE;
 814   }
 815
 816   /* Add a PT_MOVETO if necessary */
 817   if ( pPath->newStroke )
 818   {
 819     pPath->newStroke = FALSE;
 820     IntGetCurrentPositionEx ( dc, &pt );
 821     CoordLPtoDP ( dc, &pt );
 822     if ( !PATH_AddEntry(pPath, &pt, PT_MOVETO) )
 823     {
 824       PATH_UnlockPath( pPath );
 825       return FALSE;
 826     }
 827   }
 828
 829   for(i = 0; i < cbPoints; i++)
 830   {
 831     pt = pts[i];
 832     CoordLPtoDP ( dc, &pt );
 833     PATH_AddEntry(pPath, &pt, PT_LINETO);
 834   }
 835   PATH_UnlockPath( pPath );
 836   return TRUE;
 837 }
 838
 839
 840 BOOL
 841 FASTCALL
 842 PATH_Polygon ( PDC dc, const POINT *pts, DWORD cbPoints )
 843 {
 844   POINT   pt;
 845   ULONG   i;
 846   PPATH   pPath;
 847
 848   ASSERT ( dc );
 849   ASSERT ( pts );
 850
 851   pPath = PATH_LockPath( dc->dclevel.hPath );
 852   if (!pPath) return FALSE;
 853
 854   /* Check that path is open */
 855   if ( pPath->state != PATH_Open )
 856   {
 857     PATH_UnlockPath( pPath );
 858     return FALSE;
 859   }
 860
 861   for(i = 0; i < cbPoints; i++)
 862   {
 863     pt = pts[i];
 864     CoordLPtoDP ( dc, &pt );
 865     PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO :
 866       ((i == cbPoints-1) ? PT_LINETO | PT_CLOSEFIGURE :
 867       PT_LINETO));
 868   }
 869   PATH_UnlockPath( pPath );
 870   return TRUE;
 871 }
 872
 873 BOOL
 874 FASTCALL
 875 PATH_PolyPolygon ( PDC dc, const POINT* pts, const INT* counts, UINT polygons )
 876 {
 877   POINT   pt, startpt;
 878   ULONG   poly, point, i;
 879   PPATH   pPath;
 880
 881   ASSERT ( dc );
 882   ASSERT ( pts );
 883   ASSERT ( counts );
 884   ASSERT ( polygons );
 885
 886   pPath = PATH_LockPath( dc->dclevel.hPath );
 887   if (!pPath) return FALSE;
 888
 889   /* Check that path is open */
 890   if ( pPath->state != PATH_Open )
 891   {
 892     PATH_UnlockPath( pPath );
 893     return FALSE;
 894   }
 895
 896   for(i = 0, poly = 0; poly < polygons; poly++)
 897   {
 898     for(point = 0; point < (ULONG) counts[poly]; point++, i++)
 899     {
 900       pt = pts[i];
 901       CoordLPtoDP ( dc, &pt );
 902       if(point == 0) startpt = pt;
 903         PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
 904     }
 905     /* win98 adds an extra line to close the figure for some reason */
 906     PATH_AddEntry(pPath, &startpt, PT_LINETO | PT_CLOSEFIGURE);
 907   }
 908   PATH_UnlockPath( pPath );
 909   return TRUE;
 910 }
 911
 912 BOOL
 913 FASTCALL
 914 PATH_PolyPolyline ( PDC dc, const POINT* pts, const DWORD* counts, DWORD polylines )
 915 {
 916   POINT   pt;
 917   ULONG   poly, point, i;
 918   PPATH   pPath;
 919
 920   ASSERT ( dc );
 921   ASSERT ( pts );
 922   ASSERT ( counts );
 923   ASSERT ( polylines );
 924
 925   pPath = PATH_LockPath( dc->dclevel.hPath );
 926   if (!pPath) return FALSE;
 927
 928   /* Check that path is open */
 929   if ( pPath->state != PATH_Open )
 930   {
 931     PATH_UnlockPath( pPath );
 932     return FALSE;
 933   }
 934
 935   for(i = 0, poly = 0; poly < polylines; poly++)
 936   {
 937     for(point = 0; point < counts[poly]; point++, i++)
 938     {
 939       pt = pts[i];
 940       CoordLPtoDP ( dc, &pt );
 941       PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
 942     }
 943   }
 944   PATH_UnlockPath( pPath );
 945   return TRUE;
 946 }
 947
 948
 949 /* PATH_CheckCorners
 950  *
 951  * Helper function for PATH_RoundRect() and PATH_Rectangle()
 952  */
 953 BOOL PATH_CheckCorners(DC *dc, POINT corners[], INT x1, INT y1, INT x2, INT y2)
 954 {
 955    INT temp;
 956    PDC_ATTR pdcattr = dc->pdcattr;
 957
 958    /* Convert points to device coordinates */
 959    corners[0].x=x1;
 960    corners[0].y=y1;
 961    corners[1].x=x2;
 962    corners[1].y=y2;
 963    CoordLPtoDP(dc, &corners[0]);
 964    CoordLPtoDP(dc, &corners[1]);
 965
 966    /* Make sure first corner is top left and second corner is bottom right */
 967    if(corners[0].x>corners[1].x)
 968    {
 969       temp=corners[0].x;
 970       corners[0].x=corners[1].x;
 971       corners[1].x=temp;
 972    }
 973    if(corners[0].y>corners[1].y)
 974    {
 975       temp=corners[0].y;
 976       corners[0].y=corners[1].y;
 977       corners[1].y=temp;
 978    }
 979
 980    /* In GM_COMPATIBLE, don't include bottom and right edges */
 981    if(pdcattr->iGraphicsMode==GM_COMPATIBLE)
 982    {
 983       corners[1].x--;
 984       corners[1].y--;
 985    }
 986
 987    return TRUE;
 988 }
 989
 990
 991 /* PATH_AddFlatBezier
 992  *
 993  */
 994 BOOL
 995 FASTCALL
 996 PATH_AddFlatBezier ( PPATH pPath, POINT *pt, BOOL closed )
 997 {
 998   POINT *pts;
 999   INT no, i;
1000
1001   pts = GDI_Bezier( pt, 4, &no );
1002   if ( !pts ) return FALSE;
1003
1004   for(i = 1; i < no; i++)
1005     PATH_AddEntry(pPath, &pts[i],  (i == no-1 && closed) ? PT_LINETO | PT_CLOSEFIGURE : PT_LINETO);
1006
1007   ExFreePoolWithTag(pts, TAG_BEZIER);
1008   return TRUE;
1009 }
1010
1011 /* PATH_FlattenPath
1012  *
1013  * Replaces Beziers with line segments
1014  *
1015  */
1016 BOOL
1017 FASTCALL
1018 PATH_FlattenPath(PPATH pPath)
1019 {
1020   PATH newPath;
1021   INT srcpt;
1022
1023   RtlZeroMemory(&newPath, sizeof(newPath));
1024   newPath.state = PATH_Open;
1025   for(srcpt = 0; srcpt < pPath->numEntriesUsed; srcpt++) {
1026     switch(pPath->pFlags[srcpt] & ~PT_CLOSEFIGURE) {
1027       case PT_MOVETO:
1028       case PT_LINETO:
1029         PATH_AddEntry(&newPath, &pPath->pPoints[srcpt], pPath->pFlags[srcpt]);
1030         break;
1031       case PT_BEZIERTO:
1032         PATH_AddFlatBezier(&newPath, &pPath->pPoints[srcpt-1], pPath->pFlags[srcpt+2] & PT_CLOSEFIGURE);
1033         srcpt += 2;
1034         break;
1035     }
1036   }
1037   newPath.state = PATH_Closed;
1038   PATH_AssignGdiPath(pPath, &newPath);
1039   PATH_EmptyPath(&newPath);
1040   return TRUE;
1041 }
1042
1043
1044 /* PATH_PathToRegion
1045  *
1046  * Creates a region from the specified path using the specified polygon
1047  * filling mode. The path is left unchanged. A handle to the region that
1048  * was created is stored in *pHrgn. If successful, TRUE is returned; if an
1049  * error occurs, SetLastError is called with the appropriate value and
1050  * FALSE is returned.
1051  */
1052 BOOL
1053 FASTCALL
1054 PATH_PathToRegion ( PPATH pPath, INT nPolyFillMode, HRGN *pHrgn )
1055 {
1056   int    numStrokes, iStroke, i;
1057   PULONG  pNumPointsInStroke;
1058   HRGN hrgn = 0;
1059
1060   ASSERT(pPath!=NULL);
1061   ASSERT(pHrgn!=NULL);
1062
1063   PATH_FlattenPath ( pPath );
1064
1065   /* FIXME: What happens when number of points is zero? */
1066
1067   /* First pass: Find out how many strokes there are in the path */
1068   /* FIXME: We could eliminate this with some bookkeeping in GdiPath */
1069   numStrokes=0;
1070   for(i=0; i<pPath->numEntriesUsed; i++)
1071     if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1072       numStrokes++;
1073
1074   /* Allocate memory for number-of-points-in-stroke array */
1075   pNumPointsInStroke = ExAllocatePoolWithTag(PagedPool, sizeof(ULONG) * numStrokes, TAG_PATH);
1076   if(!pNumPointsInStroke)
1077   {
1078     SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1079     return FALSE;
1080   }
1081
1082   /* Second pass: remember number of points in each polygon */
1083   iStroke=-1;  /* Will get incremented to 0 at beginning of first stroke */
1084   for(i=0; i<pPath->numEntriesUsed; i++)
1085   {
1086     /* Is this the beginning of a new stroke? */
1087     if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1088     {
1089       iStroke++;
1090       pNumPointsInStroke[iStroke]=0;
1091     }
1092
1093     pNumPointsInStroke[iStroke]++;
1094   }
1095
1096   /* Create a region from the strokes */
1097   hrgn = IntCreatePolyPolygonRgn( pPath->pPoints,
1098                               pNumPointsInStroke,
1099                                       numStrokes,
1100                                    nPolyFillMode);
1101   if(hrgn==(HRGN)0)
1102   {
1103     SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1104     return FALSE;
1105   }
1106
1107   /* Free memory for number-of-points-in-stroke array */
1108   ExFreePoolWithTag(pNumPointsInStroke, TAG_PATH);
1109
1110   /* Success! */
1111   *pHrgn=hrgn;
1112   return TRUE;
1113 }
1114
1115 /* PATH_EmptyPath
1116  *
1117  * Removes all entries from the path and sets the path state to PATH_Null.
1118  */
1119 VOID
1120 FASTCALL
1121 PATH_EmptyPath ( PPATH pPath )
1122 {
1123   ASSERT(pPath!=NULL);
1124
1125   pPath->state=PATH_Null;
1126   pPath->numEntriesUsed=0;
1127 }
1128
1129 /* PATH_AddEntry
1130  *
1131  * Adds an entry to the path. For "flags", pass either PT_MOVETO, PT_LINETO
1132  * or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
1133  * successful, FALSE otherwise (e.g. if not enough memory was available).
1134  */
1135 BOOL
1136 FASTCALL
1137 PATH_AddEntry ( PPATH pPath, const POINT *pPoint, BYTE flags )
1138 {
1139   ASSERT(pPath!=NULL);
1140
1141   /* FIXME: If newStroke is true, perhaps we want to check that we're
1142    * getting a PT_MOVETO
1143    */
1144
1145   /* Check that path is open */
1146   if ( pPath->state != PATH_Open )
1147     return FALSE;
1148
1149   /* Reserve enough memory for an extra path entry */
1150   if ( !PATH_ReserveEntries(pPath, pPath->numEntriesUsed+1) )
1151     return FALSE;
1152
1153   /* Store information in path entry */
1154   pPath->pPoints[pPath->numEntriesUsed]=*pPoint;
1155   pPath->pFlags[pPath->numEntriesUsed]=flags;
1156
1157   /* If this is PT_CLOSEFIGURE, we have to start a new stroke next time */
1158   if((flags & PT_CLOSEFIGURE) == PT_CLOSEFIGURE)
1159     pPath->newStroke=TRUE;
1160
1161   /* Increment entry count */
1162   pPath->numEntriesUsed++;
1163
1164   return TRUE;
1165 }
1166
1167 /* PATH_ReserveEntries
1168  *
1169  * Ensures that at least "numEntries" entries (for points and flags) have
1170  * been allocated; allocates larger arrays and copies the existing entries
1171  * to those arrays, if necessary. Returns TRUE if successful, else FALSE.
1172  */
1173 BOOL
1174 FASTCALL
1175 PATH_ReserveEntries ( PPATH pPath, INT numEntries )
1176 {
1177   INT   numEntriesToAllocate;
1178   POINT *pPointsNew;
1179   BYTE    *pFlagsNew;
1180
1181   ASSERT(pPath!=NULL);
1182   ASSERT(numEntries>=0);
1183
1184   /* Do we have to allocate more memory? */
1185   if(numEntries > pPath->numEntriesAllocated)
1186   {
1187     /* Find number of entries to allocate. We let the size of the array
1188      * grow exponentially, since that will guarantee linear time
1189      * complexity. */
1190     if(pPath->numEntriesAllocated)
1191     {
1192       numEntriesToAllocate=pPath->numEntriesAllocated;
1193       while(numEntriesToAllocate<numEntries)
1194         numEntriesToAllocate=numEntriesToAllocate*GROW_FACTOR_NUMER/GROW_FACTOR_DENOM;
1195     } else
1196        numEntriesToAllocate=numEntries;
1197
1198     /* Allocate new arrays */
1199     pPointsNew=(POINT *)ExAllocatePoolWithTag(PagedPool, numEntriesToAllocate * sizeof(POINT), TAG_PATH);
1200     if(!pPointsNew)
1201       return FALSE;
1202     pFlagsNew=(BYTE *)ExAllocatePoolWithTag(PagedPool, numEntriesToAllocate * sizeof(BYTE), TAG_PATH);
1203     if(!pFlagsNew)
1204     {
1205       ExFreePoolWithTag(pPointsNew, TAG_PATH);
1206       return FALSE;
1207     }
1208
1209     /* Copy old arrays to new arrays and discard old arrays */
1210     if(pPath->pPoints)
1211     {
1212       ASSERT(pPath->pFlags);
1213
1214       memcpy(pPointsNew, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
1215       memcpy(pFlagsNew, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
1216
1217       ExFreePoolWithTag(pPath->pPoints, TAG_PATH);
1218       ExFreePoolWithTag(pPath->pFlags, TAG_PATH);
1219     }
1220     pPath->pPoints=pPointsNew;
1221     pPath->pFlags=pFlagsNew;
1222     pPath->numEntriesAllocated=numEntriesToAllocate;
1223   }
1224
1225   return TRUE;
1226 }
1227
1228 /* PATH_DoArcPart
1229  *
1230  * Creates a Bezier spline that corresponds to part of an arc and appends the
1231  * corresponding points to the path. The start and end angles are passed in
1232  * "angleStart" and "angleEnd"; these angles should span a quarter circle
1233  * at most. If "startEntryType" is non-zero, an entry of that type for the first
1234  * control point is added to the path; otherwise, it is assumed that the current
1235  * position is equal to the first control point.
1236  */
1237 BOOL
1238 FASTCALL
1239 PATH_DoArcPart ( PPATH pPath, FLOAT_POINT corners[],
1240    double angleStart, double angleEnd, BYTE startEntryType )
1241 {
1242   double  halfAngle, a;
1243   double  xNorm[4], yNorm[4];
1244   POINT point;
1245   int i;
1246
1247   ASSERT(fabs(angleEnd-angleStart)<=M_PI_2);
1248
1249   /* FIXME: Is there an easier way of computing this? */
1250
1251   /* Compute control points */
1252   halfAngle=(angleEnd-angleStart)/2.0;
1253   if(fabs(halfAngle)>1e-8)
1254   {
1255     a=4.0/3.0*(1-cos(halfAngle))/sin(halfAngle);
1256     xNorm[0]=cos(angleStart);
1257     yNorm[0]=sin(angleStart);
1258     xNorm[1]=xNorm[0] - a*yNorm[0];
1259     yNorm[1]=yNorm[0] + a*xNorm[0];
1260     xNorm[3]=cos(angleEnd);
1261     yNorm[3]=sin(angleEnd);
1262     xNorm[2]=xNorm[3] + a*yNorm[3];
1263     yNorm[2]=yNorm[3] - a*xNorm[3];
1264   } else
1265     for(i=0; i<4; i++)
1266     {
1267       xNorm[i]=cos(angleStart);
1268       yNorm[i]=sin(angleStart);
1269     }
1270
1271   /* Add starting point to path if desired */
1272   if(startEntryType)
1273   {
1274     PATH_ScaleNormalizedPoint(corners, xNorm[0], yNorm[0], &point);
1275     if(!PATH_AddEntry(pPath, &point, startEntryType))
1276       return FALSE;
1277   }
1278
1279   /* Add remaining control points */
1280   for(i=1; i<4; i++)
1281   {
1282     PATH_ScaleNormalizedPoint(corners, xNorm[i], yNorm[i], &point);
1283     if(!PATH_AddEntry(pPath, &point, PT_BEZIERTO))
1284       return FALSE;
1285   }
1286
1287   return TRUE;
1288 }
1289
1290 /* PATH_ScaleNormalizedPoint
1291  *
1292  * Scales a normalized point (x, y) with respect to the box whose corners are
1293  * passed in "corners". The point is stored in "*pPoint". The normalized
1294  * coordinates (-1.0, -1.0) correspond to corners[0], the coordinates
1295  * (1.0, 1.0) correspond to corners[1].
1296  */
1297 VOID
1298 FASTCALL
1299 PATH_ScaleNormalizedPoint ( FLOAT_POINT corners[], double x,
1300    double y, POINT *pPoint )
1301 {
1302   ASSERT ( corners );
1303   ASSERT ( pPoint );
1304   pPoint->x=GDI_ROUND( (double)corners[0].x + (double)(corners[1].x-corners[0].x)*0.5*(x+1.0) );
1305   pPoint->y=GDI_ROUND( (double)corners[0].y + (double)(corners[1].y-corners[0].y)*0.5*(y+1.0) );
1306 }
1307
1308 /* PATH_NormalizePoint
1309  *
1310  * Normalizes a point with respect to the box whose corners are passed in
1311  * corners. The normalized coordinates are stored in *pX and *pY.
1312  */
1313 VOID
1314 FASTCALL
1315 PATH_NormalizePoint ( FLOAT_POINT corners[],
1316    const FLOAT_POINT *pPoint,
1317    double *pX, double *pY)
1318 {
1319   ASSERT ( corners );
1320   ASSERT ( pPoint );
1321   ASSERT ( pX );
1322   ASSERT ( pY );
1323   *pX=(double)(pPoint->x-corners[0].x)/(double)(corners[1].x-corners[0].x) * 2.0 - 1.0;
1324   *pY=(double)(pPoint->y-corners[0].y)/(double)(corners[1].y-corners[0].y) * 2.0 - 1.0;
1325 }
1326
1327
1328 BOOL FASTCALL PATH_StrokePath(DC *dc, PPATH pPath)
1329 {
1330     BOOL ret = FALSE;
1331     INT i=0;
1332     INT nLinePts, nAlloc;
1333     POINT *pLinePts = NULL;
1334     POINT ptViewportOrg, ptWindowOrg;
1335     SIZE szViewportExt, szWindowExt;
1336     DWORD mapMode, graphicsMode;
1337     XFORM xform;
1338     PDC_ATTR pdcattr = dc->pdcattr;
1339
1340     DPRINT("Enter %s\n", __FUNCTION__);
1341
1342     if (pPath->state != PATH_Closed)
1343         return FALSE;
1344
1345     /* Save the mapping mode info */
1346     mapMode = pdcattr->iMapMode;
1347
1348     DC_vUpdateViewportExt(dc);
1349     szViewportExt = dc->pdcattr->szlViewportExt;
1350     ptViewportOrg = dc->pdcattr->ptlViewportOrg;
1351     szWindowExt = dc->pdcattr->szlWindowExt;
1352     ptWindowOrg = dc->pdcattr->ptlWindowOrg;
1353
1354     MatrixS2XForm(&xform, &dc->dclevel.mxWorldToPage);
1355
1356     /* Set MM_TEXT */
1357     pdcattr->iMapMode = MM_TEXT;
1358     pdcattr->ptlViewportOrg.x = 0;
1359     pdcattr->ptlViewportOrg.y = 0;
1360     pdcattr->ptlWindowOrg.x = 0;
1361     pdcattr->ptlWindowOrg.y = 0;
1362     graphicsMode = pdcattr->iGraphicsMode;
1363     pdcattr->iGraphicsMode = GM_ADVANCED;
1364     IntGdiModifyWorldTransform(dc, &xform, MWT_IDENTITY);
1365     pdcattr->iGraphicsMode = graphicsMode;
1366
1367     /* Allocate enough memory for the worst case without beziers (one PT_MOVETO
1368      * and the rest PT_LINETO with PT_CLOSEFIGURE at the end) plus some buffer
1369      * space in case we get one to keep the number of reallocations small. */
1370     nAlloc = pPath->numEntriesUsed + 1 + 300;
1371     pLinePts = ExAllocatePoolWithTag(PagedPool, nAlloc * sizeof(POINT), TAG_PATH);
1372     if(!pLinePts)
1373     {
1374         DPRINT1("Can't allocate pool!\n");
1375         SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1376         goto end;
1377     }
1378     nLinePts = 0;
1379
1380     for(i = 0; i < pPath->numEntriesUsed; i++)
1381     {
1382         if((i == 0 || (pPath->pFlags[i-1] & PT_CLOSEFIGURE))
1383                 && (pPath->pFlags[i] != PT_MOVETO))
1384         {
1385             DPRINT1("Expected PT_MOVETO %s, got path flag %d\n",
1386                 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1387                 (INT)pPath->pFlags[i]);
1388                 goto end;
1389         }
1390
1391         switch(pPath->pFlags[i])
1392         {
1393         case PT_MOVETO:
1394             DPRINT("Got PT_MOVETO (%ld, %ld)\n",
1395                 pPath->pPoints[i].x, pPath->pPoints[i].y);
1396             if(nLinePts >= 2) IntGdiPolyline(dc, pLinePts, nLinePts);
1397             nLinePts = 0;
1398             pLinePts[nLinePts++] = pPath->pPoints[i];
1399             break;
1400         case PT_LINETO:
1401         case (PT_LINETO | PT_CLOSEFIGURE):
1402             DPRINT("Got PT_LINETO (%ld, %ld)\n",
1403               pPath->pPoints[i].x, pPath->pPoints[i].y);
1404             pLinePts[nLinePts++] = pPath->pPoints[i];
1405             break;
1406         case PT_BEZIERTO:
1407             DPRINT("Got PT_BEZIERTO\n");
1408             if(pPath->pFlags[i+1] != PT_BEZIERTO ||
1409                (pPath->pFlags[i+2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO)
1410             {
1411                 DPRINT1("Path didn't contain 3 successive PT_BEZIERTOs\n");
1412                 ret = FALSE;
1413                 goto end;
1414             }
1415             else
1416             {
1417                 INT nBzrPts, nMinAlloc;
1418                 POINT *pBzrPts = GDI_Bezier(&pPath->pPoints[i-1], 4, &nBzrPts);
1419                 /* Make sure we have allocated enough memory for the lines of
1420                  * this bezier and the rest of the path, assuming we won't get
1421                  * another one (since we won't reallocate again then). */
1422                 nMinAlloc = nLinePts + (pPath->numEntriesUsed - i) + nBzrPts;
1423                 if(nAlloc < nMinAlloc)
1424                 {
1425                     // Reallocate memory
1426
1427                     POINT *Realloc = NULL;
1428                     nAlloc = nMinAlloc * 2;
1429
1430                     Realloc = ExAllocatePoolWithTag(PagedPool,
1431                         nAlloc * sizeof(POINT),
1432                         TAG_PATH);
1433
1434                     if(!Realloc)
1435                     {
1436                         DPRINT1("Can't allocate pool!\n");
1437                         goto end;
1438                     }
1439
1440                     memcpy(Realloc, pLinePts, nLinePts*sizeof(POINT));
1441                     ExFreePoolWithTag(pLinePts, TAG_PATH);
1442                     pLinePts = Realloc;
1443                 }
1444                 memcpy(&pLinePts[nLinePts], &pBzrPts[1], (nBzrPts - 1) * sizeof(POINT));
1445                 nLinePts += nBzrPts - 1;
1446                 ExFreePoolWithTag(pBzrPts, TAG_BEZIER);
1447                 i += 2;
1448             }
1449             break;
1450         default:
1451             DPRINT1("Got path flag %d (not supported)\n", (INT)pPath->pFlags[i]);
1452             goto end;
1453         }
1454
1455         if(pPath->pFlags[i] & PT_CLOSEFIGURE)
1456         {
1457             pLinePts[nLinePts++] = pLinePts[0];
1458         }
1459     }
1460     if(nLinePts >= 2)
1461         IntGdiPolyline(dc, pLinePts, nLinePts);
1462
1463     ret = TRUE;
1464
1465 end:
1466     if(pLinePts) ExFreePoolWithTag(pLinePts, TAG_PATH);
1467
1468     /* Restore the old mapping mode */
1469     pdcattr->iMapMode =  mapMode;
1470     pdcattr->szlWindowExt.cx = szWindowExt.cx;
1471     pdcattr->szlWindowExt.cy = szWindowExt.cy;
1472     pdcattr->ptlWindowOrg.x = ptWindowOrg.x;
1473     pdcattr->ptlWindowOrg.y = ptWindowOrg.y;
1474
1475     pdcattr->szlViewportExt.cx = szViewportExt.cx;
1476     pdcattr->szlViewportExt.cy = szViewportExt.cy;
1477     pdcattr->ptlViewportOrg.x = ptViewportOrg.x;
1478     pdcattr->ptlViewportOrg.y = ptViewportOrg.y;
1479
1480     /* Restore the world transform */
1481     XForm2MatrixS(&dc->dclevel.mxWorldToPage, &xform);
1482
1483     /* If we've moved the current point then get its new position
1484        which will be in device (MM_TEXT) co-ords, convert it to
1485        logical co-ords and re-set it.  This basically updates
1486        dc->CurPosX|Y so that their values are in the correct mapping
1487        mode.
1488     */
1489     if(i > 0)
1490     {
1491         POINT pt;
1492         IntGetCurrentPositionEx(dc, &pt);
1493         IntDPtoLP(dc, &pt, 1);
1494         IntGdiMoveToEx(dc, pt.x, pt.y, NULL);
1495     }
1496     DPRINT("Leave %s, ret=%d\n", __FUNCTION__, ret);
1497     return ret;
1498 }
1499
1500 #define round(x) ((int)((x)>0?(x)+0.5:(x)-0.5))
1501
1502 static
1503 BOOL
1504 FASTCALL
1505 PATH_WidenPath(DC *dc)
1506 {
1507     INT i, j, numStrokes, numOldStrokes, penWidth, penWidthIn, penWidthOut, size, penStyle;
1508     BOOL ret = FALSE;
1509     PPATH pPath, pNewPath, *pStrokes, *pOldStrokes, pUpPath, pDownPath;
1510     EXTLOGPEN *elp;
1511     DWORD obj_type, joint, endcap, penType;
1512     PDC_ATTR pdcattr = dc->pdcattr;
1513
1514     pPath = PATH_LockPath( dc->dclevel.hPath );
1515     if (!pPath) return FALSE;
1516
1517     if(pPath->state == PATH_Open)
1518     {
1519        PATH_UnlockPath( pPath );
1520        SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1521        return FALSE;
1522     }
1523
1524     PATH_FlattenPath(pPath);
1525
1526     size = IntGdiGetObject( pdcattr->hpen, 0, NULL);
1527     if (!size)
1528     {
1529         PATH_UnlockPath( pPath );
1530         SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1531         return FALSE;
1532     }
1533
1534     elp = ExAllocatePoolWithTag(PagedPool, size, TAG_PATH);
1535     (VOID) IntGdiGetObject( pdcattr->hpen, size, elp);
1536
1537     obj_type = GDIOBJ_GetObjectType(pdcattr->hpen);
1538     if(obj_type == GDI_OBJECT_TYPE_PEN)
1539     {
1540         penStyle = ((LOGPEN*)elp)->lopnStyle;
1541     }
1542     else if(obj_type == GDI_OBJECT_TYPE_EXTPEN)
1543     {
1544         penStyle = elp->elpPenStyle;
1545     }
1546     else
1547     {
1548         SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1549         ExFreePoolWithTag(elp, TAG_PATH);
1550         PATH_UnlockPath( pPath );
1551         return FALSE;
1552     }
1553
1554     penWidth = elp->elpWidth;
1555     ExFreePoolWithTag(elp, TAG_PATH);
1556
1557     endcap = (PS_ENDCAP_MASK & penStyle);
1558     joint = (PS_JOIN_MASK & penStyle);
1559     penType = (PS_TYPE_MASK & penStyle);
1560
1561     /* The function cannot apply to cosmetic pens */
1562     if(obj_type == GDI_OBJECT_TYPE_EXTPEN && penType == PS_COSMETIC)
1563     {
1564         PATH_UnlockPath( pPath );
1565         SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1566         return FALSE;
1567     }
1568
1569     penWidthIn = penWidth / 2;
1570     penWidthOut = penWidth / 2;
1571     if(penWidthIn + penWidthOut < penWidth)
1572         penWidthOut++;
1573
1574     numStrokes = 0;
1575     numOldStrokes = 1;
1576
1577     pStrokes    = ExAllocatePoolWithTag(PagedPool, sizeof(PPATH), TAG_PATH);
1578     pStrokes[0] = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1579     PATH_InitGdiPath(pStrokes[0]);
1580     pStrokes[0]->pFlags =   ExAllocatePoolWithTag(PagedPool, pPath->numEntriesUsed * sizeof(INT), TAG_PATH);
1581     pStrokes[0]->pPoints =  ExAllocatePoolWithTag(PagedPool, pPath->numEntriesUsed * sizeof(POINT), TAG_PATH);
1582     pStrokes[0]->numEntriesUsed = 0;
1583
1584     for(i = 0, j = 0; i < pPath->numEntriesUsed; i++, j++)
1585     {
1586         POINT point;
1587         if((i == 0 || (pPath->pFlags[i-1] & PT_CLOSEFIGURE)) &&
1588             (pPath->pFlags[i] != PT_MOVETO))
1589         {
1590             DPRINT1("Expected PT_MOVETO %s, got path flag %c\n",
1591                 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1592                 pPath->pFlags[i]);
1593             return FALSE;
1594         }
1595         switch(pPath->pFlags[i])
1596         {
1597             case PT_MOVETO:
1598                 if(numStrokes > 0)
1599                 {
1600                     pStrokes[numStrokes - 1]->state = PATH_Closed;
1601                 }
1602                 numStrokes++;
1603                 j = 0;
1604                 pOldStrokes = pStrokes; // Save old pointer.
1605                 pStrokes = ExAllocatePoolWithTag(PagedPool, numStrokes * sizeof(PPATH), TAG_PATH);
1606                 RtlCopyMemory(pStrokes, pOldStrokes, numOldStrokes * sizeof(PPATH));
1607                 numOldStrokes = numStrokes; // Save orig count.
1608                 ExFreePoolWithTag(pOldStrokes, TAG_PATH); // Free old pointer.
1609                 pStrokes[numStrokes - 1] = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1610
1611                 PATH_InitGdiPath(pStrokes[numStrokes - 1]);
1612                 pStrokes[numStrokes - 1]->state = PATH_Open;
1613             case PT_LINETO:
1614             case (PT_LINETO | PT_CLOSEFIGURE):
1615                 point.x = pPath->pPoints[i].x;
1616                 point.y = pPath->pPoints[i].y;
1617                 PATH_AddEntry(pStrokes[numStrokes - 1], &point, pPath->pFlags[i]);
1618                 break;
1619             case PT_BEZIERTO:
1620                 /* should never happen because of the FlattenPath call */
1621                 DPRINT1("Should never happen\n");
1622                 break;
1623             default:
1624                 DPRINT1("Got path flag %c\n", pPath->pFlags[i]);
1625                 return FALSE;
1626         }
1627     }
1628
1629     pNewPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1630     PATH_InitGdiPath(pNewPath);
1631     pNewPath->state = PATH_Open;
1632
1633     for(i = 0; i < numStrokes; i++)
1634     {
1635         pUpPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1636         PATH_InitGdiPath(pUpPath);
1637         pUpPath->state = PATH_Open;
1638         pDownPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1639         PATH_InitGdiPath(pDownPath);
1640         pDownPath->state = PATH_Open;
1641
1642         for(j = 0; j < pStrokes[i]->numEntriesUsed; j++)
1643         {
1644             /* Beginning or end of the path if not closed */
1645             if((!(pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) && (j == 0 || j == pStrokes[i]->numEntriesUsed - 1) )
1646             {
1647                 /* Compute segment angle */
1648                 double xo, yo, xa, ya, theta;
1649                 POINT pt;
1650                 FLOAT_POINT corners[2];
1651                 if(j == 0)
1652                 {
1653                     xo = pStrokes[i]->pPoints[j].x;
1654                     yo = pStrokes[i]->pPoints[j].y;
1655                     xa = pStrokes[i]->pPoints[1].x;
1656                     ya = pStrokes[i]->pPoints[1].y;
1657                 }
1658                 else
1659                 {
1660                     xa = pStrokes[i]->pPoints[j - 1].x;
1661                     ya = pStrokes[i]->pPoints[j - 1].y;
1662                     xo = pStrokes[i]->pPoints[j].x;
1663                     yo = pStrokes[i]->pPoints[j].y;
1664                 }
1665                 theta = atan2( ya - yo, xa - xo );
1666                 switch(endcap)
1667                 {
1668                     case PS_ENDCAP_SQUARE :
1669                         pt.x = xo + round(sqrt(2) * penWidthOut * cos(M_PI_4 + theta));
1670                         pt.y = yo + round(sqrt(2) * penWidthOut * sin(M_PI_4 + theta));
1671                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO) );
1672                         pt.x = xo + round(sqrt(2) * penWidthIn * cos(- M_PI_4 + theta));
1673                         pt.y = yo + round(sqrt(2) * penWidthIn * sin(- M_PI_4 + theta));
1674                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1675                         break;
1676                     case PS_ENDCAP_FLAT :
1677                         pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1678                         pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1679                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1680                         pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1681                         pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1682                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1683                         break;
1684                     case PS_ENDCAP_ROUND :
1685                     default :
1686                         corners[0].x = xo - penWidthIn;
1687                         corners[0].y = yo - penWidthIn;
1688                         corners[1].x = xo + penWidthOut;
1689                         corners[1].y = yo + penWidthOut;
1690                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI_2 , theta + 3 * M_PI_4, (j == 0 ? PT_MOVETO : FALSE));
1691                         PATH_DoArcPart(pUpPath ,corners, theta + 3 * M_PI_4 , theta + M_PI, FALSE);
1692                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI, theta +  5 * M_PI_4, FALSE);
1693                         PATH_DoArcPart(pUpPath ,corners, theta + 5 * M_PI_4 , theta + 3 * M_PI_2, FALSE);
1694                         break;
1695                 }
1696             }
1697             /* Corpse of the path */
1698             else
1699             {
1700                 /* Compute angle */
1701                 INT previous, next;
1702                 double xa, ya, xb, yb, xo, yo;
1703                 double alpha, theta, miterWidth;
1704                 DWORD _joint = joint;
1705                 POINT pt;
1706                 PPATH pInsidePath, pOutsidePath;
1707                 if(j > 0 && j < pStrokes[i]->numEntriesUsed - 1)
1708                 {
1709                     previous = j - 1;
1710                     next = j + 1;
1711                 }
1712                 else if (j == 0)
1713                 {
1714                     previous = pStrokes[i]->numEntriesUsed - 1;
1715                     next = j + 1;
1716                 }
1717                 else
1718                 {
1719                     previous = j - 1;
1720                     next = 0;
1721                 }
1722                 xo = pStrokes[i]->pPoints[j].x;
1723                 yo = pStrokes[i]->pPoints[j].y;
1724                 xa = pStrokes[i]->pPoints[previous].x;
1725                 ya = pStrokes[i]->pPoints[previous].y;
1726                 xb = pStrokes[i]->pPoints[next].x;
1727                 yb = pStrokes[i]->pPoints[next].y;
1728                 theta = atan2( yo - ya, xo - xa );
1729                 alpha = atan2( yb - yo, xb - xo ) - theta;
1730                 if (alpha > 0) alpha -= M_PI;
1731                 else alpha += M_PI;
1732                 if(_joint == PS_JOIN_MITER && dc->dclevel.laPath.eMiterLimit < fabs(1 / sin(alpha/2)))
1733                 {
1734                     _joint = PS_JOIN_BEVEL;
1735                 }
1736                 if(alpha > 0)
1737                 {
1738                     pInsidePath = pUpPath;
1739                     pOutsidePath = pDownPath;
1740                 }
1741                 else if(alpha < 0)
1742                 {
1743                     pInsidePath = pDownPath;
1744                     pOutsidePath = pUpPath;
1745                 }
1746                 else
1747                 {
1748                     continue;
1749                 }
1750                 /* Inside angle points */
1751                 if(alpha > 0)
1752                 {
1753                     pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1754                     pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1755                 }
1756                 else
1757                 {
1758                     pt.x = xo + round( penWidthIn * cos(theta + M_PI_2) );
1759                     pt.y = yo + round( penWidthIn * sin(theta + M_PI_2) );
1760                 }
1761                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1762                 if(alpha > 0)
1763                 {
1764                     pt.x = xo + round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1765                     pt.y = yo + round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1766                 }
1767                 else
1768                 {
1769                     pt.x = xo - round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1770                     pt.y = yo - round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1771                 }
1772                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1773                 /* Outside angle point */
1774                 switch(_joint)
1775                 {
1776                      case PS_JOIN_MITER :
1777                         miterWidth = fabs(penWidthOut / cos(M_PI_2 - fabs(alpha) / 2));
1778                         pt.x = xo + round( miterWidth * cos(theta + alpha / 2) );
1779                         pt.y = yo + round( miterWidth * sin(theta + alpha / 2) );
1780                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1781                         break;
1782                     case PS_JOIN_BEVEL :
1783                         if(alpha > 0)
1784                         {
1785                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1786                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1787                         }
1788                         else
1789                         {
1790                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1791                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1792                         }
1793                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1794                         if(alpha > 0)
1795                         {
1796                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1797                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1798                         }
1799                         else
1800                         {
1801                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1802                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1803                         }
1804                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1805                         break;
1806                     case PS_JOIN_ROUND :
1807                     default :
1808                         if(alpha > 0)
1809                         {
1810                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1811                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1812                         }
1813                         else
1814                         {
1815                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1816                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1817                         }
1818                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1819                         pt.x = xo + round( penWidthOut * cos(theta + alpha / 2) );
1820                         pt.y = yo + round( penWidthOut * sin(theta + alpha / 2) );
1821                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1822                         if(alpha > 0)
1823                         {
1824                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1825                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1826                         }
1827                         else
1828                         {
1829                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1830                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1831                         }
1832                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1833                         break;
1834                 }
1835             }
1836         }
1837         for(j = 0; j < pUpPath->numEntriesUsed; j++)
1838         {
1839             POINT pt;
1840             pt.x = pUpPath->pPoints[j].x;
1841             pt.y = pUpPath->pPoints[j].y;
1842             PATH_AddEntry(pNewPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1843         }
1844         for(j = 0; j < pDownPath->numEntriesUsed; j++)
1845         {
1846             POINT pt;
1847             pt.x = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].x;
1848             pt.y = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].y;
1849             PATH_AddEntry(pNewPath, &pt, ( (j == 0 && (pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) ? PT_MOVETO : PT_LINETO));
1850         }
1851
1852         PATH_DestroyGdiPath(pStrokes[i]);
1853         ExFreePoolWithTag(pStrokes[i], TAG_PATH);
1854         PATH_DestroyGdiPath(pUpPath);
1855         ExFreePoolWithTag(pUpPath, TAG_PATH);
1856         PATH_DestroyGdiPath(pDownPath);
1857         ExFreePoolWithTag(pDownPath, TAG_PATH);
1858     }
1859     ExFreePoolWithTag(pStrokes, TAG_PATH);
1860
1861     pNewPath->state = PATH_Closed;
1862     if (!(ret = PATH_AssignGdiPath(pPath, pNewPath)))
1863         DPRINT1("Assign path failed\n");
1864     PATH_DestroyGdiPath(pNewPath);
1865     ExFreePoolWithTag(pNewPath, TAG_PATH);
1866     return ret;
1867 }
1868
1869 static inline INT int_from_fixed(FIXED f)
1870 {
1871     return (f.fract >= 0x8000) ? (f.value + 1) : f.value;
1872 }
1873
1874 /**********************************************************************
1875  *      PATH_BezierTo
1876  *
1877  * internally used by PATH_add_outline
1878  */
1879 static
1880 VOID
1881 FASTCALL
1882 PATH_BezierTo(PPATH pPath, POINT *lppt, INT n)
1883 {
1884     if (n < 2) return;
1885
1886     if (n == 2)
1887     {
1888         PATH_AddEntry(pPath, &lppt[1], PT_LINETO);
1889     }
1890     else if (n == 3)
1891     {
1892         PATH_AddEntry(pPath, &lppt[0], PT_BEZIERTO);
1893         PATH_AddEntry(pPath, &lppt[1], PT_BEZIERTO);
1894         PATH_AddEntry(pPath, &lppt[2], PT_BEZIERTO);
1895     }
1896     else
1897     {
1898         POINT pt[3];
1899         INT i = 0;
1900
1901         pt[2] = lppt[0];
1902         n--;
1903
1904         while (n > 2)
1905         {
1906             pt[0] = pt[2];
1907             pt[1] = lppt[i+1];
1908             pt[2].x = (lppt[i+2].x + lppt[i+1].x) / 2;
1909             pt[2].y = (lppt[i+2].y + lppt[i+1].y) / 2;
1910             PATH_BezierTo(pPath, pt, 3);
1911             n--;
1912             i++;
1913         }
1914
1915         pt[0] = pt[2];
1916         pt[1] = lppt[i+1];
1917         pt[2] = lppt[i+2];
1918         PATH_BezierTo(pPath, pt, 3);
1919     }
1920 }
1921
1922 static
1923 BOOL
1924 FASTCALL
1925 PATH_add_outline(PDC dc, INT x, INT y, TTPOLYGONHEADER *header, DWORD size)
1926 {
1927   PPATH pPath;
1928   TTPOLYGONHEADER *start;
1929   POINT pt;
1930
1931   start = header;
1932
1933   pPath = PATH_LockPath(dc->dclevel.hPath);
1934   {
1935      return FALSE;
1936   }
1937
1938   while ((char *)header < (char *)start + size)
1939   {
1940      TTPOLYCURVE *curve;
1941
1942      if (header->dwType != TT_POLYGON_TYPE)
1943      {
1944         DPRINT1("Unknown header type %d\n", header->dwType);
1945         return FALSE;
1946      }
1947
1948      pt.x = x + int_from_fixed(header->pfxStart.x);
1949      pt.y = y - int_from_fixed(header->pfxStart.y);
1950      IntLPtoDP(dc, &pt, 1);
1951      PATH_AddEntry(pPath, &pt, PT_MOVETO);
1952
1953      curve = (TTPOLYCURVE *)(header + 1);
1954
1955      while ((char *)curve < (char *)header + header->cb)
1956      {
1957         /*DPRINT1("curve->wType %d\n", curve->wType);*/
1958
1959         switch(curve->wType)
1960         {
1961            case TT_PRIM_LINE:
1962            {
1963               WORD i;
1964
1965               for (i = 0; i < curve->cpfx; i++)
1966               {
1967                  pt.x = x + int_from_fixed(curve->apfx[i].x);
1968                  pt.y = y - int_from_fixed(curve->apfx[i].y);
1969                  IntLPtoDP(dc, &pt, 1);
1970                  PATH_AddEntry(pPath, &pt, PT_LINETO);
1971               }
1972               break;
1973            }
1974
1975            case TT_PRIM_QSPLINE:
1976            case TT_PRIM_CSPLINE:
1977            {
1978               WORD i;
1979               POINTFX ptfx;
1980               POINT *pts = ExAllocatePoolWithTag(PagedPool, (curve->cpfx + 1) * sizeof(POINT), TAG_PATH);
1981
1982               if (!pts) return FALSE;
1983
1984               ptfx = *(POINTFX *)((char *)curve - sizeof(POINTFX));
1985
1986               pts[0].x = x + int_from_fixed(ptfx.x);
1987               pts[0].y = y - int_from_fixed(ptfx.y);
1988               IntLPtoDP(dc, &pts[0], 1);
1989
1990               for (i = 0; i < curve->cpfx; i++)
1991               {
1992                   pts[i + 1].x = x + int_from_fixed(curve->apfx[i].x);
1993                   pts[i + 1].y = y - int_from_fixed(curve->apfx[i].y);
1994                   IntLPtoDP(dc, &pts[i + 1], 1);
1995               }
1996
1997               PATH_BezierTo(pPath, pts, curve->cpfx + 1);
1998
1999               ExFreePoolWithTag(pts, TAG_PATH);
2000               break;
2001            }
2002
2003            default:
2004               DPRINT1("Unknown curve type %04x\n", curve->wType);
2005               return FALSE;
2006         }
2007
2008         curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
2009      }
2010      header = (TTPOLYGONHEADER *)((char *)header + header->cb);
2011   }
2012
2013   IntGdiCloseFigure( pPath );
2014   PATH_UnlockPath( pPath );
2015   return TRUE;
2016 }
2017
2018 /**********************************************************************
2019  *      PATH_ExtTextOut
2020  */
2021 BOOL
2022 FASTCALL
2023 PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECTL *lprc,
2024                      LPCWSTR str, UINT count, const INT *dx)
2025 {
2026     unsigned int idx;
2027     double cosEsc, sinEsc;
2028     PDC_ATTR pdcattr;
2029     PTEXTOBJ TextObj;
2030     LOGFONTW lf;
2031     POINTL org;
2032     INT offset = 0, xoff = 0, yoff = 0;
2033
2034     if (!count) return TRUE;
2035
2036     pdcattr = dc->pdcattr;
2037
2038     TextObj = RealizeFontInit( pdcattr->hlfntNew);
2039     if ( !TextObj ) return FALSE;
2040
2041     FontGetObject( TextObj, sizeof(lf), &lf);
2042
2043     if (lf.lfEscapement != 0)
2044     {
2045         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2046         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2047     } else
2048     {
2049         cosEsc = 1;
2050         sinEsc = 0;
2051     }
2052
2053     IntGdiGetDCOrg(dc, &org);
2054
2055     for (idx = 0; idx < count; idx++)
2056     {
2057         GLYPHMETRICS gm;
2058         DWORD dwSize;
2059         void *outline;
2060
2061         dwSize = ftGdiGetGlyphOutline( dc,
2062                                        str[idx],
2063                                        GGO_GLYPH_INDEX | GGO_NATIVE,
2064                                        &gm,
2065                                        0,
2066                                        NULL,
2067                                        NULL,
2068                                        TRUE);
2069         if (!dwSize) return FALSE;
2070
2071         outline = ExAllocatePoolWithTag(PagedPool, dwSize, TAG_PATH);
2072         if (!outline) return FALSE;
2073
2074         ftGdiGetGlyphOutline( dc,
2075                               str[idx],
2076                               GGO_GLYPH_INDEX | GGO_NATIVE,
2077                               &gm,
2078                               dwSize,
2079                               outline,
2080                               NULL,
2081                               TRUE);
2082
2083         PATH_add_outline(dc, org.x + x + xoff, org.x + y + yoff, outline, dwSize);
2084
2085         ExFreePoolWithTag(outline, TAG_PATH);
2086
2087         if (dx)
2088         {
2089             offset += dx[idx];
2090             xoff = offset * cosEsc;
2091             yoff = offset * -sinEsc;
2092         }
2093         else
2094         {
2095             xoff += gm.gmCellIncX;
2096             yoff += gm.gmCellIncY;
2097         }
2098     }
2099     return TRUE;
2100 }
2101
2102
2103 /***********************************************************************
2104  * Exported functions
2105  */
2106
2107 BOOL
2108 APIENTRY
2109 NtGdiAbortPath(HDC  hDC)
2110 {
2111   PPATH pPath;
2112   PDC dc = DC_LockDc ( hDC );
2113   if ( !dc )
2114   {
2115      SetLastWin32Error(ERROR_INVALID_HANDLE);
2116      return FALSE;
2117   }
2118
2119   pPath = PATH_LockPath(dc->dclevel.hPath);
2120   {
2121       DC_UnlockDc(dc);
2122       return FALSE;
2123   }
2124
2125   PATH_EmptyPath(pPath);
2126
2127   PATH_UnlockPath(pPath);
2128   DC_UnlockDc ( dc );
2129   return TRUE;
2130 }
2131
2132 BOOL
2133 APIENTRY
2134 NtGdiBeginPath( HDC  hDC )
2135 {
2136   PPATH pPath;
2137   PDC dc;
2138
2139   dc = DC_LockDc ( hDC );
2140   if ( !dc )
2141   {
2142      SetLastWin32Error(ERROR_INVALID_HANDLE);
2143      return FALSE;
2144   }
2145
2146   /* If path is already open, do nothing. Check if not Save DC state */
2147     if ((dc->dclevel.flPath & DCPATH_ACTIVE) && !(dc->dclevel.flPath & DCPATH_SAVE))
2148   {
2149      DC_UnlockDc ( dc );
2150      return TRUE;
2151   }
2152
2153   if ( dc->dclevel.hPath )
2154   {
2155      DPRINT1("BeginPath 1 0x%x\n", dc->dclevel.hPath);
2156      if ( !(dc->dclevel.flPath & DCPATH_SAVE) )
2157      {  // Remove previous handle.
2158         if (!PATH_Delete(dc->dclevel.hPath))
2159         {
2160            DC_UnlockDc ( dc );
2161            return FALSE;
2162         }
2163      }
2164      else
2165      {  // Clear flags and Handle.
2166         dc->dclevel.flPath &= ~(DCPATH_SAVE|DCPATH_ACTIVE);
2167         dc->dclevel.hPath = NULL;
2168      }
2169   }
2170   pPath = PATH_AllocPathWithHandle();
2171   if (!pPath)
2172   {
2173      SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
2174      return FALSE;
2175   }
2176   dc->dclevel.flPath |= DCPATH_ACTIVE; // Set active ASAP!
2177
2178   dc->dclevel.hPath = pPath->BaseObject.hHmgr;
2179
2180   DPRINT1("BeginPath 2 h 0x%x p 0x%x\n", dc->dclevel.hPath, pPath);
2181   // Path handles are shared. Also due to recursion with in the same thread.
2182   GDIOBJ_UnlockObjByPtr((POBJ)pPath);       // Unlock
2183   pPath = PATH_LockPath(dc->dclevel.hPath); // Share Lock.
2184
2185   /* Make sure that path is empty */
2186   PATH_EmptyPath( pPath );
2187
2188   /* Initialize variables for new path */
2189   pPath->newStroke = TRUE;
2190   pPath->state = PATH_Open;
2191
2192   PATH_UnlockPath(pPath);
2193   DC_UnlockDc ( dc );
2194   return TRUE;
2195 }
2196
2197 BOOL
2198 APIENTRY
2199 NtGdiCloseFigure(HDC hDC)
2200 {
2201   BOOL Ret = FALSE; // default to failure
2202   PDC pDc;
2203   PPATH pPath;
2204
2205   DPRINT("Enter %s\n", __FUNCTION__);
2206
2207   pDc = DC_LockDc(hDC);
2208   if (!pDc)
2209   {
2210      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2211      return FALSE;
2212   }
2213   pPath = PATH_LockPath( pDc->dclevel.hPath );
2214   if (!pPath)
2215   {
2216      DC_UnlockDc(pDc);
2217      return FALSE;
2218   }
2219
2220   if (pPath->state==PATH_Open)
2221   {
2222      IntGdiCloseFigure(pPath);
2223      Ret = TRUE;
2224   }
2225   else
2226   {
2227      // FIXME: check if lasterror is set correctly
2228      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2229   }
2230
2231   PATH_UnlockPath( pPath );
2232   DC_UnlockDc(pDc);
2233   return Ret;
2234 }
2235
2236 BOOL
2237 APIENTRY
2238 NtGdiEndPath(HDC  hDC)
2239 {
2240   BOOL ret = TRUE;
2241   PPATH pPath;
2242   PDC dc = DC_LockDc ( hDC );
2243
2244   if ( !dc )
2245   {
2246      SetLastWin32Error(ERROR_INVALID_HANDLE);
2247      return FALSE;
2248   }
2249
2250   pPath = PATH_LockPath( dc->dclevel.hPath );
2251   if (!pPath)
2252   {
2253      DC_UnlockDc ( dc );
2254      return FALSE;
2255   }
2256   /* Check that path is currently being constructed */
2257   if ( (pPath->state != PATH_Open) || !(dc->dclevel.flPath & DCPATH_ACTIVE) )
2258   {
2259     DPRINT1("EndPath ERROR! 0x%x\n", dc->dclevel.hPath);
2260     SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2261     ret = FALSE;
2262   }
2263   /* Set flag to indicate that path is finished */
2264   else
2265   {
2266      DPRINT1("EndPath 0x%x\n", dc->dclevel.hPath);
2267      pPath->state = PATH_Closed;
2268      dc->dclevel.flPath &= ~DCPATH_ACTIVE;
2269   }
2270   PATH_UnlockPath( pPath );
2271   DC_UnlockDc ( dc );
2272   return ret;
2273 }
2274
2275 BOOL
2276 APIENTRY
2277 NtGdiFillPath(HDC  hDC)
2278 {
2279   BOOL ret = FALSE;
2280   PPATH pPath;
2281   PDC_ATTR pdcattr;
2282   PDC dc = DC_LockDc ( hDC );
2283
2284   if ( !dc )
2285   {
2286      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2287      return FALSE;
2288   }
2289   pPath = PATH_LockPath( dc->dclevel.hPath );
2290   if (!pPath)
2291   {
2292      DC_UnlockDc ( dc );
2293      return FALSE;
2294   }
2295
2296   pdcattr = dc->pdcattr;
2297
2298   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2299       DC_vUpdateLineBrush(dc);
2300
2301   ret = PATH_FillPath( dc, pPath );
2302   if ( ret )
2303   {
2304     /* FIXME: Should the path be emptied even if conversion
2305        failed? */
2306     PATH_EmptyPath( pPath );
2307   }
2308
2309   PATH_UnlockPath( pPath );
2310   DC_UnlockDc ( dc );
2311   return ret;
2312 }
2313
2314 BOOL
2315 APIENTRY
2316 NtGdiFlattenPath(HDC  hDC)
2317 {
2318    BOOL Ret = FALSE;
2319    DC *pDc;
2320    PPATH pPath;
2321
2322    DPRINT("Enter %s\n", __FUNCTION__);
2323
2324    pDc = DC_LockDc(hDC);
2325    if (!pDc)
2326    {
2327       SetLastWin32Error(ERROR_INVALID_HANDLE);
2328       return FALSE;
2329    }
2330
2331    pPath = PATH_LockPath( pDc->dclevel.hPath );
2332    if (!pPath)
2333    {
2334       DC_UnlockDc ( pDc );
2335       return FALSE;
2336    }
2337    if (pPath->state == PATH_Open)
2338       Ret = PATH_FlattenPath(pPath);
2339
2340    PATH_UnlockPath( pPath );
2341    DC_UnlockDc(pDc);
2342    return Ret;
2343 }
2344
2345
2346 BOOL
2347 APIENTRY
2348 NtGdiGetMiterLimit(
2349     IN HDC hdc,
2350     OUT PDWORD pdwOut)
2351 {
2352   DC *pDc;
2353   gxf_long worker;
2354   NTSTATUS Status = STATUS_SUCCESS;
2355
2356   if (!(pDc = DC_LockDc(hdc)))
2357   {
2358      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2359      return FALSE;
2360   }
2361
2362   worker.f = pDc->dclevel.laPath.eMiterLimit;
2363
2364   if (pdwOut)
2365   {
2366       _SEH2_TRY
2367       {
2368           ProbeForWrite(pdwOut,
2369                  sizeof(DWORD),
2370                              1);
2371           *pdwOut = worker.l;
2372       }
2373       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2374       {
2375           Status = _SEH2_GetExceptionCode();
2376       }
2377        _SEH2_END;
2378       if (!NT_SUCCESS(Status))
2379       {
2380          SetLastNtError(Status);
2381          DC_UnlockDc(pDc);
2382          return FALSE;
2383       }
2384   }
2385
2386   DC_UnlockDc(pDc);
2387   return TRUE;
2388
2389 }
2390
2391 INT
2392 APIENTRY
2393 NtGdiGetPath(
2394    HDC hDC,
2395    LPPOINT Points,
2396    LPBYTE Types,
2397    INT nSize)
2398 {
2399   INT ret = -1;
2400   PPATH pPath;
2401
2402   DC *dc = DC_LockDc(hDC);
2403   if (!dc)
2404   {
2405      DPRINT1("Can't lock dc!\n");
2406      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2407      return -1;
2408   }
2409
2410   pPath = PATH_LockPath( dc->dclevel.hPath );
2411   if (!pPath)
2412   {
2413      DC_UnlockDc ( dc );
2414      return -1;
2415   }
2416
2417   if (pPath->state != PATH_Closed)
2418   {
2419      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2420      goto done;
2421   }
2422
2423   if (nSize==0)
2424   {
2425      ret = pPath->numEntriesUsed;
2426   }
2427   else if(nSize<pPath->numEntriesUsed)
2428   {
2429      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2430      goto done;
2431   }
2432   else
2433   {
2434       _SEH2_TRY
2435       {
2436          memcpy(Points, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
2437          memcpy(Types, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
2438
2439          /* Convert the points to logical coordinates */
2440          IntDPtoLP(dc, Points, pPath->numEntriesUsed);
2441
2442          ret = pPath->numEntriesUsed;
2443       }
2444       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2445       {
2446          SetLastNtError(_SEH2_GetExceptionCode());
2447       }
2448       _SEH2_END
2449   }
2450
2451 done:
2452   PATH_UnlockPath( pPath );
2453   DC_UnlockDc(dc);
2454   return ret;
2455 }
2456
2457 HRGN
2458 APIENTRY
2459 NtGdiPathToRegion(HDC  hDC)
2460 {
2461   PPATH pPath;
2462   HRGN  hrgnRval = 0;
2463   DC *pDc;
2464   PDC_ATTR pdcattr;
2465
2466   DPRINT("Enter %s\n", __FUNCTION__);
2467
2468   pDc = DC_LockDc(hDC);
2469   if (!pDc)
2470   {
2471      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2472      return NULL;
2473   }
2474
2475   pdcattr = pDc->pdcattr;
2476
2477   pPath = PATH_LockPath( pDc->dclevel.hPath );
2478   if (!pPath)
2479   {
2480      DC_UnlockDc ( pDc );
2481      return NULL;
2482   }
2483
2484   if (pPath->state!=PATH_Closed)
2485   {
2486      //FIXME: check that setlasterror is being called correctly
2487      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2488   }
2489   else
2490   {
2491      /* FIXME: Should we empty the path even if conversion failed? */
2492      if(PATH_PathToRegion(pPath, pdcattr->jFillMode, &hrgnRval))
2493           PATH_EmptyPath(pPath);
2494   }
2495
2496   PATH_UnlockPath( pPath );
2497   DC_UnlockDc(pDc);
2498   return hrgnRval;
2499 }
2500
2501 BOOL
2502 APIENTRY
2503 NtGdiSetMiterLimit(
2504     IN HDC hdc,
2505     IN DWORD dwNew,
2506     IN OUT OPTIONAL PDWORD pdwOut)
2507 {
2508   DC *pDc;
2509   gxf_long worker, worker1;
2510   NTSTATUS Status = STATUS_SUCCESS;
2511
2512   if (!(pDc = DC_LockDc(hdc)))
2513   {
2514      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2515      return FALSE;
2516   }
2517
2518   worker.l  = dwNew;
2519   worker1.f = pDc->dclevel.laPath.eMiterLimit;
2520   pDc->dclevel.laPath.eMiterLimit = worker.f;
2521
2522   if (pdwOut)
2523   {
2524       _SEH2_TRY
2525       {
2526           ProbeForWrite(pdwOut,
2527                  sizeof(DWORD),
2528                              1);
2529           *pdwOut = worker1.l;
2530       }
2531       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2532       {
2533           Status = _SEH2_GetExceptionCode();
2534       }
2535        _SEH2_END;
2536       if (!NT_SUCCESS(Status))
2537       {
2538          SetLastNtError(Status);
2539          DC_UnlockDc(pDc);
2540          return FALSE;
2541       }
2542   }
2543
2544   DC_UnlockDc(pDc);
2545   return TRUE;
2546 }
2547
2548 BOOL
2549 APIENTRY
2550 NtGdiStrokeAndFillPath(HDC hDC)
2551 {
2552   DC *pDc;
2553   PDC_ATTR pdcattr;
2554   PPATH pPath;
2555   BOOL bRet = FALSE;
2556
2557   DPRINT1("Enter %s\n", __FUNCTION__);
2558
2559   if (!(pDc = DC_LockDc(hDC)))
2560   {
2561      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2562      return FALSE;
2563   }
2564   pPath = PATH_LockPath( pDc->dclevel.hPath );
2565   if (!pPath)
2566   {
2567      DC_UnlockDc ( pDc );
2568      return FALSE;
2569   }
2570
2571   pdcattr = pDc->pdcattr;
2572
2573   if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
2574     DC_vUpdateFillBrush(pDc);
2575
2576   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2577     DC_vUpdateLineBrush(pDc);
2578
2579   bRet = PATH_FillPath(pDc, pPath);
2580   if (bRet) bRet = PATH_StrokePath(pDc, pPath);
2581   if (bRet) PATH_EmptyPath(pPath);
2582
2583   PATH_UnlockPath( pPath );
2584   DC_UnlockDc(pDc);
2585   return bRet;
2586 }
2587
2588 BOOL
2589 APIENTRY
2590 NtGdiStrokePath(HDC hDC)
2591 {
2592   DC *pDc;
2593   PDC_ATTR pdcattr;
2594   PPATH pPath;
2595   BOOL bRet = FALSE;
2596
2597   DPRINT("Enter %s\n", __FUNCTION__);
2598
2599   if (!(pDc = DC_LockDc(hDC)))
2600   {
2601      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2602      return FALSE;
2603   }
2604   pPath = PATH_LockPath( pDc->dclevel.hPath );
2605   if (!pPath)
2606   {
2607      DC_UnlockDc ( pDc );
2608      return FALSE;
2609   }
2610
2611   pdcattr = pDc->pdcattr;
2612
2613   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2614      DC_vUpdateLineBrush(pDc);
2615
2616   bRet = PATH_StrokePath(pDc, pPath);
2617   PATH_EmptyPath(pPath);
2618
2619   PATH_UnlockPath( pPath );
2620   DC_UnlockDc(pDc);
2621   return bRet;
2622 }
2623
2624 BOOL
2625 APIENTRY
2626 NtGdiWidenPath(HDC  hDC)
2627 {
2628   BOOL Ret;
2629   PDC pdc = DC_LockDc ( hDC );
2630   if ( !pdc )
2631   {
2632      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2633      return FALSE;
2634   }
2635   Ret = PATH_WidenPath(pdc);
2636   DC_UnlockDc ( pdc );
2637   return Ret;
2638 }
2639
2640 /* EOF */