projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PCH compilation fix
[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/imaglist.h"
43 #include "wx/stockitem.h"
44 #include "wx/msw/private.h"
45 #include "wx/msw/private/button.h"
46 #include "wx/msw/private/dc.h"
47
48 using namespace wxMSWImpl;
49
50 #if wxUSE_UXTHEME
51 #include "wx/msw/uxtheme.h"
52
53 // no need to include tmschema.h
54 #ifndef BP_PUSHBUTTON
55 #define BP_PUSHBUTTON 1
56
57 #define PBS_NORMAL 1
58 #define PBS_HOT 2
59 #define PBS_PRESSED 3
60 #define PBS_DISABLED 4
61 #define PBS_DEFAULTED 5
62
63 #define TMT_CONTENTMARGINS 3602
64 #endif
65
66 // provide the necessary declarations ourselves if they're missing from
67 // headers
68 #ifndef BCM_SETIMAGELIST
69 #define BCM_SETIMAGELIST 0x1602
70 #define BCM_SETTEXTMARGIN 0x1604
71
72 enum
73 {
74 BUTTON_IMAGELIST_ALIGN_LEFT,
75 BUTTON_IMAGELIST_ALIGN_RIGHT,
76 BUTTON_IMAGELIST_ALIGN_TOP,
77 BUTTON_IMAGELIST_ALIGN_BOTTOM
78 };
79
80 struct BUTTON_IMAGELIST
81 {
82 HIMAGELIST himl;
83 RECT margin;
84 UINT uAlign;
85 };
86 #endif
87 #endif // wxUSE_UXTHEME
88
89 #ifndef WM_THEMECHANGED
90 #define WM_THEMECHANGED 0x031A
91 #endif
92
93 #ifndef ODS_NOACCEL
94 #define ODS_NOACCEL 0x0100
95 #endif
96
97 #ifndef ODS_NOFOCUSRECT
98 #define ODS_NOFOCUSRECT 0x0200
99 #endif
100
101 #ifndef DT_HIDEPREFIX
102 #define DT_HIDEPREFIX 0x00100000
103 #endif
104
105 // ----------------------------------------------------------------------------
106 // button image data
107 // ----------------------------------------------------------------------------
108
109 // we use different data classes for owner drawn buttons and for themed XP ones
110
111 class wxButtonImageData
112 {
113 public:
114 wxButtonImageData() { }
115 virtual ~wxButtonImageData() { }
116
117 virtual wxBitmap GetBitmap(wxButton::State which) const = 0;
118 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which) = 0;
119
120 virtual wxSize GetBitmapMargins() const = 0;
121 virtual void SetBitmapMargins(wxCoord x, wxCoord y) = 0;
122
123 virtual wxDirection GetBitmapPosition() const = 0;
124 virtual void SetBitmapPosition(wxDirection dir) = 0;
125
126 private:
127 wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
128 };
129
130 namespace
131 {
132
133 // the gap between button edge and the interior area used by Windows for the
134 // standard buttons
135 const int OD_BUTTON_MARGIN = 4;
136
137 class wxODButtonImageData : public wxButtonImageData
138 {
139 public:
140 wxODButtonImageData(wxButton *btn, const wxBitmap& bitmap)
141 {
142 SetBitmap(bitmap, wxButton::State_Normal);
143
144 m_dir = wxLEFT;
145
146 // we use margins when we have both bitmap and text, but when we have
147 // only the bitmap it should take up the entire button area
148 if ( btn->ShowsLabel() )
149 {
150 m_margin.x = btn->GetCharWidth();
151 m_margin.y = btn->GetCharHeight() / 2;
152 }
153 }
154
155 virtual wxBitmap GetBitmap(wxButton::State which) const
156 {
157 return m_bitmaps[which];
158 }
159
160 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
161 {
162 m_bitmaps[which] = bitmap;
163 }
164
165 virtual wxSize GetBitmapMargins() const
166 {
167 return m_margin;
168 }
169
170 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
171 {
172 m_margin = wxSize(x, y);
173 }
174
175 virtual wxDirection GetBitmapPosition() const
176 {
177 return m_dir;
178 }
179
180 virtual void SetBitmapPosition(wxDirection dir)
181 {
182 m_dir = dir;
183 }
184
185 private:
186 // just store the values passed to us to be able to retrieve them later
187 // from the drawing code
188 wxBitmap m_bitmaps[wxButton::State_Max];
189 wxSize m_margin;
190 wxDirection m_dir;
191
192 wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
193 };
194
195 #if wxUSE_UXTHEME
196
197 // somehow the margin is one pixel greater than the value returned by
198 // GetThemeMargins() call
199 const int XP_BUTTON_EXTRA_MARGIN = 1;
200
201 class wxXPButtonImageData : public wxButtonImageData
202 {
203 public:
204 // we must be constructed with the size of our images as we need to create
205 // the image list
206 wxXPButtonImageData(wxButton *btn, const wxBitmap& bitmap)
207 : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
208 wxButton::State_Max),
209 m_hwndBtn(GetHwndOf(btn))
210 {
211 // initialize all bitmaps to normal state
212 for ( int n = 0; n < wxButton::State_Max; n++ )
213 {
214 m_iml.Add(bitmap);
215 }
216
217 m_data.himl = GetHimagelistOf(&m_iml);
218
219 // use default margins
220 m_data.margin.left =
221 m_data.margin.right = btn->GetCharWidth();
222 m_data.margin.top =
223 m_data.margin.bottom = btn->GetCharHeight() / 2;
224
225 // and default alignment
226 m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
227
228 UpdateImageInfo();
229 }
230
231 virtual wxBitmap GetBitmap(wxButton::State which) const
232 {
233 return m_iml.GetBitmap(which);
234 }
235
236 virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
237 {
238 m_iml.Replace(which, bitmap);
239
240 UpdateImageInfo();
241 }
242
243 virtual wxSize GetBitmapMargins() const
244 {
245 return wxSize(m_data.margin.left, m_data.margin.top);
246 }
247
248 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
249 {
250 RECT& margin = m_data.margin;
251 margin.left =
252 margin.right = x;
253 margin.top =
254 margin.bottom = y;
255
256 if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
257 {
258 wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
259 }
260 }
261
262 virtual wxDirection GetBitmapPosition() const
263 {
264 switch ( m_data.uAlign )
265 {
266 default:
267 wxFAIL_MSG( "invalid image alignment" );
268 // fall through
269
270 case BUTTON_IMAGELIST_ALIGN_LEFT:
271 return wxLEFT;
272
273 case BUTTON_IMAGELIST_ALIGN_RIGHT:
274 return wxRIGHT;
275
276 case BUTTON_IMAGELIST_ALIGN_TOP:
277 return wxTOP;
278
279 case BUTTON_IMAGELIST_ALIGN_BOTTOM:
280 return wxBOTTOM;
281 }
282 }
283
284 virtual void SetBitmapPosition(wxDirection dir)
285 {
286 UINT alignNew;
287 switch ( dir )
288 {
289 default:
290 wxFAIL_MSG( "invalid direction" );
291 // fall through
292
293 case wxLEFT:
294 alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
295 break;
296
297 case wxRIGHT:
298 alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
299 break;
300
301 case wxTOP:
302 alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
303 break;
304
305 case wxBOTTOM:
306 alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
307 break;
308 }
309
310 if ( alignNew != m_data.uAlign )
311 {
312 m_data.uAlign = alignNew;
313 UpdateImageInfo();
314 }
315 }
316
317 private:
318 void UpdateImageInfo()
319 {
320 if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
321 {
322 wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
323 }
324 }
325
326 // we store image list separately to be able to use convenient wxImageList
327 // methods instead of working with raw HIMAGELIST
328 wxImageList m_iml;
329
330 // store the rest of the data in BCM_SETIMAGELIST-friendly form
331 BUTTON_IMAGELIST m_data;
332
333 // the button we're associated with
334 const HWND m_hwndBtn;
335
336
337 wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
338 };
339
340 #endif // wxUSE_UXTHEME
341
342 } // anonymous namespace
343
344 // ----------------------------------------------------------------------------
345 // macros
346 // ----------------------------------------------------------------------------
347
348 #if wxUSE_EXTENDED_RTTI
349
350 WX_DEFINE_FLAGS( wxButtonStyle )
351
352 wxBEGIN_FLAGS( wxButtonStyle )
353 // new style border flags, we put them first to
354 // use them for streaming out
355 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
356 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
357 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
358 wxFLAGS_MEMBER(wxBORDER_RAISED)
359 wxFLAGS_MEMBER(wxBORDER_STATIC)
360 wxFLAGS_MEMBER(wxBORDER_NONE)
361
362 // old style border flags
363 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
364 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
365 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
366 wxFLAGS_MEMBER(wxRAISED_BORDER)
367 wxFLAGS_MEMBER(wxSTATIC_BORDER)
368 wxFLAGS_MEMBER(wxBORDER)
369
370 // standard window styles
371 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
372 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
373 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
374 wxFLAGS_MEMBER(wxWANTS_CHARS)
375 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
376 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
377 wxFLAGS_MEMBER(wxVSCROLL)
378 wxFLAGS_MEMBER(wxHSCROLL)
379
380 wxFLAGS_MEMBER(wxBU_LEFT)
381 wxFLAGS_MEMBER(wxBU_RIGHT)
382 wxFLAGS_MEMBER(wxBU_TOP)
383 wxFLAGS_MEMBER(wxBU_BOTTOM)
384 wxFLAGS_MEMBER(wxBU_EXACTFIT)
385 wxEND_FLAGS( wxButtonStyle )
386
387 IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
388
389 wxBEGIN_PROPERTIES_TABLE(wxButton)
390 wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
391
392 wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
393 wxPROPERTY( Label, wxString , SetLabel, GetLabel, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
394
395 wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
396
397 wxEND_PROPERTIES_TABLE()
398
399 wxBEGIN_HANDLERS_TABLE(wxButton)
400 wxEND_HANDLERS_TABLE()
401
402 wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle )
403
404
405 #else
406 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
407 #endif
408
409 // ============================================================================
410 // implementation
411 // ============================================================================
412
413 // ----------------------------------------------------------------------------
414 // helper functions from wx/msw/private/button.h
415 // ----------------------------------------------------------------------------
416
417 void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
418 {
419 // update BS_MULTILINE style depending on the new label (resetting it
420 // doesn't seem to do anything very useful but it shouldn't hurt and we do
421 // have to set it whenever the label becomes multi line as otherwise it
422 // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
423 // the control unless it already has new lines in its label)
424 long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
425 styleNew;
426 if ( label.find(wxT('\n')) != wxString::npos )
427 styleNew = styleOld | BS_MULTILINE;
428 else
429 styleNew = styleOld & ~BS_MULTILINE;
430
431 if ( styleNew != styleOld )
432 ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
433 }
434
435 wxSize wxMSWButton::GetFittingSize(wxWindow *win, const wxSize& sizeLabel)
436 {
437 // FIXME: this is pure guesswork, need to retrieve the real button margins
438 wxSize sizeBtn = sizeLabel;
439
440 sizeBtn.x += 3*win->GetCharWidth();
441 sizeBtn.y = 11*EDIT_HEIGHT_FROM_CHAR_HEIGHT(sizeLabel.y)/10;
442
443 return sizeBtn;
444 }
445
446 wxSize wxMSWButton::ComputeBestSize(wxControl *btn)
447 {
448 wxClientDC dc(btn);
449
450 wxSize sizeBtn;
451 dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
452
453 sizeBtn = GetFittingSize(btn, sizeBtn);
454
455 // all buttons have at least the standard size unless the user explicitly
456 // wants them to be of smaller size and used wxBU_EXACTFIT style when
457 // creating the button
458 if ( !btn->HasFlag(wxBU_EXACTFIT) )
459 {
460 wxSize sizeDef = wxButton::GetDefaultSize();
461 if ( sizeBtn.x < sizeDef.x )
462 sizeBtn.x = sizeDef.x;
463 if ( sizeBtn.y < sizeDef.y )
464 sizeBtn.y = sizeDef.y;
465 }
466
467 btn->CacheBestSize(sizeBtn);
468
469 return sizeBtn;
470 }
471
472 // ----------------------------------------------------------------------------
473 // creation/destruction
474 // ----------------------------------------------------------------------------
475
476 bool wxButton::Create(wxWindow *parent,
477 wxWindowID id,
478 const wxString& lbl,
479 const wxPoint& pos,
480 const wxSize& size,
481 long style,
482 const wxValidator& validator,
483 const wxString& name)
484 {
485 wxString label(lbl);
486 if (label.empty() && wxIsStockID(id))
487 {
488 // On Windows, some buttons aren't supposed to have mnemonics
489 label = wxGetStockLabel
490 (
491 id,
492 id == wxID_OK || id == wxID_CANCEL || id == wxID_CLOSE
493 ? wxSTOCK_NOFLAGS
494 : wxSTOCK_WITH_MNEMONIC
495 );
496 }
497
498 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
499 return false;
500
501 WXDWORD exstyle;
502 WXDWORD msStyle = MSWGetStyle(style, &exstyle);
503
504 // if the label contains several lines we must explicitly tell the button
505 // about it or it wouldn't draw it correctly ("\n"s would just appear as
506 // black boxes)
507 //
508 // NB: we do it here and not in MSWGetStyle() because we need the label
509 // value and the label is not set yet when MSWGetStyle() is called
510 msStyle |= wxMSWButton::GetMultilineStyle(label);
511
512 return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, exstyle);
513 }
514
515 wxButton::~wxButton()
516 {
517 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
518 if ( tlw && tlw->GetTmpDefaultItem() == this )
519 {
520 UnsetTmpDefault();
521 }
522
523 delete m_imageData;
524 }
525
526 // ----------------------------------------------------------------------------
527 // flags
528 // ----------------------------------------------------------------------------
529
530 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
531 {
532 // buttons never have an external border, they draw their own one
533 WXDWORD msStyle = wxControl::MSWGetStyle
534 (
535 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
536 );
537
538 // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
539 // each other in any resizeable dialog which has more than one button in
540 // the bottom
541 msStyle |= WS_CLIPSIBLINGS;
542
543 // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
544 // and wxBU_RIGHT to get BS_CENTER!
545 if ( style & wxBU_LEFT )
546 msStyle |= BS_LEFT;
547 if ( style & wxBU_RIGHT )
548 msStyle |= BS_RIGHT;
549 if ( style & wxBU_TOP )
550 msStyle |= BS_TOP;
551 if ( style & wxBU_BOTTOM )
552 msStyle |= BS_BOTTOM;
553 #ifndef __WXWINCE__
554 // flat 2d buttons
555 if ( style & wxNO_BORDER )
556 msStyle |= BS_FLAT;
557 #endif // __WXWINCE__
558
559 return msStyle;
560 }
561
562 void wxButton::SetLabel(const wxString& label)
563 {
564 wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
565
566 wxButtonBase::SetLabel(label);
567 }
568
569 // ----------------------------------------------------------------------------
570 // size management including autosizing
571 // ----------------------------------------------------------------------------
572
573 wxSize wxButton::DoGetBestSize() const
574 {
575 wxSize size;
576
577 // account for the text part
578 if ( ShowsLabel() )
579 {
580 size = wxMSWButton::ComputeBestSize(const_cast<wxButton *>(this));
581 }
582
583 if ( m_imageData )
584 {
585 // account for the bitmap size
586 const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
587 const wxDirection dirBmp = m_imageData->GetBitmapPosition();
588 if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
589 {
590 size.x += sizeBmp.x;
591 if ( sizeBmp.y > size.y )
592 size.y = sizeBmp.y;
593 }
594 else // bitmap on top/below the text
595 {
596 size.y += sizeBmp.y;
597 if ( sizeBmp.x > size.x )
598 size.x = sizeBmp.x;
599 }
600
601 // account for the user-specified margins
602 size += 2*m_imageData->GetBitmapMargins();
603
604 // and also for the margins we always add internally (unless we have no
605 // border at all in which case the button has exactly the same size as
606 // bitmap and so no margins should be used)
607 if ( !HasFlag(wxBORDER_NONE) )
608 {
609 int marginH = 0,
610 marginV = 0;
611 #if wxUSE_UXTHEME
612 if ( wxUxThemeEngine::GetIfActive() )
613 {
614 wxUxThemeHandle theme(const_cast<wxButton *>(this), L"BUTTON");
615
616 MARGINS margins;
617 wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
618 BP_PUSHBUTTON,
619 PBS_NORMAL,
620 TMT_CONTENTMARGINS,
621 NULL,
622 &margins);
623
624 // XP doesn't draw themed buttons correctly when the client
625 // area is smaller than 8x8 - enforce this minimum size for
626 // small bitmaps
627 size.IncTo(wxSize(8, 8));
628
629 marginH = margins.cxLeftWidth + margins.cxRightWidth
630 + 2*XP_BUTTON_EXTRA_MARGIN;
631 marginV = margins.cyTopHeight + margins.cyBottomHeight
632 + 2*XP_BUTTON_EXTRA_MARGIN;
633 }
634 else
635 #endif // wxUSE_UXTHEME
636 {
637 marginH =
638 marginV = OD_BUTTON_MARGIN;
639 }
640
641 size.IncBy(marginH, marginV);
642 }
643
644 CacheBestSize(size);
645 }
646
647 return size;
648 }
649
650 /* static */
651 wxSize wxButtonBase::GetDefaultSize()
652 {
653 static wxSize s_sizeBtn;
654
655 if ( s_sizeBtn.x == 0 )
656 {
657 wxScreenDC dc;
658 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
659
660 // the size of a standard button in the dialog units is 50x14,
661 // translate this to pixels
662 // NB1: the multipliers come from the Windows convention
663 // NB2: the extra +1/+2 were needed to get the size be the same as the
664 // size of the buttons in the standard dialog - I don't know how
665 // this happens, but on my system this size is 75x23 in pixels and
666 // 23*8 isn't even divisible by 14... Would be nice to understand
667 // why these constants are needed though!
668 s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
669 s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
670 }
671
672 return s_sizeBtn;
673 }
674
675 // ----------------------------------------------------------------------------
676 // default button handling
677 // ----------------------------------------------------------------------------
678
679 /*
680 The comment below and all this code is probably due to not using WM_NEXTDLGCTL
681 message when changing focus (but just SetFocus() which is not enough), see
682 http://blogs.msdn.com/oldnewthing/archive/2004/08/02/205624.aspx for the
683 full explanation.
684
685 TODO: Do use WM_NEXTDLGCTL and get rid of all this code.
686
687
688 "Everything you ever wanted to know about the default buttons" or "Why do we
689 have to do all this?"
690
691 In MSW the default button should be activated when the user presses Enter
692 and the current control doesn't process Enter itself somehow. This is
693 handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
694 Another aspect of "defaultness" is that the default button has different
695 appearance: this is due to BS_DEFPUSHBUTTON style which is completely
696 separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
697 be unset if our parent window is not active so it should be unset whenever
698 we lose activation and set back when we regain it.
699
700 Final complication is that when a button is active, it should be the default
701 one, i.e. pressing Enter on a button always activates it and not another
702 one.
703
704 We handle this by maintaining a permanent and a temporary default items in
705 wxControlContainer (both may be NULL). When a button becomes the current
706 control (i.e. gets focus) it sets itself as the temporary default which
707 ensures that it has the right appearance and that Enter will be redirected
708 to it. When the button loses focus, it unsets the temporary default and so
709 the default item will be the permanent default -- that is the default button
710 if any had been set or none otherwise, which is just what we want.
711
712 NB: all this is quite complicated by now and the worst is that normally
713 it shouldn't be necessary at all as for the normal Windows programs
714 DefWindowProc() and IsDialogMessage() take care of all this
715 automatically -- however in wxWidgets programs this doesn't work for
716 nested hierarchies (i.e. a notebook inside a notebook) for unknown
717 reason and so we have to reproduce all this code ourselves. It would be
718 very nice if we could avoid doing it.
719 */
720
721 // set this button as the (permanently) default one in its panel
722 wxWindow *wxButton::SetDefault()
723 {
724 // set this one as the default button both for wxWidgets ...
725 wxWindow *winOldDefault = wxButtonBase::SetDefault();
726
727 // ... and Windows
728 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
729 SetDefaultStyle(this, true);
730
731 return winOldDefault;
732 }
733
734 // return the top level parent window if it's not being deleted yet, otherwise
735 // return NULL
736 static wxTopLevelWindow *GetTLWParentIfNotBeingDeleted(wxWindow *win)
737 {
738 for ( ;; )
739 {
740 // IsTopLevel() will return false for a wxTLW being deleted, so we also
741 // need the parent test for this case
742 wxWindow * const parent = win->GetParent();
743 if ( !parent || win->IsTopLevel() )
744 {
745 if ( win->IsBeingDeleted() )
746 return NULL;
747
748 break;
749 }
750
751 win = parent;
752 }
753
754 wxASSERT_MSG( win, wxT("button without top level parent?") );
755
756 wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
757 wxASSERT_MSG( tlw, wxT("logic error in GetTLWParentIfNotBeingDeleted()") );
758
759 return tlw;
760 }
761
762 // set this button as being currently default
763 void wxButton::SetTmpDefault()
764 {
765 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
766 if ( !tlw )
767 return;
768
769 wxWindow *winOldDefault = tlw->GetDefaultItem();
770 tlw->SetTmpDefaultItem(this);
771
772 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
773 SetDefaultStyle(this, true);
774 }
775
776 // unset this button as currently default, it may still stay permanent default
777 void wxButton::UnsetTmpDefault()
778 {
779 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
780 if ( !tlw )
781 return;
782
783 tlw->SetTmpDefaultItem(NULL);
784
785 wxWindow *winOldDefault = tlw->GetDefaultItem();
786
787 SetDefaultStyle(this, false);
788 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
789 }
790
791 /* static */
792 void
793 wxButton::SetDefaultStyle(wxButton *btn, bool on)
794 {
795 // we may be called with NULL pointer -- simpler to do the check here than
796 // in the caller which does wxDynamicCast()
797 if ( !btn )
798 return;
799
800 // first, let DefDlgProc() know about the new default button
801 if ( on )
802 {
803 // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
804 // focus at all any more
805 if ( !wxTheApp->IsActive() )
806 return;
807
808 wxWindow * const tlw = wxGetTopLevelParent(btn);
809 wxCHECK_RET( tlw, wxT("button without top level window?") );
810
811 ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
812
813 // sending DM_SETDEFID also changes the button style to
814 // BS_DEFPUSHBUTTON so there is nothing more to do
815 }
816
817 // then also change the style as needed
818 long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
819 if ( !(style & BS_DEFPUSHBUTTON) == on )
820 {
821 // don't do it with the owner drawn buttons because it will
822 // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
823 // BS_DEFPUSHBUTTON != 0)!
824 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
825 {
826 ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
827 on ? style | BS_DEFPUSHBUTTON
828 : style & ~BS_DEFPUSHBUTTON,
829 1L /* redraw */);
830 }
831 else // owner drawn
832 {
833 // redraw the button - it will notice itself that it's
834 // [not] the default one [any longer]
835 btn->Refresh();
836 }
837 }
838 //else: already has correct style
839 }
840
841 // ----------------------------------------------------------------------------
842 // helpers
843 // ----------------------------------------------------------------------------
844
845 bool wxButton::SendClickEvent()
846 {
847 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
848 event.SetEventObject(this);
849
850 return ProcessCommand(event);
851 }
852
853 void wxButton::Command(wxCommandEvent & event)
854 {
855 ProcessCommand(event);
856 }
857
858 // ----------------------------------------------------------------------------
859 // event/message handlers
860 // ----------------------------------------------------------------------------
861
862 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
863 {
864 bool processed = false;
865 switch ( param )
866 {
867 // NOTE: Apparently older versions (NT 4?) of the common controls send
868 // BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
869 // buttons, so in order to send two EVT_BUTTON events we should
870 // catch both types. Currently (Feb 2003) up-to-date versions of
871 // win98, win2k and winXP all send two BN_CLICKED messages for
872 // all button types, so we don't catch BN_DOUBLECLICKED anymore
873 // in order to not get 3 EVT_BUTTON events. If this is a problem
874 // then we need to figure out which version of the comctl32 changed
875 // this behaviour and test for it.
876
877 case 1: // message came from an accelerator
878 case BN_CLICKED: // normal buttons send this
879 processed = SendClickEvent();
880 break;
881 }
882
883 return processed;
884 }
885
886 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
887 {
888 // when we receive focus, we want to temporarily become the default button in
889 // our parent panel so that pressing "Enter" would activate us -- and when
890 // losing it we should restore the previous default button as well
891 if ( nMsg == WM_SETFOCUS )
892 {
893 SetTmpDefault();
894
895 // let the default processing take place too
896 }
897 else if ( nMsg == WM_KILLFOCUS )
898 {
899 UnsetTmpDefault();
900 }
901 else if ( nMsg == WM_LBUTTONDBLCLK )
902 {
903 // emulate a click event to force an owner-drawn button to change its
904 // appearance - without this, it won't do it
905 (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
906
907 // and continue with processing the message normally as well
908 }
909 #if wxUSE_UXTHEME
910 else if ( nMsg == WM_THEMECHANGED )
911 {
912 // need to recalculate the best size here
913 // as the theme size might have changed
914 InvalidateBestSize();
915 }
916 #endif // wxUSE_UXTHEME
917 // must use m_mouseInWindow here instead of IsMouseInWindow()
918 // since we need to know the first time the mouse enters the window
919 // and IsMouseInWindow() would return true in this case
920 else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
921 nMsg == WM_MOUSELEAVE )
922 {
923 if (
924 IsEnabled() &&
925 (
926 #if wxUSE_UXTHEME
927 wxUxThemeEngine::GetIfActive() ||
928 #endif // wxUSE_UXTHEME
929 m_imageData && m_imageData->GetBitmap(State_Current).IsOk()
930 )
931 )
932 {
933 Refresh();
934 }
935 }
936
937 // let the base class do all real processing
938 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
939 }
940
941 // ----------------------------------------------------------------------------
942 // button images
943 // ----------------------------------------------------------------------------
944
945 wxBitmap wxButton::DoGetBitmap(State which) const
946 {
947 return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
948 }
949
950 void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
951 {
952 // allocate the image data when the first bitmap is set
953 if ( !m_imageData )
954 {
955 #if wxUSE_UXTHEME
956 // using image list doesn't work correctly if we don't have any label
957 // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
958 // BS_BITMAP style), at least under Windows 2003 so use owner drawn
959 // strategy for bitmap-only buttons
960 if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
961 {
962 m_imageData = new wxXPButtonImageData(this, bitmap);
963 }
964 else
965 #endif // wxUSE_UXTHEME
966 {
967 m_imageData = new wxODButtonImageData(this, bitmap);
968 MakeOwnerDrawn();
969 }
970 }
971 else
972 {
973 m_imageData->SetBitmap(bitmap, which);
974 }
975
976 // it should be enough to only invalidate the best size when the normal
977 // bitmap changes as all bitmaps assigned to the button should be of the
978 // same size anyhow
979 if ( which == State_Normal )
980 InvalidateBestSize();
981
982 Refresh();
983 }
984
985 wxSize wxButton::DoGetBitmapMargins() const
986 {
987 return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
988 }
989
990 void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
991 {
992 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
993
994 m_imageData->SetBitmapMargins(x, y);
995 }
996
997 void wxButton::DoSetBitmapPosition(wxDirection dir)
998 {
999 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
1000
1001 m_imageData->SetBitmapPosition(dir);
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 switch ( m_imageData->GetBitmapPosition() )
1345 {
1346 default:
1347 wxFAIL_MSG( "invalid direction" );
1348 // fall through
1349
1350 case wxLEFT:
1351 rectBitmap.x = rectButton.x + margin.x;
1352 rectButton.x += sizeBmpWithMargins.x;
1353 rectButton.width -= sizeBmpWithMargins.x;
1354 break;
1355
1356 case wxRIGHT:
1357 rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1358 rectButton.width -= sizeBmpWithMargins.x;
1359 break;
1360
1361 case wxTOP:
1362 rectBitmap.y = rectButton.y + margin.y;
1363 rectButton.y += sizeBmpWithMargins.y;
1364 rectButton.height -= sizeBmpWithMargins.y;
1365 break;
1366
1367 case wxBOTTOM:
1368 rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1369 rectButton.height -= sizeBmpWithMargins.y;
1370 break;
1371 }
1372
1373 wxDCTemp dst((WXHDC)hdc);
1374 dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1375
1376 wxCopyRectToRECT(rectButton, rectBtn);
1377 }
1378
1379
1380 // finally draw the label
1381 if ( ShowsLabel() )
1382 {
1383 COLORREF colFg = state & ODS_DISABLED
1384 ? ::GetSysColor(COLOR_GRAYTEXT)
1385 : wxColourToRGB(GetForegroundColour());
1386
1387 // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1388 // systems but by happy coincidence ODS_NOACCEL is not used under them
1389 // neither so DT_HIDEPREFIX should never be used there
1390 DrawButtonText(hdc, &rectBtn, GetLabel(), colFg,
1391 state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1392 }
1393
1394 return true;
1395 }
1396
1397 #endif // wxUSE_BUTTON
1398
wxWidgets (Impactor)