graphics/painting.c

   1 /*
   2  * Misc. graphics operations
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  * Copyright 1997 Bertho A. Stultiens
   6  */
   7
   8 #include <math.h>
   9 #include <stdlib.h>
  10 #include "ts_xlib.h"
  11 #include "ts_xutil.h"
  12 #include <X11/Intrinsic.h>
  13 #ifndef PI
  14 #define PI M_PI
  15 #endif
  16 #include "gdi.h"
  17 #include "dc.h"
  18 #include "bitmap.h"
  19 #include "callback.h"
  20 #include "heap.h"
  21 #include "metafile.h"
  22 #include "palette.h"
  23 #include "cache.h"
  24 #include "color.h"
  25 #include "region.h"
  26 #include "path.h"
  27 #include "debug.h"
  28
  29 /***********************************************************************
  30  *           LineTo16    (GDI.19)
  31  */
  32 BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
  33 {
  34     return LineTo32( hdc, x, y );
  35 }
  36
  37
  38 /***********************************************************************
  39  *           LineTo32    (GDI32.249)
  40  */
  41 BOOL32 WINAPI LineTo32( HDC32 hdc, INT32 x, INT32 y )
  42 {
  43     DC * dc = DC_GetDCPtr( hdc );
  44
  45     if(dc && PATH_IsPathOpen(dc->w.path))
  46         if(!PATH_LineTo(hdc, x, y))
  47            return FALSE;
  48
  49     return dc && dc->funcs->pLineTo &&
  50            dc->funcs->pLineTo(dc,x,y);
  51 }
  52
  53
  54 /***********************************************************************
  55  *           MoveTo    (GDI.20)
  56  */
  57 DWORD WINAPI MoveTo( HDC16 hdc, INT16 x, INT16 y )
  58 {
  59     POINT16     pt;
  60
  61     if (!MoveToEx16(hdc,x,y,&pt))
  62         return 0;
  63     return MAKELONG(pt.x,pt.y);
  64 }
  65
  66
  67 /***********************************************************************
  68  *           MoveToEx16    (GDI.483)
  69  */
  70 BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
  71 {
  72     POINT32 pt32;
  73
  74     if (!MoveToEx32( (HDC32)hdc, (INT32)x, (INT32)y, &pt32 )) return FALSE;
  75     if (pt) CONV_POINT32TO16( &pt32, pt );
  76     return TRUE;
  77
  78 }
  79
  80
  81 /***********************************************************************
  82  *           MoveToEx32    (GDI32.254)
  83  */
  84 BOOL32 WINAPI MoveToEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
  85 {
  86     DC * dc = DC_GetDCPtr( hdc );
  87
  88     if(dc && PATH_IsPathOpen(dc->w.path))
  89         if(!PATH_MoveTo(hdc))
  90             return FALSE;
  91
  92     return dc && dc->funcs->pMoveToEx &&
  93            dc->funcs->pMoveToEx(dc,x,y,pt);
  94 }
  95
  96
  97 /***********************************************************************
  98  *           Arc16    (GDI.23)
  99  */
 100 BOOL16 WINAPI Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 101                      INT16 bottom, INT16 xstart, INT16 ystart,
 102                      INT16 xend, INT16 yend )
 103 {
 104     return Arc32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
 105                   (INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
 106                   (INT32)yend );
 107 }
 108
 109
 110 /***********************************************************************
 111  *           Arc32    (GDI32.7)
 112  */
 113 BOOL32 WINAPI Arc32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
 114                      INT32 bottom, INT32 xstart, INT32 ystart,
 115                      INT32 xend, INT32 yend )
 116 {
 117     DC * dc = DC_GetDCPtr( hdc );
 118
 119     if(dc && PATH_IsPathOpen(dc->w.path))
 120         if(!PATH_Arc(hdc, left, top, right, bottom, xstart, ystart, xend,
 121            yend))
 122            return FALSE;
 123
 124     return dc && dc->funcs->pArc &&
 125            dc->funcs->pArc(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 126 }
 127
 128
 129 /***********************************************************************
 130  *           Pie16    (GDI.26)
 131  */
 132 BOOL16 WINAPI Pie16( HDC16 hdc, INT16 left, INT16 top,
 133                      INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 134                      INT16 xend, INT16 yend )
 135 {
 136     return Pie32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
 137                   (INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
 138                   (INT32)yend );
 139 }
 140
 141
 142 /***********************************************************************
 143  *           Pie32   (GDI32.262)
 144  */
 145 BOOL32 WINAPI Pie32( HDC32 hdc, INT32 left, INT32 top,
 146                      INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
 147                      INT32 xend, INT32 yend )
 148 {
 149     DC * dc = DC_GetDCPtr( hdc );
 150
 151     return dc && dc->funcs->pPie &&
 152            dc->funcs->pPie(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 153 }
 154
 155
 156 /***********************************************************************
 157  *           Chord16    (GDI.348)
 158  */
 159 BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
 160                        INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 161                        INT16 xend, INT16 yend )
 162 {
 163     return Chord32( hdc, left, top, right, bottom, xstart, ystart, xend, yend );
 164 }
 165
 166
 167 /***********************************************************************
 168  *           Chord32    (GDI32.14)
 169  */
 170 BOOL32 WINAPI Chord32( HDC32 hdc, INT32 left, INT32 top,
 171                        INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
 172                        INT32 xend, INT32 yend )
 173 {
 174     DC * dc = DC_GetDCPtr( hdc );
 175
 176     return dc && dc->funcs->pChord &&
 177            dc->funcs->pChord(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 178 }
 179
 180
 181 /***********************************************************************
 182  *           Ellipse16    (GDI.24)
 183  */
 184 BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
 185                          INT16 right, INT16 bottom )
 186 {
 187     return Ellipse32( hdc, left, top, right, bottom );
 188 }
 189
 190
 191 /***********************************************************************
 192  *           Ellipse32    (GDI32.75)
 193  */
 194 BOOL32 WINAPI Ellipse32( HDC32 hdc, INT32 left, INT32 top,
 195                          INT32 right, INT32 bottom )
 196 {
 197     DC * dc = DC_GetDCPtr( hdc );
 198
 199     return dc && dc->funcs->pEllipse &&
 200            dc->funcs->pEllipse(dc,left,top,right,bottom);
 201 }
 202
 203
 204 /***********************************************************************
 205  *           Rectangle16    (GDI.27)
 206  */
 207 BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
 208                            INT16 right, INT16 bottom )
 209 {
 210     return Rectangle32( hdc, left, top, right, bottom );
 211 }
 212
 213
 214 /***********************************************************************
 215  *           Rectangle32    (GDI32.283)
 216  */
 217 BOOL32 WINAPI Rectangle32( HDC32 hdc, INT32 left, INT32 top,
 218                            INT32 right, INT32 bottom )
 219 {
 220     DC * dc = DC_GetDCPtr( hdc );
 221
 222     if(dc && PATH_IsPathOpen(dc->w.path))
 223         if(!PATH_Rectangle(hdc, left, top, right, bottom))
 224            return FALSE;
 225
 226     return dc && dc->funcs->pRectangle &&
 227            dc->funcs->pRectangle(dc,left,top,right,bottom);
 228 }
 229
 230
 231 /***********************************************************************
 232  *           RoundRect16    (GDI.28)
 233  */
 234 BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 235                            INT16 bottom, INT16 ell_width, INT16 ell_height )
 236 {
 237     return RoundRect32( hdc, left, top, right, bottom, ell_width, ell_height );
 238 }
 239
 240
 241 /***********************************************************************
 242  *           RoundRect32    (GDI32.291)
 243  */
 244 BOOL32 WINAPI RoundRect32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
 245                            INT32 bottom, INT32 ell_width, INT32 ell_height )
 246 {
 247
 248     if(ell_width == 0 || ell_height == 0) /* Just an optimization */
 249         return Rectangle32(hdc, left, top, right, bottom);
 250
 251     else {
 252         DC * dc = DC_GetDCPtr( hdc );
 253
 254         return dc && dc->funcs->pRoundRect &&
 255            dc->funcs->pRoundRect(dc,left,top,right,bottom,ell_width,ell_height);
 256     }
 257 }
 258
 259
 260 /***********************************************************************
 261  *           FillRect16    (USER.81)
 262  */
 263 INT16 WINAPI FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
 264 {
 265     HBRUSH16 prevBrush;
 266
 267     /* coordinates are logical so we cannot fast-check 'rect',
 268      * it will be done later in the PatBlt().
 269      */
 270
 271     if (!(prevBrush = SelectObject16( hdc, hbrush ))) return 0;
 272     PatBlt32( hdc, rect->left, rect->top,
 273               rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
 274     SelectObject16( hdc, prevBrush );
 275     return 1;
 276 }
 277
 278
 279 /***********************************************************************
 280  *           FillRect32    (USER32.197)
 281  */
 282 INT32 WINAPI FillRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
 283 {
 284     HBRUSH32 prevBrush;
 285
 286     if (!(prevBrush = SelectObject32( hdc, hbrush ))) return 0;
 287     PatBlt32( hdc, rect->left, rect->top,
 288               rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
 289     SelectObject32( hdc, prevBrush );
 290     return 1;
 291 }
 292
 293
 294 /***********************************************************************
 295  *           InvertRect16    (USER.82)
 296  */
 297 void WINAPI InvertRect16( HDC16 hdc, const RECT16 *rect )
 298 {
 299     PatBlt32( hdc, rect->left, rect->top,
 300               rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 301 }
 302
 303
 304 /***********************************************************************
 305  *           InvertRect32    (USER32.330)
 306  */
 307 void WINAPI InvertRect32( HDC32 hdc, const RECT32 *rect )
 308 {
 309     PatBlt32( hdc, rect->left, rect->top,
 310               rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 311 }
 312
 313
 314 /***********************************************************************
 315  *           FrameRect16    (USER.83)
 316  */
 317 INT16 WINAPI FrameRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
 318 {
 319     HBRUSH16 prevBrush;
 320     int left, top, right, bottom;
 321
 322     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 323     if (!dc) return FALSE;
 324
 325     left   = XLPTODP( dc, rect->left );
 326     top    = YLPTODP( dc, rect->top );
 327     right  = XLPTODP( dc, rect->right );
 328     bottom = YLPTODP( dc, rect->bottom );
 329
 330     if ( (right <= left) || (bottom <= top) ) return 0;
 331     if (!(prevBrush = SelectObject16( hdc, hbrush ))) return 0;
 332
 333     if (DC_SetupGCForBrush( dc ))
 334     {
 335         PatBlt32( hdc, rect->left, rect->top, 1,
 336                   rect->bottom - rect->top, PATCOPY );
 337         PatBlt32( hdc, rect->right - 1, rect->top, 1,
 338                   rect->bottom - rect->top, PATCOPY );
 339         PatBlt32( hdc, rect->left, rect->top,
 340                   rect->right - rect->left, 1, PATCOPY );
 341         PatBlt32( hdc, rect->left, rect->bottom - 1,
 342                   rect->right - rect->left, 1, PATCOPY );
 343     }
 344     SelectObject16( hdc, prevBrush );
 345     return 1;
 346 }
 347
 348
 349 /***********************************************************************
 350  *           FrameRect32    (USER32.203)
 351  */
 352 INT32 WINAPI FrameRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
 353 {
 354     RECT16 rect16;
 355     CONV_RECT32TO16( rect, &rect16 );
 356     return FrameRect16( (HDC16)hdc, &rect16, (HBRUSH16)hbrush );
 357 }
 358
 359
 360 /***********************************************************************
 361  *           SetPixel16    (GDI.31)
 362  */
 363 COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 364 {
 365     return SetPixel32( hdc, x, y, color );
 366 }
 367
 368
 369 /***********************************************************************
 370  *           SetPixel32    (GDI32.327)
 371  */
 372 COLORREF WINAPI SetPixel32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
 373 {
 374     DC * dc = DC_GetDCPtr( hdc );
 375
 376     if (!dc || !dc->funcs->pSetPixel) return 0;
 377     return dc->funcs->pSetPixel(dc,x,y,color);
 378 }
 379
 380 /***********************************************************************
 381  *           SetPixelV32    (GDI32.329)
 382  */
 383 BOOL32 WINAPI SetPixelV32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
 384 {
 385     DC * dc = DC_GetDCPtr( hdc );
 386
 387     if (!dc || !dc->funcs->pSetPixel) return FALSE;
 388     dc->funcs->pSetPixel(dc,x,y,color);
 389     return TRUE;
 390 }
 391
 392 /***********************************************************************
 393  *           GetPixel16    (GDI.83)
 394  */
 395 COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
 396 {
 397     return GetPixel32( hdc, x, y );
 398 }
 399
 400
 401 /***********************************************************************
 402  *           GetPixel32    (GDI32.211)
 403  */
 404 COLORREF WINAPI GetPixel32( HDC32 hdc, INT32 x, INT32 y )
 405 {
 406     DC * dc = DC_GetDCPtr( hdc );
 407
 408     if (!dc) return 0;
 409 #ifdef SOLITAIRE_SPEED_HACK
 410     return 0;
 411 #endif
 412
 413     /* FIXME: should this be in the graphics driver? */
 414     if (!PtVisible32( hdc, x, y )) return 0;
 415     if (!dc || !dc->funcs->pGetPixel) return 0;
 416     return dc->funcs->pGetPixel(dc,x,y);
 417 }
 418
 419
 420 /******************************************************************************
 421  * ChoosePixelFormat [GDI32.13]
 422  * Matches a pixel format to given format
 423  *
 424  * PARAMS
 425  *    hdc  [I] Device context to search for best pixel match
 426  *    ppfd [I] Pixel format for which a match is sought
 427  *
 428  * RETURNS
 429  *    Success: Pixel format index closest to given format
 430  *    Failure: 0
 431  */
 432 INT32 WINAPI ChoosePixelFormat( HDC32 hdc, const PIXELFORMATDESCRIPTOR* ppfd )
 433 {
 434     FIXME(gdi, "(%d,%p): stub\n",hdc,ppfd);
 435     return 1;
 436 }
 437
 438
 439 /******************************************************************************
 440  * SetPixelFormat [GDI32.328]
 441  * Sets pixel format of device context
 442  *
 443  * PARAMS
 444  *    hdc          [I] Device context to search for best pixel match
 445  *    iPixelFormat [I] Pixel format index
 446  *    ppfd         [I] Pixel format for which a match is sought
 447  *
 448  * RETURNS STD
 449  */
 450 BOOL32 WINAPI SetPixelFormat( HDC32 hdc, int iPixelFormat,
 451                               const PIXELFORMATDESCRIPTOR* ppfd)
 452 {
 453     FIXME(gdi, "(%d,%d,%p): stub\n",hdc,iPixelFormat,ppfd);
 454     return TRUE;
 455 }
 456
 457
 458 /******************************************************************************
 459  * GetPixelFormat [GDI32.212]
 460  * Gets index of pixel format of DC
 461  *
 462  * PARAMETERS
 463  *    hdc [I] Device context whose pixel format index is sought
 464  *
 465  * RETURNS
 466  *    Success: Currently selected pixel format
 467  *    Failure: 0
 468  */
 469 int WINAPI GetPixelFormat( HDC32 hdc )
 470 {
 471     FIXME(gdi, "(%d): stub\n",hdc);
 472     return 1;
 473 }
 474
 475
 476 /******************************************************************************
 477  * DescribePixelFormat [GDI32.71]
 478  * Gets info about pixel format from DC
 479  *
 480  * PARAMS
 481  *    hdc          [I] Device context
 482  *    iPixelFormat [I] Pixel format selector
 483  *    nBytes       [I] Size of buffer
 484  *    ppfd         [O] Pointer to structure to receive pixel format data
 485  *
 486  * RETURNS
 487  *    Success: Maximum pixel format index of the device context
 488  *    Failure: 0
 489  */
 490 int WINAPI DescribePixelFormat( HDC32 hdc, int iPixelFormat, UINT32 nBytes,
 491                                 LPPIXELFORMATDESCRIPTOR ppfd )
 492 {
 493     FIXME(gdi, "(%d,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd);
 494     ppfd->nSize = nBytes;
 495     ppfd->nVersion = 1;
 496     return 3;
 497 }
 498
 499
 500 /******************************************************************************
 501  * SwapBuffers [GDI32.354]
 502  * Exchanges front and back buffers of window
 503  *
 504  * PARAMS
 505  *    hdc [I] Device context whose buffers get swapped
 506  *
 507  * RETURNS STD
 508  */
 509 BOOL32 WINAPI SwapBuffers( HDC32 hdc )
 510 {
 511     FIXME(gdi, "(%d): stub\n",hdc);
 512     return TRUE;
 513 }
 514
 515
 516 /***********************************************************************
 517  *           PaintRgn16    (GDI.43)
 518  */
 519 BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
 520 {
 521     return PaintRgn32( hdc, hrgn );
 522 }
 523
 524
 525 /***********************************************************************
 526  *           PaintRgn32    (GDI32.259)
 527  */
 528 BOOL32 WINAPI PaintRgn32( HDC32 hdc, HRGN32 hrgn )
 529 {
 530     DC * dc = DC_GetDCPtr( hdc );
 531
 532     return dc && dc->funcs->pPaintRgn &&
 533            dc->funcs->pPaintRgn(dc,hrgn);
 534 }
 535
 536
 537 /***********************************************************************
 538  *           FillRgn16    (GDI.40)
 539  */
 540 BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
 541 {
 542     return FillRgn32( hdc, hrgn, hbrush );
 543 }
 544
 545
 546 /***********************************************************************
 547  *           FillRgn32    (GDI32.101)
 548  */
 549 BOOL32 WINAPI FillRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush )
 550 {
 551     BOOL32 retval;
 552     HBRUSH32 prevBrush = SelectObject32( hdc, hbrush );
 553     if (!prevBrush) return FALSE;
 554     retval = PaintRgn32( hdc, hrgn );
 555     SelectObject32( hdc, prevBrush );
 556     return retval;
 557 }
 558
 559
 560 /***********************************************************************
 561  *           FrameRgn16     (GDI.41)
 562  */
 563 BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
 564                           INT16 nWidth, INT16 nHeight )
 565 {
 566     return FrameRgn32( hdc, hrgn, hbrush, nWidth, nHeight );
 567 }
 568
 569
 570 /***********************************************************************
 571  *           FrameRgn32     (GDI32.105)
 572  */
 573 BOOL32 WINAPI FrameRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush,
 574                           INT32 nWidth, INT32 nHeight )
 575 {
 576     HRGN32 tmp = CreateRectRgn32( 0, 0, 0, 0 );
 577     if(!REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) return FALSE;
 578     FillRgn32( hdc, tmp, hbrush );
 579     DeleteObject32( tmp );
 580     return TRUE;
 581 }
 582
 583
 584 /***********************************************************************
 585  *           InvertRgn16    (GDI.42)
 586  */
 587 BOOL16 WINAPI InvertRgn16( HDC16 hdc, HRGN16 hrgn )
 588 {
 589     return InvertRgn32( hdc, hrgn );
 590 }
 591
 592
 593 /***********************************************************************
 594  *           InvertRgn32    (GDI32.246)
 595  */
 596 BOOL32 WINAPI InvertRgn32( HDC32 hdc, HRGN32 hrgn )
 597 {
 598     HBRUSH32 prevBrush = SelectObject32( hdc, GetStockObject32(BLACK_BRUSH) );
 599     INT32 prevROP = SetROP232( hdc, R2_NOT );
 600     BOOL32 retval = PaintRgn32( hdc, hrgn );
 601     SelectObject32( hdc, prevBrush );
 602     SetROP232( hdc, prevROP );
 603     return retval;
 604 }
 605
 606
 607 /***********************************************************************
 608  *           DrawFocusRect16    (USER.466)
 609  */
 610 void WINAPI DrawFocusRect16( HDC16 hdc, const RECT16* rc )
 611 {
 612     RECT32 rect32;
 613     CONV_RECT16TO32( rc, &rect32 );
 614     DrawFocusRect32( hdc, &rect32 );
 615 }
 616
 617
 618 /***********************************************************************
 619  *           DrawFocusRect32    (USER32.156)
 620  *
 621  * FIXME: PatBlt(PATINVERT) with background brush.
 622  */
 623 void WINAPI DrawFocusRect32( HDC32 hdc, const RECT32* rc )
 624 {
 625     HPEN32 hOldPen, hnewPen;
 626     INT32 oldDrawMode, oldBkMode;
 627     INT32 left, top, right, bottom;
 628
 629     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 630     if (!dc) return;
 631
 632     left   = XLPTODP( dc, rc->left );
 633     top    = YLPTODP( dc, rc->top );
 634     right  = XLPTODP( dc, rc->right );
 635     bottom = YLPTODP( dc, rc->bottom );
 636
 637     if(left == right || top == bottom)
 638         return;
 639
 640     hnewPen = CreatePen32(PS_DOT, 1, GetSysColor32(COLOR_WINDOWTEXT) );
 641     hOldPen = SelectObject32( hdc, hnewPen );
 642     oldDrawMode = SetROP232(hdc, R2_XORPEN);
 643     oldBkMode = SetBkMode32(hdc, TRANSPARENT);
 644
 645     /* Hack: make sure the XORPEN operation has an effect */
 646     dc->u.x.pen.pixel = (1 << screenDepth) - 1;
 647
 648     if (DC_SetupGCForPen( dc ))
 649         TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 650                         dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 651                         right-left-1, bottom-top-1 );
 652
 653     SetBkMode32(hdc, oldBkMode);
 654     SetROP232(hdc, oldDrawMode);
 655     SelectObject32(hdc, hOldPen);
 656     DeleteObject32(hnewPen);
 657 }
 658
 659
 660 /**********************************************************************
 661  *          Polyline16  (GDI.37)
 662  */
 663 BOOL16 WINAPI Polyline16( HDC16 hdc, const POINT16* pt, INT16 count )
 664 {
 665     register int i;
 666     BOOL16 ret;
 667     LPPOINT32 pt32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
 668                                            count*sizeof(POINT32) );
 669
 670     if (!pt32) return FALSE;
 671     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 672     ret = Polyline32(hdc,pt32,count);
 673     HeapFree( GetProcessHeap(), 0, pt32 );
 674     return ret;
 675 }
 676
 677
 678 /**********************************************************************
 679  *          Polyline32   (GDI32.276)
 680  */
 681 BOOL32 WINAPI Polyline32( HDC32 hdc, const POINT32* pt, INT32 count )
 682 {
 683     DC * dc = DC_GetDCPtr( hdc );
 684
 685     return dc && dc->funcs->pPolyline &&
 686            dc->funcs->pPolyline(dc,pt,count);
 687 }
 688
 689
 690 /**********************************************************************
 691  *          Polygon16  (GDI.36)
 692  */
 693 BOOL16 WINAPI Polygon16( HDC16 hdc, const POINT16* pt, INT16 count )
 694 {
 695     register int i;
 696     BOOL32 ret;
 697     LPPOINT32 pt32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
 698                                            count*sizeof(POINT32) );
 699
 700     if (!pt32) return FALSE;
 701     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 702     ret = Polygon32(hdc,pt32,count);
 703     HeapFree( GetProcessHeap(), 0, pt32 );
 704     return ret;
 705 }
 706
 707
 708 /**********************************************************************
 709  *          Polygon32  (GDI32.275)
 710  */
 711 BOOL32 WINAPI Polygon32( HDC32 hdc, const POINT32* pt, INT32 count )
 712 {
 713     DC * dc = DC_GetDCPtr( hdc );
 714
 715     return dc && dc->funcs->pPolygon &&
 716            dc->funcs->pPolygon(dc,pt,count);
 717 }
 718
 719
 720 /**********************************************************************
 721  *          PolyPolygon16  (GDI.450)
 722  */
 723 BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
 724                              UINT16 polygons )
 725 {
 726     int         i,nrpts;
 727     LPPOINT32   pt32;
 728     LPINT32     counts32;
 729     BOOL16      ret;
 730
 731     nrpts=0;
 732     for (i=polygons;i--;)
 733         nrpts+=counts[i];
 734     pt32 = (LPPOINT32)HEAP_xalloc( GetProcessHeap(), 0, sizeof(POINT32)*nrpts);
 735     for (i=nrpts;i--;)
 736         CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 737     counts32 = (LPINT32)HEAP_xalloc( GetProcessHeap(), 0,
 738                                      polygons*sizeof(INT32) );
 739     for (i=polygons;i--;) counts32[i]=counts[i];
 740
 741     ret = PolyPolygon32(hdc,pt32,counts32,polygons);
 742     HeapFree( GetProcessHeap(), 0, counts32 );
 743     HeapFree( GetProcessHeap(), 0, pt32 );
 744     return ret;
 745 }
 746
 747 /**********************************************************************
 748  *          PolyPolygon32  (GDI.450)
 749  */
 750 BOOL32 WINAPI PolyPolygon32( HDC32 hdc, const POINT32* pt, const INT32* counts,
 751                              UINT32 polygons )
 752 {
 753     DC * dc = DC_GetDCPtr( hdc );
 754
 755     return dc && dc->funcs->pPolyPolygon &&
 756            dc->funcs->pPolyPolygon(dc,pt,counts,polygons);
 757 }
 758
 759 /**********************************************************************
 760  *          PolyPolyline32  (GDI32.272)
 761  */
 762 BOOL32 WINAPI PolyPolyline32( HDC32 hdc, const POINT32* pt, const DWORD* counts,
 763                              DWORD polylines )
 764 {
 765     DC * dc = DC_GetDCPtr( hdc );
 766
 767     return dc && dc->funcs->pPolyPolyline &&
 768            dc->funcs->pPolyPolyline(dc,pt,counts,polylines);
 769 }
 770
 771 /**********************************************************************
 772  *          ExtFloodFill16   (GDI.372)
 773  */
 774 BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
 775                               UINT16 fillType )
 776 {
 777     return ExtFloodFill32( hdc, x, y, color, fillType );
 778 }
 779
 780
 781 /**********************************************************************
 782  *          ExtFloodFill32   (GDI32.96)
 783  */
 784 BOOL32 WINAPI ExtFloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color,
 785                               UINT32 fillType )
 786 {
 787     DC *dc = DC_GetDCPtr( hdc );
 788
 789     return dc && dc->funcs->pExtFloodFill &&
 790            dc->funcs->pExtFloodFill(dc,x,y,color,fillType);
 791 }
 792
 793
 794 /**********************************************************************
 795  *          FloodFill16   (GDI.25)
 796  */
 797 BOOL16 WINAPI FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 798 {
 799     return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
 800 }
 801
 802
 803 /**********************************************************************
 804  *          FloodFill32   (GDI32.104)
 805  */
 806 BOOL32 WINAPI FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
 807 {
 808     return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
 809 }
 810
 811
 812 /**********************************************************************
 813  *          DrawAnimatedRects32  (USER32.153)
 814  */
 815 BOOL32 WINAPI DrawAnimatedRects32( HWND32 hwnd, int idAni,
 816                                    const RECT32* lprcFrom,
 817                                    const RECT32* lprcTo )
 818 {
 819     FIXME(gdi,"(0x%x,%d,%p,%p): stub\n",hwnd,idAni,lprcFrom,lprcTo);
 820     return TRUE;
 821 }
 822
 823
 824 /**********************************************************************
 825  *          PAINTING_DrawStateJam
 826  *
 827  * Jams in the requested type in the dc
 828  */
 829 static BOOL32 PAINTING_DrawStateJam(HDC32 hdc, UINT32 opcode,
 830                                     DRAWSTATEPROC32 func, LPARAM lp, WPARAM32 wp,
 831                                     LPRECT32 rc, UINT32 dtflags,
 832                                     BOOL32 unicode, BOOL32 _32bit)
 833 {
 834     HDC32 memdc;
 835     HBITMAP32 hbmsave;
 836     BOOL32 retval;
 837     INT32 cx = rc->right - rc->left;
 838     INT32 cy = rc->bottom - rc->top;
 839
 840     switch(opcode)
 841     {
 842     case DST_TEXT:
 843     case DST_PREFIXTEXT:
 844         if(unicode)
 845             return DrawText32W(hdc, (LPWSTR)lp, (INT32)wp, rc, dtflags);
 846         else if(_32bit)
 847             return DrawText32A(hdc, (LPSTR)lp, (INT32)wp, rc, dtflags);
 848         else
 849             return DrawText32A(hdc, (LPSTR)PTR_SEG_TO_LIN(lp), (INT32)wp, rc, dtflags);
 850
 851     case DST_ICON:
 852         return DrawIcon32(hdc, rc->left, rc->top, (HICON32)lp);
 853
 854     case DST_BITMAP:
 855         memdc = CreateCompatibleDC32(hdc);
 856         if(!memdc) return FALSE;
 857         hbmsave = (HBITMAP32)SelectObject32(memdc, (HBITMAP32)lp);
 858         if(!hbmsave)
 859         {
 860             DeleteDC32(memdc);
 861             return FALSE;
 862         }
 863         retval = BitBlt32(hdc, rc->left, rc->top, cx, cy, memdc, 0, 0, SRCCOPY);
 864         SelectObject32(memdc, hbmsave);
 865         DeleteDC32(memdc);
 866         return retval;
 867
 868     case DST_COMPLEX:
 869         if(func)
 870             if(_32bit)
 871                 return func(hdc, lp, wp, cx, cy);
 872             else
 873                 return (BOOL32)((DRAWSTATEPROC16)func)((HDC16)hdc, (LPARAM)lp, (WPARAM16)wp, (INT16)cx, (INT16)cy);
 874         else
 875             return FALSE;
 876     }
 877     return FALSE;
 878 }
 879
 880 /**********************************************************************
 881  *      PAINTING_DrawState32()
 882  */
 883 static BOOL32 PAINTING_DrawState32(HDC32 hdc, HBRUSH32 hbr,
 884                                    DRAWSTATEPROC32 func, LPARAM lp, WPARAM32 wp,
 885                                    INT32 x, INT32 y, INT32 cx, INT32 cy,
 886                                    UINT32 flags, BOOL32 unicode, BOOL32 _32bit)
 887 {
 888     HBITMAP32 hbm, hbmsave;
 889     HFONT32 hfsave;
 890     HBRUSH32 hbsave;
 891     HDC32 memdc;
 892     RECT32 rc;
 893     UINT32 dtflags = DT_NOCLIP;
 894     COLORREF fg, bg;
 895     UINT32 opcode = flags & 0xf;
 896     INT32 len = wp;
 897     BOOL32 retval, tmp;
 898
 899     if((opcode == DST_TEXT || opcode == DST_PREFIXTEXT) && !len)    /* The string is '\0' terminated */
 900     {
 901         if(unicode)
 902             len = lstrlen32W((LPWSTR)lp);
 903         else if(_32bit)
 904             len = lstrlen32A((LPSTR)lp);
 905         else
 906             len = lstrlen32A((LPSTR)PTR_SEG_TO_LIN(lp));
 907     }
 908
 909     /* Find out what size the image has if not given by caller */
 910     if(!cx || !cy)
 911     {
 912         SIZE32 s;
 913         CURSORICONINFO *ici;
 914         BITMAPOBJ *bmp;
 915
 916         switch(opcode)
 917         {
 918         case DST_TEXT:
 919         case DST_PREFIXTEXT:
 920             if(unicode)
 921                 retval = GetTextExtentPoint32W(hdc, (LPWSTR)lp, len, &s);
 922             else if(_32bit)
 923                 retval = GetTextExtentPoint32A(hdc, (LPSTR)lp, len, &s);
 924             else
 925                 retval = GetTextExtentPoint32A(hdc, PTR_SEG_TO_LIN(lp), len, &s);
 926             if(!retval) return FALSE;
 927             break;
 928
 929         case DST_ICON:
 930             ici = (CURSORICONINFO *)GlobalLock16((HGLOBAL16)lp);
 931             if(!ici) return FALSE;
 932             s.cx = ici->nWidth;
 933             s.cy = ici->nHeight;
 934             GlobalUnlock16((HGLOBAL16)lp);
 935             break;
 936
 937         case DST_BITMAP:
 938             bmp = (BITMAPOBJ *)GDI_GetObjPtr((HBITMAP16)lp, BITMAP_MAGIC);
 939             if(!bmp) return FALSE;
 940             s.cx = bmp->bitmap.bmWidth;
 941             s.cy = bmp->bitmap.bmHeight;
 942             break;
 943
 944         case DST_COMPLEX: /* cx and cy must be set in this mode */
 945             return FALSE;
 946         }
 947
 948         if(!cx) cx = s.cx;
 949         if(!cy) cy = s.cy;
 950     }
 951
 952     rc.left   = x;
 953     rc.top    = y;
 954     rc.right  = x + cx;
 955     rc.bottom = y + cy;
 956
 957     if(flags & DSS_RIGHT)    /* This one is not documented in the win32.hlp file */
 958         dtflags |= DT_RIGHT;
 959     if(opcode == DST_TEXT)
 960         dtflags |= DT_NOPREFIX;
 961
 962     /* For DSS_NORMAL we just jam in the image and return */
 963     if((flags & 0x7ff0) == DSS_NORMAL)
 964     {
 965         return PAINTING_DrawStateJam(hdc, opcode, func, lp, len, &rc, dtflags, unicode, _32bit);
 966     }
 967
 968     /* For all other states we need to convert the image to B/W in a local bitmap */
 969     /* before it is displayed */
 970     fg = SetTextColor32(hdc, RGB(0, 0, 0));
 971     bg = SetBkColor32(hdc, RGB(255, 255, 255));
 972     hbm = (HBITMAP32)NULL; hbmsave = (HBITMAP32)NULL;
 973     memdc = (HDC32)NULL; hbsave = (HBRUSH32)NULL;
 974     retval = FALSE; /* assume failure */
 975
 976     /* From here on we must use "goto cleanup" when something goes wrong */
 977     hbm     = CreateBitmap32(cx, cy, 1, 1, NULL);
 978     if(!hbm) goto cleanup;
 979     memdc   = CreateCompatibleDC32(hdc);
 980     if(!memdc) goto cleanup;
 981     hbmsave = (HBITMAP32)SelectObject32(memdc, hbm);
 982     if(!hbmsave) goto cleanup;
 983     rc.left = rc.top = 0;
 984     rc.right = cx;
 985     rc.bottom = cy;
 986     if(!FillRect32(memdc, &rc, (HBRUSH32)GetStockObject32(WHITE_BRUSH))) goto cleanup;
 987     SetBkColor32(memdc, RGB(255, 255, 255));
 988     SetTextColor32(memdc, RGB(0, 0, 0));
 989     hfsave  = (HFONT32)SelectObject32(memdc, GetCurrentObject(hdc, OBJ_FONT));
 990     if(!hfsave && (opcode == DST_TEXT || opcode == DST_PREFIXTEXT)) goto cleanup;
 991     tmp = PAINTING_DrawStateJam(memdc, opcode, func, lp, len, &rc, dtflags, unicode, _32bit);
 992     if(hfsave) SelectObject32(memdc, hfsave);
 993     if(!tmp) goto cleanup;
 994
 995     /* These states cause the image to be dithered */
 996     if(flags & (DSS_UNION|DSS_DISABLED))
 997     {
 998         hbsave = (HBRUSH32)SelectObject32(memdc, CACHE_GetPattern55AABrush());
 999         if(!hbsave) goto cleanup;
1000         tmp = PatBlt32(memdc, 0, 0, cx, cy, 0x00FA0089);
1001         if(hbsave) SelectObject32(memdc, hbsave);
1002         if(!tmp) goto cleanup;
1003     }
1004
1005     hbsave = (HBRUSH32)SelectObject32(hdc, hbr ? hbr : GetStockObject32(WHITE_BRUSH));
1006     if(!hbsave) goto cleanup;
1007
1008     if(!BitBlt32(hdc, x, y, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;
1009
1010     /* DSS_DEFAULT makes the image boldface */
1011     if(flags & DSS_DEFAULT)
1012     {
1013         if(!BitBlt32(hdc, x+1, y, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;
1014     }
1015
1016     retval = TRUE; /* We succeeded */
1017
1018 cleanup:
1019     SetTextColor32(hdc, fg);
1020     SetBkColor32(hdc, bg);
1021
1022     if(hbsave)  SelectObject32(hdc, hbsave);
1023     if(hbmsave) SelectObject32(memdc, hbmsave);
1024     if(hbm)     DeleteObject32(hbm);
1025     if(memdc)   DeleteDC32(memdc);
1026
1027     return retval;
1028 }
1029
1030 /**********************************************************************
1031  *      DrawState32A()   (USER32.162)
1032  */
1033 BOOL32 WINAPI DrawState32A(HDC32 hdc, HBRUSH32 hbr,
1034                    DRAWSTATEPROC32 func, LPARAM ldata, WPARAM32 wdata,
1035                    INT32 x, INT32 y, INT32 cx, INT32 cy, UINT32 flags)
1036 {
1037     return PAINTING_DrawState32(hdc, hbr, func, ldata, wdata, x, y, cx, cy, flags, FALSE, TRUE);
1038 }
1039
1040 /**********************************************************************
1041  *      DrawState32W()   (USER32.163)
1042  */
1043 BOOL32 WINAPI DrawState32W(HDC32 hdc, HBRUSH32 hbr,
1044                    DRAWSTATEPROC32 func, LPARAM ldata, WPARAM32 wdata,
1045                    INT32 x, INT32 y, INT32 cx, INT32 cy, UINT32 flags)
1046 {
1047     return PAINTING_DrawState32(hdc, hbr, func, ldata, wdata, x, y, cx, cy, flags, TRUE, TRUE);
1048 }
1049
1050 /**********************************************************************
1051  *      DrawState16()   (USER.449)
1052  */
1053 BOOL16 WINAPI DrawState16(HDC16 hdc, HBRUSH16 hbr,
1054                    DRAWSTATEPROC16 func, LPARAM ldata, WPARAM16 wdata,
1055                    INT16 x, INT16 y, INT16 cx, INT16 cy, UINT16 flags)
1056 {
1057     return PAINTING_DrawState32(hdc, hbr, (DRAWSTATEPROC32)func, ldata, wdata, x, y, cx, cy, flags, FALSE, FALSE);
1058 }
1059
1060
1061 /******************************************************************************
1062  * PolyBezier16 [GDI.502]
1063  */
1064 BOOL16 WINAPI PolyBezier16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
1065 {
1066     int i;
1067     BOOL16 ret;
1068     LPPOINT32 pt32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
1069                                            cPoints*sizeof(POINT32) );
1070     if(!pt32) return FALSE;
1071     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
1072     ret= PolyBezier32(hDc, pt32, cPoints);
1073     HeapFree( GetProcessHeap(), 0, pt32 );
1074     return ret;
1075 }
1076
1077 /******************************************************************************
1078  * PolyBezierTo16 [GDI.503]
1079  */
1080 BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
1081 {
1082     int i;
1083     BOOL16 ret;
1084     LPPOINT32 pt32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
1085                                            cPoints*sizeof(POINT32) );
1086     if(!pt32) return FALSE;
1087     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
1088     ret= PolyBezierTo32(hDc, pt32, cPoints);
1089     HeapFree( GetProcessHeap(), 0, pt32 );
1090     return ret;
1091 }
1092
1093 /******************************************************************************
1094  * PolyBezier32 [GDI32.268]
1095  * Draws one or more Bezier curves
1096  *
1097  * PARAMS
1098  *    hDc     [I] Handle to device context
1099  *    lppt    [I] Pointer to endpoints and control points
1100  *    cPoints [I] Count of endpoints and control points
1101  *
1102  * RETURNS STD
1103  */
1104 BOOL32 WINAPI PolyBezier32( HDC32 hdc, const POINT32* lppt, DWORD cPoints )
1105 {
1106     DC * dc = DC_GetDCPtr( hdc );
1107     if(!dc) return FALSE;
1108     if(dc && PATH_IsPathOpen(dc->w.path))
1109         FIXME(gdi, "PATH_PolyBezier is not implemented!\n");
1110 /*        if(!PATH_PolyBezier(hdc, x, y))
1111            return FALSE; */
1112     return dc->funcs->pPolyBezier&&
1113            dc->funcs->pPolyBezier(dc, lppt[0], lppt+1, cPoints-1);
1114 }
1115
1116 /******************************************************************************
1117  * PolyBezierTo32 [GDI32.269]
1118  * Draws one or more Bezier curves
1119  *
1120  * PARAMS
1121  *    hDc     [I] Handle to device context
1122  *    lppt    [I] Pointer to endpoints and control points
1123  *    cPoints [I] Count of endpoints and control points
1124  *
1125  * RETURNS STD
1126  */
1127 BOOL32 WINAPI PolyBezierTo32( HDC32 hdc, const POINT32* lppt, DWORD cPoints )
1128 {
1129     DC * dc = DC_GetDCPtr( hdc );
1130     POINT32 pt;
1131     BOOL32 ret;
1132     if(!dc) return FALSE;
1133     pt.x=dc->w.CursPosX;
1134     pt.y=dc->w.CursPosY;
1135     if(dc && PATH_IsPathOpen(dc->w.path))
1136         FIXME(gdi, "PATH_PolyBezierTo is not implemented!\n");
1137 /*        if(!PATH_PolyBezier(hdc, x, y))
1138            return FALSE; */
1139     ret= dc->funcs->pPolyBezier &&
1140            dc->funcs->pPolyBezier(dc, pt, lppt, cPoints);
1141     if( dc->funcs->pMoveToEx)
1142            dc->funcs->pMoveToEx(dc,lppt[cPoints].x,lppt[cPoints].y,&pt);
1143     return ret;
1144 }