]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/themes/win32.cpp
Build fix after wxColourBase introduction.
[wxWidgets.git] / src / univ / themes / win32.cpp
index 997c95c089c84739cc7c78e0444c8afe579d0ff1..ed3e0f8d58c6c6a47dcb56068c930f418026999d 100644 (file)
@@ -6,7 +6,7 @@
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
     #include "wx/dcmemory.h"
 
     #include "wx/button.h"
     #include "wx/dcmemory.h"
 
     #include "wx/button.h"
+    #include "wx/bmpbuttn.h"
     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
     #include "wx/listbox.h"
     #include "wx/checklst.h"
     #include "wx/combobox.h"
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
+    #include "wx/listbox.h"
+    #include "wx/toolbar.h"
+    #include "wx/statusbr.h"
+
+    #ifdef __WXMSW__
+        // for COLOR_* constants
+        #include "wx/msw/private.h"
+    #endif
 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
 #include "wx/settings.h"
 #include "wx/menu.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/toplevel.h"
+#include "wx/image.h"
 
 #include "wx/univ/scrtimer.h"
 
 #include "wx/univ/scrtimer.h"
-
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
@@ -63,6 +74,21 @@ static const int BORDER_THICKNESS = 2;
 static const int FOCUS_RECT_OFFSET_X = 1;
 static const int FOCUS_RECT_OFFSET_Y = 1;
 
 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 wxCoord SLIDER_MARGIN = 6; // margin around slider
+static const wxCoord SLIDER_THUMB_LENGTH = 18;
+static const wxCoord SLIDER_TICK_LENGTH = 6;
+
 enum IndicatorType
 {
     IndicatorType_Check,
 enum IndicatorType
 {
     IndicatorType_Check,
@@ -85,6 +111,7 @@ enum IndicatorStatus
 {
     IndicatorStatus_Checked,
     IndicatorStatus_Unchecked,
 {
     IndicatorStatus_Checked,
     IndicatorStatus_Unchecked,
+    IndicatorStatus_Undeterminated,
     IndicatorStatus_Max
 };
 
     IndicatorStatus_Max
 };
 
@@ -109,11 +136,21 @@ public:
         Arrow_Normal,
         Arrow_Disabled,
         Arrow_Pressed,
         Arrow_Normal,
         Arrow_Disabled,
         Arrow_Pressed,
-        Arrow_Inversed,
-        Arrow_InversedDisabled,
+        Arrow_Inverted,
+        Arrow_InvertedDisabled,
         Arrow_StateMax
     };
 
         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);
 
@@ -121,7 +158,8 @@ public:
     virtual void DrawBackground(wxDC& dc,
                                 const wxColour& col,
                                 const wxRect& rect,
     virtual void DrawBackground(wxDC& dc,
                                 const wxColour& col,
                                 const wxRect& rect,
-                                int flags = 0);
+                                int flags = 0,
+                                wxWindow *window = NULL);
     virtual void DrawLabel(wxDC& dc,
                            const wxString& label,
                            const wxRect& rect,
     virtual void DrawLabel(wxDC& dc,
                            const wxString& label,
                            const wxRect& rect,
@@ -203,6 +241,12 @@ public:
                                  int flags = 0,
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
                                  int flags = 0,
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags = 0,
+                                   long style = 0);
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
@@ -220,22 +264,25 @@ public:
 
     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);
-#if wxUSE_MENUS
+                                 int flags = 0,
+                                 long style = 0);
 
     virtual void DrawMenuBarItem(wxDC& dc,
                                  const wxRect& rect,
 
     virtual void DrawMenuBarItem(wxDC& dc,
                                  const wxRect& rect,
@@ -253,8 +300,46 @@ public:
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);
-#endif
+
+    virtual void DrawStatusField(wxDC& dc,
+                                 const wxRect& rect,
+                                 const wxString& label,
+                                 int flags = 0, int style = 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;
+
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
+                                 wxBitmap *bmpFocus,
                                  wxBitmap *bmpPressed,
                                  wxBitmap *bmpDisabled);
 
                                  wxBitmap *bmpPressed,
                                  wxBitmap *bmpDisabled);
 
@@ -282,28 +367,37 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 0; }
 
     virtual wxCoord GetCheckItemMargin() const
         { return 0; }
 
+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+        { if ( separator ) *separator = 5; return wxSize(16, 15); }
+    virtual wxSize GetToolBarMargin() const
+        { return wxSize(4, 4); }
+
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rect);
+                                    const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
-                                     wxCoord *extraSpaceBeyond);
+                                     wxCoord *extraSpaceBeyond) const;
 
     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); }
 
-    virtual wxCoord GetSliderDim() const { return 20; }
-    virtual wxCoord GetSliderTickLen() const { return 4; }
+    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;
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 
                                       wxOrientation orient) const;
     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;
-#endif
+
+    virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
+
 protected:
     // helper of DrawLabel() and DrawCheckOrRadioButton()
     void DoDrawLabel(wxDC& dc,
 protected:
     // helper of DrawLabel() and DrawCheckOrRadioButton()
     void DoDrawLabel(wxDC& dc,
@@ -329,7 +423,8 @@ protected:
     // DrawButtonBorder() helper
     void DoDrawBackground(wxDC& dc,
                           const wxColour& col,
     // DrawButtonBorder() helper
     void DoDrawBackground(wxDC& dc,
                           const wxColour& col,
-                          const wxRect& rect);
+                          const wxRect& rect,
+                          wxWindow *window = NULL );
 
     // DrawBorder() helpers: all of them shift and clip the DC after drawing
     // the border
 
     // DrawBorder() helpers: all of them shift and clip the DC after drawing
     // the border
@@ -352,7 +447,7 @@ protected:
     void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 
     // draw the border used for scrollbar arrows
     void DrawSunkenBorder(wxDC& dc, wxRect *rect);
 
     // 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,
@@ -378,7 +473,7 @@ protected:
     void DrawLine(wxDC& dc,
                   wxCoord x1, wxCoord y1,
                   wxCoord x2, wxCoord y2,
     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);
@@ -408,6 +503,19 @@ private:
           m_penLightGrey,
           m_penHighlight;
 
           m_penLightGrey,
           m_penHighlight;
 
+    wxFont m_titlebarFont;
+
+    // the checked and unchecked bitmaps for DrawCheckItem()
+    wxBitmap m_bmpCheckBitmaps[IndicatorStatus_Max];
+
+    // the bitmaps returned by GetIndicator()
+    wxBitmap m_bmpIndicators[IndicatorType_Max]
+                            [IndicatorState_Max]
+                            [IndicatorStatus_Max];
+
+    // titlebar icons:
+    wxBitmap m_bmpFrameButtons[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];
 };
@@ -422,10 +530,10 @@ class wxWin32InputHandler : public wxInputHandler
 public:
     wxWin32InputHandler(wxWin32Renderer *renderer);
 
 public:
     wxWin32InputHandler(wxWin32Renderer *renderer);
 
-    virtual bool HandleKey(wxControl *control,
+    virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
                            const wxKeyEvent& event,
                            bool pressed);
-    virtual bool HandleMouse(wxControl *control,
+    virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
 
 protected:
                              const wxMouseEvent& event);
 
 protected:
@@ -438,8 +546,8 @@ public:
     wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
                                  wxInputHandler *handler);
 
     wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
                                  wxInputHandler *handler);
 
