]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/button.cpp
No code changes, fixed some typos.
[wxWidgets.git] / src / msw / button.cpp
index e970d5a6fb000c84707bcd08ece707edc7e88663..10bb135fb5c71fd46515a2427ccd58765483e146 100644 (file)
     #include "wx/dcscreen.h"
     #include "wx/dcclient.h"
     #include "wx/toplevel.h"
     #include "wx/dcscreen.h"
     #include "wx/dcclient.h"
     #include "wx/toplevel.h"
+    #include "wx/msw/wrapcctl.h"
+    #include "wx/msw/private.h"
+    #include "wx/msw/missing.h"
 #endif
 
 #endif
 
+#include "wx/imaglist.h"
 #include "wx/stockitem.h"
 #include "wx/stockitem.h"
-#include "wx/msw/private.h"
 #include "wx/msw/private/button.h"
 #include "wx/msw/private/button.h"
+#include "wx/msw/private/dc.h"
+#include "wx/private/window.h"
+
+#if wxUSE_MARKUP
+    #include "wx/generic/private/markuptext.h"
+#endif // wxUSE_MARKUP
+
+using namespace wxMSWImpl;
 
 #if wxUSE_UXTHEME
     #include "wx/msw/uxtheme.h"
 
 #if wxUSE_UXTHEME
     #include "wx/msw/uxtheme.h"
 
         #define TMT_CONTENTMARGINS 3602
     #endif
 
         #define TMT_CONTENTMARGINS 3602
     #endif
+
+    // provide the necessary declarations ourselves if they're missing from
+    // headers
+    #ifndef BCM_SETIMAGELIST
+        #define BCM_SETIMAGELIST    0x1602
+        #define BCM_SETTEXTMARGIN   0x1604
+
+        enum
+        {
+            BUTTON_IMAGELIST_ALIGN_LEFT,
+            BUTTON_IMAGELIST_ALIGN_RIGHT,
+            BUTTON_IMAGELIST_ALIGN_TOP,
+            BUTTON_IMAGELIST_ALIGN_BOTTOM
+        };
+
+        struct BUTTON_IMAGELIST
+        {
+            HIMAGELIST himl;
+            RECT margin;
+            UINT uAlign;
+        };
+    #endif
 #endif // wxUSE_UXTHEME
 
 #ifndef WM_THEMECHANGED
 #endif // wxUSE_UXTHEME
 
 #ifndef WM_THEMECHANGED
     #define ODS_NOFOCUSRECT     0x0200
 #endif
 
     #define ODS_NOFOCUSRECT     0x0200
 #endif
 
