]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/themes/win32.cpp
adding the GetEventHandler() indirection
[wxWidgets.git] / src / univ / themes / win32.cpp
index ccf87bc3ff467184d2f05af90bad77e2a56b1dfd..0c22469e903c650e693a2dfd8229b5d5d2038d92 100644 (file)
@@ -1,11 +1,12 @@
-// Name:        univ/themes/win32.cpp
+///////////////////////////////////////////////////////////////////////////////
+// Name:        src/univ/themes/win32.cpp
 // Purpose:     wxUniversal theme implementing Win32-like LNF
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
 // Purpose:     wxUniversal theme implementing Win32-like LNF
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
+#include "wx/univ/theme.h"
+
+#if wxUSE_THEME_WIN32
+
 #ifndef WX_PRECOMP
     #include "wx/timer.h"
     #include "wx/intl.h"
 #ifndef WX_PRECOMP
     #include "wx/timer.h"
     #include "wx/intl.h"
     #include "wx/window.h"
 
     #include "wx/dcmemory.h"
     #include "wx/window.h"
 
     #include "wx/dcmemory.h"
+    #include "wx/dcclient.h"
 
     #include "wx/button.h"
 
     #include "wx/button.h"
+    #include "wx/bmpbuttn.h"
     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
     #include "wx/toolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
     #include "wx/toolbar.h"
+    #include "wx/statusbr.h"
 
     #ifdef __WXMSW__
         // for COLOR_* constants
         #include "wx/msw/private.h"
     #endif
 
     #ifdef __WXMSW__
         // for COLOR_* constants
         #include "wx/msw/private.h"
     #endif
+    #include "wx/menu.h"
+    #include "wx/settings.h"
+    #include "wx/toplevel.h"
+    #include "wx/image.h"
 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
-#include "wx/settings.h"
-#include "wx/menu.h"
 #include "wx/artprov.h"
 #include "wx/artprov.h"
-#include "wx/toplevel.h"
+#ifdef wxUSE_TOGGLEBTN
+#include "wx/tglbtn.h"
+#endif // wxUSE_TOGGLEBTN
 
 #include "wx/univ/scrtimer.h"
 
 #include "wx/univ/scrtimer.h"
-#include "wx/univ/renderer.h"
+#include "wx/univ/stdrend.h"
+#include "wx/univ/inpcons.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
-#include "wx/univ/theme.h"
 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants
 
 static const int BORDER_THICKNESS = 2;
 
 
 static const int BORDER_THICKNESS = 2;
 
-// the offset between the label and focus rect around it
-static const int FOCUS_RECT_OFFSET_X = 1;
-static const int FOCUS_RECT_OFFSET_Y = 1;
-
-static const int FRAME_BORDER_THICKNESS            = 3;
-static const int RESIZEABLE_FRAME_BORDER_THICKNESS = 4;
-static const int FRAME_TITLEBAR_HEIGHT             = 18;
-static const int FRAME_BUTTON_WIDTH                = 16;
-static const int FRAME_BUTTON_HEIGHT               = 14;
-
 static const size_t NUM_STATUSBAR_GRIP_BANDS = 3;
 static const size_t WIDTH_STATUSBAR_GRIP_BAND = 4;
 static const size_t STATUSBAR_GRIP_SIZE =
     WIDTH_STATUSBAR_GRIP_BAND*NUM_STATUSBAR_GRIP_BANDS;
 
 static const size_t NUM_STATUSBAR_GRIP_BANDS = 3;
 static const size_t WIDTH_STATUSBAR_GRIP_BAND = 4;
 static const size_t STATUSBAR_GRIP_SIZE =
     WIDTH_STATUSBAR_GRIP_BAND*NUM_STATUSBAR_GRIP_BANDS;
 
-enum IndicatorType
-{
-    IndicatorType_Check,
-    IndicatorType_Radio,
-    IndicatorType_Menu,
-    IndicatorType_Max
-};
-
-enum IndicatorState
-{
-    IndicatorState_Normal,
-    IndicatorState_Pressed, // this one is for check/radioboxes
-    IndicatorState_Selected = IndicatorState_Pressed, // for menus
-    IndicatorState_Disabled,
-    IndicatorState_SelectedDisabled,    // only for the menus
-    IndicatorState_Max
-};
-
-enum IndicatorStatus
-{
-    IndicatorStatus_Checked,
-    IndicatorStatus_Unchecked,
-    IndicatorStatus_Max
-};
+static const wxCoord SLIDER_MARGIN = 6; // margin around slider
+static const wxCoord SLIDER_THUMB_LENGTH = 18;
+static const wxCoord SLIDER_TICK_LENGTH = 6;
 
 // wxWin32Renderer: draw the GUI elements in Win32 style
 // ----------------------------------------------------------------------------
 
 
 // wxWin32Renderer: draw the GUI elements in Win32 style
 // ----------------------------------------------------------------------------
 
-class wxWin32Renderer : public wxRenderer
+class wxWin32Renderer : public wxStdRenderer
 {
 public:
 {
 public:
-    // constants
-    enum wxArrowDirection
-    {
-        Arrow_Left,
-        Arrow_Right,
-        Arrow_Up,
-        Arrow_Down,
-        Arrow_Max
-    };
-
-    enum wxArrowStyle
-    {
-        Arrow_Normal,
-        Arrow_Disabled,
-        Arrow_Pressed,
-        Arrow_Inversed,
-        Arrow_InversedDisabled,
-        Arrow_StateMax
-    };
-
-    enum wxFrameButtonType
-    {
-        FrameButton_Close,
-        FrameButton_Minimize,
-        FrameButton_Maximize,
-        FrameButton_Restore,
-        FrameButton_Help,
-        FrameButton_Max
-    };
-
     // ctor
     wxWin32Renderer(const wxColourScheme *scheme);
 
     // ctor
     wxWin32Renderer(const wxColourScheme *scheme);
 
-    // implement the base class pure virtuals
-    virtual void DrawBackground(wxDC& dc,
-                                const wxColour& col,
-                                const wxRect& rect,
-                                int flags = 0,
-                                wxWindow *window = NULL);
+    // reimplement the renderer methods which are different for this theme
     virtual void DrawLabel(wxDC& dc,
                            const wxString& label,
                            const wxRect& rect,
     virtual void DrawLabel(wxDC& dc,
                            const wxString& label,
                            const wxRect& rect,
@@ -165,39 +111,15 @@ public:
                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                                  int indexAccel = -1,
                                  wxRect *rectBounds = NULL);
                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                                  int indexAccel = -1,
                                  wxRect *rectBounds = NULL);
-    virtual void DrawBorder(wxDC& dc,
-                            wxBorder border,
-                            const wxRect& rect,
-                            int flags = 0,
-                            wxRect *rectIn = (wxRect *)NULL);
-    virtual void DrawHorizontalLine(wxDC& dc,
-                                    wxCoord y, wxCoord x1, wxCoord x2);
-    virtual void DrawVerticalLine(wxDC& dc,
-                                  wxCoord x, wxCoord y1, wxCoord y2);
-    virtual void DrawFrame(wxDC& dc,
-                           const wxString& label,
-                           const wxRect& rect,
-                           int flags = 0,
-                           int alignment = wxALIGN_LEFT,
-                           int indexAccel = -1);
-    virtual void DrawTextBorder(wxDC& dc,
-                                wxBorder border,
-                                const wxRect& rect,
-                                int flags = 0,
-                                wxRect *rectIn = (wxRect *)NULL);
     virtual void DrawButtonBorder(wxDC& dc,
                                   const wxRect& rect,
                                   int flags = 0,
     virtual void DrawButtonBorder(wxDC& dc,
                                   const wxRect& rect,
                                   int flags = 0,
-                                  wxRect *rectIn = (wxRect *)NULL);
+                                  wxRect *rectIn = NULL);
+
     virtual void DrawArrow(wxDC& dc,
                            wxDirection dir,
                            const wxRect& rect,
                            int flags = 0);
     virtual void DrawArrow(wxDC& dc,
                            wxDirection dir,
                            const wxRect& rect,
                            int flags = 0);
-    virtual void DrawScrollbarArrow(wxDC& dc,
-                                    wxDirection dir,
-                                    const wxRect& rect,
-                                    int flags = 0)
-        { DrawArrow(dc, dir, rect, flags); }
     virtual void DrawScrollbarThumb(wxDC& dc,
                                     wxOrientation orient,
                                     const wxRect& rect,
     virtual void DrawScrollbarThumb(wxDC& dc,
                                     wxOrientation orient,
                                     const wxRect& rect,
@@ -206,43 +128,18 @@ public:
                                     wxOrientation orient,
                                     const wxRect& rect,
                                     int flags = 0);
                                     wxOrientation orient,
                                     const wxRect& rect,
                                     int flags = 0);
-    virtual void DrawScrollCorner(wxDC& dc,
-                                  const wxRect& rect);
-    virtual void DrawItem(wxDC& dc,
-                          const wxString& label,
-                          const wxRect& rect,
-                          int flags = 0);
-    virtual void DrawCheckItem(wxDC& dc,
-                               const wxString& label,
-                               const wxBitmap& bitmap,
-                               const wxRect& rect,
-                               int flags = 0);
-    virtual void DrawCheckButton(wxDC& dc,
-                                 const wxString& label,
-                                 const wxBitmap& bitmap,
-                                 const wxRect& rect,
-                                 int flags = 0,
-                                 wxAlignment align = wxALIGN_LEFT,
-                                 int indexAccel = -1);
-    virtual void DrawRadioButton(wxDC& dc,
-                                 const wxString& label,
-                                 const wxBitmap& bitmap,
-                                 const wxRect& rect,
-                                 int flags = 0,
-                                 wxAlignment align = wxALIGN_LEFT,
-                                 int indexAccel = -1);
+
+#if wxUSE_TOOLBAR
     virtual void DrawToolBarButton(wxDC& dc,
                                    const wxString& label,
                                    const wxBitmap& bitmap,
                                    const wxRect& rect,
     virtual void DrawToolBarButton(wxDC& dc,
                                    const wxString& label,
                                    const wxBitmap& bitmap,
                                    const wxRect& rect,
-                                   int flags);
-    virtual void DrawTextLine(wxDC& dc,
-                              const wxString& text,
-                              const wxRect& rect,
-                              int selStart = -1,
-                              int selEnd = -1,
-                              int flags = 0);
-    virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
+                                   int flags = 0,
+                                   long style = 0,
+                                   int tbarStyle = 0);
+#endif // wxUSE_TOOLBAR
+
+#if wxUSE_NOTEBOOK
     virtual void DrawTab(wxDC& dc,
                          const wxRect& rect,
                          wxDirection dir,
     virtual void DrawTab(wxDC& dc,
                          const wxRect& rect,
                          wxDirection dir,
@@ -250,25 +147,33 @@ public:
                          const wxBitmap& bitmap = wxNullBitmap,
                          int flags = 0,
                          int indexAccel = -1);
                          const wxBitmap& bitmap = wxNullBitmap,
                          int flags = 0,
                          int indexAccel = -1);
+#endif // wxUSE_NOTEBOOK
 
 
+#if wxUSE_SLIDER
     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,
     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,
+                                 int lenThumb,
                                  wxOrientation orient,
                                  int flags = 0,
                                  wxOrientation orient,
                                  int flags = 0,
+                                 long style = 0,
                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,
                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,
-                                 int flags = 0);
+                                 int flags = 0,
+                                 long style = 0);
     virtual void DrawSliderTicks(wxDC& dc,
                                  const wxRect& rect,
     virtual void DrawSliderTicks(wxDC& dc,
                                  const wxRect& rect,
-                                 const wxSize& sizeThumb,
+                                 int lenThumb,
                                  wxOrientation orient,
                                  int start,
                                  int end,
                                  int step = 1,
                                  wxOrientation orient,
                                  int start,
                                  int end,
                                  int step = 1,
-                                 int flags = 0);
+                                 int flags = 0,
+                                 long style = 0);
+#endif // wxUSE_SLIDER
 
 
+#if wxUSE_MENUS
     virtual void DrawMenuBarItem(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
     virtual void DrawMenuBarItem(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
@@ -285,43 +190,14 @@ public:
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);
+#endif // wxUSE_MENUS
 
 
+#if wxUSE_STATUSBAR
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
-                                 int flags = 0);
-
-    // titlebars
-    virtual void DrawFrameTitleBar(wxDC& dc,
-                                   const wxRect& rect,
-                                   const wxString& title,
-                                   const wxIcon& icon,
-                                   int flags,
-                                   int specialButton = 0,
-                                   int specialButtonFlags = 0);
-    virtual void DrawFrameBorder(wxDC& dc,
-                                 const wxRect& rect,
-                                 int flags);
-    virtual void DrawFrameBackground(wxDC& dc,
-                                     const wxRect& rect,
-                                     int flags);
-    virtual void DrawFrameTitle(wxDC& dc,
-                                const wxRect& rect,
-                                const wxString& title,
-                                int flags);
-    virtual void DrawFrameIcon(wxDC& dc,
-                               const wxRect& rect,
-                               const wxIcon& icon,
-                               int flags);
-    virtual void DrawFrameButton(wxDC& dc,
-                                 wxCoord x, wxCoord y,
-                                 int button,
-                                 int flags = 0);
-    virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
-    virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
-    virtual wxSize GetFrameMinSize(int flags) const;
-    virtual wxSize GetFrameIconSize() const;
-    virtual int HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const;
+                                 int flags = 0, int style = 0);
+#endif // wxUSE_STATUSBAR
 
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
 
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
@@ -329,22 +205,11 @@ public:
                                  wxBitmap *bmpDisabled);
 
     virtual void AdjustSize(wxSize *size, const wxWindow *window);
                                  wxBitmap *bmpDisabled);
 
     virtual void AdjustSize(wxSize *size, const wxWindow *window);
-    virtual wxRect GetBorderDimensions(wxBorder border) const;
     virtual bool AreScrollbarsInsideBorder() const;
 
     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }
     virtual bool AreScrollbarsInsideBorder() const;
 
     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }
-    virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
-                                    wxScrollBar::Element elem,
-                                    int thumbPos = -1) const;
-    virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
-    virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
-                                       const wxPoint& pt) const;
-    virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
-                                     int thumbPos = -1);
-    virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
-    virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
-        { return fontHeight + 2; }
+
     virtual wxSize GetCheckBitmapSize() const
         { return wxSize(13, 13); }
     virtual wxSize GetRadioBitmapSize() const
     virtual wxSize GetCheckBitmapSize() const
         { return wxSize(13, 13); }
     virtual wxSize GetRadioBitmapSize() const
@@ -352,110 +217,81 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 0; }
 
     virtual wxCoord GetCheckItemMargin() const
         { return 0; }
 
+#if wxUSE_TOOLBAR
     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
         { if ( separator ) *separator = 5; return wxSize(16, 15); }
     virtual wxSize GetToolBarMargin() const
         { return wxSize(4, 4); }
     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
         { if ( separator ) *separator = 5; return wxSize(16, 15); }
     virtual wxSize GetToolBarMargin() const
         { return wxSize(4, 4); }
+#endif // wxUSE_TOOLBAR
 
 
+#if wxUSE_TEXTCTRL
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
                                     const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
                                      wxCoord *extraSpaceBeyond) const;
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
                                     const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
                                      wxCoord *extraSpaceBeyond) const;
+#endif // wxUSE_TEXTCTRL
 
 
+#if wxUSE_NOTEBOOK
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
+#endif // wxUSE_NOTEBOOK
 
 
-    virtual wxCoord GetSliderDim() const { return 20; }
-    virtual wxCoord GetSliderTickLen() const { return 4; }
+#if wxUSE_SLIDER
+
+    virtual wxCoord GetSliderDim() const { return SLIDER_THUMB_LENGTH + 2*BORDER_THICKNESS; }
+    virtual wxCoord GetSliderTickLen() const { return SLIDER_TICK_LENGTH; }
     virtual wxRect GetSliderShaftRect(const wxRect& rect,
     virtual wxRect GetSliderShaftRect(const wxRect& rect,
-                                      wxOrientation orient) const;
+                                      int lenThumb,
+                                      wxOrientation orient,
+                                      long style = 0) const;
     virtual wxSize GetSliderThumbSize(const wxRect& rect,
     virtual wxSize GetSliderThumbSize(const wxRect& rect,
+                                      int lenThumb,
                                       wxOrientation orient) const;
                                       wxOrientation orient) const;
+#endif // wxUSE_SLIDER
+
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 
+#if wxUSE_MENUS
     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
                                                 const wxMenu& menu) const;
     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
                                                 const wxMenu& menu) const;
-
-    virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
+#endif // wxUSE_MENUS
 
 protected:
 
 protected:
-    // helper of DrawLabel() and DrawCheckOrRadioButton()
-    void DoDrawLabel(wxDC& dc,
-                     const wxString& label,
-                     const wxRect& rect,
-                     int flags = 0,
-                     int alignment = wxALIGN_LEFT | wxALIGN_TOP,
-                     int indexAccel = -1,
-                     wxRect *rectBounds = NULL,
-                     const wxPoint& focusOffset
-                        = wxPoint(FOCUS_RECT_OFFSET_X, FOCUS_RECT_OFFSET_Y));
-
-    // common part of DrawLabel() and DrawItem()
-    void DrawFocusRect(wxDC& dc, const wxRect& rect);
-
-    // DrawLabel() and DrawButtonLabel() helper
-    void DrawLabelShadow(wxDC& dc,
-                         const wxString& label,
-                         const wxRect& rect,
-                         int alignment,
-                         int indexAccel);
-
-    // DrawButtonBorder() helper
-    void DoDrawBackground(wxDC& dc,
-                          const wxColour& col,
-                          const wxRect& rect,
-                          wxWindow *window = NULL );
-
-    // DrawBorder() helpers: all of them shift and clip the DC after drawing
-    // the border
-
-    // just draw a rectangle with the given pen
-    void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
-    // draw the lower left part of rectangle
-    void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
-    // draw the rectange using the first brush for the left and top sides and
-    // the second one for the bottom and right ones
-    void DrawShadedRect(wxDC& dc, wxRect *rect,
-                        const wxPen& pen1, const wxPen& pen2);
-
-    // draw the normal 3D border
-    void DrawRaisedBorder(wxDC& dc, wxRect *rect);
+    // overridden wxStdRenderer methods
+    virtual void DrawFrameWithLabel(wxDC& dc,
+                                    const wxString& label,
+                                    const wxRect& rectFrame,
+                                    const wxRect& rectText,
+                                    int flags,
+                                    int alignment,
+                                    int indexAccel);
+
+    virtual void DrawCheckItemBitmap(wxDC& dc,
+                                     const wxBitmap& bitmap,
+                                     const wxRect& rect,
+                                     int flags);
 
 
-    // draw the sunken 3D border
-    void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 
     // draw the border used for scrollbar arrows
 
     // draw the border used for scrollbar arrows
