?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ole32: Fix some pointer conversion warnings on 64-bit.
[wine.git] / dlls / user32 / button.c
blobf2097aa1d9170b05fca7714cd82770473b86cafd
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 * - BS_TYPEMASK
35 *
36 * Messages
37 * - WM_CHAR: Checks a (manual or automatic) check box on '+' or '=', clears it on '-' key.
38 * - WM_SETFOCUS: For (manual or automatic) radio buttons, send the parent window BN_CLICKED
39 * - WM_NCCREATE: Turns any BS_OWNERDRAW button into a BS_PUSHBUTTON button.
40 * - WM_SYSKEYUP
41 * - BCM_GETIDEALSIZE
42 * - BCM_GETIMAGELIST
43 * - BCM_GETTEXTMARGIN
44 * - BCM_SETIMAGELIST
45 * - BCM_SETTEXTMARGIN
46 *
47 * Notifications
48 * - BCN_HOTITEMCHANGE
49 * - BN_DISABLE
50 * - BN_PUSHED/BN_HILITE
51 * + BN_KILLFOCUS: is it OK?
52 * - BN_PAINT
53 * + BN_SETFOCUS: is it OK?
54 * - BN_UNPUSHED/BN_UNHILITE
55 * - NM_CUSTOMDRAW
56 *
57 * Structures/Macros/Definitions
58 * - BUTTON_IMAGELIST
59 * - NMBCHOTITEM
60 * - Button_GetIdealSize
61 * - Button_GetImageList
62 * - Button_GetTextMargin
63 * - Button_SetImageList
64 * - Button_SetTextMargin
65 */
66
67 #include <stdarg.h>
68 #include <string.h>
69 #include <stdlib.h>
70
71 #define OEMRESOURCE
72
73 #include "windef.h"
74 #include "winbase.h"
75 #include "wingdi.h"
76 #include "wine/winuser16.h"
77 #include "controls.h"
78 #include "user_private.h"
79 #include "wine/debug.h"
80
81 WINE_DEFAULT_DEBUG_CHANNEL(button);
82
83 /* GetWindowLong offsets for window extra information */
84 #define STATE_GWL_OFFSET 0
85 #define HFONT_GWL_OFFSET (sizeof(LONG))
86 #define HIMAGE_GWL_OFFSET (HFONT_GWL_OFFSET+sizeof(HFONT))
87 #define NB_EXTRA_BYTES (HIMAGE_GWL_OFFSET+sizeof(HANDLE))
88
89 /* Button state values */
90 #define BUTTON_UNCHECKED 0x00
91 #define BUTTON_CHECKED 0x01
92 #define BUTTON_3STATE 0x02
93 #define BUTTON_HIGHLIGHTED 0x04
94 #define BUTTON_HASFOCUS 0x08
95 #define BUTTON_NSTATES 0x0F
96 /* undocumented flags */
97 #define BUTTON_BTNPRESSED 0x40
98 #define BUTTON_UNKNOWN2 0x20
99 #define BUTTON_UNKNOWN3 0x10
100
101 #define BUTTON_NOTIFY_PARENT(hWnd, code) \
102 do { /* Notify parent which has created this button control */ \
103 TRACE("notification " #code " sent to hwnd=%p\n", GetParent(hWnd)); \
104 SendMessageW(GetParent(hWnd), WM_COMMAND, \
105 MAKEWPARAM(GetWindowLongPtrW((hWnd),GWLP_ID), (code)), \
106 (LPARAM)(hWnd)); \
107 } while(0)
108
109 static UINT BUTTON_CalcLabelRect( HWND hwnd, HDC hdc, RECT *rc );
110 static void PB_Paint( HWND hwnd, HDC hDC, UINT action );
111 static void CB_Paint( HWND hwnd, HDC hDC, UINT action );
112 static void GB_Paint( HWND hwnd, HDC hDC, UINT action );
113 static void UB_Paint( HWND hwnd, HDC hDC, UINT action );
114 static void OB_Paint( HWND hwnd, HDC hDC, UINT action );
115 static void BUTTON_CheckAutoRadioButton( HWND hwnd );
116 static LRESULT WINAPI ButtonWndProcA( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
117 static LRESULT WINAPI ButtonWndProcW( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
118
119 #define MAX_BTN_TYPE 12
120
121 static const WORD maxCheckState[MAX_BTN_TYPE] =
122 {
123 BUTTON_UNCHECKED, /* BS_PUSHBUTTON */
124 BUTTON_UNCHECKED, /* BS_DEFPUSHBUTTON */
125 BUTTON_CHECKED, /* BS_CHECKBOX */
126 BUTTON_CHECKED, /* BS_AUTOCHECKBOX */
127 BUTTON_CHECKED, /* BS_RADIOBUTTON */
128 BUTTON_3STATE, /* BS_3STATE */
129 BUTTON_3STATE, /* BS_AUTO3STATE */
130 BUTTON_UNCHECKED, /* BS_GROUPBOX */
131 BUTTON_UNCHECKED, /* BS_USERBUTTON */
132 BUTTON_CHECKED, /* BS_AUTORADIOBUTTON */
133 BUTTON_UNCHECKED, /* Not defined */
134 BUTTON_UNCHECKED /* BS_OWNERDRAW */
135 };
136
137 typedef void (*pfPaint)( HWND hwnd, HDC hdc, UINT action );
138
139 static const pfPaint btnPaintFunc[MAX_BTN_TYPE] =
140 {
141 PB_Paint, /* BS_PUSHBUTTON */
142 PB_Paint, /* BS_DEFPUSHBUTTON */
143 CB_Paint, /* BS_CHECKBOX */
144 CB_Paint, /* BS_AUTOCHECKBOX */
145 CB_Paint, /* BS_RADIOBUTTON */
146 CB_Paint, /* BS_3STATE */
147 CB_Paint, /* BS_AUTO3STATE */
148 GB_Paint, /* BS_GROUPBOX */
149 UB_Paint, /* BS_USERBUTTON */
150 CB_Paint, /* BS_AUTORADIOBUTTON */
151 NULL, /* Not defined */
152 OB_Paint /* BS_OWNERDRAW */
153 };
154
155 static HBITMAP hbitmapCheckBoxes = 0;
156 static WORD checkBoxWidth = 0, checkBoxHeight = 0;
157
158
159 /*********************************************************************
160 * button class descriptor
161 */
162 static const WCHAR buttonW[] = {'B','u','t','t','o','n',0};
163 const struct builtin_class_descr BUTTON_builtin_class =
164 {
165 buttonW, /* name */
166 CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, /* style */
167 ButtonWndProcA, /* procA */
168 ButtonWndProcW, /* procW */
169 NB_EXTRA_BYTES, /* extra */
170 IDC_ARROW, /* cursor */
171 0 /* brush */
172 };
173
174
175 static inline LONG get_button_state( HWND hwnd )
176 {
177 return GetWindowLongW( hwnd, STATE_GWL_OFFSET );
178 }
179
180 static inline void set_button_state( HWND hwnd, LONG state )
181 {
182 SetWindowLongW( hwnd, STATE_GWL_OFFSET, state );
183 }
184
185 static inline HFONT get_button_font( HWND hwnd )
186 {
187 return (HFONT)GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
188 }
189
190 static inline void set_button_font( HWND hwnd, HFONT font )
191 {
192 SetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET, (LONG_PTR)font );
193 }
194
195 static inline UINT get_button_type( LONG window_style )
196 {
197 return (window_style & 0x0f);
198 }
199
200 /* paint a button of any type */
201 static inline void paint_button( HWND hwnd, LONG style, UINT action )
202 {
203 if (btnPaintFunc[style] && IsWindowVisible(hwnd))
204 {
205 HDC hdc = GetDC( hwnd );
206 btnPaintFunc[style]( hwnd, hdc, action );
207 ReleaseDC( hwnd, hdc );
208 }
209 }
210
211 /* retrieve the button text; returned buffer must be freed by caller */
212 static inline WCHAR *get_button_text( HWND hwnd )
213 {
214 INT len = 512;
215 WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
216 if (buffer) InternalGetWindowText( hwnd, buffer, len + 1 );
217 return buffer;
218 }
219
220 static void setup_clipping( HWND hwnd, HDC hdc )
221 {
222 RECT rc;
223
224 GetClientRect( hwnd, &rc );
225 DPtoLP( hdc, (POINT *)&rc, 2 );
226 IntersectClipRect( hdc, rc.left, rc.top, rc.right, rc.bottom );
227 }
228
229 /***********************************************************************
230 * ButtonWndProc_common
231 */
232 static LRESULT ButtonWndProc_common(HWND hWnd, UINT uMsg,
233 WPARAM wParam, LPARAM lParam, BOOL unicode )
234 {
235 RECT rect;
236 POINT pt;
237 LONG style = GetWindowLongW( hWnd, GWL_STYLE );
238 UINT btn_type = get_button_type( style );
239 LONG state;
240 HANDLE oldHbitmap;
241
242 pt.x = (short)LOWORD(lParam);
243 pt.y = (short)HIWORD(lParam);
244
245 switch (uMsg)
246 {
247 case WM_GETDLGCODE:
248 switch(btn_type)
249 {
250 case BS_USERBUTTON:
251 case BS_PUSHBUTTON: return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON;
252 case BS_DEFPUSHBUTTON: return DLGC_BUTTON | DLGC_DEFPUSHBUTTON;
253 case BS_RADIOBUTTON:
254 case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON;
255 case BS_GROUPBOX: return DLGC_STATIC;
256 default: return DLGC_BUTTON;
257 }
258
259 case WM_ENABLE:
260 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
261 break;
262
263 case WM_CREATE:
264 if (!hbitmapCheckBoxes)
265 {
266 BITMAP bmp;
267 hbitmapCheckBoxes = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CHECKBOXES));
268 GetObjectW( hbitmapCheckBoxes, sizeof(bmp), &bmp );
269 checkBoxWidth = bmp.bmWidth / 4;
270 checkBoxHeight = bmp.bmHeight / 3;
271 }
272 if (btn_type >= MAX_BTN_TYPE)
273 return -1; /* abort */
274 set_button_state( hWnd, BUTTON_UNCHECKED );
275 return 0;
276
277 case WM_ERASEBKGND:
278 if (btn_type == BS_OWNERDRAW)
279 {
280 HDC hdc = (HDC)wParam;
281 RECT rc;
282 HBRUSH hBrush;
283 HWND parent = GetParent(hWnd);
284 if (!parent) parent = hWnd;
285 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
286 if (!hBrush) /* did the app forget to call defwindowproc ? */
287 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
288 (WPARAM)hdc, (LPARAM)hWnd);
289 GetClientRect(hWnd, &rc);
290 FillRect(hdc, &rc, hBrush);
291 }
292 return 1;
293
294 case WM_PRINTCLIENT:
295 case WM_PAINT:
296 if (btnPaintFunc[btn_type])
297 {
298 PAINTSTRUCT ps;
299 HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
300 int nOldMode = SetBkMode( hdc, OPAQUE );
301 (btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE );
302 SetBkMode(hdc, nOldMode); /* reset painting mode */
303 if( !wParam ) EndPaint( hWnd, &ps );
304 }
305 break;
306
307 case WM_KEYDOWN:
308 if (wParam == VK_SPACE)
309 {
310 SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
311 set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
312 SetCapture( hWnd );
313 }
314 break;
315
316 case WM_LBUTTONDBLCLK:
317 if(style & BS_NOTIFY ||
318 btn_type == BS_RADIOBUTTON ||
319 btn_type == BS_USERBUTTON ||
320 btn_type == BS_OWNERDRAW)
321 {
322 BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED);
323 break;
324 }
325 /* fall through */
326 case WM_LBUTTONDOWN:
327 SetCapture( hWnd );
328 SetFocus( hWnd );
329 set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
330 SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
331 break;
332
333 case WM_KEYUP:
334 if (wParam != VK_SPACE)
335 break;
336 /* fall through */
337 case WM_LBUTTONUP:
338 state = get_button_state( hWnd );
339 if (!(state & BUTTON_BTNPRESSED)) break;
340 state &= BUTTON_NSTATES;
341 set_button_state( hWnd, state );
342 if (!(state & BUTTON_HIGHLIGHTED))
343 {
344 ReleaseCapture();
345 break;
346 }
347 SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
348 ReleaseCapture();
349 GetClientRect( hWnd, &rect );
350 if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
351 {
352 state = get_button_state( hWnd );
353 switch(btn_type)
354 {
355 case BS_AUTOCHECKBOX:
356 SendMessageW( hWnd, BM_SETCHECK, !(state & BUTTON_CHECKED), 0 );
357 break;
358 case BS_AUTORADIOBUTTON:
359 SendMessageW( hWnd, BM_SETCHECK, TRUE, 0 );
360 break;
361 case BS_AUTO3STATE:
362 SendMessageW( hWnd, BM_SETCHECK,
363 (state & BUTTON_3STATE) ? 0 : ((state & 3) + 1), 0 );
364 break;
365 }
366 BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
367 }
368 break;
369
370 case WM_CAPTURECHANGED:
371 TRACE("WM_CAPTURECHANGED %p\n", hWnd);
372 state = get_button_state( hWnd );
373 if (state & BUTTON_BTNPRESSED)
374 {
375 state &= BUTTON_NSTATES;
376 set_button_state( hWnd, state );
377 if (state & BUTTON_HIGHLIGHTED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
378 }
379 break;
380
381 case WM_MOUSEMOVE:
382 if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
383 {
384 GetClientRect( hWnd, &rect );
385 SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 );
386 }
387 break;
388
389 case WM_SETTEXT:
390 {
391 /* Clear an old text here as Windows does */
392 HDC hdc = GetDC(hWnd);
393 HBRUSH hbrush;
394 RECT client, rc;
395 HWND parent = GetParent(hWnd);
396
397 if (!parent) parent = hWnd;
398 hbrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
399 (WPARAM)hdc, (LPARAM)hWnd);
400 if (!hbrush) /* did the app forget to call DefWindowProc ? */
401 hbrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
402 (WPARAM)hdc, (LPARAM)hWnd);
403
404 GetClientRect(hWnd, &client);
405 rc = client;
406 BUTTON_CalcLabelRect(hWnd, hdc, &rc);
407 /* Clip by client rect bounds */
408 if (rc.right > client.right) rc.right = client.right;
409 if (rc.bottom > client.bottom) rc.bottom = client.bottom;
410 FillRect(hdc, &rc, hbrush);
411 ReleaseDC(hWnd, hdc);
412
413 if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam );
414 else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam );
415 if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
416 InvalidateRect( hWnd, NULL, TRUE );
417 else
418 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
419 return 1; /* success. FIXME: check text length */
420 }
421
422 case WM_SETFONT:
423 set_button_font( hWnd, (HFONT)wParam );
424 if (lParam) InvalidateRect(hWnd, NULL, TRUE);
425 break;
426
427 case WM_GETFONT:
428 return (LRESULT)get_button_font( hWnd );
429
430 case WM_SETFOCUS:
431 TRACE("WM_SETFOCUS %p\n",hWnd);
432 set_button_state( hWnd, get_button_state(hWnd) | BUTTON_HASFOCUS );
433 paint_button( hWnd, btn_type, ODA_FOCUS );
434 if (style & BS_NOTIFY)
435 BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS);
436 break;
437
438 case WM_KILLFOCUS:
439 TRACE("WM_KILLFOCUS %p\n",hWnd);
440 state = get_button_state( hWnd );
441 set_button_state( hWnd, state & ~BUTTON_HASFOCUS );
442 paint_button( hWnd, btn_type, ODA_FOCUS );
443
444 if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
445 ReleaseCapture();
446 if (style & BS_NOTIFY)
447 BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS);
448
449 break;
450
451 case WM_SYSCOLORCHANGE:
452 InvalidateRect( hWnd, NULL, FALSE );
453 break;
454
455 case BM_SETSTYLE16:
456 case BM_SETSTYLE:
457 if ((wParam & 0x0f) >= MAX_BTN_TYPE) break;
458 btn_type = wParam & 0x0f;
459 style = (style & ~0x0f) | btn_type;
460 SetWindowLongW( hWnd, GWL_STYLE, style );
461
462 /* Only redraw if lParam flag is set.*/
463 if (lParam)
464 paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
465
466 break;
467
468 case BM_CLICK:
469 SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
470 SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
471 break;
472
473 case BM_SETIMAGE:
474 /* Check that image format matches button style */
475 switch (style & (BS_BITMAP|BS_ICON))
476 {
477 case BS_BITMAP:
478 if (wParam != IMAGE_BITMAP) return 0;
479 break;
480 case BS_ICON:
481 if (wParam != IMAGE_ICON) return 0;
482 break;
483 default:
484 return 0;
485 }
486 oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam );
487 InvalidateRect( hWnd, NULL, FALSE );
488 return (LRESULT)oldHbitmap;
489
490 case BM_GETIMAGE:
491 return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET );
492
493 case BM_GETCHECK16:
494 case BM_GETCHECK:
495 return get_button_state( hWnd ) & 3;
496
497 case BM_SETCHECK16:
498 case BM_SETCHECK:
499 if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
500 state = get_button_state( hWnd );
501 if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
502 {
503 if (wParam) style |= WS_TABSTOP;
504 else style &= ~WS_TABSTOP;
505 SetWindowLongW( hWnd, GWL_STYLE, style );
506 }
507 if ((state & 3) != wParam)
508 {
509 set_button_state( hWnd, (state & ~3) | wParam );
510 paint_button( hWnd, btn_type, ODA_SELECT );
511 }
512 if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BUTTON_CHECKED) && (style & WS_CHILD))
513 BUTTON_CheckAutoRadioButton( hWnd );
514 break;
515
516 case BM_GETSTATE16:
517 case BM_GETSTATE:
518 return get_button_state( hWnd );
519
520 case BM_SETSTATE16:
521 case BM_SETSTATE:
522 state = get_button_state( hWnd );
523 if (wParam)
524 {
525 if (state & BUTTON_HIGHLIGHTED) break;
526 set_button_state( hWnd, state | BUTTON_HIGHLIGHTED );
527 }
528 else
529 {
530 if (!(state & BUTTON_HIGHLIGHTED)) break;
531 set_button_state( hWnd, state & ~BUTTON_HIGHLIGHTED );
532 }
533 paint_button( hWnd, btn_type, ODA_SELECT );
534 break;
535
536 case WM_NCHITTEST:
537 if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
538 /* fall through */
539 default:
540 return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) :
541 DefWindowProcA(hWnd, uMsg, wParam, lParam);
542 }
543 return 0;
544 }
545
546 /***********************************************************************
547 * ButtonWndProcW
548 * The button window procedure. This is just a wrapper which locks
549 * the passed HWND and calls the real window procedure (with a WND*
550 * pointer pointing to the locked windowstructure).
551 */
552 static LRESULT WINAPI ButtonWndProcW( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
553 {
554 if (!IsWindow( hWnd )) return 0;
555 return ButtonWndProc_common( hWnd, uMsg, wParam, lParam, TRUE );
556 }
557
558
559 /***********************************************************************
560 * ButtonWndProcA
561 */
562 static LRESULT WINAPI ButtonWndProcA( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
563 {
564 if (!IsWindow( hWnd )) return 0;
565 return ButtonWndProc_common( hWnd, uMsg, wParam, lParam, FALSE );
566 }
567
568
569 /**********************************************************************
570 * Convert button styles to flags used by DrawText.
571 */
572 static UINT BUTTON_BStoDT( DWORD style, DWORD ex_style )
573 {
574 UINT dtStyle = DT_NOCLIP; /* We use SelectClipRgn to limit output */
575
576 /* "Convert" pushlike buttons to pushbuttons */
577 if (style & BS_PUSHLIKE)
578 style &= ~0x0F;
579
580 if (!(style & BS_MULTILINE))
581 dtStyle |= DT_SINGLELINE;
582 else
583 dtStyle |= DT_WORDBREAK;
584
585 switch (style & BS_CENTER)
586 {
587 case BS_LEFT: /* DT_LEFT is 0 */ break;
588 case BS_RIGHT: dtStyle |= DT_RIGHT; break;
589 case BS_CENTER: dtStyle |= DT_CENTER; break;
590 default:
591 /* Pushbutton's text is centered by default */
592 if (get_button_type(style) <= BS_DEFPUSHBUTTON) dtStyle |= DT_CENTER;
593 /* all other flavours have left aligned text */
594 }
595
596 if (ex_style & WS_EX_RIGHT) dtStyle = DT_RIGHT | (dtStyle & ~(DT_LEFT | DT_CENTER));
597
598 /* DrawText ignores vertical alignment for multiline text,
599 * but we use these flags to align label manually.
600 */
601 if (get_button_type(style) != BS_GROUPBOX)
602 {
603 switch (style & BS_VCENTER)
604 {
605 case BS_TOP: /* DT_TOP is 0 */ break;
606 case BS_BOTTOM: dtStyle |= DT_BOTTOM; break;
607 case BS_VCENTER: /* fall through */
608 default: dtStyle |= DT_VCENTER; break;
609 }
610 }
611 else
612 /* GroupBox's text is always single line and is top aligned. */
613 dtStyle |= DT_SINGLELINE;
614
615 return dtStyle;
616 }
617
618 /**********************************************************************
619 * BUTTON_CalcLabelRect
620 *
621 * Calculates label's rectangle depending on button style.
622 *
623 * Returns flags to be passed to DrawText.
624 * Calculated rectangle doesn't take into account button state
625 * (pushed, etc.). If there is nothing to draw (no text/image) output
626 * rectangle is empty, and return value is (UINT)-1.
627 */
628 static UINT BUTTON_CalcLabelRect(HWND hwnd, HDC hdc, RECT *rc)
629 {
630 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
631 LONG ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
632 WCHAR *text;
633 ICONINFO iconInfo;
634 BITMAP bm;
635 UINT dtStyle = BUTTON_BStoDT( style, ex_style );
636 RECT r = *rc;
637 INT n;
638
639 /* Calculate label rectangle according to label type */
640 switch (style & (BS_ICON|BS_BITMAP))
641 {
642 case BS_TEXT:
643 if (!(text = get_button_text( hwnd ))) goto empty_rect;
644 if (!text[0])
645 {
646 HeapFree( GetProcessHeap(), 0, text );
647 goto empty_rect;
648 }
649 DrawTextW(hdc, text, -1, &r, dtStyle | DT_CALCRECT);
650 HeapFree( GetProcessHeap(), 0, text );
651 break;
652
653 case BS_ICON:
654 if (!GetIconInfo((HICON)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), &iconInfo))
655 goto empty_rect;
656
657 GetObjectW (iconInfo.hbmColor, sizeof(BITMAP), &bm);
658
659 r.right = r.left + bm.bmWidth;
660 r.bottom = r.top + bm.bmHeight;
661
662 DeleteObject(iconInfo.hbmColor);
663 DeleteObject(iconInfo.hbmMask);
664 break;
665
666 case BS_BITMAP:
667 if (!GetObjectW( (HANDLE)GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET ), sizeof(BITMAP), &bm))
668 goto empty_rect;
669
670 r.right = r.left + bm.bmWidth;
671 r.bottom = r.top + bm.bmHeight;
672 break;
673
674 default:
675 empty_rect:
676 rc->right = r.left;
677 rc->bottom = r.top;
678 return (UINT)-1;
679 }
680
681 /* Position label inside bounding rectangle according to
682 * alignment flags. (calculated rect is always left-top aligned).
683 * If label is aligned to any side - shift label in opposite
684 * direction to leave extra space for focus rectangle.
685 */
686 switch (dtStyle & (DT_CENTER|DT_RIGHT))
687 {
688 case DT_LEFT: r.left++; r.right++; break;
689 case DT_CENTER: n = r.right - r.left;
690 r.left = rc->left + ((rc->right - rc->left) - n) / 2;
691 r.right = r.left + n; break;
692 case DT_RIGHT: n = r.right - r.left;
693 r.right = rc->right - 1;
694 r.left = r.right - n;
695 break;
696 }
697
698 switch (dtStyle & (DT_VCENTER|DT_BOTTOM))
699 {
700 case DT_TOP: r.top++; r.bottom++; break;
701 case DT_VCENTER: n = r.bottom - r.top;
702 r.top = rc->top + ((rc->bottom - rc->top) - n) / 2;
703 r.bottom = r.top + n; break;
704 case DT_BOTTOM: n = r.bottom - r.top;
705 r.bottom = rc->bottom - 1;
706 r.top = r.bottom - n;
707 break;
708 }
709
710 *rc = r;
711 return dtStyle;
712 }
713
714
715 /**********************************************************************
716 * BUTTON_DrawTextCallback
717 *
718 * Callback function used by DrawStateW function.
719 */
720 static BOOL CALLBACK BUTTON_DrawTextCallback(HDC hdc, LPARAM lp, WPARAM wp, int cx, int cy)
721 {
722 RECT rc;
723 rc.left = 0;
724 rc.top = 0;
725 rc.right = cx;
726 rc.bottom = cy;
727
728 DrawTextW(hdc, (LPCWSTR)lp, -1, &rc, (UINT)wp);
729 return TRUE;
730 }
731
732
733 /**********************************************************************
734 * BUTTON_DrawLabel
735 *
736 * Common function for drawing button label.
737 */
738 static void BUTTON_DrawLabel(HWND hwnd, HDC hdc, UINT dtFlags, const RECT *rc)
739 {
740 DRAWSTATEPROC lpOutputProc = NULL;
741 LPARAM lp;
742 WPARAM wp = 0;
743 HBRUSH hbr = 0;
744 UINT flags = IsWindowEnabled(hwnd) ? DSS_NORMAL : DSS_DISABLED;
745 LONG state = get_button_state( hwnd );
746 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
747 WCHAR *text = NULL;
748
749 /* FIXME: To draw disabled label in Win31 look-and-feel, we probably
750 * must use DSS_MONO flag and COLOR_GRAYTEXT brush (or maybe DSS_UNION).
751 * I don't have Win31 on hand to verify that, so I leave it as is.
752 */
753
754 if ((style & BS_PUSHLIKE) && (state & BUTTON_3STATE))
755 {
756 hbr = GetSysColorBrush(COLOR_GRAYTEXT);
757 flags |= DSS_MONO;
758 }
759
760 switch (style & (BS_ICON|BS_BITMAP))
761 {
762 case BS_TEXT:
763 /* DST_COMPLEX -- is 0 */
764 lpOutputProc = BUTTON_DrawTextCallback;
765 if (!(text = get_button_text( hwnd ))) return;
766 lp = (LPARAM)text;
767 wp = (WPARAM)dtFlags;
768 break;
769
770 case BS_ICON:
771 flags |= DST_ICON;
772 lp = GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET );
773 break;
774
775 case BS_BITMAP:
776 flags |= DST_BITMAP;
777 lp = GetWindowLongPtrW( hwnd, HIMAGE_GWL_OFFSET );
778 break;
779
780 default:
781 return;
782 }
783
784 DrawStateW(hdc, hbr, lpOutputProc, lp, wp, rc->left, rc->top,
785 rc->right - rc->left, rc->bottom - rc->top, flags);
786 HeapFree( GetProcessHeap(), 0, text );
787 }
788
789 /**********************************************************************
790 * Push Button Functions
791 */
792 static void PB_Paint( HWND hwnd, HDC hDC, UINT action )
793 {
794 RECT rc, focus_rect, r;
795 UINT dtFlags, uState;
796 HPEN hOldPen;
797 HBRUSH hOldBrush;
798 INT oldBkMode;
799 COLORREF oldTxtColor;
800 HFONT hFont;
801 LONG state = get_button_state( hwnd );
802 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
803 BOOL pushedState = (state & BUTTON_HIGHLIGHTED);
804 HWND parent;
805
806 GetClientRect( hwnd, &rc );
807
808 /* Send WM_CTLCOLOR to allow changing the font (the colors are fixed) */
809 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
810 parent = GetParent(hwnd);
811 if (!parent) parent = hwnd;
812 SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
813
814 setup_clipping( hwnd, hDC );
815
816 hOldPen = SelectObject(hDC, SYSCOLOR_GetPen(COLOR_WINDOWFRAME));
817 hOldBrush = SelectObject(hDC,GetSysColorBrush(COLOR_BTNFACE));
818 oldBkMode = SetBkMode(hDC, TRANSPARENT);
819
820 if (get_button_type(style) == BS_DEFPUSHBUTTON)
821 {
822 Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
823 InflateRect( &rc, -1, -1 );
824 }
825
826 uState = DFCS_BUTTONPUSH | DFCS_ADJUSTRECT;
827
828 if (style & BS_FLAT)
829 uState |= DFCS_MONO;
830 else if (pushedState)
831 {
832 if (get_button_type(style) == BS_DEFPUSHBUTTON )
833 uState |= DFCS_FLAT;
834 else
835 uState |= DFCS_PUSHED;
836 }
837
838 if (state & (BUTTON_CHECKED | BUTTON_3STATE))
839 uState |= DFCS_CHECKED;
840
841 DrawFrameControl( hDC, &rc, DFC_BUTTON, uState );
842
843 focus_rect = rc;
844
845 /* draw button label */
846 r = rc;
847 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &r);
848
849 if (dtFlags == (UINT)-1L)
850 goto cleanup;
851
852 if (pushedState)
853 OffsetRect(&r, 1, 1);
854
855 IntersectClipRect(hDC, rc.left, rc.top, rc.right, rc.bottom);
856
857 oldTxtColor = SetTextColor( hDC, GetSysColor(COLOR_BTNTEXT) );
858
859 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &r);
860
861 SetTextColor( hDC, oldTxtColor );
862
863 if (state & BUTTON_HASFOCUS)
864 {
865 InflateRect( &focus_rect, -1, -1 );
866 IntersectRect(&focus_rect, &focus_rect, &rc);
867 DrawFocusRect( hDC, &focus_rect );
868 }
869
870 cleanup:
871 SelectObject( hDC, hOldPen );
872 SelectObject( hDC, hOldBrush );
873 SetBkMode(hDC, oldBkMode);
874 }
875
876 /**********************************************************************
877 * Check Box & Radio Button Functions
878 */
879
880 static void CB_Paint( HWND hwnd, HDC hDC, UINT action )
881 {
882 RECT rbox, rtext, client;
883 HBRUSH hBrush;
884 int delta;
885 UINT dtFlags;
886 HFONT hFont;
887 LONG state = get_button_state( hwnd );
888 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
889 HWND parent;
890
891 if (style & BS_PUSHLIKE)
892 {
893 PB_Paint( hwnd, hDC, action );
894 return;
895 }
896
897 GetClientRect(hwnd, &client);
898 rbox = rtext = client;
899
900 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
901
902 parent = GetParent(hwnd);
903 if (!parent) parent = hwnd;
904 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
905 (WPARAM)hDC, (LPARAM)hwnd);
906 if (!hBrush) /* did the app forget to call defwindowproc ? */
907 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
908 (WPARAM)hDC, (LPARAM)hwnd );
909 setup_clipping( hwnd, hDC );
910
911 if (style & BS_LEFTTEXT)
912 {
913 /* magic +4 is what CTL3D expects */
914
915 rtext.right -= checkBoxWidth + 4;
916 rbox.left = rbox.right - checkBoxWidth;
917 }
918 else
919 {
920 rtext.left += checkBoxWidth + 4;
921 rbox.right = checkBoxWidth;
922 }
923
924 /* Since WM_ERASEBKGND does nothing, first prepare background */
925 if (action == ODA_SELECT) FillRect( hDC, &rbox, hBrush );
926 if (action == ODA_DRAWENTIRE) FillRect( hDC, &client, hBrush );
927
928 /* Draw label */
929 client = rtext;
930 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &rtext);
931
932 /* Only adjust rbox when rtext is valid */
933 if (dtFlags != (UINT)-1L)
934 {
935 rbox.top = rtext.top;
936 rbox.bottom = rtext.bottom;
937 }
938
939 /* Draw the check-box bitmap */
940 if (action == ODA_DRAWENTIRE || action == ODA_SELECT)
941 {
942 UINT flags;
943
944 if ((get_button_type(style) == BS_RADIOBUTTON) ||
945 (get_button_type(style) == BS_AUTORADIOBUTTON)) flags = DFCS_BUTTONRADIO;
946 else if (state & BUTTON_3STATE) flags = DFCS_BUTTON3STATE;
947 else flags = DFCS_BUTTONCHECK;
948
949 if (state & (BUTTON_CHECKED | BUTTON_3STATE)) flags |= DFCS_CHECKED;
950 if (state & BUTTON_HIGHLIGHTED) flags |= DFCS_PUSHED;
951
952 if (style & WS_DISABLED) flags |= DFCS_INACTIVE;
953
954 /* rbox must have the correct height */
955 delta = rbox.bottom - rbox.top - checkBoxHeight;
956
957 if (style & BS_TOP) {
958 if (delta > 0) {
959 rbox.bottom = rbox.top + checkBoxHeight;
960 } else {
961 rbox.top -= -delta/2 + 1;
962 rbox.bottom = rbox.top + checkBoxHeight;
963 }
964 } else if (style & BS_BOTTOM) {
965 if (delta > 0) {
966 rbox.top = rbox.bottom - checkBoxHeight;
967 } else {
968 rbox.bottom += -delta/2 + 1;
969 rbox.top = rbox.bottom - checkBoxHeight;
970 }
971 } else { /* Default */
972 if (delta > 0) {
973 int ofs = (delta / 2);
974 rbox.bottom -= ofs + 1;
975 rbox.top = rbox.bottom - checkBoxHeight;
976 } else if (delta < 0) {
977 int ofs = (-delta / 2);
978 rbox.top -= ofs + 1;
979 rbox.bottom = rbox.top + checkBoxHeight;
980 }
981 }
982
983 DrawFrameControl( hDC, &rbox, DFC_BUTTON, flags );
984 }
985
986 if (dtFlags == (UINT)-1L) /* Noting to draw */
987 return;
988
989 if (action == ODA_DRAWENTIRE)
990 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &rtext);
991
992 /* ... and focus */
993 if ((action == ODA_FOCUS) ||
994 ((action == ODA_DRAWENTIRE) && (state & BUTTON_HASFOCUS)))
995 {
996 rtext.left--;
997 rtext.right++;
998 IntersectRect(&rtext, &rtext, &client);
999 DrawFocusRect( hDC, &rtext );
1000 }
1001 }
1002
1003
1004 /**********************************************************************
1005 * BUTTON_CheckAutoRadioButton
1006 *
1007 * hwnd is checked, uncheck every other auto radio button in group
1008 */
1009 static void BUTTON_CheckAutoRadioButton( HWND hwnd )
1010 {
1011 HWND parent, sibling, start;
1012
1013 parent = GetParent(hwnd);
1014 /* make sure that starting control is not disabled or invisible */
1015 start = sibling = GetNextDlgGroupItem( parent, hwnd, TRUE );
1016 do
1017 {
1018 if (!sibling) break;
1019 if ((hwnd != sibling) &&
1020 ((GetWindowLongW( sibling, GWL_STYLE) & 0x0f) == BS_AUTORADIOBUTTON))
1021 SendMessageW( sibling, BM_SETCHECK, BUTTON_UNCHECKED, 0 );
1022 sibling = GetNextDlgGroupItem( parent, sibling, FALSE );
1023 } while (sibling != start);
1024 }
1025
1026
1027 /**********************************************************************
1028 * Group Box Functions
1029 */
1030
1031 static void GB_Paint( HWND hwnd, HDC hDC, UINT action )
1032 {
1033 RECT rc, rcFrame;
1034 HBRUSH hbr;
1035 HFONT hFont;
1036 UINT dtFlags;
1037 TEXTMETRICW tm;
1038 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1039 HWND parent;
1040
1041 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
1042 /* GroupBox acts like static control, so it sends CTLCOLORSTATIC */
1043 parent = GetParent(hwnd);
1044 if (!parent) parent = hwnd;
1045 hbr = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd);
1046 if (!hbr) /* did the app forget to call defwindowproc ? */
1047 hbr = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
1048 (WPARAM)hDC, (LPARAM)hwnd);
1049 setup_clipping( hwnd, hDC );
1050
1051 GetClientRect( hwnd, &rc);
1052 rcFrame = rc;
1053
1054 GetTextMetricsW (hDC, &tm);
1055 rcFrame.top += (tm.tmHeight / 2) - 1;
1056 DrawEdge (hDC, &rcFrame, EDGE_ETCHED, BF_RECT | ((style & BS_FLAT) ? BF_FLAT : 0));
1057
1058 InflateRect(&rc, -7, 1);
1059 dtFlags = BUTTON_CalcLabelRect(hwnd, hDC, &rc);
1060
1061 if (dtFlags == (UINT)-1L)
1062 return;
1063
1064 /* Because buttons have CS_PARENTDC class style, there is a chance
1065 * that label will be drawn out of client rect.
1066 * But Windows doesn't clip label's rect, so do I.
1067 */
1068
1069 /* There is 1-pixel margin at the left, right, and bottom */
1070 rc.left--; rc.right++; rc.bottom++;
1071 FillRect(hDC, &rc, hbr);
1072 rc.left++; rc.right--; rc.bottom--;
1073
1074 BUTTON_DrawLabel(hwnd, hDC, dtFlags, &rc);
1075 }
1076
1077
1078 /**********************************************************************
1079 * User Button Functions
1080 */
1081
1082 static void UB_Paint( HWND hwnd, HDC hDC, UINT action )
1083 {
1084 RECT rc;
1085 HBRUSH hBrush;
1086 HFONT hFont;
1087 LONG state = get_button_state( hwnd );
1088 HWND parent;
1089
1090 if (action == ODA_SELECT) return;
1091
1092 GetClientRect( hwnd, &rc);
1093
1094 if ((hFont = get_button_font( hwnd ))) SelectObject( hDC, hFont );
1095
1096 parent = GetParent(hwnd);
1097 if (!parent) parent = hwnd;
1098 hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd);
1099 if (!hBrush) /* did the app forget to call defwindowproc ? */
1100 hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
1101 (WPARAM)hDC, (LPARAM)hwnd);
1102
1103 FillRect( hDC, &rc, hBrush );
1104 if ((action == ODA_FOCUS) ||
1105 ((action == ODA_DRAWENTIRE) && (state & BUTTON_HASFOCUS)))
1106 DrawFocusRect( hDC, &rc );
1107 }
1108
1109
1110 /**********************************************************************
1111 * Ownerdrawn Button Functions
1112 */
1113
1114 static void OB_Paint( HWND hwnd, HDC hDC, UINT action )
1115 {
1116 LONG state = get_button_state( hwnd );
1117 DRAWITEMSTRUCT dis;
1118 LONG_PTR id = GetWindowLongPtrW( hwnd, GWLP_ID );
1119 HWND parent;
1120 HFONT hFont, hPrevFont = 0;
1121
1122 dis.CtlType = ODT_BUTTON;
1123 dis.CtlID = id;
1124 dis.itemID = 0;
1125 dis.itemAction = action;
1126 dis.itemState = ((state & BUTTON_HASFOCUS) ? ODS_FOCUS : 0) |
1127 ((state & BUTTON_HIGHLIGHTED) ? ODS_SELECTED : 0) |
1128 (IsWindowEnabled(hwnd) ? 0: ODS_DISABLED);
1129 dis.hwndItem = hwnd;
1130 dis.hDC = hDC;
1131 dis.itemData = 0;
1132 GetClientRect( hwnd, &dis.rcItem );
1133
1134 if ((hFont = get_button_font( hwnd ))) hPrevFont = SelectObject( hDC, hFont );
1135 parent = GetParent(hwnd);
1136 if (!parent) parent = hwnd;
1137 SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
1138
1139 setup_clipping( hwnd, hDC );
1140
1141 SendMessageW( GetParent(hwnd), WM_DRAWITEM, id, (LPARAM)&dis );
1142 if (hPrevFont) SelectObject(hDC, hPrevFont);
1143 }
Windows API implementation