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