+#ifndef DT_HIDEPREFIX
+    #define DT_HIDEPREFIX       0x00100000
+#endif
+
+// set the value for BCM_SETSHIELD (for the UAC shield) if it's not defined in
+// the header
+#ifndef BCM_SETSHIELD
+    #define BCM_SETSHIELD       0x160c
+#endif
+
+#if wxUSE_UXTHEME
+extern wxWindowMSW *wxWindowBeingErased; // From src/msw/window.cpp
+#endif // wxUSE_UXTHEME
+
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// macros
+// button image data
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-#if wxUSE_EXTENDED_RTTI
+// we use different data classes for owner drawn buttons and for themed XP ones
+
+class wxButtonImageData
+{
+public:
+    wxButtonImageData() { }
+    virtual ~wxButtonImageData() { }
+
+    virtual wxBitmap GetBitmap(wxButton::State which) const = 0;
+    virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which) = 0;
+
+    virtual wxSize GetBitmapMargins() const = 0;
+    virtual void SetBitmapMargins(wxCoord x, wxCoord y) = 0;
+
+    virtual wxDirection GetBitmapPosition() const = 0;
+    virtual void SetBitmapPosition(wxDirection dir) = 0;
+
+private:
+    wxDECLARE_NO_COPY_CLASS(wxButtonImageData);
+};
+
+namespace
+{
+
+// the gap between button edge and the interior area used by Windows for the
+// standard buttons
+const int OD_BUTTON_MARGIN = 4;
+
+class wxODButtonImageData : public wxButtonImageData
+{
+public:
+    wxODButtonImageData(wxButton *btn, const wxBitmap& bitmap)
+    {
+        SetBitmap(bitmap, wxButton::State_Normal);
+        SetBitmap(bitmap.ConvertToDisabled(), wxButton::State_Disabled);
+
+        m_dir = wxLEFT;
 
 
-WX_DEFINE_FLAGS( wxButtonStyle )
+        // we use margins when we have both bitmap and text, but when we have
+        // only the bitmap it should take up the entire button area
+        if ( btn->ShowsLabel() )
+        {
+            m_margin.x = btn->GetCharWidth();
+            m_margin.y = btn->GetCharHeight() / 2;
+        }
+    }
 
 
-wxBEGIN_FLAGS( wxButtonStyle )
-    // new style border flags, we put them first to
-    // use them for streaming out
-    wxFLAGS_MEMBER(wxBORDER_SIMPLE)
-    wxFLAGS_MEMBER(wxBORDER_SUNKEN)
-    wxFLAGS_MEMBER(wxBORDER_DOUBLE)
-    wxFLAGS_MEMBER(wxBORDER_RAISED)
-    wxFLAGS_MEMBER(wxBORDER_STATIC)
-    wxFLAGS_MEMBER(wxBORDER_NONE)
+    virtual wxBitmap GetBitmap(wxButton::State which) const
+    {
+        return m_bitmaps[which];
+    }
 
 
-    // old style border flags
-    wxFLAGS_MEMBER(wxSIMPLE_BORDER)
-    wxFLAGS_MEMBER(wxSUNKEN_BORDER)
-    wxFLAGS_MEMBER(wxDOUBLE_BORDER)
-    wxFLAGS_MEMBER(wxRAISED_BORDER)
-    wxFLAGS_MEMBER(wxSTATIC_BORDER)
-    wxFLAGS_MEMBER(wxBORDER)
+    virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
+    {
+        m_bitmaps[which] = bitmap;
+    }
 
 
-    // standard window styles
-    wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
-    wxFLAGS_MEMBER(wxCLIP_CHILDREN)
-    wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
-    wxFLAGS_MEMBER(wxWANTS_CHARS)
-    wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
-    wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
-    wxFLAGS_MEMBER(wxVSCROLL)
-    wxFLAGS_MEMBER(wxHSCROLL)
+    virtual wxSize GetBitmapMargins() const
+    {
+        return m_margin;
+    }
 
 
-    wxFLAGS_MEMBER(wxBU_LEFT)
-    wxFLAGS_MEMBER(wxBU_RIGHT)
-    wxFLAGS_MEMBER(wxBU_TOP)
-    wxFLAGS_MEMBER(wxBU_BOTTOM)
-    wxFLAGS_MEMBER(wxBU_EXACTFIT)
-wxEND_FLAGS( wxButtonStyle )
+    virtual void SetBitmapMargins(wxCoord x, wxCoord y)
+    {
+        m_margin = wxSize(x, y);
+    }
 
 
-IMPLEMENT_DYNAMIC_CLASS_XTI(wxButton, wxControl,"wx/button.h")
+    virtual wxDirection GetBitmapPosition() const
+    {
+        return m_dir;
+    }
 
 
-wxBEGIN_PROPERTIES_TABLE(wxButton)
-    wxEVENT_PROPERTY( Click , wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEvent)
+    virtual void SetBitmapPosition(wxDirection dir)
+    {
+        m_dir = dir;
+    }
 
 
-    wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
-    wxPROPERTY( Label, wxString , SetLabel, GetLabel, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
+private:
+    // just store the values passed to us to be able to retrieve them later
+    // from the drawing code
+    wxBitmap m_bitmaps[wxButton::State_Max];
+    wxSize m_margin;
+    wxDirection m_dir;
 
 
-    wxPROPERTY_FLAGS( WindowStyle , wxButtonStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
+    wxDECLARE_NO_COPY_CLASS(wxODButtonImageData);
+};
 
 
-wxEND_PROPERTIES_TABLE()
+#if wxUSE_UXTHEME
 
 
-wxBEGIN_HANDLERS_TABLE(wxButton)
-wxEND_HANDLERS_TABLE()
+// somehow the margin is one pixel greater than the value returned by
+// GetThemeMargins() call
+const int XP_BUTTON_EXTRA_MARGIN = 1;
 
 
-wxCONSTRUCTOR_6( wxButton , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle  )
+class wxXPButtonImageData : public wxButtonImageData
+{
+public:
+    // we must be constructed with the size of our images as we need to create
+    // the image list
+    wxXPButtonImageData(wxButton *btn, const wxBitmap& bitmap)
+        : m_iml(bitmap.GetWidth(), bitmap.GetHeight(), true /* use mask */,
+                wxButton::State_Max),
+          m_hwndBtn(GetHwndOf(btn))
+    {
+        // initialize all bitmaps except for the disabled one to normal state
+        for ( int n = 0; n < wxButton::State_Max; n++ )
+        {
+            m_iml.Add(n == wxButton::State_Disabled ? bitmap.ConvertToDisabled()
+                                                    : bitmap);
+        }
 
 
+        m_data.himl = GetHimagelistOf(&m_iml);
 
 
-#else
-IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
-#endif
+        // no margins by default
+        m_data.margin.left =
+        m_data.margin.right =
+        m_data.margin.top =
+        m_data.margin.bottom = 0;
+
+        // use default alignment
+        m_data.uAlign = BUTTON_IMAGELIST_ALIGN_LEFT;
+
+        UpdateImageInfo();
+    }
+
+    virtual wxBitmap GetBitmap(wxButton::State which) const
+    {
+        return m_iml.GetBitmap(which);
+    }
+
+    virtual void SetBitmap(const wxBitmap& bitmap, wxButton::State which)
+    {
+        m_iml.Replace(which, bitmap);
+
+        UpdateImageInfo();
+    }
+
+    virtual wxSize GetBitmapMargins() const
+    {
+        return wxSize(m_data.margin.left, m_data.margin.top);
+    }
+
+    virtual void SetBitmapMargins(wxCoord x, wxCoord y)
+    {
+        RECT& margin = m_data.margin;
+        margin.left =
+        margin.right = x;
+        margin.top =
+        margin.bottom = y;
+
+        if ( !::SendMessage(m_hwndBtn, BCM_SETTEXTMARGIN, 0, (LPARAM)&margin) )
+        {
+            wxLogDebug("SendMessage(BCM_SETTEXTMARGIN) failed");
+        }
+    }
+
+    virtual wxDirection GetBitmapPosition() const
+    {
+        switch ( m_data.uAlign )
+        {
+            default:
+                wxFAIL_MSG( "invalid image alignment" );
+                // fall through
+
+            case BUTTON_IMAGELIST_ALIGN_LEFT:
+                return wxLEFT;
+
+            case BUTTON_IMAGELIST_ALIGN_RIGHT:
+                return wxRIGHT;
+
+            case BUTTON_IMAGELIST_ALIGN_TOP:
+                return wxTOP;
+
+            case BUTTON_IMAGELIST_ALIGN_BOTTOM:
+                return wxBOTTOM;
+        }
+    }
+
+    virtual void SetBitmapPosition(wxDirection dir)
+    {
+        UINT alignNew;
+        switch ( dir )
+        {
+            default:
+                wxFAIL_MSG( "invalid direction" );
+                // fall through
+
+            case wxLEFT:
+                alignNew = BUTTON_IMAGELIST_ALIGN_LEFT;
+                break;
+
+            case wxRIGHT:
+                alignNew = BUTTON_IMAGELIST_ALIGN_RIGHT;
+                break;
+
+            case wxTOP:
+                alignNew = BUTTON_IMAGELIST_ALIGN_TOP;
+                break;
+
+            case wxBOTTOM:
+                alignNew = BUTTON_IMAGELIST_ALIGN_BOTTOM;
+                break;
+        }
+
+        if ( alignNew != m_data.uAlign )
+        {
+            m_data.uAlign = alignNew;
+            UpdateImageInfo();
+        }
+    }
+
+private:
+    void UpdateImageInfo()
+    {
+        if ( !::SendMessage(m_hwndBtn, BCM_SETIMAGELIST, 0, (LPARAM)&m_data) )
+        {
+            wxLogDebug("SendMessage(BCM_SETIMAGELIST) failed");
+        }
+    }
+
+    // we store image list separately to be able to use convenient wxImageList
+    // methods instead of working with raw HIMAGELIST
+    wxImageList m_iml;
+
+    // store the rest of the data in BCM_SETIMAGELIST-friendly form
+    BUTTON_IMAGELIST m_data;
+
+    // the button we're associated with
+    const HWND m_hwndBtn;
+
+
+    wxDECLARE_NO_COPY_CLASS(wxXPButtonImageData);
+};
+
+#endif // wxUSE_UXTHEME
+
+} // anonymous namespace
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 
 // ============================================================================
 // implementation
 // ============================================================================
 
+// ----------------------------------------------------------------------------
+// helper functions from wx/msw/private/button.h
+// ----------------------------------------------------------------------------
+
+void wxMSWButton::UpdateMultilineStyle(HWND hwnd, const wxString& label)
+{
+    // update BS_MULTILINE style depending on the new label (resetting it
+    // doesn't seem to do anything very useful but it shouldn't hurt and we do
+    // have to set it whenever the label becomes multi line as otherwise it
+    // wouldn't be shown correctly as we don't use BS_MULTILINE when creating
+    // the control unless it already has new lines in its label)
+    long styleOld = ::GetWindowLong(hwnd, GWL_STYLE),
+         styleNew;
+    if ( label.find(wxT('\n')) != wxString::npos )
+        styleNew = styleOld | BS_MULTILINE;
+    else
+        styleNew = styleOld & ~BS_MULTILINE;
+
+    if ( styleNew != styleOld )
+        ::SetWindowLong(hwnd, GWL_STYLE, styleNew);
+}
+
+wxSize wxMSWButton::GetFittingSize(wxWindow *win,
+                                   const wxSize& sizeLabel,
+                                   int flags)
+{
+    // FIXME: this is pure guesswork, need to retrieve the real button margins
+    wxSize sizeBtn = sizeLabel;
+
+    sizeBtn.x += 3*win->GetCharWidth();
+    sizeBtn.y += win->GetCharHeight()/2;
+
+    // account for the shield UAC icon if we have it
+    if ( flags & Size_AuthNeeded )
+        sizeBtn.x += wxSystemSettings::GetMetric(wxSYS_SMALLICON_X);
+
+    return sizeBtn;
+}
+
+wxSize wxMSWButton::ComputeBestFittingSize(wxControl *btn, int flags)
+{
+    wxClientDC dc(btn);
+
+    wxSize sizeBtn;
+    dc.GetMultiLineTextExtent(btn->GetLabelText(), &sizeBtn.x, &sizeBtn.y);
+
+    return GetFittingSize(btn, sizeBtn, flags);
+}
+
+wxSize wxMSWButton::IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size)
+{
+    wxSize sizeBtn(size);
+
+    // All buttons have at least the standard height and, unless the user
+    // explicitly wants them to be as small as possible and used wxBU_EXACTFIT
+    // style to indicate this, of at least the standard width too.
+    //
+    // Notice that we really want to make all buttons equally high, otherwise
+    // they look ugly and the existing code using wxBU_EXACTFIT only uses it to
+    // control width and not height.
+
+    // The 50x14 button size is documented in the "Recommended sizing and
+    // spacing" section of MSDN layout article.
+    //
+    // Note that we intentionally don't use GetDefaultSize() here, because
+    // it's inexact -- dialog units depend on this dialog's font.
+    const wxSize sizeDef = btn->ConvertDialogToPixels(wxSize(50, 14));
+    if ( !btn->HasFlag(wxBU_EXACTFIT) )
+    {
+        if ( sizeBtn.x < sizeDef.x )
+            sizeBtn.x = sizeDef.x;
+    }
+    if ( sizeBtn.y < sizeDef.y )
+        sizeBtn.y = sizeDef.y;
+
+    btn->CacheBestSize(sizeBtn);
+
+    return sizeBtn;
+}
+
 // ----------------------------------------------------------------------------
 // creation/destruction
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // creation/destruction
 // ----------------------------------------------------------------------------
@@ -181,7 +488,7 @@ bool wxButton::Create(wxWindow *parent,
     //     value and the label is not set yet when MSWGetStyle() is called
     msStyle |= wxMSWButton::GetMultilineStyle(label);
 
     //     value and the label is not set yet when MSWGetStyle() is called
     msStyle |= wxMSWButton::GetMultilineStyle(label);
 
-    return MSWCreateControl(_T("BUTTON"), msStyle, pos, size, label, exstyle);
+    return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, exstyle);
 }
 
 wxButton::~wxButton()
 }
 
 wxButton::~wxButton()
