projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Don't increase button height in wxMSWButton::GetFittingSize().
[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 #include "wx/msw/wrapcctl.h"
41 #include "wx/msw/private.h"
42 #include "wx/msw/missing.h"
43 #endif
44
45 #include "wx/imaglist.h"
46 #include "wx/stockitem.h"
47 #include "wx/msw/private/button.h"
48 #include "wx/msw/private/dc.h"
49 #include "wx/private/window.h"
50
51 using namespace wxMSWImpl;
52
53 #if wxUSE_UXTHEME
54 #include "wx/msw/uxtheme.h"
55
56 // no need to include tmschema.h
57 #ifndef BP_PUSHBUTTON
58 #define BP_PUSHBUTTON 1
59
60 #define PBS_NORMAL 1
61 #define PBS_HOT 2
62 #define PBS_PRESSED 3
63 #define PBS_DISABLED 4
64 #define PBS_DEFAULTED 5
65
66 #define TMT_CONTENTMARGINS 3602
67 #endif
68
69 // provide the necessary declarations ourselves if they're missing from
70 // headers
71 #ifndef BCM_SETIMAGELIST
72 #define BCM_SETIMAGELIST 0x1602
73 #define BCM_SETTEXTMARGIN 0x1604
74
75 enum
76 {
77 BUTTON_IMAGELIST_ALIGN_LEFT,
78 BUTTON_IMAGELIST_ALIGN_RIGHT,
79 BUTTON_IMAGELIST_ALIGN_TOP,
80 BUTTON_IMAGELIST_ALIGN_BOTTOM
81 };
82
83 struct BUTTON_IMAGELIST
84 {
85 HIMAGELIST himl;
86 RECT margin;
87 UINT uAlign;
88 };
89 #endif
90 #endif // wxUSE_UXTHEME
91
92 #ifndef WM_THEMECHANGED
93 #define WM_THEMECHANGED 0x031A
94 #endif
95
96 #ifndef ODS_NOACCEL
97 #define ODS_NOACCEL 0x0100
98 #endif
99
100 #ifndef ODS_NOFOCUSRECT
101 #define ODS_NOFOCUSRECT 0x0200
102 #endif
103
104 #ifndef DT_HIDEPREFIX
105 #define DT_HIDEPREFIX 0x00100000
106 #endif
107
108 // set the value for BCM_SETSHIELD (for the UAC shield) if it's not defined in
109 // the header
110 #ifndef BCM_SETSHIELD
111 #define BCM_SETSHIELD 0x160c
112 #endif
113
114 // ----------------------------------------------------------------------------
115 // button image data
116 // ----------------------------------------------------------------------------
117
118 // we use different data classes for owner drawn buttons and for themed XP ones
119
120 class wxButtonImageData
121 {
122 public:
123 wxButtonImageData() { }
124 virtual ~wxButtonImageData() { }
125
126 virtual wxBitmap GetBitmap(wxButton::State which) const = 0;
127 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which) = 0;
128
129 virtual wxSize GetBitmapMargins() const = 0;
130 virtual void SetBitmapMargins(wxCoord x, wxCoord y) = 0;
131
132 virtual wxDirection GetBitmapPosition() const = 0;
133 virtual void SetBitmapPosition(wxDirection dir) = 0;
134
135 private:
136 wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
137 };
138
139 namespace
140 {
141
142 // the gap between button edge and the interior area used by Windows for the
143 // standard buttons
144 const int OD_BUTTON_MARGIN = 4;
145
146 class wxODButtonImageData : public wxButtonImageData
147 {
148 public:
149 wxODButtonImageData(wxButton *btn, const wxBitmap& bitmap)
150 {
151 SetBitmap(bitmap, wxButton::State_Normal);
152
153 m_dir = wxLEFT;
154
155 // we use margins when we have both bitmap and text, but when we have
156 // only the bitmap it should take up the entire button area
157 if ( btn->ShowsLabel() )
158 {
159 m_margin.x = btn->GetCharWidth();
160 m_margin.y = btn->GetCharHeight() / 2;
161 }
162 }
163
164 virtual wxBitmap GetBitmap(wxButton::State which) const
165 {
166 return m_bitmaps[which];
167 }
168
169 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
170 {
171 m_bitmaps[which] = bitmap;
172 }
173
174 virtual wxSize GetBitmapMargins() const
175 {
176 return m_margin;
177 }
178
179 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
180 {
181 m_margin = wxSize(x, y);
182 }
183
184 virtual wxDirection GetBitmapPosition() const
185 {
186 return m_dir;
187 }
188
189 virtual void SetBitmapPosition(wxDirection dir)
190 {
191 m_dir = dir;
192 }
193
194 private:
195 // just store the values passed to us to be able to retrieve them later
196 // from the drawing code
197 wxBitmap m_bitmaps[wxButton::State_Max];
198 wxSize m_margin;
199 wxDirection m_dir;
200
201 wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
202 };
203
204 #if wxUSE_UXTHEME
205
206 // somehow the margin is one pixel greater than the value returned by
207 // GetThemeMargins() call
208 const int XP_BUTTON_EXTRA_MARGIN = 1;
209
210 class wxXPButtonImageData : public wxButtonImageData
211 {
212 public:
213 // we must be constructed with the size of our images as we need to create
214 // the image list
215 wxXPButtonImageData(wxButton *btn, const wxBitmap& bitmap)
216 : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
217 wxButton::State_Max),
218 m_hwndBtn(GetHwndOf(btn))
219 {
220 // initialize all bitmaps to normal state
221 for ( int n = 0; n < wxButton::State_Max; n++ )
222 {
223 m_iml.Add(bitmap);
224 }
225
226 m_data.himl = GetHimagelistOf(&m_iml);
227
228 // no margins by default
229 m_data.margin.left =
230 m_data.margin.right =
231 m_data.margin.top =
232 m_data.margin.bottom = 0;
233
234 // use default alignment
235 m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
236
237 UpdateImageInfo();
238 }
239
240 virtual wxBitmap GetBitmap(wxButton::State which) const
241 {
242 return m_iml.GetBitmap(which);
243 }
244
245 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
246 {
247 m_iml.Replace(which, bitmap);
248
249 UpdateImageInfo();
250 }
251
252 virtual wxSize GetBitmapMargins() const
253 {
254 return wxSize(m_data.margin.left, m_data.margin.top);
255 }
256
257 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
258 {
259 RECT& margin = m_data.margin;
260 margin.left =
261 margin.right = x;
262 margin.top =
263 margin.bottom = y;
264
265 if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
266 {
267 wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
268 }
269 }
270
271 virtual wxDirection GetBitmapPosition() const
272 {
273 switch ( m_data.uAlign )
274 {
275 default:
276 wxFAIL_MSG( "invalid image alignment" );
277 // fall through
278
279 case BUTTON_IMAGELIST_ALIGN_LEFT:
280 return wxLEFT;
281
282 case BUTTON_IMAGELIST_ALIGN_RIGHT:
283 return wxRIGHT;
284
285 case BUTTON_IMAGELIST_ALIGN_TOP:
286 return wxTOP;
287
288 case BUTTON_IMAGELIST_ALIGN_BOTTOM:
289 return wxBOTTOM;
290 }
291 }
292
293 virtual void SetBitmapPosition(wxDirection dir)
294 {
295 UINT alignNew;
296 switch ( dir )
297 {
298 default:
299 wxFAIL_MSG( "invalid direction" );
300 // fall through
301
302 case wxLEFT:
303 alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
304 break;
305
306 case wxRIGHT:
307 alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
308 break;
309
310 case wxTOP:
311 alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
312 break;
313
314 case wxBOTTOM:
315 alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
316 break;
317 }
318
319 if ( alignNew != m_data.uAlign )
320 {
321 m_data.uAlign = alignNew;
322 UpdateImageInfo();
323 }
324 }
325
326 private:
327 void UpdateImageInfo()
328 {
329 if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
330 {
331 wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
332 }
333 }
334
335 // we store image list separately to be able to use convenient wxImageList
336 // methods instead of working with raw HIMAGELIST
337 wxImageList m_iml;
338
339 // store the rest of the data in BCM_SETIMAGELIST-friendly form
340 BUTTON_IMAGELIST m_data;
341
342 // the button we're associated with
343 const HWND m_hwndBtn;
344
345
346 wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
347 };
348
349 #endif // wxUSE_UXTHEME
350
351 } // anonymous namespace
352
353 // ----------------------------------------------------------------------------
354 // macros
355 // ----------------------------------------------------------------------------
356
357 // ============================================================================
358 // implementation
359 // ============================================================================
360
361 // ----------------------------------------------------------------------------
362 // helper functions from wx/msw/private/button.h
363 // ----------------------------------------------------------------------------
364
365 void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
366 {
367 // update BS_MULTILINE style depending on the new label (resetting it
368 // doesn't seem to do anything very useful but it shouldn't hurt and we do
369 // have to set it whenever the label becomes multi line as otherwise it
370 // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
371 // the control unless it already has new lines in its label)
372 long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
373 styleNew;
374 if ( label.find(wxT('\n')) != wxString::npos )
375 styleNew = styleOld | BS_MULTILINE;
376 else
377 styleNew = styleOld & ~BS_MULTILINE;
378
379 if ( styleNew != styleOld )
380 ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
381 }
382
383 wxSize wxMSWButton::GetFittingSize(wxWindow *win,
384 const wxSize& sizeLabel,
385 int flags)
386 {
387 // FIXME: this is pure guesswork, need to retrieve the real button margins
388 wxSize sizeBtn = sizeLabel;
389
390 sizeBtn.x += 3*win->GetCharWidth();
391
392 // account for the shield UAC icon if we have it
393 if ( flags & Size_AuthNeeded )
394 sizeBtn.x += wxSystemSettings::GetMetric(wxSYS_SMALLICON_X);
395
396 return sizeBtn;
397 }
398
399 wxSize wxMSWButton::ComputeBestFittingSize(wxControl *btn, int flags)
400 {
401 wxClientDC dc(btn);
402
403 wxSize sizeBtn;
404 dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
405
406 return GetFittingSize(btn, sizeBtn, flags);
407 }
408
409 wxSize wxMSWButton::IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size)
410 {
411 wxSize sizeBtn(size);
412
413 // all buttons have at least the standard size unless the user explicitly
414 // wants them to be of smaller size and used wxBU_EXACTFIT style when
415 // creating the button
416 if ( !btn->HasFlag(wxBU_EXACTFIT) )
417 {
418 // The 50x14 button size is documented in the "Recommended sizing and
419 // spacing" section of MSDN layout article.
420 //
421 // Note that we intentionally don't use GetDefaultSize() here, because
422 // it's inexact -- dialog units depend on this dialog's font.
423 wxSize sizeDef = btn->ConvertDialogToPixels(wxSize(50, 14));
424 if ( sizeBtn.x < sizeDef.x )
425 sizeBtn.x = sizeDef.x;
426 if ( sizeBtn.y < sizeDef.y )
427 sizeBtn.y = sizeDef.y;
428 }
429
430 btn->CacheBestSize(sizeBtn);
431
432 return sizeBtn;
433 }
434
435 // ----------------------------------------------------------------------------
436 // creation/destruction
437 // ----------------------------------------------------------------------------
438
439 bool wxButton::Create(wxWindow *parent,
440 wxWindowID id,
441 const wxString& lbl,
442 const wxPoint& pos,
443 const wxSize& size,
444 long style,
445 const wxValidator& validator,
446 const wxString& name)
447 {
448 m_authNeeded = false;
449
450 wxString label(lbl);
451 if (label.empty() && wxIsStockID(id))
452 {
453 // On Windows, some buttons aren't supposed to have mnemonics
454 label = wxGetStockLabel
455 (
456 id,
457 id == wxID_OK || id == wxID_CANCEL || id == wxID_CLOSE
458 ? wxSTOCK_NOFLAGS
459 : wxSTOCK_WITH_MNEMONIC
460 );
461 }
462
463 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
464 return false;
465
466 WXDWORD exstyle;
467 WXDWORD msStyle = MSWGetStyle(style, &exstyle);
468
469 // if the label contains several lines we must explicitly tell the button
470 // about it or it wouldn't draw it correctly ("\n"s would just appear as
471 // black boxes)
472 //
473 // NB: we do it here and not in MSWGetStyle() because we need the label
474 // value and the label is not set yet when MSWGetStyle() is called
475 msStyle |= wxMSWButton::GetMultilineStyle(label);
476
477 return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, exstyle);
478 }
479
480 wxButton::~wxButton()
481 {
482 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
483 if ( tlw && tlw->GetTmpDefaultItem() == this )
484 {
485 UnsetTmpDefault();
486 }
487
488 delete m_imageData;
489 }
490
491 // ----------------------------------------------------------------------------
492 // flags
493 // ----------------------------------------------------------------------------
494
495 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
496 {
497 // buttons never have an external border, they draw their own one
498 WXDWORD msStyle = wxControl::MSWGetStyle
499 (
500 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
501 );
502
503 // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
504 // each other in any resizeable dialog which has more than one button in
505 // the bottom
506 msStyle |= WS_CLIPSIBLINGS;
507
508 // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
509 // and wxBU_RIGHT to get BS_CENTER!
510 if ( style & wxBU_LEFT )
511 msStyle |= BS_LEFT;
512 if ( style & wxBU_RIGHT )
513 msStyle |= BS_RIGHT;
514 if ( style & wxBU_TOP )
515 msStyle |= BS_TOP;
516 if ( style & wxBU_BOTTOM )
517 msStyle |= BS_BOTTOM;
518 #ifndef __WXWINCE__
519 // flat 2d buttons
520 if ( style & wxNO_BORDER )
521 msStyle |= BS_FLAT;
522 #endif // __WXWINCE__
523
524 return msStyle;
525 }
526
527 void wxButton::SetLabel(const wxString& label)
528 {
529 wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
530
531 wxButtonBase::SetLabel(label);
532 }
533
534 // ----------------------------------------------------------------------------
535 // size management including autosizing
536 // ----------------------------------------------------------------------------
537
538 void wxButton::AdjustForBitmapSize(wxSize &size) const
539 {
540 wxCHECK_RET( m_imageData, wxT("shouldn't be called if no image") );
541
542 // account for the bitmap size
543 const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
544 const wxDirection dirBmp = m_imageData->GetBitmapPosition();
545 if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
546 {
547 size.x += sizeBmp.x;
548 if ( sizeBmp.y > size.y )
549 size.y = sizeBmp.y;
550 }
551 else // bitmap on top/below the text
552 {
553 size.y += sizeBmp.y;
554 if ( sizeBmp.x > size.x )
555 size.x = sizeBmp.x;
556 }
557
558 // account for the user-specified margins
559 size += 2*m_imageData->GetBitmapMargins();
560
561 // and also for the margins we always add internally (unless we have no
562 // border at all in which case the button has exactly the same size as
563 // bitmap and so no margins should be used)
564 if ( !HasFlag(wxBORDER_NONE) )
565 {
566 int marginH = 0,
567 marginV = 0;
568 #if wxUSE_UXTHEME
569 if ( wxUxThemeEngine::GetIfActive() )
570 {
571 wxUxThemeHandle theme(const_cast<wxButton *>(this), L"BUTTON");
572
573 MARGINS margins;
574 wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
575 BP_PUSHBUTTON,
576 PBS_NORMAL,
577 TMT_CONTENTMARGINS,
578 NULL,
579 &margins);
580
581 // XP doesn't draw themed buttons correctly when the client
582 // area is smaller than 8x8 - enforce this minimum size for
583 // small bitmaps
584 size.IncTo(wxSize(8, 8));
585
586 marginH = margins.cxLeftWidth + margins.cxRightWidth
587 + 2*XP_BUTTON_EXTRA_MARGIN;
588 marginV = margins.cyTopHeight + margins.cyBottomHeight
589 + 2*XP_BUTTON_EXTRA_MARGIN;
590 }
591 else
592 #endif // wxUSE_UXTHEME
593 {
594 marginH =
595 marginV = OD_BUTTON_MARGIN;
596 }
597
598 size.IncBy(marginH, marginV);
599 }
600 }
601
602 wxSize wxButton::DoGetBestSize() const
603 {
604 wxButton * const self = const_cast<wxButton *>(this);
605
606 wxSize size;
607
608 // Account for the text part if we have it.
609 if ( ShowsLabel() )
610 {
611 int flags = 0;
612 if ( GetAuthNeeded() )
613 flags |= wxMSWButton::Size_AuthNeeded;
614
615 size = wxMSWButton::ComputeBestFittingSize(self, flags);
616 }
617
618 if ( m_imageData )
619 AdjustForBitmapSize(size);
620
621 return wxMSWButton::IncreaseToStdSizeAndCache(self, size);
622 }
623
624 /* static */
625 wxSize wxButtonBase::GetDefaultSize()
626 {
627 static wxSize s_sizeBtn;
628
629 if ( s_sizeBtn.x == 0 )
630 {
631 wxScreenDC dc;
632 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
633
634 // The size of a standard button in the dialog units is 50x14,
635 // translate this to pixels.
636 //
637 // Windows' computes dialog units using average character width over
638 // upper- and lower-case ASCII alphabet and not using the average
639 // character width metadata stored in the font; see
640 // http://support.microsoft.com/default.aspx/kb/145994 for detailed
641 // discussion.
642 //
643 // NB: wxMulDivInt32() is used, because it correctly rounds the result
644
645 const wxSize base = wxPrivate::GetAverageASCIILetterSize(dc);
646 s_sizeBtn.x = wxMulDivInt32(50, base.x, 4);
647 s_sizeBtn.y = wxMulDivInt32(14, base.y, 8);
648 }
649
650 return s_sizeBtn;
651 }
652
653 // ----------------------------------------------------------------------------
654 // default button handling
655 // ----------------------------------------------------------------------------
656
657 /*
658 The comment below and all this code is probably due to not using WM_NEXTDLGCTL
659 message when changing focus (but just SetFocus() which is not enough), see
660 http://blogs.msdn.com/oldnewthing/archive/2004/08/02/205624.aspx for the
661 full explanation.
662
663 TODO: Do use WM_NEXTDLGCTL and get rid of all this code.
664
665
666 "Everything you ever wanted to know about the default buttons" or "Why do we
667 have to do all this?"
668
669 In MSW the default button should be activated when the user presses Enter
670 and the current control doesn't process Enter itself somehow. This is
671 handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
672 Another aspect of "defaultness" is that the default button has different
673 appearance: this is due to BS_DEFPUSHBUTTON style which is completely
674 separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
675 be unset if our parent window is not active so it should be unset whenever
676 we lose activation and set back when we regain it.
677
678 Final complication is that when a button is active, it should be the default
679 one, i.e. pressing Enter on a button always activates it and not another
680 one.
681
682 We handle this by maintaining a permanent and a temporary default items in
683 wxControlContainer (both may be NULL). When a button becomes the current
684 control (i.e. gets focus) it sets itself as the temporary default which
685 ensures that it has the right appearance and that Enter will be redirected
686 to it. When the button loses focus, it unsets the temporary default and so
687 the default item will be the permanent default -- that is the default button
688 if any had been set or none otherwise, which is just what we want.
689
690 NB: all this is quite complicated by now and the worst is that normally
691 it shouldn't be necessary at all as for the normal Windows programs
692 DefWindowProc() and IsDialogMessage() take care of all this
693 automatically -- however in wxWidgets programs this doesn't work for
694 nested hierarchies (i.e. a notebook inside a notebook) for unknown
695 reason and so we have to reproduce all this code ourselves. It would be
696 very nice if we could avoid doing it.
697 */
698
699 // set this button as the (permanently) default one in its panel
700 wxWindow *wxButton::SetDefault()
701 {
702 // set this one as the default button both for wxWidgets ...
703 wxWindow *winOldDefault = wxButtonBase::SetDefault();
704
705 // ... and Windows
706 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
707 SetDefaultStyle(this, true);
708
709 return winOldDefault;
710 }
711
712 // return the top level parent window if it's not being deleted yet, otherwise
713 // return NULL
714 static wxTopLevelWindow *GetTLWParentIfNotBeingDeleted(wxWindow *win)
715 {
716 for ( ;; )
717 {
718 // IsTopLevel() will return false for a wxTLW being deleted, so we also
719 // need the parent test for this case
720 wxWindow * const parent = win->GetParent();
721 if ( !parent || win->IsTopLevel() )
722 {
723 if ( win->IsBeingDeleted() )
724 return NULL;
725
726 break;
727 }
728
729 win = parent;
730 }
731
732 wxASSERT_MSG( win, wxT("button without top level parent?") );
733
734 wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
735 wxASSERT_MSG( tlw, wxT("logic error in GetTLWParentIfNotBeingDeleted()") );
736
737 return tlw;
738 }
739
740 // set this button as being currently default
741 void wxButton::SetTmpDefault()
742 {
743 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
744 if ( !tlw )
745 return;
746
747 wxWindow *winOldDefault = tlw->GetDefaultItem();
748 tlw->SetTmpDefaultItem(this);
749
750 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
751 SetDefaultStyle(this, true);
752 }
753
754 // unset this button as currently default, it may still stay permanent default
755 void wxButton::UnsetTmpDefault()
756 {
757 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
758 if ( !tlw )
759 return;
760
761 tlw->SetTmpDefaultItem(NULL);
762
763 wxWindow *winOldDefault = tlw->GetDefaultItem();
764
765 SetDefaultStyle(this, false);
766 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
767 }
768
769 /* static */
770 void
771 wxButton::SetDefaultStyle(wxButton *btn, bool on)
772 {
773 // we may be called with NULL pointer -- simpler to do the check here than
774 // in the caller which does wxDynamicCast()
775 if ( !btn )
776 return;
777
778 // first, let DefDlgProc() know about the new default button
779 if ( on )
780 {
781 // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
782 // focus at all any more
783 if ( !wxTheApp->IsActive() )
784 return;
785
786 wxWindow * const tlw = wxGetTopLevelParent(btn);
787 wxCHECK_RET( tlw, wxT("button without top level window?") );
788
789 ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
790
791 // sending DM_SETDEFID also changes the button style to
792 // BS_DEFPUSHBUTTON so there is nothing more to do
793 }
794
795 // then also change the style as needed
796 long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
797 if ( !(style & BS_DEFPUSHBUTTON) == on )
798 {
799 // don't do it with the owner drawn buttons because it will
800 // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
801 // BS_DEFPUSHBUTTON != 0)!
802 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
803 {
804 ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
805 on ? style | BS_DEFPUSHBUTTON
806 : style & ~BS_DEFPUSHBUTTON,
807 1L /* redraw */);
808 }
809 else // owner drawn
810 {
811 // redraw the button - it will notice itself that it's
812 // [not] the default one [any longer]
813 btn->Refresh();
814 }
815 }
816 //else: already has correct style
817 }
818
819 // ----------------------------------------------------------------------------
820 // helpers
821 // ----------------------------------------------------------------------------
822
823 bool wxButton::SendClickEvent()
824 {
825 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
826 event.SetEventObject(this);
827
828 return ProcessCommand(event);
829 }
830
831 void wxButton::Command(wxCommandEvent & event)
832 {
833 ProcessCommand(event);
834 }
835
836 // ----------------------------------------------------------------------------
837 // event/message handlers
838 // ----------------------------------------------------------------------------
839
840 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
841 {
842 bool processed = false;
843 switch ( param )
844 {
845 // NOTE: Apparently older versions (NT 4?) of the common controls send
846 // BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
847 // buttons, so in order to send two EVT_BUTTON events we should
848 // catch both types. Currently (Feb 2003) up-to-date versions of
849 // win98, win2k and winXP all send two BN_CLICKED messages for
850 // all button types, so we don't catch BN_DOUBLECLICKED anymore
851 // in order to not get 3 EVT_BUTTON events. If this is a problem
852 // then we need to figure out which version of the comctl32 changed
853 // this behaviour and test for it.
854
855 case 1: // message came from an accelerator
856 case BN_CLICKED: // normal buttons send this
857 processed = SendClickEvent();
858 break;
859 }
860
861 return processed;
862 }
863
864 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
865 {
866 // when we receive focus, we want to temporarily become the default button in
867 // our parent panel so that pressing "Enter" would activate us -- and when
868 // losing it we should restore the previous default button as well
869 if ( nMsg == WM_SETFOCUS )
870 {
871 SetTmpDefault();
872
873 // let the default processing take place too
874 }
875 else if ( nMsg == WM_KILLFOCUS )
876 {
877 UnsetTmpDefault();
878 }
879 else if ( nMsg == WM_LBUTTONDBLCLK )
880 {
881 // emulate a click event to force an owner-drawn button to change its
882 // appearance - without this, it won't do it
883 (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
884
885 // and continue with processing the message normally as well
886 }
887 #if wxUSE_UXTHEME
888 else if ( nMsg == WM_THEMECHANGED )
889 {
890 // need to recalculate the best size here
891 // as the theme size might have changed
892 InvalidateBestSize();
893 }
894 #endif // wxUSE_UXTHEME
895 // must use m_mouseInWindow here instead of IsMouseInWindow()
896 // since we need to know the first time the mouse enters the window
897 // and IsMouseInWindow() would return true in this case
898 else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
899 nMsg == WM_MOUSELEAVE )
900 {
901 if (
902 IsEnabled() &&
903 (
904 #if wxUSE_UXTHEME
905 wxUxThemeEngine::GetIfActive() ||
906 #endif // wxUSE_UXTHEME
907 (m_imageData && m_imageData->GetBitmap(State_Current).IsOk())
908 )
909 )
910 {
911 Refresh();
912 }
913 }
914
915 // let the base class do all real processing
916 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
917 }
918
919 // ----------------------------------------------------------------------------
920 // authentication needed handling
921 // ----------------------------------------------------------------------------
922
923 bool wxButton::DoGetAuthNeeded() const
924 {
925 return m_authNeeded;
926 }
927
928 void wxButton::DoSetAuthNeeded(bool show)
929 {
930 // show/hide UAC symbol on Windows Vista and later
931 if ( wxGetWinVersion() >= wxWinVersion_6 )
932 {
933 m_authNeeded = show;
934 ::SendMessage(GetHwnd(), BCM_SETSHIELD, 0, show);
935 InvalidateBestSize();
936 }
937 }
938
939 // ----------------------------------------------------------------------------
940 // button images
941 // ----------------------------------------------------------------------------
942
943 wxBitmap wxButton::DoGetBitmap(State which) const
944 {
945 return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
946 }
947
948 void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
949 {
950 // allocate the image data when the first bitmap is set
951 if ( !m_imageData )
952 {
953 #if wxUSE_UXTHEME
954 // using image list doesn't work correctly if we don't have any label
955 // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
956 // BS_BITMAP style), at least under Windows 2003 so use owner drawn
957 // strategy for bitmap-only buttons
958 if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
959 {
960 m_imageData = new wxXPButtonImageData(this, bitmap);
961 }
962 else
963 #endif // wxUSE_UXTHEME
964 {
965 m_imageData = new wxODButtonImageData(this, bitmap);
966 MakeOwnerDrawn();
967 }
968 }
969 else
970 {
971 m_imageData->SetBitmap(bitmap, which);
972 }
973
974 // it should be enough to only invalidate the best size when the normal
975 // bitmap changes as all bitmaps assigned to the button should be of the
976 // same size anyhow
977 if ( which == State_Normal )
978 InvalidateBestSize();
979
980 Refresh();
981 }
982
983 wxSize wxButton::DoGetBitmapMargins() const
984 {
985 return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
986 }
987
988 void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
989 {
990 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
991
992 m_imageData->SetBitmapMargins(x, y);
993 InvalidateBestSize();
994 }
995
996 void wxButton::DoSetBitmapPosition(wxDirection dir)
997 {
998 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
999
1000 m_imageData->SetBitmapPosition(dir);
1001 InvalidateBestSize();
1002 }
1003
1004 // ----------------------------------------------------------------------------
1005 // owner-drawn buttons support
1006 // ----------------------------------------------------------------------------
1007
1008 // drawing helpers
1009 namespace
1010 {
1011
1012 // return the button state using both the ODS_XXX flags specified in state
1013 // parameter and the current button state
1014 wxButton::State GetButtonState(wxButton *btn, UINT state)
1015 {
1016 if ( state & ODS_DISABLED )
1017 return wxButton::State_Disabled;
1018
1019 if ( state & ODS_SELECTED )
1020 return wxButton::State_Pressed;
1021
1022 if ( btn->HasCapture() || btn->IsMouseInWindow() )
1023 return wxButton::State_Current;
1024
1025 if ( state & ODS_FOCUS )
1026 return wxButton::State_Focused;
1027
1028 return wxButton::State_Normal;
1029 }
1030
1031 void DrawButtonText(HDC hdc,
1032 RECT *pRect,
1033 const wxString& text,
1034 COLORREF col,
1035 int flags)
1036 {
1037 wxTextColoursChanger changeFg(hdc, col, CLR_INVALID);
1038 wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
1039
1040 // center text horizontally in any case
1041 flags |= DT_CENTER;
1042
1043 if ( text.find(wxT('\n')) != wxString::npos )
1044 {
1045 // draw multiline label
1046
1047 // first we need to compute its bounding rect
1048 RECT rc;
1049 ::CopyRect(&rc, pRect);
1050 ::DrawText(hdc, text.wx_str(), text.length(), &rc,
1051 DT_CENTER | DT_CALCRECT);
1052
1053 // now center this rect inside the entire button area
1054 const LONG w = rc.right - rc.left;
1055 const LONG h = rc.bottom - rc.top;
1056 rc.left = (pRect->right - pRect->left)/2 - w/2;
1057 rc.right = rc.left+w;
1058 rc.top = (pRect->bottom - pRect->top)/2 - h/2;
1059 rc.bottom = rc.top+h;
1060
1061 ::DrawText(hdc, text.wx_str(), text.length(), &rc, flags);
1062 }
1063 else // single line label
1064 {
1065 // centre text vertically too (notice that we must have DT_SINGLELINE
1066 // for DT_VCENTER to work)
1067 ::DrawText(hdc, text.wx_str(), text.length(), pRect,
1068 flags | DT_SINGLELINE | DT_VCENTER);
1069 }
1070 }
1071
1072 void DrawRect(HDC hdc, const RECT& r)
1073 {
1074 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
1075 wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
1076 wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
1077 wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
1078 }
1079
1080 /*
1081 The button frame looks like this normally:
1082
1083 WWWWWWWWWWWWWWWWWWB
1084 WHHHHHHHHHHHHHHHHGB W = white (HILIGHT)
1085 WH GB H = light grey (LIGHT)
1086 WH GB G = dark grey (SHADOW)
1087 WH GB B = black (DKSHADOW)
1088 WH GB
1089 WGGGGGGGGGGGGGGGGGB
1090 BBBBBBBBBBBBBBBBBBB
1091
1092 When the button is selected, the button becomes like this (the total button
1093 size doesn't change):
1094
1095 BBBBBBBBBBBBBBBBBBB
1096 BWWWWWWWWWWWWWWWWBB
1097 BWHHHHHHHHHHHHHHGBB
1098 BWH GBB
1099 BWH GBB
1100 BWGGGGGGGGGGGGGGGBB
1101 BBBBBBBBBBBBBBBBBBB
1102 BBBBBBBBBBBBBBBBBBB
1103
1104 When the button is pushed (while selected) it is like:
1105
1106 BBBBBBBBBBBBBBBBBBB
1107 BGGGGGGGGGGGGGGGGGB
1108 BG GB
1109 BG GB
1110 BG GB
1111 BG GB
1112 BGGGGGGGGGGGGGGGGGB
1113 BBBBBBBBBBBBBBBBBBB
1114 */
1115 void DrawButtonFrame(HDC hdc, RECT& rectBtn,
1116 bool selected, bool pushed)
1117 {
1118 RECT r;
1119 CopyRect(&r, &rectBtn);
1120
1121 AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
1122 hpenGrey(GetSysColor(COLOR_3DSHADOW)),
1123 hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
1124 hpenWhite(GetSysColor(COLOR_3DHILIGHT));
1125
1126 SelectInHDC selectPen(hdc, hpenBlack);
1127
1128 r.right--;
1129 r.bottom--;
1130
1131 if ( pushed )
1132 {
1133 DrawRect(hdc, r);
1134
1135 (void)SelectObject(hdc, hpenGrey);
1136 ::InflateRect(&r, -1, -1);
1137
1138 DrawRect(hdc, r);
1139 }
1140 else // !pushed
1141 {
1142 if ( selected )
1143 {
1144 DrawRect(hdc, r);
1145
1146 ::InflateRect(&r, -1, -1);
1147 }
1148
1149 wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
1150 wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
1151
1152 (void)SelectObject(hdc, hpenWhite);
1153 wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
1154 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
1155
1156 (void)SelectObject(hdc, hpenLightGr);
1157 wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
1158 wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
1159
1160 (void)SelectObject(hdc, hpenGrey);
1161 wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
1162 wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
1163 }
1164
1165 InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
1166 }
1167
1168 #if wxUSE_UXTHEME
1169 void DrawXPBackground(wxButton *button, HDC hdc, RECT& rectBtn, UINT state)
1170 {
1171 wxUxThemeHandle theme(button, L"BUTTON");
1172
1173 // this array is indexed by wxButton::State values and so must be kept in
1174 // sync with it
1175 static const int uxStates[] =
1176 {
1177 PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
1178 };
1179
1180 int iState = uxStates[GetButtonState(button, state)];
1181
1182 wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
1183
1184 // draw parent background if needed
1185 if ( engine->IsThemeBackgroundPartiallyTransparent
1186 (
1187 theme,
1188 BP_PUSHBUTTON,
1189 iState
1190 ) )
1191 {
1192 engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
1193 }
1194
1195 // draw background
1196 engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
1197 &rectBtn, NULL);
1198
1199 // calculate content area margins
1200 MARGINS margins;
1201 engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
1202 TMT_CONTENTMARGINS, &rectBtn, &margins);
1203 ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
1204 ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
1205
1206 if ( button->UseBgCol() )
1207 {
1208 COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
1209 AutoHBRUSH hbrushBackground(colBg);
1210
1211 // don't overwrite the focus rect
1212 RECT rectClient;
1213 ::CopyRect(&rectClient, &rectBtn);
1214 ::InflateRect(&rectClient, -1, -1);
1215 FillRect(hdc, &rectClient, hbrushBackground);
1216 }
1217 }
1218 #endif // wxUSE_UXTHEME
1219
1220 } // anonymous namespace
1221
1222 // ----------------------------------------------------------------------------
1223 // owner drawn buttons support
1224 // ----------------------------------------------------------------------------
1225
1226 void wxButton::MakeOwnerDrawn()
1227 {
1228 long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1229 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
1230 {
1231 // make it so
1232 style |= BS_OWNERDRAW;
1233 SetWindowLong(GetHwnd(), GWL_STYLE, style);
1234 }
1235 }
1236
1237 bool wxButton::SetBackgroundColour(const wxColour &colour)
1238 {
1239 if ( !wxControl::SetBackgroundColour(colour) )
1240 {
1241 // nothing to do
1242 return false;
1243 }
1244
1245 MakeOwnerDrawn();
1246
1247 Refresh();
1248
1249 return true;
1250 }
1251
1252 bool wxButton::SetForegroundColour(const wxColour &colour)
1253 {
1254 if ( !wxControl::SetForegroundColour(colour) )
1255 {
1256 // nothing to do
1257 return false;
1258 }
1259
1260 MakeOwnerDrawn();
1261
1262 Refresh();
1263
1264 return true;
1265 }
1266
1267 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
1268 {
1269 LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
1270 HDC hdc = lpDIS->hDC;
1271
1272 UINT state = lpDIS->itemState;
1273 bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
1274
1275 RECT rectBtn;
1276 CopyRect(&rectBtn, &lpDIS->rcItem);
1277
1278 // draw the button background
1279 if ( !HasFlag(wxBORDER_NONE) )
1280 {
1281 #if wxUSE_UXTHEME
1282 if ( wxUxThemeEngine::GetIfActive() )
1283 {
1284 DrawXPBackground(this, hdc, rectBtn, state);
1285 }
1286 else
1287 #endif // wxUSE_UXTHEME
1288 {
1289 COLORREF colBg = wxColourToRGB(GetBackgroundColour());
1290
1291 // first, draw the background
1292 AutoHBRUSH hbrushBackground(colBg);
1293 FillRect(hdc, &rectBtn, hbrushBackground);
1294
1295 // draw the border for the current state
1296 bool selected = (state & ODS_SELECTED) != 0;
1297 if ( !selected )
1298 {
1299 wxTopLevelWindow *
1300 tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
1301 if ( tlw )
1302 {
1303 selected = tlw->GetDefaultItem() == this;
1304 }
1305 }
1306
1307 DrawButtonFrame(hdc, rectBtn, selected, pushed);
1308 }
1309
1310 // draw the focus rectangle if we need it
1311 if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
1312 {
1313 DrawFocusRect(hdc, &rectBtn);
1314
1315 #if wxUSE_UXTHEME
1316 if ( !wxUxThemeEngine::GetIfActive() )
1317 #endif // wxUSE_UXTHEME
1318 {
1319 if ( pushed )
1320 {
1321 // the label is shifted by 1 pixel to create "pushed" effect
1322 OffsetRect(&rectBtn, 1, 1);
1323 }
1324 }
1325 }
1326 }
1327
1328
1329 // draw the image, if any
1330 if ( m_imageData )
1331 {
1332 wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
1333 if ( !bmp.IsOk() )
1334 bmp = m_imageData->GetBitmap(State_Normal);
1335
1336 const wxSize sizeBmp = bmp.GetSize();
1337 const wxSize margin = m_imageData->GetBitmapMargins();
1338 const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
1339 wxRect rectButton(wxRectFromRECT(rectBtn));
1340
1341 // for simplicity, we start with centred rectangle and then move it to
1342 // the appropriate edge
1343 wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
1344
1345 // move bitmap only if we have a label, otherwise keep it centered
1346 if ( ShowsLabel() )
1347 {
1348 switch ( m_imageData->GetBitmapPosition() )
1349 {
1350 default:
1351 wxFAIL_MSG( "invalid direction" );
1352 // fall through
1353
1354 case wxLEFT:
1355 rectBitmap.x = rectButton.x + margin.x;
1356 rectButton.x += sizeBmpWithMargins.x;
1357 rectButton.width -= sizeBmpWithMargins.x;
1358 break;
1359
1360 case wxRIGHT:
1361 rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1362 rectButton.width -= sizeBmpWithMargins.x;
1363 break;
1364
1365 case wxTOP:
1366 rectBitmap.y = rectButton.y + margin.y;
1367 rectButton.y += sizeBmpWithMargins.y;
1368 rectButton.height -= sizeBmpWithMargins.y;
1369 break;
1370
1371 case wxBOTTOM:
1372 rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1373 rectButton.height -= sizeBmpWithMargins.y;
1374 break;
1375 }
1376 }
1377
1378 wxDCTemp dst((WXHDC)hdc);
1379 dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1380
1381 wxCopyRectToRECT(rectButton, rectBtn);
1382 }
1383
1384
1385 // finally draw the label
1386 if ( ShowsLabel() )
1387 {
1388 COLORREF colFg = state & ODS_DISABLED
1389 ? ::GetSysColor(COLOR_GRAYTEXT)
1390 : wxColourToRGB(GetForegroundColour());
1391
1392 // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1393 // systems but by happy coincidence ODS_NOACCEL is not used under them
1394 // neither so DT_HIDEPREFIX should never be used there
1395 DrawButtonText(hdc, &rectBtn, GetLabel(), colFg,
1396 state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1397 }
1398
1399 return true;
1400 }
1401
1402 #endif // wxUSE_BUTTON
1403
wxWidgets (Impactor)