-    void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
+    void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = false);
 
     // public DrawArrow()s helper
     void DrawArrow(wxDC& dc, const wxRect& rect,
 
     // public DrawArrow()s helper
     void DrawArrow(wxDC& dc, const wxRect& rect,
-                   wxArrowDirection arrowDir, wxArrowStyle arrowStyle);
+                   ArrowDirection arrowDir, ArrowStyle arrowStyle);
 
     // DrawArrowButton is used by DrawScrollbar and DrawComboButton
     void DrawArrowButton(wxDC& dc, const wxRect& rect,
 
     // DrawArrowButton is used by DrawScrollbar and DrawComboButton
     void DrawArrowButton(wxDC& dc, const wxRect& rect,
-                         wxArrowDirection arrowDir,
-                         wxArrowStyle arrowStyle);
-
-    // DrawCheckButton/DrawRadioButton helper
-    void DrawCheckOrRadioButton(wxDC& dc,
-                                const wxString& label,
-                                const wxBitmap& bitmap,
-                                const wxRect& rect,
-                                int flags,
-                                wxAlignment align,
-                                int indexAccel,
-                                wxCoord focusOffsetY);
+                         ArrowDirection arrowDir,
+                         ArrowStyle arrowStyle);
 
     // draw a normal or transposed line (useful for using the same code fo both
     // horizontal and vertical widgets)
     void DrawLine(wxDC& dc,
                   wxCoord x1, wxCoord y1,
                   wxCoord x2, wxCoord y2,
 
     // draw a normal or transposed line (useful for using the same code fo both
     // horizontal and vertical widgets)
     void DrawLine(wxDC& dc,
                   wxCoord x1, wxCoord y1,
                   wxCoord x2, wxCoord y2,
-                  bool transpose = FALSE)
+                  bool transpose = false)
     {
         if ( transpose )
             dc.DrawLine(y1, x1, y2, x2);
     {
         if ( transpose )
             dc.DrawLine(y1, x1, y2, x2);
@@ -465,39 +301,35 @@ protected:
 
     // get the standard check/radio button bitmap
     wxBitmap GetIndicator(IndicatorType indType, int flags);
 
     // get the standard check/radio button bitmap
     wxBitmap GetIndicator(IndicatorType indType, int flags);
-    wxBitmap GetCheckBitmap(int flags)
+    virtual wxBitmap GetCheckBitmap(int flags)
         { return GetIndicator(IndicatorType_Check, flags); }
         { return GetIndicator(IndicatorType_Check, flags); }
-    wxBitmap GetRadioBitmap(int flags)
+    virtual wxBitmap GetRadioBitmap(int flags)
         { return GetIndicator(IndicatorType_Radio, flags); }
 
         { return GetIndicator(IndicatorType_Radio, flags); }
 
-private:
-    const wxColourScheme *m_scheme;
+    virtual wxBitmap GetFrameButtonBitmap(FrameButtonType type);
 
 
+private:
     // the sizing parameters (TODO make them changeable)
     wxSize m_sizeScrollbarArrow;
 
     // the sizing parameters (TODO make them changeable)
     wxSize m_sizeScrollbarArrow;
 
-    // GDI objects we use for drawing
-    wxColour m_colDarkGrey,
-             m_colHighlight;
-
-    wxPen m_penBlack,
-          m_penDarkGrey,
-          m_penLightGrey,
-          m_penHighlight;
-
-    wxFont m_titlebarFont;
-
-    // the checked and unchecked bitmaps for DrawCheckItem()
+    // the checked and unchecked bitmaps for DrawCheckItemBitmap()
     wxBitmap m_bmpCheckBitmaps[IndicatorStatus_Max];
 
     // the bitmaps returned by GetIndicator()
     wxBitmap m_bmpIndicators[IndicatorType_Max]
     wxBitmap m_bmpCheckBitmaps[IndicatorStatus_Max];
 
     // the bitmaps returned by GetIndicator()
     wxBitmap m_bmpIndicators[IndicatorType_Max]
-                            [IndicatorState_Max]
+                            [IndicatorState_MaxMenu]
                             [IndicatorStatus_Max];
 
     // titlebar icons:
     wxBitmap m_bmpFrameButtons[FrameButton_Max];
 
                             [IndicatorStatus_Max];
 
     // titlebar icons:
     wxBitmap m_bmpFrameButtons[FrameButton_Max];
 
+    // standard defaults for the above bitmaps
+    static const char **ms_xpmChecked[IndicatorStatus_Max];
+    static const char **ms_xpmIndicators[IndicatorType_Max]
+                                        [IndicatorState_MaxMenu]
+                                        [IndicatorStatus_Max];
+    static const char **ms_xpmFrameButtons[FrameButton_Max];
+
     // first row is for the normal state, second - for the disabled
     wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
 };
     // first row is for the normal state, second - for the disabled
     wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
 };
@@ -510,34 +342,33 @@ private:
 class wxWin32InputHandler : public wxInputHandler
 {
 public:
 class wxWin32InputHandler : public wxInputHandler
 {
 public:
-    wxWin32InputHandler(wxWin32Renderer *renderer);
+    wxWin32InputHandler() { }
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
-
-protected:
-    wxWin32Renderer *m_renderer;
 };
 
 };
 
+#if wxUSE_SCROLLBAR
 class wxWin32ScrollBarInputHandler : public wxStdScrollBarInputHandler
 {
 public:
 class wxWin32ScrollBarInputHandler : public wxStdScrollBarInputHandler
 {
 public:
-    wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
+    wxWin32ScrollBarInputHandler(wxRenderer *renderer,
                                  wxInputHandler *handler);
 
                                  wxInputHandler *handler);
 
-    virtual bool HandleMouse(wxInputConsumer *control, const wxMouseEvent& event);
-    virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
+    virtual bool HandleMouse(wxInputConsumer *control,
+                             const wxMouseEvent& event);
+    virtual bool HandleMouseMove(wxInputConsumer *control,
+                                 const wxMouseEvent& event);
 
     virtual bool OnScrollTimer(wxScrollBar *scrollbar,
                                const wxControlAction& action);
 
 protected:
 
     virtual bool OnScrollTimer(wxScrollBar *scrollbar,
                                const wxControlAction& action);
 
 protected:
-    virtual bool IsAllowedButton(int button) { return button == 1; }
-
-    virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
+    virtual void Highlight(wxScrollBar * WXUNUSED(scrollbar),
+                           bool WXUNUSED(doIt))
     {
         // we don't highlight anything
     }
     {
         // we don't highlight anything
     }
@@ -552,28 +383,33 @@ protected:
     // we remember the interval of the timer to be able to restart it
     int m_interval;
 };
     // we remember the interval of the timer to be able to restart it
     int m_interval;
 };
