[USER32] Use the correct __REACTOS__ define.
[reactos.git] / win32ss / user / user32 / controls / button.c
1 /* File: button.c -- Button type widgets
2 *
3 * Copyright (C) 1993 Johannes Ruscheinski
4 * Copyright (C) 1993 David Metcalfe
5 * Copyright (C) 1994 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES
22 *
23 * This code was audited for completeness against the documented features
24 * of Comctl32.dll version 6.0 on Oct. 3, 2004, by Dimitrie O. Paun.
25 *
26 * Unless otherwise noted, we believe this code to be complete, as per
27 * the specification mentioned above.
28 * If you discover missing features, or bugs, please note them below.
29 *
30 * TODO
31 * Styles
32 * - BS_NOTIFY: is it complete?
33 * - BS_RIGHTBUTTON: same as BS_LEFTTEXT
34 *
35 * Messages
36 * - WM_CHAR: Checks a (manual or automatic) check box on '+' or '=', clears it on '-' key.
37 * - WM_SETFOCUS: For (manual or automatic) radio buttons, send the parent window BN_CLICKED
38 * - WM_NCCREATE: Turns any BS_OWNERDRAW button into a BS_PUSHBUTTON button.
39 * - WM_SYSKEYUP
40 * - BCM_GETIDEALSIZE
41 * - BCM_GETIMAGELIST
42 * - BCM_GETTEXTMARGIN
43 * - BCM_SETIMAGELIST
44 * - BCM_SETTEXTMARGIN
45 *
46 * Notifications
47 * - BCN_HOTITEMCHANGE
48 * - BN_DISABLE
49 * - BN_PUSHED/BN_HILITE
50 * + BN_KILLFOCUS: is it OK?
51 * - BN_PAINT
52 * + BN_SETFOCUS: is it OK?
53 * - BN_UNPUSHED/BN_UNHILITE
54 * - NM_CUSTOMDRAW
55 *
56 * Structures/Macros/Definitions
57 * - BUTTON_IMAGELIST
58 * - NMBCHOTITEM
59 * - Button_GetIdealSize
60 * - Button_GetImageList
61 * - Button_GetTextMargin
62 * - Button_SetImageList
63 * - Button_SetTextMargin
64 */
65
66 #include <user32.h>
67
68 WINE_DEFAULT_DEBUG_CHANNEL(button);
69
70 /* GetWindowLong offsets for window extra information */
71 #define STATE_GWL_OFFSET 0
72 #define BUTTON_HFONT_GWL_OFFSET (sizeof(LONG))
73 #define HIMAGE_GWL_OFFSET (BUTTON_HFONT_GWL_OFFSET+sizeof(HFONT))
74 #define BUTTON_UISTATE_GWL_OFFSET (HIMAGE_GWL_OFFSET+sizeof(HFONT))
75 #define NB_EXTRA_BYTES (BUTTON_UISTATE_GWL_OFFSET+sizeof(LONG))
76
77 /* undocumented flags */
78 #define BUTTON_NSTATES 0x0F
79 #define BUTTON_BTNPRESSED 0x40
80 #define BUTTON_UNKNOWN2 0x20
81 #define BUTTON_UNKNOWN3 0x10
82 #ifdef __REACTOS__
83 #define BUTTON_BMCLICK 0x100 // ReactOS Need to up to wine!
84 #endif
85
86 #define BUTTON_NOTIFY_PARENT(hWnd, code) \
87 do { /* Notify parent which has created this button control */ \
88 TRACE("notification " #code " sent to hwnd=%p\n", GetParent(hWnd)); \
89 SendMessageW(GetParent(hWnd), WM_COMMAND, \
90 MAKEWPARAM(GetWindowLongPtrW((hWnd),GWLP_ID), (code)), \
91 (LPARAM)(hWnd)); \
92 } while(0)
93
94 static UINT BUTTON_CalcLabelRect( HWND hwnd, HDC hdc, RECT *rc );
95 static void PB_Paint( HWND hwnd, HDC hDC, UINT action );
96 static void CB_Paint( HWND hwnd, HDC hDC, UINT action );
97 static void GB_Paint( HWND hwnd, HDC hDC, UINT action );
98 static void UB_Paint( HWND hwnd, HDC hDC, UINT action );
99 static void OB_Paint( HWND hwnd, HDC hDC, UINT action );
100 static void BUTTON_CheckAutoRadioButton( HWND hwnd );
101
102 #define MAX_BTN_TYPE 16
103
104 static const WORD maxCheckState[MAX_BTN_TYPE] =
105 {
106 BST_UNCHECKED, /* BS_PUSHBUTTON */
107 BST_UNCHECKED, /* BS_DEFPUSHBUTTON */
108 BST_CHECKED, /* BS_CHECKBOX */
109 BST_CHECKED, /* BS_AUTOCHECKBOX */
110 BST_CHECKED, /* BS_RADIOBUTTON */
111 BST_INDETERMINATE, /* BS_3STATE */
112 BST_INDETERMINATE, /* BS_AUTO3STATE */
113 BST_UNCHECKED, /* BS_GROUPBOX */
114 BST_UNCHECKED, /* BS_USERBUTTON */
115 BST_CHECKED, /* BS_AUTORADIOBUTTON */
116 BST_UNCHECKED, /* BS_PUSHBOX */
117 BST_UNCHECKED /* BS_OWNERDRAW */
118 };
119
120 typedef void (*pfButtonPaint)( HWND hwnd, HDC hdc, UINT action );
121
122 static const pfButtonPaint btnPaintFunc[MAX_BTN_TYPE] =
123 {
124 PB_Paint, /* BS_PUSHBUTTON */
125 PB_Paint, /* BS_DEFPUSHBUTTON */
126 CB_Paint, /* BS_CHECKBOX */
127 CB_Paint, /* BS_AUTOCHECKBOX */
128 CB_Paint, /* BS_RADIOBUTTON */
129 CB_Paint, /* BS_3STATE */
130 CB_Paint, /* BS_AUTO3STATE */
131 GB_Paint, /* BS_GROUPBOX */
132 UB_Paint, /* BS_USERBUTTON */
133 CB_Paint, /* BS_AUTORADIOBUTTON */
134 NULL, /* BS_PUSHBOX */
135 OB_Paint /* BS_OWNERDRAW */
136 };
137
138 /*********************************************************************
139 * button class descriptor
140 */
141 static const WCHAR buttonW[] = {'B','u','t','t','o','n',0};
142 const struct builtin_class_descr BUTTON_builtin_class =
143 {
144 buttonW, /* name */
145 CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, /* style */
146 #ifdef __REACTOS__
147 ButtonWndProcA, /* procA */
148 ButtonWndProcW, /* procW */
149 #else
150 WINPROC_BUTTON, /* proc */
151 #endif
152 NB_EXTRA_BYTES, /* extra */
153 IDC_ARROW, /* cursor */
154 0 /* brush */
155 };
156
157
158 static inline LONG get_button_state( HWND hwnd )
159 {
160 return GetWindowLongPtrW( hwnd, STATE_GWL_OFFSET );
161 }
162
163 static inline void set_button_state( HWND hwnd, LONG state )
164 {
165 SetWindowLongPtrW( hwnd, STATE_GWL_OFFSET, state );
166 }
167
168 #ifdef __REACTOS__
169
170 static __inline void set_ui_state( HWND hwnd, LONG flags )
171 {
172 SetWindowLongPtrW( hwnd, BUTTON_UISTATE_GWL_OFFSET, flags );
173 }
174
175 static __inline LONG get_ui_state( HWND hwnd )
176 {
177 return GetWindowLongPtrW( hwnd, BUTTON_UISTATE_GWL_OFFSET );
178 }
179
180 #endif /* __REACTOS__ */
181
182 static inline HFONT get_button_font( HWND hwnd )
183 {
184 return (HFONT)GetWindowLongPtrW( hwnd, BUTTON_HFONT_GWL_OFFSET );
185 }
186
187 static inline void set_button_font( HWND hwnd, HFONT font )
188 {
189 SetWindowLongPtrW( hwnd, BUTTON_HFONT_GWL_OFFSET, (LONG_PTR)font );
190 }
191
192 static inline UINT get_button_type( LONG window_style )
193 {
194 return (window_style & BS_TYPEMASK);
195 }
196
197 /* paint a button of any type */
198 static inline void paint_button( HWND hwnd, LONG style, UINT action )
199 {
200 if (btnPaintFunc[style] && IsWindowVisible(hwnd))
201 {
202 HDC hdc = GetDC( hwnd );
203 btnPaintFunc[style]( hwnd, hdc, action );
204 ReleaseDC( hwnd, hdc );
205 }
206 }
207
208 /* retrieve the button text; returned buffer must be freed by caller */
209 static inline WCHAR *get_button_text( HWND hwnd )
210 {
211 INT len = 512;
212 WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
213 if (buffer) InternalGetWindowText( hwnd, buffer, len + 1 );
214 return buffer;
215 }
216
217 #ifdef __REACTOS__
218 /* Retrieve the UI state for the control */
219 static BOOL button_update_uistate(HWND hwnd, BOOL unicode)
220 {
221 LONG flags, prevflags;
222
223 if (unicode)
224 flags = DefWindowProcW(hwnd, WM_QUERYUISTATE, 0, 0);
225 else
226 flags = DefWindowProcA(hwnd, WM_QUERYUISTATE, 0, 0);
227
228 prevflags = get_ui_state(hwnd);
229
230 if (prevflags != flags)
231 {
232 set_ui_state(hwnd, flags);
233 return TRUE;
234 }
235
236 return FALSE;
237 }
238 #endif
239
240 /***********************************************************************
241 * ButtonWndProc_common
242 */
243 LRESULT WINAPI ButtonWndProc_common(HWND hWnd, UINT uMsg,
244 WPARAM wParam, LPARAM lParam, BOOL unicode )
245 {
246 RECT rect;
247 POINT pt;
248 LONG style = GetWindowLongPtrW( hWnd, GWL_STYLE );
249 UINT btn_type = get_button_type( style );
250 LONG state;
251 HANDLE oldHbitmap;
252 #ifdef __REACTOS__
253 PWND pWnd;
254
255 pWnd = ValidateHwnd(hWnd);
256 if (pWnd)
257 {
258 if (!pWnd->fnid)
259 {
260 NtUserSetWindowFNID(hWnd, FNID_BUTTON);
261 }
262 else
263 {
264 if (pWnd->fnid != FNID_BUTTON)
265 {
266 ERR("Wrong window class for Button! fnId 0x%x\n",pWnd->fnid);
267 return 0;
268 }
269 }
270 }
271 else
272 return 0;
273 #else
274 if (!IsWindow( hWnd )) return 0;
275 #endif
276
277 pt.x = (short)LOWORD(lParam);
278 pt.y = (short)HIWORD(lParam);
279
280 switch (uMsg)
281 {
282 case WM_GETDLGCODE:
283 switch(btn_type)
284 {
285 case BS_USERBUTTON:
286 case BS_PUSHBUTTON: return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON;
287 case BS_DEFPUSHBUTTON: return DLGC_BUTTON | DLGC_DEFPUSHBUTTON;
288 case BS_RADIOBUTTON:
289 case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON;
290 case BS_GROUPBOX: return DLGC_STATIC;
291 default: return DLGC_BUTTON;
292 }
293
294 case WM_ENABLE:
295 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
296 break;
297
298 case WM_CREATE:
299 if (btn_type >= MAX_BTN_TYPE)
300 return -1; /* abort */
301
302 /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
303 if (btn_type == BS_USERBUTTON )
304 {
305 style = (style & ~BS_TYPEMASK) | BS_PUSHBUTTON;
306 #ifdef __REACTOS__
307 NtUserAlterWindowStyle(hWnd, GWL_STYLE, style );
308 #else
309 WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
310 #endif
311 }
312 set_button_state( hWnd, BST_UNCHECKED );
313 #ifdef __REACTOS__
314 button_update_uistate( hWnd, unicode );
315 #endif
316 return 0;
317
318 #ifdef __REACTOS__
319 case WM_NCDESTROY:
320 NtUserSetWindowFNID(hWnd, FNID_DESTROY);
321 case WM_DESTROY:
322 break;
323 #endif
324
325 case WM_ERASEBKGND:
326 if (btn_type == BS_OWNERDRAW)
327 {
328 HDC hdc = (HDC)wParam;
329 RECT rc;
330 HBRUSH hBrush;
331 HWND parent = GetParent(hWnd);
332 if (!parent) parent = hWnd;
333 #ifdef __REACTOS__
334 hBrush = GetControlColor( parent, hWnd, hdc, WM_CTLCOLORBTN);
335 #else
336 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
337 if (!hBrush) /* did the app forget to call defwindowproc ? */
338 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
339 (WPARAM)hdc, (LPARAM)hWnd);
340 #endif
341 GetClientRect(hWnd, &rc);
342 FillRect(hdc, &rc, hBrush);
343 }
344 return 1;
345
346 case WM_PRINTCLIENT:
347 case WM_PAINT:
348 {
349 PAINTSTRUCT ps;
350 HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
351 if (btnPaintFunc[btn_type])
352 {
353 int nOldMode = SetBkMode( hdc, OPAQUE );
354 (btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE );
355 SetBkMode(hdc, nOldMode); /* reset painting mode */
356 }
357 if ( !wParam ) EndPaint( hWnd, &ps );
358 break;
359 }
360
361 case WM_KEYDOWN:
362 if (wParam == VK_SPACE)
363 {
364 SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
365 set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
366 SetCapture( hWnd );
367 }
368 break;
369
370 case WM_LBUTTONDBLCLK:
371 if(style & BS_NOTIFY ||
372 btn_type == BS_RADIOBUTTON ||
373 btn_type == BS_USERBUTTON ||
374 btn_type == BS_OWNERDRAW)
375 {
376 BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED);
377 break;
378 }
379 /* fall through */
380 case WM_LBUTTONDOWN:
381 SetCapture( hWnd );
382 SetFocus( hWnd );
383 set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
384 SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
385 break;
386
387 case WM_KEYUP:
388 if (wParam != VK_SPACE)
389 break;
390 /* fall through */
391 case WM_LBUTTONUP:
392 #ifdef __REACTOS__
393 BOOL TellParent = FALSE; //// ReactOS see note below.
394 #endif
395 state = get_button_state( hWnd );
396 if (!(state & BUTTON_BTNPRESSED)) break;
397 state &= BUTTON_NSTATES;
398 set_button_state( hWnd, state );
399 if (!(state & BST_PUSHED))
400 {
401 ReleaseCapture();
402 break;
403 }
404 SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
405 GetClientRect( hWnd, &rect );
406 if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
407 {
408 state = get_button_state( hWnd );
409 switch(btn_type)
410 {
411 case BS_AUTOCHECKBOX:
412 SendMessageW( hWnd, BM_SETCHECK, !(state & BST_CHECKED), 0 );
413 break;
414 case BS_AUTORADIOBUTTON:
415 BUTTON_CheckAutoRadioButton( hWnd );
416 break;
417 case BS_AUTO3STATE:
418 SendMessageW( hWnd, BM_SETCHECK,
419 (state & BST_INDETERMINATE) ? 0 : ((state & 3) + 1), 0 );
420 break;
421 }
422 #ifdef __REACTOS__
423 TellParent = TRUE; // <---- Fix CORE-10194, Notify parent after capture is released.
424 #else
425 ReleaseCapture();
426 BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
427 #endif
428 }
429 #ifdef __REACTOS__
430 ReleaseCapture();
431 if (TellParent) BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
432 #else
433 else
434 {
435 ReleaseCapture();
436 }
437 #endif
438 break;
439
440 case WM_CAPTURECHANGED:
441 TRACE("WM_CAPTURECHANGED %p\n", hWnd);
442 if (hWnd == (HWND)lParam) break;
443 state = get_button_state( hWnd );
444 if (state & BUTTON_BTNPRESSED)
445 {
446 state &= BUTTON_NSTATES;
447 set_button_state( hWnd, state );
448 if (state & BST_PUSHED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
449 }
450 break;
451
452 case WM_MOUSEMOVE:
453 if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
454 {
455 GetClientRect( hWnd, &rect );
456 SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 );
457 }
458 break;
459
460 case WM_SETTEXT:
461 {
462 /* Clear an old text here as Windows does */
463 //
464 // ReactOS Note :
465 // wine Bug: http://bugs.winehq.org/show_bug.cgi?id=25790
466 // Patch: http://source.winehq.org/patches/data/70889
467 // By: Alexander LAW, Replicate Windows behavior of WM_SETTEXT handler regarding WM_CTLCOLOR*
468 //
469 #ifdef __REACTOS__
470 if (style & WS_VISIBLE)
471 #else
472 if (IsWindowVisible(hWnd))
473 #endif
474 {
475 HDC hdc = GetDC(hWnd);
476 HBRUSH hbrush;
477 RECT client, rc;
478 HWND parent = GetParent(hWnd);
479 UINT message = (btn_type == BS_PUSHBUTTON ||
480 btn_type == BS_DEFPUSHBUTTON ||
481 btn_type == BS_PUSHLIKE ||
482 btn_type == BS_USERBUTTON ||
483 btn_type == BS_OWNERDRAW) ?
484 WM_CTLCOLORBTN : WM_CTLCOLORSTATIC;
485
486 if (!parent) parent = hWnd;
487 #ifdef __REACTOS__
488 hbrush = GetControlColor(parent, hWnd, hdc, message);
489 #else
490 hbrush = (HBRUSH)SendMessageW(parent, message,
491 (WPARAM)hdc, (LPARAM)hWnd);
492 if (!hbrush) /* did the app forget to call DefWindowProc ? */
493 hbrush = (HBRUSH)DefWindowProcW(parent, message,
494 (WPARAM)hdc, (LPARAM)hWnd);
495 #endif
496
497 GetClientRect(hWnd, &client);
498 rc = client;
499 /* FIXME: check other BS_* handlers */
500 if (btn_type == BS_GROUPBOX)
501 InflateRect(&rc, -7, 1); /* GB_Paint does this */
502 BUTTON_CalcLabelRect(hWnd, hdc, &rc);
503 /* Clip by client rect bounds */
504 if (rc.right > client.right) rc.right = client.right;
505 if (rc.bottom > client.bottom) rc.bottom = client.bottom;
506 FillRect(hdc, &rc, hbrush);
507 ReleaseDC(hWnd, hdc);
508 }
509
510 if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam );
511 else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam );
512 if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
513 InvalidateRect( hWnd, NULL, TRUE );
514 else
515 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
516 return 1; /* success. FIXME: check text length */
517 }
518
519 case WM_SETFONT:
520 set_button_font( hWnd, (HFONT)wParam );
521 if (lParam) InvalidateRect(hWnd, NULL, TRUE);
522 break;
523
524 case WM_GETFONT:
525 return (LRESULT)get_button_font( hWnd );
526
527 case WM_SETFOCUS:
528 TRACE("WM_SETFOCUS %p\n",hWnd);
529 set_button_state( hWnd, get_button_state(hWnd) | BST_FOCUS );
530 paint_button( hWnd, btn_type, ODA_FOCUS );
531 if (style & BS_NOTIFY)
532 BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS);
533 break;
534
535 case WM_KILLFOCUS:
536 TRACE("WM_KILLFOCUS %p\n",hWnd);
537 state = get_button_state( hWnd );
538 set_button_state( hWnd, state & ~BST_FOCUS );
539 paint_button( hWnd, btn_type, ODA_FOCUS );
540
541 if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
542 ReleaseCapture();
543 if (style & BS_NOTIFY)
544 BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS);
545
546 InvalidateRect( hWnd, NULL, FALSE );
547 break;
548
549 case WM_SYSCOLORCHANGE:
550 InvalidateRect( hWnd, NULL, FALSE );
551 break;
552
553 case BM_SETSTYLE:
554 btn_type = wParam & BS_TYPEMASK;
555 style = (style & ~BS_TYPEMASK) | btn_type;
556 #ifdef __REACTOS__
557 NtUserAlterWindowStyle(hWnd, GWL_STYLE, style);
558 #else
559 WIN_SetStyle( hWnd, style, BS_TYPEMASK & ~style );
560 #endif
561
562 /* Only redraw if lParam flag is set.*/
563 if (lParam)
564 InvalidateRect( hWnd, NULL, TRUE );
565
566 break;
567
568 case BM_CLICK:
569 #ifdef __REACTOS__
570 state = get_button_state(hWnd);
571 if (state & BUTTON_BMCLICK)
572 break;
573 set_button_state(hWnd, state | BUTTON_BMCLICK); // Tracked in STATE_GWL_OFFSET.
574 #endif
575 SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
576 SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
577 #ifdef __REACTOS__
578 state = get_button_state(hWnd);
579 if (!(state & BUTTON_BMCLICK)) break;
580 state &= ~BUTTON_BMCLICK;
581 set_button_state(hWnd, state);
582 #endif
583 break;
584
585 case BM_SETIMAGE:
586 /* Check that image format matches button style */
587 switch (style & (BS_BITMAP|BS_ICON))
588 {
589 case BS_BITMAP:
590 if (wParam != IMAGE_BITMAP) return 0;
591 break;
592 case BS_ICON:
593 if (wParam != IMAGE_ICON) return 0;
594 break;
595 default:
596 return 0;
597 }
598 oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam );
599 InvalidateRect( hWnd, NULL, FALSE );
600 return (LRESULT)oldHbitmap;
601
602 case BM_GETIMAGE:
603 return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET );
604
605 case BM_GETCHECK:
606 return get_button_state( hWnd ) & 3;
607
608 case BM_SETCHECK:
609 if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
610 state = get_button_state( hWnd );
611 if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
612 {
613 #ifdef __REACTOS__
614 if (wParam) style |= WS_TABSTOP;
615 else style &= ~WS_TABSTOP;
616 NtUserAlterWindowStyle(hWnd, GWL_STYLE, style);
617 #else
618 if (wParam) WIN_SetStyle( hWnd, WS_TABSTOP, 0 );
619 else WIN_SetStyle( hWnd, 0, WS_TABSTOP );
620 #endif
621 }
622 if ((state & 3) != wParam)
623 {
624 set_button_state( hWnd, (state & ~3) | wParam );
625 paint_button( hWnd, btn_type, ODA_SELECT );
626 }
627 break;
628
629 case BM_GETSTATE:
630 return get_button_state( hWnd );
631
632 case BM_SETSTATE:
633 state = get_button_state( hWnd );
634 if (wParam)
635 set_button_state( hWnd, state | BST_PUSHED );
636 else
637 set_button_state( hWnd, state & ~BST_PUSHED );
638
639 paint_button( hWnd, btn_type, ODA_SELECT );
640 break;
641
642 #ifdef __REACTOS__
643 case WM_UPDATEUISTATE:
644 if (unicode)
645 DefWindowProcW(hWnd, uMsg, wParam, lParam);
646 else
647 DefWindowProcA(hWnd, uMsg, wParam, lParam);
648
649 if (button_update_uistate(hWnd, unicode))
650 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
651 break;
652 #endif
653
654 case WM_NCHITTEST:
655 if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
656 /* fall through */
657 default:
658 return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) :
659 DefWindowProcA(hWnd, uMsg, wParam, lParam);
660 }
661 return 0;
662 }
663
664 #ifdef __REACTOS__
665
666 /***********************************************************************
667 * ButtonWndProcW
668 * The button window procedure. This is just a wrapper which locks
669 * the passed HWND and calls the real window procedure (with a WND*
670 * pointer pointing to the locked windowstructure).
671 */
672 LRESULT WINAPI ButtonWndProcW(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
673 {
674 if (!IsWindow(hWnd)) return 0;
675 return ButtonWndProc_common(hWnd, uMsg, wParam, lParam, TRUE);
676 }
677
678 /***********************************************************************
679 * ButtonWndProcA
680 */
681 LRESULT WINAPI ButtonWndProcA(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
682 {
683 if (!IsWindow(hWnd)) return 0;
684 return ButtonWndProc_common(hWnd, uMsg, wParam, lParam, FALSE);
685 }
686
687 #endif /* __REACTOS__ */
688
689 /**********************************************************************
690 * Convert button styles to flags used by DrawText.
691 */
692 static UINT BUTTON_BStoDT( DWORD style, DWORD ex_style )
693 {
694 UINT dtStyle = DT_NOCLIP; /* We use SelectClipRgn to limit output */
695
696 /* "Convert" pushlike buttons to pushbuttons */
697 if (style & BS_PUSHLIKE)
698 style &= ~BS_TYPEMASK;
699
700 if (!(style & BS_MULTILINE))
701 dtStyle |= DT_SINGLELINE;
702 else
703 dtStyle |= DT_WORDBREAK;
704
705 switch (style & BS_CENTER)
706 {
707 case BS_LEFT: /* DT_LEFT is 0 */ break;
708 case BS_RIGHT: dtStyle |= DT_RIGHT; break;
709 case BS_CENTER: dtStyle |= DT_CENTER; break;
710 default:
711 /* Pushbutton's text is centered by default */
712 if (get_button_type(style) <= BS_DEFPUSHBUTTON) dtStyle |= DT_CENTER;
713 /* all other flavours have left aligned text */
714 }
715
716 if (ex_style & WS_EX_RIGHT) dtStyle = DT_RIGHT | (dtStyle & ~(DT_LEFT | DT_CENTER));
717
718 /* DrawText ignores vertical alignment for multiline text,
719 * but we use these flags to align label manually.
720 */
721 if (get_button_type(style) != BS_GROUPBOX)
722 {
723 switch (style & BS_VCENTER)
724 {
725 case BS_TOP: /* DT_TOP is 0 */ break;
726 case BS_BOTTOM: dtStyle |= DT_BOTTOM; break;
727 case BS_VCENTER: /* fall through */
728 default: dtStyle |= DT_VCENTER; break;
729 }
730 }
731 else
732 /* GroupBox's text is always single line and is top aligned. */
733 dtStyle |= DT_SINGLELINE;
734
735 return dtStyle;
736 }
737
738 /**********************************************************************
739 * BUTTON_CalcLabelRect
740 *
741 * Calculates label's rectangle depending on button style.
742 *
743 * Returns flags to be passed to DrawText.
744 * Calculated rectangle doesn't take into account button state
745 * (pushed, etc.). If there is nothing to draw (no text/image) output
746 * rectangle is empty, and return value is (UINT)-1.
747 */
748 static UINT BUTTON_CalcLabelRect(HWND hwnd, HDC hdc, RECT *rc)
749 {
750 LONG style = GetWindowLongPtrW( hwnd, GWL_STYLE );
751 LONG ex_style = GetWindowLongPtrW( hwnd, GWL_EXSTYLE );
752 WCHAR *text;
753 ICONINFO iconInfo;
754 BITMAP bm;
755 UINT dtStyle = BUTTON_BStoDT( style, ex_style );
756 RECT r = *rc;
757 INT n;
758
759 /* Calculate label rectangle according to label type */
760 switch (style & (BS_ICON|BS_BITMAP))
761 {
762 case BS_TEXT:
763 {
764 HFONT hFont, hPrevFont = 0;
765
766 if (!(text = get_button_text( hwnd ))) goto empty_rect;
767 if (!text[0])
768 {
769 HeapFree( GetProcessHeap(), 0, text );
770 goto empty_rect;
771 }
772
773 if ((hFont = get_button_font( hwnd ))) hPrevFont = SelectObject( hdc, hFont );
774 DrawTextW(hdc, text, -1, &r, dtStyle | DT_CALCRECT);
775 if (hPrevFont) SelectObject( hdc, hPrevFont );
776 HeapFree( GetProcessHeap(), 0, text );
777 #ifdef __REACTOS__
778 if (get_ui_state(hwnd) & UISF_HIDEACCEL)
779 dtStyle |= DT_HIDEPREFIX;
780 #endif
781 break;
782 }
783
784 case BS_ICON:
785 if (!GetIconInfo((HICON)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), &iconInfo))
786 goto empty_rect;
787
788 GetObjectW (iconInfo.hbmColor, sizeof(BITMAP), &bm);
789
790 r.right = r.left + bm.bmWidth;
791 r.bottom = r.top + bm.bmHeight;
792
793 DeleteObject(iconInfo.hbmColor);
794 DeleteObject(iconInfo.hbmMask);
795 break;
796
797 case BS_BITMAP:
798 if (!GetObjectW( (HANDLE)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), sizeof(BITMAP), &bm))
799 goto empty_rect;
800
801 r.right = r.left + bm.bmWidth;
802 r.bottom = r.top + bm.bmHeight;
803 break;
804
805 default:
806 empty_rect:
807 rc->right = r.left;
808 rc->bottom = r.top;
809 return (UINT)-1;
810 }
811
812 /* Position label inside bounding rectangle according to
813 * alignment flags. (calculated rect is always left-top aligned).
814 * If label is aligned to any side - shift label in opposite
815 * direction to leave extra space for focus rectangle.
816 */
817 switch (dtStyle & (DT_CENTER|DT_RIGHT))
818 {
819 case DT_LEFT: r.left++; r.right++; break;
820 case DT_CENTER: n = r.right - r.left;
821 r.left = rc->left + ((rc->right - rc->left) - n) / 2;
822 r.right = r.left + n; break;
823 case DT_RIGHT: n = r.right - r.left;
824 r.right = rc->right - 1;
825 r.left = r.right - n;
826 break;
827 }
828
829 switch (dtStyle & (DT_VCENTER|DT_BOTTOM))
830 {
831 case DT_TOP: r.top++; r.bottom++; break;
832 case DT_VCENTER: n = r.bottom - r.top;
833 #ifdef __REACTOS__
834 r.top = rc->top + ((rc->bottom - 1 - rc->top) - n) / 2;
835 #else
836 r.top = rc->top + ((rc->bottom - rc->top) - n) / 2;
837 #endif
838 r.bottom = r.top + n; break;
839 case DT_BOTTOM: n = r.bottom - r.top;
840 r.bottom = rc->bottom - 1;
841 r.top = r.bottom - n;
842 break;
843 }
844
845 *rc = r;
846 return dtStyle;
847 }
848
849
850 /**********************************************************************
851 * BUTTON_DrawTextCallback
852 *
853 * Callback function used by DrawStateW function.
854 */
855 static BOOL CALLBACK BUTTON_DrawTextCallback(HDC hdc, LPARAM lp, WPARAM wp, int cx, int cy)
856 {
857 RECT rc;
858
859 SetRect(&rc, 0, 0, cx, cy);
860 DrawTextW(hdc, (LPCWSTR)lp, -1, &rc, (UINT)wp);
861 return TRUE;
862 }
863
864
865 /**********************************************************************
866 * BUTTON_DrawLabel
867 *
868 * Common function for drawing button label.
869 */
870 static void BUTTON_DrawLabel(HWND hwnd, HDC hdc, UINT dtFlags, const RECT *rc)
871 {
872 DRAWSTATEPROC lpOutputProc = NULL;
873 LPARAM lp;
874 WPARAM wp = 0;
875 HBRUSH hbr = 0;
876 UINT flags = IsWindowEnabled(hwnd) ? DSS_NORMAL : DSS_DISABLED;
877 LONG state = get_button_state( hwnd );
878 LONG style = GetWindowLongPtrW( hwnd, GWL_STYLE );
879 WCHAR *text = NULL;
880
881 /* FIXME: To draw disabled label in Win31 look-and-feel, we probably
882 * must use DSS_MONO flag and COLOR_GRAYTEXT brush (or maybe DSS_UNION).
883 * I don't have Win31 on hand to verify that, so I leave it as is.
884 */
885
886 if ((style & BS_PUSHLIKE) && (state & BST_INDETERMINATE))
887 {
888 hbr = GetSysColorBrush(COLOR_GRAYTEXT);
889 flags |= DSS_MONO;
890 }
891
892 switch (style & (BS_ICON|BS_BITMAP))
893 {
894 case BS_TEXT:
895 /* DST_COMPLEX -- is 0 */
896 lpOutputProc = BUTTON_DrawTextCallback;
897 if (!(text = get_button_text( hwnd ))) return;
898 lp = (LPARAM)text;
899 wp = (WPARAM)dtFlags;
900
901 #ifdef __REACTOS__
902 if (dtFlags & DT_HIDEPREFIX)
903 flags |= DSS_HIDEPREFIX;
904 #endif
905 break;
906
907 case BS_ICON:
908 flags |= DST_ICON;
909 lp = GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET );
910 break;
911
912 case BS_BITMAP:
913 flags |= DST_BITMAP;
914 lp = GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET );
915 break;
916
917 default:
918 return;
919 }
920
921 DrawStateW(hdc, hbr, lpOutputProc, lp, wp, rc->left, rc->top,
922 rc->right - rc->left, rc->bottom - rc->top, flags);
923 HeapFree( GetProcessHeap(), 0, text );
924 }
925
926 /**********************************************************************
927 * Push Button Functions
928 */
929 static void PB_Paint( HWND hwnd, HDC hDC, UINT action )
930 {
931 RECT rc, r;
932 UINT dtFlags, uState;
933 HPEN hOldPen;
934 HBRUSH hOldBrush;
935 INT oldBkMode;
936 COLORREF oldTxtColor;
937 HFONT hFont;
938 LONG state = get_button_state( hwnd );
939 LONG style = GetWindowLongPtrW( hwnd, GWL_STYLE );
940 BOOL pushedState = (state & BST_PUSHED);
941 HWND parent;
942 HRGN hrgn;
943
944 GetClientRect( hwnd, &rc );
945
946 /* Send WM_CTLCOLOR to allow changing the font (the colors are fixed) */
947 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
948 parent = GetParent(hwnd);
949 if (!parent) parent = hwnd;
950 #ifdef __REACTOS__
951 GetControlColor( parent, hwnd, hDC, WM_CTLCOLORBTN);
952 #else
953 SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
954 #endif
955
956 hrgn = set_control_clipping( hDC, &rc );
957 #ifdef __REACTOS__
958 hOldPen = SelectObject(hDC, GetStockObject(DC_PEN));
959 SetDCPenColor(hDC, GetSysColor(COLOR_WINDOWFRAME));
960 #else
961 hOldPen = SelectObject(hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME));
962 #endif
963 hOldBrush = SelectObject(hDC,GetSysColorBrush(COLOR_BTNFACE));
964 oldBkMode = SetBkMode(hDC, TRANSPARENT);
965
966 if (get_button_type(style) == BS_DEFPUSHBUTTON)
967 {
968 if (action != ODA_FOCUS)
969 Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
970 InflateRect( &rc, -1, -1 );
971 }
972
973 /* completely skip the drawing if only focus has changed */
974 if (action == ODA_FOCUS) goto draw_focus;
975
976 uState = DFCS_BUTTONPUSH;
977
978 if (style & BS_FLAT)
979 uState |= DFCS_MONO;
980 else if (pushedState)
981 {
982 if (get_button_type(style) == BS_DEFPUSHBUTTON )
983 uState |= DFCS_FLAT;
984 else
985 uState |= DFCS_PUSHED;
986 }
987
988 if (state & (BST_CHECKED | BST_INDETERMINATE))
989 uState |= DFCS_CHECKED;
990
991 DrawFrameControl( hDC, &rc, DFC_BUTTON, uState );
992
993 /* draw button label */
994 r = rc;
995 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &r);
996
997 if (dtFlags == (UINT)-1L)
998 goto cleanup;
999
1000 if (pushedState)
1001 OffsetRect(&r, 1, 1);
1002
1003 oldTxtColor = SetTextColor( hDC, GetSysColor(COLOR_BTNTEXT) );
1004
1005 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &r);
1006
1007 SetTextColor( hDC, oldTxtColor );
1008
1009 draw_focus:
1010 if (action == ODA_FOCUS || (state & BST_FOCUS))
1011 {
1012 #ifdef __REACTOS__
1013 if (!(get_ui_state(hwnd) & UISF_HIDEFOCUS))
1014 {
1015 #endif
1016 InflateRect( &rc, -2, -2 );
1017 DrawFocusRect( hDC, &rc );
1018 #ifdef __REACTOS__
1019 }
1020 #endif
1021 }
1022
1023 cleanup:
1024 SelectObject( hDC, hOldPen );
1025 SelectObject( hDC, hOldBrush );
1026 SetBkMode(hDC, oldBkMode);
1027 SelectClipRgn( hDC, hrgn );
1028 if (hrgn) DeleteObject( hrgn );
1029 }
1030
1031 /**********************************************************************
1032 * Check Box & Radio Button Functions
1033 */
1034
1035 static void CB_Paint( HWND hwnd, HDC hDC, UINT action )
1036 {
1037 RECT rbox, rtext, client;
1038 HBRUSH hBrush;
1039 int delta, text_offset, checkBoxWidth, checkBoxHeight;
1040 UINT dtFlags;
1041 HFONT hFont;
1042 LONG state = get_button_state( hwnd );
1043 LONG style = GetWindowLongPtrW( hwnd, GWL_STYLE );
1044 LONG ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
1045 HWND parent;
1046 HRGN hrgn;
1047
1048 if (style & BS_PUSHLIKE)
1049 {
1050 PB_Paint( hwnd, hDC, action );
1051 return;
1052 }
1053
1054 GetClientRect(hwnd, &client);
1055 rbox = rtext = client;
1056
1057 checkBoxWidth = 12 * GetDeviceCaps( hDC, LOGPIXELSX ) / 96 + 1;
1058 checkBoxHeight = 12 * GetDeviceCaps( hDC, LOGPIXELSY ) / 96 + 1;
1059
1060 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
1061 GetCharWidthW( hDC, '0', '0', &text_offset );
1062 text_offset /= 2;
1063
1064 parent = GetParent(hwnd);
1065 if (!parent) parent = hwnd;
1066 #ifdef __REACTOS__
1067 hBrush = GetControlColor(parent, hwnd, hDC, WM_CTLCOLORSTATIC);
1068 #else
1069 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
1070 (WPARAM)hDC, (LPARAM)hwnd);
1071 if (!hBrush) /* did the app forget to call defwindowproc ? */
1072 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
1073 (WPARAM)hDC, (LPARAM)hwnd );
1074 #endif
1075 hrgn = set_control_clipping( hDC, &client );
1076
1077 if (style & BS_LEFTTEXT || ex_style & WS_EX_RIGHT)
1078 {
1079 /* magic +4 is what CTL3D expects */
1080
1081 rtext.right -= checkBoxWidth + text_offset;;
1082 rbox.left = rbox.right - checkBoxWidth;
1083 }
1084 else
1085 {
1086 rtext.left += checkBoxWidth + text_offset;;
1087 rbox.right = checkBoxWidth;
1088 }
1089
1090 /* Since WM_ERASEBKGND does nothing, first prepare background */
1091 if (action == ODA_SELECT) FillRect( hDC, &rbox, hBrush );
1092 if (action == ODA_DRAWENTIRE) FillRect( hDC, &client, hBrush );
1093
1094 /* Draw label */
1095 client = rtext;
1096 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &rtext);
1097
1098 /* Only adjust rbox when rtext is valid */
1099 if (dtFlags != (UINT)-1L)
1100 {
1101 rbox.top = rtext.top;
1102 rbox.bottom = rtext.bottom;
1103 }
1104
1105 /* Draw the check-box bitmap */
1106 if (action == ODA_DRAWENTIRE || action == ODA_SELECT)
1107 {
1108 UINT flags;
1109
1110 if ((get_button_type(style) == BS_RADIOBUTTON) ||
1111 (get_button_type(style) == BS_AUTORADIOBUTTON)) flags = DFCS_BUTTONRADIO;
1112 else if (state & BST_INDETERMINATE) flags = DFCS_BUTTON3STATE;
1113 else flags = DFCS_BUTTONCHECK;
1114
1115 if (state & (BST_CHECKED | BST_INDETERMINATE)) flags |= DFCS_CHECKED;
1116 if (state & BST_PUSHED) flags |= DFCS_PUSHED;
1117
1118 if (style & WS_DISABLED) flags |= DFCS_INACTIVE;
1119
1120 /* rbox must have the correct height */
1121 delta = rbox.bottom - rbox.top - checkBoxHeight;
1122
1123 if (style & BS_TOP) {
1124 if (delta > 0) {
1125 rbox.bottom = rbox.top + checkBoxHeight;
1126 } else {
1127 rbox.top -= -delta/2 + 1;
1128 rbox.bottom = rbox.top + checkBoxHeight;
1129 }
1130 } else if (style & BS_BOTTOM) {
1131 if (delta > 0) {
1132 rbox.top = rbox.bottom - checkBoxHeight;
1133 } else {
1134 rbox.bottom += -delta/2 + 1;
1135 rbox.top = rbox.bottom - checkBoxHeight;
1136 }
1137 } else { /* Default */
1138 if (delta > 0) {
1139 int ofs = (delta / 2);
1140 rbox.bottom -= ofs + 1;
1141 rbox.top = rbox.bottom - checkBoxHeight;
1142 } else if (delta < 0) {
1143 int ofs = (-delta / 2);
1144 rbox.top -= ofs + 1;
1145 rbox.bottom = rbox.top + checkBoxHeight;
1146 }
1147 }
1148
1149 DrawFrameControl( hDC, &rbox, DFC_BUTTON, flags );
1150 }
1151
1152 if (dtFlags == (UINT)-1L) /* Noting to draw */
1153 return;
1154
1155 if (action == ODA_DRAWENTIRE)
1156 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &rtext);
1157
1158 /* ... and focus */
1159 if (action == ODA_FOCUS || (state & BST_FOCUS))
1160 {
1161 #ifdef __REACTOS__
1162 if (!(get_ui_state(hwnd) & UISF_HIDEFOCUS))
1163 {
1164 #endif
1165 rtext.left--;
1166 rtext.right++;
1167 IntersectRect(&rtext, &rtext, &client);
1168 DrawFocusRect( hDC, &rtext );
1169 #ifdef __REACTOS__
1170 }
1171 #endif
1172 }
1173 SelectClipRgn( hDC, hrgn );
1174 if (hrgn) DeleteObject( hrgn );
1175 }
1176
1177
1178 /**********************************************************************
1179 * BUTTON_CheckAutoRadioButton
1180 *
1181 * hwnd is checked, uncheck every other auto radio button in group
1182 */
1183 static void BUTTON_CheckAutoRadioButton( HWND hwnd )
1184 {
1185 HWND parent, sibling, start;
1186
1187 parent = GetParent(hwnd);
1188 /* make sure that starting control is not disabled or invisible */
1189 start = sibling = hwnd;
1190 do
1191 {
1192 if (!sibling) break;
1193 if (SendMessageW( sibling, WM_GETDLGCODE, 0, 0 ) == (DLGC_BUTTON | DLGC_RADIOBUTTON))
1194 SendMessageW( sibling, BM_SETCHECK, sibling == hwnd ? BST_CHECKED : BST_UNCHECKED, 0 );
1195 sibling = GetNextDlgGroupItem( parent, sibling, FALSE );
1196 } while (sibling != start);
1197 }
1198
1199
1200 /**********************************************************************
1201 * Group Box Functions
1202 */
1203
1204 static void GB_Paint( HWND hwnd, HDC hDC, UINT action )
1205 {
1206 RECT rc, rcFrame;
1207 HBRUSH hbr;
1208 HFONT hFont;
1209 UINT dtFlags;
1210 TEXTMETRICW tm;
1211 LONG style = GetWindowLongPtrW( hwnd, GWL_STYLE );
1212 HWND parent;
1213 HRGN hrgn;
1214
1215 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
1216 /* GroupBox acts like static control, so it sends CTLCOLORSTATIC */
1217 parent = GetParent(hwnd);
1218 if (!parent) parent = hwnd;
1219 #ifdef __REACTOS__
1220 hbr = GetControlColor(parent, hwnd, hDC, WM_CTLCOLORSTATIC);
1221 #else
1222 hbr = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd);
1223 if (!hbr) /* did the app forget to call defwindowproc ? */
1224 hbr = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
1225 (WPARAM)hDC, (LPARAM)hwnd);
1226 #endif
1227 GetClientRect( hwnd, &rc);
1228 rcFrame = rc;
1229 hrgn = set_control_clipping( hDC, &rc );
1230
1231 GetTextMetricsW (hDC, &tm);
1232 rcFrame.top += (tm.tmHeight / 2) - 1;
1233 DrawEdge (hDC, &rcFrame, EDGE_ETCHED, BF_RECT | ((style & BS_FLAT) ? BF_FLAT : 0));
1234
1235 InflateRect(&rc, -7, 1);
1236 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &rc);
1237
1238 if (dtFlags != (UINT)-1L)
1239 {
1240 /* Because buttons have CS_PARENTDC class style, there is a chance
1241 * that label will be drawn out of client rect.
1242 * But Windows doesn't clip label's rect, so do I.
1243 */
1244
1245 /* There is 1-pixel margin at the left, right, and bottom */
1246 rc.left--; rc.right++; rc.bottom++;
1247 FillRect(hDC, &rc, hbr);
1248 rc.left++; rc.right--; rc.bottom--;
1249
1250 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &rc);
1251 }
1252 SelectClipRgn( hDC, hrgn );
1253 if (hrgn) DeleteObject( hrgn );
1254 }
1255
1256
1257 /**********************************************************************
1258 * User Button Functions
1259 */
1260
1261 static void UB_Paint( HWND hwnd, HDC hDC, UINT action )
1262 {
1263 RECT rc;
1264 HBRUSH hBrush;
1265 HFONT hFont;
1266 LONG state = get_button_state( hwnd );
1267 HWND parent;
1268
1269 GetClientRect( hwnd, &rc);
1270
1271 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
1272
1273 parent = GetParent(hwnd);
1274 if (!parent) parent = hwnd;
1275 #ifdef __REACTOS__
1276 hBrush = GetControlColor( parent, hwnd, hDC, WM_CTLCOLORBTN);
1277 #else
1278 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd);
1279 if (!hBrush) /* did the app forget to call defwindowproc ? */
1280 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
1281 (WPARAM)hDC, (LPARAM)hwnd);
1282 #endif
1283
1284 FillRect( hDC, &rc, hBrush );
1285 if (action == ODA_FOCUS || (state & BST_FOCUS))
1286 #ifdef __REACTOS__
1287 {
1288 if (!(get_ui_state(hwnd) & UISF_HIDEFOCUS))
1289 #endif
1290 DrawFocusRect( hDC, &rc );
1291 #ifdef __REACTOS__
1292 }
1293 #endif
1294
1295 switch (action)
1296 {
1297 case ODA_FOCUS:
1298 BUTTON_NOTIFY_PARENT( hwnd, (state & BST_FOCUS) ? BN_SETFOCUS : BN_KILLFOCUS );
1299 break;
1300
1301 case ODA_SELECT:
1302 BUTTON_NOTIFY_PARENT( hwnd, (state & BST_PUSHED) ? BN_HILITE : BN_UNHILITE );
1303 break;
1304
1305 default:
1306 BUTTON_NOTIFY_PARENT( hwnd, BN_PAINT );
1307 break;
1308 }
1309 }
1310
1311
1312 /**********************************************************************
1313 * Ownerdrawn Button Functions
1314 */
1315
1316 static void OB_Paint( HWND hwnd, HDC hDC, UINT action )
1317 {
1318 LONG state = get_button_state( hwnd );
1319 DRAWITEMSTRUCT dis;
1320 LONG_PTR id = GetWindowLongPtrW( hwnd, GWLP_ID );
1321 HWND parent;
1322 HFONT hFont, hPrevFont = 0;
1323 HRGN hrgn;
1324
1325 dis.CtlType = ODT_BUTTON;
1326 dis.CtlID = id;
1327 dis.itemID = 0;
1328 dis.itemAction = action;
1329 dis.itemState = ((state & BST_FOCUS) ? ODS_FOCUS : 0) |
1330 ((state & BST_PUSHED) ? ODS_SELECTED : 0) |
1331 (IsWindowEnabled(hwnd) ? 0: ODS_DISABLED);
1332 dis.hwndItem = hwnd;
1333 dis.hDC = hDC;
1334 dis.itemData = 0;
1335 GetClientRect( hwnd, &dis.rcItem );
1336
1337 if ((hFont = get_button_font( hwnd ))) hPrevFont = SelectObject( hDC, hFont );
1338 parent = GetParent(hwnd);
1339 if (!parent) parent = hwnd;
1340 #ifdef __REACTOS__
1341 GetControlColor( parent, hwnd, hDC, WM_CTLCOLORBTN);
1342 #else
1343 SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
1344 #endif
1345
1346 hrgn = set_control_clipping( hDC, &dis.rcItem );
1347
1348 SendMessageW( GetParent(hwnd), WM_DRAWITEM, id, (LPARAM)&dis );
1349 if (hPrevFont) SelectObject(hDC, hPrevFont);
1350 SelectClipRgn( hDC, hrgn );
1351 if (hrgn) DeleteObject( hrgn );
1352 }