src/msw/button.cpp

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