src/msw/button.cpp

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