@@ -191,6 +498,11 @@ wxButton::~wxButton()
     {
         UnsetTmpDefault();
     }
     {
         UnsetTmpDefault();
     }
+
+    delete m_imageData;
+#if wxUSE_MARKUP
+    delete m_markupText;
+#endif // wxUSE_MARKUP
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -206,7 +518,7 @@ WXDWORD wxButton::MSWGetStyle(long style, WXDWORD *exstyle) const
                       );
 
     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
                       );
 
     // we must use WS_CLIPSIBLINGS with the buttons or they would draw over
-    // each other in any resizeable dialog which has more than one button in
+    // each other in any resizable dialog which has more than one button in
     // the bottom
     msStyle |= WS_CLIPSIBLINGS;
 
     // the bottom
     msStyle |= WS_CLIPSIBLINGS;
 
@@ -234,15 +546,125 @@ void wxButton::SetLabel(const wxString& label)
     wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
 
     wxButtonBase::SetLabel(label);
     wxMSWButton::UpdateMultilineStyle(GetHwnd(), label);
 
     wxButtonBase::SetLabel(label);
+
+#if wxUSE_MARKUP
+    // If we have a plain text label, we shouldn't be using markup any longer.
+    if ( m_markupText )
+    {
+        delete m_markupText;
+        m_markupText = NULL;
+
+        // Unfortunately we don't really know whether we can reset the button
+        // to be non-owner-drawn or not: if we had made it owner-drawn just
+        // because of a call to SetLabelMarkup(), we could, but not if there
+        // were [also] calls to Set{Fore,Back}groundColour(). If it's really a
+        // problem to have button remain owner-drawn forever just because it
+        // had markup label once, we should record the reason for our current
+        // owner-drawnness and check it here.
+    }
+#endif // wxUSE_MARKUP
 }
 
 // ----------------------------------------------------------------------------
 // size management including autosizing
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // size management including autosizing
 // ----------------------------------------------------------------------------
 
