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