src/msw/button.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/button.cpp
   3 // Purpose:     wxButton
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_BUTTON
  28
  29 #include "wx/button.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/app.h"
  33     #include "wx/brush.h"
  34     #include "wx/panel.h"
  35     #include "wx/bmpbuttn.h"
  36     #include "wx/settings.h"
  37     #include "wx/dcscreen.h"
  38     #include "wx/dcclient.h"
  39 #endif
  40
  41 #include "wx/stockitem.h"
  42 #include "wx/tokenzr.h"
  43 #include "wx/msw/private.h"
  44
  45 // ----------------------------------------------------------------------------
  46 // macros
  47 // ----------------------------------------------------------------------------
  48
  49 #if wxUSE_EXTENDED_RTTI
  50
  51 WX_DEFINE_FLAGS( wxButtonStyle )
  52
  53 wxBEGIN_FLAGS( wxButtonStyle )
  54     // new style border flags, we put them first to
  55     // use them for streaming out
  56     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  57     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  58     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  59     wxFLAGS_MEMBER(wxBORDER_RAISED)
  60     wxFLAGS_MEMBER(wxBORDER_STATIC)
  61     wxFLAGS_MEMBER(wxBORDER_NONE)
  62
  63     // old style border flags
  64     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  65     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  66     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  67     wxFLAGS_MEMBER(wxRAISED_BORDER)
  68     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  69     wxFLAGS_MEMBER(wxBORDER)
  70
  71     // standard window styles
  72     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  73     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  74     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  75     wxFLAGS_MEMBER(wxWANTS_CHARS)
  76     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  77     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  78     wxFLAGS_MEMBER(wxVSCROLL)
  79     wxFLAGS_MEMBER(wxHSCROLL)
  80
  81     wxFLAGS_MEMBER(wxBU_LEFT)
  82     wxFLAGS_MEMBER(wxBU_RIGHT)
  83     wxFLAGS_MEMBER(wxBU_TOP)
  84     wxFLAGS_MEMBER(wxBU_BOTTOM)
  85     wxFLAGS_MEMBER(wxBU_EXACTFIT)
  86 wxEND_FLAGS( wxButtonStyle )
  87
  88 IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
  89
  90 wxBEGIN_PROPERTIES_TABLE(wxButton)
  91     wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
  92
  93     wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  94     wxPROPERTY( Label, wxString , SetLabel, GetLabel, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
  95
  96     wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
  97
  98 wxEND_PROPERTIES_TABLE()
  99
 100 wxBEGIN_HANDLERS_TABLE(wxButton)
 101 wxEND_HANDLERS_TABLE()
 102
 103 wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle  )
 104
 105
 106 #else
 107 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
 108 #endif
 109
 110 // this macro tries to adjust the default button height to a reasonable value
 111 // using the char height as the base
 112 #define BUTTON_HEIGHT_FROM_CHAR_HEIGHT(cy) (11*EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)/10)
 113
 114 // ============================================================================
 115 // implementation
 116 // ============================================================================
 117
 118 // ----------------------------------------------------------------------------
 119 // creation/destruction
 120 // ----------------------------------------------------------------------------
 121
 122 bool wxButton::Create(wxWindow *parent,
 123                       wxWindowID id,
 124                       const wxString& lbl,
 125                       const wxPoint& pos,
 126                       const wxSize& size,
 127                       long style,
 128                       const wxValidator& validator,
 129                       const wxString& name)
 130 {
 131     wxString label(lbl);
 132     if (label.empty() && wxIsStockID(id))
 133     {
 134         // On Windows, some buttons aren't supposed to have
 135         // mnemonics, so strip them out.
 136
 137         label = wxGetStockLabel(id
 138 #if defined(__WXMSW__) || defined(__WXWINCE__)
 139                                         , ( id != wxID_OK &&
 140                                             id != wxID_CANCEL &&
 141                                             id != wxID_CLOSE )
 142 #endif
 143                                 );
 144     }
 145
 146     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 147         return false;
 148
 149     WXDWORD exstyle;
 150     WXDWORD msStyle = MSWGetStyle(style, &exstyle);
 151
 152 #ifdef __WIN32__
 153     // if the label contains several lines we must explicitly tell the button
 154     // about it or it wouldn't draw it correctly ("\n"s would just appear as
 155     // black boxes)
 156     //
 157     // NB: we do it here and not in MSWGetStyle() because we need the label
 158     //     value and m_label is not set yet when MSWGetStyle() is called;
 159     //     besides changing BS_MULTILINE during run-time is pointless anyhow
 160     if ( label.find(_T('\n')) != wxString::npos )
 161     {
 162         msStyle |= BS_MULTILINE;
 163     }
 164 #endif // __WIN32__
 165
 166     return MSWCreateControl(_T("BUTTON"), msStyle, pos, size, label, exstyle);
 167 }
 168
 169 wxButton::~wxButton()
 170 {
 171 }
 172
 173 // ----------------------------------------------------------------------------
 174 // flags
 175 // ----------------------------------------------------------------------------
 176
 177 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
 178 {
 179     // buttons never have an external border, they draw their own one
 180     WXDWORD msStyle = wxControl::MSWGetStyle
 181                       (
 182                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 183                       );
 184
 185     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
 186     // each other in any resizeable dialog which has more than one button in
 187     // the bottom
 188     msStyle |= WS_CLIPSIBLINGS;
 189
 190 #ifdef __WIN32__
 191     // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
 192     // and wxBU_RIGHT to get BS_CENTER!
 193     if ( style & wxBU_LEFT )
 194         msStyle |= BS_LEFT;
 195     if ( style & wxBU_RIGHT )
 196         msStyle |= BS_RIGHT;
 197     if ( style & wxBU_TOP )
 198         msStyle |= BS_TOP;
 199     if ( style & wxBU_BOTTOM )
 200         msStyle |= BS_BOTTOM;
 201 #ifndef __WXWINCE__
 202     // flat 2d buttons
 203     if ( style & wxNO_BORDER )
 204         msStyle |= BS_FLAT;
 205 #endif // __WXWINCE__
 206 #endif // __WIN32__
 207
 208     return msStyle;
 209 }
 210
 211 // ----------------------------------------------------------------------------
 212 // size management including autosizing
 213 // ----------------------------------------------------------------------------
 214
 215 wxSize wxButton::DoGetBestSize() const
 216 {
 217     wxClientDC dc(wx_const_cast(wxButton *, this));
 218     dc.SetFont(GetFont());
 219
 220     wxCoord wBtn,
 221             hBtn;
 222     dc.GetMultiLineTextExtent(wxStripMenuCodes(GetLabel()), &wBtn, &hBtn);
 223
 224     // add a margin -- the button is wider than just its label
 225     wBtn += 3*GetCharWidth();
 226     hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hBtn);
 227
 228     // all buttons have at least the standard size unless the user explicitly
 229     // wants them to be of smaller size and used wxBU_EXACTFIT style when
 230     // creating the button
 231     if ( !HasFlag(wxBU_EXACTFIT) )
 232     {
 233         wxSize sz = GetDefaultSize();
 234         if (wBtn > sz.x)
 235             sz.x = wBtn;
 236         if (hBtn > sz.y)
 237             sz.y = hBtn;
 238
 239         return sz;
 240     }
 241
 242     wxSize best(wBtn, hBtn);
 243     CacheBestSize(best);
 244     return best;
 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     if ( text.find(_T('\n')) != wxString::npos )
 499     {
 500         // draw multiline label
 501
 502         // first we need to compute its bounding rect
 503         RECT rc;
 504         ::CopyRect(&rc, pRect);
 505         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER | DT_CALCRECT);
 506
 507         // now center this rect inside the entire button area
 508         const LONG w = rc.right - rc.left;
 509         const LONG h = rc.bottom - rc.top;
 510         rc.left = (pRect->right - pRect->left)/2 - w/2;
 511         rc.right = rc.left+w;
 512         rc.top = (pRect->bottom - pRect->top)/2 - h/2;
 513         rc.bottom = rc.top+h;
 514
 515         ::DrawText(hdc, text, text.length(), &rc, DT_CENTER);
 516     }
 517     else // single line label
 518     {
 519         // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
 520         ::DrawText(hdc, text, text.length(), pRect,
 521                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 522     }
 523
 524     SetBkMode(hdc, modeOld);
 525     SetTextColor(hdc, colOld);
 526 }
 527
 528 static void DrawRect(HDC hdc, const RECT& r)
 529 {
 530     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 531     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
 532     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
 533     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 534 }
 535
 536 void wxButton::MakeOwnerDrawn()
 537 {
 538     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
 539     if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 540     {
 541         // make it so
 542         style |= BS_OWNERDRAW;
 543         SetWindowLong(GetHwnd(), GWL_STYLE, style);
 544     }
 545 }
 546
 547 bool wxButton::SetBackgroundColour(const wxColour &colour)
 548 {
 549     if ( !wxControl::SetBackgroundColour(colour) )
 550     {
 551         // nothing to do
 552         return false;
 553     }
 554
 555     MakeOwnerDrawn();
 556
 557     Refresh();
 558
 559     return true;
 560 }
 561
 562 bool wxButton::SetForegroundColour(const wxColour &colour)
 563 {
 564     if ( !wxControl::SetForegroundColour(colour) )
 565     {
 566         // nothing to do
 567         return false;
 568     }
 569
 570     MakeOwnerDrawn();
 571
 572     Refresh();
 573
 574     return true;
 575 }
 576
 577 /*
 578    The button frame looks like this normally:
 579
 580    WWWWWWWWWWWWWWWWWWB
 581    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
 582    WH               GB  H = light grey  (LIGHT)
 583    WH               GB  G = dark grey   (SHADOW)
 584    WH               GB  B = black       (DKSHADOW)
 585    WH               GB
 586    WGGGGGGGGGGGGGGGGGB
 587    BBBBBBBBBBBBBBBBBBB
 588
 589    When the button is selected, the button becomes like this (the total button
 590    size doesn't change):
 591
 592    BBBBBBBBBBBBBBBBBBB
 593    BWWWWWWWWWWWWWWWWBB
 594    BWHHHHHHHHHHHHHHGBB
 595    BWH             GBB
 596    BWH             GBB
 597    BWGGGGGGGGGGGGGGGBB
 598    BBBBBBBBBBBBBBBBBBB
 599    BBBBBBBBBBBBBBBBBBB
 600
 601    When the button is pushed (while selected) it is like:
 602
 603    BBBBBBBBBBBBBBBBBBB
 604    BGGGGGGGGGGGGGGGGGB
 605    BG               GB
 606    BG               GB
 607    BG               GB
 608    BG               GB
 609    BGGGGGGGGGGGGGGGGGB
 610    BBBBBBBBBBBBBBBBBBB
 611 */
 612
 613 static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
 614                             bool selected, bool pushed)
 615 {
 616     RECT r;
 617     CopyRect(&r, &rectBtn);
 618
 619     HPEN hpenBlack   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
 620          hpenGrey    = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
 621          hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
 622          hpenWhite   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
 623
 624     HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
 625
 626     r.right--;
 627     r.bottom--;
 628
 629     if ( pushed )
 630     {
 631         DrawRect(hdc, r);
 632
 633         (void)SelectObject(hdc, hpenGrey);
 634         ::InflateRect(&r, -1, -1);
 635
 636         DrawRect(hdc, r);
 637     }
 638     else // !pushed
 639     {
 640         if ( selected )
 641         {
 642             DrawRect(hdc, r);
 643
 644             ::InflateRect(&r, -1, -1);
 645         }
 646
 647         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
 648         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
 649
 650         (void)SelectObject(hdc, hpenWhite);
 651         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
 652         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 653
 654         (void)SelectObject(hdc, hpenLightGr);
 655         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
 656         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
 657
 658         (void)SelectObject(hdc, hpenGrey);
 659         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
 660         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
 661     }
 662
 663     (void)SelectObject(hdc, hpenOld);
 664     DeleteObject(hpenWhite);
 665     DeleteObject(hpenLightGr);
 666     DeleteObject(hpenGrey);
 667     DeleteObject(hpenBlack);
 668 }
 669
 670 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 671 {
 672     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
 673
 674     RECT rectBtn;
 675     CopyRect(&rectBtn, &lpDIS->rcItem);
 676
 677     COLORREF colBg = wxColourToRGB(GetBackgroundColour()),
 678              colFg = wxColourToRGB(GetForegroundColour());
 679
 680     HDC hdc = lpDIS->hDC;
 681     UINT state = lpDIS->itemState;
 682
 683     // first, draw the background
 684     HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
 685
 686     FillRect(hdc, &rectBtn, hbrushBackground);
 687
 688     // draw the border for the current state
 689     bool selected = (state & ODS_SELECTED) != 0;
 690     if ( !selected )
 691     {
 692         wxPanel *panel = wxDynamicCast(GetParent(), wxPanel);
 693         if ( panel )
 694         {
 695             selected = panel->GetDefaultItem() == this;
 696         }
 697     }
 698     bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
 699
 700     DrawButtonFrame(hdc, rectBtn, selected, pushed);
 701
 702     // draw the focus rect if needed
 703     if ( state & ODS_FOCUS )
 704     {
 705         RECT rectFocus;
 706         CopyRect(&rectFocus, &rectBtn);
 707
 708         // I don't know where does this constant come from, but this is how
 709         // Windows draws them
 710         InflateRect(&rectFocus, -4, -4);
 711
 712         DrawFocusRect(hdc, &rectFocus);
 713     }
 714
 715     if ( pushed )
 716     {
 717         // the label is shifted by 1 pixel to create "pushed" effect
 718         OffsetRect(&rectBtn, 1, 1);
 719     }
 720
 721     DrawButtonText(hdc, &rectBtn, GetLabel(),
 722                    state & ODS_DISABLED ? GetSysColor(COLOR_GRAYTEXT)
 723                                         : colFg);
 724
 725     ::DeleteObject(hbrushBackground);
 726
 727     return true;
 728 }
 729
 730 #endif // __WIN32__
 731
 732 #endif // wxUSE_BUTTON