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 #endif
  40
  41 #include "wx/stockitem.h"
  42 #include "wx/tokenzr.h"
  43 #include "wx/msw/private.h"
  44
  45 #if wxUSE_UXTHEME
  46     #include "wx/msw/uxtheme.h"
  47
  48     // no need to include tmschema.h
  49     #ifndef BP_PUSHBUTTON
  50         #define BP_PUSHBUTTON 1
  51
  52         #define PBS_NORMAL    1
  53         #define PBS_HOT       2
  54         #define PBS_PRESSED   3
  55         #define PBS_DISABLED  4
  56         #define PBS_DEFAULTED 5
  57
  58         #define TMT_CONTENTMARGINS 3602
  59     #endif
  60 #endif // wxUSE_UXTHEME
  61
  62 #ifndef WM_THEMECHANGED
  63     #define WM_THEMECHANGED     0x031A
  64 #endif
  65
  66 #ifndef ODS_NOACCEL
  67     #define ODS_NOACCEL         0x0100
  68 #endif
  69
  70 #ifndef ODS_NOFOCUSRECT
  71     #define ODS_NOFOCUSRECT     0x0200
  72 #endif
  73
  74 // ----------------------------------------------------------------------------
  75 // macros
  76 // ----------------------------------------------------------------------------
  77
  78 #if wxUSE_EXTENDED_RTTI
  79
  80 WX_DEFINE_FLAGS( wxButtonStyle )
  81
  82 wxBEGIN_FLAGS( wxButtonStyle )
  83     // new style border flags, we put them first to
  84     // use them for streaming out
  85     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  86     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  87     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  88     wxFLAGS_MEMBER(wxBORDER_RAISED)
  89     wxFLAGS_MEMBER(wxBORDER_STATIC)
  90     wxFLAGS_MEMBER(wxBORDER_NONE)
  91
  92     // old style border flags
  93     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  94     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  95     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  96     wxFLAGS_MEMBER(wxRAISED_BORDER)
  97     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  98     wxFLAGS_MEMBER(wxBORDER)
  99
 100     // standard window styles
 101     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 102     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 103     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 104     wxFLAGS_MEMBER(wxWANTS_CHARS)
 105     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 106     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 107     wxFLAGS_MEMBER(wxVSCROLL)
 108     wxFLAGS_MEMBER(wxHSCROLL)
 109
 110     wxFLAGS_MEMBER(wxBU_LEFT)
 111     wxFLAGS_MEMBER(wxBU_RIGHT)
 112     wxFLAGS_MEMBER(wxBU_TOP)
 113     wxFLAGS_MEMBER(wxBU_BOTTOM)
 114     wxFLAGS_MEMBER(wxBU_EXACTFIT)
 115 wxEND_FLAGS( wxButtonStyle )
 116
 117 IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
 118
 119 wxBEGIN_PROPERTIES_TABLE(wxButton)
 120     wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
 121
 122     wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 123     wxPROPERTY( Label, wxString , SetLabel, GetLabel, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 124
 125     wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 126
 127 wxEND_PROPERTIES_TABLE()
 128
 129 wxBEGIN_HANDLERS_TABLE(wxButton)
 130 wxEND_HANDLERS_TABLE()
 131
 132 wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle  )
 133
 134
 135 #else
 136 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
 137 #endif
 138
 139 // this macro tries to adjust the default button height to a reasonable value
 140 // using the char height as the base
 141 #define BUTTON_HEIGHT_FROM_CHAR_HEIGHT(cy) (11*EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)/10)
 142
 143 // ============================================================================
 144 // implementation
 145 // ============================================================================
 146
 147 // ----------------------------------------------------------------------------
 148 // creation/destruction
 149 // ----------------------------------------------------------------------------
 150
 151 bool wxButton::Create(wxWindow *parent,
 152                       wxWindowID id,
 153                       const wxString& lbl,
 154                       const wxPoint& pos,
 155                       const wxSize& size,
 156                       long style,
 157                       const wxValidator& validator,
 158                       const wxString& name)
 159 {
 160     wxString label(lbl);
 161     if (label.empty() && wxIsStockID(id))
 162     {
 163         // On Windows, some buttons aren't supposed to have
 164         // mnemonics, so strip them out.
 165
 166         label = wxGetStockLabel(id
 167 #if defined(__WXMSW__) || defined(__WXWINCE__)
 168                                         , ( id != wxID_OK &&
 169                                             id != wxID_CANCEL &&
 170                                             id != wxID_CLOSE )
 171 #endif
 172                                 );
 173     }
 174
 175     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 176         return false;
 177
 178     WXDWORD exstyle;
 179     WXDWORD msStyle = MSWGetStyle(style, &exstyle);
 180
 181 #ifdef __WIN32__
 182     // if the label contains several lines we must explicitly tell the button
 183     // about it or it wouldn't draw it correctly ("\n"s would just appear as
 184     // black boxes)
 185     //
 186     // NB: we do it here and not in MSWGetStyle() because we need the label
 187     //     value and m_label is not set yet when MSWGetStyle() is called;
 188     //     besides changing BS_MULTILINE during run-time is pointless anyhow
 189     if ( label.find(_T('\n')) != wxString::npos )
 190     {
 191         msStyle |= BS_MULTILINE;
 192     }
 193 #endif // __WIN32__
 194
 195     return MSWCreateControl(_T("BUTTON"), msStyle, pos, size, label, exstyle);
 196 }
 197
 198 wxButton::~wxButton()
 199 {
 200     wxWindow *parent = GetParent();
 201     if ( parent && parent->GetTmpDefaultItem() == this )
 202     {
 203         UnsetTmpDefault();
 204     }
 205 }
 206
 207 // ----------------------------------------------------------------------------
 208 // flags
 209 // ----------------------------------------------------------------------------
 210
 211 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
 212 {
 213     // buttons never have an external border, they draw their own one
 214     WXDWORD msStyle = wxControl::MSWGetStyle
 215                       (
 216                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 217                       );
 218
 219     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
 220     // each other in any resizeable dialog which has more than one button in
 221     // the bottom
 222     msStyle |= WS_CLIPSIBLINGS;
 223
 224 #ifdef __WIN32__
 225     // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
 226     // and wxBU_RIGHT to get BS_CENTER!
 227     if ( style & wxBU_LEFT )
 228         msStyle |= BS_LEFT;
 229     if ( style & wxBU_RIGHT )
 230         msStyle |= BS_RIGHT;
 231     if ( style & wxBU_TOP )
 232         msStyle |= BS_TOP;
 233     if ( style & wxBU_BOTTOM )
 234         msStyle |= BS_BOTTOM;
 235 #ifndef __WXWINCE__
 236     // flat 2d buttons
 237     if ( style & wxNO_BORDER )
 238         msStyle |= BS_FLAT;
 239 #endif // __WXWINCE__
 240 #endif // __WIN32__
 241
 242     return msStyle;
 243 }
 244
 245 // ----------------------------------------------------------------------------
 246 // size management including autosizing
 247 // ----------------------------------------------------------------------------
 248
 249 wxSize wxButton::DoGetBestSize() const
 250 {
 251     wxClientDC dc(wx_const_cast(wxButton *, this));
 252     dc.SetFont(GetFont());
 253
 254     wxCoord wBtn,
 255             hBtn;
 256     dc.GetMultiLineTextExtent(wxStripMenuCodes(GetLabel()), &wBtn, &hBtn);
 257
 258     // add a margin -- the button is wider than just its label
 259     wBtn += 3*GetCharWidth();
 260     hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hBtn);
 261
 262     // all buttons have at least the standard size unless the user explicitly
 263     // wants them to be of smaller size and used wxBU_EXACTFIT style when
 264     // creating the button
 265     if ( !HasFlag(wxBU_EXACTFIT) )
 266     {
 267         wxSize sz = GetDefaultSize();
 268         if (wBtn > sz.x)
 269             sz.x = wBtn;
 270         if (hBtn > sz.y)
 271             sz.y = hBtn;
 272
 273         return sz;
 274     }
 275
 276     wxSize best(wBtn, hBtn);
 277     CacheBestSize(best);
 278     return best;
 279 }
 280
 281 /* static */
 282 wxSize wxButtonBase::GetDefaultSize()
 283 {
 284     static wxSize s_sizeBtn;
 285
 286     if ( s_sizeBtn.x == 0 )
 287     {
 288         wxScreenDC dc;
 289         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 290
 291         // the size of a standard button in the dialog units is 50x14,
 292         // translate this to pixels
 293         // NB1: the multipliers come from the Windows convention
 294         // NB2: the extra +1/+2 were needed to get the size be the same as the
 295         //      size of the buttons in the standard dialog - I don't know how
 296         //      this happens, but on my system this size is 75x23 in pixels and
 297         //      23*8 isn't even divisible by 14... Would be nice to understand
 298         //      why these constants are needed though!
 299         s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
 300         s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
 301     }
 302
 303     return s_sizeBtn;
 304 }
 305
 306 // ----------------------------------------------------------------------------
 307 // default button handling
 308 // ----------------------------------------------------------------------------
 309
 310 /*
 311    "Everything you ever wanted to know about the default buttons" or "Why do we
 312    have to do all this?"
 313
 314    In MSW the default button should be activated when the user presses Enter
 315    and the current control doesn't process Enter itself somehow. This is
 316    handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
 317    Another aspect of "defaultness" is that the default button has different
 318    appearance: this is due to BS_DEFPUSHBUTTON style which is completely
 319    separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
 320    be unset if our parent window is not active so it should be unset whenever
 321    we lose activation and set back when we regain it.
 322
 323    Final complication is that when a button is active, it should be the default
 324    one, i.e. pressing Enter on a button always activates it and not another
 325    one.
 326
 327    We handle this by maintaining a permanent and a temporary default items in
 328    wxControlContainer (both may be NULL). When a button becomes the current
 329    control (i.e. gets focus) it sets itself as the temporary default which
 330    ensures that it has the right appearance and that Enter will be redirected
 331    to it. When the button loses focus, it unsets the temporary default and so
 332    the default item will be the permanent default -- that is the default button
 333    if any had been set or none otherwise, which is just what we want.
 334
 335    NB: all this is quite complicated by now and the worst is that normally
 336        it shouldn't be necessary at all as for the normal Windows programs
 337        DefWindowProc() and IsDialogMessage() take care of all this
 338        automatically -- however in wxWidgets programs this doesn't work for
 339        nested hierarchies (i.e. a notebook inside a notebook) for unknown
 340        reason and so we have to reproduce all this code ourselves. It would be
 341        very nice if we could avoid doing it.
 342  */
 343
 344 // set this button as the (permanently) default one in its panel
 345 void wxButton::SetDefault()
 346 {
 347     wxWindow *parent = GetParent();
 348
 349     wxCHECK_RET( parent, _T("button without parent?") );
 350
 351     // set this one as the default button both for wxWidgets ...
 352     wxWindow *winOldDefault = parent->SetDefaultItem(this);
 353
 354     // ... and Windows
 355     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 356     SetDefaultStyle(this, true);
 357 }
 358
 359 // set this button as being currently default
 360 void wxButton::SetTmpDefault()
 361 {
 362     wxWindow *parent = GetParent();
 363
 364     wxCHECK_RET( parent, _T("button without parent?") );
 365
 366     wxWindow *winOldDefault = parent->GetDefaultItem();
 367     parent->SetTmpDefaultItem(this);
 368
 369     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 370     SetDefaultStyle(this, true);
 371 }
 372
 373 // unset this button as currently default, it may still stay permanent default
 374 void wxButton::UnsetTmpDefault()
 375 {
 376     wxWindow *parent = GetParent();
 377
 378     wxCHECK_RET( parent, _T("button without parent?") );
 379
 380     parent->SetTmpDefaultItem(NULL);
 381
 382     wxWindow *winOldDefault = parent->GetDefaultItem();
 383
 384     SetDefaultStyle(this, false);
 385     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
 386 }
 387
 388 /* static */
 389 void
 390 wxButton::SetDefaultStyle(wxButton *btn, bool on)
 391 {
 392     // we may be called with NULL pointer -- simpler to do the check here than
 393     // in the caller which does wxDynamicCast()
 394     if ( !btn )
 395         return;
 396
 397     // first, let DefDlgProc() know about the new default button
 398     if ( on )
 399     {
 400         // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
 401         // focus at all any more
 402         if ( !wxTheApp->IsActive() )
 403             return;
 404
 405         wxWindow * const parent = btn->GetParent();
 406         wxCHECK_RET( parent, _T("button without parent?") );
 407
 408         ::SendMessage(GetHwndOf(parent), DM_SETDEFID, btn->GetId(), 0L);
 409
 410         // sending DM_SETDEFID also changes the button style to
 411         // BS_DEFPUSHBUTTON so there is nothing more to do
 412     }
 413
 414     // then also change the style as needed
 415     long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
 416     if ( !(style & BS_DEFPUSHBUTTON) == on )
 417     {
 418         // don't do it with the owner drawn buttons because it will
 419         // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
 420         // BS_DEFPUSHBUTTON != 0)!
 421         if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 422         {
 423             ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
 424                           on ? style | BS_DEFPUSHBUTTON
 425                              : style & ~BS_DEFPUSHBUTTON,
 426                           1L /* redraw */);
 427         }
 428         else // owner drawn
 429         {
 430             // redraw the button - it will notice itself that it's
 431             // [not] the default one [any longer]
 432             btn->Refresh();
 433         }
 434     }
 435     //else: already has correct style
 436 }
 437
 438 // ----------------------------------------------------------------------------
 439 // helpers
 440 // ----------------------------------------------------------------------------
 441
 442 bool wxButton::SendClickEvent()
 443 {
 444     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
 445     event.SetEventObject(this);
 446
 447     return ProcessCommand(event);
 448 }
 449
 450 void wxButton::Command(wxCommandEvent & event)
 451 {
 452     ProcessCommand(event);
 453 }
 454
 455 // ----------------------------------------------------------------------------
 456 // event/message handlers
 457 // ----------------------------------------------------------------------------
 458
 459 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 460 {
 461     bool processed = false;
 462     switch ( param )
 463     {
 464         // NOTE: Apparently older versions (NT 4?) of the common controls send
 465         //       BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
 466         //       buttons, so in order to send two EVT_BUTTON events we should
 467         //       catch both types.  Currently (Feb 2003) up-to-date versions of
 468         //       win98, win2k and winXP all send two BN_CLICKED messages for
 469         //       all button types, so we don't catch BN_DOUBLECLICKED anymore
 470         //       in order to not get 3 EVT_BUTTON events.  If this is a problem
 471         //       then we need to figure out which version of the comctl32 changed
 472         //       this behaviour and test for it.
 473
 474         case 1:                     // message came from an accelerator
 475         case BN_CLICKED:            // normal buttons send this
 476             processed = SendClickEvent();
 477             break;
 478     }
 479
 480     return processed;
 481 }
 482
 483 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 484 {
 485     // when we receive focus, we want to temporarily become the default button in
 486     // our parent panel so that pressing "Enter" would activate us -- and when
 487     // losing it we should restore the previous default button as well
 488     if ( nMsg == WM_SETFOCUS )
 489     {
 490         SetTmpDefault();
 491
 492         // let the default processing take place too
 493     }
 494     else if ( nMsg == WM_KILLFOCUS )
 495     {
 496         UnsetTmpDefault();
 497     }
 498     else if ( nMsg == WM_LBUTTONDBLCLK )
 499     {
 500         // emulate a click event to force an owner-drawn button to change its
 501         // appearance - without this, it won't do it
 502         (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
 503
 504         // and continue with processing the message normally as well
 505     }
 506 #if wxUSE_UXTHEME
 507     else if ( nMsg == WM_THEMECHANGED )
 508     {
 509         // need to recalculate the best size here
 510         // as the theme size might have changed
 511         InvalidateBestSize();
 512     }
 513     else if ( wxUxThemeEngine::GetIfActive() )
 514     {
 515         // we need to Refresh() if mouse has entered or left window
 516         // so we can update the hot tracking state
 517         // must use m_mouseInWindow here instead of IsMouseInWindow()
 518         // since we need to know the first time the mouse enters the window
 519         // and IsMouseInWindow() would return true in this case
 520         if ( ( nMsg == WM_MOUSEMOVE && !m_mouseInWindow ) ||
 521              nMsg == WM_MOUSELEAVE )
 522         {
 523             Refresh();
 524         }
 525     }
 526 #endif // wxUSE_UXTHEME
 527
 528     // let the base class do all real processing
 529     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 530 }
 531
 532 // ----------------------------------------------------------------------------
 533 // owner-drawn buttons support
 534 // ----------------------------------------------------------------------------
 535
 536 #ifdef __WIN32__
 537
 538 // drawing helpers
 539
 540 static void DrawButtonText(HDC hdc,
 541                            RECT *pRect,
 542                            const wxString& text,
 543                            COLORREF col)
 544 {
 545     COLORREF colOld = SetTextColor(hdc, col);
 546     int modeOld = SetBkMode(hdc, TRANSPARENT);
 547
 548     if ( text.find(_T('\n')) != wxString::npos )
 549     {
 550         // draw multiline label
 551
 552         // first we need to compute its bounding rect
 553         RECT rc;
 554         ::CopyRect(&rc, pRect);
 555         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER | DT_CALCRECT);
 556
 557         // now center this rect inside the entire button area
 558         const LONG w = rc.right - rc.left;
 559         const LONG h = rc.bottom - rc.top;
 560         rc.left = (pRect->right - pRect->left)/2 - w/2;
 561         rc.right = rc.left+w;
 562         rc.top = (pRect->bottom - pRect->top)/2 - h/2;
 563         rc.bottom = rc.top+h;
 564
 565         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER);
 566     }
 567     else // single line label
 568     {
 569         // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
 570         ::DrawText(hdc, text, text.length(), pRect,
 571                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 572     }
 573
 574     SetBkMode(hdc, modeOld);
 575     SetTextColor(hdc, colOld);
 576 }
 577
 578 static void DrawRect(HDC hdc, const RECT& r)
 579 {
 580     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 581     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
 582     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
 583     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 584 }
 585
 586 void wxButton::MakeOwnerDrawn()
 587 {
 588     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
 589     if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 590     {
 591         // make it so
 592         style |= BS_OWNERDRAW;
 593         SetWindowLong(GetHwnd(), GWL_STYLE, style);
 594     }
 595 }
 596
 597 bool wxButton::SetBackgroundColour(const wxColour &colour)
 598 {
 599     if ( !wxControl::SetBackgroundColour(colour) )
 600     {
 601         // nothing to do
 602         return false;
 603     }
 604
 605     MakeOwnerDrawn();
 606
 607     Refresh();
 608
 609     return true;
 610 }
 611
 612 bool wxButton::SetForegroundColour(const wxColour &colour)
 613 {
 614     if ( !wxControl::SetForegroundColour(colour) )
 615     {
 616         // nothing to do
 617         return false;
 618     }
 619
 620     MakeOwnerDrawn();
 621
 622     Refresh();
 623
 624     return true;
 625 }
 626
 627 /*
 628    The button frame looks like this normally:
 629
 630    WWWWWWWWWWWWWWWWWWB
 631    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
 632    WH               GB  H = light grey  (LIGHT)
 633    WH               GB  G = dark grey   (SHADOW)
 634    WH               GB  B = black       (DKSHADOW)
 635    WH               GB
 636    WGGGGGGGGGGGGGGGGGB
 637    BBBBBBBBBBBBBBBBBBB
 638
 639    When the button is selected, the button becomes like this (the total button
 640    size doesn't change):
 641
 642    BBBBBBBBBBBBBBBBBBB
 643    BWWWWWWWWWWWWWWWWBB
 644    BWHHHHHHHHHHHHHHGBB
 645    BWH             GBB
 646    BWH             GBB
 647    BWGGGGGGGGGGGGGGGBB
 648    BBBBBBBBBBBBBBBBBBB
 649    BBBBBBBBBBBBBBBBBBB
 650
 651    When the button is pushed (while selected) it is like:
 652
 653    BBBBBBBBBBBBBBBBBBB
 654    BGGGGGGGGGGGGGGGGGB
 655    BG               GB
 656    BG               GB
 657    BG               GB
 658    BG               GB
 659    BGGGGGGGGGGGGGGGGGB
 660    BBBBBBBBBBBBBBBBBBB
 661 */
 662
 663 static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
 664                             bool selected, bool pushed)
 665 {
 666     RECT r;
 667     CopyRect(&r, &rectBtn);
 668
 669     HPEN hpenBlack   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
 670          hpenGrey    = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
 671          hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
 672          hpenWhite   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
 673
 674     HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
 675
 676     r.right--;
 677     r.bottom--;
 678
 679     if ( pushed )
 680     {
 681         DrawRect(hdc, r);
 682
 683         (void)SelectObject(hdc, hpenGrey);
 684         ::InflateRect(&r, -1, -1);
 685
 686         DrawRect(hdc, r);
 687     }
 688     else // !pushed
 689     {
 690         if ( selected )
 691         {
 692             DrawRect(hdc, r);
 693
 694             ::InflateRect(&r, -1, -1);
 695         }
 696
 697         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
 698         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
 699
 700         (void)SelectObject(hdc, hpenWhite);
 701         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
 702         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 703
 704         (void)SelectObject(hdc, hpenLightGr);
 705         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
 706         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
 707
 708         (void)SelectObject(hdc, hpenGrey);
 709         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
 710         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
 711     }
 712
 713     (void)SelectObject(hdc, hpenOld);
 714     DeleteObject(hpenWhite);
 715     DeleteObject(hpenLightGr);
 716     DeleteObject(hpenGrey);
 717     DeleteObject(hpenBlack);
 718 }
 719
 720 #if wxUSE_UXTHEME
 721 static
 722 void MSWDrawXPBackground(wxButton *button, WXDRAWITEMSTRUCT *wxdis)
 723 {
 724     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
 725     HDC hdc = lpDIS->hDC;
 726     UINT state = lpDIS->itemState;
 727     RECT rectBtn;
 728     CopyRect(&rectBtn, &lpDIS->rcItem);
 729
 730     wxUxThemeHandle theme(button, L"BUTTON");
 731     int iState;
 732
 733     if ( state & ODS_SELECTED )
 734     {
 735         iState = PBS_PRESSED;
 736     }
 737     else if ( button->HasCapture() || button->IsMouseInWindow() )
 738     {
 739         iState = PBS_HOT;
 740     }
 741     else if ( state & ODS_FOCUS )
 742     {
 743         iState = PBS_DEFAULTED;
 744     }
 745     else if ( state & ODS_DISABLED )
 746     {
 747         iState = PBS_DISABLED;
 748     }
 749     else
 750     {
 751         iState = PBS_NORMAL;
 752     }
 753
 754     // draw parent background if needed
 755     if ( wxUxThemeEngine::Get()->IsThemeBackgroundPartiallyTransparent(theme,
 756                                                                        BP_PUSHBUTTON,
 757                                                                        iState) )
 758     {
 759         wxUxThemeEngine::Get()->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
 760     }
 761
 762     // draw background
 763     wxUxThemeEngine::Get()->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
 764                                                 &rectBtn, NULL);
 765
 766     // calculate content area margins
 767     MARGINS margins;
 768     wxUxThemeEngine::Get()->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
 769                                             TMT_CONTENTMARGINS, &rectBtn, &margins);
 770     RECT rectClient;
 771     ::CopyRect(&rectClient, &rectBtn);
 772     ::InflateRect(&rectClient, -margins.cxLeftWidth, -margins.cyTopHeight);
 773
 774     // if focused and !nofocus rect
 775     if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
 776     {
 777         DrawFocusRect(hdc, &rectClient);
 778     }
 779
 780     if ( button->UseBgCol() )
 781     {
 782         COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
 783         HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
 784
 785         // don't overwrite the focus rect
 786         ::InflateRect(&rectClient, -1, -1);
 787         FillRect(hdc, &rectClient, hbrushBackground);
 788         ::DeleteObject(hbrushBackground);
 789     }
 790 }
 791 #endif // wxUSE_UXTHEME
 792
 793 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 794 {
 795     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
 796     HDC hdc = lpDIS->hDC;
 797     UINT state = lpDIS->itemState;
 798     RECT rectBtn;
 799     CopyRect(&rectBtn, &lpDIS->rcItem);
 800
 801 #if wxUSE_UXTHEME
 802     if ( wxUxThemeEngine::GetIfActive() )
 803     {
 804         MSWDrawXPBackground(this, wxdis);
 805     }
 806     else
 807 #endif // wxUSE_UXTHEME
 808     {
 809         COLORREF colBg = wxColourToRGB(GetBackgroundColour());
 810
 811         // first, draw the background
 812         HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
 813         FillRect(hdc, &rectBtn, hbrushBackground);
 814         ::DeleteObject(hbrushBackground);
 815
 816         // draw the border for the current state
 817         bool selected = (state & ODS_SELECTED) != 0;
 818         if ( !selected )
 819         {
 820             wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
 821             if ( panel )
 822             {
 823                 selected = panel->GetDefaultItem() == this;
 824             }
 825         }
 826         bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
 827
 828         DrawButtonFrame(hdc, rectBtn, selected, pushed);
 829
 830         // if focused and !nofocus rect
 831         if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
 832         {
 833             RECT rectFocus;
 834             CopyRect(&rectFocus, &rectBtn);
 835
 836             // I don't know where does this constant come from, but this is how
 837             // Windows draws them
 838             InflateRect(&rectFocus, -4, -4);
 839
 840             DrawFocusRect(hdc, &rectFocus);
 841         }
 842
 843         if ( pushed )
 844         {
 845             // the label is shifted by 1 pixel to create "pushed" effect
 846             OffsetRect(&rectBtn, 1, 1);
 847         }
 848     }
 849
 850     COLORREF colFg = wxColourToRGB(GetForegroundColour());
 851     DrawButtonText(hdc, &rectBtn,
 852                    (state & ODS_NOACCEL ? wxStripMenuCodes(GetLabel())
 853                                         : GetLabel()),
 854                    state & ODS_DISABLED ? GetSysColor(COLOR_GRAYTEXT)
 855                                         : colFg);
 856
 857     return true;
 858 }
 859
 860 #endif // __WIN32__
 861
 862 #endif // wxUSE_BUTTON