src/msw/anybutton.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/anybutton.cpp
   3 // Purpose:     wxAnyButton
   4 // Author:      Julian Smart
   5 // Created:     1998-01-04 (extracted from button.cpp)
   6 // Copyright:   (c) Julian Smart
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // ============================================================================
  11 // declarations
  12 // ============================================================================
  13
  14 // ----------------------------------------------------------------------------
  15 // headers
  16 // ----------------------------------------------------------------------------
  17
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22     #pragma hdrstop
  23 #endif
  24
  25 #ifdef wxHAS_ANY_BUTTON
  26
  27 #include "wx/anybutton.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/app.h"
  31     #include "wx/brush.h"
  32     #include "wx/panel.h"
  33     #include "wx/bmpbuttn.h"
  34     #include "wx/settings.h"
  35     #include "wx/dcscreen.h"
  36     #include "wx/dcclient.h"
  37     #include "wx/toplevel.h"
  38     #include "wx/msw/wrapcctl.h"
  39     #include "wx/msw/private.h"
  40     #include "wx/msw/missing.h"
  41 #endif
  42
  43 #include "wx/imaglist.h"
  44 #include "wx/stockitem.h"
  45 #include "wx/msw/private/button.h"
  46 #include "wx/msw/private/dc.h"
  47 #include "wx/private/window.h"
  48
  49 #if wxUSE_MARKUP
  50     #include "wx/generic/private/markuptext.h"
  51 #endif // wxUSE_MARKUP
  52
  53 using namespace wxMSWImpl;
  54
  55 #if wxUSE_UXTHEME
  56     #include "wx/msw/uxtheme.h"
  57
  58     // no need to include tmschema.h
  59     #ifndef BP_PUSHBUTTON
  60         #define BP_PUSHBUTTON 1
  61
  62         #define PBS_NORMAL    1
  63         #define PBS_HOT       2
  64         #define PBS_PRESSED   3
  65         #define PBS_DISABLED  4
  66         #define PBS_DEFAULTED 5
  67
  68         #define TMT_CONTENTMARGINS 3602
  69     #endif
  70
  71     // provide the necessary declarations ourselves if they're missing from
  72     // headers
  73     #ifndef BCM_SETIMAGELIST
  74         #define BCM_SETIMAGELIST    0x1602
  75         #define BCM_SETTEXTMARGIN   0x1604
  76
  77         enum
  78         {
  79             BUTTON_IMAGELIST_ALIGN_LEFT,
  80             BUTTON_IMAGELIST_ALIGN_RIGHT,
  81             BUTTON_IMAGELIST_ALIGN_TOP,
  82             BUTTON_IMAGELIST_ALIGN_BOTTOM
  83         };
  84
  85         struct BUTTON_IMAGELIST
  86         {
  87             HIMAGELIST himl;
  88             RECT margin;
  89             UINT uAlign;
  90         };
  91     #endif
  92 #endif // wxUSE_UXTHEME
  93
  94 #ifndef WM_THEMECHANGED
  95     #define WM_THEMECHANGED     0x031A
  96 #endif
  97
  98 #ifndef ODS_NOACCEL
  99     #define ODS_NOACCEL         0x0100
 100 #endif
 101
 102 #ifndef ODS_NOFOCUSRECT
 103     #define ODS_NOFOCUSRECT     0x0200
 104 #endif
 105
 106 #ifndef DT_HIDEPREFIX
 107     #define DT_HIDEPREFIX       0x00100000
 108 #endif
 109
 110 #if wxUSE_UXTHEME
 111 extern wxWindowMSW *wxWindowBeingErased; // From src/msw/window.cpp
 112 #endif // wxUSE_UXTHEME
 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(wxAnyButton::State which) const = 0;
 127     virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::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(wxAnyButton *btn, const wxBitmap& bitmap)
 150     {
 151         SetBitmap(bitmap, wxAnyButton::State_Normal);
 152 #if wxUSE_IMAGE
 153         SetBitmap(bitmap.ConvertToDisabled(), wxAnyButton::State_Disabled);
 154 #endif
 155         m_dir = wxLEFT;
 156
 157         // we use margins when we have both bitmap and text, but when we have
 158         // only the bitmap it should take up the entire button area
 159         if ( btn->ShowsLabel() )
 160         {
 161             m_margin.x = btn->GetCharWidth();
 162             m_margin.y = btn->GetCharHeight() / 2;
 163         }
 164     }
 165
 166     virtual wxBitmap GetBitmap(wxAnyButton::State which) const
 167     {
 168         return m_bitmaps[which];
 169     }
 170
 171     virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::State which)
 172     {
 173         m_bitmaps[which] = bitmap;
 174     }
 175
 176     virtual wxSize GetBitmapMargins() const
 177     {
 178         return m_margin;
 179     }
 180
 181     virtual void SetBitmapMargins(wxCoord x, wxCoord y)
 182     {
 183         m_margin = wxSize(x, y);
 184     }
 185
 186     virtual wxDirection GetBitmapPosition() const
 187     {
 188         return m_dir;
 189     }
 190
 191     virtual void SetBitmapPosition(wxDirection dir)
 192     {
 193         m_dir = dir;
 194     }
 195
 196 private:
 197     // just store the values passed to us to be able to retrieve them later
 198     // from the drawing code
 199     wxBitmap m_bitmaps[wxAnyButton::State_Max];
 200     wxSize m_margin;
 201     wxDirection m_dir;
 202
 203     wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
 204 };
 205
 206 #if wxUSE_UXTHEME
 207
 208 // somehow the margin is one pixel greater than the value returned by
 209 // GetThemeMargins() call
 210 const int XP_BUTTON_EXTRA_MARGIN = 1;
 211
 212 class wxXPButtonImageData : public wxButtonImageData
 213 {
 214 public:
 215     // we must be constructed with the size of our images as we need to create
 216     // the image list
 217     wxXPButtonImageData(wxAnyButton *btn, const wxBitmap& bitmap)
 218         : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
 219                 wxAnyButton::State_Max + 1 /* see "pulse" comment below */),
 220           m_hwndBtn(GetHwndOf(btn))
 221     {
 222         // initialize all bitmaps except for the disabled one to normal state
 223         for ( int n = 0; n < wxAnyButton::State_Max; n++ )
 224         {
 225 #if wxUSE_IMAGE
 226             m_iml.Add(n == wxAnyButton::State_Disabled ? bitmap.ConvertToDisabled()
 227                                                     : bitmap);
 228 #else
 229             m_iml.Add(bitmap);
 230 #endif
 231         }
 232
 233         // In addition to the states supported by wxWidgets such as normal,
 234         // hot, pressed, disabled and focused, we need to add bitmap for
 235         // another state when running under Windows 7 -- the so called "stylus
 236         // hot" state corresponding to PBS_STYLUSHOT constant. While it's
 237         // documented in MSDN as being only used with tablets, it is a lie as
 238         // a focused button actually alternates between the image list elements
 239         // with PBS_DEFAULTED and PBS_STYLUSHOT indices and, in particular,
 240         // just disappears during half of the time if the latter is not set so
 241         // we absolutely must set it.
 242         //
 243         // This also explains why we need to allocate an extra slot in the
 244         // image list ctor above, the slot State_Max is used for this one.
 245         m_iml.Add(bitmap);
 246
 247         m_data.himl = GetHimagelistOf(&m_iml);
 248
 249         // no margins by default
 250         m_data.margin.left =
 251         m_data.margin.right =
 252         m_data.margin.top =
 253         m_data.margin.bottom = 0;
 254
 255         // use default alignment
 256         m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
 257
 258         UpdateImageInfo();
 259     }
 260
 261     virtual wxBitmap GetBitmap(wxAnyButton::State which) const
 262     {
 263         return m_iml.GetBitmap(which);
 264     }
 265
 266     virtual void SetBitmap(const wxBitmap& bitmap, wxAnyButton::State which)
 267     {
 268         m_iml.Replace(which, bitmap);
 269
 270         // As we want the focused button to always show its bitmap, we need to
 271         // update the "stylus hot" one to match it to avoid any pulsing.
 272         if ( which == wxAnyButton::State_Focused )
 273             m_iml.Replace(wxAnyButton::State_Max, bitmap);
 274
 275         UpdateImageInfo();
 276     }
 277
 278     virtual wxSize GetBitmapMargins() const
 279     {
 280         return wxSize(m_data.margin.left, m_data.margin.top);
 281     }
 282
 283     virtual void SetBitmapMargins(wxCoord x, wxCoord y)
 284     {
 285         RECT& margin = m_data.margin;
 286         margin.left =
 287         margin.right = x;
 288         margin.top =
 289         margin.bottom = y;
 290
 291         if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
 292         {
 293             wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
 294         }
 295     }
 296
 297     virtual wxDirection GetBitmapPosition() const
 298     {
 299         switch ( m_data.uAlign )
 300         {
 301             default:
 302                 wxFAIL_MSG( "invalid image alignment" );
 303                 // fall through
 304
 305             case BUTTON_IMAGELIST_ALIGN_LEFT:
 306                 return wxLEFT;
 307
 308             case BUTTON_IMAGELIST_ALIGN_RIGHT:
 309                 return wxRIGHT;
 310
 311             case BUTTON_IMAGELIST_ALIGN_TOP:
 312                 return wxTOP;
 313
 314             case BUTTON_IMAGELIST_ALIGN_BOTTOM:
 315                 return wxBOTTOM;
 316         }
 317     }
 318
 319     virtual void SetBitmapPosition(wxDirection dir)
 320     {
 321         UINT alignNew;
 322         switch ( dir )
 323         {
 324             default:
 325                 wxFAIL_MSG( "invalid direction" );
 326                 // fall through
 327
 328             case wxLEFT:
 329                 alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
 330                 break;
 331
 332             case wxRIGHT:
 333                 alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
 334                 break;
 335
 336             case wxTOP:
 337                 alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
 338                 break;
 339
 340             case wxBOTTOM:
 341                 alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
 342                 break;
 343         }
 344
 345         if ( alignNew != m_data.uAlign )
 346         {
 347             m_data.uAlign = alignNew;
 348             UpdateImageInfo();
 349         }
 350     }
 351
 352 private:
 353     void UpdateImageInfo()
 354     {
 355         if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
 356         {
 357             wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
 358         }
 359     }
 360
 361     // we store image list separately to be able to use convenient wxImageList
 362     // methods instead of working with raw HIMAGELIST
 363     wxImageList m_iml;
 364
 365     // store the rest of the data in BCM_SETIMAGELIST-friendly form
 366     BUTTON_IMAGELIST m_data;
 367
 368     // the button we're associated with
 369     const HWND m_hwndBtn;
 370
 371
 372     wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
 373 };
 374
 375 #endif // wxUSE_UXTHEME
 376
 377 } // anonymous namespace
 378
 379 // ----------------------------------------------------------------------------
 380 // macros
 381 // ----------------------------------------------------------------------------
 382
 383 // ============================================================================
 384 // implementation
 385 // ============================================================================
 386
 387 // ----------------------------------------------------------------------------
 388 // helper functions from wx/msw/private/button.h
 389 // ----------------------------------------------------------------------------
 390
 391 void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
 392 {
 393     // update BS_MULTILINE style depending on the new label (resetting it
 394     // doesn't seem to do anything very useful but it shouldn't hurt and we do
 395     // have to set it whenever the label becomes multi line as otherwise it
 396     // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
 397     // the control unless it already has new lines in its label)
 398     long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
 399          styleNew;
 400     if ( label.find(wxT('\n')) != wxString::npos )
 401         styleNew = styleOld | BS_MULTILINE;
 402     else
 403         styleNew = styleOld & ~BS_MULTILINE;
 404
 405     if ( styleNew != styleOld )
 406         ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
 407 }
 408
 409 wxSize wxMSWButton::GetFittingSize(wxWindow *win,
 410                                    const wxSize& sizeLabel,
 411                                    int flags)
 412 {
 413     wxSize sizeBtn = sizeLabel;
 414
 415     // FIXME: The numbers here are pure guesswork, no idea how should the
 416     //        button margins be really calculated.
 417     if ( flags & Size_ExactFit )
 418     {
 419         // We still need some margin or the text would be overwritten, just
 420         // make it as small as possible.
 421         sizeBtn.x += (3*win->GetCharWidth());
 422     }
 423     else
 424     {
 425         sizeBtn.x += 3*win->GetCharWidth();
 426         sizeBtn.y += win->GetCharHeight()/2;
 427     }
 428
 429     // account for the shield UAC icon if we have it
 430     if ( flags & Size_AuthNeeded )
 431         sizeBtn.x += wxSystemSettings::GetMetric(wxSYS_SMALLICON_X);
 432
 433     return sizeBtn;
 434 }
 435
 436 wxSize wxMSWButton::ComputeBestFittingSize(wxControl *btn, int flags)
 437 {
 438     wxClientDC dc(btn);
 439
 440     wxSize sizeBtn;
 441     dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
 442
 443     return GetFittingSize(btn, sizeBtn, flags);
 444 }
 445
 446 wxSize wxMSWButton::IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size)
 447 {
 448     wxSize sizeBtn(size);
 449
 450     // The 50x14 button size is documented in the "Recommended sizing and
 451     // spacing" section of MSDN layout article.
 452     //
 453     // Note that we intentionally don't use GetDefaultSize() here, because
 454     // it's inexact -- dialog units depend on this dialog's font.
 455     const wxSize sizeDef = btn->ConvertDialogToPixels(wxSize(50, 14));
 456
 457     // All buttons should have at least the standard size, unless the user
 458     // explicitly wants them to be as small as possible and used wxBU_EXACTFIT
 459     // style to indicate this.
 460     const bool incToStdSize = !btn->HasFlag(wxBU_EXACTFIT);
 461     if ( incToStdSize )
 462     {
 463         if ( sizeBtn.x < sizeDef.x )
 464             sizeBtn.x = sizeDef.x;
 465     }
 466
 467     // Notice that we really want to make all buttons with text label equally
 468     // high, otherwise they look ugly and the existing code using wxBU_EXACTFIT
 469     // only uses it to control width and not height.
 470     if ( incToStdSize || !btn->GetLabel().empty() )
 471     {
 472         if ( sizeBtn.y < sizeDef.y )
 473             sizeBtn.y = sizeDef.y;
 474     }
 475
 476     btn->CacheBestSize(sizeBtn);
 477
 478     return sizeBtn;
 479 }
 480
 481 // ----------------------------------------------------------------------------
 482 // creation/destruction
 483 // ----------------------------------------------------------------------------
 484
 485 wxAnyButton::~wxAnyButton()
 486 {
 487     delete m_imageData;
 488 #if wxUSE_MARKUP
 489     delete m_markupText;
 490 #endif // wxUSE_MARKUP
 491 }
 492
 493 void wxAnyButton::SetLabel(const wxString& label)
 494 {
 495     wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
 496
 497     wxAnyButtonBase::SetLabel(label);
 498
 499 #if wxUSE_MARKUP
 500     // If we have a plain text label, we shouldn't be using markup any longer.
 501     if ( m_markupText )
 502     {
 503         delete m_markupText;
 504         m_markupText = NULL;
 505
 506         // Unfortunately we don't really know whether we can reset the button
 507         // to be non-owner-drawn or not: if we had made it owner-drawn just
 508         // because of a call to SetLabelMarkup(), we could, but not if there
 509         // were [also] calls to Set{Fore,Back}groundColour(). If it's really a
 510         // problem to have button remain owner-drawn forever just because it
 511         // had markup label once, we should record the reason for our current
 512         // owner-drawnness and check it here.
 513     }
 514 #endif // wxUSE_MARKUP
 515 }
 516
 517 // ----------------------------------------------------------------------------
 518 // size management including autosizing
 519 // ----------------------------------------------------------------------------
 520
 521 void wxAnyButton::AdjustForBitmapSize(wxSize &size) const
 522 {
 523     wxCHECK_RET( m_imageData, wxT("shouldn't be called if no image") );
 524
 525     // account for the bitmap size
 526     const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
 527     const wxDirection dirBmp = m_imageData->GetBitmapPosition();
 528     if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
 529     {
 530         size.x += sizeBmp.x;
 531         if ( sizeBmp.y > size.y )
 532             size.y = sizeBmp.y;
 533     }
 534     else // bitmap on top/below the text
 535     {
 536         size.y += sizeBmp.y;
 537         if ( sizeBmp.x > size.x )
 538             size.x = sizeBmp.x;
 539     }
 540
 541     // account for the user-specified margins
 542     size += 2*m_imageData->GetBitmapMargins();
 543
 544     // and also for the margins we always add internally (unless we have no
 545     // border at all in which case the button has exactly the same size as
 546     // bitmap and so no margins should be used)
 547     if ( !HasFlag(wxBORDER_NONE) )
 548     {
 549         int marginH = 0,
 550             marginV = 0;
 551 #if wxUSE_UXTHEME
 552         if ( wxUxThemeEngine::GetIfActive() )
 553         {
 554             wxUxThemeHandle theme(const_cast<wxAnyButton *>(this), L"BUTTON");
 555
 556             MARGINS margins;
 557             wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
 558                                                     BP_PUSHBUTTON,
 559                                                     PBS_NORMAL,
 560                                                     TMT_CONTENTMARGINS,
 561                                                     NULL,
 562                                                     &margins);
 563
 564             // XP doesn't draw themed buttons correctly when the client
 565             // area is smaller than 8x8 - enforce this minimum size for
 566             // small bitmaps
 567             size.IncTo(wxSize(8, 8));
 568
 569             marginH = margins.cxLeftWidth + margins.cxRightWidth
 570                         + 2*XP_BUTTON_EXTRA_MARGIN;
 571             marginV = margins.cyTopHeight + margins.cyBottomHeight
 572                         + 2*XP_BUTTON_EXTRA_MARGIN;
 573         }
 574         else
 575 #endif // wxUSE_UXTHEME
 576         {
 577             marginH =
 578             marginV = OD_BUTTON_MARGIN;
 579         }
 580
 581         size.IncBy(marginH, marginV);
 582     }
 583 }
 584
 585 wxSize wxAnyButton::DoGetBestSize() const
 586 {
 587     wxAnyButton * const self = const_cast<wxAnyButton *>(this);
 588
 589     wxSize size;
 590
 591     // Account for the text part if we have it.
 592     if ( ShowsLabel() )
 593     {
 594         int flags = 0;
 595         if ( HasFlag(wxBU_EXACTFIT) )
 596             flags |= wxMSWButton::Size_ExactFit;
 597         if ( DoGetAuthNeeded() )
 598             flags |= wxMSWButton::Size_AuthNeeded;
 599
 600 #if wxUSE_MARKUP
 601         if ( m_markupText )
 602         {
 603             wxClientDC dc(self);
 604             size = wxMSWButton::GetFittingSize(self,
 605                                                m_markupText->Measure(dc),
 606                                                flags);
 607         }
 608         else // Normal plain text (but possibly multiline) label.
 609 #endif // wxUSE_MARKUP
 610         {
 611             size = wxMSWButton::ComputeBestFittingSize(self, flags);
 612         }
 613     }
 614
 615     if ( m_imageData )
 616         AdjustForBitmapSize(size);
 617
 618     return wxMSWButton::IncreaseToStdSizeAndCache(self, size);
 619 }
 620
 621 // ----------------------------------------------------------------------------
 622 // event/message handlers
 623 // ----------------------------------------------------------------------------
 624
 625 WXLRESULT wxAnyButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 626 {
 627     if ( nMsg == WM_LBUTTONDBLCLK )
 628     {
 629         // emulate a click event to force an owner-drawn button to change its
 630         // appearance - without this, it won't do it
 631         (void)wxControl::MSWWindowProc(WM_LBUTTONDOWN, wParam, lParam);
 632
 633         // and continue with processing the message normally as well
 634     }
 635 #if wxUSE_UXTHEME
 636     else if ( nMsg == WM_THEMECHANGED )
 637     {
 638         // need to recalculate the best size here
 639         // as the theme size might have changed
 640         InvalidateBestSize();
 641     }
 642 #endif // wxUSE_UXTHEME
 643     // must use m_mouseInWindow here instead of IsMouseInWindow()
 644     // since we need to know the first time the mouse enters the window
 645     // and IsMouseInWindow() would return true in this case
 646     else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
 647                 nMsg == WM_MOUSELEAVE )
 648     {
 649         if (
 650                 IsEnabled() &&
 651                 (
 652 #if wxUSE_UXTHEME
 653                 wxUxThemeEngine::GetIfActive() ||
 654 #endif // wxUSE_UXTHEME
 655                  (m_imageData && m_imageData->GetBitmap(State_Current).IsOk())
 656                 )
 657            )
 658         {
 659             Refresh();
 660         }
 661     }
 662
 663     // let the base class do all real processing
 664     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 665 }
 666
 667 // ----------------------------------------------------------------------------
 668 // button images
 669 // ----------------------------------------------------------------------------
 670
 671 wxBitmap wxAnyButton::DoGetBitmap(State which) const
 672 {
 673     return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
 674 }
 675
 676 void wxAnyButton::DoSetBitmap(const wxBitmap& bitmap, State which)
 677 {
 678 #if wxUSE_UXTHEME
 679     wxXPButtonImageData *oldData = NULL;
 680 #endif // wxUSE_UXTHEME
 681
 682     // Check if we already had bitmaps of different size.
 683     if ( m_imageData &&
 684           bitmap.GetSize() != m_imageData->GetBitmap(State_Normal).GetSize() )
 685     {
 686         wxASSERT_MSG( (which == State_Normal) || bitmap.IsNull(),
 687                       "Must set normal bitmap with the new size first" );
 688
 689 #if wxUSE_UXTHEME
 690         if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
 691         {
 692             // We can't change the size of the images stored in wxImageList
 693             // in wxXPButtonImageData::m_iml so force recreating it below but
 694             // keep the current data to copy its values into the new one.
 695             oldData = static_cast<wxXPButtonImageData *>(m_imageData);
 696             m_imageData = NULL;
 697         }
 698 #endif // wxUSE_UXTHEME
 699         //else: wxODButtonImageData doesn't require anything special
 700     }
 701
 702     // allocate the image data when the first bitmap is set
 703     if ( !m_imageData )
 704     {
 705 #if wxUSE_UXTHEME
 706         // using image list doesn't work correctly if we don't have any label
 707         // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
 708         // BS_BITMAP style), at least under Windows 2003 so use owner drawn
 709         // strategy for bitmap-only buttons
 710         if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
 711         {
 712             m_imageData = new wxXPButtonImageData(this, bitmap);
 713
 714             if ( oldData )
 715             {
 716                 // Preserve the old values in case the user changed them.
 717                 m_imageData->SetBitmapPosition(oldData->GetBitmapPosition());
 718
 719                 const wxSize oldMargins = oldData->GetBitmapMargins();
 720                 m_imageData->SetBitmapMargins(oldMargins.x, oldMargins.y);
 721
 722                 // No need to preserve the bitmaps though as they were of wrong
 723                 // size anyhow.
 724
 725                 delete oldData;
 726             }
 727         }
 728         else
 729 #endif // wxUSE_UXTHEME
 730         {
 731             m_imageData = new wxODButtonImageData(this, bitmap);
 732             MakeOwnerDrawn();
 733         }
 734     }
 735     else
 736     {
 737         m_imageData->SetBitmap(bitmap, which);
 738     }
 739
 740     // it should be enough to only invalidate the best size when the normal
 741     // bitmap changes as all bitmaps assigned to the button should be of the
 742     // same size anyhow
 743     if ( which == State_Normal )
 744         InvalidateBestSize();
 745
 746     Refresh();
 747 }
 748
 749 wxSize wxAnyButton::DoGetBitmapMargins() const
 750 {
 751     return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
 752 }
 753
 754 void wxAnyButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
 755 {
 756     wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
 757
 758     m_imageData->SetBitmapMargins(x, y);
 759     InvalidateBestSize();
 760 }
 761
 762 void wxAnyButton::DoSetBitmapPosition(wxDirection dir)
 763 {
 764     wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
 765
 766     m_imageData->SetBitmapPosition(dir);
 767     InvalidateBestSize();
 768 }
 769
 770 // ----------------------------------------------------------------------------
 771 // markup support
 772 // ----------------------------------------------------------------------------
 773
 774 #if wxUSE_MARKUP
 775
 776 bool wxAnyButton::DoSetLabelMarkup(const wxString& markup)
 777 {
 778     if ( !wxAnyButtonBase::DoSetLabelMarkup(markup) )
 779         return false;
 780
 781     if ( !m_markupText )
 782     {
 783         m_markupText = new wxMarkupText(markup);
 784         MakeOwnerDrawn();
 785     }
 786     else
 787     {
 788         // We are already owner-drawn so just update the text.
 789         m_markupText->SetMarkup(markup);
 790     }
 791
 792     Refresh();
 793
 794     return true;
 795 }
 796
 797 #endif // wxUSE_MARKUP
 798
 799 // ----------------------------------------------------------------------------
 800 // owner-drawn buttons support
 801 // ----------------------------------------------------------------------------
 802
 803 // drawing helpers
 804 namespace
 805 {
 806
 807 // return the button state using both the ODS_XXX flags specified in state
 808 // parameter and the current button state
 809 wxAnyButton::State GetButtonState(wxAnyButton *btn, UINT state)
 810 {
 811     if ( state & ODS_DISABLED )
 812         return wxAnyButton::State_Disabled;
 813
 814     if ( state & ODS_SELECTED )
 815         return wxAnyButton::State_Pressed;
 816
 817     if ( btn->HasCapture() || btn->IsMouseInWindow() )
 818         return wxAnyButton::State_Current;
 819
 820     if ( state & ODS_FOCUS )
 821         return wxAnyButton::State_Focused;
 822
 823     return btn->GetNormalState();
 824 }
 825
 826 void DrawButtonText(HDC hdc,
 827                     RECT *pRect,
 828                     wxAnyButton *btn,
 829                     int flags)
 830 {
 831     const wxString text = btn->GetLabel();
 832
 833     if ( text.find(wxT('\n')) != wxString::npos )
 834     {
 835         // draw multiline label
 836
 837         // center text horizontally in any case
 838         flags |= DT_CENTER;
 839
 840         // first we need to compute its bounding rect
 841         RECT rc;
 842         ::CopyRect(&rc, pRect);
 843         ::DrawText(hdc, text.t_str(), text.length(), &rc,
 844                    DT_CENTER | DT_CALCRECT);
 845
 846         // now center this rect inside the entire button area
 847         const LONG w = rc.right - rc.left;
 848         const LONG h = rc.bottom - rc.top;
 849         rc.left = pRect->left + (pRect->right - pRect->left)/2 - w/2;
 850         rc.right = rc.left+w;
 851         rc.top = pRect->top + (pRect->bottom - pRect->top)/2 - h/2;
 852         rc.bottom = rc.top+h;
 853
 854         ::DrawText(hdc, text.t_str(), text.length(), &rc, flags);
 855     }
 856     else // single line label
 857     {
 858         // translate wx button flags to alignment flags for DrawText()
 859         if ( btn->HasFlag(wxBU_RIGHT) )
 860         {
 861             flags |= DT_RIGHT;
 862         }
 863         else if ( !btn->HasFlag(wxBU_LEFT) )
 864         {
 865             flags |= DT_CENTER;
 866         }
 867         //else: DT_LEFT is the default anyhow (and its value is 0 too)
 868
 869         if ( btn->HasFlag(wxBU_BOTTOM) )
 870         {
 871             flags |= DT_BOTTOM;
 872         }
 873         else if ( !btn->HasFlag(wxBU_TOP) )
 874         {
 875             flags |= DT_VCENTER;
 876         }
 877         //else: as above, DT_TOP is the default
 878
 879         // notice that we must have DT_SINGLELINE for vertical alignment flags
 880         // to work
 881         ::DrawText(hdc, text.t_str(), text.length(), pRect,
 882                    flags | DT_SINGLELINE );
 883     }
 884 }
 885
 886 void DrawRect(HDC hdc, const RECT& r)
 887 {
 888     wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 889     wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
 890     wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
 891     wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 892 }
 893
 894 /*
 895    The button frame looks like this normally:
 896
 897    WWWWWWWWWWWWWWWWWWB
 898    WHHHHHHHHHHHHHHHHGB  W = white       (HILIGHT)
 899    WH               GB  H = light grey  (LIGHT)
 900    WH               GB  G = dark grey   (SHADOW)
 901    WH               GB  B = black       (DKSHADOW)
 902    WH               GB
 903    WGGGGGGGGGGGGGGGGGB
 904    BBBBBBBBBBBBBBBBBBB
 905
 906    When the button is selected, the button becomes like this (the total button
 907    size doesn't change):
 908
 909    BBBBBBBBBBBBBBBBBBB
 910    BWWWWWWWWWWWWWWWWBB
 911    BWHHHHHHHHHHHHHHGBB
 912    BWH             GBB
 913    BWH             GBB
 914    BWGGGGGGGGGGGGGGGBB
 915    BBBBBBBBBBBBBBBBBBB
 916    BBBBBBBBBBBBBBBBBBB
 917
 918    When the button is pushed (while selected) it is like:
 919
 920    BBBBBBBBBBBBBBBBBBB
 921    BGGGGGGGGGGGGGGGGGB
 922    BG               GB
 923    BG               GB
 924    BG               GB
 925    BG               GB
 926    BGGGGGGGGGGGGGGGGGB
 927    BBBBBBBBBBBBBBBBBBB
 928 */
 929 void DrawButtonFrame(HDC hdc, RECT& rectBtn,
 930                      bool selected, bool pushed)
 931 {
 932     RECT r;
 933     CopyRect(&r, &rectBtn);
 934
 935     AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
 936              hpenGrey(GetSysColor(COLOR_3DSHADOW)),
 937              hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
 938              hpenWhite(GetSysColor(COLOR_3DHILIGHT));
 939
 940     SelectInHDC selectPen(hdc, hpenBlack);
 941
 942     r.right--;
 943     r.bottom--;
 944
 945     if ( pushed )
 946     {
 947         DrawRect(hdc, r);
 948
 949         (void)SelectObject(hdc, hpenGrey);
 950         ::InflateRect(&r, -1, -1);
 951
 952         DrawRect(hdc, r);
 953     }
 954     else // !pushed
 955     {
 956         if ( selected )
 957         {
 958             DrawRect(hdc, r);
 959
 960             ::InflateRect(&r, -1, -1);
 961         }
 962
 963         wxDrawLine(hdc, r.left, r.bottom, r.right, r.bottom);
 964         wxDrawLine(hdc, r.right, r.bottom, r.right, r.top - 1);
 965
 966         (void)SelectObject(hdc, hpenWhite);
 967         wxDrawLine(hdc, r.left, r.bottom - 1, r.left, r.top);
 968         wxDrawLine(hdc, r.left, r.top, r.right, r.top);
 969
 970         (void)SelectObject(hdc, hpenLightGr);
 971         wxDrawLine(hdc, r.left + 1, r.bottom - 2, r.left + 1, r.top + 1);
 972         wxDrawLine(hdc, r.left + 1, r.top + 1, r.right - 1, r.top + 1);
 973
 974         (void)SelectObject(hdc, hpenGrey);
 975         wxDrawLine(hdc, r.left + 1, r.bottom - 1, r.right - 1, r.bottom - 1);
 976         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
 977     }
 978
 979     InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
 980 }
 981
 982 #if wxUSE_UXTHEME
 983 void DrawXPBackground(wxAnyButton *button, HDC hdc, RECT& rectBtn, UINT state)
 984 {
 985     wxUxThemeHandle theme(button, L"BUTTON");
 986
 987     // this array is indexed by wxAnyButton::State values and so must be kept in
 988     // sync with it
 989     static const int uxStates[] =
 990     {
 991         PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
 992     };
 993
 994     int iState = uxStates[GetButtonState(button, state)];
 995
 996     wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
 997
 998     // draw parent background if needed
 999     if ( engine->IsThemeBackgroundPartiallyTransparent
1000                  (
1001                     theme,
1002                     BP_PUSHBUTTON,
1003                     iState
1004                  ) )
1005     {
1006         // Set this button as the one whose background is being erased: this
1007         // allows our WM_ERASEBKGND handler used by DrawThemeParentBackground()
1008         // to correctly align the background brush with this window instead of
1009         // the parent window to which WM_ERASEBKGND is sent. Notice that this
1010         // doesn't work with custom user-defined EVT_ERASE_BACKGROUND handlers
1011         // as they won't be aligned but unfortunately all the attempts to fix
1012         // it by shifting DC origin before calling DrawThemeParentBackground()
1013         // failed to work so we at least do this, even though this is far from
1014         // being the perfect solution.
1015         wxWindowBeingErased = button;
1016
1017         engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
1018
1019         wxWindowBeingErased = NULL;
1020     }
1021
1022     // draw background
1023     engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
1024                                 &rectBtn, NULL);
1025
1026     // calculate content area margins
1027     MARGINS margins;
1028     engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
1029                             TMT_CONTENTMARGINS, &rectBtn, &margins);
1030     ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
1031     ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
1032
1033     if ( button->UseBgCol() )
1034     {
1035         COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
1036         AutoHBRUSH hbrushBackground(colBg);
1037
1038         // don't overwrite the focus rect
1039         RECT rectClient;
1040         ::CopyRect(&rectClient, &rectBtn);
1041         ::InflateRect(&rectClient, -1, -1);
1042         FillRect(hdc, &rectClient, hbrushBackground);
1043     }
1044 }
1045 #endif // wxUSE_UXTHEME
1046
1047 } // anonymous namespace
1048
1049 // ----------------------------------------------------------------------------
1050 // owner drawn buttons support
1051 // ----------------------------------------------------------------------------
1052
1053 void wxAnyButton::MakeOwnerDrawn()
1054 {
1055     if ( !IsOwnerDrawn() )
1056     {
1057         // make it so
1058         // note that BS_OWNERDRAW is not independent from other style bits
1059         long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1060         style &= ~(BS_3STATE | BS_AUTO3STATE | BS_AUTOCHECKBOX | BS_AUTORADIOBUTTON | BS_CHECKBOX | BS_DEFPUSHBUTTON | BS_GROUPBOX | BS_PUSHBUTTON | BS_RADIOBUTTON | BS_PUSHLIKE);
1061         style |= BS_OWNERDRAW;
1062         SetWindowLong(GetHwnd(), GWL_STYLE, style);
1063     }
1064 }
1065
1066 bool wxAnyButton::IsOwnerDrawn() const
1067 {
1068     long style = GetWindowLong(GetHwnd(), GWL_STYLE);
1069     return ( (style & BS_OWNERDRAW) == BS_OWNERDRAW );
1070 }
1071
1072 bool wxAnyButton::SetBackgroundColour(const wxColour &colour)
1073 {
1074     if ( !wxControl::SetBackgroundColour(colour) )
1075     {
1076         // nothing to do
1077         return false;
1078     }
1079
1080     MakeOwnerDrawn();
1081
1082     Refresh();
1083
1084     return true;
1085 }
1086
1087 bool wxAnyButton::SetForegroundColour(const wxColour &colour)
1088 {
1089     if ( !wxControl::SetForegroundColour(colour) )
1090     {
1091         // nothing to do
1092         return false;
1093     }
1094
1095     MakeOwnerDrawn();
1096
1097     Refresh();
1098
1099     return true;
1100 }
1101
1102 bool wxAnyButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
1103 {
1104     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
1105     HDC hdc = lpDIS->hDC;
1106
1107     UINT state = lpDIS->itemState;
1108     switch ( GetButtonState(this, state) )
1109     {
1110         case State_Disabled:
1111             state |= ODS_DISABLED;
1112             break;
1113         case State_Pressed:
1114             state |= ODS_SELECTED;
1115             break;
1116         case State_Focused:
1117             state |= ODS_FOCUS;
1118             break;
1119         default:
1120             break;
1121     }
1122
1123     bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
1124
1125     RECT rectBtn;
1126     CopyRect(&rectBtn, &lpDIS->rcItem);
1127
1128     // draw the button background
1129     if ( !HasFlag(wxBORDER_NONE) )
1130     {
1131 #if wxUSE_UXTHEME
1132         if ( wxUxThemeEngine::GetIfActive() )
1133         {
1134             DrawXPBackground(this, hdc, rectBtn, state);
1135         }
1136         else
1137 #endif // wxUSE_UXTHEME
1138         {
1139             COLORREF colBg = wxColourToRGB(GetBackgroundColour());
1140
1141             // first, draw the background
1142             AutoHBRUSH hbrushBackground(colBg);
1143             FillRect(hdc, &rectBtn, hbrushBackground);
1144
1145             // draw the border for the current state
1146             bool selected = (state & ODS_SELECTED) != 0;
1147             if ( !selected )
1148             {
1149                 wxTopLevelWindow *
1150                     tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
1151                 if ( tlw )
1152                 {
1153                     selected = tlw->GetDefaultItem() == this;
1154                 }
1155             }
1156
1157             DrawButtonFrame(hdc, rectBtn, selected, pushed);
1158         }
1159
1160         // draw the focus rectangle if we need it
1161         if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
1162         {
1163             DrawFocusRect(hdc, &rectBtn);
1164
1165 #if wxUSE_UXTHEME
1166             if ( !wxUxThemeEngine::GetIfActive() )
1167 #endif // wxUSE_UXTHEME
1168             {
1169                 if ( pushed )
1170                 {
1171                     // the label is shifted by 1 pixel to create "pushed" effect
1172                     OffsetRect(&rectBtn, 1, 1);
1173                 }
1174             }
1175         }
1176     }
1177
1178
1179     // draw the image, if any
1180     if ( m_imageData )
1181     {
1182         wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
1183         if ( !bmp.IsOk() )
1184             bmp = m_imageData->GetBitmap(State_Normal);
1185
1186         const wxSize sizeBmp = bmp.GetSize();
1187         const wxSize margin = m_imageData->GetBitmapMargins();
1188         const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
1189         wxRect rectButton(wxRectFromRECT(rectBtn));
1190
1191         // for simplicity, we start with centred rectangle and then move it to
1192         // the appropriate edge
1193         wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
1194
1195         // move bitmap only if we have a label, otherwise keep it centered
1196         if ( ShowsLabel() )
1197         {
1198             switch ( m_imageData->GetBitmapPosition() )
1199             {
1200                 default:
1201                     wxFAIL_MSG( "invalid direction" );
1202                     // fall through
1203
1204                 case wxLEFT:
1205                     rectBitmap.x = rectButton.x + margin.x;
1206                     rectButton.x += sizeBmpWithMargins.x;
1207                     rectButton.width -= sizeBmpWithMargins.x;
1208                     break;
1209
1210                 case wxRIGHT:
1211                     rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
1212                     rectButton.width -= sizeBmpWithMargins.x;
1213                     break;
1214
1215                 case wxTOP:
1216                     rectBitmap.y = rectButton.y + margin.y;
1217                     rectButton.y += sizeBmpWithMargins.y;
1218                     rectButton.height -= sizeBmpWithMargins.y;
1219                     break;
1220
1221                 case wxBOTTOM:
1222                     rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
1223                     rectButton.height -= sizeBmpWithMargins.y;
1224                     break;
1225             }
1226         }
1227
1228         wxDCTemp dst((WXHDC)hdc);
1229         dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
1230
1231         wxCopyRectToRECT(rectButton, rectBtn);
1232     }
1233
1234
1235     // finally draw the label
1236     if ( ShowsLabel() )
1237     {
1238         COLORREF colFg = state & ODS_DISABLED
1239                             ? ::GetSysColor(COLOR_GRAYTEXT)
1240                             : wxColourToRGB(GetForegroundColour());
1241
1242         wxTextColoursChanger changeFg(hdc, colFg, CLR_INVALID);
1243         wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
1244
1245 #if wxUSE_MARKUP
1246         if ( m_markupText )
1247         {
1248             wxDCTemp dc((WXHDC)hdc);
1249             dc.SetTextForeground(wxColour(colFg));
1250             dc.SetFont(GetFont());
1251
1252             m_markupText->Render(dc, wxRectFromRECT(rectBtn),
1253                                  state & ODS_NOACCEL
1254                                     ? wxMarkupText::Render_Default
1255                                     : wxMarkupText::Render_ShowAccels);
1256         }
1257         else // Plain text label
1258 #endif // wxUSE_MARKUP
1259         {
1260             // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
1261             // systems but by happy coincidence ODS_NOACCEL is not used under
1262             // them neither so DT_HIDEPREFIX should never be used there
1263             DrawButtonText(hdc, &rectBtn, this,
1264                            state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
1265         }
1266     }
1267
1268     return true;
1269 }
1270
1271 #endif // wxHAS_ANY_BUTTON