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