+void wxButton::AdjustForBitmapSize(wxSize &size) const
+{
+    wxCHECK_RET( m_imageData, wxT("shouldn't be called if no image") );
+
+    // account for the bitmap size
+    const wxSize sizeBmp = m_imageData->GetBitmap(State_Normal).GetSize();
+    const wxDirection dirBmp = m_imageData->GetBitmapPosition();
+    if ( dirBmp == wxLEFT || dirBmp == wxRIGHT )
+    {
+        size.x += sizeBmp.x;
+        if ( sizeBmp.y > size.y )
+            size.y = sizeBmp.y;
+    }
+    else // bitmap on top/below the text
+    {
+        size.y += sizeBmp.y;
+        if ( sizeBmp.x > size.x )
+            size.x = sizeBmp.x;
+    }
+
+    // account for the user-specified margins
+    size += 2*m_imageData->GetBitmapMargins();
+
+    // and also for the margins we always add internally (unless we have no
+    // border at all in which case the button has exactly the same size as
+    // bitmap and so no margins should be used)
+    if ( !HasFlag(wxBORDER_NONE) )
+    {
+        int marginH = 0,
+            marginV = 0;
+#if wxUSE_UXTHEME
+        if ( wxUxThemeEngine::GetIfActive() )
+        {
+            wxUxThemeHandle theme(const_cast<wxButton *>(this), L"BUTTON");
+
+            MARGINS margins;
+            wxUxThemeEngine::Get()->GetThemeMargins(theme, NULL,
+                                                    BP_PUSHBUTTON,
+                                                    PBS_NORMAL,
+                                                    TMT_CONTENTMARGINS,
+                                                    NULL,
+                                                    &margins);
+
+            // XP doesn't draw themed buttons correctly when the client
+            // area is smaller than 8x8 - enforce this minimum size for
+            // small bitmaps
+            size.IncTo(wxSize(8, 8));
+
+            marginH = margins.cxLeftWidth + margins.cxRightWidth
+                        + 2*XP_BUTTON_EXTRA_MARGIN;
+            marginV = margins.cyTopHeight + margins.cyBottomHeight
+                        + 2*XP_BUTTON_EXTRA_MARGIN;
+        }
+        else
+#endif // wxUSE_UXTHEME
+        {
+            marginH =
+            marginV = OD_BUTTON_MARGIN;
+        }
+
+        size.IncBy(marginH, marginV);
+    }
+}
+
 wxSize wxButton::DoGetBestSize() const
 {
 wxSize wxButton::DoGetBestSize() const
 {
-    return wxMSWButton::ComputeBestSize(wx_const_cast(wxButton *, this));
+    wxButton * const self = const_cast<wxButton *>(this);
+
+    wxSize size;
+
+    // Account for the text part if we have it.
+    if ( ShowsLabel() )
+    {
+        int flags = 0;
+        if ( GetAuthNeeded() )
+            flags |= wxMSWButton::Size_AuthNeeded;
+
+#if wxUSE_MARKUP
+        if ( m_markupText )
+        {
+            wxClientDC dc(self);
+            size = wxMSWButton::GetFittingSize(self,
+                                               m_markupText->Measure(dc),
+                                               flags);
+        }
+        else // Normal plain text (but possibly multiline) label.
+#endif // wxUSE_MARKUP
+        {
+            size = wxMSWButton::ComputeBestFittingSize(self, flags);
+        }
+    }
+
+    if ( m_imageData )
+        AdjustForBitmapSize(size);
+
+    return wxMSWButton::IncreaseToStdSizeAndCache(self, size);
 }
 
 /* static */
 }
 
 /* static */
@@ -255,16 +677,20 @@ wxSize wxButtonBase::GetDefaultSize()
         wxScreenDC dc;
         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
         wxScreenDC dc;
         dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
-        // the size of a standard button in the dialog units is 50x14,
-        // translate this to pixels
-        // NB1: the multipliers come from the Windows convention
-        // NB2: the extra +1/+2 were needed to get the size be the same as the
-        //      size of the buttons in the standard dialog - I don't know how
-        //      this happens, but on my system this size is 75x23 in pixels and
-        //      23*8 isn't even divisible by 14... Would be nice to understand
-        //      why these constants are needed though!
-        s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4;
-        s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8;
+        // The size of a standard button in the dialog units is 50x14,
+        // translate this to pixels.
+        //
+        // Windows' computes dialog units using average character width over
+        // upper- and lower-case ASCII alphabet and not using the average
+        // character width metadata stored in the font; see
+        // http://support.microsoft.com/default.aspx/kb/145994 for detailed
+        // discussion.
+        //
+        // NB: wxMulDivInt32() is used, because it correctly rounds the result
+
+        const wxSize base = wxPrivate::GetAverageASCIILetterSize(dc);
+        s_sizeBtn.x = wxMulDivInt32(50, base.x, 4);
+        s_sizeBtn.y = wxMulDivInt32(14, base.y, 8);
     }
 
     return s_sizeBtn;
     }
 
     return s_sizeBtn;
