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