+#endif // wxUSE_SCROLLBAR
 
 
-class wxWin32CheckboxInputHandler : public wxStdCheckboxInputHandler
+#if wxUSE_CHECKBOX
+class wxWin32CheckboxInputHandler : public wxStdInputHandler
 {
 public:
     wxWin32CheckboxInputHandler(wxInputHandler *handler)
 {
 public:
     wxWin32CheckboxInputHandler(wxInputHandler *handler)
-        : wxStdCheckboxInputHandler(handler) { }
+        : wxStdInputHandler(handler) { }
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
+#endif // wxUSE_CHECKBOX
 
 
-class wxWin32TextCtrlInputHandler : public wxStdTextCtrlInputHandler
+#if wxUSE_TEXTCTRL
+class wxWin32TextCtrlInputHandler : public wxStdInputHandler
 {
 public:
     wxWin32TextCtrlInputHandler(wxInputHandler *handler)
 {
 public:
     wxWin32TextCtrlInputHandler(wxInputHandler *handler)
-        : wxStdTextCtrlInputHandler(handler) { }
+        : wxStdInputHandler(handler) { }
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
+#endif // wxUSE_TEXTCTRL
 
 class wxWin32StatusBarInputHandler : public wxStdInputHandler
 {
 
 class wxWin32StatusBarInputHandler : public wxStdInputHandler
 {
@@ -600,18 +436,20 @@ private:
 
 class wxWin32SystemMenuEvtHandler;
 
 
 class wxWin32SystemMenuEvtHandler;
 
-class wxWin32FrameInputHandler : public wxStdFrameInputHandler
+class wxWin32FrameInputHandler : public wxStdInputHandler
 {
 public:
     wxWin32FrameInputHandler(wxInputHandler *handler);
 {
 public:
     wxWin32FrameInputHandler(wxInputHandler *handler);
-    ~wxWin32FrameInputHandler();
+    virtual ~wxWin32FrameInputHandler();
 
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
 
     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
 
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
 
     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
-                             
-    void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
+
+#if wxUSE_MENUS
+    void PopupSystemMenu(wxTopLevelWindow *window) const;
+#endif // wxUSE_MENUS
 
 private:
     // was the mouse over the grip last time we checked?
 
 private:
     // was the mouse over the grip last time we checked?
@@ -645,7 +483,7 @@ protected:
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 
-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
 
 class wxWin32Theme : public wxTheme
 {
 
 class wxWin32Theme : public wxTheme
 {
@@ -655,15 +493,13 @@ public:
 
     virtual wxRenderer *GetRenderer();
     virtual wxArtProvider *GetArtProvider();
 
     virtual wxRenderer *GetRenderer();
     virtual wxArtProvider *GetArtProvider();
-    virtual wxInputHandler *GetInputHandler(const wxString& control);
+    virtual wxInputHandler *GetInputHandler(const wxString& control,
+                                            wxInputConsumer *consumer);
     virtual wxColourScheme *GetColourScheme();
 
 private:
     virtual wxColourScheme *GetColourScheme();
 
 private:
-    // get the default input handler
-    wxInputHandler *GetDefaultInputHandler();
-
     wxWin32Renderer *m_renderer;
     wxWin32Renderer *m_renderer;
-    
+
     wxWin32ArtProvider *m_artProvider;
 
     // the names of the already created handlers and the handlers themselves
     wxWin32ArtProvider *m_artProvider;
 
     // the names of the already created handlers and the handlers themselves
@@ -671,8 +507,6 @@ private:
     wxSortedArrayString m_handlerNames;
     wxArrayHandlers m_handlers;
 
     wxSortedArrayString m_handlerNames;
     wxArrayHandlers m_handlers;
 
-    wxWin32InputHandler *m_handlerDefault;
-
     wxWin32ColourScheme *m_scheme;
 
     WX_DECLARE_THEME(win32)
     wxWin32ColourScheme *m_scheme;
 
     WX_DECLARE_THEME(win32)
@@ -683,56 +517,55 @@ private:
 // ----------------------------------------------------------------------------
 
 // frame buttons bitmaps
 // ----------------------------------------------------------------------------
 
 // frame buttons bitmaps
-
 static const char *frame_button_close_xpm[] = {
 "12 10 2 1",
 "         c None",
 static const char *frame_button_close_xpm[] = {
 "12 10 2 1",
 "         c None",
-".        c black",
+"X        c black",
 "            ",
 "            ",
-"  ..    ..  ",
-"   ..  ..   ",
-"    ....    ",
-"     ..     ",
-"    ....    ",
-"   ..  ..   ",
-"  ..    ..  ",
+"  XX    XX  ",
+"   XX  XX   ",
+"    XXXX    ",
+"     XX     ",
+"    XXXX    ",
+"   XX  XX   ",
+"  XX    XX  ",
 "            ",
 "            "};
 
 static const char *frame_button_help_xpm[] = {
 "12 10 2 1",
 "         c None",
 "            ",
 "            "};
 
 static const char *frame_button_help_xpm[] = {
 "12 10 2 1",
 "         c None",
-".        c #000000",
-"    ....    ",
-"   ..  ..   ",
-"   ..  ..   ",
-"      ..    ",
-"     ..     ",
-"     ..     ",
+"X        c #000000",
+"    XXXX    ",
+"   XX  XX   ",
+"   XX  XX   ",
+"      XX    ",
+"     XX     ",
+"     XX     ",
 "            ",
 "            ",
-"     ..     ",
-"     ..     ",
+"     XX     ",
+"     XX     ",
 "            "};
 
 static const char *frame_button_maximize_xpm[] = {
 "12 10 2 1",
 "         c None",
 "            "};
 
 static const char *frame_button_maximize_xpm[] = {
 "12 10 2 1",
 "         c None",
-".        c #000000",
-" .........  ",
-" .........  ",
-" .       .  ",
-" .       .  ",
-" .       .  ",
-" .       .  ",
-" .       .  ",
-" .       .  ",
-" .........  ",
+"X        c #000000",
+" XXXXXXXXX  ",
+" XXXXXXXXX  ",
+" X       X  ",
+" X       X  ",
+" X       X  ",
+" X       X  ",
+" X       X  ",
+" X       X  ",
+" XXXXXXXXX  ",
 "            "};
 
 static const char *frame_button_minimize_xpm[] = {
 "12 10 2 1",
 "         c None",
 "            "};
 
 static const char *frame_button_minimize_xpm[] = {
 "12 10 2 1",
 "         c None",
-".        c #000000",
+"X        c #000000",
 "            ",
 "            ",
 "            ",
 "            ",
 "            ",
 "            ",
@@ -740,25 +573,34 @@ static const char *frame_button_minimize_xpm[] = {
 "            ",
 "            ",
 "            ",
 "            ",
 "            ",
 "            ",
-"  ......    ",
-"  ......    ",
+"  XXXXXX    ",
+"  XXXXXX    ",
 "            "};
 
 static const char *frame_button_restore_xpm[] = {
 "12 10 2 1",
 "         c None",
 "            "};
 
 static const char *frame_button_restore_xpm[] = {
 "12 10 2 1",
 "         c None",
-".        c #000000",
-"   ......   ",
-"   ......   ",
-"   .    .   ",
-" ...... .   ",
-" ...... .   ",
-" .    ...   ",
-" .    .     ",
-" .    .     ",
-" ......     ",
+"X        c #000000",
+"   XXXXXX   ",
+"   XXXXXX   ",
+"   X    X   ",
+" XXXXXX X   ",
+" XXXXXX X   ",
+" X    XXX   ",
+" X    X     ",
+" X    X     ",
+" XXXXXX     ",
 "            "};
 
 "            "};
 
+const char **wxWin32Renderer::ms_xpmFrameButtons[FrameButton_Max] =
+{
+    frame_button_close_xpm,
+    frame_button_minimize_xpm,
+    frame_button_maximize_xpm,
+    frame_button_restore_xpm,
+    frame_button_help_xpm,
+};
+
 // menu bitmaps
 
 static const char *checked_menu_xpm[] = {
 // menu bitmaps
 
 static const char *checked_menu_xpm[] = {
@@ -992,6 +834,54 @@ static const char *unchecked_item_xpm[] = {
 "wwwwwwwwwwwww"
 };
 
 "wwwwwwwwwwwww"
 };
 
+static const char *undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #030303",
+"B c #838383",
+"C c #C3C3C3",
+"D c #FBFBFB",
+"E c #DBDBDB",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACDCDCDCDCED",
+"BADCDCDCDBDED",
+"BACDCDCDBBCED",
+"BADBDCEBBBDED",
+"BACBBDBBBDCED",
+"BADBBBBBDCDED",
+"BACDBBBDCDCED",
+"BADCDBDCDCDED",
+"BACDCDCDCDCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+
+static const char *pressed_undetermined_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"13 13 5 1",
+"A c #040404",
+"B c #848484",
+"C c #C4C4C4",
+"D c #FCFCFC",
+"E c #DCDCDC",
+/* pixels */
+"BBBBBBBBBBBBD",
+"BAAAAAAAAAAED",
+"BACCCCCCCCCCD",
+"BACCCCCCCACED",
+"BACCCCCCAACED",
+"BACACCCAAACED",
+"BACAACAAACCED",
+"BACAAAAACCCED",
+"BACCAAACCCCCD",
+"BACCCACCCCCED",
+"BACCCCCCCCCED",
+"BEEEEEEEEEEED",
+"DDDDDDDDDDDDD"
+};
+
 static const char *checked_radio_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "12 12 6 1",
 static const char *checked_radio_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "12 12 6 1",
@@ -1112,50 +1002,51 @@ static const char *pressed_unchecked_radio_xpm[] = {
 "    hhhh    "
 };
 
 "    hhhh    "
 };
 
-static const char **
-    xpmIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
+const char **wxWin32Renderer::ms_xpmIndicators[IndicatorType_Max]
+                                              [IndicatorState_MaxMenu]
+                                              [IndicatorStatus_Max] =
 {
     // checkboxes first
     {
         // normal state
 {
     // checkboxes first
     {
         // normal state
-        { checked_xpm, unchecked_xpm },
+        { checked_xpm, unchecked_xpm, undetermined_xpm },
 
         // pressed state
 
         // pressed state
-        { pressed_checked_xpm, pressed_unchecked_xpm },
+        { pressed_checked_xpm, pressed_unchecked_xpm, pressed_undetermined_xpm },
 
         // disabled state
 
         // disabled state
-        { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
+        { pressed_disabled_checked_xpm, pressed_unchecked_xpm, pressed_disabled_checked_xpm },
     },
 
     // radio
     {
         // normal state
     },
 
     // radio
     {
         // normal state
-        { checked_radio_xpm, unchecked_radio_xpm },
+        { checked_radio_xpm, unchecked_radio_xpm, NULL },
 
         // pressed state
 
         // pressed state
-        { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
+        { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },
 
         // disabled state
 
         // disabled state
-        { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
+        { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm, NULL },
     },
 
     // menu
     {
         // normal state
     },
 
     // menu
     {
         // normal state
-        { checked_menu_xpm, NULL },
+        { checked_menu_xpm, NULL, NULL },
 
         // selected state
 
         // selected state
-        { selected_checked_menu_xpm, NULL },
+        { selected_checked_menu_xpm, NULL, NULL },
 
         // disabled state
 
         // disabled state
-        { disabled_checked_menu_xpm, NULL },
+        { disabled_checked_menu_xpm, NULL, NULL },
 
         // disabled selected state
 
         // disabled selected state
-        { selected_disabled_checked_menu_xpm, NULL },
+        { selected_disabled_checked_menu_xpm, NULL, NULL },
     }
 };
 
     }
 };
 
-static const char **xpmChecked[IndicatorStatus_Max] =
+const char **wxWin32Renderer::ms_xpmChecked[IndicatorStatus_Max] =
 {
     checked_item_xpm,
     unchecked_item_xpm
 {
     checked_item_xpm,
     unchecked_item_xpm
@@ -1175,24 +1066,14 @@ wxWin32Theme::wxWin32Theme()
 {
     m_scheme = NULL;
     m_renderer = NULL;
 {
     m_scheme = NULL;
     m_renderer = NULL;
-    m_handlerDefault = NULL;
     m_artProvider = NULL;
 }
 
 wxWin32Theme::~wxWin32Theme()
 {
     m_artProvider = NULL;
 }
 
 wxWin32Theme::~wxWin32Theme()
 {
-    size_t count = m_handlers.GetCount();
-    for ( size_t n = 0; n < count; n++ )
-    {
-        if ( m_handlers[n] != m_handlerDefault )
-            delete m_handlers[n];
-    }
-
-    delete m_handlerDefault;
-
     delete m_renderer;
     delete m_scheme;
     delete m_renderer;
     delete m_scheme;
-    wxArtProvider::RemoveProvider(m_artProvider);
+    delete m_artProvider;
 }
 
 wxRenderer *wxWin32Theme::GetRenderer()
 }
 
 wxRenderer *wxWin32Theme::GetRenderer()
@@ -1215,74 +1096,63 @@ wxArtProvider *wxWin32Theme::GetArtProvider()
     return m_artProvider;
 }
 
     return m_artProvider;
 }
 
-wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
-{
-    if ( !m_handlerDefault )
-    {
-        m_handlerDefault = new wxWin32InputHandler(m_renderer);
-    }
-
-    return m_handlerDefault;
-}
-
-wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
+wxInputHandler *
+wxWin32Theme::GetInputHandler(const wxString& control,
+                              wxInputConsumer *consumer)
 {
 {
-    wxInputHandler *handler;
+    wxInputHandler *handler = NULL;
     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {
     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {
+        static wxWin32InputHandler s_handlerDef;
+
+        wxInputHandler * const
+          handlerStd = consumer->DoGetStdInputHandler(&s_handlerDef);
+
         // create a new handler
         // create a new handler
-        if ( control == wxINP_HANDLER_SCROLLBAR )
-            handler = new wxWin32ScrollBarInputHandler(m_renderer,
-                                                       GetDefaultInputHandler());
-#if wxUSE_BUTTON
-        else if ( control == wxINP_HANDLER_BUTTON )
-            handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_BUTTON
+        if ( control == wxINP_HANDLER_TOPLEVEL )
+        {
+            static wxWin32FrameInputHandler s_handler(handlerStd);
+
+            handler = &s_handler;
+        }
 #if wxUSE_CHECKBOX
         else if ( control == wxINP_HANDLER_CHECKBOX )
 #if wxUSE_CHECKBOX
         else if ( control == wxINP_HANDLER_CHECKBOX )
-            handler = new wxWin32CheckboxInputHandler(GetDefaultInputHandler());
+        {
+            static wxWin32CheckboxInputHandler s_handler(handlerStd);
+
+            handler = &s_handler;
+        }
 #endif // wxUSE_CHECKBOX
 #endif // wxUSE_CHECKBOX
-#if wxUSE_COMBOBOX
-        else if ( control == wxINP_HANDLER_COMBOBOX )
-            handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_COMBOBOX
-#if wxUSE_LISTBOX
-        else if ( control == wxINP_HANDLER_LISTBOX )
-            handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_LISTBOX
-#if wxUSE_CHECKLISTBOX
-        else if ( control == wxINP_HANDLER_CHECKLISTBOX )
-            handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_CHECKLISTBOX
-#if wxUSE_TEXTCTRL
-        else if ( control == wxINP_HANDLER_TEXTCTRL )
-            handler = new wxWin32TextCtrlInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_TEXTCTRL
-#if wxUSE_SLIDER
-        else if ( control == wxINP_HANDLER_SLIDER )
-            handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SLIDER
-#if wxUSE_SPINBTN
-        else if ( control == wxINP_HANDLER_SPINBTN )
-            handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SPINBTN
-#if wxUSE_NOTEBOOK
-        else if ( control == wxINP_HANDLER_NOTEBOOK )
-            handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_NOTEBOOK
+#if wxUSE_SCROLLBAR
+        else if ( control == wxINP_HANDLER_SCROLLBAR )
+        {
+            static wxWin32ScrollBarInputHandler
+                s_handler(GetRenderer(), handlerStd);
+
+            handler = &s_handler;
+        }
+#endif // wxUSE_SCROLLBAR
 #if wxUSE_STATUSBAR
         else if ( control == wxINP_HANDLER_STATUSBAR )
 #if wxUSE_STATUSBAR
         else if ( control == wxINP_HANDLER_STATUSBAR )
-            handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
+        {
+            static wxWin32StatusBarInputHandler s_handler(handlerStd);
+
+            handler = &s_handler;
+        }
 #endif // wxUSE_STATUSBAR
 #endif // wxUSE_STATUSBAR
-#if wxUSE_TOOLBAR
-        else if ( control == wxINP_HANDLER_TOOLBAR )
-            handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_TOOLBAR
-        else if ( control == wxINP_HANDLER_TOPLEVEL )
-            handler = new wxWin32FrameInputHandler(GetDefaultInputHandler());
-        else
-            handler = GetDefaultInputHandler();
+#if wxUSE_TEXTCTRL
+        else if ( control == wxINP_HANDLER_TEXTCTRL )
+        {
+            static wxWin32TextCtrlInputHandler s_handler(handlerStd);
+
+            handler = &s_handler;
+        }
+#endif // wxUSE_TEXTCTRL
+        else // no special handler for this control
+        {
+            handler = handlerStd;
+        }
 
         n = m_handlerNames.Add(control);
         m_handlers.Insert(handler, n);
 
         n = m_handlerNames.Add(control);
         m_handlers.Insert(handler, n);
@@ -1317,21 +1187,37 @@ wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
         col = win->GetBackgroundColour();
     }
 
         col = win->GetBackgroundColour();
     }
 
-    if ( win->IsContainerWindow() )
+    if ( !win->ShouldInheritColours() )
     {
     {
+#if wxUSE_TEXTCTRL
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
-        if ( text )
+#endif // wxUSE_TEXTCTRL
+#if wxUSE_LISTBOX
+        wxListBox* listBox = wxDynamicCast(win, wxListBox);
+#endif // wxUSE_LISTBOX
+
+#if wxUSE_TEXTCTRL
+        if ( text
+#if wxUSE_LISTBOX
+         || listBox
+#endif
+          )
         {
         {
-            if ( !text->IsEnabled() ) // not IsEditable()
+            if ( !win->IsEnabled() ) // not IsEditable()
                 col = Get(CONTROL);
                 col = Get(CONTROL);
-            //else: execute code below
+            else
+            {
+                if ( !col.Ok() )
+                {
+                    // doesn't depend on the state
+                    col = Get(WINDOW);
+                }
+            }
         }
         }
+#endif // wxUSE_TEXTCTRL
 
 
-        if ( !col.Ok() )
-        {
-            // doesn't depend on the state
-            col = Get(WINDOW);
-        }
+        if (!col.Ok())
+            col = Get(CONTROL); // Most controls should be this colour, not WINDOW
     }
     else
     {
     }
     else
     {
@@ -1341,10 +1227,12 @@ wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
         // and for the states for which we don't have any specific colours
         if ( !col.Ok() || (flags & wxCONTROL_PRESSED) != 0 )
         {
         // and for the states for which we don't have any specific colours
         if ( !col.Ok() || (flags & wxCONTROL_PRESSED) != 0 )
         {
+#if wxUSE_SCROLLBAR
             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
                                                     : SCROLLBAR);
             else
             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
                                                     : SCROLLBAR);
             else
+#endif // wxUSE_SCROLLBAR
                 col = Get(CONTROL);
         }
     }
                 col = Get(CONTROL);
         }
     }
@@ -1396,6 +1284,7 @@ wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
         case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
 
         case DESKTOP:           return wxColour(0x808000);
         case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
 
         case DESKTOP:           return wxColour(0x808000);
+        case FRAME:             return wxColour(GetSysColor(COLOR_APPWORKSPACE));
 #else // !__WXMSW__
         // use the standard Windows colours elsewhere
         case WINDOW:            return *wxWHITE;
 #else // !__WXMSW__
         // use the standard Windows colours elsewhere
         case WINDOW:            return *wxWHITE;
@@ -1428,6 +1317,7 @@ wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
         case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
 
         case DESKTOP:           return wxColour(0x808000);
         case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
 
         case DESKTOP:           return wxColour(0x808000);
+        case FRAME:             return wxColour(0x808080);
 #endif // __WXMSW__
 
         case GAUGE:             return Get(HIGHLIGHT);
 #endif // __WXMSW__
 
         case GAUGE:             return Get(HIGHLIGHT);
@@ -1448,25 +1338,11 @@ wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
 // ----------------------------------------------------------------------------
 
 wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
 // ----------------------------------------------------------------------------
 
 wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
+               : wxStdRenderer(scheme)
 {
     // init data
 {
     // init data
-    m_scheme = scheme;
     m_sizeScrollbarArrow = wxSize(16, 16);
 
     m_sizeScrollbarArrow = wxSize(16, 16);
 
-    // init colours and pens
-    m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
-
-    m_colDarkGrey = wxSCHEME_COLOUR(scheme, SHADOW_OUT);
-    m_penDarkGrey = wxPen(m_colDarkGrey, 0, wxSOLID);
-
-    m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
-
-    m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
-    m_penHighlight = wxPen(m_colHighlight, 0, wxSOLID);
-
-    m_titlebarFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
-    m_titlebarFont.SetWeight(wxFONTWEIGHT_BOLD);
-
     // init the arrow bitmaps
     static const size_t ARROW_WIDTH = 7;
     static const size_t ARROW_LENGTH = 4;
     // init the arrow bitmaps
     static const size_t ARROW_WIDTH = 7;
     static const size_t ARROW_LENGTH = 4;
@@ -1599,31 +1475,31 @@ wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
 
         }
 
 
         }
 
-        // create the inversed bitmap but only for the right arrow as we only
+        // create the inverted bitmap but only for the right arrow as we only
         // use it for the menus
         if ( n == Arrow_Right )
         {
         // use it for the menus
         if ( n == Arrow_Right )
         {
-            m_bmpArrows[Arrow_Inversed][n].Create(w, h);
-            dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
+            m_bmpArrows[Arrow_Inverted][n].Create(w, h);
+            dcInverse.SelectObject(m_bmpArrows[Arrow_Inverted][n]);
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcNormal, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcNormal, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
-            mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
-            m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
+            mask = new wxMask(m_bmpArrows[Arrow_Inverted][n], *wxBLACK);
+            m_bmpArrows[Arrow_Inverted][n].SetMask(mask);
 
 
-            m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
-            dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
+            m_bmpArrows[Arrow_InvertedDisabled][n].Create(w, h);
+            dcInverse.SelectObject(m_bmpArrows[Arrow_InvertedDisabled][n]);
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcDisabled, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
             dcInverse.Clear();
             dcInverse.Blit(0, 0, w, h,
                           &dcDisabled, 0, 0,
                           wxXOR);
             dcInverse.SelectObject(wxNullBitmap);
 
-            mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
-            m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
+            mask = new wxMask(m_bmpArrows[Arrow_InvertedDisabled][n], *wxBLACK);
+            m_bmpArrows[Arrow_InvertedDisabled][n].SetMask(mask);
         }
 
         dcNormal.SelectObject(wxNullBitmap);
         }
 
         dcNormal.SelectObject(wxNullBitmap);
@@ -1636,608 +1512,127 @@ wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
 
         m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
     }
 
         m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
     }
+}
 
 
-    // init the frame buttons bitmaps
-    m_bmpFrameButtons[FrameButton_Close] = wxBitmap(frame_button_close_xpm);
-    m_bmpFrameButtons[FrameButton_Minimize] = wxBitmap(frame_button_minimize_xpm);
-    m_bmpFrameButtons[FrameButton_Maximize] = wxBitmap(frame_button_maximize_xpm);
-    m_bmpFrameButtons[FrameButton_Restore] = wxBitmap(frame_button_restore_xpm);
-    m_bmpFrameButtons[FrameButton_Help] = wxBitmap(frame_button_help_xpm);
+bool wxWin32Renderer::AreScrollbarsInsideBorder() const
+{
+    return true;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
-// border stuff
+// label
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-/*
-   The raised border in Win32 looks like this:
-
-   IIIIIIIIIIIIIIIIIIIIIIB
-   I                    GB
-   I                    GB  I = white       (HILIGHT)
-   I                    GB  H = light grey  (LIGHT)
-   I                    GB  G = dark grey   (SHADOI)
-   I                    GB  B = black       (DKSHADOI)
-   I                    GB  I = hIghlight (COLOR_3DHILIGHT)
-   I                    GB
-   IGGGGGGGGGGGGGGGGGGGGGB
-   BBBBBBBBBBBBBBBBBBBBBBB
-
-   The sunken border looks like this:
-
-   GGGGGGGGGGGGGGGGGGGGGGI
-   GBBBBBBBBBBBBBBBBBBBBHI
-   GB                   HI
-   GB                   HI
-   GB                   HI
-   GB                   HI
-   GB                   HI
-   GB                   HI
-   GHHHHHHHHHHHHHHHHHHHHHI
-   IIIIIIIIIIIIIIIIIIIIIII
-
-   The static border (used for the controls which don't get focus) is like
-   this:
-
-   GGGGGGGGGGGGGGGGGGGGGGW
-   G                     W
-   G                     W
-   G                     W
-   G                     W
-   G                     W
-   G                     W
-   G                     W
-   WWWWWWWWWWWWWWWWWWWWWWW
-
-   The most complicated is the double border:
-
-   HHHHHHHHHHHHHHHHHHHHHHB
-   HWWWWWWWWWWWWWWWWWWWWGB
-   HWHHHHHHHHHHHHHHHHHHHGB
-   HWH                 HGB
-   HWH                 HGB
-   HWH                 HGB
-   HWH                 HGB
-   HWHHHHHHHHHHHHHHHHHHHGB
-   HGGGGGGGGGGGGGGGGGGGGGB
-   BBBBBBBBBBBBBBBBBBBBBBB
-
-   And the simple border is, well, simple:
-
-   BBBBBBBBBBBBBBBBBBBBBBB
-   B                     B
-   B                     B
-   B                     B
-   B                     B
-   B                     B
-   B                     B
-   B                     B
-   B                     B
-   BBBBBBBBBBBBBBBBBBBBBBB
-*/
-
-void wxWin32Renderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
+void wxWin32Renderer::DrawLabel(wxDC& dc,
+                                const wxString& label,
+                                const wxRect& rect,
+                                int flags,
+                                int alignment,
+                                int indexAccel,
+                                wxRect *rectBounds)
 {
 {
-    // draw
-    dc.SetPen(pen);
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
-    dc.DrawRectangle(*rect);
+    // the underscores are not drawn for focused controls in wxMSW
+    if ( flags & wxCONTROL_FOCUSED )
+    {
+        indexAccel = -1;
+    }
 
 
-    // adjust the rect
-    rect->Inflate(-1);
-}
+    if ( flags & wxCONTROL_DISABLED )
+    {
+        // the combination of wxCONTROL_SELECTED and wxCONTROL_DISABLED
+        // currently only can happen for a menu item and it seems that Windows
+        // doesn't draw the shadow in this case, so we don't do it neither
+        if ( flags & wxCONTROL_SELECTED )
+        {
+            // just make the label text greyed out
+            dc.SetTextForeground(m_penDarkGrey.GetColour());
 
 
-void wxWin32Renderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
-{
-    // draw the bottom and right sides
-    dc.SetPen(pen);
-    dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
-                rect->GetRight() + 1, rect->GetBottom());
-    dc.DrawLine(rect->GetRight(), rect->GetTop(),
-                rect->GetRight(), rect->GetBottom());
-
-    // adjust the rect
-    rect->width--;
-    rect->height--;
-}
+            flags &= ~wxCONTROL_DISABLED;
+        }
+    }
 
 
-void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
-                                     const wxPen& pen1, const wxPen& pen2)
-{
-    // draw the rectangle
-    dc.SetPen(pen1);
-    dc.DrawLine(rect->GetLeft(), rect->GetTop(),
-                rect->GetLeft(), rect->GetBottom());
-    dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
-                rect->GetRight(), rect->GetTop());
-    dc.SetPen(pen2);
-    dc.DrawLine(rect->GetRight(), rect->GetTop(),
-                rect->GetRight(), rect->GetBottom());
-    dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
-                rect->GetRight() + 1, rect->GetBottom());
-
-    // adjust the rect
-    rect->Inflate(-1);
+    wxStdRenderer::DrawLabel(dc, label, rect, flags, alignment,
+                             indexAccel, rectBounds);
 }
 
 }
 
-void wxWin32Renderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
+void wxWin32Renderer::DrawFrameWithLabel(wxDC& dc,
+                                         const wxString& label,
+                                         const wxRect& rectFrame,
+                                         const wxRect& rectText,
+                                         int flags,
+                                         int alignment,
+                                         int indexAccel)
 {
 {
-    DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
-    DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
-}
+    wxString label2;
+    label2 << _T(' ') << label << _T(' ');
+    if ( indexAccel != -1 )
+    {
+        // adjust it as we prepended a space
+        indexAccel++;
+    }
 
 
-void wxWin32Renderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
-{
-    DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
-    DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
+    wxStdRenderer::DrawFrameWithLabel(dc, label2, rectFrame, rectText,
+                                      flags, alignment, indexAccel);
 }
 
 }
 
-void wxWin32Renderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
+void wxWin32Renderer::DrawButtonLabel(wxDC& dc,
+                                      const wxString& label,
+                                      const wxBitmap& image,
+                                      const wxRect& rect,
+                                      int flags,
+                                      int alignment,
+                                      int indexAccel,
+                                      wxRect *rectBounds)
 {
 {
-    if ( isPressed )
-    {
-        DrawRect(dc, rect, m_penDarkGrey);
-
-        // the arrow is usually drawn inside border of width 2 and is offset by
-        // another pixel in both directions when it's pressed - as the border
-        // in this case is more narrow as well, we have to adjust rect like
-        // this:
-        rect->Inflate(-1);
-        rect->x++;
-        rect->y++;
-    }
-    else
+    // the underscores are not drawn for focused controls in wxMSW
+    if ( flags & wxCONTROL_PRESSED )
     {
     {
-        DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
-        DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
+        indexAccel = -1;
     }
     }
+
+    wxStdRenderer::DrawButtonLabel(dc, label, image, rect, flags, alignment,
+                                   indexAccel, rectBounds);
 }
 
 }
 
-void wxWin32Renderer::DrawBorder(wxDC& dc,
-                                 wxBorder border,
-                                 const wxRect& rectTotal,
-                                 int WXUNUSED(flags),
-                                 wxRect *rectIn)
+void wxWin32Renderer::DrawButtonBorder(wxDC& dc,
+                                       const wxRect& rectTotal,
+                                       int flags,
+                                       wxRect *rectIn)
 {
 {
-    int i;
-
     wxRect rect = rectTotal;
 
     wxRect rect = rectTotal;
 
-    switch ( border )
-    {
-        case wxBORDER_SUNKEN:
-            for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
-            {
-                DrawSunkenBorder(dc, &rect);
-            }
-            break;
-
-        case wxBORDER_STATIC:
-            DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
-            break;
-
-        case wxBORDER_RAISED:
-            for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
-            {
-                DrawRaisedBorder(dc, &rect);
-            }
-            break;
-
-        case wxBORDER_DOUBLE:
-            DrawArrowBorder(dc, &rect);
-            DrawRect(dc, &rect, m_penLightGrey);
-            break;
-
-        case wxBORDER_SIMPLE:
-            for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
-            {
-                DrawRect(dc, &rect, m_penBlack);
-            }
-            break;
-
-        default:
-            wxFAIL_MSG(_T("unknown border type"));
-            // fall through
-
-        case wxBORDER_DEFAULT:
-        case wxBORDER_NONE:
-            break;
-    }
-
-    if ( rectIn )
-        *rectIn = rect;
-}
-
-wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
-{
-    wxCoord width;
-    switch ( border )
-    {
-        case wxBORDER_RAISED:
-        case wxBORDER_SUNKEN:
-            width = BORDER_THICKNESS;
-            break;
-
-        case wxBORDER_SIMPLE:
-        case wxBORDER_STATIC:
-            width = 1;
-            break;
-
-        case wxBORDER_DOUBLE:
-            width = 3;
-            break;
-
-        default:
-        { 
-            // char *crash = NULL;
-            // *crash = 0;
-            wxFAIL_MSG(_T("unknown border type"));
-            // fall through
-        }
-
-        case wxBORDER_DEFAULT:
-        case wxBORDER_NONE:
-            width = 0;
-            break;
-    }
-
-    wxRect rect;
-    rect.x =
-    rect.y =
-    rect.width =
-    rect.height = width;
-
-    return rect;
-}
-
-bool wxWin32Renderer::AreScrollbarsInsideBorder() const
-{
-    return TRUE;
-}
-
-// ----------------------------------------------------------------------------
-// borders
-// ----------------------------------------------------------------------------
-
-void wxWin32Renderer::DrawTextBorder(wxDC& dc,
-                                     wxBorder border,
-                                     const wxRect& rect,
-                                     int flags,
-                                     wxRect *rectIn)
-{
-    // text controls are not special under windows
-    DrawBorder(dc, border, rect, flags, rectIn);
-}
-
-void wxWin32Renderer::DrawButtonBorder(wxDC& dc,
-                                       const wxRect& rectTotal,
-                                       int flags,
-                                       wxRect *rectIn)
-{
-    wxRect rect = rectTotal;
-
-    if ( flags & wxCONTROL_PRESSED )
+    wxPen penOut(*wxBLACK);
+    if ( flags & wxCONTROL_PRESSED )
     {
         // button pressed: draw a double border around it
     {
         // button pressed: draw a double border around it
-        DrawRect(dc, &rect, m_penBlack);
+        DrawRect(dc, &rect, penOut);
         DrawRect(dc, &rect, m_penDarkGrey);
     }
         DrawRect(dc, &rect, m_penDarkGrey);
     }
-    else
+    else // button not pressed
     {
     {
-        // button not pressed
-
         if ( flags & (wxCONTROL_FOCUSED | wxCONTROL_ISDEFAULT) )
         {
         if ( flags & (wxCONTROL_FOCUSED | wxCONTROL_ISDEFAULT) )
         {
-            // button either default or focused (or both): add an extra border around it
-            DrawRect(dc, &rect, m_penBlack);
+            // button either default or focused (or both): add an extra border
+            // around it
+            DrawRect(dc, &rect, penOut);
         }
 
         }
 
-        // now draw a normal button
-        DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
-        DrawHalfRect(dc, &rect, m_penDarkGrey);
+        // now draw a normal button border
+        DrawRaisedBorder(dc, &rect);
     }
 
     if ( rectIn )
     }
 
     if ( rectIn )
-    {
         *rectIn = rect;
         *rectIn = rect;
-    }
-}
-
-// ----------------------------------------------------------------------------
-// lines and frame
-// ----------------------------------------------------------------------------
-
-void wxWin32Renderer::DrawHorizontalLine(wxDC& dc,
-                                         wxCoord y, wxCoord x1, wxCoord x2)
-{
-    dc.SetPen(m_penDarkGrey);
-    dc.DrawLine(x1, y, x2 + 1, y);
-    dc.SetPen(m_penHighlight);
-    y++;
-    dc.DrawLine(x1, y, x2 + 1, y);
-}
-
-void wxWin32Renderer::DrawVerticalLine(wxDC& dc,
-                                       wxCoord x, wxCoord y1, wxCoord y2)
-{
-    dc.SetPen(m_penDarkGrey);
-    dc.DrawLine(x, y1, x, y2 + 1);
-    dc.SetPen(m_penHighlight);
-    x++;
-    dc.DrawLine(x, y1, x, y2 + 1);
-}
-
-void wxWin32Renderer::DrawFrame(wxDC& dc,
-                                const wxString& label,
-                                const wxRect& rect,
-                                int flags,
-                                int alignment,
-                                int indexAccel)
-{
-    wxCoord height = 0; // of the label
-    wxRect rectFrame = rect;
-    if ( !label.empty() )
-    {
-        // the text should touch the top border of the rect, so the frame
-        // itself should be lower
-        dc.GetTextExtent(label, NULL, &height);
-        rectFrame.y += height / 2;
-        rectFrame.height -= height / 2;
-
-        // we have to draw each part of the frame individually as we can't
-        // erase the background beyond the label as it might contain some
-        // pixmap already, so drawing everything and then overwriting part of
-        // the frame with label doesn't work
-
-        // TODO: the +5 and space insertion should be customizable
-
-        wxRect rectText;
-        rectText.x = rectFrame.x + 5;
-        rectText.y = rect.y;
-        rectText.width = rectFrame.width - 7; // +2 border width
-        rectText.height = height;
-
-        wxString label2;
-        label2 << _T(' ') << label << _T(' ');
-        if ( indexAccel != -1 )
-        {
-            // adjust it as we prepended a space
-            indexAccel++;
-        }
-
-        wxRect rectLabel;
-        DrawLabel(dc, label2, rectText, flags, alignment, indexAccel, &rectLabel);
-
-        StandardDrawFrame(dc, rectFrame, rectLabel);
-    }
-    else
-    {
-        // just draw the complete frame
-        DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
-        DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
-    }
-}
-
-// ----------------------------------------------------------------------------
-// label
-// ----------------------------------------------------------------------------
-
-void wxWin32Renderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
-{
-    // VZ: this doesn't work under Windows, the dotted pen has dots of 3
-    //     pixels each while we really need dots here... PS_ALTERNATE might
-    //     work, but it is for NT 5 only
-#if 0
-    DrawRect(dc, &rect, wxPen(*wxBLACK, 0, wxDOT));
-#else
-    // draw the pixels manually: note that to behave in the same manner as
-    // DrawRect(), we must exclude the bottom and right borders from the
-    // rectangle
-    wxCoord x1 = rect.GetLeft(),
-            y1 = rect.GetTop(),
-            x2 = rect.GetRight(),
-            y2 = rect.GetBottom();
-
-    dc.SetPen(wxPen(*wxBLACK, 0, wxSOLID));
-
-    // this seems to be closer than what Windows does than wxINVERT although
-    // I'm still not sure if it's correct
-    dc.SetLogicalFunction(wxAND_REVERSE);
-
-    wxCoord z;
-    for ( z = x1 + 1; z < x2; z += 2 )
-        dc.DrawPoint(z, rect.GetTop());
-
-    wxCoord shift = z == x2 ? 0 : 1;
-    for ( z = y1 + shift; z < y2; z += 2 )
-        dc.DrawPoint(x2, z);
-
-    shift = z == y2 ? 0 : 1;
-    for ( z = x2 - shift; z > x1; z -= 2 )
-        dc.DrawPoint(z, y2);
-
-    shift = z == x1 ? 0 : 1;
-    for ( z = y2 - shift; z > y1; z -= 2 )
-        dc.DrawPoint(x1, z);
-
-    dc.SetLogicalFunction(wxCOPY);
-#endif // 0/1
-}
-
-void wxWin32Renderer::DrawLabelShadow(wxDC& dc,
-                                      const wxString& label,
-                                      const wxRect& rect,
-                                      int alignment,
-                                      int indexAccel)
-{
-    // draw shadow of the text
-    dc.SetTextForeground(m_colHighlight);
-    wxRect rectShadow = rect;
-    rectShadow.x++;
-    rectShadow.y++;
-    dc.DrawLabel(label, rectShadow, alignment, indexAccel);
-
-    // make the text grey
-    dc.SetTextForeground(m_colDarkGrey);
-}
-
-void wxWin32Renderer::DrawLabel(wxDC& dc,
-                                const wxString& label,
-                                const wxRect& rect,
-                                int flags,
-                                int alignment,
-                                int indexAccel,
-                                wxRect *rectBounds)
-{
-    DoDrawLabel(dc, label, rect, flags, alignment, indexAccel, rectBounds);
-}
-
-void wxWin32Renderer::DoDrawLabel(wxDC& dc,
-                                  const wxString& label,
-                                  const wxRect& rect,
-                                  int flags,
-                                  int alignment,
-                                  int indexAccel,
-                                  wxRect *rectBounds,
-                                  const wxPoint& focusOffset)
-{
-    // the underscores are not drawn for focused controls in wxMSW
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        indexAccel = -1;
-    }
-
-    if ( flags & wxCONTROL_DISABLED )
-    {
-        // the combination of wxCONTROL_SELECTED and wxCONTROL_DISABLED
-        // currently only can happen for a menu item and it seems that Windows
-        // doesn't draw the shadow in this case, so we don't do it neither
-        if ( flags & wxCONTROL_SELECTED )
-        {
-            // just make the label text greyed out
-            dc.SetTextForeground(m_colDarkGrey);
-        }
-        else // draw normal disabled label
-        {
-            DrawLabelShadow(dc, label, rect, alignment, indexAccel);
-        }
-    }
-
-    wxRect rectLabel;
-    dc.DrawLabel(label, wxNullBitmap, rect, alignment, indexAccel, &rectLabel);
-
-    if ( flags & wxCONTROL_DISABLED )
-    {
-        // restore the fg colour
-        dc.SetTextForeground(*wxBLACK);
-    }
-
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        if ( focusOffset.x || focusOffset.y )
-        {
-            rectLabel.Inflate(focusOffset.x, focusOffset.y);
-        }
-
-        DrawFocusRect(dc, rectLabel);
-    }
-
-    if ( rectBounds )
-        *rectBounds = rectLabel;
-}
-
-void wxWin32Renderer::DrawButtonLabel(wxDC& dc,
-                                      const wxString& label,
-                                      const wxBitmap& image,
-                                      const wxRect& rect,
-                                      int flags,
-                                      int alignment,
-                                      int indexAccel,
-                                      wxRect *rectBounds)
-{
-    // the underscores are not drawn for focused controls in wxMSW
-    if ( flags & wxCONTROL_PRESSED )
-    {
-        indexAccel = -1;
-    }
-
-    wxRect rectLabel = rect;
-    if ( !label.empty() )
-    {
-        // shift the label if a button is pressed
-        if ( flags & wxCONTROL_PRESSED )
-        {
-            rectLabel.x++;
-            rectLabel.y++;
-        }
-
-        if ( flags & wxCONTROL_DISABLED )
-        {
-            DrawLabelShadow(dc, label, rectLabel, alignment, indexAccel);
-        }
-
-        // leave enough space for the focus rectangle
-        if ( flags & wxCONTROL_FOCUSED )
-        {
-            rectLabel.Inflate(-2);
-        }
-    }
-
-    dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
-
-    if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
-    {
-        if ( flags & wxCONTROL_PRESSED )
-        {
-            // the focus rectangle is never pressed, so undo the shift done
-            // above
-            rectLabel.x--;
-            rectLabel.y--;
-            rectLabel.width--;
-            rectLabel.height--;
-        }
-
-        DrawFocusRect(dc, rectLabel);
-    }
 }
 
 // ----------------------------------------------------------------------------
 // (check)listbox items
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // (check)listbox items
 // ----------------------------------------------------------------------------
 
-void wxWin32Renderer::DrawItem(wxDC& dc,
-                               const wxString& label,
-                               const wxRect& rect,
-                               int flags)
-{
-    wxDCTextColourChanger colChanger(dc);
-
-    if ( flags & wxCONTROL_SELECTED )
-    {
-        colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
-
-        wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
-        dc.SetBrush(wxBrush(colBg, wxSOLID));
-        dc.SetPen(wxPen(colBg, 0, wxSOLID));
-        dc.DrawRectangle(rect);
-    }
-
-    wxRect rectText = rect;
-    rectText.x += 2;
-    rectText.width -= 2;
-    dc.DrawLabel(label, wxNullBitmap, rectText);
-
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        DrawFocusRect(dc, rect);
-    }
-}
-
-void wxWin32Renderer::DrawCheckItem(wxDC& dc,
-                                    const wxString& label,
-                                    const wxBitmap& bitmap,
-                                    const wxRect& rect,
-                                    int flags)
+void wxWin32Renderer::DrawCheckItemBitmap(wxDC& dc,
+                                          const wxBitmap& bitmap,
+                                          const wxRect& rect,
+                                          int flags)
 {
     wxBitmap bmp;
     if ( bitmap.Ok() )
 {
     wxBitmap bmp;
     if ( bitmap.Ok() )
@@ -2252,21 +1647,14 @@ void wxWin32Renderer::DrawCheckItem(wxDC& dc,
 
         if ( !m_bmpCheckBitmaps[i].Ok() )
         {
 
         if ( !m_bmpCheckBitmaps[i].Ok() )
         {
-            m_bmpCheckBitmaps[i] = wxBitmap(xpmChecked[i]);
+            m_bmpCheckBitmaps[i] = wxBitmap(ms_xpmChecked[i]);
         }
 
         bmp = m_bmpCheckBitmaps[i];
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
         }
 
         bmp = m_bmpCheckBitmaps[i];
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
-                  TRUE /* use mask */);
-
-    wxRect rectLabel = rect;
-    int bmpWidth = bmp.GetWidth();
-    rectLabel.x += bmpWidth;
-    rectLabel.width -= bmpWidth;
-
-    DrawItem(dc, label, rectLabel, flags);
+                  true /* use mask */);
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -2276,130 +1664,37 @@ void wxWin32Renderer::DrawCheckItem(wxDC& dc,
 wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
 {
     IndicatorState indState;
 wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
 {
     IndicatorState indState;
-    if ( flags & wxCONTROL_SELECTED )
-        indState = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
-                                              : IndicatorState_Selected;
-    else if ( flags & wxCONTROL_DISABLED )
-        indState = IndicatorState_Disabled;
-    else if ( flags & wxCONTROL_PRESSED )
-        indState = IndicatorState_Pressed;
-    else
-        indState = IndicatorState_Normal;
+    IndicatorStatus indStatus;
+    GetIndicatorsFromFlags(flags, indState, indStatus);
 
 
-    IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
-                                    ? IndicatorStatus_Checked
-                                    : IndicatorStatus_Unchecked;
-
-    wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
+    wxBitmap& bmp = m_bmpIndicators[indType][indState][indStatus];
     if ( !bmp.Ok() )
     {
     if ( !bmp.Ok() )
     {
-        const char **xpm = xpmIndicators[indType][indState][indStatus];
+        const char **xpm = ms_xpmIndicators[indType][indState][indStatus];
         if ( xpm )
         {
             // create and cache it
             bmp = wxBitmap(xpm);
         if ( xpm )
         {
             // create and cache it
             bmp = wxBitmap(xpm);
-            m_bmpIndicators[indType][indState][indStatus] = bmp;
         }
     }
 
     return bmp;
 }
 
         }
     }
 
     return bmp;
 }
 
-void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
-                                             const wxString& label,
-                                             const wxBitmap& bitmap,
-                                             const wxRect& rect,
-                                             int flags,
-                                             wxAlignment align,
-                                             int indexAccel,
-                                             wxCoord focusOffsetY)
-{
-    // calculate the position of the bitmap and of the label
-    wxCoord heightBmp = bitmap.GetHeight();
-    wxCoord xBmp,
-            yBmp = rect.y + (rect.height - heightBmp) / 2;
-
-    wxRect rectLabel;
-    dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
-    rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
-
-    // align label vertically with the bitmap - looks nicer like this
-    rectLabel.y -= (rectLabel.height - heightBmp) % 2;
-
-    // calc horz position
-    if ( align == wxALIGN_RIGHT )
-    {
-        xBmp = rect.GetRight() - bitmap.GetWidth();
-        rectLabel.x = rect.x + 3;
-        rectLabel.SetRight(xBmp);
-    }
-    else // normal (checkbox to the left of the text) case
-    {
-        xBmp = rect.x;
-        rectLabel.x = xBmp + bitmap.GetWidth() + 5;
-        rectLabel.SetRight(rect.GetRight());
-    }
-
-    dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
-
-    DoDrawLabel(
-                dc, label, rectLabel,
-                flags,
-                wxALIGN_LEFT | wxALIGN_TOP,
-                indexAccel,
-                NULL,         // we don't need bounding rect
-                // use custom vert focus rect offset
-                wxPoint(FOCUS_RECT_OFFSET_X, focusOffsetY)
-               );
-}
-
-void wxWin32Renderer::DrawRadioButton(wxDC& dc,
-                                      const wxString& label,
-                                      const wxBitmap& bitmap,
-                                      const wxRect& rect,
-                                      int flags,
-                                      wxAlignment align,
-                                      int indexAccel)
-{
-    wxBitmap bmp;
-    if ( bitmap.Ok() )
-        bmp = bitmap;
-    else
-        bmp = GetRadioBitmap(flags);
-
-    DrawCheckOrRadioButton(dc, label,
-                           bmp,
-                           rect, flags, align, indexAccel,
-                           FOCUS_RECT_OFFSET_Y); // default focus rect offset
-}
-
-void wxWin32Renderer::DrawCheckButton(wxDC& dc,
-                                      const wxString& label,
-                                      const wxBitmap& bitmap,
-                                      const wxRect& rect,
-                                      int flags,
-                                      wxAlignment align,
-                                      int indexAccel)
-{
-    wxBitmap bmp;
-    if ( bitmap.Ok() )
-        bmp = bitmap;
-    else
-        bmp = GetCheckBitmap(flags);
-
-    DrawCheckOrRadioButton(dc, label,
-                           bmp,
-                           rect, flags, align, indexAccel,
-                           0); // no focus rect offset for checkboxes
-}
+// ----------------------------------------------------------------------------
+// toolbar stuff
+// ----------------------------------------------------------------------------
 
 
+#if wxUSE_TOOLBAR
 void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
                                         const wxString& label,
                                         const wxBitmap& bitmap,
                                         const wxRect& rectOrig,
 void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
                                         const wxString& label,
                                         const wxBitmap& bitmap,
                                         const wxRect& rectOrig,
-                                        int flags)
+                                        int flags,
+                                        long style,
+                                        int tbarStyle)
 {
 {
-    if ( !label.empty() || bitmap.Ok() )
+    if (style == wxTOOL_STYLE_BUTTON)
     {
         wxRect rect = rectOrig;
         rect.Deflate(BORDER_THICKNESS);
     {
         wxRect rect = rectOrig;
         rect.Deflate(BORDER_THICKNESS);
@@ -2413,42 +1708,53 @@ void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
             DrawBorder(dc, wxBORDER_RAISED, rect, flags);
         }
 
             DrawBorder(dc, wxBORDER_RAISED, rect, flags);
         }
 
-        dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+        if(tbarStyle & wxTB_TEXT)
+        {
+            if(tbarStyle & wxTB_HORIZONTAL)
+            {
+                dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+            }
+            else
+            {
+                dc.DrawLabel(label, bitmap, rect, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL);
+            }
+        }
+        else
+        {
+            int xpoint = (rect.GetLeft() + rect.GetRight() + 1 - bitmap.GetWidth()) / 2;
+            int ypoint = (rect.GetTop() + rect.GetBottom() + 1 - bitmap.GetHeight()) / 2;
+            dc.DrawBitmap(bitmap, xpoint, ypoint, bitmap.GetMask() != NULL);
+        }
     }
     }
-    else // a separator
+    else if (style == wxTOOL_STYLE_SEPARATOR)
     {
         // leave a small gap aroudn the line, also account for the toolbar
         // border itself
     {
         // leave a small gap aroudn the line, also account for the toolbar
         // border itself
-        DrawVerticalLine(dc, rectOrig.x + rectOrig.width/2,
-                         rectOrig.y + 2*BORDER_THICKNESS,
-                         rectOrig.GetBottom() - BORDER_THICKNESS);
+        if(rectOrig.height > rectOrig.width)
+        {
+            // horizontal
+            DrawVerticalLine(dc, rectOrig.x + rectOrig.width/2,
+                             rectOrig.y + 2*BORDER_THICKNESS,
+                             rectOrig.GetBottom() - BORDER_THICKNESS);
+        }
+        else
+        {
+            // vertical
+            DrawHorizontalLine(dc, rectOrig.y + rectOrig.height/2,
+                         rectOrig.x + 2*BORDER_THICKNESS,
+                         rectOrig.GetRight() - BORDER_THICKNESS);
+        }
     }
     }
+    // don't draw wxTOOL_STYLE_CONTROL
 }
 }
-
-// ----------------------------------------------------------------------------
-// text control
-// ----------------------------------------------------------------------------
-
-void wxWin32Renderer::DrawTextLine(wxDC& dc,
-                                   const wxString& text,
-                                   const wxRect& rect,
-                                   int selStart,
-                                   int selEnd,
-                                   int flags)
-{
-    // nothing special to do here
-    StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
-}
-
-void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
-{
-    // we don't draw them
-}
+#endif // wxUSE_TOOLBAR
 
 // ----------------------------------------------------------------------------
 // notebook
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // notebook
 // ----------------------------------------------------------------------------
 
+#if wxUSE_NOTEBOOK
+
 void wxWin32Renderer::DrawTab(wxDC& dc,
                               const wxRect& rectOrig,
                               wxDirection dir,
 void wxWin32Renderer::DrawTab(wxDC& dc,
                               const wxRect& rectOrig,
                               wxDirection dir,
@@ -2457,13 +1763,23 @@ void wxWin32Renderer::DrawTab(wxDC& dc,
                               int flags,
                               int indexAccel)
 {
                               int flags,
                               int indexAccel)
 {
+    #define SELECT_FOR_VERTICAL(X,Y) ( isVertical ? Y : X )
+    #define REVERSE_FOR_VERTICAL(X,Y) \
+        SELECT_FOR_VERTICAL(X,Y)      \
+        ,                             \
+        SELECT_FOR_VERTICAL(Y,X)
+
     wxRect rect = rectOrig;
 
     wxRect rect = rectOrig;
 
+    bool isVertical = ( dir == wxLEFT ) || ( dir == wxRIGHT );
+
     // the current tab is drawn indented (to the top for default case) and
     // bigger than the other ones
     const wxSize indent = GetTabIndent();
     if ( flags & wxCONTROL_SELECTED )
     {
     // the current tab is drawn indented (to the top for default case) and
     // bigger than the other ones
     const wxSize indent = GetTabIndent();
     if ( flags & wxCONTROL_SELECTED )
     {
+        rect.Inflate( SELECT_FOR_VERTICAL( indent.x , 0),
+                      SELECT_FOR_VERTICAL( 0, indent.y ));
         switch ( dir )
         {
             default:
         switch ( dir )
         {
             default:
@@ -2471,153 +1787,240 @@ void wxWin32Renderer::DrawTab(wxDC& dc,
                 // fall through
 
             case wxTOP:
                 // fall through
 
             case wxTOP:
-                rect.Inflate(indent.x, 0);
                 rect.y -= indent.y;
                 rect.y -= indent.y;
-                rect.height += indent.y;
-                break;
-
+                // fall through
             case wxBOTTOM:
             case wxBOTTOM:
-                rect.Inflate(indent.x, 0);
                 rect.height += indent.y;
                 break;
 
             case wxLEFT:
                 rect.height += indent.y;
                 break;
 
             case wxLEFT:
+                rect.x -= indent.x;
+                // fall through
             case wxRIGHT:
             case wxRIGHT:
-                wxFAIL_MSG(_T("TODO"));
+                rect.width += indent.x;
                 break;
         }
     }
 
     // draw the text, image and the focus around them (if necessary)
                 break;
         }
     }
 
     // draw the text, image and the focus around them (if necessary)
-    wxRect rectLabel = rect;
+    wxRect rectLabel( REVERSE_FOR_VERTICAL(rect.x,rect.y),
+                      REVERSE_FOR_VERTICAL(rect.width,rect.height)
+                    );
     rectLabel.Deflate(1, 1);
     rectLabel.Deflate(1, 1);
-    DrawButtonLabel(dc, label, bitmap, rectLabel,
-                    flags, wxALIGN_CENTRE, indexAccel);
+    if ( isVertical )
+    {
+        // draw it horizontally into memory and rotate for screen
+        wxMemoryDC dcMem;
+        wxBitmap bitmapRotated,
+                 bitmapMem( rectLabel.x + rectLabel.width,
+                            rectLabel.y + rectLabel.height );
+        dcMem.SelectObject(bitmapMem);
+        dcMem.SetBackground(dc.GetBackground());
+        dcMem.SetFont(dc.GetFont());
+        dcMem.SetTextForeground(dc.GetTextForeground());
+        dcMem.Clear();
+        bitmapRotated =
+#if wxUSE_IMAGE
+                        wxBitmap( wxImage( bitmap.ConvertToImage() ).Rotate90(dir==wxLEFT) )
+#else
+                        bitmap
+#endif // wxUSE_IMAGE
+                        ;
+        DrawButtonLabel(dcMem, label, bitmapRotated, rectLabel,
+                        flags, wxALIGN_CENTRE, indexAccel);
+        dcMem.SelectObject(wxNullBitmap);
+        bitmapMem = bitmapMem.GetSubBitmap(rectLabel);
+#if wxUSE_IMAGE
+        bitmapMem = wxBitmap(wxImage(bitmapMem.ConvertToImage()).Rotate90(dir==wxRIGHT));
+#endif // wxUSE_IMAGE
+        dc.DrawBitmap(bitmapMem, rectLabel.y, rectLabel.x, false);
+    }
+    else
+    {
+        DrawButtonLabel(dc, label, bitmap, rectLabel,
+                        flags, wxALIGN_CENTRE, indexAccel);
+    }
 
     // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
     static const wxCoord CUTOFF = 2; // radius of the rounded corner
 
     // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
     static const wxCoord CUTOFF = 2; // radius of the rounded corner
-    wxCoord x = rect.x,
-            y = rect.y,
-            x2 = rect.GetRight(),
-            y2 = rect.GetBottom();
+    wxCoord x = SELECT_FOR_VERTICAL(rect.x,rect.y),
+            y = SELECT_FOR_VERTICAL(rect.y,rect.x),
+            x2 = SELECT_FOR_VERTICAL(rect.GetRight(),rect.GetBottom()),
+            y2 = SELECT_FOR_VERTICAL(rect.GetBottom(),rect.GetRight());
 
     // FIXME: all this code will break if the tab indent or the border width,
     //        it is tied to the fact that both of them are equal to 2
     switch ( dir )
     {
         default:
 
     // FIXME: all this code will break if the tab indent or the border width,
     //        it is tied to the fact that both of them are equal to 2
     switch ( dir )
     {
         default:
+            // default is top
+        case wxLEFT:
+            // left orientation looks like top but IsVertical makes x and y reversed
         case wxTOP:
         case wxTOP:
+            // top is not vertical so use coordinates in written order
             dc.SetPen(m_penHighlight);
             dc.SetPen(m_penHighlight);
-            dc.DrawLine(x, y2, x, y + CUTOFF);
-            dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
-            dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2),
+                        REVERSE_FOR_VERTICAL(x, y + CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y + CUTOFF),
+                        REVERSE_FOR_VERTICAL(x + CUTOFF, y));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y));
 
             dc.SetPen(m_penBlack);
 
             dc.SetPen(m_penBlack);
-            dc.DrawLine(x2, y2, x2, y + CUTOFF);
-            dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2),
+                        REVERSE_FOR_VERTICAL(x2, y + CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y + CUTOFF),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF, y));
 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);