@@ -275,6 +701,14 @@ wxSize wxButtonBase::GetDefaultSize()
 // ----------------------------------------------------------------------------
 
 /*
 // ----------------------------------------------------------------------------
 
 /*
+   The comment below and all this code is probably due to not using WM_NEXTDLGCTL
+   message when changing focus (but just SetFocus() which is not enough), see
+   http://blogs.msdn.com/oldnewthing/archive/2004/08/02/205624.aspx for the
+   full explanation.
+
+   TODO: Do use WM_NEXTDLGCTL and get rid of all this code.
+
+
    "Everything you ever wanted to know about the default buttons" or "Why do we
    have to do all this?"
 
    "Everything you ever wanted to know about the default buttons" or "Why do we
    have to do all this?"
 
@@ -341,10 +775,10 @@ static wxTopLevelWindow *GetTLWParentIfNotBeingDeleted(wxWindow *win)
         win = parent;
     }
 
         win = parent;
     }
 
-    wxASSERT_MSG( win, _T("button without top level parent?") );
+    wxASSERT_MSG( win, wxT("button without top level parent?") );
 
     wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
 
     wxTopLevelWindow * const tlw = wxDynamicCast(win, wxTopLevelWindow);
-    wxASSERT_MSG( tlw, _T("logic error in GetTLWParentIfNotBeingDeleted()") );
+    wxASSERT_MSG( tlw, wxT("logic error in GetTLWParentIfNotBeingDeleted()") );
 
     return tlw;
 }
 
     return tlw;
 }
@@ -396,7 +830,7 @@ wxButton::SetDefaultStyle(wxButton *btn, bool on)
             return;
 
         wxWindow * const tlw = wxGetTopLevelParent(btn);
             return;
 
         wxWindow * const tlw = wxGetTopLevelParent(btn);
-        wxCHECK_RET( tlw, _T("button without top level window?") );
+        wxCHECK_RET( tlw, wxT("button without top level window?") );
 
         ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
 
 
         ::SendMessage(GetHwndOf(tlw), DM_SETDEFID, btn->GetId(), 0L);
 
@@ -503,117 +937,276 @@ WXLRESULT wxButton::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
         // as the theme size might have changed
         InvalidateBestSize();
     }
         // as the theme size might have changed
         InvalidateBestSize();
     }
-    else if ( wxUxThemeEngine::GetIfActive() )
+#endif // wxUSE_UXTHEME
+    // must use m_mouseInWindow here instead of IsMouseInWindow()
+    // since we need to know the first time the mouse enters the window
+    // and IsMouseInWindow() would return true in this case
+    else if ( (nMsg == WM_MOUSEMOVE && !m_mouseInWindow) ||
+                nMsg == WM_MOUSELEAVE )
     {
     {
-        // we need to Refresh() if mouse has entered or left window
-        // so we can update the hot tracking state
-        // must use m_mouseInWindow here instead of IsMouseInWindow()
-        // since we need to know the first time the mouse enters the window
-        // and IsMouseInWindow() would return true in this case
-        if ( ( nMsg == WM_MOUSEMOVE && !m_mouseInWindow ) ||
-             nMsg == WM_MOUSELEAVE )
+        if (
+                IsEnabled() &&
+                (
+#if wxUSE_UXTHEME
+                wxUxThemeEngine::GetIfActive() ||
+#endif // wxUSE_UXTHEME
+                 (m_imageData && m_imageData->GetBitmap(State_Current).IsOk())
+                )
+           )
         {
             Refresh();
         }
     }
         {
             Refresh();
         }
     }
-#endif // wxUSE_UXTHEME
 
     // let the base class do all real processing
     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 }
 
 // ----------------------------------------------------------------------------
 
     // let the base class do all real processing
     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 }
 
 // ----------------------------------------------------------------------------
-// owner-drawn buttons support
+// authentication needed handling
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-// drawing helpers
+bool wxButton::DoGetAuthNeeded() const
+{
+    return m_authNeeded;
+}
 
 
-static void DrawButtonText(HDC hdc,
-                           RECT *pRect,
-                           const wxString& text,
-                           COLORREF col)
+void wxButton::DoSetAuthNeeded(bool show)
 {
 {
-    COLORREF colOld = SetTextColor(hdc, col);
-    int modeOld = SetBkMode(hdc, TRANSPARENT);
+    // show/hide UAC symbol on Windows Vista and later
+    if ( wxGetWinVersion() >= wxWinVersion_6 )
+    {
+        m_authNeeded = show;
+        ::SendMessage(GetHwnd(), BCM_SETSHIELD, 0, show);
+        InvalidateBestSize();
+    }
+}
 
 
-    if ( text.find(_T('\n')) != wxString::npos )
+// ----------------------------------------------------------------------------
+// button images
+// ----------------------------------------------------------------------------
+
+wxBitmap wxButton::DoGetBitmap(State which) const
+{
+    return m_imageData ? m_imageData->GetBitmap(which) : wxBitmap();
+}
+
+void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
+{
+#if wxUSE_UXTHEME
+    wxXPButtonImageData *oldData = NULL;
+#endif // wxUSE_UXTHEME
+
+    // Check if we already had bitmaps of different size.
+    if ( m_imageData &&
+          bitmap.GetSize() != m_imageData->GetBitmap(State_Normal).GetSize() )
     {
     {
-        // draw multiline label
+        wxASSERT_MSG( which == State_Normal,
+                      "Must set normal bitmap with the new size first" );
 
 
-        // first we need to compute its bounding rect
-        RECT rc;
-        ::CopyRect(&rc, pRect);
-        ::DrawText(hdc, text.wx_str(), text.length(), &rc,
-                   DT_CENTER | DT_CALCRECT);
+#if wxUSE_UXTHEME
+        if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
+        {
+            // We can't change the size of the images stored in wxImageList
+            // in wxXPButtonImageData::m_iml so force recreating it below but
+            // keep the current data to copy its values into the new one.
+            oldData = static_cast<wxXPButtonImageData *>(m_imageData);
+            m_imageData = NULL;
+        }
+#endif // wxUSE_UXTHEME
+        //else: wxODButtonImageData doesn't require anything special
+    }
 
 
-        // now center this rect inside the entire button area
-        const LONG w = rc.right - rc.left;
-        const LONG h = rc.bottom - rc.top;
-        rc.left = (pRect->right - pRect->left)/2 - w/2;
-        rc.right = rc.left+w;
-        rc.top = (pRect->bottom - pRect->top)/2 - h/2;
-        rc.bottom = rc.top+h;
+    // allocate the image data when the first bitmap is set
+    if ( !m_imageData )
+    {
+#if wxUSE_UXTHEME
+        // using image list doesn't work correctly if we don't have any label
+        // (even if we use BUTTON_IMAGELIST_ALIGN_CENTER alignment and
+        // BS_BITMAP style), at least under Windows 2003 so use owner drawn
+        // strategy for bitmap-only buttons
+        if ( ShowsLabel() && wxUxThemeEngine::GetIfActive() )
+        {
+            m_imageData = new wxXPButtonImageData(this, bitmap);
+
+            if ( oldData )
+            {
+                // Preserve the old values in case the user changed them.
+                m_imageData->SetBitmapPosition(oldData->GetBitmapPosition());
+
+                const wxSize oldMargins = oldData->GetBitmapMargins();
+                m_imageData->SetBitmapMargins(oldMargins.x, oldMargins.y);
+
+                // No need to preserve the bitmaps though as they were of wrong
+                // size anyhow.
 
 
-        ::DrawText(hdc, text.wx_str(), text.length(), &rc, DT_CENTER);
+                delete oldData;
+            }
+        }
+        else
+#endif // wxUSE_UXTHEME
+        {
+            m_imageData = new wxODButtonImageData(this, bitmap);
+            MakeOwnerDrawn();
+        }
     }
     }
-    else // single line label
+    else
     {
     {
-        // Note: we must have DT_SINGLELINE for DT_VCENTER to work.
-        ::DrawText(hdc, text.wx_str(), text.length(), pRect,
-                   DT_SINGLELINE | DT_CENTER | DT_VCENTER);
+        m_imageData->SetBitmap(bitmap, which);
     }
 
     }
 
-    SetBkMode(hdc, modeOld);
-    SetTextColor(hdc, colOld);
+    // it should be enough to only invalidate the best size when the normal
+    // bitmap changes as all bitmaps assigned to the button should be of the
+    // same size anyhow
+    if ( which == State_Normal )
+        InvalidateBestSize();
+
+    Refresh();
 }
 
 }
 
-static void DrawRect(HDC hdc, const RECT& r)
+wxSize wxButton::DoGetBitmapMargins() const
 {
 {
-    wxDrawLine(hdc, r.left, r.top, r.right, r.top);
-    wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
-    wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
-    wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
+    return m_imageData ? m_imageData->GetBitmapMargins() : wxSize(0, 0);
 }
 
 }
 
-void wxButton::MakeOwnerDrawn()
+void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
 {
 {
-    long style = GetWindowLong(GetHwnd(), GWL_STYLE);
-    if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
-    {
-        // make it so
-        style |= BS_OWNERDRAW;
-        SetWindowLong(GetHwnd(), GWL_STYLE, style);
-    }
+    wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
+
+    m_imageData->SetBitmapMargins(x, y);
+    InvalidateBestSize();
 }
 
 }
 
-bool wxButton::SetBackgroundColour(const wxColour &colour)
+void wxButton::DoSetBitmapPosition(wxDirection dir)
 {
 {
-    if ( !wxControl::SetBackgroundColour(colour) )
-    {
-        // nothing to do
+    wxCHECK_RET( m_imageData, "SetBitmap() must be called first" );
+
+    m_imageData->SetBitmapPosition(dir);
+    InvalidateBestSize();
+}
+
+// ----------------------------------------------------------------------------
+// markup support
+// ----------------------------------------------------------------------------
+
+#if wxUSE_MARKUP
+
+bool wxButton::DoSetLabelMarkup(const wxString& markup)
+{
+    if ( !wxButtonBase::DoSetLabelMarkup(markup) )
         return false;
         return false;
-    }
 
 
-    MakeOwnerDrawn();
+    if ( !m_markupText )
+    {
+        m_markupText = new wxMarkupText(markup);
+        MakeOwnerDrawn();
+    }
+    else
+    {
+        // We are already owner-drawn so just update the text.
+        m_markupText->SetMarkup(markup);
+    }
 
     Refresh();
 
     return true;
 }
 
 
     Refresh();
 
     return true;
 }
 
-bool wxButton::SetForegroundColour(const wxColour &colour)
+#endif // wxUSE_MARKUP
+
+// ----------------------------------------------------------------------------
+// owner-drawn buttons support
+// ----------------------------------------------------------------------------
+
+// drawing helpers
+namespace
 {
 {
-    if ( !wxControl::SetForegroundColour(colour) )
+
+// return the button state using both the ODS_XXX flags specified in state
+// parameter and the current button state
+wxButton::State GetButtonState(wxButton *btn, UINT state)
+{
+    if ( state & ODS_DISABLED )
+        return wxButton::State_Disabled;
+
+    if ( state & ODS_SELECTED )
+        return wxButton::State_Pressed;
+
+    if ( btn->HasCapture() || btn->IsMouseInWindow() )
+        return wxButton::State_Current;
+
+    if ( state & ODS_FOCUS )
+        return wxButton::State_Focused;
+
+    return wxButton::State_Normal;
+}
+
+void DrawButtonText(HDC hdc,
+                    RECT *pRect,
+                    wxButton *btn,
+                    int flags)
+{
+    const wxString text = btn->GetLabel();
+
+    if ( text.find(wxT('\n')) != wxString::npos )
     {
     {
-        // nothing to do
-        return false;
+        // draw multiline label
+
+        // center text horizontally in any case
+        flags |= DT_CENTER;
+
+        // first we need to compute its bounding rect
+        RECT rc;
+        ::CopyRect(&rc, pRect);
+        ::DrawText(hdc, text.wx_str(), text.length(), &rc,
+                   DT_CENTER | DT_CALCRECT);
+
+        // now center this rect inside the entire button area
+        const LONG w = rc.right - rc.left;
+        const LONG h = rc.bottom - rc.top;
+        rc.left = (pRect->right - pRect->left)/2 - w/2;
+        rc.right = rc.left+w;
+        rc.top = (pRect->bottom - pRect->top)/2 - h/2;
+        rc.bottom = rc.top+h;
+
+        ::DrawText(hdc, text.wx_str(), text.length(), &rc, flags);
     }
     }
+    else // single line label
+    {
+        // translate wx button flags to alignment flags for DrawText()
+        if ( btn->HasFlag(wxBU_RIGHT) )
+        {
+            flags |= DT_RIGHT;
+        }
+        else if ( !btn->HasFlag(wxBU_LEFT) )
+        {
+            flags |= DT_CENTER;
+        }
+        //else: DT_LEFT is the default anyhow (and its value is 0 too)
 
 
-    MakeOwnerDrawn();
+        if ( btn->HasFlag(wxBU_BOTTOM) )
+        {
+            flags |= DT_BOTTOM;
+        }
+        else if ( !btn->HasFlag(wxBU_TOP) )
+        {
+            flags |= DT_VCENTER;
+        }
+        //else: as above, DT_TOP is the default
 
 
-    Refresh();
+        // notice that we must have DT_SINGLELINE for vertical alignment flags
+        // to work
+        ::DrawText(hdc, text.wx_str(), text.length(), pRect,
+                   flags | DT_SINGLELINE );
+    }
+}
 
 
-    return true;
+void DrawRect(HDC hdc, const RECT& r)
+{
+    wxDrawLine(hdc, r.left, r.top, r.right, r.top);
+    wxDrawLine(hdc, r.right, r.top, r.right, r.bottom);
+    wxDrawLine(hdc, r.right, r.bottom, r.left, r.bottom);
+    wxDrawLine(hdc, r.left, r.bottom, r.left, r.top);
 }
 
 /*
 }
 
 /*
@@ -651,19 +1244,18 @@ bool wxButton::SetForegroundColour(const wxColour &colour)
    BGGGGGGGGGGGGGGGGGB
    BBBBBBBBBBBBBBBBBBB
 */
    BGGGGGGGGGGGGGGGGGB
    BBBBBBBBBBBBBBBBBBB
 */
