]> git.saurik.com Git - wxWidgets.git/blob - src/msw/anybutton.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Implement support for pen cap and join in wxPostScriptDC.
[wxWidgets.git] / src / msw / anybutton.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/anybutton.cpp
3 // Purpose: wxAnyButton
4 // Author: Julian Smart
5 // Created: 1998-01-04 (extracted from button.cpp)
6 // RCS-ID: $Id$
7 // Copyright: (c) Julian Smart
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #ifdef wxHAS_ANY_BUTTON
27
28 #include "wx/anybutton.h"
29
30 #ifndef WX_PRECOMP
31 #include "wx/app.h"
32 #include "wx/brush.h"
33 #include "wx/panel.h"
34 #include "wx/bmpbuttn.h"
35 #include "wx/settings.h"
36 #include "wx/dcscreen.h"
37 #include "wx/dcclient.h"
38 #include "wx/toplevel.h"
39 #include "wx/msw/wrapcctl.h"
40 #include "wx/msw/private.h"
41 #include "wx/msw/missing.h"
42 #endif
43
44 #include "wx/imaglist.h"
45 #include "wx/stockitem.h"
46 #include "wx/msw/private/button.h"
47 #include "wx/msw/private/dc.h"
48 #include "wx/private/window.h"
49
50 #if wxUSE_MARKUP
51 #include "wx/generic/private/markuptext.h"
52 #endif // wxUSE_MARKUP
53
54 using namespace wxMSWImpl;
55
56 #if wxUSE_UXTHEME
57 #include "wx/msw/uxtheme.h"
58
59 // no need to include tmschema.h
60 #ifndef BP_PUSHBUTTON
61 #define BP_PUSHBUTTON 1
62
63 #define PBS_NORMAL 1
64 #define PBS_HOT 2
65 #define PBS_PRESSED 3
66 #define PBS_DISABLED 4
67 #define PBS_DEFAULTED 5
68
69 #define TMT_CONTENTMARGINS 3602
70 #endif
71
72 // provide the necessary declarations ourselves if they're missing from
73 // headers
74 #ifndef BCM_SETIMAGELIST
75 #define BCM_SETIMAGELIST 0x1602
76 #define BCM_SETTEXTMARGIN 0x1604
77
78 enum
79 {
80 BUTTON_IMAGELIST_ALIGN_LEFT,
81 BUTTON_IMAGELIST_ALIGN_RIGHT,
82 BUTTON_IMAGELIST_ALIGN_TOP,
83 BUTTON_IMAGELIST_ALIGN_BOTTOM
84 };
85
86 struct BUTTON_IMAGELIST
87 {
88 HIMAGELIST himl;
89 RECT margin;
90 UINT uAlign;
91 };
92 #endif
93 #endif // wxUSE_UXTHEME
94
95 #ifndef WM_THEMECHANGED
96 #define WM_THEMECHANGED 0x031A
97 #endif
98
99 #ifndef ODS_NOACCEL
100 #define ODS_NOACCEL 0x0100
101 #endif
102
103 #ifndef ODS_NOFOCUSRECT
104 #define ODS_NOFOCUSRECT 0x0200
105 #endif
106
107 #ifndef DT_HIDEPREFIX
108 #define DT_HIDEPREFIX 0x00100000
109 #endif
110
111 #if wxUSE_UXTHEME
112 extern wxWindowMSW *wxWindowBeingErased; // From src/msw/window.cpp
113 #endif // wxUSE_UXTHEME
114
115 // ----------------------------------------------------------------------------
116 // button image data
117 // ----------------------------------------------------------------------------
118
119 // we use different data classes for owner drawn buttons and for themed XP ones
120
121 class wxButtonImageData
122 {
123 public:
124 wxButtonImageData() { }
125 virtual ~wxButtonImageData() { }
126
127 virtual wxBitmap GetBitmap(wxAnyButton::State which) const = 0;
128 virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::State which) = 0;
129
130 virtual wxSize GetBitmapMargins() const = 0;
131 virtual void SetBitmapMargins(wxCoord x, wxCoord y) = 0;
132
133 virtual wxDirection GetBitmapPosition() const = 0;
134 virtual void SetBitmapPosition(wxDirection dir) = 0;
135
136 private:
137 wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
138 };
139
140 namespace
141 {
142
143 // the gap between button edge and the interior area used by Windows for the
144 // standard buttons
145 const int OD_BUTTON_MARGIN = 4;
146
147 class wxODButtonImageData : public wxButtonImageData
148 {
149 public:
150 wxODButtonImageData(wxAnyButton *btn, const wxBitmap& bitmap)
151 {
152 SetBitmap(bitmap, wxAnyButton::State_Normal);
153 #if wxUSE_IMAGE
154 SetBitmap(bitmap.ConvertToDisabled(), wxAnyButton::State_Disabled);
155 #endif
156 m_dir = wxLEFT;
157
158 // we use margins when we have both bitmap and text, but when we have
159 // only the bitmap it should take up the entire button area
160 if ( btn->ShowsLabel() )
161 {
162 m_margin.x = btn->GetCharWidth();
163 m_margin.y = btn->GetCharHeight() / 2;
164 }
165 }
166
167 virtual wxBitmap GetBitmap(wxAnyButton::State which) const
168 {
169 return m_bitmaps[which];
170 }
171
172 virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::State which)
173 {
174 m_bitmaps[which] = bitmap;
175 }
176
177 virtual wxSize GetBitmapMargins() const
178 {
179 return m_margin;
180 }
181
182 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
183 {
184 m_margin = wxSize(x, y);
185 }
186
187 virtual wxDirection GetBitmapPosition() const
188 {
189 return m_dir;
190 }
191
192 virtual void SetBitmapPosition(wxDirection dir)
193 {
194 m_dir = dir;
195 }
196
197 private:
198 // just store the values passed to us to be able to retrieve them later
199 // from the drawing code
200 wxBitmap m_bitmaps[wxAnyButton::State_Max];
201 wxSize m_margin;
202 wxDirection m_dir;
203
204 wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
205 };
206
207 #if wxUSE_UXTHEME
208
209 // somehow the margin is one pixel greater than the value returned by
210 // GetThemeMargins() call
211 const int XP_BUTTON_EXTRA_MARGIN = 1;
212
213 class wxXPButtonImageData : public wxButtonImageData
214 {
215 public:
216 // we must be constructed with the size of our images as we need to create
217 // the image list
218 wxXPButtonImageData(wxAnyButton *btn, const wxBitmap& bitmap)
219 : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
220 wxAnyButton::State_Max + 1 /* see "pulse" comment below */),
221 m_hwndBtn(GetHwndOf(btn))
222 {
223 // initialize all bitmaps except for the disabled one to normal state
224 for ( int n = 0; n < wxAnyButton::State_Max; n++ )
225 {
226 #if wxUSE_IMAGE
227 m_iml.Add(n == wxAnyButton::State_Disabled ? bitmap.ConvertToDisabled()
228 : bitmap);
229 #else
230 m_iml.Add(bitmap);
231 #endif
232 }
233
234 // In addition to the states supported by wxWidgets such as normal,
235 // hot, pressed, disabled and focused, we need to add bitmap for
236 // another state when running under Windows 7 -- the so called "stylus
237 // hot" state corresponding to PBS_STYLUSHOT constant. While it's
238 // documented in MSDN as being only used with tablets, it is a lie as
239 // a focused button actually alternates between the image list elements
240 // with PBS_DEFAULTED and PBS_STYLUSHOT indices and, in particular,
241 // just disappears during half of the time if the latter is not set so
242 // we absolutely must set it.
243 //
244 // This also explains why we need to allocate an extra slot in the
245 // image list ctor above, the slot State_Max is used for this one.
246 m_iml.Add(bitmap);
247
248 m_data.himl = GetHimagelistOf(&m_iml);
249
250 // no margins by default
251 m_data.margin.left =
252 m_data.margin.right =
253 m_data.margin.top =
254 m_data.margin.bottom = 0;
255
256 // use default alignment
257 m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
258
259 UpdateImageInfo();
260 }
261
262 virtual wxBitmap GetBitmap(wxAnyButton::State which) const
263 {
264 return m_iml.GetBitmap(which);
265 }
266
267 virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::State which)
268 {
269 m_iml.Replace(which, bitmap);
270
271 // As we want the focused button to always show its bitmap, we need to
272 // update the "stylus hot" one to match it to avoid any pulsing.
273 if ( which == wxAnyButton::State_Focused )
274 m_iml.Replace(wxAnyButton::State_Max, bitmap);
275
276 UpdateImageInfo();
277 }
278
279 virtual wxSize GetBitmapMargins() const
280 {
281 return wxSize(m_data.margin.left, m_data.margin.top);
282 }
283
284 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
285 {
286 RECT& margin = m_data.margin;
287 margin.left =
288 margin.right = x;
289 margin.top =
290 margin.bottom = y;
291
292 if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
293 {
294 wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
295 }
296 }
297
298 virtual wxDirection GetBitmapPosition() const
299 {
300 switch ( m_data.uAlign )
301 {
302 default:
303 wxFAIL_MSG( "invalid image alignment" );
304 // fall through
305
306 case BUTTON_IMAGELIST_ALIGN_LEFT:
307 return wxLEFT;
308
309 case BUTTON_IMAGELIST_ALIGN_RIGHT:
310 return wxRIGHT;
311
312 case BUTTON_IMAGELIST_ALIGN_TOP:
313 return wxTOP;
314
315 case BUTTON_IMAGELIST_ALIGN_BOTTOM:
316 return wxBOTTOM;
317 }
318 }
319
320 virtual void SetBitmapPosition(wxDirection dir)
321 {
322 UINT alignNew;
323 switch ( dir )
324 {
325 default:
326 wxFAIL_MSG( "invalid direction" );
327 // fall through
328
329 case wxLEFT:
330 alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
331 break;
332
333 case wxRIGHT:
334 alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
335 break;
336
337 case wxTOP:
338 alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
339 break;
340
341 case wxBOTTOM:
342 alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
343 break;
344 }
345
346 if ( alignNew != m_data.uAlign )
347 {
348 m_data.uAlign = alignNew;
349 UpdateImageInfo();
350 }
351 }
352
353 private:
354 void UpdateImageInfo()
355 {
356 if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
357 {
358 wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
359 }
360 }
361
362 // we store image list separately to be able to use convenient wxImageList
363 // methods instead of working with raw HIMAGELIST
364 wxImageList m_iml;
365
366 // store the rest of the data in BCM_SETIMAGELIST-friendly form
367 BUTTON_IMAGELIST m_data;
368
369 // the button we're associated with
370 const HWND m_hwndBtn;
371
372
373 wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
374 };
375
376 #endif // wxUSE_UXTHEME
377
378 } // anonymous namespace
379
380 // ----------------------------------------------------------------------------
381 // macros
382 // ----------------------------------------------------------------------------
383
384 // ============================================================================
385 // implementation
386 // ============================================================================
387
388 // ----------------------------------------------------------------------------
389 // helper functions from wx/msw/private/button.h
390 // ----------------------------------------------------------------------------
391
392 void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
393 {
394 // update BS_MULTILINE style depending on the new label (resetting it
395 // doesn't seem to do anything very useful but it shouldn't hurt and we do
396 // have to set it whenever the label becomes multi line as otherwise it
397 // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
398 // the control unless it already has new lines in its label)
399 long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
400 styleNew;
401 if ( label.find(wxT('\n')) != wxString::npos )
402 styleNew = styleOld | BS_MULTILINE;
403 else
404 styleNew = styleOld & ~BS_MULTILINE;
405
406 if ( styleNew != styleOld )
407 ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
408 }
409
410 wxSize wxMSWButton::GetFittingSize(wxWindow *win,
411 const wxSize& sizeLabel,
412 int flags)
413 {
414 wxSize sizeBtn = sizeLabel;
415
416 // FIXME: The numbers here are pure guesswork, no idea how should the
417 // button margins be really calculated.
418 if ( flags & Size_ExactFit )
419 {
420 // We still need some margin or the text would be overwritten, just
421 // make it as small as possible.
422 sizeBtn.x += (3*win->GetCharWidth());
423 }
424 else
425 {
426 sizeBtn.x += 3*win->GetCharWidth();
427 sizeBtn.y += win->GetCharHeight()/2;
428 }
429
430 // account for the shield UAC icon if we have it
431 if ( flags & Size_AuthNeeded )
432 sizeBtn.x += wxSystemSettings::GetMetric(wxSYS_SMALLICON_X);
433
434 return sizeBtn;
435 }
436
437 wxSize wxMSWButton::ComputeBestFittingSize(wxControl *btn, int flags)
438 {
439 wxClientDC dc(btn);
440
441 wxSize sizeBtn;
442 dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
443
444 return GetFittingSize(btn, sizeBtn, flags);
445 }
446
447 wxSize wxMSWButton::IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size)
448 {
449 wxSize sizeBtn(size);
450
451 // The 50x14 button size is documented in the "Recommended sizing and
452 // spacing" section of MSDN layout article.
453 //
454 // Note that we intentionally don't use GetDefaultSize() here, because
455 // it's inexact -- dialog units depend on this dialog's font.
456 const wxSize sizeDef = btn->ConvertDialogToPixels(wxSize(50, 14));
457
458 // All buttons should have at least the standard size, unless the user
459 // explicitly wants them to be as small as possible and used wxBU_EXACTFIT
460 // style to indicate this.
461 const bool incToStdSize = !btn->HasFlag(wxBU_EXACTFIT);
462 if ( incToStdSize )
463 {
464 if ( sizeBtn.x < sizeDef.x )
465 sizeBtn.x = sizeDef.x;
466 }
467
468 // Notice that we really want to make all buttons with text label equally
469 // high, otherwise they look ugly and the existing code using wxBU_EXACTFIT
470 // only uses it to control width and not height.
471 if ( incToStdSize || !btn->GetLabel().empty() )
472 {
473 if ( sizeBtn.y < sizeDef.y )
474 sizeBtn.y = sizeDef.y;
475 }
476
477 btn->CacheBestSize(sizeBtn);
478
479 return sizeBtn;
480 }
481
482 // ----------------------------------------------------------------------------
483 // creation/destruction
484 // ----------------------------------------------------------------------------
485
486 wxAnyButton::~wxAnyButton()
487 {
488 delete m_imageData;
489 #if wxUSE_MARKUP
490 delete m_markupText;
491 #endif // wxUSE_MARKUP
492 }
493
494 void wxAnyButton::SetLabel(const wxString& label)
495 {
496 wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
497
498 wxAnyButtonBase::SetLabel(label);
499
500 #if wxUSE_MARKUP
501 // If we have a plain text label, we shouldn't be using markup any longer.
502 if ( m_markupText )
503 {
504 delete m_markupText;
505 m_markupText = NULL;
506
507 // Unfortunately we don't really know whether we can reset the button
508 // to be non-owner-drawn or not: if we had made it owner-drawn just
509 // because of a call to SetLabelMarkup(), we could, but not if there
510 // were [also] calls to Set{Fore,Back}groundColour(). If it's really a
511 // problem to have button remain owner-drawn forever just because it
512 // had markup label once, we should record the reason for our current
513 // owner-drawnness and check it here.
514 }
515 #endif // wxUSE_MARKUP
516 }
517
518 // ----------------------------------------------------------------------------
519 // size management including autosizing
520 // ----------------------------------------------------------------------------
521
522 void wxAnyButton::AdjustForBitmapSize(wxSize &size) const
523 {
524 wxCHECK_RET( m_imageData, wxT("shouldn't be called if no image") );
525
526 // account for the bitmap size
527 const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
528 const wxDirection dirBmp = m_imageData->GetBitmapPosition();
529 if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
530 {
531 size.x += sizeBmp.x;
532 if ( sizeBmp.y > size.y )
533 size.y = sizeBmp.y;
534 }
535 else // bitmap on top/below the text
536 {
537 size.y += sizeBmp.y;
538 if ( sizeBmp.x > size.x )
539 size.x = sizeBmp.x;
540 }
541
542 // account for the user-specified margins
543 size += 2*m_imageData->GetBitmapMargins();
544
545 // and also for the margins we always add internally (unless we have no
546 // border at all in which case the button has exactly the same size as
547 // bitmap and so no margins should be used)
548 if ( !HasFlag(wxBORDER_NONE) )
549 {
550 int marginH = 0,
551 marginV = 0;
552 #if wxUSE_UXTHEME
553 if ( wxUxThemeEngine::GetIfActive() )
554 {
555 wxUxThemeHandle theme(const_cast<wxAnyButton *>(this), L"BUTTON");
556
557 MARGINS margins;
558 wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
559 BP_PUSHBUTTON,
560 PBS_NORMAL,
561 TMT_CONTENTMARGINS,
562 NULL,
563 &margins);
564
565 // XP doesn't draw themed buttons correctly when the client
566 // area is smaller than 8x8 - enforce this minimum size for
567 // small bitmaps
568 size.IncTo(wxSize(8, 8));
569
570 marginH = margins.cxLeftWidth + margins.cxRightWidth
571 + 2*XP_BUTTON_EXTRA_MARGIN;
572 marginV = margins.cyTopHeight + margins.cyBottomHeight
573 + 2*XP_BUTTON_EXTRA_MARGIN;
574 }
575 else
576 #endif // wxUSE_UXTHEME
577 {
578 marginH =
579 marginV = OD_BUTTON_MARGIN;
580 }
581
582 size.IncBy(marginH, marginV);
583 }
584 }
585
586 wxSize wxAnyButton::DoGetBestSize() const
587 {
588 wxAnyButton * const self = const_cast<wxAnyButton *>(this);
589
590 wxSize size;
591
592 // Account for the text part if we have it.
593 if ( ShowsLabel() )
594 {
595 int flags = 0;
596 if ( HasFlag(wxBU_EXACTFIT) )
597 flags |= wxMSWButton::Size_ExactFit;
598 if ( DoGetAuthNeeded() )
599 flags |= wxMSWButton::Size_AuthNeeded;
600
601 #if wxUSE_MARKUP
602 if ( m_markupText )
603 {
604 wxClientDC dc(self);
605 size = wxMSWButton::GetFittingSize(self,
606 m_markupText->Measure(dc),
607 flags);
608 }
609 else // Normal plain text (but possibly multiline) label.
610 #endif // wxUSE_MARKUP
611 {
612 size = wxMSWButton::ComputeBestFittingSize(self, flags);
613 }
614 }
615
616 if ( m_imageData )
617 AdjustForBitmapSize(size);
618
619 return wxMSWButton::IncreaseToStdSizeAndCache(self, size);
620 }
621
622 // ----------------------------------------------------------------------------
623 // event/message handlers
624 // ----------------------------------------------------------------------------
625
626 WXLRESULT wxAnyButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
627 {
628 if ( nMsg == WM_LBUTTONDBLCLK )
629 {
630 // emulate a click event to force an owner-drawn button to change its
631 // appearance - without this, it won't do it
632 (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
633
634 // and continue with processing the message normally as well
635 }
636 #if wxUSE_UXTHEME
637 else if ( nMsg == WM_THEMECHANGED )
638 {
639 // need to recalculate the best size here
640 // as the theme size might have changed
641 InvalidateBestSize();
642 }
643 #endif // wxUSE_UXTHEME
644 // must use m_mouseInWindow here instead of IsMouseInWindow()
645 // since we need to know the first time the mouse enters the window
646 // and IsMouseInWindow() would return true in this case
647 else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
648 nMsg == WM_MOUSELEAVE )
649 {
650 if (
651 IsEnabled() &&
652 (
653 #if wxUSE_UXTHEME
654 wxUxThemeEngine::GetIfActive() ||
655 #endif // wxUSE_UXTHEME
656 (m_imageData && m_imageData->GetBitmap(State_Current).IsOk())
657 )
658 )
659 {
660 Refresh();
661 }
662 }
663
664 // let the base class do all real processing
665 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
666 }
667
668 // ----------------------------------------------------------------------------
669 // button images
670 // ----------------------------------------------------------------------------
671
672 wxBitmap wxAnyButton::DoGetBitmap(State which) const
673 {
674 return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
675 }
676
677 void wxAnyButton::DoSetBitmap(const wxBitmap& bitmap, State which)
678 {
679 #if wxUSE_UXTHEME
680 wxXPButtonImageData *oldData = NULL;
681 #endif // wxUSE_UXTHEME
682
683 // Check if we already had bitmaps of different size.
684 if ( m_imageData &&
685 bitmap.GetSize() != m_imageData->GetBitmap(State_Normal).GetSize() )
686 {
687 wxASSERT_MSG( (which == State_Normal) || bitmap.IsNull(),
688 "Must set normal bitmap with the new size first" );
689
690 #if wxUSE_UXTHEME
691 if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
692 {
693 // We can't change the size of the images stored in wxImageList
694 // in wxXPButtonImageData::m_iml so force recreating it below but
695 // keep the current data to copy its values into the new one.
696 oldData = static_cast<wxXPButtonImageData *>(m_imageData);
697 m_imageData = NULL;
698 }
699 #endif // wxUSE_UXTHEME
700 //else: wxODButtonImageData doesn't require anything special
701 }
702
703 // allocate the image data when the first bitmap is set
704 if ( !m_imageData )
705 {
706 #if wxUSE_UXTHEME
707 // using image list doesn't work correctly if we don't have any label
708 // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
709 // BS_BITMAP style), at least under Windows 2003 so use owner drawn
710 // strategy for bitmap-only buttons
711 if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
712 {
713 m_imageData = new wxXPButtonImageData(this, bitmap);
714
715 if ( oldData )
716 {
717 // Preserve the old values in case the user changed them.
718 m_imageData->SetBitmapPosition(oldData->GetBitmapPosition());
719
720 const wxSize oldMargins = oldData->GetBitmapMargins();
721 m_imageData->SetBitmapMargins(oldMargins.x, oldMargins.y);
722
723 // No need to preserve the bitmaps though as they were of wrong
724 // size anyhow.
725
726 delete oldData;
727 }
728 }
729 else
730 #endif // wxUSE_UXTHEME
731 {
732 m_imageData = new wxODButtonImageData(this, bitmap);
733 MakeOwnerDrawn();
734 }
735 }
736 else
737 {
738 m_imageData->SetBitmap(bitmap, which);
739 }
740
741 // it should be enough to only invalidate the best size when the normal
742 // bitmap changes as all bitmaps assigned to the button should be of the
743 // same size anyhow
744 if ( which == State_Normal )
745 InvalidateBestSize();
746
747 Refresh();
748 }
749
750 wxSize wxAnyButton::DoGetBitmapMargins() const
751 {
752 return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
753 }
754
755 void wxAnyButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
756 {
757 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
758
759 m_imageData->SetBitmapMargins(x, y);
760 InvalidateBestSize();
761 }
762
763 void wxAnyButton::DoSetBitmapPosition(wxDirection dir)
764 {
765 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
766
767 m_imageData->SetBitmapPosition(dir);
768 InvalidateBestSize();
769 }
770
771 // ----------------------------------------------------------------------------
772 // markup support
773 // ----------------------------------------------------------------------------
774
775 #if wxUSE_MARKUP
776
777 bool wxAnyButton::DoSetLabelMarkup(const wxString& markup)
778 {
779 if ( !wxAnyButtonBase::DoSetLabelMarkup(markup) )
780 return false;
781
782 if ( !m_markupText )
783 {
784 m_markupText = new wxMarkupText(markup);
785 MakeOwnerDrawn();
786 }
787 else
788 {
789 // We are already owner-drawn so just update the text.
790 m_markupText->SetMarkup(markup);
791 }
792
793 Refresh();
794
795 return true;
796 }
797
798 #endif // wxUSE_MARKUP
799
800 // ----------------------------------------------------------------------------
801 // owner-drawn buttons support
802 // ----------------------------------------------------------------------------
803
804 // drawing helpers
805 namespace
806 {
807
808 // return the button state using both the ODS_XXX flags specified in state
809 // parameter and the current button state
810 wxAnyButton::State GetButtonState(wxAnyButton *btn, UINT state)
811 {
812 if ( state & ODS_DISABLED )
813 return wxAnyButton::State_Disabled;
814
815 if ( state & ODS_SELECTED )
816 return wxAnyButton::State_Pressed;
817
818 if ( btn->HasCapture() || btn->IsMouseInWindow() )
819 return wxAnyButton::State_Current;
820
821 if ( state & ODS_FOCUS )
822 return wxAnyButton::State_Focused;
823
824 return btn->GetNormalState();
825 }
826
827 void DrawButtonText(HDC hdc,
828 RECT *pRect,
829 wxAnyButton *btn,
830 int flags)
831 {
832 const wxString text = btn->GetLabel();
833
834 if ( text.find(wxT('\n')) != wxString::npos )
835 {
836 // draw multiline label
837
838 // center text horizontally in any case
839 flags |= DT_CENTER;
840
841 // first we need to compute its bounding rect
842 RECT rc;
843 ::CopyRect(&rc, pRect);
844 ::DrawText(hdc, text.t_str(), text.length(), &rc,
845 DT_CENTER | DT_CALCRECT);
846
847 // now center this rect inside the entire button area
848 const LONG w = rc.right - rc.left;
849 const LONG h = rc.bottom - rc.top;
850 rc.left = pRect->left + (pRect->right - pRect->left)/2 - w/2;
851 rc.right = rc.left+w;
852 rc.top = pRect->top + (pRect->bottom - pRect->top)/2 - h/2;
853 rc.bottom = rc.top+h;
854
855 ::DrawText(hdc, text.t_str(), text.length(), &rc, flags);
856 }
857 else // single line label
858 {
859 // translate wx button flags to alignment flags for DrawText()
860 if ( btn->HasFlag(wxBU_RIGHT) )
861 {
862 flags |= DT_RIGHT;
863 }
864 else if ( !btn->HasFlag(wxBU_LEFT) )
865 {
866 flags |= DT_CENTER;
867 }
868 //else: DT_LEFT is the default anyhow (and its value is 0 too)
869
870 if ( btn->HasFlag(wxBU_BOTTOM) )
871 {
872 flags |= DT_BOTTOM;
873 }
874 else if ( !btn->HasFlag(wxBU_TOP) )
875 {
876 flags |= DT_VCENTER;
877 }
878 //else: as above, DT_TOP is the default
879
880 // notice that we must have DT_SINGLELINE for vertical alignment flags
881 // to work
882 ::DrawText(hdc, text.t_str(), text.length(), pRect,
883 flags | DT_SINGLELINE );
884 }
885 }
886
887 void DrawRect(HDC hdc, const RECT& r)
888 {
889 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
890 wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
891 wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
892 wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
893 }
894
895 /*
896 The button frame looks like this normally:
897
898 WWWWWWWWWWWWWWWWWWB
899 WHHHHHHHHHHHHHHHHGB W = white (HILIGHT)
900 WH GB H = light grey (LIGHT)
901 WH GB G = dark grey (SHADOW)
902 WH GB B = black (DKSHADOW)
903 WH GB
904 WGGGGGGGGGGGGGGGGGB
905 BBBBBBBBBBBBBBBBBBB
906
907 When the button is selected, the button becomes like this (the total button
908 size doesn't change):
909
910 BBBBBBBBBBBBBBBBBBB
911 BWWWWWWWWWWWWWWWWBB
912 BWHHHHHHHHHHHHHHGBB
913 BWH GBB
914 BWH GBB
915 BWGGGGGGGGGGGGGGGBB
916 BBBBBBBBBBBBBBBBBBB
917 BBBBBBBBBBBBBBBBBBB
918
919 When the button is pushed (while selected) it is like:
920
921 BBBBBBBBBBBBBBBBBBB
922 BGGGGGGGGGGGGGGGGGB
923 BG GB
924 BG GB
925 BG GB
926 BG GB
927 BGGGGGGGGGGGGGGGGGB
928 BBBBBBBBBBBBBBBBBBB
929 */
930 void DrawButtonFrame(HDC hdc, RECT& rectBtn,
931 bool selected, bool pushed)
932 {
933 RECT r;
934 CopyRect(&r, &rectBtn);
935
936 AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
937 hpenGrey(GetSysColor(COLOR_3DSHADOW)),
938 hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
939 hpenWhite(GetSysColor(COLOR_3DHILIGHT));
940
941 SelectInHDC selectPen(hdc, hpenBlack);
942
943 r.right--;
944 r.bottom--;
945
946 if ( pushed )
947 {
948 DrawRect(hdc, r);
949
950 (void)SelectObject(hdc, hpenGrey);
951 ::InflateRect(&r, -1, -1);
952
953 DrawRect(hdc, r);
954 }
955 else // !pushed
956 {
957 if ( selected )
958 {
959 DrawRect(hdc, r);
960
961 ::InflateRect(&r, -1, -1);
962 }
963
964 wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
965 wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
966
967 (void)SelectObject(hdc, hpenWhite);
968 wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
969 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
970
971 (void)SelectObject(hdc, hpenLightGr);
972 wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
973 wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
974
975 (void)SelectObject(hdc, hpenGrey);
976 wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
977 wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
978 }
979
980 InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
981 }
982
983 #if wxUSE_UXTHEME
984 void DrawXPBackground(wxAnyButton *button, HDC hdc, RECT& rectBtn, UINT state)
985 {
986 wxUxThemeHandle theme(button, L"BUTTON");
987
988 // this array is indexed by wxAnyButton::State values and so must be kept in
989 // sync with it
990 static const int uxStates[] =
991 {
992 PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
993 };
994
995 int iState = uxStates[GetButtonState(button, state)];
996
997 wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
998
999 // draw parent background if needed
1000 if ( engine->IsThemeBackgroundPartiallyTransparent
1001 (
1002 theme,
1003 BP_PUSHBUTTON,
1004 iState
1005 ) )
1006 {
1007 // Set this button as the one whose background is being erased: this
1008 // allows our WM_ERASEBKGND handler used by DrawThemeParentBackground()
1009 // to correctly align the background brush with this window instead of
1010 // the parent window to which WM_ERASEBKGND is sent. Notice that this
1011 // doesn't work with custom user-defined EVT_ERASE_BACKGROUND handlers
1012 // as they won't be aligned but unfortunately all the attempts to fix
1013 // it by shifting DC origin before calling DrawThemeParentBackground()
1014 // failed to work so we at least do this, even though this is far from
1015 // being the perfect solution.
1016 wxWindowBeingErased = button;
1017
1018 engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
1019
1020 wxWindowBeingErased = NULL;
1021 }
1022
1023 // draw background
1024 engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
1025 &rectBtn, NULL);
1026
1027 // calculate content area margins
1028 MARGINS margins;
1029 engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
1030 TMT_CONTENTMARGINS, &rectBtn, &margins);
1031 ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
1032 ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
1033
1034 if ( button->UseBgCol() )
1035 {
1036 COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
1037 AutoHBRUSH hbrushBackground(colBg);
1038
1039 // don't overwrite the focus rect
1040 RECT rectClient;
1041 ::CopyRect(&rectClient, &rectBtn);
1042 ::InflateRect(&rectClient, -1, -1);
1043 FillRect(hdc, &rectClient, hbrushBackground);
1044 }
1045 }
1046 #endif // wxUSE_UXTHEME
1047
1048 } // anonymous namespace
1049
1050 // ----------------------------------------------------------------------------
1051 // owner drawn buttons support
1052 // ----------------------------------------------------------------------------
1053
1054 void wxAnyButton::MakeOwnerDrawn()
1055 {
1056 if ( !IsOwnerDrawn() )
1057 {
1058 // make it so
1059 // note that BS_OWNERDRAW is not independent from other style bits
1060 long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1061 style &= ~(BS_3STATE | BS_AUTO3STATE | BS_AUTOCHECKBOX | BS_AUTORADIOBUTTON | BS_CHECKBOX | BS_DEFPUSHBUTTON | BS_GROUPBOX | BS_PUSHBUTTON | BS_RADIOBUTTON | BS_PUSHLIKE);
1062 style |= BS_OWNERDRAW;
1063 SetWindowLong(GetHwnd(), GWL_STYLE, style);
1064 }
1065 }
1066
1067 bool wxAnyButton::IsOwnerDrawn() const
1068 {
1069 long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1070 return ( (style & BS_OWNERDRAW) == BS_OWNERDRAW );
1071 }
1072
1073 bool wxAnyButton::SetBackgroundColour(const wxColour &colour)
1074 {
1075 if ( !wxControl::SetBackgroundColour(colour) )
1076 {
1077 // nothing to do
1078 return false;
1079 }
1080
1081 MakeOwnerDrawn();
1082
1083 Refresh();
1084
1085 return true;
1086 }
1087
1088 bool wxAnyButton::SetForegroundColour(const wxColour &colour)
1089 {
1090 if ( !wxControl::SetForegroundColour(colour) )
1091 {
1092 // nothing to do
1093 return false;
1094 }
1095
1096 MakeOwnerDrawn();
1097
1098 Refresh();
1099
1100 return true;
1101 }
1102
1103 bool wxAnyButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
1104 {
1105 LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
1106 HDC hdc = lpDIS->hDC;
1107
1108 UINT state = lpDIS->itemState;
1109 switch ( GetButtonState(this, state) )
1110 {
1111 case State_Disabled:
1112 state |= ODS_DISABLED;
1113 break;
1114 case State_Pressed:
1115 state |= ODS_SELECTED;
1116 break;
1117 case State_Focused:
1118 state |= ODS_FOCUS;
1119 break;
1120 default:
1121 break;
1122 }
1123
1124 bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
1125
1126 RECT rectBtn;
1127 CopyRect(&rectBtn, &lpDIS->rcItem);
1128
1129 // draw the button background
1130 if ( !HasFlag(wxBORDER_NONE) )
1131 {
1132 #if wxUSE_UXTHEME
1133 if ( wxUxThemeEngine::GetIfActive() )
1134 {
1135 DrawXPBackground(this, hdc, rectBtn, state);
1136 }
1137 else
1138 #endif // wxUSE_UXTHEME
1139 {
1140 COLORREF colBg = wxColourToRGB(GetBackgroundColour());
1141
1142 // first, draw the background
1143 AutoHBRUSH hbrushBackground(colBg);
1144 FillRect(hdc, &rectBtn, hbrushBackground);
1145
1146 // draw the border for the current state
1147 bool selected = (state & ODS_SELECTED) != 0;
1148 if ( !selected )
1149 {
1150 wxTopLevelWindow *
1151 tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
1152 if ( tlw )
1153 {
1154 selected = tlw->GetDefaultItem() == this;
1155 }
1156 }
1157
1158 DrawButtonFrame(hdc, rectBtn, selected, pushed);
1159 }
1160
1161 // draw the focus rectangle if we need it
1162 if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
1163 {
1164 DrawFocusRect(hdc, &rectBtn);
1165
1166 #if wxUSE_UXTHEME
1167 if ( !wxUxThemeEngine::GetIfActive() )
1168 #endif // wxUSE_UXTHEME
1169 {
1170 if ( pushed )
1171 {
1172 // the label is shifted by 1 pixel to create "pushed" effect
1173 OffsetRect(&rectBtn, 1, 1);
1174 }
1175 }
1176 }
1177 }
1178
1179
1180 // draw the image, if any
1181 if ( m_imageData )
1182 {
1183 wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
1184 if ( !bmp.IsOk() )
1185 bmp = m_imageData->GetBitmap(State_Normal);
1186
1187 const wxSize sizeBmp = bmp.GetSize();
1188 const wxSize margin = m_imageData->GetBitmapMargins();
1189 const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
1190 wxRect rectButton(wxRectFromRECT(rectBtn));
1191
1192 // for simplicity, we start with centred rectangle and then move it to
1193 // the appropriate edge
1194 wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
1195
1196 // move bitmap only if we have a label, otherwise keep it centered
1197 if ( ShowsLabel() )
1198 {
1199 switch ( m_imageData->GetBitmapPosition() )
1200 {
1201 default:
1202 wxFAIL_MSG( "invalid direction" );
1203 // fall through
1204
1205 case wxLEFT:
1206 rectBitmap.x = rectButton.x + margin.x;
1207 rectButton.x += sizeBmpWithMargins.x;
1208 rectButton.width -= sizeBmpWithMargins.x;
1209 break;
1210
1211 case wxRIGHT:
1212 rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1213 rectButton.width -= sizeBmpWithMargins.x;
1214 break;
1215
1216 case wxTOP:
1217 rectBitmap.y = rectButton.y + margin.y;
1218 rectButton.y += sizeBmpWithMargins.y;
1219 rectButton.height -= sizeBmpWithMargins.y;
1220 break;
1221
1222 case wxBOTTOM:
1223 rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1224 rectButton.height -= sizeBmpWithMargins.y;
1225 break;
1226 }
1227 }
1228
1229 wxDCTemp dst((WXHDC)hdc);
1230 dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1231
1232 wxCopyRectToRECT(rectButton, rectBtn);
1233 }
1234
1235
1236 // finally draw the label
1237 if ( ShowsLabel() )
1238 {
1239 COLORREF colFg = state & ODS_DISABLED
1240 ? ::GetSysColor(COLOR_GRAYTEXT)
1241 : wxColourToRGB(GetForegroundColour());
1242
1243 wxTextColoursChanger changeFg(hdc, colFg, CLR_INVALID);
1244 wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
1245
1246 #if wxUSE_MARKUP
1247 if ( m_markupText )
1248 {
1249 wxDCTemp dc((WXHDC)hdc);
1250 dc.SetTextForeground(wxColour(colFg));
1251 dc.SetFont(GetFont());
1252
1253 m_markupText->Render(dc, wxRectFromRECT(rectBtn),
1254 state & ODS_NOACCEL
1255 ? wxMarkupText::Render_Default
1256 : wxMarkupText::Render_ShowAccels);
1257 }
1258 else // Plain text label
1259 #endif // wxUSE_MARKUP
1260 {
1261 // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1262 // systems but by happy coincidence ODS_NOACCEL is not used under
1263 // them neither so DT_HIDEPREFIX should never be used there
1264 DrawButtonText(hdc, &rectBtn, this,
1265 state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1266 }
1267 }
1268
1269 return true;
1270 }
1271
1272 #endif // wxHAS_ANY_BUTTON
wxWidgets (Impactor)