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     wxClientDC dc(wx_const_cast(wxButton *, this));
 220     dc.SetFont(GetFont());
 221
 222     wxCoord wBtn,
 223             hBtn;
 224     dc.GetMultiLineTextExtent(GetLabel(), &wBtn, &hBtn);
 225
 226     // add a margin -- the button is wider than just its label
 227     wBtn += 3*GetCharWidth();
 228     hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hBtn);
 229
 230     // all buttons have at least the standard size unless the user explicitly
 231     // wants them to be of smaller size and used wxBU_EXACTFIT style when
 232     // creating the button
 233     if ( !HasFlag(wxBU_EXACTFIT) )
 234     {
 235         wxSize sz = GetDefaultSize();
 236         if (wBtn > sz.x)
 237             sz.x = wBtn;
 238         if (hBtn > sz.y)
 239             sz.y = hBtn;
 240
 241         return sz;
 242     }
 243
 244     return wxSize(wBtn, hBtn);
 245 }
 246
 247 /* static */
 248 wxSize wxButtonBase::GetDefaultSize()
 249 {
 250     static wxSize s_sizeBtn;
 251
 252     if ( s_sizeBtn.x == 0 )
 253     {
 254         wxScreenDC dc;
 255         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 256
 257         // the size of a standard button in the dialog units is 50x14,
 258         // translate this to pixels
 259         // NB1: the multipliers come from the Windows convention
 260         // NB2: the extra +1/+2 were needed to get the size be the same as the
 261         //      size of the buttons in the standard dialog - I don't know how
 262         //      this happens, but on my system this size is 75x23 in pixels and
 263         //      23*8 isn't even divisible by 14... Would be nice to understand
 264         //      why these constants are needed though!
 265         s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
 266         s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
 267     }
 268
 269     return s_sizeBtn;
 270 }
 271
 272 // ----------------------------------------------------------------------------
 273 // default button handling
 274 // ----------------------------------------------------------------------------
 275
 276 /*
 277    "Everything you ever wanted to know about the default buttons" or "Why do we
 278    have to do all this?"
 279
 280    In MSW the default button should be activated when the user presses Enter
 281    and the current control doesn't process Enter itself somehow. This is
 282    handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
 283    Another aspect of "defaultness" is that the default button has different
 284    appearance: this is due to BS_DEFPUSHBUTTON style which is completely
 285    separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
 286    be unset if our parent window is not active so it should be unset whenever
 287    we lose activation and set back when we regain it.
 288
 289    Final complication is that when a button is active, it should be the default
 290    one, i.e. pressing Enter on a button always activates it and not another
 291    one.
 292
 293    We handle this by maintaining a permanent and a temporary default items in
 294    wxControlContainer (both may be NULL). When a button becomes the current
 295    control (i.e. gets focus) it sets itself as the temporary default which
 296    ensures that it has the right appearance and that Enter will be redirected
 297    to it. When the button loses focus, it unsets the temporary default and so
 298    the default item will be the permanent default -- that is the default button
 299    if any had been set or none otherwise, which is just what we want.
 300
 301    NB: all this is quite complicated by now and the worst is that normally
 302        it shouldn't be necessary at all as for the normal Windows programs
 303        DefWindowProc() and IsDialogMessage() take care of all this
 304        automatically -- however in wxWidgets programs this doesn't work for
 305        nested hierarchies (i.e. a notebook inside a notebook) for unknown
 306        reason and so we have to reproduce all this code ourselves. It would be
 307        very nice if we could avoid doing it.
 308  */
 309
 310 // set this button as the (permanently) default one in its panel
 311 void wxButton::SetDefault()
 312 {
 313     wxWindow *parent = GetParent();
 314
 315     wxCHECK_RET( parent, _T("button without parent?") );
 316
 317     // set this one as the default button both for wxWidgets ...
 318     wxWindow *winOldDefault = parent->SetDefaultItem(this);
 319
 320     // ... and Windows
 321     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 322     SetDefaultStyle(this, true);
 323 }
 324
 325 // set this button as being currently default
 326 void wxButton::SetTmpDefault()
 327 {
 328     wxWindow *parent = GetParent();
 329
 330     wxCHECK_RET( parent, _T("button without parent?") );
 331
 332     wxWindow *winOldDefault = parent->GetDefaultItem();
 333     parent->SetTmpDefaultItem(this);
 334
 335     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 336     SetDefaultStyle(this, true);
 337 }
 338
 339 // unset this button as currently default, it may still stay permanent default
 340 void wxButton::UnsetTmpDefault()
 341 {
 342     wxWindow *parent = GetParent();
 343
 344     wxCHECK_RET( parent, _T("button without parent?") );
 345
 346     parent->SetTmpDefaultItem(NULL);
 347
 348     wxWindow *winOldDefault = parent->GetDefaultItem();
 349
 350     SetDefaultStyle(this, false);
 351     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
 352 }
 353
 354 /* static */
 355 void
 356 wxButton::SetDefaultStyle(wxButton *btn, bool on)
 357 {
 358     // we may be called with NULL pointer -- simpler to do the check here than
 359     // in the caller which does wxDynamicCast()
 360     if ( !btn )
 361         return;
 362
 363     // first, let DefDlgProc() know about the new default button
 364     if ( on )
 365     {
 366         // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
 367         // focus at all any more
 368         if ( !wxTheApp->IsActive() )
 369             return;
 370
 371         // look for a panel-like window
 372         wxWindow *win = btn->GetParent();
 373         while ( win && !win->HasFlag(wxTAB_TRAVERSAL) )
 374             win = win->GetParent();
 375
 376         if ( win )
 377         {
 378             ::SendMessage(GetHwndOf(win), DM_SETDEFID, btn->GetId(), 0L);
 379
 380             // sending DM_SETDEFID also changes the button style to
 381             // BS_DEFPUSHBUTTON so there is nothing more to do
 382         }
 383     }
 384
 385     // then also change the style as needed
 386     long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
 387     if ( !(style & BS_DEFPUSHBUTTON) == on )
 388     {
 389         // don't do it with the owner drawn buttons because it will
 390         // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
 391         // BS_DEFPUSHBUTTON != 0)!
 392         if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 393         {
 394             ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
 395                           on ? style | BS_DEFPUSHBUTTON
 396                              : style & ~BS_DEFPUSHBUTTON,
 397                           1L /* redraw */);
 398         }
 399         else // owner drawn
 400         {
 401             // redraw the button - it will notice itself that it's
 402             // [not] the default one [any longer]
 403             btn->Refresh();
 404         }
 405     }
 406     //else: already has correct style
 407 }
 408
 409 // ----------------------------------------------------------------------------
 410 // helpers
 411 // ----------------------------------------------------------------------------
 412
 413 bool wxButton::SendClickEvent()
 414 {
 415     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
 416     event.SetEventObject(this);
 417
 418     return ProcessCommand(event);
 419 }
 420
 421 void wxButton::Command(wxCommandEvent & event)
 422 {
 423     ProcessCommand(event);
 424 }
 425
 426 // ----------------------------------------------------------------------------
 427 // event/message handlers
 428 // ----------------------------------------------------------------------------
 429
 430 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 431 {
 432     bool processed = false;
 433     switch ( param )
 434     {
 435         // NOTE: Apparently older versions (NT 4?) of the common controls send
 436         //       BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
 437         //       buttons, so in order to send two EVT_BUTTON events we should
 438         //       catch both types.  Currently (Feb 2003) up-to-date versions of
 439         //       win98, win2k and winXP all send two BN_CLICKED messages for
 440         //       all button types, so we don't catch BN_DOUBLECLICKED anymore
 441         //       in order to not get 3 EVT_BUTTON events.  If this is a problem
 442         //       then we need to figure out which version of the comctl32 changed
 443         //       this behaviour and test for it.
 444
 445         case 1:                     // message came from an accelerator
 446         case BN_CLICKED:            // normal buttons send this
 447             processed = SendClickEvent();
 448             break;
 449     }
 450
 451     return processed;
 452 }
 453
 454 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 455 {
 456     // when we receive focus, we want to temporarily become the default button in
 457     // our parent panel so that pressing "Enter" would activate us -- and when
 458     // losing it we should restore the previous default button as well
 459     if ( nMsg == WM_SETFOCUS )
 460     {
 461         SetTmpDefault();
 462
 463         // let the default processing take place too
 464     }
 465     else if ( nMsg == WM_KILLFOCUS )
 466     {
 467         UnsetTmpDefault();
 468     }
 469     else if ( nMsg == WM_LBUTTONDBLCLK )
 470     {
 471         // emulate a click event to force an owner-drawn button to change its
 472         // appearance - without this, it won't do it
 473         (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
 474
 475         // and continue with processing the message normally as well
 476     }
 477
 478     // let the base class do all real processing
 479     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 480 }
 481
 482 // ----------------------------------------------------------------------------
 483 // owner-drawn buttons support
 484 // ----------------------------------------------------------------------------
 485
 486 #ifdef __WIN32__
 487
 488 // drawing helpers
 489
 490 static void DrawButtonText(HDC hdc,
 491                            RECT *pRect,
 492                            const wxString& text,
 493                            COLORREF col)
 494 {
 495     COLORREF colOld = SetTextColor(hdc, col);
 496     int modeOld = SetBkMode(hdc, TRANSPARENT);
 497
 498     // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
 499     ::DrawText(hdc, text, text.length(), pRect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 500
 501     SetBkMode(hdc, modeOld);
 502     SetTextColor(hdc, colOld);
 503 }
 504
 505 static void DrawRect(HDC hdc, const RECT& r)
 506 {
 507     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 508     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
 509     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
 510     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 511 }
 512
 513 void wxButton::MakeOwnerDrawn()
 514 {
 515     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
 516     if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 517     {
 518         // make it so
 519         style |= BS_OWNERDRAW;
 520         SetWindowLong(GetHwnd(), GWL_STYLE, style);
 521     }
 522 }
 523
 524 bool wxButton::SetBackgroundColour(const wxColour &colour)
 525 {
 526     if ( !wxControl::SetBackgroundColour(colour) )
 527     {
 528         // nothing to do
 529         return false;
 530     }
 531
 532     MakeOwnerDrawn();
 533
 534     Refresh();
 535
 536     return true;
 537 }
 538
 539 bool wxButton::SetForegroundColour(const wxColour &colour)
 540 {
 541     if ( !wxControl::SetForegroundColour(colour) )
 542     {
 543         // nothing to do
 544         return false;
 545     }
 546
 547     MakeOwnerDrawn();
 548
 549     Refresh();
 550
 551     return true;
 552 }
 553
 554 /*
 555    The button frame looks like this normally:
 556
 557    WWWWWWWWWWWWWWWWWWB
 558    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
 559    WH               GB  H = light grey  (LIGHT)
 560    WH               GB  G = dark grey   (SHADOW)
 561    WH               GB  B = black       (DKSHADOW)
 562    WH               GB
 563    WGGGGGGGGGGGGGGGGGB
 564    BBBBBBBBBBBBBBBBBBB
 565
 566    When the button is selected, the button becomes like this (the total button
 567    size doesn't change):
 568
 569    BBBBBBBBBBBBBBBBBBB
 570    BWWWWWWWWWWWWWWWWBB
 571    BWHHHHHHHHHHHHHHGBB
 572    BWH             GBB
 573    BWH             GBB
 574    BWGGGGGGGGGGGGGGGBB
 575    BBBBBBBBBBBBBBBBBBB
 576    BBBBBBBBBBBBBBBBBBB
 577
 578    When the button is pushed (while selected) it is like:
 579
 580    BBBBBBBBBBBBBBBBBBB
 581    BGGGGGGGGGGGGGGGGGB
 582    BG               GB
 583    BG               GB
 584    BG               GB
 585    BG               GB
 586    BGGGGGGGGGGGGGGGGGB
 587    BBBBBBBBBBBBBBBBBBB
 588 */
 589
 590 static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
 591                             bool selected, bool pushed)
 592 {
 593     RECT r;
 594     CopyRect(&r, &rectBtn);
 595
 596     HPEN hpenBlack   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
 597          hpenGrey    = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
 598          hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
 599          hpenWhite   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
 600
 601     HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
 602
 603     r.right--;
 604     r.bottom--;
 605
 606     if ( pushed )
 607     {
 608         DrawRect(hdc, r);
 609
 610         (void)SelectObject(hdc, hpenGrey);
 611         ::InflateRect(&r, -1, -1);
 612
 613         DrawRect(hdc, r);
 614     }
 615     else // !pushed
 616     {
 617         if ( selected )
 618         {
 619             DrawRect(hdc, r);
 620
 621             ::InflateRect(&r, -1, -1);
 622         }
 623
 624         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
 625         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
 626
 627         (void)SelectObject(hdc, hpenWhite);
 628         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
 629         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 630
 631         (void)SelectObject(hdc, hpenLightGr);
 632         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
 633         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
 634
 635         (void)SelectObject(hdc, hpenGrey);
 636         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
 637         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
 638     }
 639
 640     (void)SelectObject(hdc, hpenOld);
 641     DeleteObject(hpenWhite);
 642     DeleteObject(hpenLightGr);
 643     DeleteObject(hpenGrey);
 644     DeleteObject(hpenBlack);
 645 }
 646
 647 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 648 {
 649     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
 650
 651     RECT rectBtn;
 652     CopyRect(&rectBtn, &lpDIS->rcItem);
 653
 654     COLORREF colBg = wxColourToRGB(GetBackgroundColour()),
 655              colFg = wxColourToRGB(GetForegroundColour());
 656
 657     HDC hdc = lpDIS->hDC;
 658     UINT state = lpDIS->itemState;
 659
 660     // first, draw the background
 661     HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
 662
 663     FillRect(hdc, &rectBtn, hbrushBackground);
 664
 665     // draw the border for the current state
 666     bool selected = (state & ODS_SELECTED) != 0;
 667     if ( !selected )
 668     {
 669         wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
 670         if ( panel )
 671         {
 672             selected = panel->GetDefaultItem() == this;
 673         }
 674     }
 675     bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
 676
 677     DrawButtonFrame(hdc, rectBtn, selected, pushed);
 678
 679     // draw the focus rect if needed
 680     if ( state & ODS_FOCUS )
 681     {
 682         RECT rectFocus;
 683         CopyRect(&rectFocus, &rectBtn);
 684
 685         // I don't know where does this constant come from, but this is how
 686         // Windows draws them
 687         InflateRect(&rectFocus, -4, -4);
 688
 689         DrawFocusRect(hdc, &rectFocus);
 690     }
 691
 692     if ( pushed )
 693     {
 694         // the label is shifted by 1 pixel to create "pushed" effect
 695         OffsetRect(&rectBtn, 1, 1);
 696     }
 697
 698     DrawButtonText(hdc, &rectBtn, GetLabel(),
 699                    state & ODS_DISABLED ? GetSysColor(COLOR_GRAYTEXT)
 700                                         : colFg);
 701
 702     ::DeleteObject(hbrushBackground);
 703
 704     return true;
 705 }
 706
 707 #endif // __WIN32__
 708
 709 #endif // wxUSE_BUTTON
 710