-
-static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
-                            bool selected, bool pushed)
+void DrawButtonFrame(HDC hdc, RECT& rectBtn,
+                     bool selected, bool pushed)
 {
     RECT r;
     CopyRect(&r, &rectBtn);
 
 {
     RECT r;
     CopyRect(&r, &rectBtn);
 
-    HPEN hpenBlack   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW)),
-         hpenGrey    = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW)),
-         hpenLightGr = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)),
-         hpenWhite   = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DHILIGHT));
+    AutoHPEN hpenBlack(GetSysColor(COLOR_3DDKSHADOW)),
+             hpenGrey(GetSysColor(COLOR_3DSHADOW)),
+             hpenLightGr(GetSysColor(COLOR_3DLIGHT)),
+             hpenWhite(GetSysColor(COLOR_3DHILIGHT));
 
 
-    HPEN hpenOld = (HPEN)SelectObject(hdc, hpenBlack);
+    SelectInHDC selectPen(hdc, hpenBlack);
 
     r.right--;
     r.bottom--;
 
     r.right--;
     r.bottom--;
@@ -702,150 +1294,274 @@ static void DrawButtonFrame(HDC hdc, const RECT& rectBtn,
         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
     }
 
         wxDrawLine(hdc, r.right - 1, r.bottom - 1, r.right - 1, r.top);
     }
 
-    (void)SelectObject(hdc, hpenOld);
-    DeleteObject(hpenWhite);
-    DeleteObject(hpenLightGr);
-    DeleteObject(hpenGrey);
-    DeleteObject(hpenBlack);
+    InflateRect(&rectBtn, -OD_BUTTON_MARGIN, -OD_BUTTON_MARGIN);
 }
 
 #if wxUSE_UXTHEME
 }
 
 #if wxUSE_UXTHEME
