src/msw/button.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/button.cpp
   3 // Purpose:     wxButton
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_BUTTON
  28
  29 #include "wx/button.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/app.h"
  33     #include "wx/brush.h"
  34     #include "wx/panel.h"
  35     #include "wx/bmpbuttn.h"
  36     #include "wx/settings.h"
  37     #include "wx/dcscreen.h"
  38     #include "wx/dcclient.h"
  39     #include "wx/toplevel.h"
  40     #include "wx/msw/wrapcctl.h"
  41     #include "wx/msw/private.h"
  42     #include "wx/msw/missing.h"
  43 #endif
  44
  45 #include "wx/imaglist.h"
  46 #include "wx/stockitem.h"
  47 #include "wx/msw/private/button.h"
  48 #include "wx/msw/private/dc.h"
  49 #include "wx/private/window.h"
  50
  51 using namespace wxMSWImpl;
  52
  53 #if wxUSE_UXTHEME
  54     #include "wx/msw/uxtheme.h"
  55
  56     // no need to include tmschema.h
  57     #ifndef BP_PUSHBUTTON
  58         #define BP_PUSHBUTTON 1
  59
  60         #define PBS_NORMAL    1
  61         #define PBS_HOT       2
  62         #define PBS_PRESSED   3
  63         #define PBS_DISABLED  4
  64         #define PBS_DEFAULTED 5
  65
  66         #define TMT_CONTENTMARGINS 3602
  67     #endif
  68
  69     // provide the necessary declarations ourselves if they're missing from
  70     // headers
  71     #ifndef BCM_SETIMAGELIST
  72         #define BCM_SETIMAGELIST    0x1602
  73         #define BCM_SETTEXTMARGIN   0x1604
  74
  75         enum
  76         {
  77             BUTTON_IMAGELIST_ALIGN_LEFT,
  78             BUTTON_IMAGELIST_ALIGN_RIGHT,
  79             BUTTON_IMAGELIST_ALIGN_TOP,
  80             BUTTON_IMAGELIST_ALIGN_BOTTOM
  81         };
  82
  83         struct BUTTON_IMAGELIST
  84         {
  85             HIMAGELIST himl;
  86             RECT margin;
  87             UINT uAlign;
  88         };
  89     #endif
  90 #endif // wxUSE_UXTHEME
  91
  92 #ifndef WM_THEMECHANGED
  93     #define WM_THEMECHANGED     0x031A
  94 #endif
  95
  96 #ifndef ODS_NOACCEL
  97     #define ODS_NOACCEL         0x0100
  98 #endif
  99
 100 #ifndef ODS_NOFOCUSRECT
 101     #define ODS_NOFOCUSRECT     0x0200
 102 #endif
 103
 104 #ifndef DT_HIDEPREFIX
 105     #define DT_HIDEPREFIX       0x00100000
 106 #endif
 107
 108 // set the value for BCM_SETSHIELD (for the UAC shield) if it's not defined in
 109 // the header
 110 #ifndef BCM_SETSHIELD
 111     #define BCM_SETSHIELD       0x160c
 112 #endif
 113
 114 // ----------------------------------------------------------------------------
 115 // button image data
 116 // ----------------------------------------------------------------------------
 117
 118 // we use different data classes for owner drawn buttons and for themed XP ones
 119
 120 class wxButtonImageData
 121 {
 122 public:
 123     wxButtonImageData() { }
 124     virtual ~wxButtonImageData() { }
 125
 126     virtual wxBitmap GetBitmap(wxButton::State which) const = 0;
 127     virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which) = 0;
 128
 129     virtual wxSize GetBitmapMargins() const = 0;
 130     virtual void SetBitmapMargins(wxCoord x, wxCoord y) = 0;
 131
 132     virtual wxDirection GetBitmapPosition() const = 0;
 133     virtual void SetBitmapPosition(wxDirection dir) = 0;
 134
 135 private:
 136     wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
 137 };
 138
 139 namespace
 140 {
 141
 142 // the gap between button edge and the interior area used by Windows for the
 143 // standard buttons
 144 const int OD_BUTTON_MARGIN = 4;
 145
 146 class wxODButtonImageData : public wxButtonImageData
 147 {
 148 public:
 149     wxODButtonImageData(wxButton *btn, const wxBitmap& bitmap)
 150     {
 151         SetBitmap(bitmap, wxButton::State_Normal);
 152
 153         m_dir = wxLEFT;
 154
 155         // we use margins when we have both bitmap and text, but when we have
 156         // only the bitmap it should take up the entire button area
 157         if ( btn->ShowsLabel() )
 158         {
 159             m_margin.x = btn->GetCharWidth();
 160             m_margin.y = btn->GetCharHeight() / 2;
 161         }
 162     }
 163
 164     virtual wxBitmap GetBitmap(wxButton::State which) const
 165     {
 166         return m_bitmaps[which];
 167     }
 168
 169     virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
 170     {
 171         m_bitmaps[which] = bitmap;
 172     }
 173
 174     virtual wxSize GetBitmapMargins() const
 175     {
 176         return m_margin;
 177     }
 178
 179     virtual void SetBitmapMargins(wxCoord x, wxCoord y)
 180     {
 181         m_margin = wxSize(x, y);
 182     }
 183
 184     virtual wxDirection GetBitmapPosition() const
 185     {
 186         return m_dir;
 187     }
 188
 189     virtual void SetBitmapPosition(wxDirection dir)
 190     {
 191         m_dir = dir;
 192     }
 193
 194 private:
 195     // just store the values passed to us to be able to retrieve them later
 196     // from the drawing code
 197     wxBitmap m_bitmaps[wxButton::State_Max];
 198     wxSize m_margin;
 199     wxDirection m_dir;
 200
 201     wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
 202 };
 203
 204 #if wxUSE_UXTHEME
 205
 206 // somehow the margin is one pixel greater than the value returned by
 207 // GetThemeMargins() call
 208 const int XP_BUTTON_EXTRA_MARGIN = 1;
 209
 210 class wxXPButtonImageData : public wxButtonImageData
 211 {
 212 public:
 213     // we must be constructed with the size of our images as we need to create
 214     // the image list
 215     wxXPButtonImageData(wxButton *btn, const wxBitmap& bitmap)
 216         : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
 217                 wxButton::State_Max),
 218           m_hwndBtn(GetHwndOf(btn))
 219     {
 220         // initialize all bitmaps to normal state
 221         for ( int n = 0; n < wxButton::State_Max; n++ )
 222         {
 223             m_iml.Add(bitmap);
 224         }
 225
 226         m_data.himl = GetHimagelistOf(&m_iml);
 227
 228         // no margins by default
 229         m_data.margin.left =
 230         m_data.margin.right =
 231         m_data.margin.top =
 232         m_data.margin.bottom = 0;
 233
 234         // use default alignment
 235         m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
 236
 237         UpdateImageInfo();
 238     }
 239
 240     virtual wxBitmap GetBitmap(wxButton::State which) const
 241     {
 242         return m_iml.GetBitmap(which);
 243     }
 244
 245     virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
 246     {
 247         m_iml.Replace(which, bitmap);
 248
 249         UpdateImageInfo();
 250     }
 251
 252     virtual wxSize GetBitmapMargins() const
 253     {
 254         return wxSize(m_data.margin.left, m_data.margin.top);
 255     }
 256
 257     virtual void SetBitmapMargins(wxCoord x, wxCoord y)
 258     {
 259         RECT& margin = m_data.margin;
 260         margin.left =
 261         margin.right = x;
 262         margin.top =
 263         margin.bottom = y;
 264
 265         if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
 266         {
 267             wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
 268         }
 269     }
 270
 271     virtual wxDirection GetBitmapPosition() const
 272     {
 273         switch ( m_data.uAlign )
 274         {
 275             default:
 276                 wxFAIL_MSG( "invalid image alignment" );
 277                 // fall through
 278
 279             case BUTTON_IMAGELIST_ALIGN_LEFT:
 280                 return wxLEFT;
 281
 282             case BUTTON_IMAGELIST_ALIGN_RIGHT:
 283                 return wxRIGHT;
 284
 285             case BUTTON_IMAGELIST_ALIGN_TOP:
 286                 return wxTOP;
 287
 288             case BUTTON_IMAGELIST_ALIGN_BOTTOM:
 289                 return wxBOTTOM;
 290         }
 291     }
 292
 293     virtual void SetBitmapPosition(wxDirection dir)
 294     {
 295         UINT alignNew;
 296         switch ( dir )
 297         {
 298             default:
 299                 wxFAIL_MSG( "invalid direction" );
 300                 // fall through
 301
 302             case wxLEFT:
 303                 alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
 304                 break;
 305
 306             case wxRIGHT:
 307                 alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
 308                 break;
 309
 310             case wxTOP:
 311                 alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
 312                 break;
 313
 314             case wxBOTTOM:
 315                 alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
 316                 break;
 317         }
 318
 319         if ( alignNew != m_data.uAlign )
 320         {
 321             m_data.uAlign = alignNew;
 322             UpdateImageInfo();
 323         }
 324     }
 325
 326 private:
 327     void UpdateImageInfo()
 328     {
 329         if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
 330         {
 331             wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
 332         }
 333     }
 334
 335     // we store image list separately to be able to use convenient wxImageList
 336     // methods instead of working with raw HIMAGELIST
 337     wxImageList m_iml;
 338
 339     // store the rest of the data in BCM_SETIMAGELIST-friendly form
 340     BUTTON_IMAGELIST m_data;
 341
 342     // the button we're associated with
 343     const HWND m_hwndBtn;
 344
 345
 346     wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
 347 };
 348
 349 #endif // wxUSE_UXTHEME
 350
 351 } // anonymous namespace
 352
 353 // ----------------------------------------------------------------------------
 354 // macros
 355 // ----------------------------------------------------------------------------
 356
 357 // ============================================================================
 358 // implementation
 359 // ============================================================================
 360
 361 // ----------------------------------------------------------------------------
 362 // helper functions from wx/msw/private/button.h
 363 // ----------------------------------------------------------------------------
 364
 365 void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
 366 {
 367     // update BS_MULTILINE style depending on the new label (resetting it
 368     // doesn't seem to do anything very useful but it shouldn't hurt and we do
 369     // have to set it whenever the label becomes multi line as otherwise it
 370     // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
 371     // the control unless it already has new lines in its label)
 372     long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
 373          styleNew;
 374     if ( label.find(wxT('\n')) != wxString::npos )
 375         styleNew = styleOld | BS_MULTILINE;
 376     else
 377         styleNew = styleOld & ~BS_MULTILINE;
 378
 379     if ( styleNew != styleOld )
 380         ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
 381 }
 382
 383 wxSize wxMSWButton::GetFittingSize(wxWindow *win,
 384                                    const wxSize& sizeLabel,
 385                                    int flags)
 386 {
 387     // FIXME: this is pure guesswork, need to retrieve the real button margins
 388     wxSize sizeBtn = sizeLabel;
 389
 390     sizeBtn.x += 3*win->GetCharWidth();
 391
 392     // account for the shield UAC icon if we have it
 393     if ( flags & Size_AuthNeeded )
 394         sizeBtn.x += wxSystemSettings::GetMetric(wxSYS_SMALLICON_X);
 395
 396     return sizeBtn;
 397 }
 398
 399 wxSize wxMSWButton::ComputeBestFittingSize(wxControl *btn, int flags)
 400 {
 401     wxClientDC dc(btn);
 402
 403     wxSize sizeBtn;
 404     dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
 405
 406     return GetFittingSize(btn, sizeBtn, flags);
 407 }
 408
 409 wxSize wxMSWButton::IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size)
 410 {
 411     wxSize sizeBtn(size);
 412
 413     // All buttons have at least the standard height and, unless the user
 414     // explicitly wants them to be as small as possible and used wxBU_EXACTFIT
 415     // style to indicate this, of at least the standard width too.
 416     //
 417     // Notice that we really want to make all buttons equally high, otherwise
 418     // they look ugly and the existing code using wxBU_EXACTFIT only uses it to
 419     // control width and not height.
 420
 421     // The 50x14 button size is documented in the "Recommended sizing and
 422     // spacing" section of MSDN layout article.
 423     //
 424     // Note that we intentionally don't use GetDefaultSize() here, because
 425     // it's inexact -- dialog units depend on this dialog's font.
 426     const wxSize sizeDef = btn->ConvertDialogToPixels(wxSize(50, 14));
 427     if ( !btn->HasFlag(wxBU_EXACTFIT) )
 428     {
 429         if ( sizeBtn.x < sizeDef.x )
 430             sizeBtn.x = sizeDef.x;
 431     }
 432     if ( sizeBtn.y < sizeDef.y )
 433         sizeBtn.y = sizeDef.y;
 434
 435     btn->CacheBestSize(sizeBtn);
 436
 437     return sizeBtn;
 438 }
 439
 440 // ----------------------------------------------------------------------------
 441 // creation/destruction
 442 // ----------------------------------------------------------------------------
 443
 444 bool wxButton::Create(wxWindow *parent,
 445                       wxWindowID id,
 446                       const wxString& lbl,
 447                       const wxPoint& pos,
 448                       const wxSize& size,
 449                       long style,
 450                       const wxValidator& validator,
 451                       const wxString& name)
 452 {
 453     m_authNeeded = false;
 454
 455     wxString label(lbl);
 456     if (label.empty() && wxIsStockID(id))
 457     {
 458         // On Windows, some buttons aren't supposed to have mnemonics
 459         label = wxGetStockLabel
 460                 (
 461                     id,
 462                     id == wxID_OK || id == wxID_CANCEL || id == wxID_CLOSE
 463                         ? wxSTOCK_NOFLAGS
 464                         : wxSTOCK_WITH_MNEMONIC
 465                 );
 466     }
 467
 468     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 469         return false;
 470
 471     WXDWORD exstyle;
 472     WXDWORD msStyle = MSWGetStyle(style, &exstyle);
 473
 474     // if the label contains several lines we must explicitly tell the button
 475     // about it or it wouldn't draw it correctly ("\n"s would just appear as
 476     // black boxes)
 477     //
 478     // NB: we do it here and not in MSWGetStyle() because we need the label
 479     //     value and the label is not set yet when MSWGetStyle() is called
 480     msStyle |= wxMSWButton::GetMultilineStyle(label);
 481
 482     return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, exstyle);
 483 }
 484
 485 wxButton::~wxButton()
 486 {
 487     wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
 488     if ( tlw && tlw->GetTmpDefaultItem() == this )
 489     {
 490         UnsetTmpDefault();
 491     }
 492
 493     delete m_imageData;
 494 }
 495
 496 // ----------------------------------------------------------------------------
 497 // flags
 498 // ----------------------------------------------------------------------------
 499
 500 WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
 501 {
 502     // buttons never have an external border, they draw their own one
 503     WXDWORD msStyle = wxControl::MSWGetStyle
 504                       (
 505                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 506                       );
 507
 508     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
 509     // each other in any resizeable dialog which has more than one button in
 510     // the bottom
 511     msStyle |= WS_CLIPSIBLINGS;
 512
 513     // don't use "else if" here: weird as it is, but you may combine wxBU_LEFT
 514     // and wxBU_RIGHT to get BS_CENTER!
 515     if ( style & wxBU_LEFT )
 516         msStyle |= BS_LEFT;
 517     if ( style & wxBU_RIGHT )
 518         msStyle |= BS_RIGHT;
 519     if ( style & wxBU_TOP )
 520         msStyle |= BS_TOP;
 521     if ( style & wxBU_BOTTOM )
 522         msStyle |= BS_BOTTOM;
 523 #ifndef __WXWINCE__
 524     // flat 2d buttons
 525     if ( style & wxNO_BORDER )
 526         msStyle |= BS_FLAT;
 527 #endif // __WXWINCE__
 528
 529     return msStyle;
 530 }
 531
 532 void wxButton::SetLabel(const wxString& label)
 533 {
 534     wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
 535
 536     wxButtonBase::SetLabel(label);
 537 }
 538
 539 // ----------------------------------------------------------------------------
 540 // size management including autosizing
 541 // ----------------------------------------------------------------------------
 542
 543 void wxButton::AdjustForBitmapSize(wxSize &size) const
 544 {
 545     wxCHECK_RET( m_imageData, wxT("shouldn't be called if no image") );
 546
 547     // account for the bitmap size
 548     const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
 549     const wxDirection dirBmp = m_imageData->GetBitmapPosition();
 550     if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
 551     {
 552         size.x += sizeBmp.x;
 553         if ( sizeBmp.y > size.y )
 554             size.y = sizeBmp.y;
 555     }
 556     else // bitmap on top/below the text
 557     {
 558         size.y += sizeBmp.y;
 559         if ( sizeBmp.x > size.x )
 560             size.x = sizeBmp.x;
 561     }
 562
 563     // account for the user-specified margins
 564     size += 2*m_imageData->GetBitmapMargins();
 565
 566     // and also for the margins we always add internally (unless we have no
 567     // border at all in which case the button has exactly the same size as
 568     // bitmap and so no margins should be used)
 569     if ( !HasFlag(wxBORDER_NONE) )
 570     {
 571         int marginH = 0,
 572             marginV = 0;
 573 #if wxUSE_UXTHEME
 574         if ( wxUxThemeEngine::GetIfActive() )
 575         {
 576             wxUxThemeHandle theme(const_cast<wxButton *>(this), L"BUTTON");
 577
 578             MARGINS margins;
 579             wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
 580                                                     BP_PUSHBUTTON,
 581                                                     PBS_NORMAL,
 582                                                     TMT_CONTENTMARGINS,
 583                                                     NULL,
 584                                                     &margins);
 585
 586             // XP doesn't draw themed buttons correctly when the client
 587             // area is smaller than 8x8 - enforce this minimum size for
 588             // small bitmaps
 589             size.IncTo(wxSize(8, 8));
 590
 591             marginH = margins.cxLeftWidth + margins.cxRightWidth
 592                         + 2*XP_BUTTON_EXTRA_MARGIN;
 593             marginV = margins.cyTopHeight + margins.cyBottomHeight
 594                         + 2*XP_BUTTON_EXTRA_MARGIN;
 595         }
 596         else
 597 #endif // wxUSE_UXTHEME
 598         {
 599             marginH =
 600             marginV = OD_BUTTON_MARGIN;
 601         }
 602
 603         size.IncBy(marginH, marginV);
 604     }
 605 }
 606
 607 wxSize wxButton::DoGetBestSize() const
 608 {
 609     wxButton * const self = const_cast<wxButton *>(this);
 610
 611     wxSize size;
 612
 613     // Account for the text part if we have it.
 614     if ( ShowsLabel() )
 615     {
 616         int flags = 0;
 617         if ( GetAuthNeeded() )
 618             flags |= wxMSWButton::Size_AuthNeeded;
 619
 620         size = wxMSWButton::ComputeBestFittingSize(self, flags);
 621     }
 622
 623     if ( m_imageData )
 624         AdjustForBitmapSize(size);
 625
 626     return wxMSWButton::IncreaseToStdSizeAndCache(self, size);
 627 }
 628
 629 /* static */
 630 wxSize wxButtonBase::GetDefaultSize()
 631 {
 632     static wxSize s_sizeBtn;
 633
 634     if ( s_sizeBtn.x == 0 )
 635     {
 636         wxScreenDC dc;
 637         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 638
 639         // The size of a standard button in the dialog units is 50x14,
 640         // translate this to pixels.
 641         //
 642         // Windows' computes dialog units using average character width over
 643         // upper- and lower-case ASCII alphabet and not using the average
 644         // character width metadata stored in the font; see
 645         // http://support.microsoft.com/default.aspx/kb/145994 for detailed
 646         // discussion.
 647         //
 648         // NB: wxMulDivInt32() is used, because it correctly rounds the result
 649
 650         const wxSize base = wxPrivate::GetAverageASCIILetterSize(dc);
 651         s_sizeBtn.x = wxMulDivInt32(50, base.x, 4);
 652         s_sizeBtn.y = wxMulDivInt32(14, base.y, 8);
 653     }
 654
 655     return s_sizeBtn;
 656 }
 657
 658 // ----------------------------------------------------------------------------
 659 // default button handling
 660 // ----------------------------------------------------------------------------
 661
 662 /*
 663    The comment below and all this code is probably due to not using WM_NEXTDLGCTL
 664    message when changing focus (but just SetFocus() which is not enough), see
 665    http://blogs.msdn.com/oldnewthing/archive/2004/08/02/205624.aspx for the
 666    full explanation.
 667
 668    TODO: Do use WM_NEXTDLGCTL and get rid of all this code.
 669
 670
 671    "Everything you ever wanted to know about the default buttons" or "Why do we
 672    have to do all this?"
 673
 674    In MSW the default button should be activated when the user presses Enter
 675    and the current control doesn't process Enter itself somehow. This is
 676    handled by ::DefWindowProc() (or maybe ::DefDialogProc()) using DM_SETDEFID
 677    Another aspect of "defaultness" is that the default button has different
 678    appearance: this is due to BS_DEFPUSHBUTTON style which is completely
 679    separate from DM_SETDEFID stuff (!). Also note that BS_DEFPUSHBUTTON should
 680    be unset if our parent window is not active so it should be unset whenever
 681    we lose activation and set back when we regain it.
 682
 683    Final complication is that when a button is active, it should be the default
 684    one, i.e. pressing Enter on a button always activates it and not another
 685    one.
 686
 687    We handle this by maintaining a permanent and a temporary default items in
 688    wxControlContainer (both may be NULL). When a button becomes the current
 689    control (i.e. gets focus) it sets itself as the temporary default which
 690    ensures that it has the right appearance and that Enter will be redirected
 691    to it. When the button loses focus, it unsets the temporary default and so
 692    the default item will be the permanent default -- that is the default button
 693    if any had been set or none otherwise, which is just what we want.
 694
 695    NB: all this is quite complicated by now and the worst is that normally
 696        it shouldn't be necessary at all as for the normal Windows programs
 697        DefWindowProc() and IsDialogMessage() take care of all this
 698        automatically -- however in wxWidgets programs this doesn't work for
 699        nested hierarchies (i.e. a notebook inside a notebook) for unknown
 700        reason and so we have to reproduce all this code ourselves. It would be
 701        very nice if we could avoid doing it.
 702  */
 703
 704 // set this button as the (permanently) default one in its panel
 705 wxWindow *wxButton::SetDefault()
 706 {
 707     // set this one as the default button both for wxWidgets ...
 708     wxWindow *winOldDefault = wxButtonBase::SetDefault();
 709
 710     // ... and Windows
 711     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 712     SetDefaultStyle(this, true);
 713
 714     return winOldDefault;
 715 }
 716
 717 // return the top level parent window if it's not being deleted yet, otherwise
 718 // return NULL
 719 static wxTopLevelWindow *GetTLWParentIfNotBeingDeleted(wxWindow *win)
 720 {
 721     for ( ;; )
 722     {
 723         // IsTopLevel() will return false for a wxTLW being deleted, so we also
 724         // need the parent test for this case
 725         wxWindow * const parent = win->GetParent();
 726         if ( !parent || win->IsTopLevel() )
 727         {
 728             if ( win->IsBeingDeleted() )
 729                 return NULL;
 730
 731             break;
 732         }
 733
 734         win = parent;
 735     }
 736
 737     wxASSERT_MSG( win, wxT("button without top level parent?") );
 738
 739     wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
 740     wxASSERT_MSG( tlw, wxT("logic error in GetTLWParentIfNotBeingDeleted()") );
 741
 742     return tlw;
 743 }
 744
 745 // set this button as being currently default
 746 void wxButton::SetTmpDefault()
 747 {
 748     wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
 749     if ( !tlw )
 750         return;
 751
 752     wxWindow *winOldDefault = tlw->GetDefaultItem();
 753     tlw->SetTmpDefaultItem(this);
 754
 755     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), false);
 756     SetDefaultStyle(this, true);
 757 }
 758
 759 // unset this button as currently default, it may still stay permanent default
 760 void wxButton::UnsetTmpDefault()
 761 {
 762     wxTopLevelWindow * const tlw = GetTLWParentIfNotBeingDeleted(GetParent());
 763     if ( !tlw )
 764         return;
 765
 766     tlw->SetTmpDefaultItem(NULL);
 767
 768     wxWindow *winOldDefault = tlw->GetDefaultItem();
 769
 770     SetDefaultStyle(this, false);
 771     SetDefaultStyle(wxDynamicCast(winOldDefault, wxButton), true);
 772 }
 773
 774 /* static */
 775 void
 776 wxButton::SetDefaultStyle(wxButton *btn, bool on)
 777 {
 778     // we may be called with NULL pointer -- simpler to do the check here than
 779     // in the caller which does wxDynamicCast()
 780     if ( !btn )
 781         return;
 782
 783     // first, let DefDlgProc() know about the new default button
 784     if ( on )
 785     {
 786         // we shouldn't set BS_DEFPUSHBUTTON for any button if we don't have
 787         // focus at all any more
 788         if ( !wxTheApp->IsActive() )
 789             return;
 790
 791         wxWindow * const tlw = wxGetTopLevelParent(btn);
 792         wxCHECK_RET( tlw, wxT("button without top level window?") );
 793
 794         ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
 795
 796         // sending DM_SETDEFID also changes the button style to
 797         // BS_DEFPUSHBUTTON so there is nothing more to do
 798     }
 799
 800     // then also change the style as needed
 801     long style = ::GetWindowLong(GetHwndOf(btn), GWL_STYLE);
 802     if ( !(style & BS_DEFPUSHBUTTON) == on )
 803     {
 804         // don't do it with the owner drawn buttons because it will
 805         // reset BS_OWNERDRAW style bit too (as BS_OWNERDRAW &
 806         // BS_DEFPUSHBUTTON != 0)!
 807         if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
 808         {
 809             ::SendMessage(GetHwndOf(btn), BM_SETSTYLE,
 810                           on ? style | BS_DEFPUSHBUTTON
 811                              : style & ~BS_DEFPUSHBUTTON,
 812                           1L /* redraw */);
 813         }
 814         else // owner drawn
 815         {
 816             // redraw the button - it will notice itself that it's
 817             // [not] the default one [any longer]
 818             btn->Refresh();
 819         }
 820     }
 821     //else: already has correct style
 822 }
 823
 824 // ----------------------------------------------------------------------------
 825 // helpers
 826 // ----------------------------------------------------------------------------
 827
 828 bool wxButton::SendClickEvent()
 829 {
 830     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
 831     event.SetEventObject(this);
 832
 833     return ProcessCommand(event);
 834 }
 835
 836 void wxButton::Command(wxCommandEvent & event)
 837 {
 838     ProcessCommand(event);
 839 }
 840
 841 // ----------------------------------------------------------------------------
 842 // event/message handlers
 843 // ----------------------------------------------------------------------------
 844
 845 bool wxButton::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 846 {
 847     bool processed = false;
 848     switch ( param )
 849     {
 850         // NOTE: Apparently older versions (NT 4?) of the common controls send
 851         //       BN_DOUBLECLICKED but not a second BN_CLICKED for owner-drawn
 852         //       buttons, so in order to send two EVT_BUTTON events we should
 853         //       catch both types.  Currently (Feb 2003) up-to-date versions of
 854         //       win98, win2k and winXP all send two BN_CLICKED messages for
 855         //       all button types, so we don't catch BN_DOUBLECLICKED anymore
 856         //       in order to not get 3 EVT_BUTTON events.  If this is a problem
 857         //       then we need to figure out which version of the comctl32 changed
 858         //       this behaviour and test for it.
 859
 860         case 1:                     // message came from an accelerator
 861         case BN_CLICKED:            // normal buttons send this
 862             processed = SendClickEvent();
 863             break;
 864     }
 865
 866     return processed;
 867 }
 868
 869 WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 870 {
 871     // when we receive focus, we want to temporarily become the default button in
 872     // our parent panel so that pressing "Enter" would activate us -- and when
 873     // losing it we should restore the previous default button as well
 874     if ( nMsg == WM_SETFOCUS )
 875     {
 876         SetTmpDefault();
 877
 878         // let the default processing take place too
 879     }
 880     else if ( nMsg == WM_KILLFOCUS )
 881     {
 882         UnsetTmpDefault();
 883     }
 884     else if ( nMsg == WM_LBUTTONDBLCLK )
 885     {
 886         // emulate a click event to force an owner-drawn button to change its
 887         // appearance - without this, it won't do it
 888         (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
 889
 890         // and continue with processing the message normally as well
 891     }
 892 #if wxUSE_UXTHEME
 893     else if ( nMsg == WM_THEMECHANGED )
 894     {
 895         // need to recalculate the best size here
 896         // as the theme size might have changed
 897         InvalidateBestSize();
 898     }
 899 #endif // wxUSE_UXTHEME
 900     // must use m_mouseInWindow here instead of IsMouseInWindow()
 901     // since we need to know the first time the mouse enters the window
 902     // and IsMouseInWindow() would return true in this case
 903     else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
 904                 nMsg == WM_MOUSELEAVE )
 905     {
 906         if (
 907                 IsEnabled() &&
 908                 (
 909 #if wxUSE_UXTHEME
 910                 wxUxThemeEngine::GetIfActive() ||
 911 #endif // wxUSE_UXTHEME
 912                  (m_imageData && m_imageData->GetBitmap(State_Current).IsOk())
 913                 )
 914            )
 915         {
 916             Refresh();
 917         }
 918     }
 919
 920     // let the base class do all real processing
 921     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 922 }
 923
 924 // ----------------------------------------------------------------------------
 925 // authentication needed handling
 926 // ----------------------------------------------------------------------------
 927
 928 bool wxButton::DoGetAuthNeeded() const
 929 {
 930     return m_authNeeded;
 931 }
 932
 933 void wxButton::DoSetAuthNeeded(bool show)
 934 {
 935     // show/hide UAC symbol on Windows Vista and later
 936     if ( wxGetWinVersion() >= wxWinVersion_6 )
 937     {
 938         m_authNeeded = show;
 939         ::SendMessage(GetHwnd(), BCM_SETSHIELD, 0, show);
 940         InvalidateBestSize();
 941     }
 942 }
 943
 944 // ----------------------------------------------------------------------------
 945 // button images
 946 // ----------------------------------------------------------------------------
 947
 948 wxBitmap wxButton::DoGetBitmap(State which) const
 949 {
 950     return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
 951 }
 952
 953 void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
 954 {
 955     // allocate the image data when the first bitmap is set
 956     if ( !m_imageData )
 957     {
 958 #if wxUSE_UXTHEME
 959         // using image list doesn't work correctly if we don't have any label
 960         // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
 961         // BS_BITMAP style), at least under Windows 2003 so use owner drawn
 962         // strategy for bitmap-only buttons
 963         if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
 964         {
 965             m_imageData = new wxXPButtonImageData(this, bitmap);
 966         }
 967         else
 968 #endif // wxUSE_UXTHEME
 969         {
 970             m_imageData = new wxODButtonImageData(this, bitmap);
 971             MakeOwnerDrawn();
 972         }
 973     }
 974     else
 975     {
 976         m_imageData->SetBitmap(bitmap, which);
 977     }
 978
 979     // it should be enough to only invalidate the best size when the normal
 980     // bitmap changes as all bitmaps assigned to the button should be of the
 981     // same size anyhow
 982     if ( which == State_Normal )
 983         InvalidateBestSize();
 984
 985     Refresh();
 986 }
 987
 988 wxSize wxButton::DoGetBitmapMargins() const
 989 {
 990     return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
 991 }
 992
 993 void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
 994 {
 995     wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
 996
 997     m_imageData->SetBitmapMargins(x, y);
 998     InvalidateBestSize();
 999 }
