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