-static
-void MSWDrawXPBackground(wxButton *button, WXDRAWITEMSTRUCT *wxdis)
+void DrawXPBackground(wxButton *button, HDC hdc, RECT& rectBtn, UINT state)
 {
 {
-    LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
-    HDC hdc = lpDIS->hDC;
-    UINT state = lpDIS->itemState;
-    RECT rectBtn;
-    CopyRect(&rectBtn, &lpDIS->rcItem);
-
     wxUxThemeHandle theme(button, L"BUTTON");
     wxUxThemeHandle theme(button, L"BUTTON");
-    int iState;
 
 
-    if ( state & ODS_SELECTED )
-    {
-        iState = PBS_PRESSED;
-    }
-    else if ( button->HasCapture() || button->IsMouseInWindow() )
+    // this array is indexed by wxButton::State values and so must be kept in
+    // sync with it
+    static const int uxStates[] =
     {
     {
-        iState = PBS_HOT;
-    }
-    else if ( state & ODS_FOCUS )
-    {
-        iState = PBS_DEFAULTED;
-    }
-    else if ( state & ODS_DISABLED )
-    {
-        iState = PBS_DISABLED;
-    }
-    else
-    {
-        iState = PBS_NORMAL;
-    }
+        PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED
+    };
+
+    int iState = uxStates[GetButtonState(button, state)];
+
+    wxUxThemeEngine * const engine = wxUxThemeEngine::Get();
 
     // draw parent background if needed
 
     // draw parent background if needed
-    if ( wxUxThemeEngine::Get()->IsThemeBackgroundPartiallyTransparent(theme,
-                                                                       BP_PUSHBUTTON,
-                                                                       iState) )
+    if ( engine->IsThemeBackgroundPartiallyTransparent
+                 (
+                    theme,
+                    BP_PUSHBUTTON,
+                    iState
+                 ) )
     {
     {
-        wxUxThemeEngine::Get()->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
+        // Set this button as the one whose background is being erased: this
+        // allows our WM_ERASEBKGND handler used by DrawThemeParentBackground()
+        // to correctly align the background brush with this window instead of
+        // the parent window to which WM_ERASEBKGND is sent. Notice that this
+        // doesn't work with custom user-defined EVT_ERASE_BACKGROUND handlers
+        // as they won't be aligned but unfortunately all the attempts to fix
+        // it by shifting DC origin before calling DrawThemeParentBackground()
+        // failed to work so we at least do this, even though this is far from
+        // being the perfect solution.
+        wxWindowBeingErased = button;
+
+        engine->DrawThemeParentBackground(GetHwndOf(button), hdc, &rectBtn);
+
+        wxWindowBeingErased = NULL;
     }
 
     // draw background
     }
 
     // draw background
-    wxUxThemeEngine::Get()->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
-                                                &rectBtn, NULL);
+    engine->DrawThemeBackground(theme, hdc, BP_PUSHBUTTON, iState,
+                                &rectBtn, NULL);
 
     // calculate content area margins
     MARGINS margins;
 
     // calculate content area margins
     MARGINS margins;
-    wxUxThemeEngine::Get()->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
-                                            TMT_CONTENTMARGINS, &rectBtn, &margins);
-    RECT rectClient;
-    ::CopyRect(&rectClient, &rectBtn);
-    ::InflateRect(&rectClient, -margins.cxLeftWidth, -margins.cyTopHeight);
-
-    // if focused and !nofocus rect
-    if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
-    {
-        DrawFocusRect(hdc, &rectClient);
-    }
+    engine->GetThemeMargins(theme, hdc, BP_PUSHBUTTON, iState,
+                            TMT_CONTENTMARGINS, &rectBtn, &margins);
+    ::InflateRect(&rectBtn, -margins.cxLeftWidth, -margins.cyTopHeight);
+    ::InflateRect(&rectBtn, -XP_BUTTON_EXTRA_MARGIN, -XP_BUTTON_EXTRA_MARGIN);
 
     if ( button->UseBgCol() )
     {
         COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
 
     if ( button->UseBgCol() )
     {
         COLORREF colBg = wxColourToRGB(button->GetBackgroundColour());
-        HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
+        AutoHBRUSH hbrushBackground(colBg);
 
         // don't overwrite the focus rect
 
         // don't overwrite the focus rect
+        RECT rectClient;
+        ::CopyRect(&rectClient, &rectBtn);
         ::InflateRect(&rectClient, -1, -1);
         FillRect(hdc, &rectClient, hbrushBackground);
         ::InflateRect(&rectClient, -1, -1);
         FillRect(hdc, &rectClient, hbrushBackground);
-        ::DeleteObject(hbrushBackground);
     }
 }
 #endif // wxUSE_UXTHEME
 
     }
 }
 #endif // wxUSE_UXTHEME
 
