dlls/user/static.c

   1 /*
   2  * Static control
   3  *
   4  * Copyright  David W. Metcalfe, 1993
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES
  21  *
  22  * This code was audited for completeness against the documented features
  23  * of Comctl32.dll version 6.0 on Oct. 4, 2004, by Dimitrie O. Paun.
  24  *
  25  * Unless otherwise noted, we believe this code to be complete, as per
  26  * the specification mentioned above.
  27  * If you discover missing features, or bugs, please note them below.
  28  *
  29  * Notes:
  30  *   - Windows XP introduced new behavior: The background of centered
  31  *     icons and bitmaps is painted differently. This is only done if
  32  *     a manifest is present.
  33  *     Because it has not yet been decided how to implement the two
  34  *     different modes in Wine, only the Windows XP mode is implemented.
  35  *   - Controls with SS_SIMPLE but without SS_NOPREFIX:
  36  *     The text should not be changed. Windows doesn't clear the
  37  *     client rectangle, so the new text must be larger than the old one.
  38  *   - The SS_RIGHTJUST style is currently not implemented by Windows
  39  *     (or it does something different than documented).
  40  *
  41  * TODO:
  42  *   - Animated cursors
  43  */
  44
  45 #include <stdarg.h>
  46
  47 #include "windef.h"
  48 #include "winbase.h"
  49 #include "wingdi.h"
  50 #include "wine/winuser16.h"
  51 #include "controls.h"
  52 #include "user_private.h"
  53 #include "wine/debug.h"
  54
  55 WINE_DEFAULT_DEBUG_CHANNEL(static);
  56
  57 static void STATIC_PaintOwnerDrawfn( HWND hwnd, HDC hdc, DWORD style );
  58 static void STATIC_PaintTextfn( HWND hwnd, HDC hdc, DWORD style );
  59 static void STATIC_PaintRectfn( HWND hwnd, HDC hdc, DWORD style );
  60 static void STATIC_PaintIconfn( HWND hwnd, HDC hdc, DWORD style );
  61 static void STATIC_PaintBitmapfn( HWND hwnd, HDC hdc, DWORD style );
  62 static void STATIC_PaintEnhMetafn( HWND hwnd, HDC hdc, DWORD style );
  63 static void STATIC_PaintEtchedfn( HWND hwnd, HDC hdc, DWORD style );
  64 static LRESULT WINAPI StaticWndProcA( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  65 static LRESULT WINAPI StaticWndProcW( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  66
  67 static COLORREF color_3dshadow, color_3ddkshadow, color_3dhighlight;
  68
  69 /* offsets for GetWindowLong for static private information */
  70 #define HFONT_GWL_OFFSET    0
  71 #define HICON_GWL_OFFSET    (sizeof(HFONT))
  72 #define STATIC_EXTRA_BYTES  (HICON_GWL_OFFSET + sizeof(HICON))
  73
  74 typedef void (*pfPaint)( HWND hwnd, HDC hdc, DWORD style );
  75
  76 static pfPaint staticPaintFunc[SS_TYPEMASK+1] =
  77 {
  78     STATIC_PaintTextfn,      /* SS_LEFT */
  79     STATIC_PaintTextfn,      /* SS_CENTER */
  80     STATIC_PaintTextfn,      /* SS_RIGHT */
  81     STATIC_PaintIconfn,      /* SS_ICON */
  82     STATIC_PaintRectfn,      /* SS_BLACKRECT */
  83     STATIC_PaintRectfn,      /* SS_GRAYRECT */
  84     STATIC_PaintRectfn,      /* SS_WHITERECT */
  85     STATIC_PaintRectfn,      /* SS_BLACKFRAME */
  86     STATIC_PaintRectfn,      /* SS_GRAYFRAME */
  87     STATIC_PaintRectfn,      /* SS_WHITEFRAME */
  88     NULL,                    /* SS_USERITEM */
  89     STATIC_PaintTextfn,      /* SS_SIMPLE */
  90     STATIC_PaintTextfn,      /* SS_LEFTNOWORDWRAP */
  91     STATIC_PaintOwnerDrawfn, /* SS_OWNERDRAW */
  92     STATIC_PaintBitmapfn,    /* SS_BITMAP */
  93     STATIC_PaintEnhMetafn,   /* SS_ENHMETAFILE */
  94     STATIC_PaintEtchedfn,    /* SS_ETCHEDHORZ */
  95     STATIC_PaintEtchedfn,    /* SS_ETCHEDVERT */
  96     STATIC_PaintEtchedfn,    /* SS_ETCHEDFRAME */
  97 };
  98
  99
 100 /*********************************************************************
 101  * static class descriptor
 102  */
 103 const struct builtin_class_descr STATIC_builtin_class =
 104 {
 105     "Static",            /* name */
 106     CS_DBLCLKS | CS_PARENTDC, /* style  */
 107     StaticWndProcA,      /* procA */
 108     StaticWndProcW,      /* procW */
 109     STATIC_EXTRA_BYTES,  /* extra */
 110     IDC_ARROW,           /* cursor */
 111     0                    /* brush */
 112 };
 113
 114
 115 /***********************************************************************
 116  *           STATIC_SetIcon
 117  *
 118  * Set the icon for an SS_ICON control.
 119  */
 120 static HICON STATIC_SetIcon( HWND hwnd, HICON hicon, DWORD style )
 121 {
 122     HICON prevIcon;
 123     CURSORICONINFO * info;
 124
 125     if ((style & SS_TYPEMASK) != SS_ICON) return 0;
 126     info = hicon?(CURSORICONINFO *) GlobalLock16(HICON_16(hicon)):NULL;
 127     if (hicon && !info) {
 128         WARN("hicon != 0, but info == 0\n");
 129         return 0;
 130     }
 131     prevIcon = (HICON)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hicon );
 132     if (hicon && !(style & SS_CENTERIMAGE) && !(style & SS_REALSIZECONTROL))
 133     {
 134         /* Windows currently doesn't implement SS_RIGHTJUST */
 135         /*
 136         if ((style & SS_RIGHTJUST) != 0)
 137         {
 138             RECT wr;
 139             GetWindowRect(hwnd, &wr);
 140             SetWindowPos( hwnd, 0, wr.right - info->nWidth, wr.bottom - info->nHeight,
 141                           info->nWidth, info->nHeight, SWP_NOACTIVATE | SWP_NOZORDER );
 142         }
 143         else */
 144         {
 145             SetWindowPos( hwnd, 0, 0, 0, info->nWidth, info->nHeight,
 146                           SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER );
 147         }
 148     }
 149     if (info) GlobalUnlock16(HICON_16(hicon));
 150     return prevIcon;
 151 }
 152
 153 /***********************************************************************
 154  *           STATIC_SetBitmap
 155  *
 156  * Set the bitmap for an SS_BITMAP control.
 157  */
 158 static HBITMAP STATIC_SetBitmap( HWND hwnd, HBITMAP hBitmap, DWORD style )
 159 {
 160     HBITMAP hOldBitmap;
 161
 162     if ((style & SS_TYPEMASK) != SS_BITMAP) return 0;
 163     if (hBitmap && GetObjectType(hBitmap) != OBJ_BITMAP) {
 164         WARN("hBitmap != 0, but it's not a bitmap\n");
 165         return 0;
 166     }
 167     hOldBitmap = (HBITMAP)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hBitmap );
 168     if (hBitmap && !(style & SS_CENTERIMAGE) && !(style & SS_REALSIZECONTROL))
 169     {
 170         BITMAP bm;
 171         GetObjectW(hBitmap, sizeof(bm), &bm);
 172         /* Windows currently doesn't implement SS_RIGHTJUST */
 173         /*
 174         if ((style & SS_RIGHTJUST) != 0)
 175         {
 176             RECT wr;
 177             GetWindowRect(hwnd, &wr);
 178             SetWindowPos( hwnd, 0, wr.right - bm.bmWidth, wr.bottom - bm.bmHeight,
 179                           bm.bmWidth, bm.bmHeight, SWP_NOACTIVATE | SWP_NOZORDER );
 180         }
 181         else */
 182         {
 183             SetWindowPos( hwnd, 0, 0, 0, bm.bmWidth, bm.bmHeight,
 184                           SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER );
 185         }
 186
 187     }
 188     return hOldBitmap;
 189 }
 190
 191 /***********************************************************************
 192  *           STATIC_SetEnhMetaFile
 193  *
 194  * Set the enhanced metafile for an SS_ENHMETAFILE control.
 195  */
 196 static HENHMETAFILE STATIC_SetEnhMetaFile( HWND hwnd, HENHMETAFILE hEnhMetaFile, DWORD style )
 197 {
 198     if ((style & SS_TYPEMASK) != SS_ENHMETAFILE) return 0;
 199     if (hEnhMetaFile && GetObjectType(hEnhMetaFile) != OBJ_ENHMETAFILE) {
 200         WARN("hEnhMetaFile != 0, but it's not an enhanced metafile\n");
 201         return 0;
 202     }
 203     return (HENHMETAFILE)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hEnhMetaFile );
 204 }
 205
 206 /***********************************************************************
 207  *           STATIC_GetImage
 208  *
 209  * Gets the bitmap for an SS_BITMAP control, the icon/cursor for an
 210  * SS_ICON control or the enhanced metafile for an SS_ENHMETAFILE control.
 211  */
 212 static HANDLE STATIC_GetImage( HWND hwnd, WPARAM wParam, DWORD style )
 213 {
 214     switch(style & SS_TYPEMASK)
 215     {
 216         case SS_ICON:
 217             if ((wParam != IMAGE_ICON) &&
 218                 (wParam != IMAGE_CURSOR)) return NULL;
 219             break;
 220         case SS_BITMAP:
 221             if (wParam != IMAGE_BITMAP) return NULL;
 222             break;
 223         case SS_ENHMETAFILE:
 224             if (wParam != IMAGE_ENHMETAFILE) return NULL;
 225             break;
 226         default:
 227             return NULL;
 228     }
 229     return (HANDLE)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET );
 230 }
 231
 232 /***********************************************************************
 233  *           STATIC_LoadIconA
 234  *
 235  * Load the icon for an SS_ICON control.
 236  */
 237 static HICON STATIC_LoadIconA( HWND hwnd, LPCSTR name, DWORD style )
 238 {
 239     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 240     if ((style & SS_REALSIZEIMAGE) != 0)
 241     {
 242         return LoadImageA(hInstance, name, IMAGE_ICON, 0, 0, LR_SHARED);
 243     }
 244     else
 245     {
 246         HICON hicon = LoadIconA( hInstance, name );
 247         if (!hicon) hicon = LoadCursorA( hInstance, name );
 248         if (!hicon) hicon = LoadIconA( 0, name );
 249         /* Windows doesn't try to load a standard cursor,
 250            probably because most IDs for standard cursors conflict
 251            with the IDs for standard icons anyway */
 252         return hicon;
 253     }
 254 }
 255
 256 /***********************************************************************
 257  *           STATIC_LoadIconW
 258  *
 259  * Load the icon for an SS_ICON control.
 260  */
 261 static HICON STATIC_LoadIconW( HWND hwnd, LPCWSTR name, DWORD style )
 262 {
 263     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 264     if ((style & SS_REALSIZEIMAGE) != 0)
 265     {
 266         return LoadImageW(hInstance, name, IMAGE_ICON, 0, 0, LR_SHARED);
 267     }
 268     else
 269     {
 270         HICON hicon = LoadIconW( hInstance, name );
 271         if (!hicon) hicon = LoadCursorW( hInstance, name );
 272         if (!hicon) hicon = LoadIconW( 0, name );
 273         /* Windows doesn't try to load a standard cursor,
 274            probably because most IDs for standard cursors conflict
 275            with the IDs for standard icons anyway */
 276         return hicon;
 277     }
 278 }
 279
 280 /***********************************************************************
 281  *           STATIC_LoadBitmapA
 282  *
 283  * Load the bitmap for an SS_BITMAP control.
 284  */
 285 static HBITMAP STATIC_LoadBitmapA( HWND hwnd, LPCSTR name )
 286 {
 287     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 288     /* Windows doesn't try to load OEM Bitmaps (hInstance == NULL) */
 289     return LoadBitmapA( hInstance, name );
 290 }
 291
 292 /***********************************************************************
 293  *           STATIC_LoadBitmapW
 294  *
 295  * Load the bitmap for an SS_BITMAP control.
 296  */
 297 static HBITMAP STATIC_LoadBitmapW( HWND hwnd, LPCWSTR name )
 298 {
 299     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 300     /* Windows doesn't try to load OEM Bitmaps (hInstance == NULL) */
 301     return LoadBitmapW( hInstance, name );
 302 }
 303
 304 /***********************************************************************
 305  *           STATIC_TryPaintFcn
 306  *
 307  * Try to immediately paint the control.
 308  */
 309 static VOID STATIC_TryPaintFcn(HWND hwnd, LONG full_style)
 310 {
 311     LONG style = full_style & SS_TYPEMASK;
 312     RECT rc;
 313
 314     GetClientRect( hwnd, &rc );
 315     if (!IsRectEmpty(&rc) && IsWindowVisible(hwnd) && staticPaintFunc[style])
 316     {
 317         HDC hdc;
 318         hdc = GetDC( hwnd );
 319         (staticPaintFunc[style])( hwnd, hdc, full_style );
 320         ReleaseDC( hwnd, hdc );
 321     }
 322 }
 323
 324 static HBRUSH STATIC_SendWmCtlColorStatic(HWND hwnd, HDC hdc)
 325 {
 326     HBRUSH hBrush = (HBRUSH) SendMessageW( GetParent(hwnd),
 327                     WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hwnd );
 328     if (!hBrush) /* did the app forget to call DefWindowProc ? */
 329     {
 330         /* FIXME: DefWindowProc should return different colors if a
 331                   manifest is present */
 332         hBrush = (HBRUSH)DefWindowProcW(GetParent(hwnd), WM_CTLCOLORSTATIC,
 333                                         (WPARAM)hdc, (LPARAM)hwnd);
 334     }
 335     return hBrush;
 336 }
 337
 338 static VOID STATIC_InitColours(void)
 339 {
 340     color_3ddkshadow  = GetSysColor(COLOR_3DDKSHADOW);
 341     color_3dshadow    = GetSysColor(COLOR_3DSHADOW);
 342     color_3dhighlight = GetSysColor(COLOR_3DHIGHLIGHT);
 343 }
 344
 345 /***********************************************************************
 346  *           hasTextStyle
 347  *
 348  * Tests if the control displays text.
 349  */
 350 static BOOL hasTextStyle( DWORD style )
 351 {
 352     switch(style & SS_TYPEMASK)
 353     {
 354         case SS_SIMPLE:
 355         case SS_LEFT:
 356         case SS_LEFTNOWORDWRAP:
 357         case SS_CENTER:
 358         case SS_RIGHT:
 359         case SS_OWNERDRAW:
 360             return TRUE;
 361     }
 362
 363     return FALSE;
 364 }
 365
 366 /***********************************************************************
 367  *           StaticWndProc_common
 368  */
 369 static LRESULT StaticWndProc_common( HWND hwnd, UINT uMsg, WPARAM wParam,
 370                                      LPARAM lParam, BOOL unicode )
 371 {
 372     LRESULT lResult = 0;
 373     LONG full_style = GetWindowLongW( hwnd, GWL_STYLE );
 374     LONG style = full_style & SS_TYPEMASK;
 375
 376     switch (uMsg)
 377     {
 378     case WM_CREATE:
 379         if (style < 0L || style > SS_TYPEMASK)
 380         {
 381             ERR("Unknown style 0x%02lx\n", style );
 382             return -1;
 383         }
 384         STATIC_InitColours();
 385         break;
 386
 387     case WM_NCDESTROY:
 388         if (style == SS_ICON) {
 389 /*
 390  * FIXME
 391  *           DestroyIcon32( STATIC_SetIcon( wndPtr, 0 ) );
 392  *
 393  * We don't want to do this yet because DestroyIcon32 is broken. If the icon
 394  * had already been loaded by the application the last thing we want to do is
 395  * GlobalFree16 the handle.
 396  */
 397             break;
 398         }
 399         else return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
 400                               DefWindowProcA(hwnd, uMsg, wParam, lParam);
 401
 402     case WM_PRINTCLIENT:
 403     case WM_PAINT:
 404         {
 405             PAINTSTRUCT ps;
 406             HDC hdc = wParam ? (HDC)wParam : BeginPaint(hwnd, &ps);
 407             if (staticPaintFunc[style])
 408                 (staticPaintFunc[style])( hwnd, hdc, full_style );
 409             if (!wParam) EndPaint(hwnd, &ps);
 410         }
 411         break;
 412
 413     case WM_ENABLE:
 414         STATIC_TryPaintFcn( hwnd, full_style );
 415         if (full_style & SS_NOTIFY) {
 416             if (wParam) {
 417                 SendMessageW( GetParent(hwnd), WM_COMMAND,
 418                               MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_ENABLE ), (LPARAM)hwnd);
 419             }
 420             else {
 421                 SendMessageW( GetParent(hwnd), WM_COMMAND,
 422                               MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DISABLE ), (LPARAM)hwnd);
 423             }
 424         }
 425         break;
 426
 427     case WM_SYSCOLORCHANGE:
 428         STATIC_InitColours();
 429         STATIC_TryPaintFcn( hwnd, full_style );
 430         break;
 431
 432     case WM_NCCREATE:
 433         {
 434             LPCSTR textA;
 435             LPCWSTR textW;
 436
 437             if (full_style & SS_SUNKEN)
 438                 SetWindowLongW( hwnd, GWL_EXSTYLE,
 439                                 GetWindowLongW( hwnd, GWL_EXSTYLE ) | WS_EX_STATICEDGE );
 440
 441             if(unicode)
 442             {
 443                 textA = NULL;
 444                 textW = ((LPCREATESTRUCTW)lParam)->lpszName;
 445             }
 446             else
 447             {
 448                 textA = ((LPCREATESTRUCTA)lParam)->lpszName;
 449                 textW = NULL;
 450             }
 451
 452             switch (style) {
 453             case SS_ICON:
 454                 {
 455                     HICON hIcon;
 456                     if(unicode)
 457                        hIcon = STATIC_LoadIconW(hwnd, textW, full_style);
 458                     else
 459                        hIcon = STATIC_LoadIconA(hwnd, textA, full_style);
 460                     STATIC_SetIcon(hwnd, hIcon, full_style);
 461                 }
 462                 break;
 463             case SS_BITMAP:
 464                 {
 465                     HBITMAP hBitmap;
 466                     if(unicode)
 467                         hBitmap = STATIC_LoadBitmapW(hwnd, textW);
 468                     else
 469                         hBitmap = STATIC_LoadBitmapA(hwnd, textA);
 470                     STATIC_SetBitmap(hwnd, hBitmap, full_style);
 471                 }
 472                 break;
 473             }
 474             /* SS_ENHMETAFILE: Despite what MSDN says, Windows does not load
 475                the enhanced metafile that was specified as the window text. */
 476         }
 477         return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
 478                          DefWindowProcA(hwnd, uMsg, wParam, lParam);
 479
 480     case WM_SETTEXT:
 481         if (hasTextStyle( full_style ))
 482         {
 483             if (HIWORD(lParam))
 484             {
 485                 if(unicode)
 486                      lResult = DefWindowProcW( hwnd, uMsg, wParam, lParam );
 487                 else
 488                     lResult = DefWindowProcA( hwnd, uMsg, wParam, lParam );
 489                 STATIC_TryPaintFcn( hwnd, full_style );
 490             }
 491         }
 492         break;
 493
 494     case WM_SETFONT:
 495         if (hasTextStyle( full_style ))
 496         {
 497             SetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET, wParam );
 498             if (LOWORD(lParam))
 499                 STATIC_TryPaintFcn( hwnd, full_style );
 500         }
 501         break;
 502
 503     case WM_GETFONT:
 504         return GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
 505
 506     case WM_NCHITTEST:
 507         if (full_style & SS_NOTIFY)
 508            return HTCLIENT;
 509         else
 510            return HTTRANSPARENT;
 511
 512     case WM_GETDLGCODE:
 513         return DLGC_STATIC;
 514
 515     case WM_LBUTTONDOWN:
 516     case WM_NCLBUTTONDOWN:
 517         if (full_style & SS_NOTIFY)
 518             SendMessageW( GetParent(hwnd), WM_COMMAND,
 519                           MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_CLICKED ), (LPARAM)hwnd);
 520         return 0;
 521
 522     case WM_LBUTTONDBLCLK:
 523     case WM_NCLBUTTONDBLCLK:
 524         if (full_style & SS_NOTIFY)
 525             SendMessageW( GetParent(hwnd), WM_COMMAND,
 526                           MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DBLCLK ), (LPARAM)hwnd);
 527         return 0;
 528
 529     case STM_GETIMAGE:
 530         return (LRESULT)STATIC_GetImage( hwnd, wParam, full_style );
 531
 532     case STM_GETICON16:
 533     case STM_GETICON:
 534         return (LRESULT)STATIC_GetImage( hwnd, IMAGE_ICON, full_style );
 535
 536     case STM_SETIMAGE:
 537         switch(wParam) {
 538         case IMAGE_BITMAP:
 539             lResult = (LRESULT)STATIC_SetBitmap( hwnd, (HBITMAP)lParam, full_style );
 540             break;
 541         case IMAGE_ENHMETAFILE:
 542             lResult = (LRESULT)STATIC_SetEnhMetaFile( hwnd, (HENHMETAFILE)lParam, full_style );
 543             break;
 544         case IMAGE_ICON:
 545         case IMAGE_CURSOR:
 546             lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)lParam, full_style );
 547             break;
 548         default:
 549             FIXME("STM_SETIMAGE: Unhandled type %x\n", wParam);
 550             break;
 551         }
 552         STATIC_TryPaintFcn( hwnd, full_style );
 553         break;
 554
 555     case STM_SETICON16:
 556     case STM_SETICON:
 557         lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)wParam, full_style );
 558         STATIC_TryPaintFcn( hwnd, full_style );
 559         break;
 560
 561     default:
 562         return unicode ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
 563                          DefWindowProcA(hwnd, uMsg, wParam, lParam);
 564     }
 565     return lResult;
 566 }
 567
 568 /***********************************************************************
 569  *           StaticWndProcA
 570  */
 571 static LRESULT WINAPI StaticWndProcA( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 572 {
 573     if (!IsWindow( hWnd )) return 0;
 574     return StaticWndProc_common(hWnd, uMsg, wParam, lParam, FALSE);
 575 }
 576
 577 /***********************************************************************
 578  *           StaticWndProcW
 579  */
 580 static LRESULT WINAPI StaticWndProcW( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 581 {
 582     if (!IsWindow( hWnd )) return 0;
 583     return StaticWndProc_common(hWnd, uMsg, wParam, lParam, TRUE);
 584 }
 585
 586 static void STATIC_PaintOwnerDrawfn( HWND hwnd, HDC hdc, DWORD style )
 587 {
 588   DRAWITEMSTRUCT dis;
 589   HFONT font, oldFont = NULL;
 590   UINT id = (UINT)GetWindowLongPtrW( hwnd, GWLP_ID );
 591
 592   dis.CtlType    = ODT_STATIC;
 593   dis.CtlID      = id;
 594   dis.itemID     = 0;
 595   dis.itemAction = ODA_DRAWENTIRE;
 596   dis.itemState  = IsWindowEnabled(hwnd) ? 0 : ODS_DISABLED;
 597   dis.hwndItem   = hwnd;
 598   dis.hDC        = hdc;
 599   dis.itemData   = 0;
 600   GetClientRect( hwnd, &dis.rcItem );
 601
 602   font = (HFONT)GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
 603   if (font) oldFont = SelectObject( hdc, font );
 604   SendMessageW( GetParent(hwnd), WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hwnd );
 605   SendMessageW( GetParent(hwnd), WM_DRAWITEM, id, (LPARAM)&dis );
 606   if (font) SelectObject( hdc, oldFont );
 607 }
 608
 609 static void STATIC_PaintTextfn( HWND hwnd, HDC hdc, DWORD style )
 610 {
 611     RECT rc;
 612     HBRUSH hBrush;
 613     HFONT hFont, hOldFont = NULL;
 614     WORD wFormat;
 615     INT len;
 616     WCHAR *text;
 617
 618     GetClientRect( hwnd, &rc);
 619
 620     switch (style & SS_TYPEMASK)
 621     {
 622     case SS_LEFT:
 623         wFormat = DT_LEFT | DT_EXPANDTABS | DT_WORDBREAK;
 624         break;
 625
 626     case SS_CENTER:
 627         wFormat = DT_CENTER | DT_EXPANDTABS | DT_WORDBREAK;
 628         break;
 629
 630     case SS_RIGHT:
 631         wFormat = DT_RIGHT | DT_EXPANDTABS | DT_WORDBREAK;
 632         break;
 633
 634     case SS_SIMPLE:
 635         wFormat = DT_LEFT | DT_SINGLELINE;
 636         break;
 637
 638     case SS_LEFTNOWORDWRAP:
 639         wFormat = DT_LEFT | DT_EXPANDTABS;
 640         break;
 641
 642     default:
 643         return;
 644     }
 645
 646     if (style & SS_NOPREFIX)
 647         wFormat |= DT_NOPREFIX;
 648
 649     if ((style & SS_TYPEMASK) != SS_SIMPLE)
 650     {
 651         if (style & SS_CENTERIMAGE)
 652             wFormat |= DT_SINGLELINE | DT_VCENTER;
 653         if (style & SS_EDITCONTROL)
 654             wFormat |= DT_EDITCONTROL;
 655         if (style & SS_ENDELLIPSIS)
 656             wFormat |= DT_SINGLELINE | DT_END_ELLIPSIS;
 657         if (style & SS_PATHELLIPSIS)
 658             wFormat |= DT_SINGLELINE | DT_PATH_ELLIPSIS;
 659         if (style & SS_WORDELLIPSIS)
 660             wFormat |= DT_SINGLELINE | DT_WORD_ELLIPSIS;
 661     }
 662
 663     if ((hFont = (HFONT)GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET )))
 664         hOldFont = (HFONT)SelectObject( hdc, hFont );
 665
 666     /* SS_SIMPLE controls: WM_CTLCOLORSTATIC is sent, but the returned
 667                            brush is not used */
 668     hBrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 669
 670     if ((style & SS_TYPEMASK) != SS_SIMPLE)
 671     {
 672         FillRect( hdc, &rc, hBrush );
 673         if (!IsWindowEnabled(hwnd)) SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
 674     }
 675
 676     if (!(len = SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 ))) return;
 677     if (!(text = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return;
 678     SendMessageW( hwnd, WM_GETTEXT, len + 1, (LPARAM)text );
 679
 680     if (((style & SS_TYPEMASK) == SS_SIMPLE) && (style & SS_NOPREFIX))
 681     {
 682         /* Windows uses the faster ExtTextOut() to draw the text and
 683            to paint the whole client rectangle with the text background
 684            color. Reference: "Static Controls" by Kyle Marsh, 1992 */
 685         ExtTextOutW( hdc, rc.left, rc.top, ETO_CLIPPED | ETO_OPAQUE,
 686                      &rc, text, len, NULL );
 687     }
 688     else
 689     {
 690         DrawTextW( hdc, text, -1, &rc, wFormat );
 691     }
 692
 693     HeapFree( GetProcessHeap(), 0, text );
 694
 695     if (hFont)
 696         SelectObject( hdc, hOldFont );
 697 }
 698
 699 static void STATIC_PaintRectfn( HWND hwnd, HDC hdc, DWORD style )
 700 {
 701     RECT rc;
 702     HBRUSH hBrush;
 703
 704     GetClientRect( hwnd, &rc);
 705
 706     switch (style & SS_TYPEMASK)
 707     {
 708     case SS_BLACKRECT:
 709         hBrush = CreateSolidBrush(color_3ddkshadow);
 710         FillRect( hdc, &rc, hBrush );
 711         break;
 712     case SS_GRAYRECT:
 713         hBrush = CreateSolidBrush(color_3dshadow);
 714         FillRect( hdc, &rc, hBrush );
 715         break;
 716     case SS_WHITERECT:
 717         hBrush = CreateSolidBrush(color_3dhighlight);
 718         FillRect( hdc, &rc, hBrush );
 719         break;
 720     case SS_BLACKFRAME:
 721         hBrush = CreateSolidBrush(color_3ddkshadow);
 722         FrameRect( hdc, &rc, hBrush );
 723         break;
 724     case SS_GRAYFRAME:
 725         hBrush = CreateSolidBrush(color_3dshadow);
 726         FrameRect( hdc, &rc, hBrush );
 727         break;
 728     case SS_WHITEFRAME:
 729         hBrush = CreateSolidBrush(color_3dhighlight);
 730         FrameRect( hdc, &rc, hBrush );
 731         break;
 732     default:
 733         return;
 734     }
 735     DeleteObject( hBrush );
 736 }
 737
 738
 739 static void STATIC_PaintIconfn( HWND hwnd, HDC hdc, DWORD style )
 740 {
 741     RECT rc, iconRect;
 742     HBRUSH hbrush;
 743     HICON hIcon;
 744     CURSORICONINFO * info;
 745
 746     GetClientRect( hwnd, &rc );
 747     hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 748     hIcon = (HICON)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET );
 749     info = hIcon ? (CURSORICONINFO *)GlobalLock16(HICON_16(hIcon)) : NULL;
 750     if (!hIcon || !info)
 751     {
 752         FillRect(hdc, &rc, hbrush);
 753     }
 754     else
 755     {
 756         if (style & SS_CENTERIMAGE)
 757         {
 758             iconRect.left = (rc.right - rc.left) / 2 - info->nWidth / 2;
 759             iconRect.top = (rc.bottom - rc.top) / 2 - info->nHeight / 2;
 760             iconRect.right = iconRect.left + info->nWidth;
 761             iconRect.bottom = iconRect.top + info->nHeight;
 762             FillRect( hdc, &rc, hbrush );
 763         }
 764         else
 765         {
 766             FillRect( hdc, &rc, hbrush );
 767             DrawIconEx( hdc, rc.left, rc.top, hIcon, rc.right - rc.left,
 768                         rc.bottom - rc.top, 0, NULL, DI_NORMAL );
 769         }
 770     }
 771     if (info) GlobalUnlock16(HICON_16(hIcon));
 772 }
 773
 774 static void STATIC_PaintBitmapfn(HWND hwnd, HDC hdc, DWORD style )
 775 {
 776     HDC hMemDC;
 777     HBITMAP hBitmap, oldbitmap;
 778     HBRUSH hbrush;
 779
 780     /* message is still sent, even if the returned brush is not used */
 781     hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 782
 783     if ((hBitmap = (HBITMAP)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET ))
 784          && (GetObjectType(hBitmap) == OBJ_BITMAP)
 785          && (hMemDC = CreateCompatibleDC( hdc )))
 786     {
 787         BITMAP bm;
 788         RECT rcClient;
 789         LOGBRUSH brush;
 790
 791         GetObjectW(hBitmap, sizeof(bm), &bm);
 792         oldbitmap = SelectObject(hMemDC, hBitmap);
 793
 794         /* Set the background color for monochrome bitmaps
 795            to the color of the background brush */
 796         if (GetObjectW( hbrush, sizeof(brush), &brush ))
 797         {
 798             if (brush.lbStyle == BS_SOLID)
 799                 SetBkColor(hdc, brush.lbColor);
 800         }
 801         GetClientRect(hwnd, &rcClient);
 802         if (style & SS_CENTERIMAGE)
 803         {
 804             INT x, y;
 805             x = (rcClient.right - rcClient.left)/2 - bm.bmWidth/2;
 806             y = (rcClient.bottom - rcClient.top)/2 - bm.bmHeight/2;
 807             FillRect( hdc, &rcClient, hbrush );
 808             BitBlt(hdc, x, y, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0,
 809                    SRCCOPY);
 810         }
 811         else
 812         {
 813             StretchBlt(hdc, 0, 0, rcClient.right - rcClient.left,
 814                        rcClient.bottom - rcClient.top, hMemDC,
 815                        0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
 816         }
 817         SelectObject(hMemDC, oldbitmap);
 818         DeleteDC(hMemDC);
 819     }
 820     else
 821     {
 822         RECT rcClient;
 823         GetClientRect( hwnd, &rcClient );
 824         FillRect( hdc, &rcClient, hbrush );
 825     }
 826 }
 827
 828
 829 static void STATIC_PaintEnhMetafn(HWND hwnd, HDC hdc, DWORD style )
 830 {
 831     HENHMETAFILE hEnhMetaFile;
 832     RECT rc;
 833     HBRUSH hbrush;
 834
 835     GetClientRect(hwnd, &rc);
 836     hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 837     FillRect(hdc, &rc, hbrush);
 838     if ((hEnhMetaFile = (HENHMETAFILE)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET )))
 839     {
 840         /* The control's current font is not selected into the
 841            device context! */
 842         if (GetObjectType(hEnhMetaFile) == OBJ_ENHMETAFILE)
 843             PlayEnhMetaFile(hdc, hEnhMetaFile, &rc);
 844     }
 845 }
 846
 847
 848 static void STATIC_PaintEtchedfn( HWND hwnd, HDC hdc, DWORD style )
 849 {
 850     RECT rc;
 851
 852     GetClientRect( hwnd, &rc );
 853     switch (style & SS_TYPEMASK)
 854     {
 855         case SS_ETCHEDHORZ:
 856             DrawEdge(hdc,&rc,EDGE_ETCHED,BF_TOP|BF_BOTTOM);
 857             break;
 858         case SS_ETCHEDVERT:
 859             DrawEdge(hdc,&rc,EDGE_ETCHED,BF_LEFT|BF_RIGHT);
 860             break;
 861         case SS_ETCHEDFRAME:
 862             DrawEdge (hdc, &rc, EDGE_ETCHED, BF_RECT);
 863             break;
 864     }
 865 }