-    virtual bool HandleMouse(wxControl *control, const wxMouseEvent& event);
-    virtual bool HandleMouseMove(wxControl *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);
 
     virtual bool OnScrollTimer(wxScrollBar *scrollbar,
                                const wxControlAction& action);
@@ -447,7 +555,8 @@ public:
 protected:
     virtual bool IsAllowedButton(int button) { return button == 1; }
 
 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
     }
@@ -469,7 +578,7 @@ public:
     wxWin32CheckboxInputHandler(wxInputHandler *handler)
         : wxStdCheckboxInputHandler(handler) { }
 
     wxWin32CheckboxInputHandler(wxInputHandler *handler)
         : wxStdCheckboxInputHandler(handler) { }
 
-    virtual bool HandleKey(wxControl *control,
+    virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
                            const wxKeyEvent& event,
                            bool pressed);
 };
@@ -480,11 +589,54 @@ public:
     wxWin32TextCtrlInputHandler(wxInputHandler *handler)
         : wxStdTextCtrlInputHandler(handler) { }
 
     wxWin32TextCtrlInputHandler(wxInputHandler *handler)
         : wxStdTextCtrlInputHandler(handler) { }
 
-    virtual bool HandleKey(wxControl *control,
+    virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
 };
 
                            const wxKeyEvent& event,
                            bool pressed);
 };
 
+class wxWin32StatusBarInputHandler : public wxStdInputHandler
+{
+public:
+    wxWin32StatusBarInputHandler(wxInputHandler *handler);
+
+    virtual bool HandleMouse(wxInputConsumer *consumer,
+                             const wxMouseEvent& event);
+
+    virtual bool HandleMouseMove(wxInputConsumer *consumer,
+                                 const wxMouseEvent& event);
+
+protected:
+    // is the given point over the statusbar grip?
+    bool IsOnGrip(wxWindow *statbar, const wxPoint& pt) const;
+
+private:
+    // the cursor we had replaced with the resize one
+    wxCursor m_cursorOld;
+
+    // was the mouse over the grip last time we checked?
+    bool m_isOnGrip;
+};
+
+class wxWin32SystemMenuEvtHandler;
+
+class wxWin32FrameInputHandler : public wxStdFrameInputHandler
+{
+public:
+    wxWin32FrameInputHandler(wxInputHandler *handler);
+    ~wxWin32FrameInputHandler();
+
+    virtual bool HandleMouse(wxInputConsumer *control,
+                             const wxMouseEvent& event);
+
+    virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
+
+    void PopupSystemMenu(wxTopLevelWindow *window, const wxPoint& pos) const;
+
+private:
+    // was the mouse over the grip last time we checked?
+    wxWin32SystemMenuEvtHandler *m_menuHandler;
+};
+
 // ----------------------------------------------------------------------------
 // wxWin32ColourScheme: uses (default) Win32 colours
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxWin32ColourScheme: uses (default) Win32 colours
 // ----------------------------------------------------------------------------
@@ -496,11 +648,23 @@ public:
     virtual wxColour GetBackground(wxWindow *win) const;
 };
 
     virtual wxColour GetBackground(wxWindow *win) const;
 };
 
+// ----------------------------------------------------------------------------
+// wxWin32ArtProvider
+// ----------------------------------------------------------------------------
+
+class wxWin32ArtProvider : public wxArtProvider
+{
+protected:
+    virtual wxBitmap CreateBitmap(const wxArtID& id,
+                                  const wxArtClient& client,
+                                  const wxSize& size);
+};
+
 // ----------------------------------------------------------------------------
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxWin32Theme
 // ----------------------------------------------------------------------------
 
-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
 
 class wxWin32Theme : public wxTheme
 {
 
 class wxWin32Theme : public wxTheme
 {
@@ -508,7 +672,8 @@ public:
     wxWin32Theme();
     virtual ~wxWin32Theme();
 
     wxWin32Theme();
     virtual ~wxWin32Theme();
 
-    virtual wxRenderer *GetRenderer() { return m_renderer; }
+    virtual wxRenderer *GetRenderer();
+    virtual wxArtProvider *GetArtProvider();
     virtual wxInputHandler *GetInputHandler(const wxString& control);
     virtual wxColourScheme *GetColourScheme();
 
     virtual wxInputHandler *GetInputHandler(const wxString& control);
     virtual wxColourScheme *GetColourScheme();
 
@@ -518,6 +683,8 @@ private:
 
     wxWin32Renderer *m_renderer;
 
 
     wxWin32Renderer *m_renderer;
 
+    wxWin32ArtProvider *m_artProvider;
+
     // the names of the already created handlers and the handlers themselves
     // (these arrays are synchronized)
     wxSortedArrayString m_handlerNames;
     // the names of the already created handlers and the handlers themselves
     // (these arrays are synchronized)
     wxSortedArrayString m_handlerNames;
@@ -534,6 +701,83 @@ private:
 // standard bitmaps
 // ----------------------------------------------------------------------------
 
 // standard bitmaps
 // ----------------------------------------------------------------------------
 
+// frame buttons bitmaps
+
+static const char *frame_button_close_xpm[] = {
+"12 10 2 1",
+"         c None",
+".        c black",
+"            ",
+"  ..    ..  ",
+"   ..  ..   ",
+"    ....    ",
+"     ..     ",
+"    ....    ",
+"   ..  ..   ",
+"  ..    ..  ",
+"            ",
+"            "};
+
+static const char *frame_button_help_xpm[] = {
+"12 10 2 1",
+"         c None",
+".        c #000000",
+"    ....    ",
+"   ..  ..   ",
+"   ..  ..   ",
+"      ..    ",
+"     ..     ",
+"     ..     ",
+"            ",
+"     ..     ",
+"     ..     ",
+"            "};
+
+static const char *frame_button_maximize_xpm[] = {
+"12 10 2 1",
+"         c None",
+".        c #000000",
+" .........  ",
+" .........  ",
+" .       .  ",
+" .       .  ",
+" .       .  ",
+" .       .  ",
+" .       .  ",
+" .       .  ",
+" .........  ",
+"            "};
+
+static const char *frame_button_minimize_xpm[] = {
+"12 10 2 1",
+"         c None",
+".        c #000000",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"  ......    ",
+"  ......    ",
+"            "};
+
+static const char *frame_button_restore_xpm[] = {
+"12 10 2 1",
+"         c None",
+".        c #000000",
+"   ......   ",
+"   ......   ",
+"   .    .   ",
+" ...... .   ",
+" ...... .   ",
+" .    ...   ",
+" .    .     ",
+" .    .     ",
+" ......     ",
+"            "};
+
 // menu bitmaps
 
 static const char *checked_menu_xpm[] = {
 // menu bitmaps
 
 static const char *checked_menu_xpm[] = {
@@ -767,6 +1011,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",
@@ -888,48 +1180,54 @@ static const char *pressed_unchecked_radio_xpm[] = {
 };
 
 static const char **
 };
 
 static const char **
-    bmpIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
+    xpmIndicators[IndicatorType_Max][IndicatorState_Max][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] =
+{
+    checked_item_xpm,
+    unchecked_item_xpm
+};
+
 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================
@@ -942,9 +1240,10 @@ WX_IMPLEMENT_THEME(wxWin32Theme, win32, wxTRANSLATE("Win32 theme"));
 
 wxWin32Theme::wxWin32Theme()
 {
 
 wxWin32Theme::wxWin32Theme()
 {
-    m_scheme = new wxWin32ColourScheme;
-    m_renderer = new wxWin32Renderer(m_scheme);
+    m_scheme = NULL;
+    m_renderer = NULL;
     m_handlerDefault = NULL;
     m_handlerDefault = NULL;
+    m_artProvider = NULL;
 }
 
 wxWin32Theme::~wxWin32Theme()
 }
 
 wxWin32Theme::~wxWin32Theme()
@@ -960,6 +1259,27 @@ wxWin32Theme::~wxWin32Theme()
 
     delete m_renderer;
     delete m_scheme;
 
     delete m_renderer;
     delete m_scheme;
+    wxArtProvider::RemoveProvider(m_artProvider);
+}
+
+wxRenderer *wxWin32Theme::GetRenderer()
+{
+    if ( !m_renderer )
+    {
+        m_renderer = new wxWin32Renderer(GetColourScheme());
+    }
+
+    return m_renderer;
+}
+
+wxArtProvider *wxWin32Theme::GetArtProvider()
+{
+    if ( !m_artProvider )
+    {
+        m_artProvider = new wxWin32ArtProvider;
+    }
+
+    return m_artProvider;
 }
 
 wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
 }
 
 wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
@@ -1018,6 +1338,16 @@ wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
         else if ( control == wxINP_HANDLER_NOTEBOOK )
             handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
 #endif // wxUSE_NOTEBOOK
         else if ( control == wxINP_HANDLER_NOTEBOOK )
             handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
 #endif // wxUSE_NOTEBOOK
+#if wxUSE_STATUSBAR
+        else if ( control == wxINP_HANDLER_STATUSBAR )
+            handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
+#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();
 
         else
             handler = GetDefaultInputHandler();
 
@@ -1034,6 +1364,10 @@ wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
 
 wxColourScheme *wxWin32Theme::GetColourScheme()
 {
 
 wxColourScheme *wxWin32Theme::GetColourScheme()
 {
+    if ( !m_scheme )
+    {
+        m_scheme = new wxWin32ColourScheme;
+    }
     return m_scheme;
 }
 
     return m_scheme;
 }
 
@@ -1050,21 +1384,32 @@ wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
         col = win->GetBackgroundColour();
     }
 
         col = win->GetBackgroundColour();
     }
 
