]> git.saurik.com Git - wxWidgets.git/blame - src/msw/button.cpp
Create a text measuring context until a real context is assigned, this allows things...
[wxWidgets.git] / src / msw / button.cpp
CommitLineData
2bda0e17 1/////////////////////////////////////////////////////////////////////////////
f1e01716 2// Name: src/msw/button.cpp
2bda0e17
KB
3// Purpose: wxButton
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
6c9a19aa 8// Copyright: (c) Julian Smart
65571936 9// Licence: wxWindows licence
2bda0e17
KB
10/////////////////////////////////////////////////////////////////////////////
11
edccf428
VZ
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
cd0b1709 19
2bda0e17
KB
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
edccf428 24 #pragma hdrstop
2bda0e17
KB
25#endif
26
1e6feb95
VZ
27#if wxUSE_BUTTON
28
f1e01716
WS
29#include "wx/button.h"
30
2bda0e17 31#ifndef WX_PRECOMP
bac409a0 32 #include "wx/app.h"
edccf428 33 #include "wx/brush.h"
4e938f5b 34 #include "wx/panel.h"
8a4df159 35 #include "wx/bmpbuttn.h"
fb39c7ec
RR
36 #include "wx/settings.h"
37 #include "wx/dcscreen.h"
61e6a2ab 38 #include "wx/dcclient.h"
b84aec03 39 #include "wx/toplevel.h"
2bda0e17
KB
40#endif
41
bdf14bff 42#include "wx/imaglist.h"
5f7bcb48 43#include "wx/stockitem.h"
2bda0e17 44#include "wx/msw/private.h"
533171c2 45#include "wx/msw/private/button.h"
d8c89c48
VZ
46#include "wx/msw/private/dc.h"
47
48using namespace wxMSWImpl;
2bda0e17 49
4e9da8b7
RD
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
2352862a 65
233f10bf
VZ
66 // provide the necessary declarations ourselves if they're missing from
67 // headers
2352862a
VZ
68 #ifndef BCM_SETIMAGELIST
69 #define BCM_SETIMAGELIST 0x1602
70 #define BCM_SETTEXTMARGIN 0x1604
233f10bf
VZ
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 };
2352862a 86 #endif
4e9da8b7
RD
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
f915b92e
VZ
101#ifndef DT_HIDEPREFIX
102 #define DT_HIDEPREFIX 0x00100000
103#endif
104
233f10bf
VZ
105// ----------------------------------------------------------------------------
106// button image data
107// ----------------------------------------------------------------------------
108
109// we use different data classes for owner drawn buttons and for themed XP ones
110
111class wxButtonImageData
112{
113public:
114 wxButtonImageData() { }
8f4745fe 115 virtual ~wxButtonImageData() { }
233f10bf
VZ
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
8f4745fe 123 virtual wxDirection GetBitmapPosition() const = 0;
233f10bf
VZ
124 virtual void SetBitmapPosition(wxDirection dir) = 0;
125
126private:
127 wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
128};
129
130namespace
131{
132
8f4745fe
VZ
133// the gap between button edge and the interior area used by Windows for the
134// standard buttons
135const int OD_BUTTON_MARGIN = 4;
136
233f10bf
VZ
137class wxODButtonImageData : public wxButtonImageData
138{
139public:
d5b98eb9 140 wxODButtonImageData(wxButton *btn, const wxBitmap& bitmap)
8f4745fe 141 {
d5b98eb9
VZ
142 SetBitmap(bitmap, wxButton::State_Normal);
143
8f4745fe
VZ
144 m_dir = wxLEFT;
145
a6fd73d3
VZ
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
a2117591 148 if ( btn->ShowsLabel() )
a6fd73d3
VZ
149 {
150 m_margin.x = btn->GetCharWidth();
151 m_margin.y = btn->GetCharHeight() / 2;
152 }
8f4745fe 153 }
233f10bf
VZ
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 {
a6fd73d3 167 return m_margin;
233f10bf
VZ
168 }
169
170 virtual void SetBitmapMargins(wxCoord x, wxCoord y)
171 {
172 m_margin = wxSize(x, y);
173 }
174
8f4745fe 175 virtual wxDirection GetBitmapPosition() const
233f10bf 176 {
8f4745fe 177 return m_dir;
233f10bf
VZ
178 }
179
180 virtual void SetBitmapPosition(wxDirection dir)
181 {
182 m_dir = dir;
183 }
184
185private:
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
a6fd73d3
VZ
197// somehow the margin is one pixel greater than the value returned by
198// GetThemeMargins() call
199const int XP_BUTTON_EXTRA_MARGIN = 1;
200
233f10bf
VZ
201class wxXPButtonImageData : public wxButtonImageData
202{
203public:
204 // we must be constructed with the size of our images as we need to create
205 // the image list
d5b98eb9
VZ
206 wxXPButtonImageData(wxButton *btn, const wxBitmap& bitmap)
207 : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
208 wxButton::State_Max),
233f10bf
VZ
209 m_hwndBtn(GetHwndOf(btn))
210 {
d5b98eb9
VZ
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
233f10bf
VZ
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;
a6fd73d3
VZ
227
228 UpdateImageInfo();
233f10bf
VZ
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 {
d5b98eb9 238 m_iml.Replace(which, bitmap);
233f10bf
VZ
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
8f4745fe 262 virtual wxDirection GetBitmapPosition() const
233f10bf 263 {
8f4745fe
VZ
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 }
233f10bf
VZ
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
317private:
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
edccf428
VZ
344// ----------------------------------------------------------------------------
345// macros
346// ----------------------------------------------------------------------------
347
51596bcb 348#if wxUSE_EXTENDED_RTTI
067e9be6 349
f3291a82
SC
350WX_DEFINE_FLAGS( wxButtonStyle )
351
3ff066a4 352wxBEGIN_FLAGS( wxButtonStyle )
f3291a82
SC
353 // new style border flags, we put them first to
354 // use them for streaming out
3ff066a4
SC
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)
fcf90ee1 361
f3291a82 362 // old style border flags
3ff066a4
SC
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)
cb0afb26 368 wxFLAGS_MEMBER(wxBORDER)
f3291a82 369
bc9fb572 370 // standard window styles
3ff066a4
SC
371 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
372 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
373 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
374 wxFLAGS_MEMBER(wxWANTS_CHARS)
cb0afb26 375 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
3ff066a4
SC
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)
385wxEND_FLAGS( wxButtonStyle )
067e9be6 386
51596bcb
SC
387IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
388
3ff066a4 389wxBEGIN_PROPERTIES_TABLE(wxButton)
fcf90ee1 390 wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
067e9be6 391
fcf90ee1
WS
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") )
067e9be6 394
af498247 395 wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
51741307 396
3ff066a4 397wxEND_PROPERTIES_TABLE()
51596bcb 398
3ff066a4
SC
399wxBEGIN_HANDLERS_TABLE(wxButton)
400wxEND_HANDLERS_TABLE()
51596bcb 401
3ff066a4 402wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle )
51596bcb
SC
403
404
405#else
cd0b1709 406IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
51596bcb 407#endif
2bda0e17 408
edccf428
VZ
409// ============================================================================
410// implementation
411// ============================================================================
412
4af4dec6
VZ
413// ----------------------------------------------------------------------------
414// helper functions from wx/msw/private/button.h
415// ----------------------------------------------------------------------------
416
417void 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;
9a83f860 426 if ( label.find(wxT('\n')) != wxString::npos )
4af4dec6
VZ
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
433aca2d
VZ
435wxSize 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
4af4dec6
VZ
446wxSize wxMSWButton::ComputeBestSize(wxControl *btn)
447{
448 wxClientDC dc(btn);
449
433aca2d
VZ
450 wxSize sizeBtn;
451 dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
4af4dec6 452
433aca2d 453 sizeBtn = GetFittingSize(btn, sizeBtn);
4af4dec6
VZ
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 {
433aca2d
VZ
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;
4af4dec6
VZ
465 }
466
433aca2d
VZ
467 btn->CacheBestSize(sizeBtn);
468
469 return sizeBtn;
4af4dec6
VZ
470}
471
edccf428
VZ
472// ----------------------------------------------------------------------------
473// creation/destruction
474// ----------------------------------------------------------------------------
475
476bool wxButton::Create(wxWindow *parent,
477 wxWindowID id,
5f7bcb48 478 const wxString& lbl,
edccf428
VZ
479 const wxPoint& pos,
480 const wxSize& size,
481 long style,
482 const wxValidator& validator,
483 const wxString& name)
2bda0e17 484{
5f7bcb48
VS
485 wxString label(lbl);
486 if (label.empty() && wxIsStockID(id))
c87fc285 487 {
c4e1d0fc
VZ
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 );
f1e01716
WS
496 }
497
5b2f31eb 498 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
fcf90ee1 499 return false;
edccf428 500
8292017c
VZ
501 WXDWORD exstyle;
502 WXDWORD msStyle = MSWGetStyle(style, &exstyle);
503
8292017c
VZ
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
d94de683 509 // value and the label is not set yet when MSWGetStyle() is called
533171c2 510 msStyle |= wxMSWButton::GetMultilineStyle(label);
8292017c 511
9a83f860 512 return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, exstyle);
5b2f31eb
VZ
513}
514
515wxButton::~wxButton()
516{
6c20e8f8
VZ
517 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
518 if ( tlw && tlw->GetTmpDefaultItem() == this )
789367e1
VZ
519 {
520 UnsetTmpDefault();
521 }
233f10bf
VZ
522
523 delete m_imageData;
5b2f31eb 524}
edccf428 525
5b2f31eb
VZ
526// ----------------------------------------------------------------------------
527// flags
528// ----------------------------------------------------------------------------
cd0b1709 529
5b2f31eb
VZ
530WXDWORD 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 );
f6bcfd97 537
5b2f31eb
VZ
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;
b0766406 542
5b2f31eb
VZ
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 )
f6bcfd97 546 msStyle |= BS_LEFT;
5b2f31eb 547 if ( style & wxBU_RIGHT )
f6bcfd97 548 msStyle |= BS_RIGHT;
5b2f31eb 549 if ( style & wxBU_TOP )
f6bcfd97 550 msStyle |= BS_TOP;
5b2f31eb 551 if ( style & wxBU_BOTTOM )
f6bcfd97 552 msStyle |= BS_BOTTOM;
8cc4850c 553#ifndef __WXWINCE__
8a094d7b
JS
554 // flat 2d buttons
555 if ( style & wxNO_BORDER )
556 msStyle |= BS_FLAT;
8cc4850c 557#endif // __WXWINCE__
edccf428 558
5b2f31eb 559 return msStyle;
2bda0e17
KB
560}
561
d94de683
VZ
562void wxButton::SetLabel(const wxString& label)
563{
533171c2 564 wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
d94de683
VZ
565
566 wxButtonBase::SetLabel(label);
567}
568
edccf428
VZ
569// ----------------------------------------------------------------------------
570// size management including autosizing
571// ----------------------------------------------------------------------------
572
f68586e5 573wxSize wxButton::DoGetBestSize() const
2bda0e17 574{
a6fd73d3
VZ
575 wxSize size;
576
4b601a59
VZ
577 // account for the text part if we have it or if we don't have any image at
578 // all (buttons initially created with empty label should still have a non
579 // zero size)
580 if ( ShowsLabel() || !m_imageData )
a6fd73d3
VZ
581 {
582 size = wxMSWButton::ComputeBestSize(const_cast<wxButton *>(this));
583 }
584
233f10bf
VZ
585 if ( m_imageData )
586 {
a6fd73d3 587 // account for the bitmap size
233f10bf 588 const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
8f4745fe
VZ
589 const wxDirection dirBmp = m_imageData->GetBitmapPosition();
590 if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
233f10bf
VZ
591 {
592 size.x += sizeBmp.x;
593 if ( sizeBmp.y > size.y )
594 size.y = sizeBmp.y;
595 }
596 else // bitmap on top/below the text
597 {
598 size.y += sizeBmp.y;
599 if ( sizeBmp.x > size.x )
600 size.x = sizeBmp.x;
601 }
602
a6fd73d3 603 // account for the user-specified margins
233f10bf
VZ
604 size += 2*m_imageData->GetBitmapMargins();
605
86ac84b8
VZ
606 // and also for the margins we always add internally (unless we have no
607 // border at all in which case the button has exactly the same size as
608 // bitmap and so no margins should be used)
609 if ( !HasFlag(wxBORDER_NONE) )
a6fd73d3 610 {
86ac84b8
VZ
611 int marginH = 0,
612 marginV = 0;
613#if wxUSE_UXTHEME
614 if ( wxUxThemeEngine::GetIfActive() )
615 {
616 wxUxThemeHandle theme(const_cast<wxButton *>(this), L"BUTTON");
a6fd73d3 617
86ac84b8
VZ
618 MARGINS margins;
619 wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
620 BP_PUSHBUTTON,
621 PBS_NORMAL,
622 TMT_CONTENTMARGINS,
623 NULL,
624 &margins);
a6fd73d3 625
86ac84b8
VZ
626 // XP doesn't draw themed buttons correctly when the client
627 // area is smaller than 8x8 - enforce this minimum size for
628 // small bitmaps
629 size.IncTo(wxSize(8, 8));
a6fd73d3 630
a6fd73d3
VZ
631 marginH = margins.cxLeftWidth + margins.cxRightWidth
632 + 2*XP_BUTTON_EXTRA_MARGIN;
633 marginV = margins.cyTopHeight + margins.cyBottomHeight
634 + 2*XP_BUTTON_EXTRA_MARGIN;
635 }
86ac84b8 636 else
a6fd73d3 637#endif // wxUSE_UXTHEME
86ac84b8
VZ
638 {
639 marginH =
640 marginV = OD_BUTTON_MARGIN;
641 }
a6fd73d3 642
86ac84b8
VZ
643 size.IncBy(marginH, marginV);
644 }
a6fd73d3 645
233f10bf
VZ
646 CacheBestSize(size);
647 }
648
649 return size;
2bda0e17
KB
650}
651
e1f36ff8 652/* static */
1e6feb95 653wxSize wxButtonBase::GetDefaultSize()
e1f36ff8 654{
8c3c31d4 655 static wxSize s_sizeBtn;
e1f36ff8 656
8c3c31d4
VZ
657 if ( s_sizeBtn.x == 0 )
658 {
659 wxScreenDC dc;
a756f210 660 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
8c3c31d4
VZ
661
662 // the size of a standard button in the dialog units is 50x14,
663 // translate this to pixels
664 // NB1: the multipliers come from the Windows convention
665 // NB2: the extra +1/+2 were needed to get the size be the same as the
666 // size of the buttons in the standard dialog - I don't know how
667 // this happens, but on my system this size is 75x23 in pixels and
668 // 23*8 isn't even divisible by 14... Would be nice to understand
669 // why these constants are needed though!
670 s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
671 s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
672 }
e1f36ff8 673
8c3c31d4 674 return s_sizeBtn;
e1f36ff8
VZ
675}
676
4438caf4 677// ----------------------------------------------------------------------------
036da5e3 678// default button handling
4438caf4
VZ
679// ----------------------------------------------------------------------------
680
d78f09e2 681/*
eb74a51f
VZ
682 The comment below and all this code is probably due to not using WM_NEXTDLGCTL
683 message when changing focus (but just SetFocus() which is not enough), see
684 http://blogs.msdn.com/oldnewthing/archive/2004/08/02/205624.aspx for the
685 full explanation.
686
687 TODO: Do use WM_NEXTDLGCTL and get rid of all this code.
688
689
d78f09e2
VZ
690 "Everything you ever wanted to know about the default buttons" or "Why do we
691 have to do all this?"
692
693 In MSW the default button should be activated when the user presses Enter
694 and the current control doesn't process Enter itself somehow. This is
695 handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
696 Another aspect of "defaultness" is that the default button has different
697 appearance: this is due to BS_DEFPUSHBUTTON style which is completely
7fb1b2b4
VZ
698 separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
699 be unset if our parent window is not active so it should be unset whenever
700 we lose activation and set back when we regain it.
d78f09e2
VZ
701
702 Final complication is that when a button is active, it should be the default
703 one, i.e. pressing Enter on a button always activates it and not another
704 one.
705
706 We handle this by maintaining a permanent and a temporary default items in
707 wxControlContainer (both may be NULL). When a button becomes the current
708 control (i.e. gets focus) it sets itself as the temporary default which
709 ensures that it has the right appearance and that Enter will be redirected
710 to it. When the button loses focus, it unsets the temporary default and so
711 the default item will be the permanent default -- that is the default button
712 if any had been set or none otherwise, which is just what we want.
713
7fb1b2b4
VZ
714 NB: all this is quite complicated by now and the worst is that normally
715 it shouldn't be necessary at all as for the normal Windows programs
716 DefWindowProc() and IsDialogMessage() take care of all this
77ffb593 717 automatically -- however in wxWidgets programs this doesn't work for
7fb1b2b4
VZ
718 nested hierarchies (i.e. a notebook inside a notebook) for unknown
719 reason and so we have to reproduce all this code ourselves. It would be
720 very nice if we could avoid doing it.
d78f09e2
VZ
721 */
722
036da5e3 723// set this button as the (permanently) default one in its panel
94aff5ff 724wxWindow *wxButton::SetDefault()
2bda0e17 725{
77ffb593 726 // set this one as the default button both for wxWidgets ...
94aff5ff 727 wxWindow *winOldDefault = wxButtonBase::SetDefault();
036da5e3 728
7fb1b2b4 729 // ... and Windows
fcf90ee1
WS
730 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
731 SetDefaultStyle(this, true);
ebc0b155
VZ
732
733 return winOldDefault;
036da5e3
VZ
734}
735
627c8d89
VZ
736// return the top level parent window if it's not being deleted yet, otherwise
737// return NULL
05c5f281
VZ
738static wxTopLevelWindow *GetTLWParentIfNotBeingDeleted(wxWindow *win)
739{
627c8d89 740 for ( ;; )
05c5f281 741 {
627c8d89
VZ
742 // IsTopLevel() will return false for a wxTLW being deleted, so we also
743 // need the parent test for this case
744 wxWindow * const parent = win->GetParent();
745 if ( !parent || win->IsTopLevel() )
9617f65b
VZ
746 {
747 if ( win->IsBeingDeleted() )
748 return NULL;
627c8d89 749
05c5f281 750 break;
9617f65b 751 }
627c8d89
VZ
752
753 win = parent;
05c5f281
VZ
754 }
755
9a83f860 756 wxASSERT_MSG( win, wxT("button without top level parent?") );
05c5f281 757
627c8d89 758 wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
9a83f860 759 wxASSERT_MSG( tlw, wxT("logic error in GetTLWParentIfNotBeingDeleted()") );
627c8d89
VZ
760
761 return tlw;
05c5f281
VZ
762}
763
7fb1b2b4 764// set this button as being currently default
036da5e3
VZ
765void wxButton::SetTmpDefault()
766{
05c5f281
VZ
767 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
768 if ( !tlw )
769 return;
036da5e3 770
6c20e8f8
VZ
771 wxWindow *winOldDefault = tlw->GetDefaultItem();
772 tlw->SetTmpDefaultItem(this);
7fb1b2b4 773
fcf90ee1
WS
774 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
775 SetDefaultStyle(this, true);
036da5e3
VZ
776}
777
7fb1b2b4 778// unset this button as currently default, it may still stay permanent default
036da5e3
VZ
779void wxButton::UnsetTmpDefault()
780{
05c5f281
VZ
781 wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
782 if ( !tlw )
783 return;
036da5e3 784
6c20e8f8 785 tlw->SetTmpDefaultItem(NULL);
036da5e3 786
6c20e8f8 787 wxWindow *winOldDefault = tlw->GetDefaultItem();
7fb1b2b4 788
fcf90ee1
WS
789 SetDefaultStyle(this, false);
790 SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
036da5e3 791}
8ed57d93 792
036da5e3
VZ
793/* static */
794void
7fb1b2b4 795wxButton::SetDefaultStyle(wxButton *btn, bool on)
036da5e3 796{
7fb1b2b4
VZ
797 // we may be called with NULL pointer -- simpler to do the check here than
798 // in the caller which does wxDynamicCast()
799 if ( !btn )
800 return;
801
802 // first, let DefDlgProc() know about the new default button
803 if ( on )
5d1d2d46 804 {
7fb1b2b4
VZ
805 // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
806 // focus at all any more
807 if ( !wxTheApp->IsActive() )
808 return;
cd0b1709 809
6c20e8f8 810 wxWindow * const tlw = wxGetTopLevelParent(btn);
9a83f860 811 wxCHECK_RET( tlw, wxT("button without top level window?") );
cef55d64 812
6c20e8f8 813 ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
cef55d64
VZ
814
815 // sending DM_SETDEFID also changes the button style to
816 // BS_DEFPUSHBUTTON so there is nothing more to do
5d1d2d46
VZ
817 }
818
7fb1b2b4
VZ
819 // then also change the style as needed
820 long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
821 if ( !(style & BS_DEFPUSHBUTTON) == on )
be4017f8 822 {
7fb1b2b4
VZ
823 // don't do it with the owner drawn buttons because it will
824 // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
825 // BS_DEFPUSHBUTTON != 0)!
036da5e3
VZ
826 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
827 {
7fb1b2b4
VZ
828 ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
829 on ? style | BS_DEFPUSHBUTTON
830 : style & ~BS_DEFPUSHBUTTON,
831 1L /* redraw */);
036da5e3 832 }
7fb1b2b4 833 else // owner drawn
036da5e3 834 {
7fb1b2b4
VZ
835 // redraw the button - it will notice itself that it's
836 // [not] the default one [any longer]
837 btn->Refresh();
036da5e3 838 }
be4017f8 839 }
7fb1b2b4 840 //else: already has correct style
2bda0e17
KB
841}
842
edccf428
VZ
843// ----------------------------------------------------------------------------
844// helpers
845// ----------------------------------------------------------------------------
846
847bool wxButton::SendClickEvent()
2bda0e17 848{
edccf428
VZ
849 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
850 event.SetEventObject(this);
851
852 return ProcessCommand(event);
2bda0e17
KB
853}
854
edccf428 855void wxButton::Command(wxCommandEvent & event)
2bda0e17 856{
edccf428 857 ProcessCommand(event);
2bda0e17
KB
858}
859
edccf428
VZ
860// ----------------------------------------------------------------------------
861// event/message handlers
862// ----------------------------------------------------------------------------
2bda0e17 863
33ac7e6f 864bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
edccf428 865{
fcf90ee1 866 bool processed = false;
57c0af52 867 switch ( param )
edccf428 868 {
5aab763c
RD
869 // NOTE: Apparently older versions (NT 4?) of the common controls send
870 // BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
87b6002d 871 // buttons, so in order to send two EVT_BUTTON events we should
5aab763c
RD
872 // catch both types. Currently (Feb 2003) up-to-date versions of
873 // win98, win2k and winXP all send two BN_CLICKED messages for
874 // all button types, so we don't catch BN_DOUBLECLICKED anymore
875 // in order to not get 3 EVT_BUTTON events. If this is a problem
876 // then we need to figure out which version of the comctl32 changed
877 // this behaviour and test for it.
878
a95e38c0
VZ
879 case 1: // message came from an accelerator
880 case BN_CLICKED: // normal buttons send this
57c0af52
VZ
881 processed = SendClickEvent();
882 break;
edccf428 883 }
2bda0e17 884
edccf428 885 return processed;
2bda0e17
KB
886}
887
c140b7e7 888WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
678cd6de 889{
87b6002d 890 // when we receive focus, we want to temporarily become the default button in
036da5e3
VZ
891 // our parent panel so that pressing "Enter" would activate us -- and when
892 // losing it we should restore the previous default button as well
be4017f8 893 if ( nMsg == WM_SETFOCUS )
678cd6de 894 {
036da5e3 895 SetTmpDefault();
be4017f8 896
036da5e3
VZ
897 // let the default processing take place too
898 }
899 else if ( nMsg == WM_KILLFOCUS )
900 {
901 UnsetTmpDefault();
678cd6de 902 }
a95e38c0
VZ
903 else if ( nMsg == WM_LBUTTONDBLCLK )
904 {
f6bcfd97
BP
905 // emulate a click event to force an owner-drawn button to change its
906 // appearance - without this, it won't do it
907 (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
908
036da5e3 909 // and continue with processing the message normally as well
a95e38c0 910 }
4e9da8b7
RD
911#if wxUSE_UXTHEME
912 else if ( nMsg == WM_THEMECHANGED )
913 {
914 // need to recalculate the best size here
915 // as the theme size might have changed
916 InvalidateBestSize();
917 }
d5b98eb9
VZ
918#endif // wxUSE_UXTHEME
919 // must use m_mouseInWindow here instead of IsMouseInWindow()
920 // since we need to know the first time the mouse enters the window
921 // and IsMouseInWindow() would return true in this case
922 else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
923 nMsg == WM_MOUSELEAVE )
4e9da8b7 924 {
d5b98eb9 925 if (
a6fd73d3
VZ
926 IsEnabled() &&
927 (
d5b98eb9
VZ
928#if wxUSE_UXTHEME
929 wxUxThemeEngine::GetIfActive() ||
930#endif // wxUSE_UXTHEME
931 m_imageData && m_imageData->GetBitmap(State_Current).IsOk()
a6fd73d3 932 )
d5b98eb9 933 )
4e9da8b7
RD
934 {
935 Refresh();
936 }
937 }
678cd6de
VZ
938
939 // let the base class do all real processing
940 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
941}
cd0b1709 942
233f10bf
VZ
943// ----------------------------------------------------------------------------
944// button images
945// ----------------------------------------------------------------------------
946
947wxBitmap wxButton::DoGetBitmap(State which) const
948{
949 return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
950}
951
952void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
953{
954 // allocate the image data when the first bitmap is set
955 if ( !m_imageData )
956 {
957#if wxUSE_UXTHEME
a6fd73d3
VZ
958 // using image list doesn't work correctly if we don't have any label
959 // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
960 // BS_BITMAP style), at least under Windows 2003 so use owner drawn
961 // strategy for bitmap-only buttons
a2117591 962 if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
8f4745fe 963 {
d5b98eb9 964 m_imageData = new wxXPButtonImageData(this, bitmap);
8f4745fe 965 }
233f10bf
VZ
966 else
967#endif // wxUSE_UXTHEME
8f4745fe 968 {
d5b98eb9 969 m_imageData = new wxODButtonImageData(this, bitmap);
8f4745fe
VZ
970 MakeOwnerDrawn();
971 }
233f10bf 972 }
d5b98eb9
VZ
973 else
974 {
975 m_imageData->SetBitmap(bitmap, which);
976 }
a6fd73d3 977
e431c7df
VZ
978 // it should be enough to only invalidate the best size when the normal
979 // bitmap changes as all bitmaps assigned to the button should be of the
980 // same size anyhow
981 if ( which == State_Normal )
982 InvalidateBestSize();
983
a6fd73d3
VZ
984 Refresh();
985}
986
987wxSize wxButton::DoGetBitmapMargins() const
988{
989 return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
233f10bf
VZ
990}
991
992void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
993{
994 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
995
996 m_imageData->SetBitmapMargins(x, y);
997}
998
999void wxButton::DoSetBitmapPosition(wxDirection dir)
1000{
1001 wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
1002
1003 m_imageData->SetBitmapPosition(dir);
1004}
1005
cd0b1709
VZ
1006// ----------------------------------------------------------------------------
1007// owner-drawn buttons support
1008// ----------------------------------------------------------------------------
1009
cd0b1709 1010// drawing helpers
d8c89c48
VZ
1011namespace
1012{
cd0b1709 1013
d5b98eb9
VZ
1014// return the button state using both the ODS_XXX flags specified in state
1015// parameter and the current button state
1016wxButton::State GetButtonState(wxButton *btn, UINT state)
1017{
1018 if ( state & ODS_DISABLED )
1019 return wxButton::State_Disabled;
1020
1021 if ( state & ODS_SELECTED )
1022 return wxButton::State_Pressed;
1023
1024 if ( btn->HasCapture() || btn->IsMouseInWindow() )
1025 return wxButton::State_Current;
1026
1027 if ( state & ODS_FOCUS )
1028 return wxButton::State_Focused;
1029
1030 return wxButton::State_Normal;
1031}
1032
d8c89c48
VZ
1033void DrawButtonText(HDC hdc,
1034 RECT *pRect,
1035 const wxString& text,
1036 COLORREF col,
1037 int flags)
cd0b1709 1038{
d8c89c48
VZ
1039 wxTextColoursChanger changeFg(hdc, col, CLR_INVALID);
1040 wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
cd0b1709 1041
f915b92e
VZ
1042 // center text horizontally in any case
1043 flags |= DT_CENTER;
1044
9a83f860 1045 if ( text.find(wxT('\n')) != wxString::npos )
cbbb6724
VZ
1046 {
1047 // draw multiline label
1048
1049 // first we need to compute its bounding rect
1050 RECT rc;
1051 ::CopyRect(&rc, pRect);
e0a050e3
VS
1052 ::DrawText(hdc, text.wx_str(), text.length(), &rc,
1053 DT_CENTER | DT_CALCRECT);
cbbb6724
VZ
1054
1055 // now center this rect inside the entire button area
1056 const LONG w = rc.right - rc.left;
1057 const LONG h = rc.bottom - rc.top;
1058 rc.left = (pRect->right - pRect->left)/2 - w/2;
1059 rc.right = rc.left+w;
1060 rc.top = (pRect->bottom - pRect->top)/2 - h/2;
1061 rc.bottom = rc.top+h;
1062
f915b92e 1063 ::DrawText(hdc, text.wx_str(), text.length(), &rc, flags);
cbbb6724
VZ
1064 }
1065 else // single line label
1066 {
f915b92e
VZ
1067 // centre text vertically too (notice that we must have DT_SINGLELINE
1068 // for DT_VCENTER to work)
e0a050e3 1069 ::DrawText(hdc, text.wx_str(), text.length(), pRect,
f915b92e 1070 flags | DT_SINGLELINE | DT_VCENTER);
cbbb6724 1071 }
cd0b1709
VZ
1072}
1073
d8c89c48 1074void DrawRect(HDC hdc, const RECT& r)
cd0b1709 1075{
4676948b
JS
1076 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
1077 wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
1078 wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
1079 wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
cd0b1709
VZ
1080}
1081
cd0b1709
VZ
1082/*
1083 The button frame looks like this normally:
1084
1085 WWWWWWWWWWWWWWWWWWB
16162a64
GRG
1086 WHHHHHHHHHHHHHHHHGB W = white (HILIGHT)
1087 WH GB H = light grey (LIGHT)
1088 WH GB G = dark grey (SHADOW)
1089 WH GB B = black (DKSHADOW)
1090 WH GB
cd0b1709
VZ
1091 WGGGGGGGGGGGGGGGGGB
1092 BBBBBBBBBBBBBBBBBBB
1093
1094 When the button is selected, the button becomes like this (the total button
1095 size doesn't change):
1096
1097 BBBBBBBBBBBBBBBBBBB
1098 BWWWWWWWWWWWWWWWWBB
16162a64
GRG
1099 BWHHHHHHHHHHHHHHGBB
1100 BWH GBB
1101 BWH GBB
cd0b1709
VZ
1102 BWGGGGGGGGGGGGGGGBB
1103 BBBBBBBBBBBBBBBBBBB
1104 BBBBBBBBBBBBBBBBBBB
1105
1106 When the button is pushed (while selected) it is like:
1107
1108 BBBBBBBBBBBBBBBBBBB
1109 BGGGGGGGGGGGGGGGGGB
1110 BG GB
1111 BG GB
1112 BG GB
16162a64 1113 BG GB
cd0b1709
VZ
1114 BGGGGGGGGGGGGGGGGGB
1115 BBBBBBBBBBBBBBBBBBB
1116*/
8f4745fe 1117void DrawButtonFrame(HDC hdc, RECT& rectBtn,
d8c89c48 1118 bool selected, bool pushed)
cd0b1709
VZ
1119{
1120 RECT r;
1121 CopyRect(&r, &rectBtn);
1122
9c956c0a
VZ
1123 AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
1124 hpenGrey(GetSysColor(COLOR_3DSHADOW)),
1125 hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
1126 hpenWhite(GetSysColor(COLOR_3DHILIGHT));
cd0b1709 1127
9c956c0a 1128 SelectInHDC selectPen(hdc, hpenBlack);
cd0b1709
VZ
1129
1130 r.right--;
1131 r.bottom--;
1132
1133 if ( pushed )
1134 {
1135 DrawRect(hdc, r);
1136
1137 (void)SelectObject(hdc, hpenGrey);
fcf90ee1 1138 ::InflateRect(&r, -1, -1);
cd0b1709
VZ
1139
1140 DrawRect(hdc, r);
1141 }
1142 else // !pushed
1143 {
1144 if ( selected )
1145 {
1146 DrawRect(hdc, r);
1147
fcf90ee1 1148 ::InflateRect(&r, -1, -1);
cd0b1709
VZ
1149 }
1150
4676948b
JS
1151 wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
1152 wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
cd0b1709
VZ
1153
1154 (void)SelectObject(hdc, hpenWhite);
4676948b
JS
1155 wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
1156 wxDrawLine(hdc, r.left, r.top, r.right, r.top);
cd0b1709 1157
16162a64 1158 (void)SelectObject(hdc, hpenLightGr);
4676948b
JS
1159 wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
1160 wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
16162a64 1161
cd0b1709 1162 (void)SelectObject(hdc, hpenGrey);
4676948b
JS
1163 wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
1164 wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
cd0b1709 1165 }
8f4745fe
VZ
1166
1167 InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
cd0b1709
VZ
1168}
1169
4e9da8b7 1170#if wxUSE_UXTHEME
d5b98eb9 1171void DrawXPBackground(wxButton *button, HDC hdc, RECT& rectBtn, UINT state)
cd0b1709 1172{
4e9da8b7 1173 wxUxThemeHandle theme(button, L"BUTTON");
4e9da8b7 1174
d5b98eb9
VZ
1175 // this array is indexed by wxButton::State values and so must be kept in
1176 // sync with it
958e4b4b 1177 static const int uxStates[] =
4e9da8b7 1178 {
d5b98eb9
VZ
1179 PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
1180 };
1181
1182 int iState = uxStates[GetButtonState(button, state)];
1183
1184 wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
cd0b1709 1185
4e9da8b7 1186 // draw parent background if needed
d5b98eb9
VZ
1187 if ( engine->IsThemeBackgroundPartiallyTransparent
1188 (
1189 theme,
1190 BP_PUSHBUTTON,
1191 iState
1192 ) )
4e9da8b7 1193 {
d5b98eb9 1194 engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
4e9da8b7
RD
1195 }
1196
1197 // draw background
d5b98eb9
VZ
1198 engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
1199 &rectBtn, NULL);
4e9da8b7
RD
1200
1201 // calculate content area margins
1202 MARGINS margins;
d5b98eb9
VZ
1203 engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
1204 TMT_CONTENTMARGINS, &rectBtn, &margins);
8f4745fe 1205 ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
a6fd73d3 1206 ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
4e9da8b7
RD
1207
1208 if ( button->UseBgCol() )
1209 {
1210 COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
9c956c0a 1211 AutoHBRUSH hbrushBackground(colBg);
4e9da8b7
RD
1212
1213 // don't overwrite the focus rect
8f4745fe
VZ
1214 RECT rectClient;
1215 ::CopyRect(&rectClient, &rectBtn);
4e9da8b7
RD
1216 ::InflateRect(&rectClient, -1, -1);
1217 FillRect(hdc, &rectClient, hbrushBackground);
4e9da8b7
RD
1218 }
1219}
1220#endif // wxUSE_UXTHEME
1221
d8c89c48
VZ
1222} // anonymous namespace
1223
1224// ----------------------------------------------------------------------------
1225// owner drawn buttons support
1226// ----------------------------------------------------------------------------
1227
1228void wxButton::MakeOwnerDrawn()
1229{
1230 long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1231 if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
1232 {
1233 // make it so
1234 style |= BS_OWNERDRAW;
1235 SetWindowLong(GetHwnd(), GWL_STYLE, style);
1236 }
1237}
1238
1239bool wxButton::SetBackgroundColour(const wxColour &colour)
1240{
1241 if ( !wxControl::SetBackgroundColour(colour) )
1242 {
1243 // nothing to do
1244 return false;
1245 }
1246
1247 MakeOwnerDrawn();
1248
1249 Refresh();
1250
1251 return true;
1252}
1253
1254bool wxButton::SetForegroundColour(const wxColour &colour)
1255{
1256 if ( !wxControl::SetForegroundColour(colour) )
1257 {
1258 // nothing to do
1259 return false;
1260 }
1261
1262 MakeOwnerDrawn();
1263
1264 Refresh();
1265
1266 return true;
1267}
1268
4e9da8b7
RD
1269bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
1270{
1271 LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
cd0b1709 1272 HDC hdc = lpDIS->hDC;
8f4745fe 1273
cd0b1709 1274 UINT state = lpDIS->itemState;
8f4745fe
VZ
1275 bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
1276
4e9da8b7
RD
1277 RECT rectBtn;
1278 CopyRect(&rectBtn, &lpDIS->rcItem);
cd0b1709 1279
8f4745fe 1280 // draw the button background
86ac84b8 1281 if ( !HasFlag(wxBORDER_NONE) )
4e9da8b7 1282 {
86ac84b8
VZ
1283#if wxUSE_UXTHEME
1284 if ( wxUxThemeEngine::GetIfActive() )
1285 {
1286 DrawXPBackground(this, hdc, rectBtn, state);
1287 }
1288 else
4e9da8b7 1289#endif // wxUSE_UXTHEME
86ac84b8
VZ
1290 {
1291 COLORREF colBg = wxColourToRGB(GetBackgroundColour());
cd0b1709 1292
86ac84b8
VZ
1293 // first, draw the background
1294 AutoHBRUSH hbrushBackground(colBg);
1295 FillRect(hdc, &rectBtn, hbrushBackground);
cd0b1709 1296
86ac84b8
VZ
1297 // draw the border for the current state
1298 bool selected = (state & ODS_SELECTED) != 0;
1299 if ( !selected )
4e9da8b7 1300 {
86ac84b8
VZ
1301 wxTopLevelWindow *
1302 tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
1303 if ( tlw )
1304 {
1305 selected = tlw->GetDefaultItem() == this;
1306 }
4e9da8b7 1307 }
cd0b1709 1308
86ac84b8
VZ
1309 DrawButtonFrame(hdc, rectBtn, selected, pushed);
1310 }
cd0b1709 1311
86ac84b8
VZ
1312 // draw the focus rectangle if we need it
1313 if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
1314 {
1315 DrawFocusRect(hdc, &rectBtn);
cd0b1709 1316
8f4745fe 1317#if wxUSE_UXTHEME
86ac84b8 1318 if ( !wxUxThemeEngine::GetIfActive() )
8f4745fe 1319#endif // wxUSE_UXTHEME
8f4745fe 1320 {
86ac84b8
VZ
1321 if ( pushed )
1322 {
1323 // the label is shifted by 1 pixel to create "pushed" effect
1324 OffsetRect(&rectBtn, 1, 1);
1325 }
8f4745fe 1326 }
4e9da8b7 1327 }
8f4745fe
VZ
1328 }
1329
cd0b1709 1330
8f4745fe
VZ
1331 // draw the image, if any
1332 if ( m_imageData )
1333 {
d5b98eb9
VZ
1334 wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
1335 if ( !bmp.IsOk() )
1336 bmp = m_imageData->GetBitmap(State_Normal);
1337
8f4745fe
VZ
1338 const wxSize sizeBmp = bmp.GetSize();
1339 const wxSize margin = m_imageData->GetBitmapMargins();
1340 const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
1341 wxRect rectButton(wxRectFromRECT(rectBtn));
1342
1343 // for simplicity, we start with centred rectangle and then move it to
1344 // the appropriate edge
1345 wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
1346 switch ( m_imageData->GetBitmapPosition() )
4e9da8b7 1347 {
8f4745fe
VZ
1348 default:
1349 wxFAIL_MSG( "invalid direction" );
1350 // fall through
1351
1352 case wxLEFT:
1353 rectBitmap.x = rectButton.x + margin.x;
1354 rectButton.x += sizeBmpWithMargins.x;
1355 rectButton.width -= sizeBmpWithMargins.x;
1356 break;
1357
1358 case wxRIGHT:
1359 rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1360 rectButton.width -= sizeBmpWithMargins.x;
1361 break;
1362
1363 case wxTOP:
1364 rectBitmap.y = rectButton.y + margin.y;
1365 rectButton.y += sizeBmpWithMargins.y;
1366 rectButton.height -= sizeBmpWithMargins.y;
1367 break;
1368
1369 case wxBOTTOM:
1370 rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1371 rectButton.height -= sizeBmpWithMargins.y;
1372 break;
4e9da8b7 1373 }
8f4745fe
VZ
1374
1375 wxDCTemp dst((WXHDC)hdc);
1376 dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1377
1378 wxCopyRectToRECT(rectButton, rectBtn);
9750fc42
VZ
1379 }
1380
8f4745fe
VZ
1381
1382 // finally draw the label
a2117591 1383 if ( ShowsLabel() )
a6fd73d3
VZ
1384 {
1385 COLORREF colFg = state & ODS_DISABLED
1386 ? ::GetSysColor(COLOR_GRAYTEXT)
1387 : wxColourToRGB(GetForegroundColour());
1388
1389 // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1390 // systems but by happy coincidence ODS_NOACCEL is not used under them
1391 // neither so DT_HIDEPREFIX should never be used there
a2117591 1392 DrawButtonText(hdc, &rectBtn, GetLabel(), colFg,
a6fd73d3
VZ
1393 state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1394 }
cd0b1709 1395
fcf90ee1 1396 return true;
cd0b1709
VZ
1397}
1398
1e6feb95 1399#endif // wxUSE_BUTTON
4af4dec6 1400