-            dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y2),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y + CUTOFF - 1));
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the border below this tab
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the border below this tab
-                dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 + 1),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y2 + 1));
 
                 // and the shadow of the tab to the left of us
 
                 // and the shadow of the tab to the left of us
-                dc.DrawLine(x + 1, y + CUTOFF + 1, x + 1, y2 + 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y + CUTOFF + 1),
+                            REVERSE_FOR_VERTICAL(x + 1, y2 + 1));
             }
             break;
 
             }
             break;
 
+        case wxRIGHT:
+            // right orientation looks like bottom but IsVertical makes x and y reversed
         case wxBOTTOM:
         case wxBOTTOM:
+            // bottom is not vertical so use coordinates in written order
             dc.SetPen(m_penHighlight);
             // we need to continue one pixel further to overwrite the corner of
             // the border for the selected tab
             dc.SetPen(m_penHighlight);
             // we need to continue one pixel further to overwrite the corner of
             // the border for the selected tab
-            dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
-                        x, y2 - CUTOFF);
-            dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0)),
+                        REVERSE_FOR_VERTICAL(x, y2 - CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2 - CUTOFF),
+                        REVERSE_FOR_VERTICAL(x + CUTOFF, y2));
 
             dc.SetPen(m_penBlack);
 
             dc.SetPen(m_penBlack);
