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