-    if ( win->IsContainerWindow() )
+    if ( !win->ShouldInheritColours() )
     {
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
     {
         wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
-        if ( text )
+#if wxUSE_LISTBOX
+        wxListBox* listBox = wxDynamicCast(win, wxListBox);
+#endif
+        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);
+                }
+            }
         }
 
         }
 
-        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
     {
@@ -1072,7 +1417,7 @@ wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
 
         // the colour set by the user should be used for the normal state
         // and for the states for which we don't have any specific colours
 
         // the colour set by the user should be used for the normal state
         // and for the states for which we don't have any specific colours
-        if ( !col.Ok() || (flags != 0) )
+        if ( !col.Ok() || (flags & wxCONTROL_PRESSED) != 0 )
         {
             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
         {
             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
@@ -1089,6 +1434,48 @@ wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
 {
     switch ( col )
     {
 {
     switch ( col )
     {
+        // use the system colours under Windows
+#if defined(__WXMSW__)
+        case WINDOW:            return wxColour(GetSysColor(COLOR_WINDOW));
+
+        case CONTROL_PRESSED:
+        case CONTROL_CURRENT:
+        case CONTROL:           return wxColour(GetSysColor(COLOR_BTNFACE));
+
+        case CONTROL_TEXT:      return wxColour(GetSysColor(COLOR_BTNTEXT));
+
+#if defined(COLOR_3DLIGHT)
+        case SCROLLBAR:         return wxColour(GetSysColor(COLOR_3DLIGHT));
+#else
+        case SCROLLBAR:         return wxColour(0xe0e0e0);
+#endif
+        case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_BTNTEXT));
+
+        case HIGHLIGHT:         return wxColour(GetSysColor(COLOR_HIGHLIGHT));
+        case HIGHLIGHT_TEXT:    return wxColour(GetSysColor(COLOR_HIGHLIGHTTEXT));
+
+#if defined(COLOR_3DDKSHADOW)
+        case SHADOW_DARK:       return wxColour(GetSysColor(COLOR_3DDKSHADOW));
+#else
+        case SHADOW_DARK:       return wxColour(GetSysColor(COLOR_3DHADOW));
+#endif
+
+        case CONTROL_TEXT_DISABLED:
+        case SHADOW_HIGHLIGHT:  return wxColour(GetSysColor(COLOR_BTNHIGHLIGHT));
+
+        case SHADOW_IN:         return wxColour(GetSysColor(COLOR_BTNFACE));
+
+        case CONTROL_TEXT_DISABLED_SHADOW:
+        case SHADOW_OUT:        return wxColour(GetSysColor(COLOR_BTNSHADOW));
+
+        case TITLEBAR:          return wxColour(GetSysColor(COLOR_INACTIVECAPTION));
+        case TITLEBAR_ACTIVE:   return wxColour(GetSysColor(COLOR_ACTIVECAPTION));
+        case TITLEBAR_TEXT:     return wxColour(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
+        case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
+
+        case DESKTOP:           return wxColour(0x808000);
+#else // !__WXMSW__
+        // use the standard Windows colours elsewhere
         case WINDOW:            return *wxWHITE;
 
         case CONTROL_PRESSED:
         case WINDOW:            return *wxWHITE;
 
         case CONTROL_PRESSED:
@@ -1105,14 +1492,24 @@ wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
 
         case SHADOW_DARK:       return *wxBLACK;
 
 
         case SHADOW_DARK:       return *wxBLACK;
 
-        case CONTROL_TEXT_DISABLED:
-        case SHADOW_HIGHLIGHT:  return wxColour(0xe0e0e0);
+        case CONTROL_TEXT_DISABLED:return wxColour(0xe0e0e0);
+        case SHADOW_HIGHLIGHT:  return wxColour(0xffffff);
 
         case SHADOW_IN:         return wxColour(0xc0c0c0);
 
         case CONTROL_TEXT_DISABLED_SHADOW:
         case SHADOW_OUT:        return wxColour(0x7f7f7f);
 
 
         case SHADOW_IN:         return wxColour(0xc0c0c0);
 
         case CONTROL_TEXT_DISABLED_SHADOW:
         case SHADOW_OUT:        return wxColour(0x7f7f7f);
 
+        case TITLEBAR:          return wxColour(0xaeaaae);
+        case TITLEBAR_ACTIVE:   return wxColour(0x820300);
+        case TITLEBAR_TEXT:     return wxColour(0xc0c0c0);
+        case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
+
+        case DESKTOP:           return wxColour(0x808000);
+#endif // __WXMSW__
+
+        case GAUGE:             return Get(HIGHLIGHT);
+
         case MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));
         case MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));
@@ -1145,6 +1542,9 @@ wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
     m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
     m_penHighlight = wxPen(m_colHighlight, 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;
@@ -1277,31 +1677,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);
@@ -1314,6 +1714,13 @@ 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);
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1408,8 +1815,7 @@ void wxWin32Renderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
                 rect->GetRight(), rect->GetBottom());
 
     // adjust the rect
                 rect->GetRight(), rect->GetBottom());
 
     // adjust the rect