1000
1001 void wxButton::DoSetBitmapPosition(wxDirection dir)
1002 {
1003     wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
1004
1005     m_imageData->SetBitmapPosition(dir);
1006     InvalidateBestSize();
1007 }
1008
1009 // ----------------------------------------------------------------------------
1010 // owner-drawn buttons support
1011 // ----------------------------------------------------------------------------
1012
1013 // drawing helpers
1014 namespace
1015 {
1016
1017 // return the button state using both the ODS_XXX flags specified in state
1018 // parameter and the current button state
1019 wxButton::State GetButtonState(wxButton *btn, UINT state)
1020 {
1021     if ( state & ODS_DISABLED )
1022         return wxButton::State_Disabled;
1023
1024     if ( state & ODS_SELECTED )
1025         return wxButton::State_Pressed;
1026
1027     if ( btn->HasCapture() || btn->IsMouseInWindow() )
1028         return wxButton::State_Current;
1029
1030     if ( state & ODS_FOCUS )
1031         return wxButton::State_Focused;
1032
1033     return wxButton::State_Normal;
1034 }
1035
1036 void DrawButtonText(HDC hdc,
1037                     RECT *pRect,
1038                     const wxString& text,
1039                     COLORREF col,
1040                     int flags)
1041 {
1042     wxTextColoursChanger changeFg(hdc, col, CLR_INVALID);
1043     wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
1044
1045     // center text horizontally in any case
1046     flags |= DT_CENTER;
1047
1048     if ( text.find(wxT('\n')) != wxString::npos )
1049     {
1050         // draw multiline label
1051
1052         // first we need to compute its bounding rect
1053         RECT rc;
1054         ::CopyRect(&rc, pRect);
1055         ::DrawText(hdc, text.wx_str(), text.length(), &rc,
1056                    DT_CENTER | DT_CALCRECT);
1057
1058         // now center this rect inside the entire button area
1059         const LONG w = rc.right - rc.left;
1060         const LONG h = rc.bottom - rc.top;
1061         rc.left = (pRect->right - pRect->left)/2 - w/2;
1062         rc.right = rc.left+w;
1063         rc.top = (pRect->bottom - pRect->top)/2 - h/2;
1064         rc.bottom = rc.top+h;
1065
1066         ::DrawText(hdc, text.wx_str(), text.length(), &rc, flags);
1067     }
1068     else // single line label
1069     {
1070         // centre text vertically too (notice that we must have DT_SINGLELINE
1071         // for DT_VCENTER to work)
1072         ::DrawText(hdc, text.wx_str(), text.length(), pRect,
1073                    flags | DT_SINGLELINE | DT_VCENTER);
1074     }
1075 }
1076
1077 void DrawRect(HDC hdc, const RECT& r)
1078 {
1079     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
1080     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
1081     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
1082     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
1083 }
1084
1085 /*
1086    The button frame looks like this normally:
1087
1088    WWWWWWWWWWWWWWWWWWB
1089    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
1090    WH               GB  H = light grey  (LIGHT)
1091    WH               GB  G = dark grey   (SHADOW)
1092    WH               GB  B = black       (DKSHADOW)
1093    WH               GB
1094    WGGGGGGGGGGGGGGGGGB
1095    BBBBBBBBBBBBBBBBBBB
1096
1097    When the button is selected, the button becomes like this (the total button
1098    size doesn't change):
1099
1100    BBBBBBBBBBBBBBBBBBB
1101    BWWWWWWWWWWWWWWWWBB
1102    BWHHHHHHHHHHHHHHGBB
1103    BWH             GBB
1104    BWH             GBB
1105    BWGGGGGGGGGGGGGGGBB
1106    BBBBBBBBBBBBBBBBBBB
1107    BBBBBBBBBBBBBBBBBBB
1108
1109    When the button is pushed (while selected) it is like:
1110
1111    BBBBBBBBBBBBBBBBBBB
1112    BGGGGGGGGGGGGGGGGGB
1113    BG               GB
1114    BG               GB
1115    BG               GB
1116    BG               GB
1117    BGGGGGGGGGGGGGGGGGB
1118    BBBBBBBBBBBBBBBBBBB
1119 */
1120 void DrawButtonFrame(HDC hdc, RECT& rectBtn,
1121                      bool selected, bool pushed)
1122 {
1123     RECT r;
1124     CopyRect(&r, &rectBtn);
1125
1126     AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
1127              hpenGrey(GetSysColor(COLOR_3DSHADOW)),
1128              hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
1129              hpenWhite(GetSysColor(COLOR_3DHILIGHT));
1130
1131     SelectInHDC selectPen(hdc, hpenBlack);
1132
1133     r.right--;
1134     r.bottom--;
1135
1136     if ( pushed )
1137     {
1138         DrawRect(hdc, r);
1139
1140         (void)SelectObject(hdc, hpenGrey);
1141         ::InflateRect(&r, -1, -1);
1142
1143         DrawRect(hdc, r);
1144     }
1145     else // !pushed
1146     {
1147         if ( selected )
1148         {
1149             DrawRect(hdc, r);
1150
1151             ::InflateRect(&r, -1, -1);
1152         }
1153
1154         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
1155         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
1156
1157         (void)SelectObject(hdc, hpenWhite);
1158         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
1159         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
1160
1161         (void)SelectObject(hdc, hpenLightGr);
1162         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
1163         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
1164
1165         (void)SelectObject(hdc, hpenGrey);
1166         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
1167         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
1168     }
1169
1170     InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
1171 }
1172
1173 #if wxUSE_UXTHEME
1174 void DrawXPBackground(wxButton *button, HDC hdc, RECT& rectBtn, UINT state)
1175 {
1176     wxUxThemeHandle theme(button, L"BUTTON");
1177
1178     // this array is indexed by wxButton::State values and so must be kept in
1179     // sync with it
1180     static const int uxStates[] =
1181     {
1182         PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
1183     };
1184
1185     int iState = uxStates[GetButtonState(button, state)];
1186
1187     wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
1188
1189     // draw parent background if needed
1190     if ( engine->IsThemeBackgroundPartiallyTransparent
1191                  (
1192                     theme,
1193                     BP_PUSHBUTTON,
1194                     iState
1195                  ) )
1196     {
1197         engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
1198     }
1199
1200     // draw background
1201     engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
1202                                 &rectBtn, NULL);
1203
1204     // calculate content area margins
1205     MARGINS margins;
1206     engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
1207                             TMT_CONTENTMARGINS, &rectBtn, &margins);
1208     ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
1209     ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
1210
1211     if ( button->UseBgCol() )
1212     {
1213         COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
1214         AutoHBRUSH hbrushBackground(colBg);
1215
1216         // don't overwrite the focus rect
1217         RECT rectClient;
1218         ::CopyRect(&rectClient, &rectBtn);
1219         ::InflateRect(&rectClient, -1, -1);
1220         FillRect(hdc, &rectClient, hbrushBackground);
1221     }
1222 }
1223 #endif // wxUSE_UXTHEME
1224
1225 } // anonymous namespace
1226
1227 // ----------------------------------------------------------------------------
1228 // owner drawn buttons support
1229 // ----------------------------------------------------------------------------
1230
1231 void wxButton::MakeOwnerDrawn()
1232 {
1233     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1234     if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
1235     {
1236         // make it so
1237         style |= BS_OWNERDRAW;
1238         SetWindowLong(GetHwnd(), GWL_STYLE, style);
1239     }
1240 }
1241
1242 bool wxButton::SetBackgroundColour(const wxColour &colour)
1243 {
1244     if ( !wxControl::SetBackgroundColour(colour) )
1245     {
1246         // nothing to do
1247         return false;
1248     }
1249
1250     MakeOwnerDrawn();
1251
1252     Refresh();
1253
1254     return true;
1255 }
1256
1257 bool wxButton::SetForegroundColour(const wxColour &colour)
1258 {
1259     if ( !wxControl::SetForegroundColour(colour) )
1260     {
1261         // nothing to do
1262         return false;
1263     }
1264
1265     MakeOwnerDrawn();
1266
1267     Refresh();
1268
1269     return true;
1270 }
1271
1272 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
1273 {
1274     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
1275     HDC hdc = lpDIS->hDC;
1276
1277     UINT state = lpDIS->itemState;
1278     bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
1279
1280     RECT rectBtn;
1281     CopyRect(&rectBtn, &lpDIS->rcItem);
1282
1283     // draw the button background
1284     if ( !HasFlag(wxBORDER_NONE) )
1285     {
1286 #if wxUSE_UXTHEME
1287         if ( wxUxThemeEngine::GetIfActive() )
1288         {
1289             DrawXPBackground(this, hdc, rectBtn, state);
1290         }
1291         else
1292 #endif // wxUSE_UXTHEME
1293         {
1294             COLORREF colBg = wxColourToRGB(GetBackgroundColour());
1295
1296             // first, draw the background
1297             AutoHBRUSH hbrushBackground(colBg);
1298             FillRect(hdc, &rectBtn, hbrushBackground);
1299
1300             // draw the border for the current state
1301             bool selected = (state & ODS_SELECTED) != 0;
1302             if ( !selected )
1303             {
1304                 wxTopLevelWindow *
1305                     tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
1306                 if ( tlw )
1307                 {
1308                     selected = tlw->GetDefaultItem() == this;
1309                 }
1310             }
1311
1312             DrawButtonFrame(hdc, rectBtn, selected, pushed);
1313         }
1314
1315         // draw the focus rectangle if we need it
1316         if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
1317         {
1318             DrawFocusRect(hdc, &rectBtn);
1319
1320 #if wxUSE_UXTHEME
1321             if ( !wxUxThemeEngine::GetIfActive() )
1322 #endif // wxUSE_UXTHEME
1323             {
1324                 if ( pushed )
1325                 {
1326                     // the label is shifted by 1 pixel to create "pushed" effect
1327                     OffsetRect(&rectBtn, 1, 1);
1328                 }
1329             }
1330         }
1331     }
1332
1333
1334     // draw the image, if any
1335     if ( m_imageData )
1336     {
1337         wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
1338         if ( !bmp.IsOk() )
1339             bmp = m_imageData->GetBitmap(State_Normal);
1340
1341         const wxSize sizeBmp = bmp.GetSize();
1342         const wxSize margin = m_imageData->GetBitmapMargins();
1343         const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
1344         wxRect rectButton(wxRectFromRECT(rectBtn));
1345
1346         // for simplicity, we start with centred rectangle and then move it to
1347         // the appropriate edge
1348         wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
1349
1350         // move bitmap only if we have a label, otherwise keep it centered
1351         if ( ShowsLabel() )
1352         {
1353             switch ( m_imageData->GetBitmapPosition() )
1354             {
1355                 default:
1356                     wxFAIL_MSG( "invalid direction" );
1357                     // fall through
1358
1359                 case wxLEFT:
1360                     rectBitmap.x = rectButton.x + margin.x;
1361                     rectButton.x += sizeBmpWithMargins.x;
1362                     rectButton.width -= sizeBmpWithMargins.x;
1363                     break;
1364
1365                 case wxRIGHT:
1366                     rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1367                     rectButton.width -= sizeBmpWithMargins.x;
1368                     break;
1369
1370                 case wxTOP:
1371                     rectBitmap.y = rectButton.y + margin.y;
1372                     rectButton.y += sizeBmpWithMargins.y;
1373                     rectButton.height -= sizeBmpWithMargins.y;
1374                     break;
1375
1376                 case wxBOTTOM:
1377                     rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1378                     rectButton.height -= sizeBmpWithMargins.y;
1379                     break;
1380             }
1381         }
1382
1383         wxDCTemp dst((WXHDC)hdc);
1384         dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1385
1386         wxCopyRectToRECT(rectButton, rectBtn);
1387     }
1388
1389
1390     // finally draw the label
1391     if ( ShowsLabel() )
1392     {
1393         COLORREF colFg = state & ODS_DISABLED
1394                             ? ::GetSysColor(COLOR_GRAYTEXT)
1395                             : wxColourToRGB(GetForegroundColour());
1396
1397         // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1398         // systems but by happy coincidence ODS_NOACCEL is not used under them
1399         // neither so DT_HIDEPREFIX should never be used there
1400         DrawButtonText(hdc, &rectBtn, GetLabel(), colFg,
1401                        state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1402     }
1403
1404     return true;
1405 }
1406
1407 #endif // wxUSE_BUTTON
1408