projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Forward port of changes for using themed drawing of owner-drawn buttons.
[wxWidgets.git] / src / msw / button.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/button.cpp
3 // Purpose: wxButton
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_BUTTON
28
29 #include "wx/button.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/app.h"
33 #include "wx/brush.h"
34 #include "wx/panel.h"
35 #include "wx/bmpbuttn.h"
36 #include "wx/settings.h"
37 #include "wx/dcscreen.h"
38 #include "wx/dcclient.h"
39 #endif
40
41 #include "wx/stockitem.h"
42 #include "wx/tokenzr.h"
43 #include "wx/msw/private.h"
44
45 #if wxUSE_UXTHEME
46 #include "wx/msw/uxtheme.h"
47
48 // no need to include tmschema.h
49 #ifndef BP_PUSHBUTTON
50 #define BP_PUSHBUTTON 1
51
52 #define PBS_NORMAL 1
53 #define PBS_HOT 2
54 #define PBS_PRESSED 3
55 #define PBS_DISABLED 4
56 #define PBS_DEFAULTED 5
57
58 #define TMT_CONTENTMARGINS 3602
59 #endif
60 #endif // wxUSE_UXTHEME
61
62 #ifndef WM_THEMECHANGED
63 #define WM_THEMECHANGED 0x031A
64 #endif
65
66 #ifndef ODS_NOACCEL
67 #define ODS_NOACCEL 0x0100
68 #endif
69
70 #ifndef ODS_NOFOCUSRECT
71 #define ODS_NOFOCUSRECT 0x0200
72 #endif
73
74 // ----------------------------------------------------------------------------
75 // macros
76 // ----------------------------------------------------------------------------
77
78 #if wxUSE_EXTENDED_RTTI
79
80 WX_DEFINE_FLAGS( wxButtonStyle )
81
82 wxBEGIN_FLAGS( wxButtonStyle )
83 // new style border flags, we put them first to
84 // use them for streaming out
85 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
86 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
87 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
88 wxFLAGS_MEMBER(wxBORDER_RAISED)
89 wxFLAGS_MEMBER(wxBORDER_STATIC)
90 wxFLAGS_MEMBER(wxBORDER_NONE)
91
92 // old style border flags
93 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
94 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
95 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
96 wxFLAGS_MEMBER(wxRAISED_BORDER)
97 wxFLAGS_MEMBER(wxSTATIC_BORDER)
98 wxFLAGS_MEMBER(wxBORDER)
99
100 // standard window styles
101 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
102 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
103 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
104 wxFLAGS_MEMBER(wxWANTS_CHARS)
105 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
106 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
107 wxFLAGS_MEMBER(wxVSCROLL)
108 wxFLAGS_MEMBER(wxHSCROLL)
109
110 wxFLAGS_MEMBER(wxBU_LEFT)
111 wxFLAGS_MEMBER(wxBU_RIGHT)
112 wxFLAGS_MEMBER(wxBU_TOP)
113 wxFLAGS_MEMBER(wxBU_BOTTOM)
114 wxFLAGS_MEMBER(wxBU_EXACTFIT)
115 wxEND_FLAGS( wxButtonStyle )
116
117 IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
118
119 wxBEGIN_PROPERTIES_TABLE(wxButton)
120 wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
121
122 wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
123 wxPROPERTY( Label, wxString , SetLabel, GetLabel, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
124
125 wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
126
127 wxEND_PROPERTIES_TABLE()
128
129 wxBEGIN_HANDLERS_TABLE(wxButton)
130 wxEND_HANDLERS_TABLE()
131
132 wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle )
133
134
135 #else
136 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
137 #endif
138
139 // this macro tries to adjust the default button height to a reasonable value
140 // using the char height as the base
141 #define BUTTON_HEIGHT_FROM_CHAR_HEIGHT(cy) (11*EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)/10)
142
143 // ============================================================================
144 // implementation
145 // ============================================================================
146
147 // ----------------------------------------------------------------------------
148 // creation/destruction
149 // ----------------------------------------------------------------------------
150
151 bool wxButton::Create(wxWindow *parent,
152 wxWindowID id,
153 const wxString& lbl,
154 const wxPoint& pos,
155 const wxSize& size,
156 long style,
157 const wxValidator& validator,
158 const wxString& name)
159 {
160 wxString label(lbl);
161 if (label.empty() && wxIsStockID(id))
162 {
163 // On Windows, some buttons aren't supposed to have
164 // mnemonics, so strip them out.
165
166 label = wxGetStockLabel(id
167 #if defined(__WXMSW__) || defined(__WXWINCE__)
168 , ( id != wxID_OK &&
169 id != wxID_CANCEL &&
170 id != wxID_CLOSE )
171 #endif
172 );
173 }
174
175 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
176 return false;
177
178 WXDWORD exstyle;
179 WXDWORD msStyle = MSWGetStyle(style, &exstyle);
180
181 #ifdef __WIN32__
182 // if the label contains several lines we must explicitly tell the button
183 // about it or it wouldn't draw it correctly ("\n"s would just appear as
184 // black boxes)
185 //
186 // NB: we do it here and not in MSWGetStyle() because we need the label
187 // value and m_label is not set yet when MSWGetStyle() is called;
188 // besides changing BS_MULTILINE during run-time is pointless anyhow
189 if ( label.find(_T('\n')) != wxString::npos )
190 {
191 msStyle |= BS_MULTILINE;
192 }
193 #endif // __WIN32__
194
195 return MSWCreateControl(_T("BUTTON"), msStyle, pos, size, label, exstyle);
196 }
197
198 wxButton::~wxButton()
199 {
200 }
201
202 // ----------------------------------------------------------------------------
203 // flags
204 // ----------------------------------------------------------------------------
205
206 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
207 {
208 // buttons never have an external border, they draw their own one
209 WXDWORD msStyle = wxControl::MSWGetStyle
210 (
211 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
212 );
213
214 // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
215 // each other in any resizeable dialog which has more than one button in
216 // the bottom
217 msStyle |= WS_CLIPSIBLINGS;
218
219 #ifdef __WIN32__
220 // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
221 // and wxBU_RIGHT to get BS_CENTER!
222 if ( style & wxBU_LEFT )
223 msStyle |= BS_LEFT;
224 if ( style & wxBU_RIGHT )
225 msStyle |= BS_RIGHT;
226 if ( style & wxBU_TOP )
227 msStyle |= BS_TOP;
228 if ( style & wxBU_BOTTOM )
229 msStyle |= BS_BOTTOM;
230 #ifndef __WXWINCE__
231 // flat 2d buttons
232 if ( style & wxNO_BORDER )
233 msStyle |= BS_FLAT;
234 #endif // __WXWINCE__
235 #endif // __WIN32__
236
237 return msStyle;
238 }
239
240 // ----------------------------------------------------------------------------
241 // size management including autosizing
242 // ----------------------------------------------------------------------------
243
244 wxSize wxButton::DoGetBestSize() const
245 {
246 wxClientDC dc(wx_const_cast(wxButton *, this));
247 dc.SetFont(GetFont());
248
249 wxCoord wBtn,
250 hBtn;
251 dc.GetMultiLineTextExtent(wxStripMenuCodes(GetLabel()), &wBtn, &hBtn);
252
253 // add a margin -- the button is wider than just its label
254 wBtn += 3*GetCharWidth();
255 hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hBtn);
256
257 // all buttons have at least the standard size unless the user explicitly
258 // wants them to be of smaller size and used wxBU_EXACTFIT style when
259 // creating the button
260 if ( !HasFlag(wxBU_EXACTFIT) )
261 {
262 wxSize sz = GetDefaultSize();
263 if (wBtn > sz.x)
264 sz.x = wBtn;
265 if (hBtn > sz.y)
266 sz.y = hBtn;
267
268 return sz;
269 }
270
271 wxSize best(wBtn, hBtn);
272 CacheBestSize(best);
273 return best;
274 }
275
276 /* static */
277 wxSize wxButtonBase::GetDefaultSize()
278 {
279 static wxSize s_sizeBtn;
280
281 if ( s_sizeBtn.x == 0 )
282 {
283 wxScreenDC dc;
284 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
285
286 // the size of a standard button in the dialog units is 50x14,
287 // translate this to pixels
288 // NB1: the multipliers come from the Windows convention
289 // NB2: the extra +1/+2 were needed to get the size be the same as the
290 // size of the buttons in the standard dialog - I don't know how
291 // this happens, but on my system this size is 75x23 in pixels and
292 // 23*8 isn't even divisible by 14... Would be nice to understand
293 // why these constants are needed though!
294 s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
295 s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
296 }
297
298 return s_sizeBtn;
299 }
300
301 // ----------------------------------------------------------------------------
302 // default button handling
303 // ----------------------------------------------------------------------------
304
305 /*
306 "Everything you ever wanted to know about the default buttons" or "Why do we
307 have to do all this?"
308
309 In MSW the default button should be activated when the user presses Enter
310 and the current control doesn't process Enter itself somehow. This is
311 handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
312 Another aspect of "defaultness" is that the default button has different
313 appearance: this is due to BS_DEFPUSHBUTTON style which is completely
314 separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
315 be unset if our parent window is not active so it should be unset whenever
316 we lose activation and set back when we regain it.
317
318 Final complication is that when a button is active, it should be the default
319 one, i.e. pressing Enter on a button always activates it and not another
320 one.
321
322 We handle this by maintaining a permanent and a temporary default items in
323 wxControlContainer (both may be NULL). When a button becomes the current
324 control (i.e. gets focus) it sets itself as the temporary default which
325 ensures that it has the right appearance and that Enter will be redirected
326 to it. When the button loses focus, it unsets the temporary default and so
327 the default item will be the permanent default -- that is the default button
328 if any had been set or none otherwise, which is just what we want.
329
330 NB: all this is quite complicated by now and the worst is that normally
331 it shouldn't be necessary at all as for the normal Windows programs
332 DefWindowProc() and IsDialogMessage() take care of all this
333 automatically -- however in wxWidgets programs this doesn't work for
334 nested hierarchies (i.e. a notebook inside a notebook) for unknown
335 reason and so we have to reproduce all this code ourselves. It would be
336 very nice if we could avoid doing it.
337 */
338
339 // set this button as the (permanently) default one in its panel
340 void wxButton::SetDefault()
341 {
342 wxWindow *parent = GetParent();
343
344 wxCHECK_RET( parent, _T("button without parent?") );
345
346 // set this one as the default button both for wxWidgets ...
347 wxWindow *winOldDefault = parent->SetDefaultItem(this);
348
349 // ... and Windows
350 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
351 SetDefaultStyle(this, true);
352 }
353
354 // set this button as being currently default
355 void wxButton::SetTmpDefault()
356 {
357 wxWindow *parent = GetParent();
358
359 wxCHECK_RET( parent, _T("button without parent?") );
360
361 wxWindow *winOldDefault = parent->GetDefaultItem();
362 parent->SetTmpDefaultItem(this);
363
364 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
365 SetDefaultStyle(this, true);
366 }
367
368 // unset this button as currently default, it may still stay permanent default
369 void wxButton::UnsetTmpDefault()
370 {
371 wxWindow *parent = GetParent();
372
373 wxCHECK_RET( parent, _T("button without parent?") );
374
375 parent->SetTmpDefaultItem(NULL);
376
377 wxWindow *winOldDefault = parent->GetDefaultItem();
378
379 SetDefaultStyle(this, false);
380 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
381 }
382
383 /* static */
384 void
385 wxButton::SetDefaultStyle(wxButton *btn, bool on)
386 {
387 // we may be called with NULL pointer -- simpler to do the check here than
388 // in the caller which does wxDynamicCast()
389 if ( !btn )
390 return;
391
392 // first, let DefDlgProc() know about the new default button
393 if ( on )
394 {
395 // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
396 // focus at all any more
397 if ( !wxTheApp->IsActive() )
398 return;
399
400 // look for a panel-like window
401 wxWindow *win = btn->GetParent();
402 while ( win && !win->HasFlag(wxTAB_TRAVERSAL) )
403 win = win->GetParent();
404
405 if ( win )
406 {
407 ::SendMessage(GetHwndOf(win), DM_SETDEFID, btn->GetId(), 0L);
408
409 // sending DM_SETDEFID also changes the button style to
410 // BS_DEFPUSHBUTTON so there is nothing more to do
411 }
412 }
413
414 // then also change the style as needed
415 long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
416 if ( !(style & BS_DEFPUSHBUTTON) == on )
417 {
418 // don't do it with the owner drawn buttons because it will
419 // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
420 // BS_DEFPUSHBUTTON != 0)!
421 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
422 {
423 ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
424 on ? style | BS_DEFPUSHBUTTON
425 : style & ~BS_DEFPUSHBUTTON,
426 1L /* redraw */);
427 }
428 else // owner drawn
429 {
430 // redraw the button - it will notice itself that it's
431 // [not] the default one [any longer]
432 btn->Refresh();
433 }
434 }
435 //else: already has correct style
436 }
437
438 // ----------------------------------------------------------------------------
439 // helpers
440 // ----------------------------------------------------------------------------
441
442 bool wxButton::SendClickEvent()
443 {
444 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
445 event.SetEventObject(this);
446
447 return ProcessCommand(event);
448 }
449
450 void wxButton::Command(wxCommandEvent & event)
451 {
452 ProcessCommand(event);
453 }
454
455 // ----------------------------------------------------------------------------
456 // event/message handlers
457 // ----------------------------------------------------------------------------
458
459 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
460 {
461 bool processed = false;
462 switch ( param )
463 {
464 // NOTE: Apparently older versions (NT 4?) of the common controls send
465 // BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
466 // buttons, so in order to send two EVT_BUTTON events we should
467 // catch both types. Currently (Feb 2003) up-to-date versions of
468 // win98, win2k and winXP all send two BN_CLICKED messages for
469 // all button types, so we don't catch BN_DOUBLECLICKED anymore
470 // in order to not get 3 EVT_BUTTON events. If this is a problem
471 // then we need to figure out which version of the comctl32 changed
472 // this behaviour and test for it.
473
474 case 1: // message came from an accelerator
475 case BN_CLICKED: // normal buttons send this
476 processed = SendClickEvent();
477 break;
478 }
479
480 return processed;
481 }
482
483 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
484 {
485 // when we receive focus, we want to temporarily become the default button in
486 // our parent panel so that pressing "Enter" would activate us -- and when
487 // losing it we should restore the previous default button as well
488 if ( nMsg == WM_SETFOCUS )
489 {
490 SetTmpDefault();
491
492 // let the default processing take place too
493 }
494 else if ( nMsg == WM_KILLFOCUS )
495 {
496 UnsetTmpDefault();
497 }
498 else if ( nMsg == WM_LBUTTONDBLCLK )
499 {
500 // emulate a click event to force an owner-drawn button to change its
501 // appearance - without this, it won't do it
502 (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
503
504 // and continue with processing the message normally as well
505 }
506 #if wxUSE_UXTHEME
507 else if ( nMsg == WM_THEMECHANGED )
508 {
509 // need to recalculate the best size here
510 // as the theme size might have changed
511 InvalidateBestSize();
512 }
513 else if ( wxUxThemeEngine::GetIfActive() )
514 {
515 // we need to Refresh() if mouse has entered or left window
516 // so we can update the hot tracking state
517 // must use m_mouseInWindow here instead of IsMouseInWindow()
518 // since we need to know the first time the mouse enters the window
519 // and IsMouseInWindow() would return true in this case
520 if ( ( nMsg == WM_MOUSEMOVE && !m_mouseInWindow ) ||
521 nMsg == WM_MOUSELEAVE )
522 {
523 Refresh();
524 }
525 }
526 #endif // wxUSE_UXTHEME
527
528 // let the base class do all real processing
529 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
530 }
531
532 // ----------------------------------------------------------------------------
533 // owner-drawn buttons support
534 // ----------------------------------------------------------------------------
535
536 #ifdef __WIN32__
537
538 // drawing helpers
539
540 static void DrawButtonText(HDC hdc,
541 RECT *pRect,
542 const wxString& text,
543 COLORREF col)
544 {
545 COLORREF colOld = SetTextColor(hdc, col);
546 int modeOld = SetBkMode(hdc, TRANSPARENT);
547
548 if ( text.find(_T('\n')) != wxString::npos )
549 {
550 // draw multiline label
551
552 // first we need to compute its bounding rect
553 RECT rc;
554 ::CopyRect(&rc, pRect);
555 ::DrawText(hdc, text, text.length(), &rc, DT_CENTER | DT_CALCRECT);
556
557 // now center this rect inside the entire button area
558 const LONG w = rc.right - rc.left;
559 const LONG h = rc.bottom - rc.top;
560 rc.left = (pRect->right - pRect->left)/2 - w/2;
561 rc.right = rc.left+w;
562 rc.top = (pRect->bottom - pRect->top)/2 - h/2;
563 rc.bottom = rc.top+h;
564
565 ::DrawText(hdc, text, text.length(), &rc, DT_CENTER);
566 }
567 else // single line label
568 {
569 // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
570 ::DrawText(hdc, text, text.length(), pRect,
571 DT_SINGLELINE | DT_CENTER | DT_VCENTER);
572 }
573
574 SetBkMode(hdc, modeOld);
575 SetTextColor(hdc, colOld);
576 }
577
578 static void DrawRect(HDC hdc, const RECT& r)
579 {
580 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
581 wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
582 wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
583 wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
584 }
585
586 void wxButton::MakeOwnerDrawn()
587 {
588 long style = GetWindowLong(GetHwnd(), GWL_STYLE);
589 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
590 {
591 // make it so
592 style |= BS_OWNERDRAW;
593 SetWindowLong(GetHwnd(), GWL_STYLE, style);
594 }
595 }
596
597 bool wxButton::SetBackgroundColour(const wxColour &colour)
598 {
599 if ( !wxControl::SetBackgroundColour(colour) )
600 {
601 // nothing to do
602 return false;
603 }
604
605 MakeOwnerDrawn();
606
607 Refresh();
608
609 return true;
610 }
611
612 bool wxButton::SetForegroundColour(const wxColour &colour)
613 {
614 if ( !wxControl::SetForegroundColour(colour) )
615 {
616 // nothing to do
617 return false;
618 }
619
620 MakeOwnerDrawn();
621
622 Refresh();
623
624 return true;
625 }
626
627 /*
628 The button frame looks like this normally:
629
630 WWWWWWWWWWWWWWWWWWB
631 WHHHHHHHHHHHHHHHHGB W = white (HILIGHT)
632 WH GB H = light grey (LIGHT)
633 WH GB G = dark grey (SHADOW)
634 WH GB B = black (DKSHADOW)
635 WH GB
636 WGGGGGGGGGGGGGGGGGB
637 BBBBBBBBBBBBBBBBBBB
638
639 When the button is selected, the button becomes like this (the total button
640 size doesn't change):
641
642 BBBBBBBBBBBBBBBBBBB
643 BWWWWWWWWWWWWWWWWBB
644 BWHHHHHHHHHHHHHHGBB
645 BWH GBB
646 BWH GBB
647 BWGGGGGGGGGGGGGGGBB
648 BBBBBBBBBBBBBBBBBBB
649 BBBBBBBBBBBBBBBBBBB
650
651 When the button is pushed (while selected) it is like:
652
653 BBBBBBBBBBBBBBBBBBB
654 BGGGGGGGGGGGGGGGGGB
655 BG GB
656 BG GB
657 BG GB
658 BG GB
659 BGGGGGGGGGGGGGGGGGB
660 BBBBBBBBBBBBBBBBBBB
661 */
662
663 static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
664 bool selected, bool pushed)
665 {
666 RECT r;
667 CopyRect(&r, &rectBtn);
668
669 HPEN hpenBlack = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
670 hpenGrey = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
671 hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
672 hpenWhite = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
673
674 HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
675
676 r.right--;
677 r.bottom--;
678
679 if ( pushed )
680 {
681 DrawRect(hdc, r);
682
683 (void)SelectObject(hdc, hpenGrey);
684 ::InflateRect(&r, -1, -1);
685
686 DrawRect(hdc, r);
687 }
688 else // !pushed
689 {
690 if ( selected )
691 {
692 DrawRect(hdc, r);
693
694 ::InflateRect(&r, -1, -1);
695 }
696
697 wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
698 wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
699
700 (void)SelectObject(hdc, hpenWhite);
701 wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
702 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
703
704 (void)SelectObject(hdc, hpenLightGr);
705 wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
706 wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
707
708 (void)SelectObject(hdc, hpenGrey);
709 wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
710 wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
711 }
712
713 (void)SelectObject(hdc, hpenOld);
714 DeleteObject(hpenWhite);
715 DeleteObject(hpenLightGr);
716 DeleteObject(hpenGrey);
717 DeleteObject(hpenBlack);
718 }
719
720 #if wxUSE_UXTHEME
721 static
722 void MSWDrawXPBackground(wxButton *button, WXDRAWITEMSTRUCT *wxdis)
723 {
724 LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
725 HDC hdc = lpDIS->hDC;
726 UINT state = lpDIS->itemState;
727 RECT rectBtn;
728 CopyRect(&rectBtn, &lpDIS->rcItem);
729
730 wxUxThemeHandle theme(button, L"BUTTON");
731 int iState;
732
733 if ( state & ODS_SELECTED )
734 {
735 iState = PBS_PRESSED;
736 }
737 else if ( button->HasCapture() || button->IsMouseInWindow() )
738 {
739 iState = PBS_HOT;
740 }
741 else if ( state & ODS_FOCUS )
742 {
743 iState = PBS_DEFAULTED;
744 }
745 else if ( state & ODS_DISABLED )
746 {
747 iState = PBS_DISABLED;
748 }
749 else
750 {
751 iState = PBS_NORMAL;
752 }
753
754 // draw parent background if needed
755 if ( wxUxThemeEngine::Get()->IsThemeBackgroundPartiallyTransparent(theme,
756 BP_PUSHBUTTON,
757 iState) )
758 {
759 wxUxThemeEngine::Get()->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
760 }
761
762 // draw background
763 wxUxThemeEngine::Get()->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
764 &rectBtn, NULL);
765
766 // calculate content area margins
767 MARGINS margins;
768 wxUxThemeEngine::Get()->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
769 TMT_CONTENTMARGINS, &rectBtn, &margins);
770 RECT rectClient;
771 ::CopyRect(&rectClient, &rectBtn);
772 ::InflateRect(&rectClient, -margins.cxLeftWidth, -margins.cyTopHeight);
773
774 // if focused and !nofocus rect
775 if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
776 {
777 DrawFocusRect(hdc, &rectClient);
778 }
779
780 if ( button->UseBgCol() )
781 {
782 COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
783 HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
784
785 // don't overwrite the focus rect
786 ::InflateRect(&rectClient, -1, -1);
787 FillRect(hdc, &rectClient, hbrushBackground);
788 ::DeleteObject(hbrushBackground);
789 }
790 }
791 #endif // wxUSE_UXTHEME
792
793 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
794 {
795 LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
796 HDC hdc = lpDIS->hDC;
797 UINT state = lpDIS->itemState;
798 RECT rectBtn;
799 CopyRect(&rectBtn, &lpDIS->rcItem);
800
801 #if wxUSE_UXTHEME
802 if ( wxUxThemeEngine::GetIfActive() )
803 {
804 MSWDrawXPBackground(this, wxdis);
805 }
806 else
807 #endif // wxUSE_UXTHEME
808 {
809 COLORREF colBg = wxColourToRGB(GetBackgroundColour());
810
811 // first, draw the background
812 HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
813 FillRect(hdc, &rectBtn, hbrushBackground);
814 ::DeleteObject(hbrushBackground);
815
816 // draw the border for the current state
817 bool selected = (state & ODS_SELECTED) != 0;
818 if ( !selected )
819 {
820 wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
821 if ( panel )
822 {
823 selected = panel->GetDefaultItem() == this;
824 }
825 }
826 bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
827
828 DrawButtonFrame(hdc, rectBtn, selected, pushed);
829
830 // if focused and !nofocus rect
831 if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
832 {
833 RECT rectFocus;
834 CopyRect(&rectFocus, &rectBtn);
835
836 // I don't know where does this constant come from, but this is how
837 // Windows draws them
838 InflateRect(&rectFocus, -4, -4);
839
840 DrawFocusRect(hdc, &rectFocus);
841 }
842
843 if ( pushed )
844 {
845 // the label is shifted by 1 pixel to create "pushed" effect
846 OffsetRect(&rectBtn, 1, 1);
847 }
848 }
849
850 COLORREF colFg = wxColourToRGB(GetForegroundColour());
851 DrawButtonText(hdc, &rectBtn,
852 (state & ODS_NOACCEL ? wxStripMenuCodes(GetLabel())
853 : GetLabel()),
854 state & ODS_DISABLED ? GetSysColor(COLOR_GRAYTEXT)
855 : colFg);
856
857 return true;
858 }
859
860 #endif // __WIN32__
861
862 #endif // wxUSE_BUTTON
wxWidgets (Impactor)