-    rect->width--;
-    rect->height--;
+    rect->Inflate(-1);
 }
 
 void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
 }
 
 void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
@@ -1539,8 +1945,12 @@ wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
             break;
 
         default:
             break;
 
         default:
+        {
+            // char *crash = NULL;
+            // *crash = 0;
             wxFAIL_MSG(_T("unknown border type"));
             // fall through
             wxFAIL_MSG(_T("unknown border type"));
             // fall through
+        }
 
         case wxBORDER_DEFAULT:
         case wxBORDER_NONE:
 
         case wxBORDER_DEFAULT:
         case wxBORDER_NONE:
@@ -1559,7 +1969,7 @@ wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
 
 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
 {
 
 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
 {
-    return TRUE;
+    return true;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1913,12 +2323,20 @@ void wxWin32Renderer::DrawCheckItem(wxDC& dc,
     }
     else // use default bitmap
     {
     }
     else // use default bitmap
     {
-        bmp = wxBitmap(flags & wxCONTROL_CHECKED ? checked_item_xpm
-                                                 : unchecked_item_xpm);
+        IndicatorStatus i = flags & wxCONTROL_CHECKED
+                                ? IndicatorStatus_Checked
+                                : IndicatorStatus_Unchecked;
+
+        if ( !m_bmpCheckBitmaps[i].Ok() )
+        {
+            m_bmpCheckBitmaps[i] = wxBitmap(xpmChecked[i]);
+        }
+
+        bmp = m_bmpCheckBitmaps[i];
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
     }
 
     dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
-                  TRUE /* use mask */);
+                  true /* use mask */);
 
     wxRect rectLabel = rect;
     int bmpWidth = bmp.GetWidth();
 
     wxRect rectLabel = rect;
     int bmpWidth = bmp.GetWidth();
@@ -1947,10 +2365,23 @@ wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
 
     IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
                                     ? IndicatorStatus_Checked
 
     IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
                                     ? IndicatorStatus_Checked
-                                    : IndicatorStatus_Unchecked;
+                                    : ( flags & wxCONTROL_UNDETERMINED
+                                          ? IndicatorStatus_Undeterminated
+                                          : IndicatorStatus_Unchecked );
+
+    wxBitmap bmp = m_bmpIndicators[indType][indState][indStatus];
+    if ( !bmp.Ok() )
+    {
+        const char **xpm = xpmIndicators[indType][indState][indStatus];
+        if ( xpm )
+        {
+            // create and cache it
+            bmp = wxBitmap(xpm);
+            m_bmpIndicators[indType][indState][indStatus] = bmp;
+        }
+    }
 
 
-    const char **xpm = bmpIndicators[indType][indState][indStatus];
-    return xpm ? wxBitmap(xpm) : wxNullBitmap;
+    return bmp;
 }
 
 void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
@@ -1988,7 +2419,7 @@ void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
         rectLabel.SetRight(rect.GetRight());
     }
 
         rectLabel.SetRight(rect.GetRight());
     }
 
-    dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
+    dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
 
     DoDrawLabel(
                 dc, label, rectLabel,
 
     DoDrawLabel(
                 dc, label, rectLabel,
@@ -2009,8 +2440,14 @@ void wxWin32Renderer::DrawRadioButton(wxDC& dc,
                                       wxAlignment align,
                                       int indexAccel)
 {
                                       wxAlignment align,
                                       int indexAccel)
 {
+    wxBitmap bmp;
+    if ( bitmap.Ok() )
+        bmp = bitmap;
+    else
+        bmp = GetRadioBitmap(flags);
+
     DrawCheckOrRadioButton(dc, label,
     DrawCheckOrRadioButton(dc, label,
-                           bitmap.Ok() ? bitmap : GetRadioBitmap(flags),
+                           bmp,
                            rect, flags, align, indexAccel,
                            FOCUS_RECT_OFFSET_Y); // default focus rect offset
 }
                            rect, flags, align, indexAccel,
                            FOCUS_RECT_OFFSET_Y); // default focus rect offset
 }
@@ -2023,12 +2460,52 @@ void wxWin32Renderer::DrawCheckButton(wxDC& dc,
                                       wxAlignment align,
                                       int indexAccel)
 {
                                       wxAlignment align,
                                       int indexAccel)
 {
+    wxBitmap bmp;
+    if ( bitmap.Ok() )
+        bmp = bitmap;
+    else
+        bmp = GetCheckBitmap(flags);
+
     DrawCheckOrRadioButton(dc, label,
     DrawCheckOrRadioButton(dc, label,
-                           bitmap.Ok() ? bitmap : GetCheckBitmap(flags),
+                           bmp,
                            rect, flags, align, indexAccel,
                            0); // no focus rect offset for checkboxes
 }
 
                            rect, flags, align, indexAccel,
                            0); // no focus rect offset for checkboxes
 }
 
+void wxWin32Renderer::DrawToolBarButton(wxDC& dc,
+                                        const wxString& label,
+                                        const wxBitmap& bitmap,
+                                        const wxRect& rectOrig,
+                                        int flags,
+                                        long style)
+{
+    if (style == wxTOOL_STYLE_BUTTON)
+    {
+        wxRect rect = rectOrig;
+        rect.Deflate(BORDER_THICKNESS);
+
+        if ( flags & wxCONTROL_PRESSED )
+        {
+            DrawBorder(dc, wxBORDER_SUNKEN, rect, flags);
+        }
+        else if ( flags & wxCONTROL_CURRENT )
+        {
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags);
+        }
+
+        dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+    }
+    else if (style == wxTOOL_STYLE_SEPARATOR)
+    {
+        // 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);
+    }
+    // don't draw wxTOOL_STYLE_CONTROL
+}
+
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
@@ -2044,7 +2521,9 @@ void wxWin32Renderer::DrawTextLine(wxDC& dc,
     StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
 }
 
     StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
 }
 
-void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
+void
+wxWin32Renderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
+                                  const wxRect& WXUNUSED(rect))
 {
     // we don't draw them
 }
 {
     // we don't draw them
 }
@@ -2061,13 +2540,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:
@@ -2075,153 +2564,228 @@ 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 = wxBitmap( wxImage( bitmap.ConvertToImage() ).Rotate90(dir==wxLEFT) );
+        DrawButtonLabel(dcMem, label, bitmapRotated, rectLabel,
+                        flags, wxALIGN_CENTRE, indexAccel);
+        dcMem.SelectObject(wxNullBitmap);
+        bitmapMem = bitmapMem.GetSubBitmap(rectLabel);
+        bitmapMem = wxBitmap(wxImage(bitmapMem.ConvertToImage()).Rotate90(dir==wxRIGHT));
+        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
 }
 
 // ----------------------------------------------------------------------------
 // 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