-            dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
-            dc.DrawLine(x2, y, x2, y2 - CUTOFF);
-            dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y),
+                        REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2 - CUTOFF),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF, y2));
 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);
-            dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
-            dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + CUTOFF, y2 - 1),
+                        REVERSE_FOR_VERTICAL(x2 - CUTOFF + 1, y2 - 1));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y2 - CUTOFF + 1));
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the (double!) border above this tab
 
             if ( flags & wxCONTROL_SELECTED )
             {
                 dc.SetPen(m_penLightGrey);
 
                 // overwrite the part of the (double!) border above this tab
-                dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
-                dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 1),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y - 1));
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y - 2),
+                            REVERSE_FOR_VERTICAL(x2 - 1, y - 2));
 
                 // and the shadow of the tab to the left of us
 
                 // and the shadow of the tab to the left of us
-                dc.DrawLine(x + 1, y2 - CUTOFF, x + 1, y - 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 - CUTOFF),
+                            REVERSE_FOR_VERTICAL(x + 1, y - 1));
             }
             break;
             }
             break;
-
-        case wxLEFT:
-        case wxRIGHT:
-            wxFAIL_MSG(_T("TODO"));
     }
     }
+
+    #undef SELECT_FOR_VERTICAL
+    #undef REVERSE_FOR_VERTICAL
 }
 
 }
 
+#endif // wxUSE_NOTEBOOK
+
+#if wxUSE_SLIDER
+
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
-wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
-                                           wxOrientation orient) const
+wxSize
+wxWin32Renderer::GetSliderThumbSize(const wxRect& WXUNUSED(rect),
+                                    int lenThumb,
+                                    wxOrientation orient) const
 {
     wxSize size;
 {
     wxSize size;
+    wxCoord width  = wxMax (lenThumb, SLIDER_THUMB_LENGTH) / 2;
+    wxCoord height = wxMax (lenThumb, SLIDER_THUMB_LENGTH);
 
 
-    wxRect rectShaft = GetSliderShaftRect(rect, orient);
-    if ( orient == wxHORIZONTAL )
+    if (orient == wxHORIZONTAL)
     {
     {
-        size.y = rect.height - 6;
-        size.x = wxMin(size.y / 2, rectShaft.width);
+        size.x = width;
+        size.y = height;
     }
     }
-    else // vertical
-    {
-        size.x = rect.width - 6;
-        size.y = wxMin(size.x / 2, rectShaft.height);
+    else
+    { // == wxVERTICAL
+        size.x = height;
+        size.y = width;
     }
 
     return size;
 }
 
 wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
     }
 
     return size;
 }
 
 wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
-                                           wxOrientation orient) const
-{
-    static const wxCoord SLIDER_MARGIN = 6;
+                                           int lenThumb,
+                                           wxOrientation orient,
+                                           long style) const
+{
+    bool transpose = (orient == wxVERTICAL);
+    bool left  = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_TOP) != 0) & !transpose |
+                  ((style & wxSL_LEFT) != 0) & transpose |
+                  ((style & wxSL_BOTH) != 0));
+    bool right = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_BOTTOM) != 0) & !transpose |
+                  ((style & wxSL_RIGHT) != 0) & transpose |
+                  ((style & wxSL_BOTH) != 0));
 
     wxRect rect = rectOrig;
 
 
     wxRect rect = rectOrig;
 
-    if ( orient == wxHORIZONTAL )
-    {
-        // make the rect of minimal width and centre it
-        rect.height = 2*BORDER_THICKNESS;
-        rect.y = rectOrig.y + (rectOrig.height - rect.height) / 2;
-        if ( rect.y < 0 )
-            rect.y = 0;
+    wxSize sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
 
 
-        // leave margins on the sides
-        rect.Deflate(SLIDER_MARGIN, 0);
+    if (orient == wxHORIZONTAL) {
+        rect.x += SLIDER_MARGIN;
+        if (left & right)
+        {
+            rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS) / 2, sizeThumb.y/2);
+        }
+        else if (left)
+        {
+            rect.y += wxMax ((rect.height - 2*BORDER_THICKNESS - sizeThumb.y/2), sizeThumb.y/2);
+        }
+        else
+        {
+            rect.y += sizeThumb.y/2;
+        }
+        rect.width -= 2*SLIDER_MARGIN;
+        rect.height = 2*BORDER_THICKNESS;
     }
     }
-    else // vertical
-    {
-        // same as above but in other direction
+    else
+    { // == wxVERTICAL
+        rect.y += SLIDER_MARGIN;
+        if (left & right)
+        {
+            rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS) / 2, sizeThumb.x/2);
+        }
+        else if (left)
+        {
+            rect.x += wxMax ((rect.width - 2*BORDER_THICKNESS - sizeThumb.x/2), sizeThumb.x/2);
+        }
+        else
+        {
+            rect.x += sizeThumb.x/2;
+        }
         rect.width = 2*BORDER_THICKNESS;
         rect.width = 2*BORDER_THICKNESS;
-        rect.x = rectOrig.x + (rectOrig.width - rect.width) / 2;
-        if ( rect.x < 0 )
-            rect.x = 0;
-
-        rect.Deflate(0, SLIDER_MARGIN);
+        rect.height -= 2*SLIDER_MARGIN;
     }
 
     return rect;
     }
 
     return rect;
@@ -2625,19 +2028,37 @@ wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
 
 void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
                                       const wxRect& rectOrig,
 
 void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
                                       const wxRect& rectOrig,
+                                      int lenThumb,
                                       wxOrientation orient,
                                       int flags,
                                       wxOrientation orient,
                                       int flags,
+                                      long style,
                                       wxRect *rectShaft)
 {
                                       wxRect *rectShaft)
 {
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        DrawFocusRect(dc, rectOrig);
+    /*    show shaft geometry
+
+             shaft
+        +-------------+
+        |             |
+        |     XXX     |  <-- x1
+        |     XXX     |
+        |     XXX     |
+        |     XXX     |
+        |     XXX     |  <-- x2
+        |             |
+        +-------------+
+
+              ^ ^
+              | |
+             y1 y2
+    */
+
+    if (flags & wxCONTROL_FOCUSED) {
+        DrawFocusRect(NULL, dc, rectOrig);
     }
 
     }
 
-    wxRect rect = GetSliderShaftRect(rectOrig, orient);
+    wxRect rect = GetSliderShaftRect(rectOrig, lenThumb, orient, style);
 
 
-    if ( rectShaft )
-        *rectShaft = rect;
+    if (rectShaft) *rectShaft = rect;
 
     DrawSunkenBorder(dc, &rect);
 }
 
     DrawSunkenBorder(dc, &rect);
 }
@@ -2645,26 +2066,31 @@ void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
 void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
                                       const wxRect& rect,
                                       wxOrientation orient,
 void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
                                       const wxRect& rect,
                                       wxOrientation orient,
-                                      int flags)
-{
-    /*
-       we are drawing a shape of this form
-
-       HHHHHHB <--- y
-       H    DB
-       H    DB
-       H    DB   where H is hightlight colour
-       H    DB         D    dark grey
-       H    DB         B    black
-       H    DB
-       H    DB <--- y3
-        H  DB
-         HDB
-          B    <--- y2
-
-       ^  ^  ^
-       |  |  |
-       x x3  x2
+                                      int flags,
+                                      long style)
+{
+    /*    show thumb geometry
+
+             H       <--- y1
+           H H B
+         H     H B
+       H         H B <--- y3
+       H         D B
+       H         D B
+       H         D B
+       H         D B   where H is highlight colour
+       H         D B         D    dark grey
+       H         D B         B    black
+       H         D B
+       H         D B
+       H         D B <--- y4
+         H     D B
+           H D B
+             B       <--- y2
+
+       ^     ^     ^
+       |     |     |
+       x1    x3    x2
 
        The interior of this shape is filled with the hatched brush if the thumb
        is pressed.
 
        The interior of this shape is filled with the hatched brush if the thumb
        is pressed.
@@ -2672,51 +2098,81 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
 
     DrawBackground(dc, wxNullColour, rect, flags);
 
 
     DrawBackground(dc, wxNullColour, rect, flags);
 
-    bool transpose = orient == wxVERTICAL;
+    bool transpose = (orient == wxVERTICAL);
+    bool left  = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_TOP) != 0) & !transpose |
+                  ((style & wxSL_LEFT) != 0) & transpose) &
+                 ((style & wxSL_BOTH) == 0);
+    bool right = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_BOTTOM) != 0) & !transpose |
+                  ((style & wxSL_RIGHT) != 0) & transpose) &
+                 ((style & wxSL_BOTH) == 0);
+
+    wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
+    wxCoord c = ((transpose ? rect.height : rect.width) - 2*sizeArrow);
+
+    wxCoord x1, x2, x3, y1, y2, y3, y4;
+    x1 = (transpose ? rect.y : rect.x);
+    x2 = (transpose ? rect.GetBottom() : rect.GetRight());
+    x3 = (x1-1+c) + sizeArrow;
+    y1 = (transpose ? rect.x : rect.y);
+    y2 = (transpose ? rect.GetRight() : rect.GetBottom());
+    y3 = (left  ? (y1-1+c) + sizeArrow : y1);
+    y4 = (right ? (y2+1-c) - sizeArrow : y2);
 
 
-    wxCoord x, y, x2, y2;
-    if ( transpose )
+    dc.SetPen(m_penBlack);
+    if (left) {
+        DrawLine(dc, x3+1-c, y1, x2, y3, transpose);
+    }
+    DrawLine(dc, x2, y3, x2, y4, transpose);
+    if (right)
     {
     {
-        x = rect.y;
-        y = rect.x;
-        x2 = rect.GetBottom();
-        y2 = rect.GetRight();
+        DrawLine(dc, x3+1-c, y2, x2, y4, transpose);
     }
     else
     {
     }
     else
     {
-        x = rect.x;
-        y = rect.y;
-        x2 = rect.GetRight();
-        y2 = rect.GetBottom();
+        DrawLine(dc, x1, y2, x2, y2, transpose);
     }
 
     }
 
-    // the size of the pointed part of the thumb
-    wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
-
-    wxCoord x3 = x + sizeArrow,
-            y3 = y2 - sizeArrow;
-
-    dc.SetPen(m_penHighlight);
-    DrawLine(dc, x, y, x2, y, transpose);
-    DrawLine(dc, x, y + 1, x, y2 - sizeArrow, transpose);
-    DrawLine(dc, x, y3, x3, y2, transpose);
-
-    dc.SetPen(m_penBlack);
-    DrawLine(dc, x3, y2, x2, y3, transpose);
-    DrawLine(dc, x2, y3, x2, y - 1, transpose);
-
     dc.SetPen(m_penDarkGrey);
     dc.SetPen(m_penDarkGrey);
-    DrawLine(dc, x3, y2 - 1, x2 - 1, y3, transpose);
-    DrawLine(dc, x2 - 1, y3, x2 - 1, y, transpose);
+    DrawLine(dc, x2-1, y3+1, x2-1, y4-1, transpose);
+    if (right) {
+        DrawLine(dc, x3+1-c, y2-1, x2-1, y4, transpose);
+    }
+    else
+    {
+        DrawLine(dc, x1+1, y2-1, x2-1, y2-1, transpose);
+    }
 
 
-    if ( flags & wxCONTROL_PRESSED )
+    dc.SetPen(m_penHighlight);
+    if (left)
     {
     {
+        DrawLine(dc, x1, y3, x3, y1, transpose);
+        DrawLine(dc, x3+1-c, y1+1, x2-1, y3, transpose);
+    }
+    else
+    {
+        DrawLine(dc, x1, y1, x2, y1, transpose);
+    }
+    DrawLine(dc, x1, y3, x1, y4, transpose);
+    if (right)
+    {
+        DrawLine(dc, x1, y4, x3+c, y2+c, transpose);
+    }
+
+    if (flags & wxCONTROL_PRESSED) {
         // TODO: MSW fills the entire area inside, not just the rect
         wxRect rectInt = rect;
         if ( transpose )
         // TODO: MSW fills the entire area inside, not just the rect
         wxRect rectInt = rect;
         if ( transpose )
-            rectInt.SetRight(y3);
+        {
+            rectInt.SetLeft(y3);
+            rectInt.SetRight(y4);
+        }
         else
         else
-            rectInt.SetBottom(y3);
+        {
+            rectInt.SetTop(y3);
+            rectInt.SetBottom(y4);
+        }
         rectInt.Deflate(2);
 
 #if !defined(__WXMGL__)
         rectInt.Deflate(2);
 
 #if !defined(__WXMGL__)
@@ -2758,72 +2214,86 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
 
 void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
                                       const wxRect& rect,
 
 void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
                                       const wxRect& rect,
-                                      const wxSize& sizeThumb,
+                                      int lenThumb,
                                       wxOrientation orient,
                                       int start,
                                       int end,
                                       int step,
                                       wxOrientation orient,
                                       int start,
                                       int end,
                                       int step,
-                                      int flags)
+                                      int WXUNUSED(flags),
+                                      long style)
 {
 {
-    if ( end == start )
-    {
-        // empty slider?
-        return;
-    }
-
-    // the variable names correspond to horizontal case, but they can be used
-    // for both orientations
-    wxCoord x1, x2, y1, y2, len, widthThumb;
-    if ( orient == wxHORIZONTAL )
-    {
-        x1 = rect.GetLeft();
-        x2 = rect.GetRight();
-
-        // draw from bottom to top to leave one pixel space between the ticks
-        // and the slider as Windows do
-        y1 = rect.GetBottom();
-        y2 = rect.GetTop();
+    /*    show ticks geometry
 
 
-        len = rect.width;
-
-        widthThumb = sizeThumb.x;
-    }
-    else // vertical
-    {
-        x1 = rect.GetTop();
-        x2 = rect.GetBottom();
+        left        right
+        ticks shaft ticks
+        ----   XX   ----  <-- x1
+        ----   XX   ----
+        ----   XX   ----
+        ----   XX   ----  <-- x2
 
 
-        y1 = rect.GetRight();
-        y2 = rect.GetLeft();
-
-        len = rect.height;
-
-        widthThumb = sizeThumb.y;
-    }
-
-    // the first tick should be positioned in such way that a thumb drawn in
-    // the first position points down directly to it
-    x1 += widthThumb / 2;
-    x2 -= widthThumb / 2;
+        ^  ^        ^  ^
+        |  |        |  |
+        y3 y1       y2 y4
+    */
 
 
-    // this also means that we have slightly less space for the ticks in
-    // between the first and the last
-    len -= widthThumb;
+    // empty slider?
+    if (end == start) return;
+
+    bool transpose = (orient == wxVERTICAL);
+    bool left  = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_TOP) != 0) & !transpose |
+                  ((style & wxSL_LEFT) != 0) & transpose |
+                  ((style & wxSL_BOTH) != 0));
+    bool right = ((style & wxSL_AUTOTICKS) != 0) &
+                 (((style & wxSL_BOTTOM) != 0) & !transpose |
+                  ((style & wxSL_RIGHT) != 0) & transpose |
+                  ((style & wxSL_BOTH) != 0));
+
+    // default thumb size
+    wxSize sizeThumb = GetSliderThumbSize (rect, 0, orient);
+    wxCoord defaultLen = (transpose ? sizeThumb.x : sizeThumb.y);
+
+    // normal thumb size
+    sizeThumb = GetSliderThumbSize (rect, lenThumb, orient);
+    wxCoord widthThumb  = (transpose ? sizeThumb.y : sizeThumb.x);
+
+    wxRect rectShaft = GetSliderShaftRect (rect, lenThumb, orient, style);
+
+    wxCoord x1, x2, y1, y2, y3, y4 , len;
+    x1 = (transpose ? rectShaft.y : rectShaft.x) + widthThumb/2;
+    x2 = (transpose ? rectShaft.GetBottom() : rectShaft.GetRight()) - widthThumb/2;
+    y1 = (transpose ? rectShaft.x : rectShaft.y) - defaultLen/2;
+    y2 = (transpose ? rectShaft.GetRight() : rectShaft.GetBottom()) + defaultLen/2;
+    y3 = (transpose ? rect.x : rect.y);
+    y4 = (transpose ? rect.GetRight() : rect.GetBottom());
+    len = x2 - x1;
 
     dc.SetPen(m_penBlack);
 
     int range = end - start;
 
     dc.SetPen(m_penBlack);
 
     int range = end - start;
-    for ( int n = 0; n < range; n += step )
-    {
+    for ( int n = 0; n < range; n += step ) {
         wxCoord x = x1 + (len*n) / range;
 
         wxCoord x = x1 + (len*n) / range;
 
-        DrawLine(dc, x, y1, x, y2, orient == wxVERTICAL);
+        if (left & (y1 > y3)) {
+            DrawLine(dc, x, y1, x, y3, orient == wxVERTICAL);
+        }
+        if (right & (y4 > y2)) {
+            DrawLine(dc, x, y2, x, y4, orient == wxVERTICAL);
+        }
     }
     }
-
     // always draw the line at the end position
     // always draw the line at the end position
-    DrawLine(dc, x2, y1, x2, y2, orient == wxVERTICAL);
+    if (left & (y1 > y3)) {
+        DrawLine(dc, x2, y1, x2, y3, orient == wxVERTICAL);
+    }
+    if (right & (y4 > y2)) {
+        DrawLine(dc, x2, y2, x2, y4, orient == wxVERTICAL);
+    }
 }
 
 }
 
+#endif // wxUSE_SLIDER
+
+#if wxUSE_MENUS
+
 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
@@ -2890,9 +2360,9 @@ void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
     {
         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
 
     {
         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
 
-        wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
-        dc.SetBrush(wxBrush(colBg, wxSOLID));
-        dc.SetPen(wxPen(colBg, 0, wxSOLID));
+        const wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
+        dc.SetBrush(colBg);
+        dc.SetPen(colBg);
         dc.DrawRectangle(rect);
     }
 
         dc.DrawRectangle(rect);
     }
 
