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