+                                           int lenThumb,
+                                           wxOrientation orient,
+                                           long style) const
 {
 {
-    static const wxCoord SLIDER_MARGIN = 6;
+    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;
@@ -2229,19 +2793,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 )
-    {
+    /*    show shaft geometry
+
+             shaft
+        +-------------+
+        |             |
+        |     XXX     |  <-- x1
+        |     XXX     |
+        |     XXX     |
+        |     XXX     |
+        |     XXX     |  <-- x2
+        |             |
+        +-------------+
+
+              ^ ^
+              | |
+             y1 y2
+    */
+
+    if (flags & wxCONTROL_FOCUSED) {
         DrawFocusRect(dc, rectOrig);
     }
 
         DrawFocusRect(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);
 }
@@ -2249,26 +2831,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)
+                                      int flags,
+                                      long style)
 {
 {
-    /*
-       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
+    /*    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.
@@ -2276,53 +2863,84 @@ 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);
 
         rectInt.Deflate(2);
 
+#if !defined(__WXMGL__)
         static const char *stipple_xpm[] = {
             /* columns rows colors chars-per-pixel */
             "2 2 2 1",
         static const char *stipple_xpm[] = {
             /* columns rows colors chars-per-pixel */
             "2 2 2 1",
@@ -2332,89 +2950,115 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
             "w ",
             " w",
         };
             "w ",
             " w",
         };
-        dc.SetBrush(wxBrush(stipple_xpm));
-
-        dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
-        dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));
-        dc.SetPen(*wxTRANSPARENT_PEN);
-        dc.DrawRectangle(rectInt);
+#else
+        // VS: MGL can only do 8x8 stipple brushes
+        static const char *stipple_xpm[] = {
+            /* columns rows colors chars-per-pixel */
+            "8 8 2 1",
+            "  c None",
+            "w c white",
+            /* pixels */
+            "w w w w ",
+            " w w w w",
+            "w w w w ",
+            " w w w w",
+            "w w w w ",
+            " w w w w",
+            "w w w w ",
+            " w w w w",
+        };
+#endif
+        dc.SetBrush(wxBrush(stipple_xpm));
+
+        dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
+        dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));
+        dc.SetPen(*wxTRANSPARENT_PEN);
+        dc.DrawRectangle(rectInt);
     }
 }
 
 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();
-
-        len = rect.width;
-
-        widthThumb = sizeThumb.x;
-    }
-    else // vertical
-    {
-        x1 = rect.GetTop();
-        x2 = rect.GetBottom();
-
-        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;
+    /*    show ticks geometry
+
+        left        right
+        ticks shaft ticks
+        ----   XX   ----  <-- x1
+        ----   XX   ----
+        ----   XX   ----
+        ----   XX   ----  <-- x2
+
+        ^  ^        ^  ^
+        |  |        |  |
+        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);
+    }
 }
 
 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
 
-#if wxUSE_MENUS
-
 // wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
 class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
 {
 // wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
 class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
 {
@@ -2439,12 +3083,10 @@ private:
     // the height of a normal (not separator) item
     wxCoord m_heightItem;
 
     // the height of a normal (not separator) item
     wxCoord m_heightItem;
 
-    friend wxMenuGeometryInfo *wxWin32Renderer::
-                GetMenuGeometry(wxWindow *, const wxMenu&) const;
+    friend wxMenuGeometryInfo *
+        wxWin32Renderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
 };
 
 };
 
-#endif // wxUSE_MENUS
-
 // FIXME: all constants are hardcoded but shouldn't be
 static const wxCoord MENU_LEFT_MARGIN = 9;
 static const wxCoord MENU_RIGHT_MARGIN = 18;
 // FIXME: all constants are hardcoded but shouldn't be
 static const wxCoord MENU_LEFT_MARGIN = 9;
 static const wxCoord MENU_RIGHT_MARGIN = 18;
@@ -2464,10 +3106,6 @@ static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
 // the size of the standard checkmark bitmap
 static const wxCoord MENU_CHECK_SIZE = 9;
 
 // the size of the standard checkmark bitmap
 static const wxCoord MENU_CHECK_SIZE = 9;
 
-// we can't implement these methods without wxMenuGeometryInfo implementation
-// which we don't have if !wxUSE_MENUS
-#if wxUSE_MENUS
-
 void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
                                       const wxRect& rectOrig,
                                       const wxString& label,
 void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
                                       const wxRect& rectOrig,
                                       const wxString& label,
@@ -2559,10 +3197,10 @@ void wxWin32Renderer::DrawMenuItem(wxDC& dc,
 
         wxArrowStyle arrowStyle;
         if ( flags & wxCONTROL_DISABLED )
 
         wxArrowStyle arrowStyle;
         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;
 
@@ -2593,7 +3231,7 @@ wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
 {
     // prepare the dc: for now we draw all the items with the system font
     wxClientDC dc(win);
 {
     // prepare the dc: for now we draw all the items with the system font
     wxClientDC dc(win);
-    dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
     // the height of a normal item
     wxCoord heightText = dc.GetCharHeight();
 
     // the height of a normal item
     wxCoord heightText = dc.GetCharHeight();
@@ -2611,7 +3249,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() )
     {
@@ -2679,54 +3317,104 @@ wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
     return gi;
 }
 
     return gi;
 }
 
-#else // !wxUSE_MENUS
+// ----------------------------------------------------------------------------
+// status bar
+// ----------------------------------------------------------------------------
 
 
-/*
-void wxWin32Renderer::DrawMenuBarItem(wxDC& WXUNUSED(dc),
-                                      const wxRect& WXUNUSED(rectOrig),
-                                      const wxString& WXUNUSED(label),
-                                      int WXUNUSED(flags),
-                                      int WXUNUSED(indexAccel))
-{
-}
+static const wxCoord STATBAR_BORDER_X = 2;
+static const wxCoord STATBAR_BORDER_Y = 2;
 
 
-void wxWin32Renderer::DrawMenuItem(wxDC& WXUNUSED(dc),
-                                   wxCoord WXUNUSED(y),
-                                   const wxMenuGeometryInfo& WXUNUSED(gi),
-                                   const wxString& WXUNUSED(label),
-                                   const wxString& WXUNUSED(accel),
-                                   const wxBitmap& WXUNUSED(bitmap),
-                                   int WXUNUSED(flags),
-                                   int WXUNUSED(indexAccel))
+wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
 {
 {
-}
+    if ( borderBetweenFields )
+        *borderBetweenFields = 2;
 
 
-void wxWin32Renderer::DrawMenuSeparator(wxDC& WXUNUSED(dc),
-                                        wxCoord WXUNUSED(y),
-                                        const wxMenuGeometryInfo& WXUNUSED(gi))
-{
+    return wxSize(STATBAR_BORDER_X, STATBAR_BORDER_Y);
 }
 
 }
 
-wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& size) const
+void wxWin32Renderer::DrawStatusField(wxDC& dc,
+                                      const wxRect& rect,
+                                      const wxString& label,
+                                      int flags, int style /*=0*/)
 {
 {
-    return size;
-}
+    wxRect rectIn;
 
 
-wxMenuGeometryInfo *
-wxWin32Renderer::GetMenuGeometry(wxWindow *WXUNUSED(win),
-                                 const wxMenu& WXUNUSED(menu)) const
-{
-    return NULL;
-}
-*/
+    if ( flags & wxCONTROL_ISDEFAULT )
+    {
+        // 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
+        // the status bar corner
+        //
+        // each band consists of 4 stripes: m_penHighlight, double
+        // m_penDarkGrey and transparent one
+        wxCoord x2 = rect.GetRight(),
+                y2 = rect.GetBottom();
+
+        // draw the upper left part of the rect normally
+        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;
+        wxCoord ofs = WIDTH_STATUSBAR_GRIP_BAND - 1;
+        for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
+        {
+            dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
+            dc.DrawLine(x2 - ofs, y2 - 1, x2, y2 - ofs - 1);
+        }
+
+        // draw the white stripes
+        dc.SetPen(m_penHighlight);
+        ofs = WIDTH_STATUSBAR_GRIP_BAND + 1;
+        for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
+        {
+            dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
+        }
+
+        // draw the remaining rect boundaries
+        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;
+    }
+    else // normal pane
+    {
+        if (style == wxSB_RAISED)
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
+        else if (style != wxSB_FLAT)
+            DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
+    }
 
 
-#endif // wxUSE_MENUS/!wxUSE_MENUS
+    rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
+
+    wxDCClipper clipper(dc, rectIn);
+    DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
+}
 
 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
 
 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------
 
 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