@@ -2925,9 +2395,9 @@ void wxWin32Renderer::DrawMenuItem(wxDC& dc,
     {
         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
 
     {
         colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
 
-        wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
-        dc.SetBrush(wxBrush(colBg, wxSOLID));
-        dc.SetPen(wxPen(colBg, 0, wxSOLID));
+        const wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
+        dc.SetBrush(colBg);
+        dc.SetPen(colBg);
         dc.DrawRectangle(rect);
     }
 
         dc.DrawRectangle(rect);
     }
 
@@ -2964,12 +2434,12 @@ void wxWin32Renderer::DrawMenuItem(wxDC& dc,
         rect.x = geometryInfo.GetSize().x - MENU_RIGHT_MARGIN;
         rect.width = MENU_RIGHT_MARGIN;
 
         rect.x = geometryInfo.GetSize().x - MENU_RIGHT_MARGIN;
         rect.width = MENU_RIGHT_MARGIN;
 
-        wxArrowStyle arrowStyle;
+        ArrowStyle arrowStyle;
         if ( flags & wxCONTROL_DISABLED )
         if ( flags & wxCONTROL_DISABLED )
-            arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
+            arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InvertedDisabled
                                                     : Arrow_Disabled;
         else if ( flags & wxCONTROL_SELECTED )
                                                     : Arrow_Disabled;
         else if ( flags & wxCONTROL_SELECTED )
-            arrowStyle = Arrow_Inversed;
+            arrowStyle = Arrow_Inverted;
         else
             arrowStyle = Arrow_Normal;
 
         else
             arrowStyle = Arrow_Normal;
 
@@ -3018,7 +2488,7 @@ wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
             widthAccelMax = 0,
             widthBmpMax = MENU_LEFT_MARGIN;
 
             widthAccelMax = 0,
             widthBmpMax = MENU_LEFT_MARGIN;
 
-    for ( wxMenuItemList::Node *node = menu.GetMenuItems().GetFirst();
+    for ( wxMenuItemList::compatibility_iterator node = menu.GetMenuItems().GetFirst();
           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {
@@ -3035,7 +2505,7 @@ wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
             h = heightText;
 
             wxCoord widthLabel;
             h = heightText;
 
             wxCoord widthLabel;
-            dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
+            dc.GetTextExtent(item->GetItemLabelText(), &widthLabel, NULL);
             if ( widthLabel > widthLabelMax )
             {
                 widthLabelMax = widthLabel;
             if ( widthLabel > widthLabelMax )
             {
                 widthLabelMax = widthLabel;
@@ -3086,29 +2556,23 @@ wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
     return gi;
 }
 
     return gi;
 }
 
+#endif // wxUSE_MENUS
+
+#if wxUSE_STATUSBAR
+
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
 
-static const wxCoord STATBAR_BORDER_X = 2;
-static const wxCoord STATBAR_BORDER_Y = 2;
-
-wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
-{
-    if ( borderBetweenFields )
-        *borderBetweenFields = 2;
-
-    return wxSize(STATBAR_BORDER_X, STATBAR_BORDER_Y);
-}
-
 void wxWin32Renderer::DrawStatusField(wxDC& dc,
                                       const wxRect& rect,
                                       const wxString& label,
 void wxWin32Renderer::DrawStatusField(wxDC& dc,
                                       const wxRect& rect,
                                       const wxString& label,
-                                      int flags)
+                                      int flags,
+                                      int style)
 {
     wxRect rectIn;
 
 {
     wxRect rectIn;
 
-    if ( flags & wxCONTROL_ISDEFAULT )
+    if ( flags & wxCONTROL_SIZEGRIP )
     {
         // draw the size grip: it is a normal rect except that in the lower
         // right corner we have several bands which may be used for dragging
     {
         // draw the size grip: it is a normal rect except that in the lower
         // right corner we have several bands which may be used for dragging
@@ -3120,9 +2584,15 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
                 y2 = rect.GetBottom();
 
         // draw the upper left part of the rect normally
                 y2 = rect.GetBottom();
 
         // draw the upper left part of the rect normally
-        dc.SetPen(m_penDarkGrey);
-        dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
-        dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
+        if (style != wxSB_FLAT)
+        {
+            if (style == wxSB_RAISED)
+                dc.SetPen(m_penHighlight);
+            else
+                dc.SetPen(m_penDarkGrey);
+            dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
+            dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
+        }
 
         // draw the grey stripes of the grip
         size_t n;
 
         // draw the grey stripes of the grip
         size_t n;
@@ -3142,32 +2612,37 @@ void wxWin32Renderer::DrawStatusField(wxDC& dc,
         }
 
         // draw the remaining rect boundaries
         }
 
         // draw the remaining rect boundaries
-        ofs -= WIDTH_STATUSBAR_GRIP_BAND;
-        dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
-        dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
+        if (style != wxSB_FLAT)
+        {
+            if (style == wxSB_RAISED)
+                dc.SetPen(m_penDarkGrey);
+            else
+                dc.SetPen(m_penHighlight);
+            ofs -= WIDTH_STATUSBAR_GRIP_BAND;
+            dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
+            dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
+        }
 
         rectIn = rect;
         rectIn.Deflate(1);
 
         rectIn.width -= STATUSBAR_GRIP_SIZE;
 
         rectIn = rect;
         rectIn.Deflate(1);
 
         rectIn.width -= STATUSBAR_GRIP_SIZE;
-    }
-    else // normal pane
-    {
-        DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
-    }
 
 
-    rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
+        // this will prevent the standard version from drawing any borders
+        style = wxSB_FLAT;
+    }
 
 
-    wxDCClipper clipper(dc, rectIn);
-    DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
+    wxStdRenderer::DrawStatusField(dc, rect, label, flags, style);
 }
 
 }
 
+#endif // wxUSE_STATUSBAR
+
 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
-                                      wxBitmap *bmpFocus,
+                                      wxBitmap * WXUNUSED(bmpFocus),
                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {
                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {
@@ -3201,56 +2676,36 @@ void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
     }
 }
 
     }
 }
 
-// ----------------------------------------------------------------------------
-// background
-// ----------------------------------------------------------------------------
-
-void wxWin32Renderer::DoDrawBackground(wxDC& dc,
-                                       const wxColour& col,
-                                       const wxRect& rect,
-                                       wxWindow *window )
-{
-    wxBrush brush(col, wxSOLID);
-    dc.SetBrush(brush);
-    dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.DrawRectangle(rect);
-}
-
-void wxWin32Renderer::DrawBackground(wxDC& dc,
-                                     const wxColour& col,
-                                     const wxRect& rect,
-                                     int flags,
-                                     wxWindow *window )
-{
-    // just fill it with the given or default bg colour
-    wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
-    DoDrawBackground(dc, colBg, rect, window );
-}
-
 // ----------------------------------------------------------------------------
 // scrollbar
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // scrollbar
 // ----------------------------------------------------------------------------
 
-void wxWin32Renderer::DrawArrow(wxDC& dc,
-                                wxDirection dir,
-                                const wxRect& rect,
-                                int flags)
+void wxWin32Renderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
 {
 {
-    // get the bitmap for this arrow
-    wxArrowDirection arrowDir;
-    switch ( dir )
+    if ( isPressed )
     {
     {
-        case wxLEFT:    arrowDir = Arrow_Left; break;
-        case wxRIGHT:   arrowDir = Arrow_Right; break;
-        case wxUP:      arrowDir = Arrow_Up; break;
-        case wxDOWN:    arrowDir = Arrow_Down; break;
+        DrawRect(dc, rect, m_penDarkGrey);
 
 
-        default:
-            wxFAIL_MSG(_T("unknown arrow direction"));
-            return;
+        // the arrow is usually drawn inside border of width 2 and is offset by
+        // another pixel in both directions when it's pressed - as the border
+        // in this case is more narrow as well, we have to adjust rect like
+        // this:
+        rect->Inflate(-1);
+        rect->x++;
+        rect->y++;
     }
     }
+    else // !pressed
+    {
+        DrawAntiSunkenBorder(dc, rect);
+    }
+}
 
 
-    wxArrowStyle arrowStyle;
+void wxWin32Renderer::DrawArrow(wxDC& dc,
+                                wxDirection dir,
+                                const wxRect& rect,
+                                int flags)
+{
+    ArrowStyle arrowStyle;
     if ( flags & wxCONTROL_PRESSED )
     {
         // can't be pressed and disabled
     if ( flags & wxCONTROL_PRESSED )
     {
         // can't be pressed and disabled
@@ -3261,13 +2716,13 @@ void wxWin32Renderer::DrawArrow(wxDC& dc,
         arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
     }
 
         arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
     }
 
-    DrawArrowButton(dc, rect, arrowDir, arrowStyle);
+    DrawArrowButton(dc, rect, GetArrowDirection(dir), arrowStyle);
 }
 
 void wxWin32Renderer::DrawArrow(wxDC& dc,
                                 const wxRect& rect,
 }
 
 void wxWin32Renderer::DrawArrow(wxDC& dc,
                                 const wxRect& rect,
-                                wxArrowDirection arrowDir,
-                                wxArrowStyle arrowStyle)
+                                ArrowDirection arrowDir,
+                                ArrowStyle arrowStyle)
 {
     const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
 
 {
     const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
 
@@ -3281,24 +2736,24 @@ void wxWin32Renderer::DrawArrow(wxDC& dc,
         x--;
 
     // draw it
         x--;
 
     // draw it
-    dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
+    dc.DrawBitmap(bmp, x, y, true /* use mask */);
 }
 
 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
                                       const wxRect& rectAll,
 }
 
 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
                                       const wxRect& rectAll,
-                                      wxArrowDirection arrowDir,
-                                      wxArrowStyle arrowStyle)
+                                      ArrowDirection arrowDir,
+                                      ArrowStyle arrowStyle)
 {
     wxRect rect = rectAll;
 {
     wxRect rect = rectAll;
-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
+    DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
     DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
     DrawArrow(dc, rect, arrowDir, arrowStyle);
 }
 
 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
     DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
     DrawArrow(dc, rect, arrowDir, arrowStyle);
 }
 
 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
-                                         wxOrientation orient,
+                                         wxOrientation WXUNUSED(orient),
                                          const wxRect& rect,
                                          const wxRect& rect,
-                                         int flags)
+                                         int WXUNUSED(flags))
 {
     // we don't use the flags, the thumb never changes appearance
     wxRect rectThumb = rect;
 {
     // we don't use the flags, the thumb never changes appearance
     wxRect rectThumb = rect;
@@ -3307,589 +2762,288 @@ void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
-                                         wxOrientation orient,
+                                         wxOrientation WXUNUSED(orient),
                                          const wxRect& rectBar,
                                          int flags)
 {
     wxColourScheme::StdColour col = flags & wxCONTROL_PRESSED
                                     ? wxColourScheme::SCROLLBAR_PRESSED
                                     : wxColourScheme::SCROLLBAR;
                                          const wxRect& rectBar,
                                          int flags)
 {
     wxColourScheme::StdColour col = flags & wxCONTROL_PRESSED
                                     ? wxColourScheme::SCROLLBAR_PRESSED
                                     : wxColourScheme::SCROLLBAR;
-    DoDrawBackground(dc, m_scheme->Get(col), rectBar);
-}
-
-void wxWin32Renderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
-{
-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
-}
-
-wxRect wxWin32Renderer::GetScrollbarRect(const wxScrollBar *scrollbar,
-                                         wxScrollBar::Element elem,
-                                         int thumbPos) const
-{
-    return StandardGetScrollbarRect(scrollbar, elem,
-                                    thumbPos, m_sizeScrollbarArrow);
-}
-
-wxCoord wxWin32Renderer::GetScrollbarSize(const wxScrollBar *scrollbar)
-{
-    return StandardScrollBarSize(scrollbar, m_sizeScrollbarArrow);
-}
-
-wxHitTest wxWin32Renderer::HitTestScrollbar(const wxScrollBar *scrollbar,
-                                            const wxPoint& pt) const
-{
-    return StandardHitTestScrollbar(scrollbar, pt, m_sizeScrollbarArrow);
-}
-
-wxCoord wxWin32Renderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
-                                          int thumbPos)
-{
-    return StandardScrollbarToPixel(scrollbar, thumbPos, m_sizeScrollbarArrow);
-}
-
-int wxWin32Renderer::PixelToScrollbar(const wxScrollBar *scrollbar,
-                                      wxCoord coord)
-{
-    return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
+    DrawBackground(dc, m_scheme->Get(col), rectBar);
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
-// top level windows
+// standard icons
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-int wxWin32Renderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
-{
-    wxRect client = GetFrameClientArea(rect, flags);
-
-    if ( client.Inside(pt) )
-        return wxHT_TOPLEVEL_CLIENT_AREA;
-
-    if ( flags & wxTOPLEVEL_TITLEBAR )
-    {
-        wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
-
-        if ( flags & wxTOPLEVEL_ICON )
-        {
-            if ( wxRect(client.GetPosition(), GetFrameIconSize()).Inside(pt) )
-                return wxHT_TOPLEVEL_ICON;
-        }
-
-        wxRect btnRect(client.GetRight() - 2 - FRAME_BUTTON_WIDTH,
-                       client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2,
-                       FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
-
-        if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
-        {
-            if ( btnRect.Inside(pt) )
-                return wxHT_TOPLEVEL_BUTTON_CLOSE;
-            btnRect.x -= FRAME_BUTTON_WIDTH + 2;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
-        {
-            if ( btnRect.Inside(pt) )
-                return wxHT_TOPLEVEL_BUTTON_MAXIMIZE;
-            btnRect.x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
-        {
-            if ( btnRect.Inside(pt) )
-                return wxHT_TOPLEVEL_BUTTON_RESTORE;
-            btnRect.x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
-        {
-            if ( btnRect.Inside(pt) )
-                return wxHT_TOPLEVEL_BUTTON_ICONIZE;
-            btnRect.x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_HELP )
-        {
-            if ( btnRect.Inside(pt) )
-                return wxHT_TOPLEVEL_BUTTON_HELP;
-            btnRect.x -= FRAME_BUTTON_WIDTH;
-        }
-
-        if ( pt.y >= client.y && pt.y < client.y + FRAME_TITLEBAR_HEIGHT )
-            return wxHT_TOPLEVEL_TITLEBAR;
-    }
-
-    if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
-    {
-        // we are certainly at one of borders, lets decide which one:
-
-        int border = 0;
-        // dirty trick, relies on the way wxHT_TOPLEVEL_XXX are defined!
-        if ( pt.x < client.x )
-            border |= wxHT_TOPLEVEL_BORDER_W;
-        else if ( pt.x >= client.width + client.x )
-            border |= wxHT_TOPLEVEL_BORDER_E;
-        if ( pt.y < client.y )
-            border |= wxHT_TOPLEVEL_BORDER_N;
-        else if ( pt.y >= client.height + client.y )
-            border |= wxHT_TOPLEVEL_BORDER_S;
-        return border;
-    }
-
-    return wxHT_NOWHERE;
-}
-
-void wxWin32Renderer::DrawFrameTitleBar(wxDC& dc,
-                                        const wxRect& rect,
-                                        const wxString& title,
-                                        const wxIcon& icon,
-                                        int flags,
-                                        int specialButton,
-                                        int specialButtonFlags)
-{
-    if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
-    {
-        DrawFrameBorder(dc, rect, flags);
-    }
-    if ( flags & wxTOPLEVEL_TITLEBAR )
-    {
-        DrawFrameBackground(dc, rect, flags);
-        if ( flags & wxTOPLEVEL_ICON )
-            DrawFrameIcon(dc, rect, icon, flags);
-        DrawFrameTitle(dc, rect, title, flags);
-
-        wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
-        wxCoord x,y;
-        x = client.GetRight() - 2 - FRAME_BUTTON_WIDTH;
-        y = client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2;
-
-        if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
-        {
-            DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_CLOSE,
-                            (specialButton == wxTOPLEVEL_BUTTON_CLOSE) ?
-                            specialButtonFlags : 0);
-            x -= FRAME_BUTTON_WIDTH + 2;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
-        {
-            DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_MAXIMIZE,
-                            (specialButton == wxTOPLEVEL_BUTTON_MAXIMIZE) ?
-                            specialButtonFlags : 0);
-            x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
-        {
-            DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_RESTORE,
-                            (specialButton == wxTOPLEVEL_BUTTON_RESTORE) ?
-                            specialButtonFlags : 0);
-            x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
-        {
-            DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_ICONIZE,
-                            (specialButton == wxTOPLEVEL_BUTTON_ICONIZE) ?
-                            specialButtonFlags : 0);
-            x -= FRAME_BUTTON_WIDTH;
-        }
-        if ( flags & wxTOPLEVEL_BUTTON_HELP )
-        {
-            DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
-                            (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
-                            specialButtonFlags : 0);
-            x -= FRAME_BUTTON_WIDTH;
-        }
-    }
-}
-
-void wxWin32Renderer::DrawFrameBorder(wxDC& dc,
-                                      const wxRect& rect,
-                                      int flags)
-{
-    if ( !(flags & wxTOPLEVEL_BORDER) ) return;
-
-    wxRect r(rect);
-
-    DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
-    DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
-    DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
-    if ( flags & wxTOPLEVEL_RESIZEABLE )
-        DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
-}
-
-void wxWin32Renderer::DrawFrameBackground(wxDC& dc,
-                                          const wxRect& rect,
-                                          int flags)
-{
-    if ( !(flags & wxTOPLEVEL_TITLEBAR) ) return;
-
-    wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
-                   wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE) :
-                   wxSCHEME_COLOUR(m_scheme, TITLEBAR);
-
-    wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
-    r.height = FRAME_TITLEBAR_HEIGHT;
-
-    DrawBackground(dc, col, r);
-}
-
-void wxWin32Renderer::DrawFrameTitle(wxDC& dc,
-                                     const wxRect& rect,
-                                     const wxString& title,
-                                     int flags)
-{
-    wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
-                   wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE_TEXT) :
-                   wxSCHEME_COLOUR(m_scheme, TITLEBAR_TEXT);
-
-    wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
-    r.height = FRAME_TITLEBAR_HEIGHT;
-    if ( flags & wxTOPLEVEL_ICON )
-    {
-        r.x += FRAME_TITLEBAR_HEIGHT;
-        r.width -= FRAME_TITLEBAR_HEIGHT + 2;
-    }
-    else
-    {
-        r.x += 1;
-        r.width -= 3;
-    }
-
-    if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
-        r.width -= FRAME_BUTTON_WIDTH + 2;
-    if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
-        r.width -= FRAME_BUTTON_WIDTH;
-    if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
-        r.width -= FRAME_BUTTON_WIDTH;
-    if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
-        r.width -= FRAME_BUTTON_WIDTH;
-    if ( flags & wxTOPLEVEL_BUTTON_HELP )
-        r.width -= FRAME_BUTTON_WIDTH;
-
-    dc.SetFont(m_titlebarFont);
-    dc.SetTextForeground(col);
-
-    wxCoord textW;
-    dc.GetTextExtent(title, &textW, NULL);
-    if ( textW > r.width )
-    {
-        // text is too big, let's shorten it and add "..." after it:
-        size_t len = title.length();
-        wxCoord WSoFar, letterW;
-
-        dc.GetTextExtent(wxT("..."), &WSoFar, NULL);
-        if ( WSoFar > r.width )
-        {
-            // not enough space to draw anything
-            return;
-        }
-
-        wxString s;
-        s.Alloc(len);
-        for (size_t i = 0; i < len; i++)
-        {
-            dc.GetTextExtent(title[i], &letterW, NULL);
-            if ( letterW + WSoFar > r.width )
-                break;
-            WSoFar += letterW;
-            s << title[i];
-        }
-        s << wxT("...");
-        dc.DrawLabel(s, wxNullBitmap, r,
-                     wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
-    }
-    else
-        dc.DrawLabel(title, wxNullBitmap, r,
-                     wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
-}
-
-void wxWin32Renderer::DrawFrameIcon(wxDC& dc,
-                                    const wxRect& rect,
-                                    const wxIcon& icon,
-                                    int flags)
-{
-    if ( icon.Ok() )
-    {
-        wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
-        dc.DrawIcon(icon, r.x, r.y);
-    }
-}
-
-void wxWin32Renderer::DrawFrameButton(wxDC& dc,
-                                      wxCoord x, wxCoord y,
-                                      int button,
-                                      int flags)
-{
-    wxRect r(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
-
-    size_t idx = 0;
-    switch (button)
-    {
-        case wxTOPLEVEL_BUTTON_CLOSE:    idx = FrameButton_Close; break;
-        case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
-        case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
-        case wxTOPLEVEL_BUTTON_RESTORE:  idx = FrameButton_Restore; break;
-        case wxTOPLEVEL_BUTTON_HELP:     idx = FrameButton_Help; break;
-        default:
-            wxFAIL_MSG(wxT("incorrect button specification"));
-    }
-
-    if ( flags & wxCONTROL_PRESSED )
-    {
-        DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
-        DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
-        DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
-        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, TRUE);
-    }
-    else
-    {
-        DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
-        DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
-        DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
-        dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
-    }
-}
-
-
-wxRect wxWin32Renderer::GetFrameClientArea(const wxRect& rect,
-                                           int flags) const
-{
-    wxRect r(rect);
-
-    if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
-    {
-        int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
-                        RESIZEABLE_FRAME_BORDER_THICKNESS :
-                        FRAME_BORDER_THICKNESS;
-        r.Inflate(-border);
-    }
-    if ( flags & wxTOPLEVEL_TITLEBAR )
-    {
-        r.y += FRAME_TITLEBAR_HEIGHT;
-        r.height -= FRAME_TITLEBAR_HEIGHT;
-    }
-
-    return r;
-}
-
-wxSize wxWin32Renderer::GetFrameTotalSize(const wxSize& clientSize,
-                                     int flags) const
-{
-    wxSize s(clientSize);
-
-    if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
-    {
-        int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
-                        RESIZEABLE_FRAME_BORDER_THICKNESS :
-                        FRAME_BORDER_THICKNESS;
-        s.x += 2*border;
-        s.y += 2*border;
-    }
-    if ( flags & wxTOPLEVEL_TITLEBAR )
-        s.y += FRAME_TITLEBAR_HEIGHT;
-
-    return s;
-}
-
-wxSize wxWin32Renderer::GetFrameMinSize(int flags) const
-{
-    wxSize s(0, 0);
-
-    if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
-    {
-        int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
-                        RESIZEABLE_FRAME_BORDER_THICKNESS :
-                        FRAME_BORDER_THICKNESS;
-        s.x += 2*border;
-        s.y += 2*border;
-    }
-
-    if ( flags & wxTOPLEVEL_TITLEBAR )
-    {
-        s.y += FRAME_TITLEBAR_HEIGHT;
-
-        if ( flags & wxTOPLEVEL_ICON )
-            s.x += FRAME_TITLEBAR_HEIGHT + 2;
-        if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
-            s.x += FRAME_BUTTON_WIDTH + 2;
-        if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
-            s.x += FRAME_BUTTON_WIDTH;
-        if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
-            s.x += FRAME_BUTTON_WIDTH;
-        if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
-            s.x += FRAME_BUTTON_WIDTH;
-        if ( flags & wxTOPLEVEL_BUTTON_HELP )
-            s.x += FRAME_BUTTON_WIDTH;
-    }
-
-    return s;
-}
+/* Copyright (c) Julian Smart */
+static const char *error_xpm[]={
+/* columns rows colors chars-per-pixel */
+"32 32 70 1",
+"- c #BF0101",
+"b c #361F1F",
+"& c #C08484",
+"X c #BF3333",
+"# c #C08181",
+"% c #C01111",
+"d c #C51515",
+"s c #551818",
+"O c #C07E7E",
+": c #C00E0E",
+"u c #E28A8A",
+"2 c #C81F1F",
+"8 c #FFFFFF",
+"p c #E59494",
+"< c #BB0101",
+"y c #DA6A6A",
+"A c #4C4C4C",
+"9 c #F7DFDF",
+"@ c #BF5353",
+"w c #FAE9E9",
+"F c #272727",
+"5 c #D24A4A",
+". c #C06363",
+"n c #BF8282",
+"7 c #F2C9C9",
+"t c #C09292",
+"M c #3E3E3E",
+"x c #4D4D4D",
+"4 c #CA2A2A",
+"h c #E79F9F",
+"* c #C05454",
+"D c #711212",
+"V c #737373",
+"$ c #BF3232",
+"N c #900B0B",
+"6 c #BD0303",
+"3 c #DF7F7F",
+"K c #6F1212",
+"C c #BD0000",
+"m c #950909",
+"P c #8A8A8A",
+"j c #D75F5F",
+"  c None",
+"e c #F4D4D4",
+"S c #BF2020",
+"L c #747474",
+"G c #842C2C",
+"c c #ECB4B4",
+"l c #2E2121",
+"g c #BF7E7E",
+"k c #9B0808",
+"= c #BF0505",
+"a c #B10303",
+"q c #7E2020",
+"1 c #642222",
+"J c #676767",
+"B c #322020",
+"; c #C00303",
+"i c #242424",
+"o c #C00000",
+"> c #BF1F1F",
+", c #842B2B",
+"f c #701212",
+"0 c #BE0000",
+"r c #960909",
+"H c #686868",
+"v c #BC0000",
+"Z c #671414",
+"+ c #C02020",
+"z c #CD3535",
+/* pixels */
+"                                ",
+"                                ",
+"            .XoooOO             ",
+"         .+ooooooooo@#          ",
+"        $oooooooooooo%&         ",
+"      *=-ooooooooooooo;:        ",
+"     *oooooooooooooooooo>       ",
+"     =ooooooooooooooooooo,      ",
+"    $-ooooooooooooooooooo<1     ",
+"   .oooooo2334ooo533oooooo6     ",
+"   +ooooooo789oo2883oooooo0q    ",
+"   oooooooo2w83o78eoooooooor    ",
+"  toooooooooy88u884oooooooori   ",
+"  Xooooooooooe888poooooooooas   ",
+"  ooooooooooo4889doooooooooof   ",
+"  ooooooooooo588w2oooooooooofi  ",
+"  oooooooooodw8887oooooooooofi  ",
+"  goooooooooh8w588jooooooookli  ",
+"  tooooooooz885op8wdooooooorix  ",
+"   oooooood98cood98cooooooori   ",
+"   @oooooop8w2ooo5885ooooovbi   ",
+"   n%ooooooooooooooooooooomiM   ",
+"    &;oooooooooooooooooooNBiV   ",
+"     :ooooooooooooooooooCZiA    ",
+"     nSooooooooooooooooCDiF     ",
+"      nG<oooooooooooooNZiiH     ",
+"        160ooooooooovmBiFH      ",
+"         nqrraoookrrbiiA        ",
+"          nJisKKKliiiML         ",
+"             nPiiix             ",
+"                                ",
+"                                "
+};
 
 
-wxSize wxWin32Renderer::GetFrameIconSize() const
-{
-    return wxSize(16, 16);
-}
+/* Copyright (c) Julian Smart */
+static const char *info_xpm[]={
+/* columns rows colors chars-per-pixel */
+"32 32 17 1",
+"* c #A1A3FB",
+"X c #FFFFFF",
+"O c #191EF4",
+"= c #777AF9",
+": c #4D51F7",
+"  c None",
+"- c #2328F5",
+"+ c #4247F6",
+"; c #C1C2FC",
+". c #C0C0C0",
+"& c #E0E1FE",
+"% c #242424",
+"> c #2D32F5",
+"o c #CBCCFD",
+"# c #0309F3",
+"@ c #8C8FFA",
+"$ c #EAEBFE",
+/* pixels */
+"          .......               ",
+"       ...XXXXXXX...            ",
+"     ..XXXXXXXXXXXXX..          ",
+"    .XXXXXXXXXXXXXXXXX.         ",
+"   .XXXXXXXXoO+XXXXXXXX.        ",
+"  .XXXXXXXXX@#OXXXXXXXXX.       ",
+" .XXXXXXXXXX$@oXXXXXXXXXX.      ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.%     ",
+" .XXXXXXXXX&*=-XXXXXXXXXX.%%    ",
+".XXXXXXXXXX;:#>XXXXXXXXXXX.%    ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.%    ",
+".XXXXXXXXXXX;#+XXXXXXXXXXX.%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%%   ",
+" .XXXXXXXXXX;#+XXXXXXXXXX.%%    ",
+"  .XXXXXXXX*-##+XXXXXXXX.%%%    ",
+"   .XXXXXXXXXXXXXXXXXXX.%%%%    ",
+"    .XXXXXXXXXXXXXXXXX.%%%%     ",
+"     ..XXXXXXXXXXXXX..%%%%      ",
+"      %...XXXXXXXX..%%%%%       ",
+"       %%%..XXXXXX.%%%%%        ",
+"         %%%.XXXXX.%%%          ",
+"            %.XXXX.%%           ",
+"              .XXX.%%           ",
+"               .XX.%%           ",
+"                .X.%%           ",
+"                 ..%%           ",
+"                  .%%           ",
+"                   %%           ",
+"                    %           ",
+"                                ",
+"                                "
+};
 
 
+/* Copyright (c) Julian Smart */
+static const char *question_xpm[]={
+/* columns rows colors chars-per-pixel */
+"32 32 16 1",
+"O c #A3A3FF",
+"X c #FFFFFF",
+"% c #CACAFF",
+"- c #4141FF",
+"= c #6060FF",
+"* c #2B2BFF",
+"@ c #B5B5FF",
+"  c None",
+"# c #1616FF",
+"+ c #8181FF",
+"$ c #0000FF",
+". c #C0C0C0",
+"; c #5555FF",
+": c #242424",
+"o c #E7E7FF",
+"& c #7575FF",
+/* pixels */
+"          .......               ",
+"       ...XXXXXXX...            ",
+"     ..XXXXXXXXXXXXX..          ",
+"    .XXXXXXoO++@XXXXXX.         ",
+"   .XXXXXXO#$$$$#%XXXXX.        ",
+"  .XXXXXX@$$#&&#$#oXXXXX.       ",
+" .XXXXXXX*$$%XX%$$=XXXXXX.      ",
+" .XXXXXXX+-;XXXX$$-XXXXXX.:     ",
+" .XXXXXXXXXXXXX+$$&XXXXXX.::    ",
+".XXXXXXXXXXXXo;$$*oXXXXXXX.:    ",
+".XXXXXXXXXXXo*$$*oXXXXXXXX.:    ",
+".XXXXXXXXXXX+$$*oXXXXXXXXX.::   ",
+" .XXXXXXXXXX-$$oXXXXXXXXX.:::   ",
+" .XXXXXXXXXXX--XXXXXXXXXX.:::   ",
+" .XXXXXXXXXXXXXXXXXXXXXXX.::    ",
+"  .XXXXXXXXX-$$XXXXXXXXX.:::    ",
+"   .XXXXXXXX-$$XXXXXXXX.::::    ",
+"    .XXXXXXXO++XXXXXXX.::::     ",
+"     ..XXXXXXXXXXXXX..::::      ",
+"      :...XXXXXXXX..:::::       ",
+"       :::..XXXXXX.:::::        ",
+"         :::.XXXXX.:::          ",
+"            :.XXXX.::           ",
+"              .XXX.::           ",
+"               .XX.::           ",
+"                .X.::           ",
+"                 ..::           ",
+"                  .::           ",
+"                   ::           ",
+"                    :           ",
+"                                ",
+"                                "
+};
 
 
-// ----------------------------------------------------------------------------
-// standard icons
-// ----------------------------------------------------------------------------
+/* Copyright (c) Julian Smart */
+static const char *warning_xpm[]={
+/* columns rows colors chars-per-pixel */
+"32 32 9 1",
+"@ c Black",
+"o c #A6A800",
+"+ c #8A8C00",
+"$ c #B8BA00",
+"  c None",
+"O c #6E7000",
+"X c #DCDF00",
+". c #C00000",
+"# c #373800",
+/* pixels */
+"                                ",
+"                                ",
+"                                ",
+"                .               ",
+"               ...              ",
+"               ...              ",
+"              .....             ",
+"             ...X..             ",
+"             ..XXX..            ",
+"            ...XXX...           ",
+"            ..XXXXX..           ",
+"           ..XXXXXX...          ",
+"          ...XXoO+XX..          ",
+"          ..XXXO@#XXX..         ",
+"         ..XXXXO@#XXX...        ",
+"        ...XXXXO@#XXXX..        ",
+"        ..XXXXXO@#XXXX...       ",
+"       ...XXXXXo@OXXXXX..       ",
+"      ...XXXXXXo@OXXXXXX..      ",
+"      ..XXXXXXX$@OXXXXXX...     ",
+"     ...XXXXXXXX@XXXXXXXX..     ",
+"    ...XXXXXXXXXXXXXXXXXX...    ",
+"    ..XXXXXXXXXXOXXXXXXXXX..    ",
+"   ...XXXXXXXXXO@#XXXXXXXXX..   ",
+"   ..XXXXXXXXXXX#XXXXXXXXXX...  ",
+"  ...XXXXXXXXXXXXXXXXXXXXXXX..  ",
+" ...XXXXXXXXXXXXXXXXXXXXXXXX... ",
+" .............................. ",
+" .............................. ",
+"                                ",
+"                                ",
+"                                "
+};
 
 
-static char *error_xpm[]={
-"32 32 5 1",
-". c None",
-"# c #800000",
-"b c #808080",
-"a c #ff0000",
-"c c #ffffff",
-"...........########.............",
-"........###aaaaaaaa###..........",
-".......#aaaaaaaaaaaaaa#.........",
-".....##aaaaaaaaaaaaaaaa##.......",
-"....#aaaaaaaaaaaaaaaaaaaa#......",
-"...#aaaaaaaaaaaaaaaaaaaaaa#.....",
-"...#aaaaaaaaaaaaaaaaaaaaaa#b....",
-"..#aaaaaacaaaaaaaaaacaaaaaa#b...",
-".#aaaaaacccaaaaaaaacccaaaaaa#...",
-".#aaaaacccccaaaaaacccccaaaaa#b..",
-".#aaaaaacccccaaaacccccaaaaaa#bb.",
-"#aaaaaaaacccccaacccccaaaaaaaa#b.",
-"#aaaaaaaaaccccccccccaaaaaaaaa#b.",
-"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
-"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
-"#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
-"#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
-"#aaaaaaaaaccccccccccaaaaaaaaa#bb",
-"#aaaaaaaacccccaacccccaaaaaaaa#bb",
-".#aaaaaacccccaaaacccccaaaaaa#bbb",
-".#aaaaacccccaaaaaacccccaaaaa#bbb",
-".#aaaaaacccaaaaaaaacccaaaaaa#bb.",
-"..#aaaaaacaaaaaaaaaacaaaaaa#bbb.",
-"...#aaaaaaaaaaaaaaaaaaaaaa#bbbb.",
-"...#aaaaaaaaaaaaaaaaaaaaaa#bbb..",
-"....#aaaaaaaaaaaaaaaaaaaa#bbb...",
-".....##aaaaaaaaaaaaaaaa##bbbb...",
-"......b#aaaaaaaaaaaaaa#bbbbb....",
-".......b###aaaaaaaa###bbbbb.....",
-".........bb########bbbbbb.......",
-"..........bbbbbbbbbbbbbb........",
-".............bbbbbbbb..........."};
-
-static char *info_xpm[]={
-"32 32 6 1",
-". c None",
-"d c #000000",
-"c c #0000ff",
-"# c #808080",
-"a c #c0c0c0",
-"b c #ffffff",
-"...........########.............",
-"........###abbbbbba###..........",
-"......##abbbbbbbbbbbba##........",
-".....#abbbbbbbbbbbbbbbba#.......",
-"....#bbbbbbbaccccabbbbbbbd......",
-"...#bbbbbbbbccccccbbbbbbbbd.....",
-"..#bbbbbbbbbccccccbbbbbbbbbd....",
-".#abbbbbbbbbaccccabbbbbbbbbad...",
-".#bbbbbbbbbbbbbbbbbbbbbbbbbbd#..",
-"#abbbbbbbbbbbbbbbbbbbbbbbbbbad#.",
-"#bbbbbbbbbbcccccccbbbbbbbbbbbd#.",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
-"#abbbbbbbbbbbcccccbbbbbbbbbbad##",
-".#bbbbbbbbbbbcccccbbbbbbbbbbd###",
-".#abbbbbbbbbbcccccbbbbbbbbbad###",
-"..#bbbbbbbbcccccccccbbbbbbbd###.",
-"...dbbbbbbbbbbbbbbbbbbbbbbd####.",
-"....dbbbbbbbbbbbbbbbbbbbbd####..",
-".....dabbbbbbbbbbbbbbbbad####...",
-"......ddabbbbbbbbbbbbadd####....",
-".......#dddabbbbbbaddd#####.....",
-"........###dddabbbd#######......",
-"..........####dbbbd#####........",
-".............#dbbbd##...........",
-"...............dbbd##...........",
-"................dbd##...........",
-".................dd##...........",
-"..................###...........",
-"...................##..........."};
-
-static char *question_xpm[]={
-"32 32 6 1",
-". c None",
-"c c #000000",
-"d c #0000ff",
-"# c #808080",
-"a c #c0c0c0",
-"b c #ffffff",
-"...........########.............",
-"........###abbbbbba###..........",
-"......##abbbbbbbbbbbba##........",
-".....#abbbbbbbbbbbbbbbba#.......",
-"....#bbbbbbbbbbbbbbbbbbbbc......",
-"...#bbbbbbbaddddddabbbbbbbc.....",
-"..#bbbbbbbadabbddddabbbbbbbc....",
-".#abbbbbbbddbbbbddddbbbbbbbac...",
-".#bbbbbbbbddddbbddddbbbbbbbbc#..",
-"#abbbbbbbbddddbaddddbbbbbbbbac#.",
-"#bbbbbbbbbaddabddddbbbbbbbbbbc#.",
-"#bbbbbbbbbbbbbadddbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbdddbbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbddabbbbbbbbbbbbc##",
-"#bbbbbbbbbbbbbddbbbbbbbbbbbbbc##",
-"#abbbbbbbbbbbbbbbbbbbbbbbbbbac##",
-".#bbbbbbbbbbbaddabbbbbbbbbbbc###",
-".#abbbbbbbbbbddddbbbbbbbbbbac###",
-"..#bbbbbbbbbbddddbbbbbbbbbbc###.",
-"...cbbbbbbbbbaddabbbbbbbbbc####.",
-"....cbbbbbbbbbbbbbbbbbbbbc####..",
-".....cabbbbbbbbbbbbbbbbac####...",
-"......ccabbbbbbbbbbbbacc####....",
-".......#cccabbbbbbaccc#####.....",
-"........###cccabbbc#######......",
-"..........####cbbbc#####........",
-".............#cbbbc##...........",
-"...............cbbc##...........",
-"................cbc##...........",
-".................cc##...........",
-"..................###...........",
-"...................##..........."};
-
-static char *warning_xpm[]={
-"32 32 6 1",
-". c None",
-"c c #000000",
-"# c #808000",
-"d c #808080",
-"b c #c0c0c0",
-"a c #ffff00",
-".............###................",
-"............#aabc...............",
-"...........#aaaabcd.............",
-"...........#aaaaacdd............",
-"..........#aaaaaabcdd...........",
-"..........#aaaaaaacdd...........",
-".........#aaaaaaaabcdd..........",
-".........#aaaaaaaaacdd..........",
-"........#aaaaaaaaaabcdd.........",
-"........#aaabcccbaaacdd.........",
-".......#aaaacccccaaabcdd........",
-".......#aaaacccccaaaacdd........",
-"......#aaaaacccccaaaabcdd.......",
-"......#aaaaacccccaaaaacdd.......",
-".....#aaaaaacccccaaaaabcdd......",
-".....#aaaaaa#ccc#aaaaaacdd......",
-"....#aaaaaaabcccbaaaaaabcdd.....",
-"....#aaaaaaaacccaaaaaaaacdd.....",
-"...#aaaaaaaaa#c#aaaaaaaabcdd....",
-"...#aaaaaaaaabcbaaaaaaaaacdd....",
-"..#aaaaaaaaaaacaaaaaaaaaabcdd...",
-"..#aaaaaaaaaaaaaaaaaaaaaaacdd...",
-".#aaaaaaaaaaabccbaaaaaaaaabcdd..",
-".#aaaaaaaaaaaccccaaaaaaaaaacdd..",
-"#aaaaaaaaaaaaccccaaaaaaaaaabcdd.",
-"#aaaaaaaaaaaabccbaaaaaaaaaaacdd.",
-"#aaaaaaaaaaaaaaaaaaaaaaaaaaacddd",
-"#aaaaaaaaaaaaaaaaaaaaaaaaaabcddd",
-".#aaaaaaaaaaaaaaaaaaaaaaaabcdddd",
-"..#ccccccccccccccccccccccccddddd",
-"....ddddddddddddddddddddddddddd.",
-".....ddddddddddddddddddddddddd.."};
 
 wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
                                           const wxArtClient& WXUNUSED(client),
 
 wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
                                           const wxArtClient& WXUNUSED(client),
@@ -3907,32 +3061,28 @@ wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
 }
 
 
 }
 
 
+#if wxUSE_TEXTCTRL
+
 // ----------------------------------------------------------------------------
 // text control geometry
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // text control geometry
 // ----------------------------------------------------------------------------
 
-static inline int GetTextBorderWidth()
-{
-    return 1;
-}
-
-wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
-                                         const wxRect& rect) const
+wxRect
+wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
+                                  const wxRect& rect) const
 {
 {
-    wxRect rectTotal = rect;
+    wxRect rectTotal = wxStdRenderer::GetTextTotalArea(text, rect);
 
 
-    wxCoord widthBorder = GetTextBorderWidth();
-    rectTotal.Inflate(widthBorder);
-
-    // this is what Windows does
+    // this is strange but it's what Windows does
     rectTotal.height++;
 
     return rectTotal;
 }
 
     rectTotal.height++;
 
     return rectTotal;
 }
 
-wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
-                                          const wxRect& rect,
-                                          wxCoord *extraSpaceBeyond) const
+wxRect
+wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
+                                   const wxRect& rect,
+                                   wxCoord *extraSpaceBeyond) const
 {
     wxRect rectText = rect;
 
 {
     wxRect rectText = rect;
 
@@ -3940,15 +3090,11 @@ wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
     if ( rectText.height > 0 )
         rectText.height--;
 
     if ( rectText.height > 0 )
         rectText.height--;
 
-    wxCoord widthBorder = GetTextBorderWidth();
-    rectText.Inflate(-widthBorder);
-
-    if ( extraSpaceBeyond )
-        *extraSpaceBeyond = 0;
-
-    return rectText;
+    return wxStdRenderer::GetTextClientArea(text, rect, extraSpaceBeyond);
 }
 
 }
 
+#endif // wxUSE_TEXTCTRL
+
 // ----------------------------------------------------------------------------
 // size adjustments
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // size adjustments
 // ----------------------------------------------------------------------------
@@ -3968,10 +3114,23 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
         // skip border width adjustments, they don't make sense for us
         return;
     }
         // skip border width adjustments, they don't make sense for us
         return;
     }
-#endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
+#endif // wxUSE_SCROLLBAR
 
 
-#if wxUSE_BUTTON
-    if ( wxDynamicCast(window, wxButton) )
+#if wxUSE_BMPBUTTON
+    if ( wxDynamicCast(window, wxBitmapButton) )
+    {
+        // do nothing
+    } else
+#endif // wxUSE_BMPBUTTON
+#if wxUSE_BUTTON || wxUSE_TOGGLEBTN
+    if ( 0
+#  if wxUSE_BUTTON
+         || wxDynamicCast(window, wxButton)
+#  endif // wxUSE_BUTTON
+#  if wxUSE_TOGGLEBTN
+         || wxDynamicCast(window, wxToggleButton)
+#  endif // wxUSE_TOGGLEBTN
+        )
     {
         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
         {
     {
         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
         {
@@ -3985,15 +3144,35 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
                 size->y += 9;
         }
 
                 size->y += 9;
         }
 
+        // for compatibility with other ports, the buttons default size is never
+        // less than the standard one, but not when display not PDAs.
+        if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
+        {
+            if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
+            {
+                wxSize szDef = wxButton::GetDefaultSize();
+                if ( size->x < szDef.x )
+                    size->x = szDef.x;
+            }
+        }
+
         // no border width adjustments for buttons
         return;
     }
         // no border width adjustments for buttons
         return;
     }
