user: Added helper functions for A<->W conversion of single characters.
[wine] / 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 }