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 }
 201
 202 // ----------------------------------------------------------------------------
 203 // flags
 204 // ----------------------------------------------------------------------------
 205
 206 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
 207 {
 208     // buttons never have an external border, they draw their own one
 209     WXDWORD msStyle = wxControl::MSWGetStyle
 210                       (
 211                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 212                       );
 213
 214     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
 215     // each other in any resizeable dialog which has more than one button in
 216     // the bottom
 217     msStyle |= WS_CLIPSIBLINGS;
 218
 219 #ifdef __WIN32__
 220     // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
 221     // and wxBU_RIGHT to get BS_CENTER!
 222     if ( style & wxBU_LEFT )
 223         msStyle |= BS_LEFT;
 224     if ( style & wxBU_RIGHT )
 225         msStyle |= BS_RIGHT;
 226     if ( style & wxBU_TOP )
 227         msStyle |= BS_TOP;
 228     if ( style & wxBU_BOTTOM )
 229         msStyle |= BS_BOTTOM;
 230 #ifndef __WXWINCE__
 231     // flat 2d buttons
 232     if ( style & wxNO_BORDER )
 233         msStyle |= BS_FLAT;
 234 #endif // __WXWINCE__
 235 #endif // __WIN32__
 236
 237     return msStyle;
 238 }
 239
 240 // ----------------------------------------------------------------------------
 241 // size management including autosizing
 242 // ----------------------------------------------------------------------------
 243
 244 wxSize wxButton::DoGetBestSize() const
 245 {
 246     wxClientDC dc(wx_const_cast(wxButton *, this));
 247     dc.SetFont(GetFont());
 248
 249     wxCoord wBtn,
 250             hBtn;
 251     dc.GetMultiLineTextExtent(wxStripMenuCodes(GetLabel()), &wBtn, &hBtn);
 252
 253     // add a margin -- the button is wider than just its label
 254     wBtn += 3*GetCharWidth();
 255     hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hBtn);
 256
 257     // all buttons have at least the standard size unless the user explicitly
 258     // wants them to be of smaller size and used wxBU_EXACTFIT style when
 259     // creating the button
 260     if ( !HasFlag(wxBU_EXACTFIT) )
 261     {
 262         wxSize sz = GetDefaultSize();
 263         if (wBtn > sz.x)
 264             sz.x = wBtn;
 265         if (hBtn > sz.y)
 266             sz.y = hBtn;
 267
 268         return sz;
 269     }
 270
 271     wxSize best(wBtn, hBtn);
 272     CacheBestSize(best);
 273     return best;
 274 }
 275
 276 /* static */
 277 wxSize wxButtonBase::GetDefaultSize()
 278 {
 279     static wxSize s_sizeBtn;
 280
 281     if ( s_sizeBtn.x == 0 )
 282     {
 283         wxScreenDC dc;
 284         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 285
 286         // the size of a standard button in the dialog units is 50x14,
 287         // translate this to pixels
 288         // NB1: the multipliers come from the Windows convention
 289         // NB2: the extra +1/+2 were needed to get the size be the same as the
 290         //      size of the buttons in the standard dialog - I don't know how
 291         //      this happens, but on my system this size is 75x23 in pixels and
 292         //      23*8 isn't even divisible by 14... Would be nice to understand
 293         //      why these constants are needed though!
 294         s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
 295         s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
 296     }
 297
 298     return s_sizeBtn;
 299 }
 300
 301 // ----------------------------------------------------------------------------
 302 // default button handling
 303 // ----------------------------------------------------------------------------
 304
 305 /*
 306    "Everything you ever wanted to know about the default buttons" or "Why do we
 307    have to do all this?"
 308
 309    In MSW the default button should be activated when the user presses Enter
 310    and the current control doesn't process Enter itself somehow. This is
 311    handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
 312    Another aspect of "defaultness" is that the default button has different
 313    appearance: this is due to BS_DEFPUSHBUTTON style which is completely
 314    separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
 315    be unset if our parent window is not active so it should be unset whenever
 316    we lose activation and set back when we regain it.
 317
 318    Final complication is that when a button is active, it should be the default
 319    one, i.e. pressing Enter on a button always activates it and not another
 320    one.
 321
 322    We handle this by maintaining a permanent and a temporary default items in
 323    wxControlContainer (both may be NULL). When a button becomes the current
 324    control (i.e. gets focus) it sets itself as the temporary default which
 325    ensures that it has the right appearance and that Enter will be redirected
 326    to it. When the button loses focus, it unsets the temporary default and so
 327    the default item will be the permanent default -- that is the default button
 328    if any had been set or none otherwise, which is just what we want.
 329
 330    NB: all this is quite complicated by now and the worst is that normally
 331        it shouldn't be necessary at all as for the normal Windows programs
 332        DefWindowProc() and IsDialogMessage() take care of all this
 333        automatically -- however in wxWidgets programs this doesn't work for
 334        nested hierarchies (i.e. a notebook inside a notebook) for unknown
 335        reason and so we have to reproduce all this code ourselves. It would be
 336        very nice if we could avoid doing it.
 337  */
 338
 339 // set this button as the (permanently) default one in its panel
 340 void wxButton::SetDefault()
 341 {
 342     wxWindow *parent = GetParent();
 343
 344     wxCHECK_RET( parent, _T("button without parent?") );
 345
 346     // set this one as the default button both for wxWidgets ...
 347     wxWindow *winOldDefault = parent->SetDefaultItem(this);
 348
 349     // ... and Windows
 350     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 351     SetDefaultStyle(this, true);
 352 }
 353
 354 // set this button as being currently default
 355 void wxButton::SetTmpDefault()
 356 {
 357     wxWindow *parent = GetParent();
 358
 359     wxCHECK_RET( parent, _T("button without parent?") );
 360
 361     wxWindow *winOldDefault = parent->GetDefaultItem();
 362     parent->SetTmpDefaultItem(this);
 363
 364     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 365     SetDefaultStyle(this, true);
 366 }
 367
 368 // unset this button as currently default, it may still stay permanent default
 369 void wxButton::UnsetTmpDefault()
 370 {
 371     wxWindow *parent = GetParent();
 372
 373     wxCHECK_RET( parent, _T("button without parent?") );
 374
 375     parent->SetTmpDefaultItem(NULL);
 376
 377     wxWindow *winOldDefault = parent->GetDefaultItem();
 378
 379     SetDefaultStyle(this, false);
 380     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
 381 }
 382
 383 /* static */
 384 void
 385 wxButton::SetDefaultStyle(wxButton *btn, bool on)
 386 {
 387     // we may be called with NULL pointer -- simpler to do the check here than
 388     // in the caller which does wxDynamicCast()
 389     if ( !btn )
 390         return;
 391
 392     // first, let DefDlgProc() know about the new default button
 393     if ( on )
 394     {
 395         // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
 396         // focus at all any more
 397         if ( !wxTheApp->IsActive() )
 398             return;
 399
 400         // look for a panel-like window
 401         wxWindow *win = btn->GetParent();
 402         while ( win && !win->HasFlag(wxTAB_TRAVERSAL) )
 403             win = win->GetParent();
 404
 405         if ( win )
 406         {
 407             ::SendMessage(GetHwndOf(win), DM_SETDEFID, btn->GetId(), 0L);
 408
 409             // sending DM_SETDEFID also changes the button style to
 410             // BS_DEFPUSHBUTTON so there is nothing more to do
 411         }
 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