-#endif // wxUSE_BUTTON
+#endif // wxUSE_BUTTON || wxUSE_TOGGLEBTN
+
+    wxStdRenderer::AdjustSize(size, window);
+}
+
+wxBitmap wxWin32Renderer::GetFrameButtonBitmap(FrameButtonType type)
+{
+    wxBitmap& bmp = m_bmpFrameButtons[type];
+    if ( !bmp.Ok() )
+    {
+        bmp = wxBitmap(ms_xpmFrameButtons[type]);
+    }
 
 
-    // take into account the border width
-    wxRect rectBorder = GetBorderDimensions(window->GetBorder());
-    size->x += rectBorder.x + rectBorder.width;
-    size->y += rectBorder.y + rectBorder.height;
+    return bmp;
 }
 
 // ============================================================================
 }
 
 // ============================================================================
@@ -4004,16 +3183,11 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
 // wxWin32InputHandler
 // ----------------------------------------------------------------------------
 
 // wxWin32InputHandler
 // ----------------------------------------------------------------------------
 
-wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
-{
-    m_renderer = renderer;
-}
-
-bool wxWin32InputHandler::HandleKey(wxInputConsumer *control,
-                                    const wxKeyEvent& event,
-                                    bool pressed)
+bool wxWin32InputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
+                                    const wxKeyEvent& WXUNUSED(event),
+                                    bool WXUNUSED(pressed))
 {
 {
-    return FALSE;
+    return false;
 }
 
 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
 }
 
 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
@@ -4022,30 +3196,30 @@ bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
     // clicking on the control gives it focus
     if ( event.ButtonDown() )
     {
     // clicking on the control gives it focus
     if ( event.ButtonDown() )
     {
-        wxWindow *win = control->GetInputWindow();
+        wxWindow * const win = control->GetInputWindow();
 
 
-        if (( wxWindow::FindFocus() != control->GetInputWindow() ) &&
-            ( win->AcceptsFocus() ) )
+        if ( win->CanAcceptFocus() && wxWindow::FindFocus() != win )
         {
             win->SetFocus();
 
         {
             win->SetFocus();
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
+#if wxUSE_SCROLLBAR
+
 // ----------------------------------------------------------------------------
 // wxWin32ScrollBarInputHandler
 // ----------------------------------------------------------------------------
 
 wxWin32ScrollBarInputHandler::
 // ----------------------------------------------------------------------------
 // wxWin32ScrollBarInputHandler
 // ----------------------------------------------------------------------------
 
 wxWin32ScrollBarInputHandler::
-wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
-                             wxInputHandler *handler)
+wxWin32ScrollBarInputHandler(wxRenderer *renderer, wxInputHandler *handler)
         : wxStdScrollBarInputHandler(renderer, handler)
 {
         : wxStdScrollBarInputHandler(renderer, handler)
 {
-    m_scrollPaused = FALSE;
+    m_scrollPaused = false;
     m_interval = 0;
 }
 
     m_interval = 0;
 }
 
@@ -4054,16 +3228,14 @@ bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 {
     // stop if went beyond the position of the original click (this can only
     // happen when we scroll by pages)
 {
     // stop if went beyond the position of the original click (this can only
     // happen when we scroll by pages)
-    bool stop = FALSE;
+    bool stop = false;
     if ( action == wxACTION_SCROLL_PAGE_DOWN )
     {
     if ( action == wxACTION_SCROLL_PAGE_DOWN )
     {
-        stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
-                != wxHT_SCROLLBAR_BAR_2;
+        stop = scrollbar->HitTestBar(m_ptStartScrolling) != wxHT_SCROLLBAR_BAR_2;
     }
     else if ( action == wxACTION_SCROLL_PAGE_UP )
     {
     }
     else if ( action == wxACTION_SCROLL_PAGE_UP )
     {
-        stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
-                != wxHT_SCROLLBAR_BAR_1;
+        stop = scrollbar->HitTestBar(m_ptStartScrolling) != wxHT_SCROLLBAR_BAR_1;
     }
 
     if ( stop )
     }
 
     if ( stop )
@@ -4072,7 +3244,7 @@ bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 
         scrollbar->Refresh();
 
 
         scrollbar->Refresh();
 
-        return FALSE;
+        return false;
     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
@@ -4105,12 +3277,12 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
     // mouse move events normally - only do it while mouse is captured (i.e.
     // when we're dragging the thumb or pressing on something)
     if ( !m_winCapture )
     // mouse move events normally - only do it while mouse is captured (i.e.
     // when we're dragging the thumb or pressing on something)
     if ( !m_winCapture )
-        return FALSE;
+        return false;
 
     if ( event.Entering() )
     {
         // we're not interested in this at all
 
     if ( event.Entering() )
     {
         // we're not interested in this at all
-        return FALSE;
+        return false;
     }
 
     wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
     }
 
     wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
@@ -4122,20 +3294,20 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
         if ( event.Leaving() )
         {
             // it surely didn't
         if ( event.Leaving() )
         {
             // it surely didn't
-            return FALSE;
+            return false;
         }
 
         }
 
-        ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
+        ht = scrollbar->HitTestBar(event.GetPosition());
         if ( ht == m_htLast )
         {
             // yes it did, resume scrolling
         if ( ht == m_htLast )
         {
             // yes it did, resume scrolling
-            m_scrollPaused = FALSE;
+            m_scrollPaused = false;
             if ( m_timerScroll )
             {
                 // we were scrolling by line/page, restart timer
                 m_timerScroll->Start(m_interval);
 
             if ( m_timerScroll )
             {
                 // we were scrolling by line/page, restart timer
                 m_timerScroll->Start(m_interval);
 
-                Press(scrollbar, TRUE);
+                Press(scrollbar, true);
             }
             else // we were dragging the thumb
             {
             }
             else // we were dragging the thumb
             {
@@ -4143,7 +3315,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 HandleThumbMove(scrollbar, m_eventLastDrag);
             }
 
                 HandleThumbMove(scrollbar, m_eventLastDrag);
             }
 
-            return TRUE;
+            return true;
         }
     }
     else // normal case, scrolling hasn't been paused
         }
     }
     else // normal case, scrolling hasn't been paused
@@ -4155,7 +3327,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
         // Always let thumb jump back if we leave the scrollbar
         if ( event.Moving() )
         {
         // Always let thumb jump back if we leave the scrollbar
         if ( event.Moving() )
         {
-            ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
+            ht = scrollbar->HitTestBar(event.GetPosition());
         }
         else // event.Leaving()
         {
         }
         else // event.Leaving()
         {
@@ -4174,7 +3346,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
             if (pos.y > -40 && pos.y < scrollbar->GetSize().y+40)
                pos.y = 5;
         }
             if (pos.y > -40 && pos.y < scrollbar->GetSize().y+40)
                pos.y = 5;
         }
-        ht = m_renderer->HitTestScrollbar(scrollbar, pos );
+        ht = scrollbar->HitTestBar(pos);
 #endif
 
         // if we're dragging the thumb and the mouse stays in the scrollbar, it
 #endif
 
         // if we're dragging the thumb and the mouse stays in the scrollbar, it
@@ -4195,10 +3367,10 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 // pause scrolling
                 m_interval = m_timerScroll->GetInterval();
                 m_timerScroll->Stop();
                 // pause scrolling
                 m_interval = m_timerScroll->GetInterval();
                 m_timerScroll->Stop();
-                m_scrollPaused = TRUE;
+                m_scrollPaused = true;
 
                 // unpress the arrow
 
                 // unpress the arrow
-                Press(scrollbar, FALSE);
+                Press(scrollbar, false);
             }
             else // we were dragging the thumb
             {
             }
             else // we were dragging the thumb
             {
@@ -4211,13 +3383,17 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return wxStdScrollBarInputHandler::HandleMouseMove(control, event);
+    return wxStdInputHandler::HandleMouseMove(control, event);
 }
 
 }
 
+#endif // wxUSE_SCROLLBAR
+
+#if wxUSE_CHECKBOX
+
 // ----------------------------------------------------------------------------
 // wxWin32CheckboxInputHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin32CheckboxInputHandler
 // ----------------------------------------------------------------------------
@@ -4248,17 +3424,21 @@ bool wxWin32CheckboxInputHandler::HandleKey(wxInputConsumer *control,
                 break;
         }
 
                 break;
         }
 
-        if ( !!action )
+        if ( !action.IsEmpty() )
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 }
 
+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_TEXTCTRL
+
 // ----------------------------------------------------------------------------
 // wxWin32TextCtrlInputHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin32TextCtrlInputHandler
 // ----------------------------------------------------------------------------
@@ -4290,13 +3470,17 @@ bool wxWin32TextCtrlInputHandler::HandleKey(wxInputConsumer *control,
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
+    return wxStdInputHandler::HandleKey(control, event, pressed);
 }
 
 }
 
+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_STATUSBAR
+
 // ----------------------------------------------------------------------------
 // wxWin32StatusBarInputHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin32StatusBarInputHandler
 // ----------------------------------------------------------------------------
@@ -4305,7 +3489,7 @@ wxWin32StatusBarInputHandler::
 wxWin32StatusBarInputHandler(wxInputHandler *handler)
     : wxStdInputHandler(handler)
 {
 wxWin32StatusBarInputHandler(wxInputHandler *handler)
     : wxStdInputHandler(handler)
 {
-    m_isOnGrip = FALSE;
+    m_isOnGrip = false;
 }
 
 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
 }
 
 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
@@ -4317,7 +3501,7 @@ bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
         wxTopLevelWindow *
             parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
 
         wxTopLevelWindow *
             parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
 
-        wxCHECK_MSG( parentTLW, FALSE,
+        wxCHECK_MSG( parentTLW, false,
                      _T("the status bar should be a child of a TLW") );
 
         // a maximized window can't be resized anyhow
                      _T("the status bar should be a child of a TLW") );
 
         // a maximized window can't be resized anyhow
@@ -4335,7 +3519,7 @@ bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
 }
 
 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
@@ -4358,7 +3542,7 @@ bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
 
                     statbar->SetCursor(m_cursorOld);
 
 
                     statbar->SetCursor(m_cursorOld);
 
-                    return TRUE;
+                    return true;
                 }
             }
         }
                 }
             }
         }
@@ -4390,6 +3574,8 @@ bool wxWin32StatusBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
     return wxStdInputHandler::HandleMouseMove(consumer, event);
 }
 
     return wxStdInputHandler::HandleMouseMove(consumer, event);
 }
 
+#endif // wxUSE_STATUSBAR
+
 // ----------------------------------------------------------------------------
 // wxWin32FrameInputHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin32FrameInputHandler
 // ----------------------------------------------------------------------------
@@ -4398,23 +3584,25 @@ class wxWin32SystemMenuEvtHandler : public wxEvtHandler
 {
 public:
     wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
 {
 public:
     wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
-    
+
     void Attach(wxInputConsumer *consumer);
     void Detach();
     void Attach(wxInputConsumer *consumer);
     void Detach();
-    
+
 private:
     DECLARE_EVENT_TABLE()
     void OnSystemMenu(wxCommandEvent &event);
     void OnCloseFrame(wxCommandEvent &event);
     void OnClose(wxCloseEvent &event);
 private:
     DECLARE_EVENT_TABLE()
     void OnSystemMenu(wxCommandEvent &event);
     void OnCloseFrame(wxCommandEvent &event);
     void OnClose(wxCloseEvent &event);
-   
+
     wxWin32FrameInputHandler *m_inputHnd;
     wxTopLevelWindow         *m_wnd;
     wxWin32FrameInputHandler *m_inputHnd;
     wxTopLevelWindow         *m_wnd;
+#if wxUSE_ACCEL
     wxAcceleratorTable        m_oldAccelTable;
     wxAcceleratorTable        m_oldAccelTable;
+#endif
 };
 
 };
 
-wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
-                                wxWin32FrameInputHandler *handler)
+wxWin32SystemMenuEvtHandler::
+wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler)
 {
     m_inputHnd = handler;
     m_wnd = NULL;
 {
     m_inputHnd = handler;
     m_wnd = NULL;
@@ -4426,22 +3614,26 @@ void wxWin32SystemMenuEvtHandler::Attach(wxInputConsumer *consumer)
 
     m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
     m_wnd->PushEventHandler(this);
 
     m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
     m_wnd->PushEventHandler(this);
-    
-    // VS: This code relies on using generic implementation of 
+
+#if wxUSE_ACCEL
+    // VS: This code relies on using generic implementation of
     //     wxAcceleratorTable in wxUniv!
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_oldAccelTable = table;
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
     m_wnd->SetAcceleratorTable(table);
     //     wxAcceleratorTable in wxUniv!
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_oldAccelTable = table;
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_SPACE, wxID_SYSTEM_MENU));
     table.Add(wxAcceleratorEntry(wxACCEL_ALT, WXK_F4, wxID_CLOSE_FRAME));
     m_wnd->SetAcceleratorTable(table);
+#endif
 }
 
 void wxWin32SystemMenuEvtHandler::Detach()
 {
     if ( m_wnd )
     {
 }
 
 void wxWin32SystemMenuEvtHandler::Detach()
 {
     if ( m_wnd )
     {
+#if wxUSE_ACCEL
         m_wnd->SetAcceleratorTable(m_oldAccelTable);
         m_wnd->SetAcceleratorTable(m_oldAccelTable);
-        m_wnd->RemoveEventHandler(this); 
+#endif
+        m_wnd->RemoveEventHandler(this);
         m_wnd = NULL;
     }
 }
         m_wnd = NULL;
     }
 }
@@ -4454,18 +3646,18 @@ END_EVENT_TABLE()
 
 void wxWin32SystemMenuEvtHandler::OnSystemMenu(wxCommandEvent &WXUNUSED(event))
 {
 
 void wxWin32SystemMenuEvtHandler::OnSystemMenu(wxCommandEvent &WXUNUSED(event))
 {
-    int border = ((m_wnd->GetWindowStyle() & wxRESIZE_BORDER) &&
-                  !m_wnd->IsMaximized()) ?
-                      RESIZEABLE_FRAME_BORDER_THICKNESS :
-                      FRAME_BORDER_THICKNESS;
-    wxPoint pt = m_wnd->GetClientAreaOrigin();
-    pt.x = -pt.x + border;
-    pt.y = -pt.y + border + FRAME_TITLEBAR_HEIGHT;
-
+#if wxUSE_ACCEL
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
     wxAcceleratorTable table = *m_wnd->GetAcceleratorTable();
     m_wnd->SetAcceleratorTable(wxNullAcceleratorTable);
-    m_inputHnd->PopupSystemMenu(m_wnd, pt);
+#endif
+
+#if wxUSE_MENUS
+    m_inputHnd->PopupSystemMenu(m_wnd);
+#endif // wxUSE_MENUS
+
+#if wxUSE_ACCEL
     m_wnd->SetAcceleratorTable(table);
     m_wnd->SetAcceleratorTable(table);
+#endif
 }
 
 void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
 }
 
 void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
@@ -4482,7 +3674,7 @@ void wxWin32SystemMenuEvtHandler::OnClose(wxCloseEvent &event)
 
 
 wxWin32FrameInputHandler::wxWin32FrameInputHandler(wxInputHandler *handler)
 
 
 wxWin32FrameInputHandler::wxWin32FrameInputHandler(wxInputHandler *handler)
-        : wxStdFrameInputHandler(handler)
+                        : wxStdInputHandler(handler)
 {
     m_menuHandler = new wxWin32SystemMenuEvtHandler(this);
 }
 {
     m_menuHandler = new wxWin32SystemMenuEvtHandler(this);
 }
@@ -4511,59 +3703,63 @@ bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
             tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
                                tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
                                                   : wxTOPLEVEL_BUTTON_MAXIMIZE);
             tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
                                tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
                                                   : wxTOPLEVEL_BUTTON_MAXIMIZE);
-            return TRUE;
+            return true;
         }
         else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
         {
             if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
         }
         else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
         {
             if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
-                 (event.RightDown() && 
-                      (hit == wxHT_TOPLEVEL_TITLEBAR || 
+                 (event.RightDown() &&
+                      (hit == wxHT_TOPLEVEL_TITLEBAR ||
                        hit == wxHT_TOPLEVEL_ICON)) )
             {
                        hit == wxHT_TOPLEVEL_ICON)) )
             {
-                PopupSystemMenu(tlw, event.GetPosition());
-                return TRUE;
+#if wxUSE_MENUS
+                PopupSystemMenu(tlw);
+#endif // wxUSE_MENUS
+                return true;
             }
         }
     }
 
             }
         }
     }
 
-    return wxStdFrameInputHandler::HandleMouse(consumer, event);
+    return wxStdInputHandler::HandleMouse(consumer, event);
 }
 
 }
 
-void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window, 
-                                               const wxPoint& pos) const
+#if wxUSE_MENUS
+
+void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window) const
 {
 {
-    wxMenu *menu = new wxMenu;
+    wxMenu menu;
 
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
 
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
-        menu->Append(wxID_RESTORE_FRAME , _("&Restore"));
-    menu->Append(wxID_MOVE_FRAME , _("&Move"));
+        menu.Append(wxID_RESTORE_FRAME , _("&Restore"));
+    menu.Append(wxID_MOVE_FRAME , _("&Move"));
     if ( window->GetWindowStyle() & wxRESIZE_BORDER )
     if ( window->GetWindowStyle() & wxRESIZE_BORDER )
-        menu->Append(wxID_RESIZE_FRAME , _("&Size"));
+        menu.Append(wxID_RESIZE_FRAME , _("&Size"));
     if ( wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME) )
     if ( wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME) )
-        menu->Append(wxID_ICONIZE_FRAME , _("Mi&nimize"));
+        menu.Append(wxID_ICONIZE_FRAME , _("Mi&nimize"));
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
-        menu->Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
-    menu->AppendSeparator();
-    menu->Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));
-    
+        menu.Append(wxID_MAXIMIZE_FRAME , _("Ma&ximize"));
+    menu.AppendSeparator();
+    menu.Append(wxID_CLOSE_FRAME, _("Close\tAlt-F4"));
+
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
     {
         if ( window->IsMaximized() )
         {
     if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
     {
         if ( window->IsMaximized() )
         {
-            menu->Enable(wxID_MAXIMIZE_FRAME, FALSE);
-            menu->Enable(wxID_MOVE_FRAME, FALSE);
+            menu.Enable(wxID_MAXIMIZE_FRAME, false);
+            menu.Enable(wxID_MOVE_FRAME, false);
             if ( window->GetWindowStyle() & wxRESIZE_BORDER )
             if ( window->GetWindowStyle() & wxRESIZE_BORDER )
-                menu->Enable(wxID_RESIZE_FRAME, FALSE);
+                menu.Enable(wxID_RESIZE_FRAME, false);
         }
         else
         }
         else
-            menu->Enable(wxID_RESTORE_FRAME, FALSE);
+            menu.Enable(wxID_RESTORE_FRAME, false);
     }
 
     }
 
-    window->PopupMenu(menu, pos);
-    delete menu;
+    window->PopupMenu(&menu, wxPoint(0, 0));
 }
 
 }
 
-bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer, 
+#endif // wxUSE_MENUS
+
+bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
                                                 bool activated)
 {
     if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
                                                 bool activated)
 {
     if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
@@ -4577,5 +3773,7 @@ bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
         }
     }
 
         }
     }
 
-    return wxStdFrameInputHandler::HandleActivation(consumer, activated);
+    return wxStdInputHandler::HandleActivation(consumer, activated);
 }
 }
+
+#endif // wxUSE_THEME_WIN32