ReactOS  0.4.13-dev-464-g6b95727
button.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1993 Johannes Ruscheinski
3  * Copyright (C) 1993 David Metcalfe
4  * Copyright (C) 1994 Alexandre Julliard
5  * Copyright (C) 2008 by Reece H. Dunn
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  * TODO
22  * Styles
23  * - BS_NOTIFY: is it complete?
24  * - BS_RIGHTBUTTON: same as BS_LEFTTEXT
25  *
26  * Messages
27  * - WM_CHAR: Checks a (manual or automatic) check box on '+' or '=', clears it on '-' key.
28  * - WM_SETFOCUS: For (manual or automatic) radio buttons, send the parent window BN_CLICKED
29  * - WM_NCCREATE: Turns any BS_OWNERDRAW button into a BS_PUSHBUTTON button.
30  * - WM_SYSKEYUP
31  * - BCM_GETIDEALSIZE
32  * - BCM_GETIMAGELIST
33  * - BCM_GETTEXTMARGIN
34  * - BCM_SETIMAGELIST
35  * - BCM_SETTEXTMARGIN
36  *
37  * Notifications
38  * - BCN_HOTITEMCHANGE
39  * - BN_DISABLE
40  * - BN_PUSHED/BN_HILITE
41  * + BN_KILLFOCUS: is it OK?
42  * - BN_PAINT
43  * + BN_SETFOCUS: is it OK?
44  * - BN_UNPUSHED/BN_UNHILITE
45  * - NM_CUSTOMDRAW
46  *
47  * Structures/Macros/Definitions
48  * - BUTTON_IMAGELIST
49  * - NMBCHOTITEM
50  * - Button_GetIdealSize
51  * - Button_GetImageList
52  * - Button_GetTextMargin
53  * - Button_SetImageList
54  * - Button_SetTextMargin
55  */
56 
57 #include <stdarg.h>
58 #include <string.h>
59 #include <stdlib.h>
60 
61 #define OEMRESOURCE
62 
63 #include "windef.h"
64 #include "winbase.h"
65 #include "wingdi.h"
66 #include "winuser.h"
67 #include "uxtheme.h"
68 #include "vssym32.h"
69 #include "wine/debug.h"
70 #include "wine/heap.h"
71 
72 #include "comctl32.h"
73 
75 
76 /* undocumented flags */
77 #define BUTTON_NSTATES 0x0F
78 #define BUTTON_BTNPRESSED 0x40
79 #define BUTTON_UNKNOWN2 0x20
80 #define BUTTON_UNKNOWN3 0x10
81 #ifdef __REACTOS__
82 #define BUTTON_BMCLICK 0x100 // ReactOS Need to up to wine!
83 #endif
84 
85 #define BUTTON_NOTIFY_PARENT(hWnd, code) \
86  do { /* Notify parent which has created this button control */ \
87  TRACE("notification " #code " sent to hwnd=%p\n", GetParent(hWnd)); \
88  SendMessageW(GetParent(hWnd), WM_COMMAND, \
89  MAKEWPARAM(GetWindowLongPtrW((hWnd),GWLP_ID), (code)), \
90  (LPARAM)(hWnd)); \
91  } while(0)
92 
93 typedef struct _BUTTON_INFO
94 {
98  union
99  {
103  } u;
104 
105 #ifdef __REACTOS__
106  DWORD ui_state;
107  RECT rcTextMargin;
108  BUTTON_IMAGELIST imlData;
109 #endif
110 } BUTTON_INFO;
111 
112 static UINT BUTTON_CalcLabelRect( const BUTTON_INFO *infoPtr, HDC hdc, RECT *rc );
113 static void PB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action );
114 static void CB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action );
115 static void GB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action );
116 static void UB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action );
117 static void OB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action );
118 static void BUTTON_CheckAutoRadioButton( HWND hwnd );
119 
120 #define MAX_BTN_TYPE 16
121 
123 {
124  BST_UNCHECKED, /* BS_PUSHBUTTON */
125  BST_UNCHECKED, /* BS_DEFPUSHBUTTON */
126  BST_CHECKED, /* BS_CHECKBOX */
127  BST_CHECKED, /* BS_AUTOCHECKBOX */
128  BST_CHECKED, /* BS_RADIOBUTTON */
129  BST_INDETERMINATE, /* BS_3STATE */
130  BST_INDETERMINATE, /* BS_AUTO3STATE */
131  BST_UNCHECKED, /* BS_GROUPBOX */
132  BST_UNCHECKED, /* BS_USERBUTTON */
133  BST_CHECKED, /* BS_AUTORADIOBUTTON */
134  BST_UNCHECKED, /* BS_PUSHBOX */
135  BST_UNCHECKED, /* BS_OWNERDRAW */
136  BST_UNCHECKED, /* BS_SPLITBUTTON */
137  BST_UNCHECKED, /* BS_DEFSPLITBUTTON */
138  BST_UNCHECKED, /* BS_COMMANDLINK */
139  BST_UNCHECKED /* BS_DEFCOMMANDLINK */
140 };
141 
142 /* These are indices into a states array to determine the theme state for a given theme part. */
143 typedef enum
144 {
150 } ButtonState;
151 
152 typedef void (*pfPaint)( const BUTTON_INFO *infoPtr, HDC hdc, UINT action );
153 
155 {
156  PB_Paint, /* BS_PUSHBUTTON */
157  PB_Paint, /* BS_DEFPUSHBUTTON */
158  CB_Paint, /* BS_CHECKBOX */
159  CB_Paint, /* BS_AUTOCHECKBOX */
160  CB_Paint, /* BS_RADIOBUTTON */
161  CB_Paint, /* BS_3STATE */
162  CB_Paint, /* BS_AUTO3STATE */
163  GB_Paint, /* BS_GROUPBOX */
164  UB_Paint, /* BS_USERBUTTON */
165  CB_Paint, /* BS_AUTORADIOBUTTON */
166  NULL, /* BS_PUSHBOX */
167  OB_Paint, /* BS_OWNERDRAW */
168  PB_Paint, /* BS_SPLITBUTTON */
169  PB_Paint, /* BS_DEFSPLITBUTTON */
170  PB_Paint, /* BS_COMMANDLINK */
171  PB_Paint /* BS_DEFCOMMANDLINK */
172 };
173 
174 
175 #ifdef __REACTOS__ /* r73885 */
176 typedef void (*pfThemedPaint)( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused, LPARAM prfFlag);
177 
178 static void PB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused, LPARAM prfFlag);
179 static void CB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused, LPARAM prfFlag);
180 static void GB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused, LPARAM prfFlag);
181 
182 #else
183 typedef void (*pfThemedPaint)( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused);
184 
185 static void PB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused);
186 static void CB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused);
187 static void GB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused);
188 
189 #endif
190 
192 {
193  PB_ThemedPaint, /* BS_PUSHBUTTON */
194  PB_ThemedPaint, /* BS_DEFPUSHBUTTON */
195  CB_ThemedPaint, /* BS_CHECKBOX */
196  CB_ThemedPaint, /* BS_AUTOCHECKBOX */
197  CB_ThemedPaint, /* BS_RADIOBUTTON */
198  CB_ThemedPaint, /* BS_3STATE */
199  CB_ThemedPaint, /* BS_AUTO3STATE */
200  GB_ThemedPaint, /* BS_GROUPBOX */
201  NULL, /* BS_USERBUTTON */
202  CB_ThemedPaint, /* BS_AUTORADIOBUTTON */
203  NULL, /* BS_PUSHBOX */
204  NULL, /* BS_OWNERDRAW */
205  NULL, /* BS_SPLITBUTTON */
206  NULL, /* BS_DEFSPLITBUTTON */
207  NULL, /* BS_COMMANDLINK */
208  NULL, /* BS_DEFCOMMANDLINK */
209 };
210 
211 static inline UINT get_button_type( LONG window_style )
212 {
213  return (window_style & BS_TYPEMASK);
214 }
215 
216 #ifndef __REACTOS__
217 /* paint a button of any type */
218 static inline void paint_button( BUTTON_INFO *infoPtr, LONG style, UINT action )
219 {
220  if (btnPaintFunc[style] && IsWindowVisible(infoPtr->hwnd))
221  {
222  HDC hdc = GetDC( infoPtr->hwnd );
223  btnPaintFunc[style]( infoPtr, hdc, action );
224  ReleaseDC( infoPtr->hwnd, hdc );
225  }
226 }
227 #endif
228 
229 /* retrieve the button text; returned buffer must be freed by caller */
230 static inline WCHAR *get_button_text( const BUTTON_INFO *infoPtr )
231 {
232  INT len = GetWindowTextLengthW( infoPtr->hwnd );
233  WCHAR *buffer = heap_alloc( (len + 1) * sizeof(WCHAR) );
234  if (buffer)
235  GetWindowTextW( infoPtr->hwnd, buffer, len + 1 );
236  return buffer;
237 }
238 
240 {
241  RECT rc = *rect;
242  HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
243 
244  if (GetClipRgn( hdc, hrgn ) != 1)
245  {
246  DeleteObject( hrgn );
247  hrgn = 0;
248  }
249  DPtoLP( hdc, (POINT *)&rc, 2 );
250  if (GetLayout( hdc ) & LAYOUT_RTL) /* compensate for the shifting done by IntersectClipRect */
251  {
252  rc.left++;
253  rc.right++;
254  }
255  IntersectClipRect( hdc, rc.left, rc.top, rc.right, rc.bottom );
256  return hrgn;
257 }
258 
259 /**********************************************************************
260  * Convert button styles to flags used by DrawText.
261  */
262 static UINT BUTTON_BStoDT( DWORD style, DWORD ex_style )
263 {
264  UINT dtStyle = DT_NOCLIP; /* We use SelectClipRgn to limit output */
265 
266  /* "Convert" pushlike buttons to pushbuttons */
267  if (style & BS_PUSHLIKE)
268  style &= ~BS_TYPEMASK;
269 
270  if (!(style & BS_MULTILINE))
271  dtStyle |= DT_SINGLELINE;
272  else
273  dtStyle |= DT_WORDBREAK;
274 
275  switch (style & BS_CENTER)
276  {
277  case BS_LEFT: /* DT_LEFT is 0 */ break;
278  case BS_RIGHT: dtStyle |= DT_RIGHT; break;
279  case BS_CENTER: dtStyle |= DT_CENTER; break;
280  default:
281  /* Pushbutton's text is centered by default */
282  if (get_button_type(style) <= BS_DEFPUSHBUTTON) dtStyle |= DT_CENTER;
283  /* all other flavours have left aligned text */
284  }
285 
286  if (ex_style & WS_EX_RIGHT) dtStyle = DT_RIGHT | (dtStyle & ~(DT_LEFT | DT_CENTER));
287 
288  /* DrawText ignores vertical alignment for multiline text,
289  * but we use these flags to align label manually.
290  */
292  {
293  switch (style & BS_VCENTER)
294  {
295  case BS_TOP: /* DT_TOP is 0 */ break;
296  case BS_BOTTOM: dtStyle |= DT_BOTTOM; break;
297  case BS_VCENTER: /* fall through */
298  default: dtStyle |= DT_VCENTER; break;
299  }
300  }
301  else
302  /* GroupBox's text is always single line and is top aligned. */
303  dtStyle |= DT_SINGLELINE;
304 
305  return dtStyle;
306 }
307 
308 
309 #ifdef __REACTOS__
310 BOOL BUTTON_PaintWithTheme(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hParamDC, LPARAM prfFlag)
311 {
312  DWORD dwStyle;
313  DWORD dwStyleEx;
314  DWORD type;
315  UINT dtFlags;
316  ButtonState drawState;
318 
319  /* Don't draw with themes on a button with BS_ICON or BS_BITMAP */
320  if (infoPtr->u.image != 0)
321  return FALSE;
322 
323  dwStyle = GetWindowLongW(infoPtr->hwnd, GWL_STYLE);
324  type = get_button_type(dwStyle);
325 
326  if (type != BS_PUSHBUTTON && type != BS_DEFPUSHBUTTON && (dwStyle & BS_PUSHLIKE))
328 
330  if (!paint)
331  return FALSE;
332 
333  dwStyleEx = GetWindowLongW(infoPtr->hwnd, GWL_EXSTYLE);
334  dtFlags = BUTTON_BStoDT(dwStyle, dwStyleEx);
335 
336  if(dwStyle & WS_DISABLED)
337  drawState = STATE_DISABLED;
338  else if(infoPtr->state & BST_PUSHED)
339  drawState = STATE_PRESSED;
340  else if ((dwStyle & BS_PUSHLIKE) && (infoPtr->state & (BST_CHECKED|BST_INDETERMINATE)))
341  drawState = STATE_PRESSED;
342  else if(infoPtr->state & BST_HOT)
343  drawState = STATE_HOT;
344  else if((infoPtr->state & BST_FOCUS) || (dwStyle & BS_DEFPUSHBUTTON))
345  drawState = STATE_DEFAULTED;
346  else
347  drawState = STATE_NORMAL;
348 
350  {
351  HDC hdc;
352  HBITMAP hbmp;
353  RECT rc;
354 
355  GetClientRect(infoPtr->hwnd, &rc);
356  hdc = CreateCompatibleDC(hParamDC);
357  hbmp = CreateCompatibleBitmap(hParamDC, rc.right, rc.bottom);
358  if (hdc && hbmp)
359  {
361 
362  paint(theme, infoPtr, hdc, drawState, dtFlags, infoPtr->state & BST_FOCUS, prfFlag);
363 
364  BitBlt(hParamDC, 0, 0, rc.right, rc.bottom, hdc, 0, 0, SRCCOPY);
366  DeleteDC(hdc);
367  return TRUE;
368  }
369  else
370  {
371  ERR("Failed to create DC and bitmap for double buffering\n");
372  if (hbmp)
374  if (hdc)
375  DeleteDC(hdc);
376  }
377  }
378 
379  paint(theme, infoPtr, hParamDC, drawState, dtFlags, infoPtr->state & BST_FOCUS, prfFlag);
380  return TRUE;
381 }
382 
383 /* paint a button of any type */
384 static inline void paint_button( BUTTON_INFO *infoPtr, LONG style, UINT action )
385 {
386  HTHEME theme = GetWindowTheme(infoPtr->hwnd);
387  RECT rc;
388  HDC hdc = GetDC( infoPtr->hwnd );
389  /* GetDC appears to give a dc with a clip rect that includes the whoe parent, not sure if it is correct or not. */
390  GetClientRect(infoPtr->hwnd, &rc);
391  IntersectClipRect (hdc, rc.left, rc. top, rc.right, rc.bottom);
392  if (theme && BUTTON_PaintWithTheme(theme, infoPtr, hdc, 0))
393  {
394  ReleaseDC( infoPtr->hwnd, hdc );
395  return;
396  }
397  if (btnPaintFunc[style] && IsWindowVisible(infoPtr->hwnd))
398  {
399  btnPaintFunc[style]( infoPtr, hdc, action );
400  }
401  ReleaseDC( infoPtr->hwnd, hdc );
402 }
403 
404 BOOL BUTTON_GetIdealSize(BUTTON_INFO *infoPtr, HTHEME theme, SIZE* psize)
405 {
406  HDC hdc;
407  WCHAR *text;
408  HFONT hFont = 0, hPrevFont = 0;
409  SIZE TextSize, ImageSize, ButtonSize;
410  BOOL ret = FALSE;
411  LOGFONTW logfont = {0};
412 
413  text = get_button_text(infoPtr);
414  hdc = GetDC(infoPtr->hwnd);
415  if (!text || !hdc || !text[0])
416  goto cleanup;
417 
418  /* FIXME : Should use GetThemeTextExtent but unfortunately uses DrawTextW which is broken */
419  if (theme)
420  {
421  HRESULT hr = GetThemeFont(theme, hdc, BP_PUSHBUTTON, PBS_NORMAL, TMT_FONT, &logfont);
422  if(SUCCEEDED(hr))
423  {
424  hFont = CreateFontIndirectW(&logfont);
425  if(hFont)
426  hPrevFont = SelectObject( hdc, hFont );
427  }
428  }
429  else
430  {
431  if (infoPtr->font)
432  hPrevFont = SelectObject( hdc, infoPtr->font );
433  }
434 
435  GetTextExtentPoint32W(hdc, text, wcslen(text), &TextSize);
436 
437  if (logfont.lfHeight == -1 && logfont.lfWidth == 0 && wcscmp(logfont.lfFaceName, L"Arial") == 0 && wcsicmp(text, L"Start") == 0)
438  {
439  TextSize.cx = 5;
440  TextSize.cy = 4;
441  }
442 
443  if (hPrevFont)
444  SelectObject( hdc, hPrevFont );
445 
446  TextSize.cy += infoPtr->rcTextMargin.top + infoPtr->rcTextMargin.bottom;
447  TextSize.cx += infoPtr->rcTextMargin.left + infoPtr->rcTextMargin.right;
448 
449  if (infoPtr->imlData.himl && ImageList_GetIconSize(infoPtr->imlData.himl, &ImageSize.cx, &ImageSize.cy))
450  {
451  ImageSize.cx += infoPtr->imlData.margin.left + infoPtr->imlData.margin.right;
452  ImageSize.cy += infoPtr->imlData.margin.top + infoPtr->imlData.margin.bottom;
453  }
454  else
455  {
456  ImageSize.cx = ImageSize.cy = 0;
457  }
458 
459  if (theme)
460  {
461  RECT rcContents = {0};
462  RECT rcButtonExtent = {0};
463  rcContents.right = ImageSize.cx + TextSize.cx;
464  rcContents.bottom = max(ImageSize.cy, TextSize.cy);
465  GetThemeBackgroundExtent(theme, hdc, BP_PUSHBUTTON, PBS_NORMAL, &rcContents, &rcButtonExtent);
466  ButtonSize.cx = rcButtonExtent.right - rcButtonExtent.left;
467  ButtonSize.cy = rcButtonExtent.bottom - rcButtonExtent.top;
468  }
469  else
470  {
471  ButtonSize.cx = ImageSize.cx + TextSize.cx + 5;
472  ButtonSize.cy = max(ImageSize.cy, TextSize.cy + 7);
473  }
474 
475  *psize = ButtonSize;
476  ret = TRUE;
477 
478 cleanup:
479  if (hFont)
481  if (text)
482  HeapFree( GetProcessHeap(), 0, text );
483  if (hdc)
484  ReleaseDC(infoPtr->hwnd, hdc);
485 
486  return ret;
487 }
488 
489 BOOL BUTTON_DrawIml(HDC hDC, const BUTTON_IMAGELIST *pimlData, RECT *prc, BOOL bOnlyCalc, int index)
490 {
491  SIZE ImageSize;
492  int left, top, count;
493 
494  if (!pimlData->himl)
495  return FALSE;
496 
497  if (!ImageList_GetIconSize(pimlData->himl, &ImageSize.cx, &ImageSize.cy))
498  return FALSE;
499 
500  if (pimlData->uAlign == BUTTON_IMAGELIST_ALIGN_LEFT)
501  {
502  left = prc->left + pimlData->margin.left;
503  top = prc->top + (prc->bottom - prc->top - ImageSize.cy) / 2;
504  prc->left = left + pimlData->margin.right + ImageSize.cx;
505  }
506  else if (pimlData->uAlign == BUTTON_IMAGELIST_ALIGN_RIGHT)
507  {
508  left = prc->right - pimlData->margin.right - ImageSize.cx;
509  top = prc->top + (prc->bottom - prc->top - ImageSize.cy) / 2;
510  prc->right = left - pimlData->margin.left;
511  }
512  else if (pimlData->uAlign == BUTTON_IMAGELIST_ALIGN_TOP)
513  {
514  left = prc->left + (prc->right - prc->left - ImageSize.cx) / 2;
515  top = prc->top + pimlData->margin.top;
516  prc->top = top + ImageSize.cy + pimlData->margin.bottom;
517  }
518  else if (pimlData->uAlign == BUTTON_IMAGELIST_ALIGN_BOTTOM)
519  {
520  left = prc->left + (prc->right - prc->left - ImageSize.cx) / 2;
521  top = prc->bottom - pimlData->margin.bottom - ImageSize.cy;
522  prc->bottom = top - pimlData->margin.top;
523  }
524  else if (pimlData->uAlign == BUTTON_IMAGELIST_ALIGN_CENTER)
525  {
526  left = prc->left + (prc->right - prc->left - ImageSize.cx) / 2;
527  top = prc->top + (prc->bottom - prc->top - ImageSize.cy) / 2;
528  }
529 
530  if (bOnlyCalc)
531  return TRUE;
532 
533  count = ImageList_GetImageCount(pimlData->himl);
534 
535  if (count == 1)
536  index = 0;
537  else if (index >= count)
538  return TRUE;
539 
540  ImageList_Draw(pimlData->himl, index, hDC, left, top, 0);
541 
542  return TRUE;
543 }
544 
545 DWORD BUTTON_SendCustomDraw(const BUTTON_INFO *infoPtr, HDC hDC, DWORD dwDrawStage, RECT* prc)
546 {
547  NMCUSTOMDRAW nmcs;
548 
549  nmcs.hdr.hwndFrom = infoPtr->hwnd;
550  nmcs.hdr.idFrom = GetWindowLongPtrW (infoPtr->hwnd, GWLP_ID);
551  nmcs.hdr.code = NM_CUSTOMDRAW ;
552  nmcs.dwDrawStage = dwDrawStage;
553  nmcs.hdc = hDC;
554  nmcs.rc = *prc;
555  nmcs.dwItemSpec = 0;
556  nmcs.uItemState = 0;
557  nmcs.lItemlParam = 0;
558  if(!IsWindowEnabled(infoPtr->hwnd))
559  nmcs.uItemState |= CDIS_DISABLED;
560  if (infoPtr->state & (BST_CHECKED | BST_INDETERMINATE))
561  nmcs.uItemState |= CDIS_CHECKED;
562  if (infoPtr->state & BST_FOCUS)
563  nmcs.uItemState |= CDIS_FOCUS;
564  if (infoPtr->state & BST_PUSHED)
565  nmcs.uItemState |= CDIS_SELECTED;
566  if (!(infoPtr->ui_state & UISF_HIDEACCEL))
568 
569  return SendMessageW(GetParent(infoPtr->hwnd), WM_NOTIFY, nmcs.hdr.idFrom, (LPARAM)&nmcs);
570 }
571 
572 /* Retrieve the UI state for the control */
573 static BOOL button_update_uistate(BUTTON_INFO *infoPtr)
574 {
575  LONG flags = DefWindowProcW(infoPtr->hwnd, WM_QUERYUISTATE, 0, 0);
576 
577  if (infoPtr->ui_state != flags)
578  {
579  infoPtr->ui_state = flags;
580  return TRUE;
581  }
582 
583  return FALSE;
584 }
585 #endif
586 
588 {
589  BUTTON_INFO *infoPtr = (BUTTON_INFO *)GetWindowLongPtrW(hWnd, 0);
590  RECT rect;
591  POINT pt;
593  UINT btn_type = get_button_type( style );
594  LONG state, new_state;
595  HANDLE oldHbitmap;
596  HTHEME theme;
597 
598  if (!IsWindow( hWnd )) return 0;
599 
600  if (!infoPtr && (uMsg != WM_NCCREATE))
601  return DefWindowProcW(hWnd, uMsg, wParam, lParam);
602 
603  pt.x = (short)LOWORD(lParam);
604  pt.y = (short)HIWORD(lParam);
605 
606  switch (uMsg)
607  {
608  case WM_GETDLGCODE:
609  switch(btn_type)
610  {
611  case BS_COMMANDLINK:
612  case BS_USERBUTTON:
614  case BS_DEFCOMMANDLINK:
616  case BS_RADIOBUTTON:
618  case BS_GROUPBOX: return DLGC_STATIC;
621  default: return DLGC_BUTTON;
622  }
623 
624  case WM_ENABLE:
625 #ifndef __REACTOS__
626  theme = GetWindowTheme( hWnd );
627  if (theme)
629  else
630 #endif
631  paint_button( infoPtr, btn_type, ODA_DRAWENTIRE );
632  break;
633 
634  case WM_NCCREATE:
635  infoPtr = heap_alloc_zero( sizeof(*infoPtr) );
636  SetWindowLongPtrW( hWnd, 0, (LONG_PTR)infoPtr );
637  infoPtr->hwnd = hWnd;
638 #ifdef __REACTOS__
639  SetRect(&infoPtr->rcTextMargin, 1,1,1,1);
640 #endif
641  return DefWindowProcW(hWnd, uMsg, wParam, lParam);
642 
643  case WM_NCDESTROY:
644  SetWindowLongPtrW( hWnd, 0, 0 );
645  heap_free(infoPtr);
646  break;
647 
648  case WM_CREATE:
649  if (btn_type >= MAX_BTN_TYPE)
650  return -1; /* abort */
651 
652  /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
653  if (btn_type == BS_USERBUTTON )
654  {
657  }
658  infoPtr->state = BST_UNCHECKED;
660  return 0;
661 
662  case WM_DESTROY:
663  theme = GetWindowTheme( hWnd );
664  CloseThemeData( theme );
665  break;
666 
667  case WM_THEMECHANGED:
668  theme = GetWindowTheme( hWnd );
669  CloseThemeData( theme );
671 #ifdef __REACTOS__
673 #endif
674  break;
675 
676  case WM_ERASEBKGND:
677  if (btn_type == BS_OWNERDRAW)
678  {
679  HDC hdc = (HDC)wParam;
680  RECT rc;
681  HBRUSH hBrush;
683  if (!parent) parent = hWnd;
684  hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
685  if (!hBrush) /* did the app forget to call defwindowproc ? */
686  hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
687  (WPARAM)hdc, (LPARAM)hWnd);
688  GetClientRect(hWnd, &rc);
689  FillRect(hdc, &rc, hBrush);
690  }
691  return 1;
692 
693  case WM_PRINTCLIENT:
694  case WM_PAINT:
695  {
696  PAINTSTRUCT ps;
697  HDC hdc;
698 
699  theme = GetWindowTheme( hWnd );
700  hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
701 
702 #ifdef __REACTOS__
703  if (theme && BUTTON_PaintWithTheme(theme, infoPtr, hdc, uMsg == WM_PRINTCLIENT ? lParam : 0))
704  {
705  if ( !wParam ) EndPaint( hWnd, &ps );
706  return 0;
707  }
708 #else
709  if (theme && btnThemedPaintFunc[btn_type])
710  {
711  ButtonState drawState;
712  UINT dtflags;
713 
714  if (IsWindowEnabled( hWnd ))
715  {
716  if (infoPtr->state & BST_PUSHED) drawState = STATE_PRESSED;
717  else if (infoPtr->state & BST_HOT) drawState = STATE_HOT;
718  else if (infoPtr->state & BST_FOCUS) drawState = STATE_DEFAULTED;
719  else drawState = STATE_NORMAL;
720  }
721  else
722  drawState = STATE_DISABLED;
723 
725  btnThemedPaintFunc[btn_type](theme, infoPtr, hdc, drawState, dtflags, infoPtr->state & BST_FOCUS);
726  }
727 #endif
728  else if (btnPaintFunc[btn_type])
729  {
730  int nOldMode = SetBkMode( hdc, OPAQUE );
731  btnPaintFunc[btn_type]( infoPtr, hdc, ODA_DRAWENTIRE );
732  SetBkMode(hdc, nOldMode); /* reset painting mode */
733  }
734 
735  if ( !wParam ) EndPaint( hWnd, &ps );
736  break;
737  }
738 
739  case WM_KEYDOWN:
740  if (wParam == VK_SPACE)
741  {
743  infoPtr->state |= BUTTON_BTNPRESSED;
744  SetCapture( hWnd );
745  }
746  break;
747 
748  case WM_LBUTTONDBLCLK:
749  if(style & BS_NOTIFY ||
750  btn_type == BS_RADIOBUTTON ||
751  btn_type == BS_USERBUTTON ||
752  btn_type == BS_OWNERDRAW)
753  {
755  break;
756  }
757  /* fall through */
758  case WM_LBUTTONDOWN:
759  SetCapture( hWnd );
760  SetFocus( hWnd );
761  infoPtr->state |= BUTTON_BTNPRESSED;
763  break;
764 
765  case WM_KEYUP:
766  if (wParam != VK_SPACE)
767  break;
768  /* fall through */
769  case WM_LBUTTONUP:
770  state = infoPtr->state;
771  if (!(state & BUTTON_BTNPRESSED)) break;
772  infoPtr->state &= BUTTON_NSTATES;
773  if (!(state & BST_PUSHED))
774  {
775  ReleaseCapture();
776  break;
777  }
779  GetClientRect( hWnd, &rect );
780  if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
781  {
782  switch(btn_type)
783  {
784  case BS_AUTOCHECKBOX:
785  SendMessageW( hWnd, BM_SETCHECK, !(infoPtr->state & BST_CHECKED), 0 );
786  break;
787  case BS_AUTORADIOBUTTON:
788 #ifdef __REACTOS__
790 #else
792 #endif
793  break;
794  case BS_AUTO3STATE:
795  SendMessageW( hWnd, BM_SETCHECK, (infoPtr->state & BST_INDETERMINATE) ? 0 :
796  ((infoPtr->state & 3) + 1), 0 );
797  break;
798  }
799 #ifdef __REACTOS__
800  // Fix CORE-10194, Notify parent after capture is released.
801  ReleaseCapture();
803 #else
805  ReleaseCapture();
806 #endif
807  }
808  else
809  {
810  ReleaseCapture();
811  }
812 
813  break;
814 
815  case WM_CAPTURECHANGED:
816  TRACE("WM_CAPTURECHANGED %p\n", hWnd);
817  if (hWnd == (HWND)lParam) break;
818  if (infoPtr->state & BUTTON_BTNPRESSED)
819  {
820  infoPtr->state &= BUTTON_NSTATES;
821  if (infoPtr->state & BST_PUSHED)
823  }
824  break;
825 
826  case WM_MOUSEMOVE:
827  {
829  mouse_event.cbSize = sizeof(TRACKMOUSEEVENT);
830  mouse_event.dwFlags = TME_QUERY;
831 
832 #ifdef __REACTOS__
833  if ((infoPtr->state & BST_HOT) == 0)
834  {
835  NMBCHOTITEM nmhotitem;
836 
837  infoPtr->state |= BST_HOT;
838 
839  nmhotitem.hdr.hwndFrom = hWnd;
840  nmhotitem.hdr.idFrom = GetWindowLongPtrW (hWnd, GWLP_ID);
841  nmhotitem.hdr.code = BCN_HOTITEMCHANGE;
842  nmhotitem.dwFlags = HICF_ENTERING;
843  SendMessageW(GetParent(hWnd), WM_NOTIFY, nmhotitem.hdr.idFrom, (LPARAM)&nmhotitem);
844 
846  }
847 
848  if(!TrackMouseEvent(&mouse_event) || !(mouse_event.dwFlags&TME_LEAVE))
849  {
850  mouse_event.dwFlags = TME_LEAVE;
851  mouse_event.hwndTrack = hWnd;
852  mouse_event.dwHoverTime = 1;
854  }
855  break;
856 #else
857 
858  if (!TrackMouseEvent(&mouse_event) || !(mouse_event.dwFlags & (TME_HOVER | TME_LEAVE)))
859  {
860  mouse_event.dwFlags = TME_HOVER | TME_LEAVE;
861  mouse_event.hwndTrack = hWnd;
862  mouse_event.dwHoverTime = 1;
864  }
865 
866  if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
867  {
868  GetClientRect( hWnd, &rect );
870  }
871  break;
872 #endif
873  }
874 
875 #ifndef __REACTOS__
876  case WM_MOUSEHOVER:
877  {
878  infoPtr->state |= BST_HOT;
880  break;
881  }
882 #endif
883 
884  case WM_MOUSELEAVE:
885  {
886 #ifdef __REACTOS__
887  if (infoPtr->state & BST_HOT)
888  {
889  NMBCHOTITEM nmhotitem;
890 
891  infoPtr->state &= ~BST_HOT;
892 
893  nmhotitem.hdr.hwndFrom = hWnd;
894  nmhotitem.hdr.idFrom = GetWindowLongPtrW (hWnd, GWLP_ID);
895  nmhotitem.hdr.code = BCN_HOTITEMCHANGE;
896  nmhotitem.dwFlags = HICF_LEAVING;
897  SendMessageW(GetParent(hWnd), WM_NOTIFY, nmhotitem.hdr.idFrom, (LPARAM)&nmhotitem);
898 
900  }
901  break;
902 #else
903  infoPtr->state &= ~BST_HOT;
905  break;
906 #endif
907  }
908 
909 #ifdef __REACTOS__
910  case BCM_GETTEXTMARGIN:
911  {
912  RECT* prc = (RECT*)lParam;
913  if (!prc)
914  return FALSE;
915  *prc = infoPtr->rcTextMargin;
916  return TRUE;
917  }
918  case BCM_SETTEXTMARGIN:
919  {
920  RECT* prc = (RECT*)lParam;
921  if (!prc)
922  return FALSE;
923  infoPtr->rcTextMargin = *prc;
924  return TRUE;
925  }
926  case BCM_SETIMAGELIST:
927  {
928  BUTTON_IMAGELIST * pimldata = (BUTTON_IMAGELIST *)lParam;
929  if (!pimldata || !pimldata->himl)
930  return FALSE;
931  infoPtr->imlData = *pimldata;
932  return TRUE;
933  }
934  case BCM_GETIMAGELIST:
935  {
936  BUTTON_IMAGELIST * pimldata = (BUTTON_IMAGELIST *)lParam;
937  if (!pimldata)
938  return FALSE;
939  *pimldata = infoPtr->imlData;
940  return TRUE;
941  }
942  case BCM_GETIDEALSIZE:
943  {
944  HTHEME theme = GetWindowTheme(hWnd);
945  BOOL ret = FALSE;
946  SIZE* pSize = (SIZE*)lParam;
947 
948  if (!pSize)
949  {
950  return FALSE;
951  }
952 
953  if (btn_type == BS_PUSHBUTTON ||
954  btn_type == BS_DEFPUSHBUTTON ||
955  btn_type == BS_USERBUTTON)
956  {
957  ret = BUTTON_GetIdealSize(infoPtr, theme, pSize);
958  }
959 
960  if (!ret)
961  {
963  pSize->cx = rect.right;
964  pSize->cy = rect.bottom;
965  }
966 
967  return TRUE;
968  }
969 #endif
970 
971  case WM_SETTEXT:
972  {
973  /* Clear an old text here as Windows does */
974 #ifdef __REACTOS__
975 //
976 // ReactOS Note :
977 // wine Bug: http://bugs.winehq.org/show_bug.cgi?id=25790
978 // Patch: http://source.winehq.org/patches/data/70889
979 // By: Alexander LAW, Replicate Windows behavior of WM_SETTEXT handler regarding WM_CTLCOLOR*
980 //
981  if (style & WS_VISIBLE)
982 #else
983  if (IsWindowVisible(hWnd))
984 #endif
985  {
986  HDC hdc = GetDC(hWnd);
987  HBRUSH hbrush;
988  RECT client, rc;
990  UINT message = (btn_type == BS_PUSHBUTTON ||
991  btn_type == BS_DEFPUSHBUTTON ||
992  btn_type == BS_USERBUTTON ||
993  btn_type == BS_OWNERDRAW) ?
995 
996  if (!parent) parent = hWnd;
997  hbrush = (HBRUSH)SendMessageW(parent, message,
998  (WPARAM)hdc, (LPARAM)hWnd);
999  if (!hbrush) /* did the app forget to call DefWindowProc ? */
1000  hbrush = (HBRUSH)DefWindowProcW(parent, message,
1001  (WPARAM)hdc, (LPARAM)hWnd);
1002 
1004  rc = client;
1005  /* FIXME: check other BS_* handlers */
1006  if (btn_type == BS_GROUPBOX)
1007  InflateRect(&rc, -7, 1); /* GB_Paint does this */
1008  BUTTON_CalcLabelRect(infoPtr, hdc, &rc);
1009  /* Clip by client rect bounds */
1010  if (rc.right > client.right) rc.right = client.right;
1011  if (rc.bottom > client.bottom) rc.bottom = client.bottom;
1012  FillRect(hdc, &rc, hbrush);
1013  ReleaseDC(hWnd, hdc);
1014  }
1015 
1017  if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
1019  else
1020  paint_button( infoPtr, btn_type, ODA_DRAWENTIRE );
1021  return 1; /* success. FIXME: check text length */
1022  }
1023 
1024  case WM_SETFONT:
1025  infoPtr->font = (HFONT)wParam;
1027  break;
1028 
1029  case WM_GETFONT:
1030  return (LRESULT)infoPtr->font;
1031 
1032  case WM_SETFOCUS:
1033  TRACE("WM_SETFOCUS %p\n",hWnd);
1034  infoPtr->state |= BST_FOCUS;
1035 #ifdef __REACTOS__
1036  if (btn_type != BS_OWNERDRAW)
1038  else
1039 #endif
1040  paint_button( infoPtr, btn_type, ODA_FOCUS );
1041  if (style & BS_NOTIFY)
1043  break;
1044 
1045  case WM_KILLFOCUS:
1046  TRACE("WM_KILLFOCUS %p\n",hWnd);
1047  infoPtr->state &= ~BST_FOCUS;
1048 #ifndef __REACTOS__
1049  paint_button( infoPtr, btn_type, ODA_FOCUS );
1050 #endif
1051 
1052  if ((infoPtr->state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
1053  ReleaseCapture();
1054  if (style & BS_NOTIFY)
1056 
1058  break;
1059 
1060  case WM_SYSCOLORCHANGE:
1062  break;
1063 
1064  case BM_SETSTYLE:
1065  btn_type = wParam & BS_TYPEMASK;
1066  style = (style & ~BS_TYPEMASK) | btn_type;
1068 
1069  /* Only redraw if lParam flag is set.*/
1070  if (lParam)
1072 
1073  break;
1074 
1075  case BM_CLICK:
1076 #ifdef __REACTOS__
1077  /* Fix for core CORE-6024 */
1078  if (infoPtr->state & BUTTON_BMCLICK)
1079  break;
1080  infoPtr->state |= BUTTON_BMCLICK;
1081 #endif
1082  SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
1083  SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
1084 #ifdef __REACTOS__
1085  infoPtr->state &= ~BUTTON_BMCLICK;
1086 #endif
1087  break;
1088 
1089  case BM_SETIMAGE:
1090  /* Check that image format matches button style */
1091  switch (style & (BS_BITMAP|BS_ICON))
1092  {
1093  case BS_BITMAP:
1094  if (wParam != IMAGE_BITMAP) return 0;
1095  break;
1096  case BS_ICON:
1097  if (wParam != IMAGE_ICON) return 0;
1098  break;
1099  default:
1100  return 0;
1101  }
1102  oldHbitmap = infoPtr->u.image;
1103  infoPtr->u.image = (HANDLE)lParam;
1105  return (LRESULT)oldHbitmap;
1106 
1107  case BM_GETIMAGE:
1108  return (LRESULT)infoPtr->u.image;
1109 
1110  case BM_GETCHECK:
1111  return infoPtr->state & 3;
1112 
1113  case BM_SETCHECK:
1114  if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
1115  if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
1116  {
1119  }
1120  if ((infoPtr->state & 3) != wParam)
1121  {
1122  infoPtr->state = (infoPtr->state & ~3) | wParam;
1124  }
1125 #ifndef __REACTOS__
1126  if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BST_CHECKED) && (style & WS_CHILD))
1128 #endif
1129  break;
1130 
1131  case BM_GETSTATE:
1132  return infoPtr->state;
1133 
1134  case BM_SETSTATE:
1135  state = infoPtr->state;
1136  new_state = wParam ? BST_PUSHED : 0;
1137 
1138  if ((state ^ new_state) & BST_PUSHED)
1139  {
1140  if (wParam)
1141  state |= BST_PUSHED;
1142  else
1143  state &= ~BST_PUSHED;
1144 
1145  if (btn_type == BS_USERBUTTON)
1147  infoPtr->state = state;
1148 
1150  }
1151  break;
1152 
1153 #ifdef __REACTOS__
1154  case WM_UPDATEUISTATE:
1155  DefWindowProcW(hWnd, uMsg, wParam, lParam);
1156 
1157  if (button_update_uistate(infoPtr))
1158  paint_button( infoPtr, btn_type, ODA_DRAWENTIRE );
1159  break;
1160 #endif
1161 
1162  case WM_NCHITTEST:
1163  if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
1164  /* fall through */
1165  default:
1166  return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1167  }
1168  return 0;
1169 }
1170 
1171 /**********************************************************************
1172  * BUTTON_CalcLabelRect
1173  *
1174  * Calculates label's rectangle depending on button style.
1175  *
1176  * Returns flags to be passed to DrawText.
1177  * Calculated rectangle doesn't take into account button state
1178  * (pushed, etc.). If there is nothing to draw (no text/image) output
1179  * rectangle is empty, and return value is (UINT)-1.
1180  */
1181 static UINT BUTTON_CalcLabelRect(const BUTTON_INFO *infoPtr, HDC hdc, RECT *rc)
1182 {
1183  LONG style = GetWindowLongW( infoPtr->hwnd, GWL_STYLE );
1184  LONG ex_style = GetWindowLongW( infoPtr->hwnd, GWL_EXSTYLE );
1185  WCHAR *text;
1186  ICONINFO iconInfo;
1187  BITMAP bm;
1188  UINT dtStyle = BUTTON_BStoDT( style, ex_style );
1189  RECT r = *rc;
1190  INT n;
1191 #ifdef __REACTOS__
1192  BOOL bHasIml = BUTTON_DrawIml(hdc, &infoPtr->imlData, &r, TRUE, 0);
1193 #endif
1194 
1195  /* Calculate label rectangle according to label type */
1196  switch (style & (BS_ICON|BS_BITMAP))
1197  {
1198  case BS_TEXT:
1199  {
1200  HFONT hFont, hPrevFont = 0;
1201 
1202  if (!(text = get_button_text( infoPtr ))) goto empty_rect;
1203  if (!text[0])
1204  {
1205  heap_free( text );
1206  goto empty_rect;
1207  }
1208 
1209  if ((hFont = infoPtr->font)) hPrevFont = SelectObject( hdc, hFont );
1210  DrawTextW(hdc, text, -1, &r, dtStyle | DT_CALCRECT);
1211  if (hPrevFont) SelectObject( hdc, hPrevFont );
1212  heap_free( text );
1213 #ifdef __REACTOS__
1214  if (infoPtr->ui_state & UISF_HIDEACCEL)
1215  dtStyle |= DT_HIDEPREFIX;
1216 #endif
1217  break;
1218  }
1219 
1220  case BS_ICON:
1221  if (!GetIconInfo(infoPtr->u.icon, &iconInfo))
1222  goto empty_rect;
1223 
1224  GetObjectW (iconInfo.hbmColor, sizeof(BITMAP), &bm);
1225 
1226  r.right = r.left + bm.bmWidth;
1227  r.bottom = r.top + bm.bmHeight;
1228 
1229  DeleteObject(iconInfo.hbmColor);
1230  DeleteObject(iconInfo.hbmMask);
1231  break;
1232 
1233  case BS_BITMAP:
1234  if (!GetObjectW( infoPtr->u.bitmap, sizeof(BITMAP), &bm))
1235  goto empty_rect;
1236 
1237  r.right = r.left + bm.bmWidth;
1238  r.bottom = r.top + bm.bmHeight;
1239  break;
1240 
1241  default:
1242  empty_rect:
1243 #ifdef __REACTOS__
1244  if (bHasIml)
1245  break;
1246 #endif
1247  rc->right = r.left;
1248  rc->bottom = r.top;
1249  return (UINT)-1;
1250  }
1251 
1252 #ifdef __REACTOS__
1253  if (bHasIml)
1254  {
1255  if (infoPtr->imlData.uAlign == BUTTON_IMAGELIST_ALIGN_LEFT)
1256  r.left = infoPtr->imlData.margin.left;
1257  else if (infoPtr->imlData.uAlign == BUTTON_IMAGELIST_ALIGN_RIGHT)
1258  r.right = infoPtr->imlData.margin.right;
1259  else if (infoPtr->imlData.uAlign == BUTTON_IMAGELIST_ALIGN_TOP)
1260  r.top = infoPtr->imlData.margin.top;
1261  else if (infoPtr->imlData.uAlign == BUTTON_IMAGELIST_ALIGN_BOTTOM)
1262  r.bottom = infoPtr->imlData.margin.bottom;
1263  }
1264 #endif
1265 
1266  /* Position label inside bounding rectangle according to
1267  * alignment flags. (calculated rect is always left-top aligned).
1268  * If label is aligned to any side - shift label in opposite
1269  * direction to leave extra space for focus rectangle.
1270  */
1271  switch (dtStyle & (DT_CENTER|DT_RIGHT))
1272  {
1273  case DT_LEFT: r.left++; r.right++; break;
1274  case DT_CENTER: n = r.right - r.left;
1275  r.left = rc->left + ((rc->right - rc->left) - n) / 2;
1276  r.right = r.left + n; break;
1277  case DT_RIGHT: n = r.right - r.left;
1278  r.right = rc->right - 1;
1279  r.left = r.right - n;
1280  break;
1281  }
1282 
1283  switch (dtStyle & (DT_VCENTER|DT_BOTTOM))
1284  {
1285  case DT_TOP: r.top++; r.bottom++; break;
1286  case DT_VCENTER: n = r.bottom - r.top;
1287 #ifdef __REACTOS__
1288  r.top = rc->top + ((rc->bottom - 1 - rc->top) - n) / 2;
1289 #else
1290  r.top = rc->top + ((rc->bottom - rc->top) - n) / 2;
1291 #endif
1292  r.bottom = r.top + n; break;
1293  case DT_BOTTOM: n = r.bottom - r.top;
1294  r.bottom = rc->bottom - 1;
1295  r.top = r.bottom - n;
1296  break;
1297  }
1298 
1299  *rc = r;
1300  return dtStyle;
1301 }
1302 
1303 
1304 /**********************************************************************
1305  * BUTTON_DrawTextCallback
1306  *
1307  * Callback function used by DrawStateW function.
1308  */
1310 {
1311  RECT rc;
1312 
1313  SetRect(&rc, 0, 0, cx, cy);
1314  DrawTextW(hdc, (LPCWSTR)lp, -1, &rc, (UINT)wp);
1315  return TRUE;
1316 }
1317 
1318 
1319 /**********************************************************************
1320  * BUTTON_DrawLabel
1321  *
1322  * Common function for drawing button label.
1323  */
1324 static void BUTTON_DrawLabel(const BUTTON_INFO *infoPtr, HDC hdc, UINT dtFlags, const RECT *rc)
1325 {
1326  DRAWSTATEPROC lpOutputProc = NULL;
1327  LPARAM lp;
1328  WPARAM wp = 0;
1329  HBRUSH hbr = 0;
1331  LONG state = infoPtr->state;
1332  LONG style = GetWindowLongW( infoPtr->hwnd, GWL_STYLE );
1333  WCHAR *text = NULL;
1334 
1335  /* FIXME: To draw disabled label in Win31 look-and-feel, we probably
1336  * must use DSS_MONO flag and COLOR_GRAYTEXT brush (or maybe DSS_UNION).
1337  * I don't have Win31 on hand to verify that, so I leave it as is.
1338  */
1339 
1340 #ifdef __REACTOS__
1341  RECT rcText = *rc;
1342  BUTTON_DrawIml(hdc, &infoPtr->imlData, &rcText, FALSE, 0);
1343 #endif
1344 
1345  if ((style & BS_PUSHLIKE) && (state & BST_INDETERMINATE))
1346  {
1348  flags |= DSS_MONO;
1349  }
1350 
1351  switch (style & (BS_ICON|BS_BITMAP))
1352  {
1353  case BS_TEXT:
1354  /* DST_COMPLEX -- is 0 */
1355  lpOutputProc = BUTTON_DrawTextCallback;
1356  if (!(text = get_button_text( infoPtr ))) return;
1357  lp = (LPARAM)text;
1358  wp = dtFlags;
1359 #ifdef __REACTOS__
1360  if (dtFlags & DT_HIDEPREFIX)
1361  flags |= DSS_HIDEPREFIX;
1362 #endif
1363  break;
1364 
1365  case BS_ICON:
1366  flags |= DST_ICON;
1367  lp = (LPARAM)infoPtr->u.icon;
1368  break;
1369 
1370  case BS_BITMAP:
1371  flags |= DST_BITMAP;
1372  lp = (LPARAM)infoPtr->u.bitmap;
1373  break;
1374 
1375  default:
1376  return;
1377  }
1378 
1379 #ifdef __REACTOS__
1380  DrawStateW(hdc, hbr, lpOutputProc, lp, wp, rcText.left, rcText.top,
1381  rcText.right - rcText.left, rcText.bottom - rcText.top, flags);
1382 #else
1383  DrawStateW(hdc, hbr, lpOutputProc, lp, wp, rc->left, rc->top,
1384  rc->right - rc->left, rc->bottom - rc->top, flags);
1385 #endif
1386  heap_free( text );
1387 }
1388 
1389 /**********************************************************************
1390  * Push Button Functions
1391  */
1392 static void PB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action )
1393 {
1394  RECT rc, r;
1395  UINT dtFlags, uState;
1396  HPEN hOldPen, hpen;
1397  HBRUSH hOldBrush;
1398  INT oldBkMode;
1399  COLORREF oldTxtColor;
1400  HFONT hFont;
1401  LONG state = infoPtr->state;
1402  LONG style = GetWindowLongW( infoPtr->hwnd, GWL_STYLE );
1403  BOOL pushedState = (state & BST_PUSHED);
1404  HWND parent;
1405  HRGN hrgn;
1406 #ifdef __REACTOS__
1407  DWORD cdrf;
1408 #endif
1409 
1410  GetClientRect( infoPtr->hwnd, &rc );
1411 
1412  /* Send WM_CTLCOLOR to allow changing the font (the colors are fixed) */
1413  if ((hFont = infoPtr->font)) SelectObject( hDC, hFont );
1414  parent = GetParent(infoPtr->hwnd);
1415  if (!parent) parent = infoPtr->hwnd;
1417 
1418  hrgn = set_control_clipping( hDC, &rc );
1419 
1421  hOldPen = SelectObject(hDC, hpen);
1423  oldBkMode = SetBkMode(hDC, TRANSPARENT);
1424 
1425 #ifdef __REACTOS__
1426  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREERASE, &rc);
1427  if (cdrf == CDRF_SKIPDEFAULT)
1428  goto cleanup;
1429 #endif
1430 
1432  {
1433  if (action != ODA_FOCUS)
1434  Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
1435  InflateRect( &rc, -1, -1 );
1436  }
1437 
1438  /* completely skip the drawing if only focus has changed */
1439  if (action == ODA_FOCUS) goto draw_focus;
1440 
1441  uState = DFCS_BUTTONPUSH;
1442 
1443  if (style & BS_FLAT)
1444  uState |= DFCS_MONO;
1445  else if (pushedState)
1446  {
1448  uState |= DFCS_FLAT;
1449  else
1450  uState |= DFCS_PUSHED;
1451  }
1452 
1454  uState |= DFCS_CHECKED;
1455 
1456  DrawFrameControl( hDC, &rc, DFC_BUTTON, uState );
1457 
1458 #ifdef __REACTOS__
1459  if (cdrf == CDRF_NOTIFYPOSTERASE)
1460  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTERASE, &rc);
1461 
1462  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREPAINT, &rc);
1463  if (cdrf == CDRF_SKIPDEFAULT)
1464  goto cleanup;
1465 #endif
1466 
1467  /* draw button label */
1468  r = rc;
1469  dtFlags = BUTTON_CalcLabelRect(infoPtr, hDC, &r);
1470 
1471  if (dtFlags == (UINT)-1L)
1472  goto cleanup;
1473 
1474  if (pushedState)
1475  OffsetRect(&r, 1, 1);
1476 
1477  oldTxtColor = SetTextColor( hDC, GetSysColor(COLOR_BTNTEXT) );
1478 
1479  BUTTON_DrawLabel(infoPtr, hDC, dtFlags, &r);
1480 
1481  SetTextColor( hDC, oldTxtColor );
1482 
1483 #ifdef __REACTOS__
1484  if (cdrf == CDRF_NOTIFYPOSTPAINT)
1485  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTPAINT, &rc);
1486 #endif
1487 
1488 draw_focus:
1489  if (action == ODA_FOCUS || (state & BST_FOCUS))
1490  {
1491 #ifdef __REACTOS__
1492  if (!(infoPtr->ui_state & UISF_HIDEFOCUS))
1493  {
1494 #endif
1495  InflateRect( &rc, -2, -2 );
1496  DrawFocusRect( hDC, &rc );
1497 #ifdef __REACTOS__
1498  }
1499 #endif
1500  }
1501 
1502  cleanup:
1503  SelectObject( hDC, hOldPen );
1504  SelectObject( hDC, hOldBrush );
1505  SetBkMode(hDC, oldBkMode);
1506  SelectClipRgn( hDC, hrgn );
1507  if (hrgn) DeleteObject( hrgn );
1508  DeleteObject( hpen );
1509 }
1510 
1511 /**********************************************************************
1512  * Check Box & Radio Button Functions
1513  */
1514 
1515 static void CB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action )
1516 {
1517  RECT rbox, rtext, client;
1518  HBRUSH hBrush;
1519  int delta, text_offset, checkBoxWidth, checkBoxHeight;
1520  UINT dtFlags;
1521  HFONT hFont;
1522  LONG state = infoPtr->state;
1523  LONG style = GetWindowLongW( infoPtr->hwnd, GWL_STYLE );
1524  LONG ex_style = GetWindowLongW( infoPtr->hwnd, GWL_EXSTYLE );
1525  HWND parent;
1526  HRGN hrgn;
1527 
1528  if (style & BS_PUSHLIKE)
1529  {
1530  PB_Paint( infoPtr, hDC, action );
1531  return;
1532  }
1533 
1534  GetClientRect(infoPtr->hwnd, &client);
1535  rbox = rtext = client;
1536 
1537  checkBoxWidth = 12 * GetDeviceCaps( hDC, LOGPIXELSX ) / 96 + 1;
1538  checkBoxHeight = 12 * GetDeviceCaps( hDC, LOGPIXELSY ) / 96 + 1;
1539 
1540  if ((hFont = infoPtr->font)) SelectObject( hDC, hFont );
1541  GetCharWidthW( hDC, '0', '0', &text_offset );
1542  text_offset /= 2;
1543 
1544  parent = GetParent(infoPtr->hwnd);
1545  if (!parent) parent = infoPtr->hwnd;
1546  hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1547  if (!hBrush) /* did the app forget to call defwindowproc ? */
1548  hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1550 
1551  if (style & BS_LEFTTEXT || ex_style & WS_EX_RIGHT)
1552  {
1553  rtext.right -= checkBoxWidth + text_offset;
1554  rbox.left = rbox.right - checkBoxWidth;
1555  }
1556  else
1557  {
1558  rtext.left += checkBoxWidth + text_offset;
1559  rbox.right = checkBoxWidth;
1560  }
1561 
1562  /* Since WM_ERASEBKGND does nothing, first prepare background */
1563  if (action == ODA_SELECT) FillRect( hDC, &rbox, hBrush );
1564  if (action == ODA_DRAWENTIRE) FillRect( hDC, &client, hBrush );
1565 
1566  /* Draw label */
1567  client = rtext;
1568  dtFlags = BUTTON_CalcLabelRect(infoPtr, hDC, &rtext);
1569 
1570  /* Only adjust rbox when rtext is valid */
1571  if (dtFlags != (UINT)-1L)
1572  {
1573  rbox.top = rtext.top;
1574  rbox.bottom = rtext.bottom;
1575  }
1576 
1577  /* Draw the check-box bitmap */
1578  if (action == ODA_DRAWENTIRE || action == ODA_SELECT)
1579  {
1580  UINT flags;
1581 
1582  if ((get_button_type(style) == BS_RADIOBUTTON) ||
1585  else flags = DFCS_BUTTONCHECK;
1586 
1588  if (state & BST_PUSHED) flags |= DFCS_PUSHED;
1589 
1591 
1592  /* rbox must have the correct height */
1593  delta = rbox.bottom - rbox.top - checkBoxHeight;
1594 
1595  if (style & BS_TOP) {
1596  if (delta > 0) {
1597  rbox.bottom = rbox.top + checkBoxHeight;
1598  } else {
1599  rbox.top -= -delta/2 + 1;
1600  rbox.bottom = rbox.top + checkBoxHeight;
1601  }
1602  } else if (style & BS_BOTTOM) {
1603  if (delta > 0) {
1604  rbox.top = rbox.bottom - checkBoxHeight;
1605  } else {
1606  rbox.bottom += -delta/2 + 1;
1607  rbox.top = rbox.bottom - checkBoxHeight;
1608  }
1609  } else { /* Default */
1610  if (delta > 0) {
1611  int ofs = (delta / 2);
1612  rbox.bottom -= ofs + 1;
1613  rbox.top = rbox.bottom - checkBoxHeight;
1614  } else if (delta < 0) {
1615  int ofs = (-delta / 2);
1616  rbox.top -= ofs + 1;
1617  rbox.bottom = rbox.top + checkBoxHeight;
1618  }
1619  }
1620 
1621  DrawFrameControl( hDC, &rbox, DFC_BUTTON, flags );
1622  }
1623 
1624  if (dtFlags == (UINT)-1L) /* Noting to draw */
1625  return;
1626 
1627  if (action == ODA_DRAWENTIRE)
1628  BUTTON_DrawLabel(infoPtr, hDC, dtFlags, &rtext);
1629 
1630  /* ... and focus */
1631  if (action == ODA_FOCUS || (state & BST_FOCUS))
1632  {
1633  rtext.left--;
1634  rtext.right++;
1635  IntersectRect(&rtext, &rtext, &client);
1636  DrawFocusRect( hDC, &rtext );
1637  }
1638  SelectClipRgn( hDC, hrgn );
1639  if (hrgn) DeleteObject( hrgn );
1640 }
1641 
1642 
1643 /**********************************************************************
1644  * BUTTON_CheckAutoRadioButton
1645  *
1646  * hwnd is checked, uncheck every other auto radio button in group
1647  */
1649 {
1650  HWND parent, sibling, start;
1651 
1652  parent = GetParent(hwnd);
1653  /* make sure that starting control is not disabled or invisible */
1654 #ifdef __REACTOS__
1655  start = sibling = hwnd;
1656 #else
1657  start = sibling = GetNextDlgGroupItem( parent, hwnd, TRUE );
1658 #endif
1659  do
1660  {
1661  if (!sibling) break;
1662 #ifdef __REACTOS__
1663  if (SendMessageW( sibling, WM_GETDLGCODE, 0, 0 ) == (DLGC_BUTTON | DLGC_RADIOBUTTON))
1664  SendMessageW( sibling, BM_SETCHECK, sibling == hwnd ? BST_CHECKED : BST_UNCHECKED, 0 );
1665 #else
1666  if ((hwnd != sibling) &&
1668  SendMessageW( sibling, BM_SETCHECK, BST_UNCHECKED, 0 );
1669 #endif
1670  sibling = GetNextDlgGroupItem( parent, sibling, FALSE );
1671  } while (sibling != start);
1672 }
1673 
1674 
1675 /**********************************************************************
1676  * Group Box Functions
1677  */
1678 
1679 static void GB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action )
1680 {
1681  RECT rc, rcFrame;
1682  HBRUSH hbr;
1683  HFONT hFont;
1684  UINT dtFlags;
1685  TEXTMETRICW tm;
1686  LONG style = GetWindowLongW( infoPtr->hwnd, GWL_STYLE );
1687  HWND parent;
1688  HRGN hrgn;
1689 
1690  if ((hFont = infoPtr->font)) SelectObject( hDC, hFont );
1691  /* GroupBox acts like static control, so it sends CTLCOLORSTATIC */
1692  parent = GetParent(infoPtr->hwnd);
1693  if (!parent) parent = infoPtr->hwnd;
1694  hbr = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1695  if (!hbr) /* did the app forget to call defwindowproc ? */
1696  hbr = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1697  GetClientRect( infoPtr->hwnd, &rc);
1698  rcFrame = rc;
1699  hrgn = set_control_clipping( hDC, &rc );
1700 
1701  GetTextMetricsW (hDC, &tm);
1702  rcFrame.top += (tm.tmHeight / 2) - 1;
1703  DrawEdge (hDC, &rcFrame, EDGE_ETCHED, BF_RECT | ((style & BS_FLAT) ? BF_FLAT : 0));
1704 
1705  InflateRect(&rc, -7, 1);
1706  dtFlags = BUTTON_CalcLabelRect(infoPtr, hDC, &rc);
1707 
1708  if (dtFlags != (UINT)-1)
1709  {
1710  /* Because buttons have CS_PARENTDC class style, there is a chance
1711  * that label will be drawn out of client rect.
1712  * But Windows doesn't clip label's rect, so do I.
1713  */
1714 
1715  /* There is 1-pixel margin at the left, right, and bottom */
1716  rc.left--; rc.right++; rc.bottom++;
1717  FillRect(hDC, &rc, hbr);
1718  rc.left++; rc.right--; rc.bottom--;
1719 
1720  BUTTON_DrawLabel(infoPtr, hDC, dtFlags, &rc);
1721  }
1722  SelectClipRgn( hDC, hrgn );
1723  if (hrgn) DeleteObject( hrgn );
1724 }
1725 
1726 
1727 /**********************************************************************
1728  * User Button Functions
1729  */
1730 
1731 static void UB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action )
1732 {
1733  RECT rc;
1734  HBRUSH hBrush;
1735  HFONT hFont;
1736  LONG state = infoPtr->state;
1737  HWND parent;
1738 
1739  GetClientRect( infoPtr->hwnd, &rc);
1740 
1741  if ((hFont = infoPtr->font)) SelectObject( hDC, hFont );
1742 
1743  parent = GetParent(infoPtr->hwnd);
1744  if (!parent) parent = infoPtr->hwnd;
1745  hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1746  if (!hBrush) /* did the app forget to call defwindowproc ? */
1747  hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1748 
1749  FillRect( hDC, &rc, hBrush );
1750  if (action == ODA_FOCUS || (state & BST_FOCUS))
1751  DrawFocusRect( hDC, &rc );
1752 
1753  switch (action)
1754  {
1755  case ODA_FOCUS:
1757  break;
1758 
1759  case ODA_SELECT:
1761  break;
1762 
1763  default:
1764  break;
1765  }
1766 }
1767 
1768 
1769 /**********************************************************************
1770  * Ownerdrawn Button Functions
1771  */
1772 
1773 static void OB_Paint( const BUTTON_INFO *infoPtr, HDC hDC, UINT action )
1774 {
1775  LONG state = infoPtr->state;
1776  DRAWITEMSTRUCT dis;
1777  LONG_PTR id = GetWindowLongPtrW( infoPtr->hwnd, GWLP_ID );
1778  HWND parent;
1779  HFONT hFont;
1780  HRGN hrgn;
1781 
1782  dis.CtlType = ODT_BUTTON;
1783  dis.CtlID = id;
1784  dis.itemID = 0;
1785  dis.itemAction = action;
1786  dis.itemState = ((state & BST_FOCUS) ? ODS_FOCUS : 0) |
1787  ((state & BST_PUSHED) ? ODS_SELECTED : 0) |
1788  (IsWindowEnabled(infoPtr->hwnd) ? 0: ODS_DISABLED);
1789  dis.hwndItem = infoPtr->hwnd;
1790  dis.hDC = hDC;
1791  dis.itemData = 0;
1792  GetClientRect( infoPtr->hwnd, &dis.rcItem );
1793 
1794  if ((hFont = infoPtr->font)) SelectObject( hDC, hFont );
1795  parent = GetParent(infoPtr->hwnd);
1796  if (!parent) parent = infoPtr->hwnd;
1798 
1799  hrgn = set_control_clipping( hDC, &dis.rcItem );
1800 
1801  SendMessageW( GetParent(infoPtr->hwnd), WM_DRAWITEM, id, (LPARAM)&dis );
1802  SelectClipRgn( hDC, hrgn );
1803  if (hrgn) DeleteObject( hrgn );
1804 }
1805 
1806 #ifdef __REACTOS__ /* r73885 */
1807 static void PB_ThemedPaint( HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag)
1808 #else
1809 static void PB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
1810 #endif
1811 {
1812  static const int states[] = { PBS_NORMAL, PBS_DISABLED, PBS_HOT, PBS_PRESSED, PBS_DEFAULTED };
1813 
1814  RECT bgRect, textRect;
1815  HFONT font = infoPtr->font;
1816  HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
1817  int state = states[ drawState ];
1818  WCHAR *text = get_button_text(infoPtr);
1819 #ifdef __REACTOS__
1820  HWND parent;
1821  DWORD cdrf;
1822 
1823  GetClientRect(infoPtr->hwnd, &bgRect);
1825 
1826  if (prfFlag == 0)
1827  {
1829  DrawThemeParentBackground(infoPtr->hwnd, hDC, NULL);
1830  }
1831 
1832  parent = GetParent(infoPtr->hwnd);
1833  if (!parent) parent = infoPtr->hwnd;
1835 
1836  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREERASE, &bgRect);
1837  if (cdrf == CDRF_SKIPDEFAULT)
1838  goto cleanup;
1839 
1840  DrawThemeBackground(theme, hDC, BP_PUSHBUTTON, state, &bgRect, NULL);
1841 
1842  if (cdrf == CDRF_NOTIFYPOSTERASE)
1843  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTERASE, &bgRect);
1844 
1845  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREPAINT, &bgRect);
1846  if (cdrf == CDRF_SKIPDEFAULT)
1847  goto cleanup;
1848 
1849  BUTTON_DrawIml(hDC, &infoPtr->imlData, &textRect, FALSE, drawState);
1850 #else
1851  GetClientRect(infoPtr->hwnd, &bgRect);
1853 
1855  DrawThemeParentBackground(infoPtr->hwnd, hDC, NULL);
1856 
1857  DrawThemeBackground(theme, hDC, BP_PUSHBUTTON, state, &bgRect, NULL);
1858 #endif
1859 
1860  if (text)
1861  {
1862  DrawThemeText(theme, hDC, BP_PUSHBUTTON, state, text, lstrlenW(text), dtFlags, 0, &textRect);
1863  heap_free(text);
1864 #ifdef __REACTOS__
1865  text = NULL;
1866 #endif
1867  }
1868 
1869  if (focused)
1870  {
1871  MARGINS margins;
1872  RECT focusRect = bgRect;
1873 
1875 
1876  focusRect.left += margins.cxLeftWidth;
1877  focusRect.top += margins.cyTopHeight;
1878  focusRect.right -= margins.cxRightWidth;
1879  focusRect.bottom -= margins.cyBottomHeight;
1880 
1881  DrawFocusRect( hDC, &focusRect );
1882  }
1883 
1884 #ifdef __REACTOS__
1885  if (cdrf == CDRF_NOTIFYPOSTPAINT)
1886  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTPAINT, &bgRect);
1887 cleanup:
1888  if (text) heap_free(text);
1889 #endif
1890  if (hPrevFont) SelectObject(hDC, hPrevFont);
1891 }
1892 
1893 #ifdef __REACTOS__ /* r73885 */
1894 static void CB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag)
1895 #else
1896 static void CB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
1897 #endif
1898 {
1899  static const int cb_states[3][5] =
1900  {
1904  };
1905 
1906  static const int rb_states[2][5] =
1907  {
1910  };
1911 
1912  SIZE sz;
1913  RECT bgRect, textRect;
1914  HFONT font, hPrevFont = NULL;
1915  int checkState = infoPtr->state & 3;
1916  DWORD dwStyle = GetWindowLongW(infoPtr->hwnd, GWL_STYLE);
1917  UINT btn_type = get_button_type( dwStyle );
1918  int part = (btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON) ? BP_RADIOBUTTON : BP_CHECKBOX;
1919  int state = (part == BP_CHECKBOX)
1920  ? cb_states[ checkState ][ drawState ]
1921  : rb_states[ checkState ][ drawState ];
1922  WCHAR *text = get_button_text(infoPtr);
1923  LOGFONTW lf;
1924  BOOL created_font = FALSE;
1925 #ifdef __REACTOS__
1926  HWND parent;
1927  HBRUSH hBrush;
1928  DWORD cdrf;
1929 #endif
1930 
1931  HRESULT hr = GetThemeFont(theme, hDC, part, state, TMT_FONT, &lf);
1932  if (SUCCEEDED(hr)) {
1933  font = CreateFontIndirectW(&lf);
1934  if (!font)
1935  TRACE("Failed to create font\n");
1936  else {
1937  TRACE("font = %s\n", debugstr_w(lf.lfFaceName));
1938  hPrevFont = SelectObject(hDC, font);
1939  created_font = TRUE;
1940  }
1941  } else {
1942 #ifdef __REACTOS__ /* r73885 */
1943  font = infoPtr->font;
1944 #else
1945  font = (HFONT)SendMessageW(infoPtr->hwnd, WM_GETFONT, 0, 0);
1946 #endif
1947  hPrevFont = SelectObject(hDC, font);
1948  }
1949 
1950  if (FAILED(GetThemePartSize(theme, hDC, part, state, NULL, TS_DRAW, &sz)))
1951  sz.cx = sz.cy = 13;
1952 
1953  GetClientRect(infoPtr->hwnd, &bgRect);
1954 
1955 #ifdef __REACTOS__
1956  if (prfFlag == 0)
1957  {
1958  DrawThemeParentBackground(infoPtr->hwnd, hDC, NULL);
1959  }
1960 
1961  parent = GetParent(infoPtr->hwnd);
1962  if (!parent) parent = infoPtr->hwnd;
1963  hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
1964  (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
1965  if (!hBrush) /* did the app forget to call defwindowproc ? */
1966  hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
1967  (WPARAM)hDC, (LPARAM)infoPtr->hwnd );
1968  FillRect( hDC, &bgRect, hBrush );
1969 
1970  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREERASE, &bgRect);
1971  if (cdrf == CDRF_SKIPDEFAULT)
1972  goto cleanup;
1973 #endif
1974 
1975  GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect);
1976 
1977  if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */
1978  bgRect.top = bgRect.top + (textRect.bottom - textRect.top - sz.cy) / 2;
1979 
1980  /* adjust for the check/radio marker */
1981  bgRect.bottom = bgRect.top + sz.cy;
1982  bgRect.right = bgRect.left + sz.cx;
1983  textRect.left = bgRect.right + 6;
1984 
1985 #ifdef __REACTOS__
1986  DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
1987 
1988  if (cdrf == CDRF_NOTIFYPOSTERASE)
1989  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTERASE, &bgRect);
1990 
1991  cdrf = BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_PREPAINT, &bgRect);
1992  if (cdrf == CDRF_SKIPDEFAULT)
1993  goto cleanup;
1994 
1995 #else
1996  DrawThemeParentBackground(infoPtr->hwnd, hDC, NULL);
1997  DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
1998 #endif
1999  if (text)
2000  {
2001  DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect);
2002 
2003  if (focused)
2004  {
2005  RECT focusRect;
2006 
2007  focusRect = textRect;
2008 
2009  DrawTextW(hDC, text, lstrlenW(text), &focusRect, dtFlags | DT_CALCRECT);
2010 
2011  if (focusRect.right < textRect.right) focusRect.right++;
2012  focusRect.bottom = textRect.bottom;
2013 
2014  DrawFocusRect( hDC, &focusRect );
2015  }
2016 
2017  heap_free(text);
2018 #ifdef __REACTOS__
2019  text = NULL;
2020 #endif
2021  }
2022 
2023 #ifdef __REACTOS__
2024  if (cdrf == CDRF_NOTIFYPOSTPAINT)
2025  BUTTON_SendCustomDraw(infoPtr, hDC, CDDS_POSTPAINT, &bgRect);
2026 cleanup:
2027  if (text) heap_free(text);
2028 #endif
2029  if (created_font) DeleteObject(font);
2030  if (hPrevFont) SelectObject(hDC, hPrevFont);
2031 }
2032 
2033 #ifdef __REACTOS__ /* r73885 */
2034 static void GB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag)
2035 #else
2036 static void GB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
2037 #endif
2038 {
2039  static const int states[] = { GBS_NORMAL, GBS_DISABLED, GBS_NORMAL, GBS_NORMAL, GBS_NORMAL };
2040 
2041  RECT bgRect, textRect, contentRect;
2042  int state = states[ drawState ];
2043  WCHAR *text = get_button_text(infoPtr);
2044  LOGFONTW lf;
2045  HFONT font, hPrevFont = NULL;
2046  BOOL created_font = FALSE;
2047 #ifdef __REACTOS__ /* r74406 */
2048  HWND parent;
2049  HBRUSH hBrush;
2050  RECT clientRect;
2051 #endif
2052 
2053  HRESULT hr = GetThemeFont(theme, hDC, BP_GROUPBOX, state, TMT_FONT, &lf);
2054  if (SUCCEEDED(hr)) {
2055  font = CreateFontIndirectW(&lf);
2056  if (!font)
2057  TRACE("Failed to create font\n");
2058  else {
2059  hPrevFont = SelectObject(hDC, font);
2060  created_font = TRUE;
2061  }
2062  } else {
2063 #ifdef __REACTOS__ /* r73885 */
2064  font = infoPtr->font;
2065 #else
2066  font = (HFONT)SendMessageW(infoPtr->hwnd, WM_GETFONT, 0, 0);
2067 #endif
2068  hPrevFont = SelectObject(hDC, font);
2069  }
2070 
2071  GetClientRect(infoPtr->hwnd, &bgRect);
2072  textRect = bgRect;
2073 
2074  if (text)
2075  {
2076  SIZE textExtent;
2077  GetTextExtentPoint32W(hDC, text, lstrlenW(text), &textExtent);
2078  bgRect.top += (textExtent.cy / 2);
2079  textRect.left += 10;
2080  textRect.bottom = textRect.top + textExtent.cy;
2081  textRect.right = textRect.left + textExtent.cx + 4;
2082 
2084  }
2085 
2086  GetThemeBackgroundContentRect(theme, hDC, BP_GROUPBOX, state, &bgRect, &contentRect);
2087  ExcludeClipRect(hDC, contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
2088 
2089 #ifdef __REACTOS__ /* r73885 & r74149 */
2090  if (prfFlag == 0)
2091 #endif
2093  DrawThemeParentBackground(infoPtr->hwnd, hDC, NULL);
2094 
2095 #ifdef __REACTOS__ /* r74406 */
2096  parent = GetParent(infoPtr->hwnd);
2097  if (!parent) parent = infoPtr->hwnd;
2098  hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
2099  (WPARAM)hDC, (LPARAM)infoPtr->hwnd);
2100  if (!hBrush) /* did the app forget to call defwindowproc ? */
2101  hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
2102  (WPARAM)hDC, (LPARAM)infoPtr->hwnd );
2103  GetClientRect(infoPtr->hwnd, &clientRect);
2104  FillRect( hDC, &clientRect, hBrush );
2105 #endif
2106 
2107  DrawThemeBackground(theme, hDC, BP_GROUPBOX, state, &bgRect, NULL);
2108 
2110 
2111  if (text)
2112  {
2113  InflateRect(&textRect, -2, 0);
2115  heap_free(text);
2116  }
2117 
2118  if (created_font) DeleteObject(font);
2119  if (hPrevFont) SelectObject(hDC, hPrevFont);
2120 }
2121 
2123 {
2124  WNDCLASSW wndClass;
2125 
2126  memset(&wndClass, 0, sizeof(wndClass));
2128  wndClass.lpfnWndProc = BUTTON_WindowProc;
2129  wndClass.cbClsExtra = 0;
2130  wndClass.cbWndExtra = sizeof(BUTTON_INFO *);
2131  wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
2132  wndClass.hbrBackground = NULL;
2133  wndClass.lpszClassName = WC_BUTTONW;
2134  RegisterClassW(&wndClass);
2135 }
2136 
2137 
2138 #ifdef __REACTOS__
2139 void BUTTON_Unregister(void)
2140 {
2142 }
2143 #endif
#define BF_FLAT
Definition: winuser.h:471
#define BS_NOTIFY
Definition: winuser.h:268
INT WINAPI ImageList_GetImageCount(HIMAGELIST himl)
Definition: imagelist.c:2004
HIMAGELIST himl
Definition: commctrl.h:4606
HRESULT WINAPI GetThemePartSize(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *prc, THEMESIZE eSize, SIZE *psz)
Definition: draw.c:1777
#define WS_DISABLED
Definition: pedump.c:621
#define BS_LEFT
Definition: winuser.h:265
BOOL WINAPI GetCharWidthW(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) LPINT lpBuffer)
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define DFCS_FLAT
Definition: winuser.h:510
#define BM_SETSTATE
Definition: winuser.h:1884
BOOL WINAPI RedrawWindow(_In_opt_ HWND, _In_opt_ LPCRECT, _In_opt_ HRGN, _In_ UINT)
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1608
WINE_DEFAULT_DEBUG_CHANNEL(button)
#define max(a, b)
Definition: svc.c:63
#define BS_OWNERDRAW
Definition: pedump.c:661
#define LOGPIXELSX
Definition: wingdi.h:717
BOOL WINAPI InflateRect(_Inout_ LPRECT, _In_ int, _In_ int)
Definition: tftpd.h:59
static HICON
Definition: imagelist.c:84
static void BUTTON_DrawLabel(const BUTTON_INFO *infoPtr, HDC hdc, UINT dtFlags, const RECT *rc)
Definition: button.c:1324
#define HTTRANSPARENT
Definition: winuser.h:2427
#define TRUE
Definition: types.h:120
#define DLGC_UNDEFPUSHBUTTON
Definition: winuser.h:2570
HPEN WINAPI CreatePen(_In_ int, _In_ int, _In_ COLORREF)
#define DT_HIDEPREFIX
Definition: winuser.h:547
#define DFC_BUTTON
Definition: winuser.h:476
#define IMAGE_ICON
Definition: winuser.h:212
#define COLOR_WINDOWFRAME
Definition: winuser.h:909
static HBRUSH hbrush
BOOL WINAPI GetTextMetricsW(_In_ HDC, _Out_ LPTEXTMETRICW)
Definition: text.c:221
#define BS_DEFCOMMANDLINK
Definition: commctrl.h:4644
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
_Must_inspect_result_ _Out_ LPSIZE psize
Definition: ntgdi.h:1569
int WINAPI SelectClipRgn(_In_ HDC, _In_opt_ HRGN)
UINT style
Definition: winuser.h:3129
#define WM_GETDLGCODE
Definition: winuser.h:1671
#define LAYOUT_RTL
Definition: wingdi.h:1353
#define WM_LBUTTONDOWN
Definition: winuser.h:1752
HRESULT hr
Definition: shlfolder.c:183
#define BS_LEFTTEXT
Definition: pedump.c:662
void BUTTON_Register(void)
Definition: button.c:2122
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
BOOL WINAPI IsWindow(_In_opt_ HWND)
#define CDDS_POSTERASE
Definition: commctrl.h:268
#define BCM_SETTEXTMARGIN
Definition: commctrl.h:4620
#define DFCS_CHECKED
Definition: winuser.h:504
#define BS_DEFSPLITBUTTON
Definition: commctrl.h:4642
#define MK_LBUTTON
Definition: winuser.h:2321
#define CDRF_NOTIFYPOSTPAINT
Definition: commctrl.h:259
BOOL WINAPI Rectangle(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
HDC WINAPI GetDC(_In_opt_ HWND)
static void PB_Paint(const BUTTON_INFO *infoPtr, HDC hDC, UINT action)
Definition: button.c:1392
HBITMAP WINAPI CreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
Definition: mk_font.cpp:20
#define BS_RIGHT
Definition: winuser.h:274
#define BS_RADIOBUTTON
Definition: pedump.c:655
static WCHAR * get_button_text(const BUTTON_INFO *infoPtr)
Definition: button.c:230
#define pt(x, y)
Definition: drawing.c:79
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
const WCHAR * text
Definition: package.c:1827
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define WM_MOUSEHOVER
Definition: commctrl.h:4945
#define BM_GETSTATE
Definition: winuser.h:1881
#define WM_CTLCOLORSTATIC
Definition: winuser.h:1748
#define DT_WORDBREAK
Definition: winuser.h:544
#define DFCS_BUTTON3STATE
Definition: winuser.h:500
LONG lfHeight
Definition: dimm.idl:59
#define BCM_GETTEXTMARGIN
Definition: commctrl.h:4622
BOOL WINAPI DrawFocusRect(_In_ HDC, _In_ LPCRECT)
#define BS_TEXT
Definition: winuser.h:276
#define WM_CAPTURECHANGED
Definition: winuser.h:1784
HANDLE image
Definition: button.c:102
static const WORD maxCheckState[MAX_BTN_TYPE]
Definition: button.c:122
static HDC
Definition: imagelist.c:92
#define DLGC_RADIOBUTTON
Definition: winuser.h:2571
#define DFCS_INACTIVE
Definition: winuser.h:502
#define CALLBACK
Definition: compat.h:27
#define BS_DEFPUSHBUTTON
Definition: pedump.c:652
HWND hWnd
Definition: settings.c:17
GLdouble n
Definition: glext.h:7729
ULONG_PTR itemData
Definition: winuser.h:3046
LONG top
Definition: windef.h:292
BOOL(CALLBACK * DRAWSTATEPROC)(HDC, LPARAM, WPARAM, int, int)
Definition: winuser.h:2860
int WINAPI IntersectClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
#define CDDS_POSTPAINT
Definition: commctrl.h:266
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1497
#define ODS_FOCUS
Definition: winuser.h:2503
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define BUTTON_NSTATES
Definition: button.c:77
#define BUTTON_IMAGELIST_ALIGN_TOP
Definition: commctrl.h:4601
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
#define CS_HREDRAW
Definition: winuser.h:648
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
#define GWL_EXSTYLE
Definition: winuser.h:845
static void CB_Paint(const BUTTON_INFO *infoPtr, HDC hDC, UINT action)
Definition: button.c:1515
GLuint buffer
Definition: glext.h:5915
int cbClsExtra
Definition: winuser.h:3131
HWND WINAPI SetFocus(_In_opt_ HWND)
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define WM_NCHITTEST
Definition: winuser.h:1668
BOOL WINAPI DrawFrameControl(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
UINT_PTR WPARAM
Definition: windef.h:207
HRESULT WINAPI GetThemeFont(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, int iPropId, LOGFONTW *pFont)
Definition: property.c:108
#define WS_CHILD
Definition: pedump.c:617
static HPEN hpen
#define DT_RIGHT
Definition: winuser.h:538
#define GetWindowLongPtrW
Definition: winuser.h:4698
BOOL WINAPI ImageList_Draw(HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
Definition: imagelist.c:1225
HBITMAP bitmap
Definition: button.c:101
#define RDW_FRAME
Definition: winuser.h:1198
LONG left
Definition: windef.h:291
static void OB_Paint(const BUTTON_INFO *infoPtr, HDC hDC, UINT action)
Definition: button.c:1773
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
#define CDRF_SKIPDEFAULT
Definition: commctrl.h:255
#define BS_CENTER
Definition: winuser.h:260
LONG right
Definition: windef.h:293
#define ODA_FOCUS
Definition: winuser.h:2498
#define lstrlenW
Definition: compat.h:407
#define BM_GETIMAGE
Definition: winuser.h:1880
#define WS_EX_RIGHT
Definition: winuser.h:400
#define WM_NCCREATE
Definition: winuser.h:1665
static LRESULT CALLBACK BUTTON_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: button.c:587
#define BM_SETIMAGE
Definition: winuser.h:1883
BOOL WINAPI DPtoLP(_In_ HDC hdc, _Inout_updates_(c) LPPOINT lppt, _In_ int c)
HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect)
Definition: draw.c:128
struct _BUTTON_INFO BUTTON_INFO
static VOID NTAPI BitBlt(IN ULONG Left, IN ULONG Top, IN ULONG Width, IN ULONG Height, IN PUCHAR Buffer, IN ULONG BitsPerPixel, IN ULONG Delta)
Definition: vga.c:416
HRGN set_control_clipping(HDC hdc, const RECT *rect)
Definition: button.c:239
int32_t INT
Definition: typedefs.h:56
BOOL WINAPI GetIconInfo(_In_ HICON, _Out_ PICONINFO)
Definition: cursoricon.c:2014
#define BS_GROUPBOX
Definition: pedump.c:658
#define BN_UNHILITE
Definition: winuser.h:1895
Definition: misc.c:279
DWORD WINAPI GetSysColor(_In_ int)
& rect
Definition: startmenu.cpp:1413
WPARAM wParam
Definition: combotst.c:138
#define BST_INDETERMINATE
Definition: winuser.h:198
static void GB_Paint(const BUTTON_INFO *infoPtr, HDC hDC, UINT action)
Definition: button.c:1679
HFONT hFont
Definition: main.c:53
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
#define WM_ENABLE
Definition: winuser.h:1597
#define WM_PRINTCLIENT
Definition: richedit.h:70
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI TrackMouseEvent(_Inout_ LPTRACKMOUSEEVENT)
#define DSS_HIDEPREFIX
Definition: winuser.h:522
HWND WINAPI GetNextDlgGroupItem(_In_ HWND, _In_opt_ HWND, _In_ BOOL)
UINT code
Definition: winuser.h:3112
static const pfPaint btnPaintFunc[MAX_BTN_TYPE]
Definition: button.c:154
BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId, int iStateId)
Definition: draw.c:1883
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)
#define BF_RECT
Definition: winuser.h:462
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:93
#define PS_SOLID
Definition: wingdi.h:585
#define DFCS_PUSHED
Definition: winuser.h:503
#define DFCS_BUTTONRADIO
Definition: winuser.h:499
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1032
#define WM_CTLCOLORBTN
Definition: winuser.h:1745
#define DT_LEFT
Definition: winuser.h:534
#define DT_CALCRECT
Definition: winuser.h:526
#define BST_HOT
Definition: commctrl.h:4639
#define HICF_ENTERING
Definition: commctrl.h:1302
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define TMT_CONTENTMARGINS
Definition: vssym32.h:324
LONG WINAPI SetWindowLongW(_In_ HWND, _In_ int, _In_ LONG)
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)
BOOL WINAPI DrawEdge(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
UINT_PTR idFrom
Definition: winuser.h:3111
#define BUTTON_IMAGELIST_ALIGN_CENTER
Definition: commctrl.h:4603
#define debugstr_w
Definition: kernel32.h:32
HBITMAP hbmMask
Definition: winuser.h:3079
ButtonState
Definition: button.c:143
WNDPROC lpfnWndProc
Definition: winuser.h:3130
HWND WINAPI GetCapture(void)
Definition: message.c:2879
#define WM_MOUSELEAVE
Definition: commctrl.h:4946
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define HICF_LEAVING
Definition: commctrl.h:1303
#define TRANSPARENT
Definition: wingdi.h:949
void WINAPI mouse_event(_In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ ULONG_PTR)
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:570
static void CB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused)
Definition: button.c:1896
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
RECT textRect
Definition: startmenu.cpp:1392
LONG lfWidth
Definition: dimm.idl:60
smooth NULL
Definition: ftsmooth.c:416
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)
#define WM_GETFONT
Definition: winuser.h:1633
#define BS_AUTOCHECKBOX
Definition: pedump.c:654
#define CDIS_SELECTED
Definition: commctrl.h:276
#define BS_AUTO3STATE
Definition: pedump.c:657
LONG cx
Definition: windef.h:319
#define TMT_FONT
Definition: vssym32.h:144
#define WM_KEYDOWN
Definition: winuser.h:1691
LPCWSTR lpszClassName
Definition: winuser.h:3138
LONG_PTR LPARAM
Definition: windef.h:208
HBITMAP hbmColor
Definition: winuser.h:3080
#define BM_GETCHECK
Definition: winuser.h:1879
BOOL WINAPI IsWindowEnabled(_In_ HWND)
static UINT BUTTON_CalcLabelRect(const BUTTON_INFO *infoPtr, HDC hdc, RECT *rc)
Definition: button.c:1181
GLuint index
Definition: glext.h:6031
#define BST_FOCUS
Definition: winuser.h:200
#define DT_VCENTER
Definition: winuser.h:543
#define WM_SETTEXT
Definition: winuser.h:1599
#define WM_DESTROY
Definition: winuser.h:1591
#define BN_HILITE
Definition: winuser.h:1890
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
HRESULT WINAPI GetThemeBackgroundExtent(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pContentRect, RECT *pExtentRect)
Definition: draw.c:1528
HBITMAP hbmp
#define BUTTON_NOTIFY_PARENT(hWnd, code)
Definition: button.c:85
static void UB_Paint(const BUTTON_INFO *infoPtr, HDC hDC, UINT action)
Definition: button.c:1731
HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
Definition: draw.c:72
#define CS_VREDRAW
Definition: winuser.h:653
#define BM_CLICK
Definition: winuser.h:1878
#define ODA_DRAWENTIRE
Definition: winuser.h:2496
static void PB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused)
Definition: button.c:1809
#define DLGC_DEFPUSHBUTTON
Definition: winuser.h:2569
#define BM_SETCHECK
Definition: winuser.h:1882
#define TRACE(s)
Definition: solgame.cpp:4
#define BS_COMMANDLINK
Definition: commctrl.h:4643
#define WM_KILLFOCUS
Definition: winuser.h:1596
#define GetProcessHeap()
Definition: compat.h:395
HWND hwnd
Definition: button.c:95
r parent
Definition: btrfs.c:2708
int cbWndExtra
Definition: winuser.h:3132
#define BS_MULTILINE
Definition: winuser.h:267
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define DSS_MONO
Definition: winuser.h:521
#define BM_SETSTYLE
Definition: winuser.h:1885
#define ODS_DISABLED
Definition: winuser.h:2501
LONG HRESULT
Definition: typedefs.h:77
#define BST_PUSHED
Definition: winuser.h:201
DWORD COLORREF
Definition: windef.h:285
#define DSS_DISABLED
Definition: winuser.h:519
#define CS_GLOBALCLASS
Definition: winuser.h:647
#define WM_NCDESTROY
Definition: winuser.h:1666
#define DFCS_MONO
Definition: winuser.h:511
int WINAPI GetWindowTextLengthW(_In_ HWND)
#define BS_TOP
Definition: winuser.h:277
#define WM_KEYUP
Definition: winuser.h:1692
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
static UINT BUTTON_BStoDT(DWORD style, DWORD ex_style)
Definition: button.c:262
#define TME_QUERY
Definition: commctrl.h:4954
static FILE * client
Definition: client.c:41
unsigned short WORD
Definition: ntddk_ex.h:93
#define BN_CLICKED
Definition: winuser.h:1886
PVOID HANDLE
Definition: typedefs.h:71
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint left
Definition: glext.h:7726
#define CDIS_FOCUS
Definition: commctrl.h:280
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2074
#define CDIS_CHECKED
Definition: commctrl.h:279
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
Definition: system.c:835
#define EDGE_ETCHED
Definition: winuser.h:452
#define MAX_BTN_TYPE
Definition: button.c:120
GLbitfield flags
Definition: glext.h:7161
static LPARAM
Definition: button.c:42
#define BN_KILLFOCUS
Definition: winuser.h:1891
#define WM_PAINT
Definition: winuser.h:1602
#define BS_SPLITBUTTON
Definition: commctrl.h:4641
HTHEME WINAPI GetWindowTheme(HWND hwnd)
Definition: system.c:851
int ret
#define NM_CUSTOMDRAW
Definition: commctrl.h:137
#define CDDS_PREPAINT
Definition: commctrl.h:265
#define BUTTON_IMAGELIST_ALIGN_LEFT
Definition: commctrl.h:4599
#define BS_ICON
Definition: winuser.h:264
#define COLOR_GRAYTEXT
Definition: winuser.h:922
#define BCM_GETIMAGELIST
Definition: commctrl.h:4617
#define OPAQUE
Definition: wingdi.h:948
static const WCHAR L[]
Definition: oid.c:1250
struct tagTRACKMOUSEEVENT TRACKMOUSEEVENT
HDC hdc
Definition: main.c:9
#define COLOR_BTNFACE
Definition: winuser.h:918
BOOL WINAPI DrawStateW(_In_ HDC, _In_opt_ HBRUSH, _In_opt_ DRAWSTATEPROC, _In_ LPARAM, _In_ WPARAM, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
static HRGN hrgn
Definition: win.c:55
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
#define BS_BITMAP
Definition: winuser.h:258
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1754
#define CS_DBLCLKS
Definition: winuser.h:646
#define WS_TABSTOP
Definition: pedump.c:634
Definition: time.h:76
HFONT font
Definition: button.c:97
static UINT get_button_type(LONG window_style)
Definition: button.c:211
HWND hwndFrom
Definition: winuser.h:3110
#define BS_VCENTER
Definition: winuser.h:279
#define BST_UNCHECKED
Definition: winuser.h:199
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
static RECT margins
Definition: print.c:55
#define wcsicmp
Definition: string.h:1152
#define BUTTON_BTNPRESSED
Definition: button.c:78
#define BS_PUSHBUTTON
Definition: pedump.c:651
HRESULT WINAPI GetThemeMargins(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, int iPropId, RECT *prc, MARGINS *pMargins)
Definition: property.c:216
LONG state
Definition: button.c:96
#define BS_FLAT
Definition: winuser.h:280
HCURSOR hCursor
Definition: winuser.h:3135
#define ERR(fmt,...)
Definition: debug.h:109
#define GWL_STYLE
Definition: winuser.h:846
#define DT_NOCLIP
Definition: winuser.h:536
#define BUTTON_IMAGELIST_ALIGN_BOTTOM
Definition: commctrl.h:4602
#define DFCS_BUTTONCHECK
Definition: winuser.h:496
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:886
static HDC hDC
Definition: 3dtext.c:33
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define BN_SETFOCUS
Definition: winuser.h:1894
#define DT_SINGLELINE
Definition: winuser.h:540
HWND WINAPI GetParent(_In_ HWND)
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
HWND WINAPI SetCapture(_In_ HWND hWnd)
void(* pfThemedPaint)(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused)
Definition: button.c:183
#define BS_AUTORADIOBUTTON
Definition: pedump.c:660
DWORD WINAPI GetLayout(_In_ HDC hdc)
Definition: coord.c:741
const WCHAR * action
Definition: action.c:7783
#define TME_HOVER
Definition: commctrl.h:4951
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1378
BOOL WINAPI DeleteDC(_In_ HDC)
int WINAPI ExcludeClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
GLuint start
Definition: gl.h:1545
#define BS_TYPEMASK
Definition: winuser.h:270
#define WC_BUTTONW
Definition: commctrl.h:4595
DWORD_PTR dwItemSpec
Definition: commctrl.h:292
HBRUSH hbrBackground
Definition: winuser.h:3136
#define DLGC_BUTTON
Definition: winuser.h:2574
#define DFCS_BUTTONPUSH
Definition: winuser.h:501
#define TME_LEAVE
Definition: commctrl.h:4952
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define WM_LBUTTONUP
Definition: winuser.h:1753
Definition: bl.h:1331
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define DT_TOP
Definition: winuser.h:542
unsigned int UINT
Definition: ndis.h:50
#define WM_MOUSEMOVE
Definition: winuser.h:1751
#define VK_SPACE
Definition: winuser.h:2173
#define BS_BOTTOM
Definition: winuser.h:259
#define IMAGE_BITMAP
Definition: winuser.h:211
#define CDRF_NOTIFYPOSTERASE
Definition: commctrl.h:262
#define CDIS_DISABLED
Definition: commctrl.h:278
static const pfThemedPaint btnThemedPaintFunc[MAX_BTN_TYPE]
Definition: button.c:191
#define WM_SETFONT
Definition: winuser.h:1632
#define BST_CHECKED
Definition: winuser.h:197
#define BUTTON_IMAGELIST_ALIGN_RIGHT
Definition: commctrl.h:4600
union _BUTTON_INFO::@318 u
static LRESULT paint(HTHEME theme, HWND hwnd, HDC hParamDC, ULONG state)
Definition: theme_combo.c:154
#define WM_DRAWITEM
Definition: winuser.h:1627
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)
#define RDW_UPDATENOW
Definition: winuser.h:1206
#define IDC_ARROW
Definition: winuser.h:682
HRESULT WINAPI GetThemeBackgroundContentRect(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect)
Definition: draw.c:1479
_Out_opt_ int * cx
Definition: commctrl.h:570
BOOL WINAPI ReleaseCapture(void)
Definition: message.c:2888
static void paint_button(BUTTON_INFO *infoPtr, LONG style, UINT action)
Definition: button.c:218
#define BS_PUSHLIKE
Definition: winuser.h:272
#define DST_BITMAP
Definition: winuser.h:516
#define ODS_SELECTED
Definition: winuser.h:2499
#define WM_CREATE
Definition: winuser.h:1590
#define ODT_BUTTON
Definition: winuser.h:2494
BOOL WINAPI ImageList_GetIconSize(HIMAGELIST himl, INT *cx, INT *cy)
Definition: imagelist.c:1978
#define DSS_NORMAL
Definition: winuser.h:517
static void BUTTON_CheckAutoRadioButton(HWND hwnd)
Definition: button.c:1648
WCHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:72
#define HIWORD(l)
Definition: typedefs.h:246
GLenum GLuint id
Definition: glext.h:5579
BOOL WINAPI IsWindowVisible(_In_ HWND)
LONG bottom
Definition: windef.h:294
#define CDIS_SHOWKEYBOARDCUES
Definition: commctrl.h:285
#define DT_CENTER
Definition: winuser.h:527
char * cleanup(char *str)
Definition: wpickclick.c:99
#define LOGPIXELSY
Definition: wingdi.h:718
static BOOL CALLBACK BUTTON_DrawTextCallback(HDC hdc, LPARAM lp, WPARAM wp, int cx, int cy)
Definition: button.c:1309
#define BCM_GETIDEALSIZE
Definition: commctrl.h:4611
#define COLOR_BTNTEXT
Definition: winuser.h:923
#define BN_DOUBLECLICKED
Definition: winuser.h:1889
int WINAPI GetClipRgn(_In_ HDC, _In_ HRGN)
#define SetWindowLongPtrW
Definition: winuser.h:5215
static HBITMAP
Definition: button.c:44
#define DST_ICON
Definition: winuser.h:515
#define BS_USERBUTTON
Definition: pedump.c:659
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
#define WM_ERASEBKGND
Definition: winuser.h:1607
#define WM_SETFOCUS
Definition: winuser.h:1595
#define BCN_HOTITEMCHANGE
Definition: commctrl.h:4637
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static void GB_ThemedPaint(HTHEME theme, const BUTTON_INFO *infoPtr, HDC hdc, ButtonState drawState, UINT dtflags, BOOL focused)
Definition: button.c:2036
LONG_PTR LRESULT
Definition: windef.h:209
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
Arabic default style
Definition: afstyles.h:93
_Out_ LPRECT prc
Definition: ntgdi.h:1658
#define WS_VISIBLE
Definition: pedump.c:620
HBRUSH WINAPI GetSysColorBrush(_In_ int)
#define BCM_SETIMAGELIST
Definition: commctrl.h:4614
#define memset(x, y, z)
Definition: compat.h:39
#define DT_BOTTOM
Definition: winuser.h:525
HICON icon
Definition: button.c:100
LONG cy
Definition: windef.h:320
LPARAM lParam
Definition: combotst.c:139
#define LOWORD(l)
Definition: pedump.c:82
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:394
#define GWLP_ID
Definition: winuser.h:854
#define DLGC_WANTARROWS
Definition: winuser.h:2564
#define SRCCOPY
Definition: wingdi.h:332
#define DLGC_STATIC
Definition: winuser.h:2573
#define CS_PARENTDC
Definition: winuser.h:651
#define ODA_SELECT
Definition: winuser.h:2497
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:950
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
#define WM_NOTIFY
Definition: richedit.h:61
void(* pfPaint)(const BUTTON_INFO *infoPtr, HDC hdc, UINT action)
Definition: button.c:152
HRESULT WINAPI DrawThemeText(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, const RECT *pRect)
Definition: draw.c:1377
#define SUCCEEDED(hr)
Definition: intsafe.h:57
#define RDW_INVALIDATE
Definition: winuser.h:1200
#define CDDS_PREERASE
Definition: commctrl.h:267
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:17
static BOOL heap_free(void *mem)
Definition: appwiz.h:75