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     if ( text.find(_T('\n')) != wxString::npos )
 501     {
 502         // draw multiline label
 503
 504         // first we need to compute its bounding rect
 505         RECT rc;
 506         ::CopyRect(&rc, pRect);
 507         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER | DT_CALCRECT);
 508
 509         // now center this rect inside the entire button area
 510         const LONG w = rc.right - rc.left;
 511         const LONG h = rc.bottom - rc.top;
 512         rc.left = (pRect->right - pRect->left)/2 - w/2;
 513         rc.right = rc.left+w;
 514         rc.top = (pRect->bottom - pRect->top)/2 - h/2;
 515         rc.bottom = rc.top+h;
 516
 517         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER);
 518     }
 519     else // single line label
 520     {
 521         // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
 522         ::DrawText(hdc, text, text.length(), pRect,
 523                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 524     }
 525
 526     SetBkMode(hdc, modeOld);
 527     SetTextColor(hdc, colOld);
 528 }
 529
 530 static void DrawRect(HDC hdc, const RECT& r)
 531 {
 532     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 533     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
 534     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
 535     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 536 }
 537
 538 void wxButton::MakeOwnerDrawn()
 539 {
 540     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
 541     if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 542     {
 543         // make it so
 544         style |= BS_OWNERDRAW;
 545         SetWindowLong(GetHwnd(), GWL_STYLE, style);
 546     }
 547 }
 548
 549 bool wxButton::SetBackgroundColour(const wxColour &colour)
 550 {
 551     if ( !wxControl::SetBackgroundColour(colour) )
 552     {
 553         // nothing to do
 554         return false;
 555     }
 556
 557     MakeOwnerDrawn();
 558
 559     Refresh();
 560
 561     return true;
 562 }
 563
 564 bool wxButton::SetForegroundColour(const wxColour &colour)
 565 {
 566     if ( !wxControl::SetForegroundColour(colour) )
 567     {
 568         // nothing to do
 569         return false;
 570     }
 571
 572     MakeOwnerDrawn();
 573
 574     Refresh();
 575
 576     return true;
 577 }
 578
 579 /*
 580    The button frame looks like this normally:
 581
 582    WWWWWWWWWWWWWWWWWWB
 583    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
 584    WH               GB  H = light grey  (LIGHT)
 585    WH               GB  G = dark grey   (SHADOW)
 586    WH               GB  B = black       (DKSHADOW)
 587    WH               GB
 588    WGGGGGGGGGGGGGGGGGB
 589    BBBBBBBBBBBBBBBBBBB
 590
 591    When the button is selected, the button becomes like this (the total button
 592    size doesn't change):
 593
 594    BBBBBBBBBBBBBBBBBBB
 595    BWWWWWWWWWWWWWWWWBB
 596    BWHHHHHHHHHHHHHHGBB
 597    BWH             GBB
 598    BWH             GBB
 599    BWGGGGGGGGGGGGGGGBB
 600    BBBBBBBBBBBBBBBBBBB
 601    BBBBBBBBBBBBBBBBBBB
 602
 603    When the button is pushed (while selected) it is like:
 604
 605    BBBBBBBBBBBBBBBBBBB
 606    BGGGGGGGGGGGGGGGGGB
 607    BG               GB
 608    BG               GB
 609    BG               GB
 610    BG               GB
 611    BGGGGGGGGGGGGGGGGGB
 612    BBBBBBBBBBBBBBBBBBB
 613 */
 614
 615 static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
 616                             bool selected, bool pushed)
 617 {
 618     RECT r;
 619     CopyRect(&r, &rectBtn);
 620
 621     HPEN hpenBlack   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
 622          hpenGrey    = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
 623          hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
 624          hpenWhite   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
 625
 626     HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
 627
 628     r.right--;
 629     r.bottom--;
 630
 631     if ( pushed )
 632     {
 633         DrawRect(hdc, r);
 634
 635         (void)SelectObject(hdc, hpenGrey);
 636         ::InflateRect(&r, -1, -1);
 637
 638         DrawRect(hdc, r);
 639     }
 640     else // !pushed
 641     {
 642         if ( selected )
 643         {
 644             DrawRect(hdc, r);
 645
 646             ::InflateRect(&r, -1, -1);
 647         }
 648
 649         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
 650         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
 651
 652         (void)SelectObject(hdc, hpenWhite);
 653         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
 654         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 655
 656         (void)SelectObject(hdc, hpenLightGr);
 657         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
 658         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
 659
 660         (void)SelectObject(hdc, hpenGrey);
 661         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
 662         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
 663     }
 664
 665     (void)SelectObject(hdc, hpenOld);
 666     DeleteObject(hpenWhite);
 667     DeleteObject(hpenLightGr);
 668     DeleteObject(hpenGrey);
 669     DeleteObject(hpenBlack);
 670 }
 671
 672 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 673 {
 674     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
 675
 676     RECT rectBtn;
 677     CopyRect(&rectBtn, &lpDIS->rcItem);
 678
 679     COLORREF colBg = wxColourToRGB(GetBackgroundColour()),
 680              colFg = wxColourToRGB(GetForegroundColour());
 681
 682     HDC hdc = lpDIS->hDC;
 683     UINT state = lpDIS->itemState;
 684
 685     // first, draw the background
 686     HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
 687
 688     FillRect(hdc, &rectBtn, hbrushBackground);
 689
 690     // draw the border for the current state
 691     bool selected = (state & ODS_SELECTED) != 0;
 692     if ( !selected )
 693     {
 694         wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
 695         if ( panel )
 696         {
 697             selected = panel->GetDefaultItem() == this;
 698         }
 699     }
 700     bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
 701
 702     DrawButtonFrame(hdc, rectBtn, selected, pushed);
 703
 704     // draw the focus rect if needed
 705     if ( state & ODS_FOCUS )
 706     {
 707         RECT rectFocus;
 708         CopyRect(&rectFocus, &rectBtn);
 709
 710         // I don't know where does this constant come from, but this is how
 711         // Windows draws them
 712         InflateRect(&rectFocus, -4, -4);
 713
 714         DrawFocusRect(hdc, &rectFocus);
 715     }
 716
 717     if ( pushed )
 718     {
 719         // the label is shifted by 1 pixel to create "pushed" effect
 720         OffsetRect(&rectBtn, 1, 1);
 721     }
 722
 723     DrawButtonText(hdc, &rectBtn, GetLabel(),
 724                    state & ODS_DISABLED ? GetSysColor(COLOR_GRAYTEXT)
 725                                         : colFg);
 726
 727     ::DeleteObject(hbrushBackground);
 728
 729     return true;
 730 }
 731
 732 #endif // __WIN32__
 733
 734 #endif // wxUSE_BUTTON
 735