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 <win32k.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, FALSE);
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, penWidth, penWidthIn, penWidthOut, size, penStyle;
1508     BOOL ret = FALSE;
1509     PPATH pPath, pNewPath, *pStrokes = NULL, *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
1576     for(i = 0, j = 0; i < pPath->numEntriesUsed; i++, j++)
1577     {
1578         POINT point;
1579         if((i == 0 || (pPath->pFlags[i-1] & PT_CLOSEFIGURE)) &&
1580             (pPath->pFlags[i] != PT_MOVETO))
1581         {
1582             DPRINT1("Expected PT_MOVETO %s, got path flag %c\n",
1583                 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1584                 pPath->pFlags[i]);
1585             return FALSE;
1586         }
1587         switch(pPath->pFlags[i])
1588         {
1589             case PT_MOVETO:
1590                 if(numStrokes > 0)
1591                 {
1592                     pStrokes[numStrokes - 1]->state = PATH_Closed;
1593                 }
1594                 numStrokes++;
1595                 j = 0;
1596                 if (numStrokes == 1)
1597                    pStrokes = ExAllocatePoolWithTag(PagedPool, numStrokes * sizeof(PPATH), TAG_PATH);
1598                 else
1599                 {
1600                    pOldStrokes = pStrokes; // Save old pointer.
1601                    pStrokes = ExAllocatePoolWithTag(PagedPool, numStrokes * sizeof(PPATH), TAG_PATH);
1602                    if (!pStrokes) return FALSE;
1603                    RtlCopyMemory(pStrokes, pOldStrokes, numStrokes * sizeof(PPATH));
1604                    ExFreePoolWithTag(pOldStrokes, TAG_PATH); // Free old pointer.
1605                 }
1606                 if (!pStrokes) return FALSE;
1607                 pStrokes[numStrokes - 1] = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1608
1609                 PATH_InitGdiPath(pStrokes[numStrokes - 1]);
1610                 pStrokes[numStrokes - 1]->state = PATH_Open;
1611             case PT_LINETO:
1612             case (PT_LINETO | PT_CLOSEFIGURE):
1613                 point.x = pPath->pPoints[i].x;
1614                 point.y = pPath->pPoints[i].y;
1615                 PATH_AddEntry(pStrokes[numStrokes - 1], &point, pPath->pFlags[i]);
1616                 break;
1617             case PT_BEZIERTO:
1618                 /* should never happen because of the FlattenPath call */
1619                 DPRINT1("Should never happen\n");
1620                 break;
1621             default:
1622                 DPRINT1("Got path flag %c\n", pPath->pFlags[i]);
1623                 return FALSE;
1624         }
1625     }
1626
1627     pNewPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1628     PATH_InitGdiPath(pNewPath);
1629     pNewPath->state = PATH_Open;
1630
1631     for(i = 0; i < numStrokes; i++)
1632     {
1633         pUpPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1634         PATH_InitGdiPath(pUpPath);
1635         pUpPath->state = PATH_Open;
1636         pDownPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1637         PATH_InitGdiPath(pDownPath);
1638         pDownPath->state = PATH_Open;
1639
1640         for(j = 0; j < pStrokes[i]->numEntriesUsed; j++)
1641         {
1642             /* Beginning or end of the path if not closed */
1643             if((!(pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) && (j == 0 || j == pStrokes[i]->numEntriesUsed - 1) )
1644             {
1645                 /* Compute segment angle */
1646                 double xo, yo, xa, ya, theta;
1647                 POINT pt;
1648                 FLOAT_POINT corners[2];
1649                 if(j == 0)
1650                 {
1651                     xo = pStrokes[i]->pPoints[j].x;
1652                     yo = pStrokes[i]->pPoints[j].y;
1653                     xa = pStrokes[i]->pPoints[1].x;
1654                     ya = pStrokes[i]->pPoints[1].y;
1655                 }
1656                 else
1657                 {
1658                     xa = pStrokes[i]->pPoints[j - 1].x;
1659                     ya = pStrokes[i]->pPoints[j - 1].y;
1660                     xo = pStrokes[i]->pPoints[j].x;
1661                     yo = pStrokes[i]->pPoints[j].y;
1662                 }
1663                 theta = atan2( ya - yo, xa - xo );
1664                 switch(endcap)
1665                 {
1666                     case PS_ENDCAP_SQUARE :
1667                         pt.x = xo + round(sqrt(2) * penWidthOut * cos(M_PI_4 + theta));
1668                         pt.y = yo + round(sqrt(2) * penWidthOut * sin(M_PI_4 + theta));
1669                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO) );
1670                         pt.x = xo + round(sqrt(2) * penWidthIn * cos(- M_PI_4 + theta));
1671                         pt.y = yo + round(sqrt(2) * penWidthIn * sin(- M_PI_4 + theta));
1672                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1673                         break;
1674                     case PS_ENDCAP_FLAT :
1675                         pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1676                         pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1677                         PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1678                         pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1679                         pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1680                         PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1681                         break;
1682                     case PS_ENDCAP_ROUND :
1683                     default :
1684                         corners[0].x = xo - penWidthIn;
1685                         corners[0].y = yo - penWidthIn;
1686                         corners[1].x = xo + penWidthOut;
1687                         corners[1].y = yo + penWidthOut;
1688                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI_2 , theta + 3 * M_PI_4, (j == 0 ? PT_MOVETO : FALSE));
1689                         PATH_DoArcPart(pUpPath ,corners, theta + 3 * M_PI_4 , theta + M_PI, FALSE);
1690                         PATH_DoArcPart(pUpPath ,corners, theta + M_PI, theta +  5 * M_PI_4, FALSE);
1691                         PATH_DoArcPart(pUpPath ,corners, theta + 5 * M_PI_4 , theta + 3 * M_PI_2, FALSE);
1692                         break;
1693                 }
1694             }
1695             /* Corpse of the path */
1696             else
1697             {
1698                 /* Compute angle */
1699                 INT previous, next;
1700                 double xa, ya, xb, yb, xo, yo;
1701                 double alpha, theta, miterWidth;
1702                 DWORD _joint = joint;
1703                 POINT pt;
1704                 PPATH pInsidePath, pOutsidePath;
1705                 if(j > 0 && j < pStrokes[i]->numEntriesUsed - 1)
1706                 {
1707                     previous = j - 1;
1708                     next = j + 1;
1709                 }
1710                 else if (j == 0)
1711                 {
1712                     previous = pStrokes[i]->numEntriesUsed - 1;
1713                     next = j + 1;
1714                 }
1715                 else
1716                 {
1717                     previous = j - 1;
1718                     next = 0;
1719                 }
1720                 xo = pStrokes[i]->pPoints[j].x;
1721                 yo = pStrokes[i]->pPoints[j].y;
1722                 xa = pStrokes[i]->pPoints[previous].x;
1723                 ya = pStrokes[i]->pPoints[previous].y;
1724                 xb = pStrokes[i]->pPoints[next].x;
1725                 yb = pStrokes[i]->pPoints[next].y;
1726                 theta = atan2( yo - ya, xo - xa );
1727                 alpha = atan2( yb - yo, xb - xo ) - theta;
1728                 if (alpha > 0) alpha -= M_PI;
1729                 else alpha += M_PI;
1730                 if(_joint == PS_JOIN_MITER && dc->dclevel.laPath.eMiterLimit < fabs(1 / sin(alpha/2)))
1731                 {
1732                     _joint = PS_JOIN_BEVEL;
1733                 }
1734                 if(alpha > 0)
1735                 {
1736                     pInsidePath = pUpPath;
1737                     pOutsidePath = pDownPath;
1738                 }
1739                 else if(alpha < 0)
1740                 {
1741                     pInsidePath = pDownPath;
1742                     pOutsidePath = pUpPath;
1743                 }
1744                 else
1745                 {
1746                     continue;
1747                 }
1748                 /* Inside angle points */
1749                 if(alpha > 0)
1750                 {
1751                     pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1752                     pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1753                 }
1754                 else
1755                 {
1756                     pt.x = xo + round( penWidthIn * cos(theta + M_PI_2) );
1757                     pt.y = yo + round( penWidthIn * sin(theta + M_PI_2) );
1758                 }
1759                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1760                 if(alpha > 0)
1761                 {
1762                     pt.x = xo + round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1763                     pt.y = yo + round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1764                 }
1765                 else
1766                 {
1767                     pt.x = xo - round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1768                     pt.y = yo - round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1769                 }
1770                 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1771                 /* Outside angle point */
1772                 switch(_joint)
1773                 {
1774                      case PS_JOIN_MITER :
1775                         miterWidth = fabs(penWidthOut / cos(M_PI_2 - fabs(alpha) / 2));
1776                         pt.x = xo + round( miterWidth * cos(theta + alpha / 2) );
1777                         pt.y = yo + round( miterWidth * sin(theta + alpha / 2) );
1778                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1779                         break;
1780                     case PS_JOIN_BEVEL :
1781                         if(alpha > 0)
1782                         {
1783                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1784                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1785                         }
1786                         else
1787                         {
1788                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1789                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1790                         }
1791                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1792                         if(alpha > 0)
1793                         {
1794                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1795                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1796                         }
1797                         else
1798                         {
1799                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1800                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1801                         }
1802                         PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1803                         break;
1804                     case PS_JOIN_ROUND :
1805                     default :
1806                         if(alpha > 0)
1807                         {
1808                             pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1809                             pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1810                         }
1811                         else
1812                         {
1813                             pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1814                             pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1815                         }
1816                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1817                         pt.x = xo + round( penWidthOut * cos(theta + alpha / 2) );
1818                         pt.y = yo + round( penWidthOut * sin(theta + alpha / 2) );
1819                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1820                         if(alpha > 0)
1821                         {
1822                             pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1823                             pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1824                         }
1825                         else
1826                         {
1827                             pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1828                             pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1829                         }
1830                         PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1831                         break;
1832                 }
1833             }
1834         }
1835         for(j = 0; j < pUpPath->numEntriesUsed; j++)
1836         {
1837             POINT pt;
1838             pt.x = pUpPath->pPoints[j].x;
1839             pt.y = pUpPath->pPoints[j].y;
1840             PATH_AddEntry(pNewPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1841         }
1842         for(j = 0; j < pDownPath->numEntriesUsed; j++)
1843         {
1844             POINT pt;
1845             pt.x = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].x;
1846             pt.y = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].y;
1847             PATH_AddEntry(pNewPath, &pt, ( (j == 0 && (pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) ? PT_MOVETO : PT_LINETO));
1848         }
1849
1850         PATH_DestroyGdiPath(pStrokes[i]);
1851         ExFreePoolWithTag(pStrokes[i], TAG_PATH);
1852         PATH_DestroyGdiPath(pUpPath);
1853         ExFreePoolWithTag(pUpPath, TAG_PATH);
1854         PATH_DestroyGdiPath(pDownPath);
1855         ExFreePoolWithTag(pDownPath, TAG_PATH);
1856     }
1857     ExFreePoolWithTag(pStrokes, TAG_PATH);
1858
1859     pNewPath->state = PATH_Closed;
1860     if (!(ret = PATH_AssignGdiPath(pPath, pNewPath)))
1861         DPRINT1("Assign path failed\n");
1862     PATH_DestroyGdiPath(pNewPath);
1863     ExFreePoolWithTag(pNewPath, TAG_PATH);
1864     return ret;
1865 }
1866
1867 static inline INT int_from_fixed(FIXED f)
1868 {
1869     return (f.fract >= 0x8000) ? (f.value + 1) : f.value;
1870 }
1871
1872 /**********************************************************************
1873  *      PATH_BezierTo
1874  *
1875  * internally used by PATH_add_outline
1876  */
1877 static
1878 VOID
1879 FASTCALL
1880 PATH_BezierTo(PPATH pPath, POINT *lppt, INT n)
1881 {
1882     if (n < 2) return;
1883
1884     if (n == 2)
1885     {
1886         PATH_AddEntry(pPath, &lppt[1], PT_LINETO);
1887     }
1888     else if (n == 3)
1889     {
1890         PATH_AddEntry(pPath, &lppt[0], PT_BEZIERTO);
1891         PATH_AddEntry(pPath, &lppt[1], PT_BEZIERTO);
1892         PATH_AddEntry(pPath, &lppt[2], PT_BEZIERTO);
1893     }
1894     else
1895     {
1896         POINT pt[3];
1897         INT i = 0;
1898
1899         pt[2] = lppt[0];
1900         n--;
1901
1902         while (n > 2)
1903         {
1904             pt[0] = pt[2];
1905             pt[1] = lppt[i+1];
1906             pt[2].x = (lppt[i+2].x + lppt[i+1].x) / 2;
1907             pt[2].y = (lppt[i+2].y + lppt[i+1].y) / 2;
1908             PATH_BezierTo(pPath, pt, 3);
1909             n--;
1910             i++;
1911         }
1912
1913         pt[0] = pt[2];
1914         pt[1] = lppt[i+1];
1915         pt[2] = lppt[i+2];
1916         PATH_BezierTo(pPath, pt, 3);
1917     }
1918 }
1919
1920 static
1921 BOOL
1922 FASTCALL
1923 PATH_add_outline(PDC dc, INT x, INT y, TTPOLYGONHEADER *header, DWORD size)
1924 {
1925   PPATH pPath;
1926   TTPOLYGONHEADER *start;
1927   POINT pt;
1928
1929   start = header;
1930
1931   pPath = PATH_LockPath(dc->dclevel.hPath);
1932   {
1933      return FALSE;
1934   }
1935
1936   while ((char *)header < (char *)start + size)
1937   {
1938      TTPOLYCURVE *curve;
1939
1940      if (header->dwType != TT_POLYGON_TYPE)
1941      {
1942         DPRINT1("Unknown header type %d\n", header->dwType);
1943         return FALSE;
1944      }
1945
1946      pt.x = x + int_from_fixed(header->pfxStart.x);
1947      pt.y = y - int_from_fixed(header->pfxStart.y);
1948      IntLPtoDP(dc, &pt, 1);
1949      PATH_AddEntry(pPath, &pt, PT_MOVETO);
1950
1951      curve = (TTPOLYCURVE *)(header + 1);
1952
1953      while ((char *)curve < (char *)header + header->cb)
1954      {
1955         /*DPRINT1("curve->wType %d\n", curve->wType);*/
1956
1957         switch(curve->wType)
1958         {
1959            case TT_PRIM_LINE:
1960            {
1961               WORD i;
1962
1963               for (i = 0; i < curve->cpfx; i++)
1964               {
1965                  pt.x = x + int_from_fixed(curve->apfx[i].x);
1966                  pt.y = y - int_from_fixed(curve->apfx[i].y);
1967                  IntLPtoDP(dc, &pt, 1);
1968                  PATH_AddEntry(pPath, &pt, PT_LINETO);
1969               }
1970               break;
1971            }
1972
1973            case TT_PRIM_QSPLINE:
1974            case TT_PRIM_CSPLINE:
1975            {
1976               WORD i;
1977               POINTFX ptfx;
1978               POINT *pts = ExAllocatePoolWithTag(PagedPool, (curve->cpfx + 1) * sizeof(POINT), TAG_PATH);
1979
1980               if (!pts) return FALSE;
1981
1982               ptfx = *(POINTFX *)((char *)curve - sizeof(POINTFX));
1983
1984               pts[0].x = x + int_from_fixed(ptfx.x);
1985               pts[0].y = y - int_from_fixed(ptfx.y);
1986               IntLPtoDP(dc, &pts[0], 1);
1987
1988               for (i = 0; i < curve->cpfx; i++)
1989               {
1990                   pts[i + 1].x = x + int_from_fixed(curve->apfx[i].x);
1991                   pts[i + 1].y = y - int_from_fixed(curve->apfx[i].y);
1992                   IntLPtoDP(dc, &pts[i + 1], 1);
1993               }
1994
1995               PATH_BezierTo(pPath, pts, curve->cpfx + 1);
1996
1997               ExFreePoolWithTag(pts, TAG_PATH);
1998               break;
1999            }
2000
2001            default:
2002               DPRINT1("Unknown curve type %04x\n", curve->wType);
2003               return FALSE;
2004         }
2005
2006         curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
2007      }
2008      header = (TTPOLYGONHEADER *)((char *)header + header->cb);
2009   }
2010
2011   IntGdiCloseFigure( pPath );
2012   PATH_UnlockPath( pPath );
2013   return TRUE;
2014 }
2015
2016 /**********************************************************************
2017  *      PATH_ExtTextOut
2018  */
2019 BOOL
2020 FASTCALL
2021 PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECTL *lprc,
2022                      LPCWSTR str, UINT count, const INT *dx)
2023 {
2024     unsigned int idx;
2025     double cosEsc, sinEsc;
2026     PDC_ATTR pdcattr;
2027     PTEXTOBJ TextObj;
2028     LOGFONTW lf;
2029     POINTL org;
2030     INT offset = 0, xoff = 0, yoff = 0;
2031
2032     if (!count) return TRUE;
2033
2034     pdcattr = dc->pdcattr;
2035
2036     TextObj = RealizeFontInit( pdcattr->hlfntNew);
2037     if ( !TextObj ) return FALSE;
2038
2039     FontGetObject( TextObj, sizeof(lf), &lf);
2040
2041     if (lf.lfEscapement != 0)
2042     {
2043         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2044         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2045     } else
2046     {
2047         cosEsc = 1;
2048         sinEsc = 0;
2049     }
2050
2051     IntGdiGetDCOrg(dc, &org);
2052
2053     for (idx = 0; idx < count; idx++)
2054     {
2055         GLYPHMETRICS gm;
2056         DWORD dwSize;
2057         void *outline;
2058
2059         dwSize = ftGdiGetGlyphOutline( dc,
2060                                        str[idx],
2061                                        GGO_GLYPH_INDEX | GGO_NATIVE,
2062                                        &gm,
2063                                        0,
2064                                        NULL,
2065                                        NULL,
2066                                        TRUE);
2067         if (!dwSize) return FALSE;
2068
2069         outline = ExAllocatePoolWithTag(PagedPool, dwSize, TAG_PATH);
2070         if (!outline) return FALSE;
2071
2072         ftGdiGetGlyphOutline( dc,
2073                               str[idx],
2074                               GGO_GLYPH_INDEX | GGO_NATIVE,
2075                               &gm,
2076                               dwSize,
2077                               outline,
2078                               NULL,
2079                               TRUE);
2080
2081         PATH_add_outline(dc, org.x + x + xoff, org.x + y + yoff, outline, dwSize);
2082
2083         ExFreePoolWithTag(outline, TAG_PATH);
2084
2085         if (dx)
2086         {
2087             offset += dx[idx];
2088             xoff = offset * cosEsc;
2089             yoff = offset * -sinEsc;
2090         }
2091         else
2092         {
2093             xoff += gm.gmCellIncX;
2094             yoff += gm.gmCellIncY;
2095         }
2096     }
2097     return TRUE;
2098 }
2099
2100
2101 /***********************************************************************
2102  * Exported functions
2103  */
2104
2105 BOOL
2106 APIENTRY
2107 NtGdiAbortPath(HDC  hDC)
2108 {
2109   PPATH pPath;
2110   PDC dc = DC_LockDc ( hDC );
2111   if ( !dc )
2112   {
2113      SetLastWin32Error(ERROR_INVALID_HANDLE);
2114      return FALSE;
2115   }
2116
2117   pPath = PATH_LockPath(dc->dclevel.hPath);
2118   {
2119       DC_UnlockDc(dc);
2120       return FALSE;
2121   }
2122
2123   PATH_EmptyPath(pPath);
2124
2125   PATH_UnlockPath(pPath);
2126   DC_UnlockDc ( dc );
2127   return TRUE;
2128 }
2129
2130 BOOL
2131 APIENTRY
2132 NtGdiBeginPath( HDC  hDC )
2133 {
2134   PPATH pPath;
2135   PDC dc;
2136
2137   dc = DC_LockDc ( hDC );
2138   if ( !dc )
2139   {
2140      SetLastWin32Error(ERROR_INVALID_HANDLE);
2141      return FALSE;
2142   }
2143
2144   /* If path is already open, do nothing. Check if not Save DC state */
2145     if ((dc->dclevel.flPath & DCPATH_ACTIVE) && !(dc->dclevel.flPath & DCPATH_SAVE))
2146   {
2147      DC_UnlockDc ( dc );
2148      return TRUE;
2149   }
2150
2151   if ( dc->dclevel.hPath )
2152   {
2153      DPRINT1("BeginPath 1 0x%x\n", dc->dclevel.hPath);
2154      if ( !(dc->dclevel.flPath & DCPATH_SAVE) )
2155      {  // Remove previous handle.
2156         if (!PATH_Delete(dc->dclevel.hPath))
2157         {
2158            DC_UnlockDc ( dc );
2159            return FALSE;
2160         }
2161      }
2162      else
2163      {  // Clear flags and Handle.
2164         dc->dclevel.flPath &= ~(DCPATH_SAVE|DCPATH_ACTIVE);
2165         dc->dclevel.hPath = NULL;
2166      }
2167   }
2168   pPath = PATH_AllocPathWithHandle();
2169   if (!pPath)
2170   {
2171      SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
2172      return FALSE;
2173   }
2174   dc->dclevel.flPath |= DCPATH_ACTIVE; // Set active ASAP!
2175
2176   dc->dclevel.hPath = pPath->BaseObject.hHmgr;
2177
2178   DPRINT1("BeginPath 2 h 0x%x p 0x%x\n", dc->dclevel.hPath, pPath);
2179   // Path handles are shared. Also due to recursion with in the same thread.
2180   GDIOBJ_UnlockObjByPtr((POBJ)pPath);       // Unlock
2181   pPath = PATH_LockPath(dc->dclevel.hPath); // Share Lock.
2182
2183   /* Make sure that path is empty */
2184   PATH_EmptyPath( pPath );
2185
2186   /* Initialize variables for new path */
2187   pPath->newStroke = TRUE;
2188   pPath->state = PATH_Open;
2189
2190   PATH_UnlockPath(pPath);
2191   DC_UnlockDc ( dc );
2192   return TRUE;
2193 }
2194
2195 BOOL
2196 APIENTRY
2197 NtGdiCloseFigure(HDC hDC)
2198 {
2199   BOOL Ret = FALSE; // default to failure
2200   PDC pDc;
2201   PPATH pPath;
2202
2203   DPRINT("Enter %s\n", __FUNCTION__);
2204
2205   pDc = DC_LockDc(hDC);
2206   if (!pDc)
2207   {
2208      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2209      return FALSE;
2210   }
2211   pPath = PATH_LockPath( pDc->dclevel.hPath );
2212   if (!pPath)
2213   {
2214      DC_UnlockDc(pDc);
2215      return FALSE;
2216   }
2217
2218   if (pPath->state==PATH_Open)
2219   {
2220      IntGdiCloseFigure(pPath);
2221      Ret = TRUE;
2222   }
2223   else
2224   {
2225      // FIXME: check if lasterror is set correctly
2226      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2227   }
2228
2229   PATH_UnlockPath( pPath );
2230   DC_UnlockDc(pDc);
2231   return Ret;
2232 }
2233
2234 BOOL
2235 APIENTRY
2236 NtGdiEndPath(HDC  hDC)
2237 {
2238   BOOL ret = TRUE;
2239   PPATH pPath;
2240   PDC dc = DC_LockDc ( hDC );
2241
2242   if ( !dc )
2243   {
2244      SetLastWin32Error(ERROR_INVALID_HANDLE);
2245      return FALSE;
2246   }
2247
2248   pPath = PATH_LockPath( dc->dclevel.hPath );
2249   if (!pPath)
2250   {
2251      DC_UnlockDc ( dc );
2252      return FALSE;
2253   }
2254   /* Check that path is currently being constructed */
2255   if ( (pPath->state != PATH_Open) || !(dc->dclevel.flPath & DCPATH_ACTIVE) )
2256   {
2257     DPRINT1("EndPath ERROR! 0x%x\n", dc->dclevel.hPath);
2258     SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2259     ret = FALSE;
2260   }
2261   /* Set flag to indicate that path is finished */
2262   else
2263   {
2264      DPRINT1("EndPath 0x%x\n", dc->dclevel.hPath);
2265      pPath->state = PATH_Closed;
2266      dc->dclevel.flPath &= ~DCPATH_ACTIVE;
2267   }
2268   PATH_UnlockPath( pPath );
2269   DC_UnlockDc ( dc );
2270   return ret;
2271 }
2272
2273 BOOL
2274 APIENTRY
2275 NtGdiFillPath(HDC  hDC)
2276 {
2277   BOOL ret = FALSE;
2278   PPATH pPath;
2279   PDC_ATTR pdcattr;
2280   PDC dc = DC_LockDc ( hDC );
2281
2282   if ( !dc )
2283   {
2284      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2285      return FALSE;
2286   }
2287   pPath = PATH_LockPath( dc->dclevel.hPath );
2288   if (!pPath)
2289   {
2290      DC_UnlockDc ( dc );
2291      return FALSE;
2292   }
2293
2294   DC_vPrepareDCsForBlit(dc, dc->rosdc.CombinedClip->rclBounds,
2295                             NULL, dc->rosdc.CombinedClip->rclBounds);
2296
2297   pdcattr = dc->pdcattr;
2298
2299   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2300       DC_vUpdateLineBrush(dc);
2301
2302   if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
2303       DC_vUpdateFillBrush(dc);
2304
2305   ret = PATH_FillPath( dc, pPath );
2306   if ( ret )
2307   {
2308     /* FIXME: Should the path be emptied even if conversion
2309        failed? */
2310     PATH_EmptyPath( pPath );
2311   }
2312
2313   PATH_UnlockPath( pPath );
2314   DC_vFinishBlit(dc, NULL);
2315   DC_UnlockDc ( dc );
2316   return ret;
2317 }
2318
2319 BOOL
2320 APIENTRY
2321 NtGdiFlattenPath(HDC  hDC)
2322 {
2323    BOOL Ret = FALSE;
2324    DC *pDc;
2325    PPATH pPath;
2326
2327    DPRINT("Enter %s\n", __FUNCTION__);
2328
2329    pDc = DC_LockDc(hDC);
2330    if (!pDc)
2331    {
2332       SetLastWin32Error(ERROR_INVALID_HANDLE);
2333       return FALSE;
2334    }
2335
2336    pPath = PATH_LockPath( pDc->dclevel.hPath );
2337    if (!pPath)
2338    {
2339       DC_UnlockDc ( pDc );
2340       return FALSE;
2341    }
2342    if (pPath->state == PATH_Open)
2343       Ret = PATH_FlattenPath(pPath);
2344
2345    PATH_UnlockPath( pPath );
2346    DC_UnlockDc(pDc);
2347    return Ret;
2348 }
2349
2350
2351 BOOL
2352 APIENTRY
2353 NtGdiGetMiterLimit(
2354     IN HDC hdc,
2355     OUT PDWORD pdwOut)
2356 {
2357   DC *pDc;
2358   gxf_long worker;
2359   NTSTATUS Status = STATUS_SUCCESS;
2360
2361   if (!(pDc = DC_LockDc(hdc)))
2362   {
2363      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2364      return FALSE;
2365   }
2366
2367   worker.f = pDc->dclevel.laPath.eMiterLimit;
2368
2369   if (pdwOut)
2370   {
2371       _SEH2_TRY
2372       {
2373           ProbeForWrite(pdwOut,
2374                  sizeof(DWORD),
2375                              1);
2376           *pdwOut = worker.l;
2377       }
2378       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2379       {
2380           Status = _SEH2_GetExceptionCode();
2381       }
2382        _SEH2_END;
2383       if (!NT_SUCCESS(Status))
2384       {
2385          SetLastNtError(Status);
2386          DC_UnlockDc(pDc);
2387          return FALSE;
2388       }
2389   }
2390
2391   DC_UnlockDc(pDc);
2392   return TRUE;
2393
2394 }
2395
2396 INT
2397 APIENTRY
2398 NtGdiGetPath(
2399    HDC hDC,
2400    LPPOINT Points,
2401    LPBYTE Types,
2402    INT nSize)
2403 {
2404   INT ret = -1;
2405   PPATH pPath;
2406
2407   DC *dc = DC_LockDc(hDC);
2408   if (!dc)
2409   {
2410      DPRINT1("Can't lock dc!\n");
2411      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2412      return -1;
2413   }
2414
2415   pPath = PATH_LockPath( dc->dclevel.hPath );
2416   if (!pPath)
2417   {
2418      DC_UnlockDc ( dc );
2419      return -1;
2420   }
2421
2422   if (pPath->state != PATH_Closed)
2423   {
2424      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2425      goto done;
2426   }
2427
2428   if (nSize==0)
2429   {
2430      ret = pPath->numEntriesUsed;
2431   }
2432   else if(nSize<pPath->numEntriesUsed)
2433   {
2434      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2435      goto done;
2436   }
2437   else
2438   {
2439       _SEH2_TRY
2440       {
2441          memcpy(Points, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
2442          memcpy(Types, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
2443
2444          /* Convert the points to logical coordinates */
2445          IntDPtoLP(dc, Points, pPath->numEntriesUsed);
2446
2447          ret = pPath->numEntriesUsed;
2448       }
2449       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2450       {
2451          SetLastNtError(_SEH2_GetExceptionCode());
2452       }
2453       _SEH2_END
2454   }
2455
2456 done:
2457   PATH_UnlockPath( pPath );
2458   DC_UnlockDc(dc);
2459   return ret;
2460 }
2461
2462 HRGN
2463 APIENTRY
2464 NtGdiPathToRegion(HDC  hDC)
2465 {
2466   PPATH pPath;
2467   HRGN  hrgnRval = 0;
2468   DC *pDc;
2469   PDC_ATTR pdcattr;
2470
2471   DPRINT("Enter %s\n", __FUNCTION__);
2472
2473   pDc = DC_LockDc(hDC);
2474   if (!pDc)
2475   {
2476      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2477      return NULL;
2478   }
2479
2480   pdcattr = pDc->pdcattr;
2481
2482   pPath = PATH_LockPath( pDc->dclevel.hPath );
2483   if (!pPath)
2484   {
2485      DC_UnlockDc ( pDc );
2486      return NULL;
2487   }
2488
2489   if (pPath->state!=PATH_Closed)
2490   {
2491      //FIXME: check that setlasterror is being called correctly
2492      SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2493   }
2494   else
2495   {
2496      /* FIXME: Should we empty the path even if conversion failed? */
2497      if(PATH_PathToRegion(pPath, pdcattr->jFillMode, &hrgnRval))
2498           PATH_EmptyPath(pPath);
2499   }
2500
2501   PATH_UnlockPath( pPath );
2502   DC_UnlockDc(pDc);
2503   return hrgnRval;
2504 }
2505
2506 BOOL
2507 APIENTRY
2508 NtGdiSetMiterLimit(
2509     IN HDC hdc,
2510     IN DWORD dwNew,
2511     IN OUT OPTIONAL PDWORD pdwOut)
2512 {
2513   DC *pDc;
2514   gxf_long worker, worker1;
2515   NTSTATUS Status = STATUS_SUCCESS;
2516
2517   if (!(pDc = DC_LockDc(hdc)))
2518   {
2519      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2520      return FALSE;
2521   }
2522
2523   worker.l  = dwNew;
2524   worker1.f = pDc->dclevel.laPath.eMiterLimit;
2525   pDc->dclevel.laPath.eMiterLimit = worker.f;
2526
2527   if (pdwOut)
2528   {
2529       _SEH2_TRY
2530       {
2531           ProbeForWrite(pdwOut,
2532                  sizeof(DWORD),
2533                              1);
2534           *pdwOut = worker1.l;
2535       }
2536       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2537       {
2538           Status = _SEH2_GetExceptionCode();
2539       }
2540        _SEH2_END;
2541       if (!NT_SUCCESS(Status))
2542       {
2543          SetLastNtError(Status);
2544          DC_UnlockDc(pDc);
2545          return FALSE;
2546       }
2547   }
2548
2549   DC_UnlockDc(pDc);
2550   return TRUE;
2551 }
2552
2553 BOOL
2554 APIENTRY
2555 NtGdiStrokeAndFillPath(HDC hDC)
2556 {
2557   DC *pDc;
2558   PDC_ATTR pdcattr;
2559   PPATH pPath;
2560   BOOL bRet = FALSE;
2561
2562   DPRINT1("Enter %s\n", __FUNCTION__);
2563
2564   if (!(pDc = DC_LockDc(hDC)))
2565   {
2566      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2567      return FALSE;
2568   }
2569   pPath = PATH_LockPath( pDc->dclevel.hPath );
2570   if (!pPath)
2571   {
2572      DC_UnlockDc ( pDc );
2573      return FALSE;
2574   }
2575
2576   DC_vPrepareDCsForBlit(pDc, pDc->rosdc.CombinedClip->rclBounds,
2577                             NULL, pDc->rosdc.CombinedClip->rclBounds);
2578
2579   pdcattr = pDc->pdcattr;
2580
2581   if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
2582     DC_vUpdateFillBrush(pDc);
2583
2584   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2585     DC_vUpdateLineBrush(pDc);
2586
2587   bRet = PATH_FillPath(pDc, pPath);
2588   if (bRet) bRet = PATH_StrokePath(pDc, pPath);
2589   if (bRet) PATH_EmptyPath(pPath);
2590
2591   PATH_UnlockPath( pPath );
2592   DC_vFinishBlit(pDc, NULL);
2593   DC_UnlockDc(pDc);
2594   return bRet;
2595 }
2596
2597 BOOL
2598 APIENTRY
2599 NtGdiStrokePath(HDC hDC)
2600 {
2601   DC *pDc;
2602   PDC_ATTR pdcattr;
2603   PPATH pPath;
2604   BOOL bRet = FALSE;
2605
2606   DPRINT("Enter %s\n", __FUNCTION__);
2607
2608   if (!(pDc = DC_LockDc(hDC)))
2609   {
2610      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2611      return FALSE;
2612   }
2613   pPath = PATH_LockPath( pDc->dclevel.hPath );
2614   if (!pPath)
2615   {
2616      DC_UnlockDc ( pDc );
2617      return FALSE;
2618   }
2619
2620   DC_vPrepareDCsForBlit(pDc, pDc->rosdc.CombinedClip->rclBounds,
2621                             NULL, pDc->rosdc.CombinedClip->rclBounds);
2622
2623   pdcattr = pDc->pdcattr;
2624
2625   if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2626      DC_vUpdateLineBrush(pDc);
2627
2628   bRet = PATH_StrokePath(pDc, pPath);
2629
2630   DC_vFinishBlit(pDc, NULL);
2631   PATH_EmptyPath(pPath);
2632
2633   PATH_UnlockPath( pPath );
2634   DC_UnlockDc(pDc);
2635   return bRet;
2636 }
2637
2638 BOOL
2639 APIENTRY
2640 NtGdiWidenPath(HDC  hDC)
2641 {
2642   BOOL Ret;
2643   PDC pdc = DC_LockDc ( hDC );
2644   if ( !pdc )
2645   {
2646      SetLastWin32Error(ERROR_INVALID_PARAMETER);
2647      return FALSE;
2648   }
2649   Ret = PATH_WidenPath(pdc);
2650   DC_UnlockDc ( pdc );
2651   return Ret;
2652 }
2653
2654 /* EOF */