+                                      wxBitmap * WXUNUSED(bmpFocus),
                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {
                                       wxBitmap *bmpPressed,
                                       wxBitmap *bmpDisabled)
 {
@@ -2766,7 +3454,8 @@ void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
 
 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
                                        const wxColour& col,
 
 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
                                        const wxColour& col,
-                                       const wxRect& rect)
+                                       const wxRect& rect,
+                                       wxWindow * WXUNUSED(window))
 {
     wxBrush brush(col, wxSOLID);
     dc.SetBrush(brush);
 {
     wxBrush brush(col, wxSOLID);
     dc.SetBrush(brush);
@@ -2777,11 +3466,12 @@ void wxWin32Renderer::DoDrawBackground(wxDC& dc,
 void wxWin32Renderer::DrawBackground(wxDC& dc,
                                      const wxColour& col,
                                      const wxRect& rect,
 void wxWin32Renderer::DrawBackground(wxDC& dc,
                                      const wxColour& col,
                                      const wxRect& rect,
-                                     int flags)
+                                     int WXUNUSED(flags),
+                                     wxWindow *window)
 {
     // just fill it with the given or default bg colour
     wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
 {
     // just fill it with the given or default bg colour
     wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
-    DoDrawBackground(dc, colBg, rect);
+    DoDrawBackground(dc, colBg, rect, window );
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -2838,7 +3528,7 @@ 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,
 }
 
 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
@@ -2853,9 +3543,9 @@ void wxWin32Renderer::DrawArrowButton(wxDC& dc,
 }
 
 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
 }
 
 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;
@@ -2864,7 +3554,7 @@ 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)
 {
                                          const wxRect& rectBar,
                                          int flags)
 {
@@ -2910,6 +3600,665 @@ int wxWin32Renderer::PixelToScrollbar(const wxScrollBar *scrollbar,
     return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
 }
 
     return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
 }
 
+// ----------------------------------------------------------------------------
+// top level windows
+// ----------------------------------------------------------------------------
+
+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);
+        }
+    }
+}
+
+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;
+
+    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;
+}
+
+wxSize wxWin32Renderer::GetFrameIconSize() const
+{
+    return wxSize(16, 16);
+}
+
+
+// ----------------------------------------------------------------------------
+// standard icons
+// ----------------------------------------------------------------------------
+
+/* Copyright (c) Julian Smart */
+static 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             ",
+"                                ",
+"                                "
+};
+
+/* Copyright (c) Julian Smart */
+static 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 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.::           ",
+"                 ..::           ",
+"                  .::           ",
+"                   ::           ",
+"                    :           ",
+"                                ",
+"                                "
+};
+
+/* Copyright (c) Julian Smart */
+static 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... ",
+" .............................. ",
+" .............................. ",
+"                                ",
+"                                ",
+"                                "
+};
+
+
+wxBitmap wxWin32ArtProvider::CreateBitmap(const wxArtID& id,
+                                          const wxArtClient& WXUNUSED(client),
+                                          const wxSize& WXUNUSED(size))
+{
+    if ( id == wxART_INFORMATION )
+        return wxBitmap(info_xpm);
+    if ( id == wxART_ERROR )
+        return wxBitmap(error_xpm);
+    if ( id == wxART_WARNING )
+        return wxBitmap(warning_xpm);
+    if ( id == wxART_QUESTION )
+        return wxBitmap(question_xpm);
+    return wxNullBitmap;
+}
+
+
 // ----------------------------------------------------------------------------
 // text control geometry
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // text control geometry
 // ----------------------------------------------------------------------------
@@ -2919,8 +4268,9 @@ static inline int GetTextBorderWidth()
     return 1;
 }
 
     return 1;
 }
 
-wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
-                                         const wxRect& rect)
+wxRect
+wxWin32Renderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
+                                  const wxRect& rect) const
 {
     wxRect rectTotal = rect;
 
 {
     wxRect rectTotal = rect;
 
@@ -2933,9 +4283,10 @@ wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
     return rectTotal;
 }
 
     return rectTotal;
 }
 
-wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
-                                          const wxRect& rect,
-                                          wxCoord *extraSpaceBeyond)
+wxRect
+wxWin32Renderer::GetTextClientArea(const wxTextCtrl * WXUNUSED(text),
+                                   const wxRect& rect,
+                                   wxCoord *extraSpaceBeyond) const
 {
     wxRect rectText = rect;
 
 {
     wxRect rectText = rect;
 
@@ -2973,22 +4324,38 @@ void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
     }
 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
 
     }
 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
 
+#if wxUSE_BMPBUTTON
+    if ( wxDynamicCast(window, wxBitmapButton) )
+    {
+        // do nothing
+    } else
+#endif // wxUSE_BMPBUTTON
 #if wxUSE_BUTTON
     if ( wxDynamicCast(window, wxButton) )
     {
 #if wxUSE_BUTTON
     if ( wxDynamicCast(window, wxButton) )
     {
-        // TODO
-        size->x += 3*window->GetCharWidth();
-#if 0 // do allow creating small buttons if wanted
-        wxSize sizeDef = wxButton::GetDefaultSize();
-        if ( size->x < sizeDef.x )
-            size->x = sizeDef.x;
-#endif // 0
-
-        wxCoord heightBtn = (11*(window->GetCharHeight() + 8))/10;
-        if ( size->y < heightBtn - 8 )
-            size->y = heightBtn;
-        else
-            size->y += 9;
+        if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
+        {
+            // TODO: don't harcode all this
+            size->x += 3*window->GetCharWidth();
+
+            wxCoord heightBtn = (11*(window->GetCharHeight() + 8))/10;
+            if ( size->y < heightBtn - 8 )
+                size->y = heightBtn;
+            else
+                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;
@@ -3014,17 +4381,31 @@ wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
     m_renderer = renderer;
 }
 
     m_renderer = renderer;
 }
 
-bool wxWin32InputHandler::HandleKey(wxControl *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(wxControl *control,
+bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
                                       const wxMouseEvent& event)
 {
                                       const wxMouseEvent& event)
 {
-    return FALSE;
+    // clicking on the control gives it focus
+    if ( event.ButtonDown() )
+    {
+        wxWindow *win = control->GetInputWindow();
+
+        if (( wxWindow::FindFocus() != control->GetInputWindow() ) &&
+            ( win->AcceptsFocus() ) )
+        {
+            win->SetFocus();
+
+            return true;
+        }
+    }
+
+    return false;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -3036,7 +4417,7 @@ wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
                              wxInputHandler *handler)
         : wxStdScrollBarInputHandler(renderer, handler)
 {
                              wxInputHandler *handler)
         : wxStdScrollBarInputHandler(renderer, handler)
 {
-    m_scrollPaused = FALSE;
+    m_scrollPaused = false;
     m_interval = 0;
 }
 
     m_interval = 0;
 }
 
@@ -3045,7 +4426,7 @@ 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 )
     {
         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
     if ( action == wxACTION_SCROLL_PAGE_DOWN )
     {
         stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
@@ -3063,13 +4444,13 @@ bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 
         scrollbar->Refresh();
 
 
         scrollbar->Refresh();
 
-        return FALSE;
+        return false;
     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
 }
 
     }
 
     return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
 }
 