+} // anonymous namespace
+
+// ----------------------------------------------------------------------------
+// owner drawn buttons support
+// ----------------------------------------------------------------------------
+
+void wxButton::MakeOwnerDrawn()
+{
+    long style = GetWindowLong(GetHwnd(), GWL_STYLE);
+    if ( (style & BS_OWNERDRAW) != BS_OWNERDRAW )
+    {
+        // make it so
+        style |= BS_OWNERDRAW;
+        SetWindowLong(GetHwnd(), GWL_STYLE, style);
+    }
+}
+
+bool wxButton::SetBackgroundColour(const wxColour &colour)
+{
+    if ( !wxControl::SetBackgroundColour(colour) )
+    {
+        // nothing to do
+        return false;
+    }
+
+    MakeOwnerDrawn();
+
+    Refresh();
+
+    return true;
+}
+
+bool wxButton::SetForegroundColour(const wxColour &colour)
+{
+    if ( !wxControl::SetForegroundColour(colour) )
+    {
+        // nothing to do
+        return false;
+    }
+
+    MakeOwnerDrawn();
+
+    Refresh();
+
+    return true;
+}
+
 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 {
     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
     HDC hdc = lpDIS->hDC;
 bool wxButton::MSWOnDraw(WXDRAWITEMSTRUCT *wxdis)
 {
     LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)wxdis;
     HDC hdc = lpDIS->hDC;
+
     UINT state = lpDIS->itemState;
     UINT state = lpDIS->itemState;
+    bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
+
     RECT rectBtn;
     CopyRect(&rectBtn, &lpDIS->rcItem);
 
     RECT rectBtn;
     CopyRect(&rectBtn, &lpDIS->rcItem);
 
-#if wxUSE_UXTHEME
-    if ( wxUxThemeEngine::GetIfActive() )
+    // draw the button background
+    if ( !HasFlag(wxBORDER_NONE) )
     {
     {
-        MSWDrawXPBackground(this, wxdis);
-    }
-    else
+#if wxUSE_UXTHEME
+        if ( wxUxThemeEngine::GetIfActive() )
+        {
+            DrawXPBackground(this, hdc, rectBtn, state);
+        }
+        else
 #endif // wxUSE_UXTHEME
 #endif // wxUSE_UXTHEME
-    {
-        COLORREF colBg = wxColourToRGB(GetBackgroundColour());
+        {
+            COLORREF colBg = wxColourToRGB(GetBackgroundColour());
 
 
-        // first, draw the background
-        HBRUSH hbrushBackground = ::CreateSolidBrush(colBg);
-        FillRect(hdc, &rectBtn, hbrushBackground);
-        ::DeleteObject(hbrushBackground);
+            // first, draw the background
+            AutoHBRUSH hbrushBackground(colBg);
+            FillRect(hdc, &rectBtn, hbrushBackground);
 
 
-        // draw the border for the current state
-        bool selected = (state & ODS_SELECTED) != 0;
-        if ( !selected )
-        {
-            wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
-            if ( tlw )
+            // draw the border for the current state
+            bool selected = (state & ODS_SELECTED) != 0;
+            if ( !selected )
             {
             {
-                selected = tlw->GetDefaultItem() == this;
+                wxTopLevelWindow *
+                    tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
+                if ( tlw )
+                {
+                    selected = tlw->GetDefaultItem() == this;
+                }
             }
             }
-        }
-        bool pushed = (SendMessage(GetHwnd(), BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
 
 
-        DrawButtonFrame(hdc, rectBtn, selected, pushed);
+            DrawButtonFrame(hdc, rectBtn, selected, pushed);
+        }
 
 
-        // if focused and !nofocus rect
+        // draw the focus rectangle if we need it
         if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
         {
         if ( (state & ODS_FOCUS) && !(state & ODS_NOFOCUSRECT) )
         {
-            RECT rectFocus;
-            CopyRect(&rectFocus, &rectBtn);
-
-            // I don't know where does this constant come from, but this is how
-            // Windows draws them
-            InflateRect(&rectFocus, -4, -4);
+            DrawFocusRect(hdc, &rectBtn);
 
 
-            DrawFocusRect(hdc, &rectFocus);
+#if wxUSE_UXTHEME
+            if ( !wxUxThemeEngine::GetIfActive() )
+#endif // wxUSE_UXTHEME
+            {
+                if ( pushed )
+                {
+                    // the label is shifted by 1 pixel to create "pushed" effect
+                    OffsetRect(&rectBtn, 1, 1);
+                }
+            }
         }
         }
+    }
 
 
-        if ( pushed )
+
+    // draw the image, if any
+    if ( m_imageData )
+    {
+        wxBitmap bmp = m_imageData->GetBitmap(GetButtonState(this, state));
+        if ( !bmp.IsOk() )
+            bmp = m_imageData->GetBitmap(State_Normal);
+
+        const wxSize sizeBmp = bmp.GetSize();
+        const wxSize margin = m_imageData->GetBitmapMargins();
+        const wxSize sizeBmpWithMargins(sizeBmp + 2*margin);
+        wxRect rectButton(wxRectFromRECT(rectBtn));
+
+        // for simplicity, we start with centred rectangle and then move it to
+        // the appropriate edge
+        wxRect rectBitmap = wxRect(sizeBmp).CentreIn(rectButton);
+
+        // move bitmap only if we have a label, otherwise keep it centered
+        if ( ShowsLabel() )
         {
         {
-            // the label is shifted by 1 pixel to create "pushed" effect
-            OffsetRect(&rectBtn, 1, 1);
+            switch ( m_imageData->GetBitmapPosition() )
+            {
+                default:
+                    wxFAIL_MSG( "invalid direction" );
+                    // fall through
+
+                case wxLEFT:
+                    rectBitmap.x = rectButton.x + margin.x;
+                    rectButton.x += sizeBmpWithMargins.x;
+                    rectButton.width -= sizeBmpWithMargins.x;
+                    break;
+
+                case wxRIGHT:
+                    rectBitmap.x = rectButton.GetRight() - sizeBmp.x - margin.x;
+                    rectButton.width -= sizeBmpWithMargins.x;
+                    break;
+
+                case wxTOP:
+                    rectBitmap.y = rectButton.y + margin.y;
+                    rectButton.y += sizeBmpWithMargins.y;
+                    rectButton.height -= sizeBmpWithMargins.y;
+                    break;
+
+                case wxBOTTOM:
+                    rectBitmap.y = rectButton.GetBottom() - sizeBmp.y - margin.y;
+                    rectButton.height -= sizeBmpWithMargins.y;
+                    break;
+            }
         }
         }
+
+        wxDCTemp dst((WXHDC)hdc);
+        dst.DrawBitmap(bmp, rectBitmap.GetPosition(), true);
+
+        wxCopyRectToRECT(rectButton, rectBtn);
     }
 
     }
 
-    COLORREF colFg = wxColourToRGB(GetForegroundColour());
-    if ( state & ODS_DISABLED ) colFg = GetSysColor(COLOR_GRAYTEXT) ;
-    wxString label = GetLabel();
-    if ( state & ODS_NOACCEL ) label = GetLabelText() ;
-    DrawButtonText(hdc, &rectBtn, label, colFg);
+
+    // finally draw the label
+    if ( ShowsLabel() )
+    {
+        COLORREF colFg = state & ODS_DISABLED
+                            ? ::GetSysColor(COLOR_GRAYTEXT)
+                            : wxColourToRGB(GetForegroundColour());
+
+        wxTextColoursChanger changeFg(hdc, colFg, CLR_INVALID);
+        wxBkModeChanger changeBkMode(hdc, wxBRUSHSTYLE_TRANSPARENT);
+
+#if wxUSE_MARKUP
+        if ( m_markupText )
+        {
+            wxDCTemp dc((WXHDC)hdc);
+            dc.SetTextForeground(wxColour(colFg));
+            dc.SetFont(GetFont());
+
+            m_markupText->Render(dc, wxRectFromRECT(rectBtn),
+                                 state & ODS_NOACCEL
+                                    ? wxMarkupText::Render_Default
+                                    : wxMarkupText::Render_ShowAccels);
+        }
+        else // Plain text label
+#endif // wxUSE_MARKUP
+        {
+            // notice that DT_HIDEPREFIX doesn't work on old (pre-Windows 2000)
+            // systems but by happy coincidence ODS_NOACCEL is not used under
+            // them neither so DT_HIDEPREFIX should never be used there
+            DrawButtonText(hdc, &rectBtn, this,
+                           state & ODS_NOACCEL ? DT_HIDEPREFIX : 0);
+        }
+    }
 
     return true;
 }
 
 #endif // wxUSE_BUTTON
 
     return true;
 }
 
 #endif // wxUSE_BUTTON
+