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