-bool wxWin32ScrollBarInputHandler::HandleMouse(wxControl *control,
+bool wxWin32ScrollBarInputHandler::HandleMouse(wxInputConsumer *control,
                                                const wxMouseEvent& event)
 {
     // remember the current state
                                                const wxMouseEvent& event)
 {
     // remember the current state
@@ -3089,22 +4470,22 @@ bool wxWin32ScrollBarInputHandler::HandleMouse(wxControl *control,
     return rc;
 }
 
     return rc;
 }
 
-bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
+bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
                                                    const wxMouseEvent& event)
 {
     // we don't highlight scrollbar elements, so there is no need to process
     // 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 )
                                                    const wxMouseEvent& event)
 {
     // we don't highlight scrollbar elements, so there is no need to process
     // 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, wxScrollBar);
+    wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
     wxHitTest ht;
     if ( m_scrollPaused )
     {
     wxHitTest ht;
     if ( m_scrollPaused )
     {
@@ -3113,20 +4494,20 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *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());
         if ( ht == m_htLast )
         {
             // yes it did, resume scrolling
         }
 
         ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
         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
             {
@@ -3134,7 +4515,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *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
@@ -3142,6 +4523,8 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
         // if we're scrolling the scrollbar because the arrow or the shaft was
         // pressed, check that the mouse stays on the same scrollbar element
 
         // if we're scrolling the scrollbar because the arrow or the shaft was
         // pressed, check that the mouse stays on the same scrollbar element
 
+#if 0
+        // Always let thumb jump back if we leave the scrollbar
         if ( event.Moving() )
         {
             ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
         if ( event.Moving() )
         {
             ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
@@ -3150,6 +4533,21 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
         {
             ht = wxHT_NOWHERE;
         }
         {
             ht = wxHT_NOWHERE;
         }
+#else
+        // Jump back only if we get far away from it
+        wxPoint pos = event.GetPosition();
+        if (scrollbar->HasFlag( wxVERTICAL ))
+        {
+            if (pos.x > -40 && pos.x < scrollbar->GetSize().x+40)
+               pos.x = 5;
+        }
+        else
+        {
+            if (pos.y > -40 && pos.y < scrollbar->GetSize().y+40)
+               pos.y = 5;
+        }
+        ht = m_renderer->HitTestScrollbar(scrollbar, pos );
+#endif
 
         // if we're dragging the thumb and the mouse stays in the scrollbar, it
         // is still ok - we only want to catch the case when the mouse leaves
 
         // if we're dragging the thumb and the mouse stays in the scrollbar, it
         // is still ok - we only want to catch the case when the mouse leaves
@@ -3169,10 +4567,10 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *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
             {
@@ -3185,7 +4583,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 
                 HandleThumbMove(scrollbar, m_eventStartDrag);
             }
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
@@ -3196,7 +4594,7 @@ bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
 // wxWin32CheckboxInputHandler
 // ----------------------------------------------------------------------------
 
 // wxWin32CheckboxInputHandler
 // ----------------------------------------------------------------------------
 
-bool wxWin32CheckboxInputHandler::HandleKey(wxControl *control,
+bool wxWin32CheckboxInputHandler::HandleKey(wxInputConsumer *control,
                                             const wxKeyEvent& event,
                                             bool pressed)
 {
                                             const wxKeyEvent& event,
                                             bool pressed)
 {
@@ -3222,22 +4620,22 @@ bool wxWin32CheckboxInputHandler::HandleKey(wxControl *control,
                 break;
         }
 
                 break;
         }
 
-        if ( !!action )
+        if ( !action.IsEmpty() )
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 // ----------------------------------------------------------------------------
 // wxWin32TextCtrlInputHandler
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxWin32TextCtrlInputHandler
 // ----------------------------------------------------------------------------
 
-bool wxWin32TextCtrlInputHandler::HandleKey(wxControl *control,
+bool wxWin32TextCtrlInputHandler::HandleKey(wxInputConsumer *control,
                                             const wxKeyEvent& event,
                                             bool pressed)
 {
                                             const wxKeyEvent& event,
                                             bool pressed)
 {
@@ -3264,10 +4662,304 @@ bool wxWin32TextCtrlInputHandler::HandleKey(wxControl *control,
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 
-            return TRUE;
+            return true;
         }
     }
 
     return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
 }
 
         }
     }
 
     return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
 }
 
+// ----------------------------------------------------------------------------
+// wxWin32StatusBarInputHandler
+// ----------------------------------------------------------------------------
+
+wxWin32StatusBarInputHandler::
+wxWin32StatusBarInputHandler(wxInputHandler *handler)
+    : wxStdInputHandler(handler)
+{
+    m_isOnGrip = false;
+}
+
+bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
+                                            const wxPoint& pt) const
+{
+    if ( statbar->HasFlag(wxST_SIZEGRIP) &&
+         statbar->GetParent()->HasFlag(wxRESIZE_BORDER) )
+    {
+        wxTopLevelWindow *
+            parentTLW = wxDynamicCast(statbar->GetParent(), wxTopLevelWindow);
+
+        wxCHECK_MSG( parentTLW, false,
+                     _T("the status bar should be a child of a TLW") );
+
+        // a maximized window can't be resized anyhow
+        if ( !parentTLW->IsMaximized() )
+        {
+            // VZ: I think that the standard Windows behaviour is to only
+            //     show the resizing cursor when the mouse is on top of the
+            //     grip itself but apparently different Windows versions behave
+            //     differently (?) and it seems a better UI to allow resizing
+            //     the status bar even when the mouse is above the grip
+            wxSize sizeSbar = statbar->GetSize();
+
+            int diff = sizeSbar.x - pt.x;
+            return diff >= 0 && diff < (wxCoord)STATUSBAR_GRIP_SIZE;
+        }
+    }
+
+    return false;
+}
+
+bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
+                                               const wxMouseEvent& event)
+{
+    if ( event.Button(1) )
+    {
+        if ( event.ButtonDown(1) )
+        {
+            wxWindow *statbar = consumer->GetInputWindow();
+
+            if ( IsOnGrip(statbar, event.GetPosition()) )
+            {
+                wxTopLevelWindow *tlw = wxDynamicCast(statbar->GetParent(),
+                                                      wxTopLevelWindow);
+                if ( tlw )
+                {
+                    tlw->PerformAction(wxACTION_TOPLEVEL_RESIZE,
+                                       wxHT_TOPLEVEL_BORDER_SE);
+
+                    statbar->SetCursor(m_cursorOld);
+
+                    return true;
+                }
+            }
+        }
+    }
+
+    return wxStdInputHandler::HandleMouse(consumer, event);
+}
+
+bool wxWin32StatusBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
+                                                   const wxMouseEvent& event)
+{
+    wxWindow *statbar = consumer->GetInputWindow();
+
+    bool isOnGrip = IsOnGrip(statbar, event.GetPosition());
+    if ( isOnGrip != m_isOnGrip )
+    {
+        m_isOnGrip = isOnGrip;
+        if ( isOnGrip )
+        {
+            m_cursorOld = statbar->GetCursor();
+            statbar->SetCursor(wxCURSOR_SIZENWSE);
+        }
+        else
+        {
+            statbar->SetCursor(m_cursorOld);
+        }
+    }
+
+    return wxStdInputHandler::HandleMouseMove(consumer, event);
+}
+
+// ----------------------------------------------------------------------------
+// wxWin32FrameInputHandler
+// ----------------------------------------------------------------------------
+
+class wxWin32SystemMenuEvtHandler : public wxEvtHandler
+{
+public:
+    wxWin32SystemMenuEvtHandler(wxWin32FrameInputHandler *handler);
+
+    void Attach(wxInputConsumer *consumer);
+    void Detach();
+
+private:
+    DECLARE_EVENT_TABLE()
+    void OnSystemMenu(wxCommandEvent &event);
+    void OnCloseFrame(wxCommandEvent &event);
+    void OnClose(wxCloseEvent &event);
+
+    wxWin32FrameInputHandler *m_inputHnd;
+    wxTopLevelWindow         *m_wnd;
+#if wxUSE_ACCEL
+    wxAcceleratorTable        m_oldAccelTable;
+#endif
+};
+
+wxWin32SystemMenuEvtHandler::wxWin32SystemMenuEvtHandler(
+                                wxWin32FrameInputHandler *handler)
+{
+    m_inputHnd = handler;
+    m_wnd = NULL;
+}
+
+void wxWin32SystemMenuEvtHandler::Attach(wxInputConsumer *consumer)
+{
+    wxASSERT_MSG( m_wnd == NULL, _T("can't attach the handler twice!") );
+
+    m_wnd = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
+    m_wnd->PushEventHandler(this);
+
+#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);
+#endif
+}
+
+void wxWin32SystemMenuEvtHandler::Detach()
+{
+    if ( m_wnd )
+    {
+#if wxUSE_ACCEL
+        m_wnd->SetAcceleratorTable(m_oldAccelTable);
+#endif
+        m_wnd->RemoveEventHandler(this);
+        m_wnd = NULL;
+    }
+}
+
+BEGIN_EVENT_TABLE(wxWin32SystemMenuEvtHandler, wxEvtHandler)
+    EVT_MENU(wxID_SYSTEM_MENU, wxWin32SystemMenuEvtHandler::OnSystemMenu)
+    EVT_MENU(wxID_CLOSE_FRAME, wxWin32SystemMenuEvtHandler::OnCloseFrame)
+    EVT_CLOSE(wxWin32SystemMenuEvtHandler::OnClose)
+END_EVENT_TABLE()
+
+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);
+#endif
+
+    m_inputHnd->PopupSystemMenu(m_wnd, pt);
+
+#if wxUSE_ACCEL
+    m_wnd->SetAcceleratorTable(table);
+#endif
+}
+
+void wxWin32SystemMenuEvtHandler::OnCloseFrame(wxCommandEvent &WXUNUSED(event))
+{
+    m_wnd->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                         wxTOPLEVEL_BUTTON_CLOSE);
+}
+
+void wxWin32SystemMenuEvtHandler::OnClose(wxCloseEvent &event)
+{
+    m_wnd = NULL;
+    event.Skip();
+}
+
+
+wxWin32FrameInputHandler::wxWin32FrameInputHandler(wxInputHandler *handler)
+        : wxStdFrameInputHandler(handler)
+{
+    m_menuHandler = new wxWin32SystemMenuEvtHandler(this);
+}
+
+wxWin32FrameInputHandler::~wxWin32FrameInputHandler()
+{
+    if ( m_menuHandler )
+    {
+        m_menuHandler->Detach();
+        delete m_menuHandler;
+    }
+}
+
+bool wxWin32FrameInputHandler::HandleMouse(wxInputConsumer *consumer,
+                                           const wxMouseEvent& event)
+{
+    if ( event.LeftDClick() || event.LeftDown() || event.RightDown() )
+    {
+        wxTopLevelWindow *tlw =
+            wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
+
+        long hit = tlw->HitTest(event.GetPosition());
+
+        if ( event.LeftDClick() && hit == wxHT_TOPLEVEL_TITLEBAR )
+        {
+            tlw->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
+                               tlw->IsMaximized() ? wxTOPLEVEL_BUTTON_RESTORE
+                                                  : wxTOPLEVEL_BUTTON_MAXIMIZE);
+            return true;
+        }
+        else if ( tlw->GetWindowStyle() & wxSYSTEM_MENU )
+        {
+            if ( (event.LeftDown() && hit == wxHT_TOPLEVEL_ICON) ||
+                 (event.RightDown() &&
+                      (hit == wxHT_TOPLEVEL_TITLEBAR ||
+                       hit == wxHT_TOPLEVEL_ICON)) )
+            {
+                PopupSystemMenu(tlw, event.GetPosition());
+                return true;
+            }
+        }
+    }
+
+    return wxStdFrameInputHandler::HandleMouse(consumer, event);
+}
+
+void wxWin32FrameInputHandler::PopupSystemMenu(wxTopLevelWindow *window,
+                                               const wxPoint& pos) const
+{
+    wxMenu *menu = new wxMenu;
+
+    if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
+        menu->Append(wxID_RESTORE_FRAME , _("&Restore"));
+    menu->Append(wxID_MOVE_FRAME , _("&Move"));
+    if ( window->GetWindowStyle() & wxRESIZE_BORDER )
+        menu->Append(wxID_RESIZE_FRAME , _("&Size"));
+    if ( wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME) )
+        menu->Append(wxID_ICONIZE_FRAME , _("Mi&nimize"));
+    if ( window->GetWindowStyle() & wxMAXIMIZE_BOX )
+        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() )
+        {
+            menu->Enable(wxID_MAXIMIZE_FRAME, false);
+            menu->Enable(wxID_MOVE_FRAME, false);
+            if ( window->GetWindowStyle() & wxRESIZE_BORDER )
+                menu->Enable(wxID_RESIZE_FRAME, false);
+        }
+        else
+            menu->Enable(wxID_RESTORE_FRAME, false);
+    }
+
+    window->PopupMenu(menu, pos);
+    delete menu;
+}
+
+bool wxWin32FrameInputHandler::HandleActivation(wxInputConsumer *consumer,
+                                                bool activated)
+{
+    if ( consumer->GetInputWindow()->GetWindowStyle() & wxSYSTEM_MENU )
+    {
+        // always detach if active frame changed:
+        m_menuHandler->Detach();
+
+        if ( activated )
+        {
+            m_menuHandler->Attach(consumer);
+        }
+    }
+
+    return wxStdFrameInputHandler::HandleActivation(consumer, activated);
+}