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