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