graphics/painting.c

   1 /*
   2  * Misc. graphics operations
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <math.h>
   8 #include <stdlib.h>
   9 #include <X11/Xlib.h>
  10 #include <X11/Xutil.h>
  11 #include <X11/Intrinsic.h>
  12 #ifndef PI
  13 #define PI M_PI
  14 #endif
  15 #include "gdi.h"
  16 #include "dc.h"
  17 #include "bitmap.h"
  18 #include "callback.h"
  19 #include "metafile.h"
  20 #include "syscolor.h"
  21 #include "palette.h"
  22 #include "color.h"
  23 #include "region.h"
  24 #include "stddebug.h"
  25 #include "debug.h"
  26 #include "xmalloc.h"
  27
  28 BOOL32 DrawDiagEdge32(HDC32 hdc, RECT32 *rect, UINT32 edge, UINT32 flags);
  29 BOOL32 DrawRectEdge32(HDC32 hdc, RECT32 *rect, UINT32 edge, UINT32 flags);
  30 BOOL32 DrawFrameButton32(HDC32 hdc, LPRECT32 rc, UINT32 uState);
  31 BOOL32 DrawFrameCaption32(HDC32 hdc, LPRECT32 rc, UINT32 uState);
  32 BOOL32 DrawFrameMenu32(HDC32 hdc, LPRECT32 rc, UINT32 uState);
  33 BOOL32 DrawFrameScroll32(HDC32 hdc, LPRECT32 rc, UINT32 uState);
  34
  35 /***********************************************************************
  36  *           LineTo16    (GDI.19)
  37  */
  38 BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
  39 {
  40     return LineTo32( hdc, x, y );
  41 }
  42
  43
  44 /***********************************************************************
  45  *           LineTo32    (GDI32.249)
  46  */
  47 BOOL32 WINAPI LineTo32( HDC32 hdc, INT32 x, INT32 y )
  48 {
  49     DC * dc = DC_GetDCPtr( hdc );
  50
  51     return dc && dc->funcs->pLineTo &&
  52            dc->funcs->pLineTo(dc,x,y);
  53 }
  54
  55
  56 /***********************************************************************
  57  *           MoveTo    (GDI.20)
  58  */
  59 DWORD WINAPI MoveTo( HDC16 hdc, INT16 x, INT16 y )
  60 {
  61     POINT16     pt;
  62
  63     if (!MoveToEx16(hdc,x,y,&pt))
  64         return 0;
  65     return MAKELONG(pt.x,pt.y);
  66 }
  67
  68
  69 /***********************************************************************
  70  *           MoveToEx16    (GDI.483)
  71  */
  72 BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
  73 {
  74     POINT32 pt32;
  75
  76     if (!MoveToEx32( (HDC32)hdc, (INT32)x, (INT32)y, &pt32 )) return FALSE;
  77     if (pt) CONV_POINT32TO16( &pt32, pt );
  78     return TRUE;
  79
  80 }
  81
  82
  83 /***********************************************************************
  84  *           MoveToEx32    (GDI32.254)
  85  */
  86 BOOL32 WINAPI MoveToEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
  87 {
  88     DC * dc = DC_GetDCPtr( hdc );
  89
  90     return dc && dc->funcs->pMoveToEx &&
  91            dc->funcs->pMoveToEx(dc,x,y,pt);
  92 }
  93
  94
  95 /***********************************************************************
  96  *           Arc16    (GDI.23)
  97  */
  98 BOOL16 WINAPI Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
  99                      INT16 bottom, INT16 xstart, INT16 ystart,
 100                      INT16 xend, INT16 yend )
 101 {
 102     return Arc32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
 103                   (INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
 104                   (INT32)yend );
 105 }
 106
 107
 108 /***********************************************************************
 109  *           Arc32    (GDI32.7)
 110  */
 111 BOOL32 WINAPI Arc32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
 112                      INT32 bottom, INT32 xstart, INT32 ystart,
 113                      INT32 xend, INT32 yend )
 114 {
 115     DC * dc = DC_GetDCPtr( hdc );
 116
 117     return dc && dc->funcs->pArc &&
 118            dc->funcs->pArc(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 119 }
 120
 121
 122 /***********************************************************************
 123  *           Pie16    (GDI.26)
 124  */
 125 BOOL16 WINAPI Pie16( HDC16 hdc, INT16 left, INT16 top,
 126                      INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 127                      INT16 xend, INT16 yend )
 128 {
 129     return Pie32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
 130                   (INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
 131                   (INT32)yend );
 132 }
 133
 134
 135 /***********************************************************************
 136  *           Pie32   (GDI32.262)
 137  */
 138 BOOL32 WINAPI Pie32( HDC32 hdc, INT32 left, INT32 top,
 139                      INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
 140                      INT32 xend, INT32 yend )
 141 {
 142     DC * dc = DC_GetDCPtr( hdc );
 143
 144     return dc && dc->funcs->pPie &&
 145            dc->funcs->pPie(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 146 }
 147
 148
 149 /***********************************************************************
 150  *           Chord16    (GDI.348)
 151  */
 152 BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
 153                        INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 154                        INT16 xend, INT16 yend )
 155 {
 156     return Chord32( hdc, left, top, right, bottom, xstart, ystart, xend, yend );
 157 }
 158
 159
 160 /***********************************************************************
 161  *           Chord32    (GDI32.14)
 162  */
 163 BOOL32 WINAPI Chord32( HDC32 hdc, INT32 left, INT32 top,
 164                        INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
 165                        INT32 xend, INT32 yend )
 166 {
 167     DC * dc = DC_GetDCPtr( hdc );
 168
 169     return dc && dc->funcs->pChord &&
 170            dc->funcs->pChord(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 171 }
 172
 173
 174 /***********************************************************************
 175  *           Ellipse16    (GDI.24)
 176  */
 177 BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
 178                          INT16 right, INT16 bottom )
 179 {
 180     return Ellipse32( hdc, left, top, right, bottom );
 181 }
 182
 183
 184 /***********************************************************************
 185  *           Ellipse32    (GDI32.75)
 186  */
 187 BOOL32 WINAPI Ellipse32( HDC32 hdc, INT32 left, INT32 top,
 188                          INT32 right, INT32 bottom )
 189 {
 190     DC * dc = DC_GetDCPtr( hdc );
 191
 192     return dc && dc->funcs->pEllipse &&
 193            dc->funcs->pEllipse(dc,left,top,right,bottom);
 194 }
 195
 196
 197 /***********************************************************************
 198  *           Rectangle16    (GDI.27)
 199  */
 200 BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
 201                            INT16 right, INT16 bottom )
 202 {
 203     return Rectangle32( hdc, left, top, right, bottom );
 204 }
 205
 206
 207 /***********************************************************************
 208  *           Rectangle32    (GDI32.283)
 209  */
 210 BOOL32 WINAPI Rectangle32( HDC32 hdc, INT32 left, INT32 top,
 211                            INT32 right, INT32 bottom )
 212 {
 213     DC * dc = DC_GetDCPtr( hdc );
 214
 215     return dc && dc->funcs->pRectangle &&
 216            dc->funcs->pRectangle(dc,left,top,right,bottom);
 217 }
 218
 219
 220 /***********************************************************************
 221  *           RoundRect16    (GDI.28)
 222  */
 223 BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 224                            INT16 bottom, INT16 ell_width, INT16 ell_height )
 225 {
 226     return RoundRect32( hdc, left, top, right, bottom, ell_width, ell_height );
 227 }
 228
 229
 230 /***********************************************************************
 231  *           RoundRect32    (GDI32.291)
 232  */
 233 BOOL32 WINAPI RoundRect32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
 234                            INT32 bottom, INT32 ell_width, INT32 ell_height )
 235 {
 236     DC * dc = DC_GetDCPtr( hdc );
 237
 238     return dc && dc->funcs->pRoundRect &&
 239            dc->funcs->pRoundRect(dc,left,top,right,bottom,ell_width,ell_height);
 240 }
 241
 242
 243 /***********************************************************************
 244  *           FillRect16    (USER.81)
 245  */
 246 INT16 WINAPI FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
 247 {
 248     HBRUSH16 prevBrush;
 249
 250     /* coordinates are logical so we cannot fast-check 'rect',
 251      * it will be done later in the PatBlt().
 252      */
 253
 254     if (!(prevBrush = SelectObject16( hdc, hbrush ))) return 0;
 255     PatBlt32( hdc, rect->left, rect->top,
 256               rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
 257     SelectObject16( hdc, prevBrush );
 258     return 1;
 259 }
 260
 261
 262 /***********************************************************************
 263  *           FillRect32    (USER32.196)
 264  */
 265 INT32 WINAPI FillRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
 266 {
 267     HBRUSH32 prevBrush;
 268
 269     if (!(prevBrush = SelectObject32( hdc, hbrush ))) return 0;
 270     PatBlt32( hdc, rect->left, rect->top,
 271               rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
 272     SelectObject32( hdc, prevBrush );
 273     return 1;
 274 }
 275
 276
 277 /***********************************************************************
 278  *           InvertRect16    (USER.82)
 279  */
 280 void WINAPI InvertRect16( HDC16 hdc, const RECT16 *rect )
 281 {
 282     PatBlt32( hdc, rect->left, rect->top,
 283               rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 284 }
 285
 286
 287 /***********************************************************************
 288  *           InvertRect32    (USER32.329)
 289  */
 290 void WINAPI InvertRect32( HDC32 hdc, const RECT32 *rect )
 291 {
 292     PatBlt32( hdc, rect->left, rect->top,
 293               rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 294 }
 295
 296
 297 /***********************************************************************
 298  *           FrameRect16    (USER.83)
 299  */
 300 INT16 WINAPI FrameRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
 301 {
 302     HBRUSH16 prevBrush;
 303     int left, top, right, bottom;
 304
 305     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 306     if (!dc) return FALSE;
 307
 308     left   = XLPTODP( dc, rect->left );
 309     top    = YLPTODP( dc, rect->top );
 310     right  = XLPTODP( dc, rect->right );
 311     bottom = YLPTODP( dc, rect->bottom );
 312
 313     if ( (right <= left) || (bottom <= top) ) return 0;
 314     if (!(prevBrush = SelectObject16( hdc, hbrush ))) return 0;
 315
 316     if (DC_SetupGCForBrush( dc ))
 317     {
 318         PatBlt32( hdc, rect->left, rect->top, 1,
 319                   rect->bottom - rect->top, PATCOPY );
 320         PatBlt32( hdc, rect->right - 1, rect->top, 1,
 321                   rect->bottom - rect->top, PATCOPY );
 322         PatBlt32( hdc, rect->left, rect->top,
 323                   rect->right - rect->left, 1, PATCOPY );
 324         PatBlt32( hdc, rect->left, rect->bottom - 1,
 325                   rect->right - rect->left, 1, PATCOPY );
 326     }
 327     SelectObject16( hdc, prevBrush );
 328     return 1;
 329 }
 330
 331
 332 /***********************************************************************
 333  *           FrameRect32    (USER32.202)
 334  */
 335 INT32 WINAPI FrameRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
 336 {
 337     RECT16 rect16;
 338     CONV_RECT32TO16( rect, &rect16 );
 339     return FrameRect16( (HDC16)hdc, &rect16, (HBRUSH16)hbrush );
 340 }
 341
 342
 343 /***********************************************************************
 344  *           SetPixel16    (GDI.31)
 345  */
 346 COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 347 {
 348     return SetPixel32( hdc, x, y, color );
 349 }
 350
 351
 352 /***********************************************************************
 353  *           SetPixel32    (GDI32.327)
 354  */
 355 COLORREF WINAPI SetPixel32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
 356 {
 357     DC * dc = DC_GetDCPtr( hdc );
 358
 359     if (!dc || !dc->funcs->pSetPixel) return 0;
 360     return dc->funcs->pSetPixel(dc,x,y,color);
 361 }
 362
 363
 364 /***********************************************************************
 365  *           GetPixel16    (GDI.83)
 366  */
 367 COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
 368 {
 369     return GetPixel32( hdc, x, y );
 370 }
 371
 372
 373 /***********************************************************************
 374  *           GetPixel32    (GDI32.211)
 375  */
 376 COLORREF WINAPI GetPixel32( HDC32 hdc, INT32 x, INT32 y )
 377 {
 378     DC * dc = DC_GetDCPtr( hdc );
 379
 380     if (!dc) return 0;
 381 #ifdef SOLITAIRE_SPEED_HACK
 382     return 0;
 383 #endif
 384
 385     /* FIXME: should this be in the graphics driver? */
 386     if (!PtVisible32( hdc, x, y )) return 0;
 387     if (!dc || !dc->funcs->pGetPixel) return 0;
 388     return dc->funcs->pGetPixel(dc,x,y);
 389 }
 390
 391
 392 /***********************************************************************
 393  *           PaintRgn16    (GDI.43)
 394  */
 395 BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
 396 {
 397     return PaintRgn32( hdc, hrgn );
 398 }
 399
 400
 401 /***********************************************************************
 402  *           PaintRgn32    (GDI32.259)
 403  */
 404 BOOL32 WINAPI PaintRgn32( HDC32 hdc, HRGN32 hrgn )
 405 {
 406     DC * dc = DC_GetDCPtr( hdc );
 407
 408     return dc && dc->funcs->pPaintRgn &&
 409            dc->funcs->pPaintRgn(dc,hrgn);
 410 }
 411
 412
 413 /***********************************************************************
 414  *           FillRgn16    (GDI.40)
 415  */
 416 BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
 417 {
 418     return FillRgn32( hdc, hrgn, hbrush );
 419 }
 420
 421
 422 /***********************************************************************
 423  *           FillRgn32    (GDI32.101)
 424  */
 425 BOOL32 WINAPI FillRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush )
 426 {
 427     BOOL32 retval;
 428     HBRUSH32 prevBrush = SelectObject32( hdc, hbrush );
 429     if (!prevBrush) return FALSE;
 430     retval = PaintRgn32( hdc, hrgn );
 431     SelectObject32( hdc, prevBrush );
 432     return retval;
 433 }
 434
 435
 436 /***********************************************************************
 437  *           FrameRgn16     (GDI.41)
 438  */
 439 BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
 440                           INT16 nWidth, INT16 nHeight )
 441 {
 442     return FrameRgn32( hdc, hrgn, hbrush, nWidth, nHeight );
 443 }
 444
 445
 446 /***********************************************************************
 447  *           FrameRgn32     (GDI32.105)
 448  */
 449 BOOL32 WINAPI FrameRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush,
 450                           INT32 nWidth, INT32 nHeight )
 451 {
 452     HRGN32 tmp = CreateRectRgn32( 0, 0, 0, 0 );
 453     if(!REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) return FALSE;
 454     FillRgn32( hdc, tmp, hbrush );
 455     DeleteObject32( tmp );
 456     return TRUE;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           InvertRgn16    (GDI.42)
 462  */
 463 BOOL16 WINAPI InvertRgn16( HDC16 hdc, HRGN16 hrgn )
 464 {
 465     return InvertRgn32( hdc, hrgn );
 466 }
 467
 468
 469 /***********************************************************************
 470  *           InvertRgn32    (GDI32.246)
 471  */
 472 BOOL32 WINAPI InvertRgn32( HDC32 hdc, HRGN32 hrgn )
 473 {
 474     HBRUSH32 prevBrush = SelectObject32( hdc, GetStockObject32(BLACK_BRUSH) );
 475     INT32 prevROP = SetROP232( hdc, R2_NOT );
 476     BOOL32 retval = PaintRgn32( hdc, hrgn );
 477     SelectObject32( hdc, prevBrush );
 478     SetROP232( hdc, prevROP );
 479     return retval;
 480 }
 481
 482
 483 /***********************************************************************
 484  *           DrawFocusRect16    (USER.466)
 485  */
 486 void WINAPI DrawFocusRect16( HDC16 hdc, const RECT16* rc )
 487 {
 488     RECT32 rect32;
 489     CONV_RECT16TO32( rc, &rect32 );
 490     DrawFocusRect32( hdc, &rect32 );
 491 }
 492
 493
 494 /***********************************************************************
 495  *           DrawFocusRect32    (USER32.155)
 496  *
 497  * FIXME: PatBlt(PATINVERT) with background brush.
 498  */
 499 void WINAPI DrawFocusRect32( HDC32 hdc, const RECT32* rc )
 500 {
 501     HPEN32 hOldPen;
 502     INT32 oldDrawMode, oldBkMode;
 503     INT32 left, top, right, bottom;
 504
 505     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 506     if (!dc) return;
 507
 508     left   = XLPTODP( dc, rc->left );
 509     top    = YLPTODP( dc, rc->top );
 510     right  = XLPTODP( dc, rc->right );
 511     bottom = YLPTODP( dc, rc->bottom );
 512
 513     hOldPen = SelectObject32( hdc, sysColorObjects.hpenWindowText );
 514     oldDrawMode = SetROP232(hdc, R2_XORPEN);
 515     oldBkMode = SetBkMode32(hdc, TRANSPARENT);
 516
 517     /* Hack: make sure the XORPEN operation has an effect */
 518     dc->u.x.pen.pixel = (1 << screenDepth) - 1;
 519
 520     if (DC_SetupGCForPen( dc ))
 521         XDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 522                         dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 523                         right-left-1, bottom-top-1 );
 524
 525     SetBkMode32(hdc, oldBkMode);
 526     SetROP232(hdc, oldDrawMode);
 527     SelectObject32(hdc, hOldPen);
 528 }
 529
 530
 531 /**********************************************************************
 532  *          Polyline16  (GDI.37)
 533  */
 534 BOOL16 WINAPI Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
 535 {
 536     register int i;
 537     LPPOINT32 pt32 = (LPPOINT32)xmalloc(count*sizeof(POINT32));
 538     BOOL16 ret;
 539
 540     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 541     ret = Polyline32(hdc,pt32,count);
 542     free(pt32);
 543     return ret;
 544 }
 545
 546
 547 /**********************************************************************
 548  *          Polyline32   (GDI32.276)
 549  */
 550 BOOL32 WINAPI Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
 551 {
 552     DC * dc = DC_GetDCPtr( hdc );
 553
 554     return dc && dc->funcs->pPolyline &&
 555            dc->funcs->pPolyline(dc,pt,count);
 556 }
 557
 558
 559 /**********************************************************************
 560  *          Polygon16  (GDI.36)
 561  */
 562 BOOL16 WINAPI Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
 563 {
 564     register int i;
 565     LPPOINT32 pt32 = (LPPOINT32)xmalloc(count*sizeof(POINT32));
 566     BOOL32 ret;
 567
 568
 569     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 570     ret = Polygon32(hdc,pt32,count);
 571     free(pt32);
 572     return ret;
 573 }
 574
 575
 576 /**********************************************************************
 577  *          Polygon32  (GDI32.275)
 578  */
 579 BOOL32 WINAPI Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
 580 {
 581     DC * dc = DC_GetDCPtr( hdc );
 582
 583     return dc && dc->funcs->pPolygon &&
 584            dc->funcs->pPolygon(dc,pt,count);
 585 }
 586
 587
 588 /**********************************************************************
 589  *          PolyPolygon16  (GDI.450)
 590  */
 591 BOOL16 WINAPI PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts,
 592                              UINT16 polygons )
 593 {
 594     int         i,nrpts;
 595     LPPOINT32   pt32;
 596     LPINT32     counts32;
 597     BOOL16      ret;
 598
 599     nrpts=0;
 600     for (i=polygons;i--;)
 601         nrpts+=counts[i];
 602     pt32 = (LPPOINT32)xmalloc(sizeof(POINT32)*nrpts);
 603     for (i=nrpts;i--;)
 604         CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 605     counts32 = (LPINT32)xmalloc(polygons*sizeof(INT32));
 606     for (i=polygons;i--;) counts32[i]=counts[i];
 607
 608     ret = PolyPolygon32(hdc,pt32,counts32,polygons);
 609     free(counts32);
 610     free(pt32);
 611     return ret;
 612 }
 613
 614 /**********************************************************************
 615  *          PolyPolygon32  (GDI.450)
 616  */
 617 BOOL32 WINAPI PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts,
 618                              UINT32 polygons )
 619 {
 620     DC * dc = DC_GetDCPtr( hdc );
 621
 622     return dc && dc->funcs->pPolyPolygon &&
 623            dc->funcs->pPolyPolygon(dc,pt,counts,polygons);
 624 }
 625
 626 /**********************************************************************
 627  *          ExtFloodFill16   (GDI.372)
 628  */
 629 BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
 630                               UINT16 fillType )
 631 {
 632     return ExtFloodFill32( hdc, x, y, color, fillType );
 633 }
 634
 635
 636 /**********************************************************************
 637  *          ExtFloodFill32   (GDI32.96)
 638  */
 639 BOOL32 WINAPI ExtFloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color,
 640                               UINT32 fillType )
 641 {
 642     DC *dc = DC_GetDCPtr( hdc );
 643
 644     return dc && dc->funcs->pExtFloodFill &&
 645            dc->funcs->pExtFloodFill(dc,x,y,color,fillType);
 646 }
 647
 648
 649 /**********************************************************************
 650  *          FloodFill16   (GDI.25)
 651  */
 652 BOOL16 WINAPI FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 653 {
 654     return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
 655 }
 656
 657
 658 /**********************************************************************
 659  *          FloodFill32   (GDI32.104)
 660  */
 661 BOOL32 WINAPI FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
 662 {
 663     return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
 664 }
 665
 666
 667 /**********************************************************************
 668  *          DrawFrameControl32  (USER32.152)
 669  */
 670 BOOL32 WINAPI DrawAnimatedRects32( HWND32 hwnd, int idAni,
 671                                    const LPRECT32 lprcFrom,
 672                                    const LPRECT32 lprcTo )
 673 {
 674     fprintf( stdnimp,"DrawAnimatedRects32(%x,%d,%p,%p), empty stub!\n",
 675              hwnd, idAni, lprcFrom, lprcTo );
 676     return TRUE;
 677 }
 678
 679 BOOL32 WINAPI DrawState32A(
 680         HDC32 hdc,HBRUSH32 hbrush,DRAWSTATEPROC drawstateproc,
 681         LPARAM lparam,WPARAM32 wparam,INT32 x,INT32 y,INT32 z,INT32 a,UINT32 b
 682 ) {
 683         fprintf(stderr,"DrawStateA(%x,%x,%p,0x%08lx,0x%08x,%d,%d,%d,%d,%d),stub\n",
 684                 hdc,hbrush,drawstateproc,lparam,wparam,x,y,z,a,b
 685         );
 686         return TRUE;
 687 }
 688