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