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