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