Add support for generating classes for menus

[wxWidgets.git] / src / univ / themes / gtk.cpp

diff --git a/src/univ/themes/gtk.cpp b/src/univ/themes/gtk.cpp
index ec6405a78f3f00456d1ca8f2d20c3bdb22adb7b6..e385744196aba7507769d7e6239830fe7a63cb58 100644 (file)
--- a/src/univ/themes/gtk.cpp
+++ b/src/univ/themes/gtk.cpp
@@ -1,12 +1,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        univ/themes/gtk.cpp
+// Name:        src/univ/themes/gtk.cpp

 // Purpose:     wxUniversal theme implementing GTK-like LNF
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
 // Purpose:     wxUniversal theme implementing GTK-like LNF
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================


@@ -30,6 +30,8 @@
     #include "wx/dcmemory.h"
     #include "wx/window.h"
 
     #include "wx/dcmemory.h"
     #include "wx/window.h"
 

+    #include "wx/menu.h"
+

     #include "wx/bmpbuttn.h"
     #include "wx/button.h"
     #include "wx/checkbox.h"
     #include "wx/bmpbuttn.h"
     #include "wx/button.h"
     #include "wx/checkbox.h"


@@ -39,16 +41,28 @@
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"
     #include "wx/scrolbar.h"
     #include "wx/slider.h"
     #include "wx/textctrl.h"

+    #include "wx/toolbar.h"
+    #include "wx/statusbr.h"
+
+    #include "wx/settings.h"

 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
 #endif // WX_PRECOMP
 
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"

+#include "wx/toplevel.h"
+#include "wx/artprov.h"
+#include "wx/image.h"
+#ifdef wxUSE_TOGGLEBTN
+#include "wx/tglbtn.h"
+#endif // wxUSE_TOGGLEBTN

 
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
 #include "wx/univ/theme.h"
 
 
 #include "wx/univ/renderer.h"
 #include "wx/univ/inphand.h"
 #include "wx/univ/colschem.h"
 #include "wx/univ/theme.h"
 

+class WXDLLEXPORT wxGTKMenuGeometryInfo;
+

 // ----------------------------------------------------------------------------
 // constants (to be removed, for testing only)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants (to be removed, for testing only)
 // ----------------------------------------------------------------------------


@@ -68,7 +82,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,


@@ -151,6 +166,16 @@ public:
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
 
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
 

+#if wxUSE_TOOLBAR
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags = 0,
+                                   long style = 0,
+                                   int tbarStyle = 0);
+#endif // wxUSE_TOOLBAR
+

     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,


@@ -166,26 +191,32 @@ public:
                          int flags = 0,
                          int indexAccel = -1);
 
                          int flags = 0,
                          int indexAccel = -1);
 

+#if wxUSE_SLIDER

     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,
     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,

+                                 int lenThumb,

                                  wxOrientation orient,
                                  int flags = 0,
                                  wxOrientation orient,
                                  int flags = 0,

+                                 long style = 0,

                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,
                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,

-                                 int flags = 0);
-    virtual void DrawSliderTicks(wxDC& dc,
-                                 const wxRect& rect,
-                                 const wxSize& sizeThumb,
-                                 wxOrientation orient,
-                                 int start,
-                                 int end,
-                                 int step,
-                                 int flags)
+                                 int flags = 0,
+                                 long style = 0);
+    virtual void DrawSliderTicks(wxDC& WXUNUSED(dc),
+                                 const wxRect& WXUNUSED(rect),
+                                 int WXUNUSED(lenThumb),
+                                 wxOrientation WXUNUSED(orient),
+                                 int WXUNUSED(start),
+                                 int WXUNUSED(end),
+                                 int WXUNUSED(step) = 1,
+                                 int WXUNUSED(flags) = 0,
+                                 long WXUNUSED(style) = 0)

     {
         // we don't have the ticks in GTK version
     }
     {
         // we don't have the ticks in GTK version
     }

+#endif // wxUSE_SLIDER

 
 #if wxUSE_MENUS
     virtual void DrawMenuBarItem(wxDC& dc,
 
 #if wxUSE_MENUS
     virtual void DrawMenuBarItem(wxDC& dc,


@@ -204,7 +235,48 @@ public:
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);
     virtual void DrawMenuSeparator(wxDC& dc,
                                    wxCoord y,
                                    const wxMenuGeometryInfo& geomInfo);

-#endif
+#endif // wxUSE_MENUS
+
+#if wxUSE_STATUSBAR
+    virtual void DrawStatusField(wxDC& dc,
+                                 const wxRect& rect,
+                                 const wxString& label,
+                                 int flags = 0, int style = 0);
+#endif // wxUSE_STATUSBAR
+
+    virtual void DrawFrameTitleBar(wxDC& dc,
+                                   const wxRect& rect,
+                                   const wxString& title,
+                                   const wxIcon& icon,
+                                   int flags,
+                                   int specialButton = 0,
+                                   int specialButtonFlag = 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);
+
+    // titlebars
+    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,
                                  wxBitmap *bmpFocus,
                                  wxBitmap *bmpPressed,
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
                                  wxBitmap *bmpPressed,


@@ -217,6 +289,7 @@ public:
     // geometry and hit testing
     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }
     // geometry and hit testing
     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }

+#if wxUSE_SCROLLBAR

     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
                                     wxScrollBar::Element elem,
                                     int thumbPos = -1) const;
     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
                                     wxScrollBar::Element elem,
                                     int thumbPos = -1) const;


@@ -226,6 +299,8 @@ public:
     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
                                      int thumbPos = -1);
     virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
                                      int thumbPos = -1);
     virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);

+#endif // wxUSE_SCROLLBAR
+

     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
         { return fontHeight + 2; }
     virtual wxSize GetCheckBitmapSize() const
     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
         { return fontHeight + 2; }
     virtual wxSize GetCheckBitmapSize() const


@@ -235,31 +310,50 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 2; }
 
     virtual wxCoord GetCheckItemMargin() const
         { return 2; }
 

+    virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
+        { if ( separator ) *separator = 5; return wxSize(16, 15); }
+    virtual wxSize GetToolBarMargin() const
+        { return wxSize(6, 6); }
+
+#if wxUSE_TEXTCTRL

     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;
+#endif // wxUSE_TEXTCTRL

 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
 
 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
 

+#if wxUSE_SLIDER

     virtual wxCoord GetSliderDim() const { return 15; }
     virtual wxCoord GetSliderTickLen() const { return 0; }
     virtual wxRect GetSliderShaftRect(const wxRect& rect,
     virtual wxCoord GetSliderDim() const { return 15; }
     virtual wxCoord GetSliderTickLen() const { return 0; }
     virtual wxRect GetSliderShaftRect(const wxRect& rect,

-                                      wxOrientation orient) const;
+                                      int lenThumb,
+                                      wxOrientation orient,
+                                      long style = 0) const;

     virtual wxSize GetSliderThumbSize(const wxRect& rect,
     virtual wxSize GetSliderThumbSize(const wxRect& rect,

+                                      int lenThumb,

                                       wxOrientation orient) const;
                                       wxOrientation orient) const;

+#endif // wxUSE_SLIDER
+

     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }

-#if wxUSE_MENUS

 
 

+#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
+#endif // wxUSE_MENUS
+
+#if wxUSE_STATUSBAR
+    virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
+#endif // wxUSE_STATUSBAR
+

     // helpers for "wxBitmap wxColourScheme::Get()"
     void DrawCheckBitmap(wxDC& dc, const wxRect& rect);
     void DrawUncheckBitmap(wxDC& dc, const wxRect& rect, bool isPressed);
     // helpers for "wxBitmap wxColourScheme::Get()"
     void DrawCheckBitmap(wxDC& dc, const wxRect& rect);
     void DrawUncheckBitmap(wxDC& dc, const wxRect& rect, bool isPressed);

+    void DrawUndeterminedBitmap(wxDC& dc, const wxRect& rect, bool isPressed);

 
 protected:
     // DrawBackground() helpers
 
 protected:
     // DrawBackground() helpers


@@ -278,7 +372,8 @@ protected:
     // draw the background with any colour, not only the default one(s)
     void DoDrawBackground(wxDC& dc,
                           const wxColour& col,
     // draw the background with any colour, not only the default one(s)
     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


@@ -325,6 +420,7 @@ protected:
     // rect is drawn with DrawAntiShadedRect() and not DrawShadedRect())
     void DrawAntiRaisedBorder(wxDC& dc, wxRect *rect);
 
     // rect is drawn with DrawAntiShadedRect() and not DrawShadedRect())
     void DrawAntiRaisedBorder(wxDC& dc, wxRect *rect);
 

+#if wxUSE_SCROLLBAR

     // returns the size of the arrow for the scrollbar (depends on
     // orientation)
     wxSize GetScrollbarArrowSize(const wxScrollBar *scrollbar) const
     // returns the size of the arrow for the scrollbar (depends on
     // orientation)
     wxSize GetScrollbarArrowSize(const wxScrollBar *scrollbar) const


@@ -342,9 +438,10 @@ protected:
 
         return size;
     }
 
         return size;
     }

+#endif // wxUSE_SCROLLBAR

 
     // get the line wrap indicator bitmap
 
     // get the line wrap indicator bitmap

-    wxBitmap GetLineWrapBitmap();
+    wxBitmap GetLineWrapBitmap() const;

 
     // DrawCheckBitmap and DrawRadioBitmap helpers
 
 
     // DrawCheckBitmap and DrawRadioBitmap helpers
 


@@ -372,6 +469,16 @@ protected:
                                   wxAlignment align,
                                   int indexAccel);
 
                                   wxAlignment align,
                                   int indexAccel);
 

+    // common part of DrawMenuItem() and DrawMenuBarItem()
+    void DoDrawMenuItem(wxDC& dc,
+                        const wxRect& rect,
+                        const wxString& label,
+                        int flags,
+                        int indexAccel,
+                        const wxString& accel = wxEmptyString,
+                        const wxBitmap& bitmap = wxNullBitmap,
+                        const wxGTKMenuGeometryInfo *geometryInfo = NULL);
+

     // initialize the combo bitmaps
     void InitComboBitmaps();
 
     // initialize the combo bitmaps
     void InitComboBitmaps();
 


@@ -389,9 +496,9 @@ private:
           m_penHighlight;
 
     // the checkbox bitmaps: first row is for the normal, second for the
           m_penHighlight;
 
     // the checkbox bitmaps: first row is for the normal, second for the

-    // pressed state and the columns are for checked and unchecked status
-    // respectively
-    wxBitmap m_bitmapsCheckbox[2][2];
+    // pressed state and the columns are for checked, unchecked and
+    // undeterminated respectively
+    wxBitmap m_bitmapsCheckbox[2][3];

 
     // the line wrap bitmap (drawn at the end of wrapped lines)
     wxBitmap m_bmpLineWrap;
 
     // the line wrap bitmap (drawn at the end of wrapped lines)
     wxBitmap m_bmpLineWrap;


@@ -419,17 +526,19 @@ class wxGTKInputHandler : public wxInputHandler
 public:
     wxGTKInputHandler(wxGTKRenderer *renderer);
 
 public:
     wxGTKInputHandler(wxGTKRenderer *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);
                              const wxMouseEvent& event);

-    virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
+    virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);

 
 protected:
     wxGTKRenderer *m_renderer;
 };
 
 
 protected:
     wxGTKRenderer *m_renderer;
 };
 

+#if wxUSE_SCROLLBAR
+

 class wxGTKScrollBarInputHandler : public wxStdScrollBarInputHandler
 {
 public:
 class wxGTKScrollBarInputHandler : public wxStdScrollBarInputHandler
 {
 public:


@@ -455,7 +564,7 @@ protected:
         wxStdScrollBarInputHandler::Press(scrollbar, doIt);
     }
 
         wxStdScrollBarInputHandler::Press(scrollbar, doIt);
     }
 

-    virtual bool IsAllowedButton(int WXUNUSED(button)) { return TRUE; }
+    virtual bool IsAllowedButton(int WXUNUSED(button)) { return true; }

 
     bool IsArrow() const
     {
 
     bool IsArrow() const
     {


@@ -464,28 +573,38 @@ protected:
     }
 };
 
     }
 };
 

+#endif // wxUSE_SCROLLBAR
+
+#if wxUSE_CHECKBOX
+

 class wxGTKCheckboxInputHandler : public wxStdCheckboxInputHandler
 {
 public:
     wxGTKCheckboxInputHandler(wxInputHandler *handler)
         : wxStdCheckboxInputHandler(handler) { }
 
 class wxGTKCheckboxInputHandler : public wxStdCheckboxInputHandler
 {
 public:
     wxGTKCheckboxInputHandler(wxInputHandler *handler)
         : wxStdCheckboxInputHandler(handler) { }
 

-    virtual bool HandleKey(wxControl *control,
+    virtual bool HandleKey(wxInputConsumer *control,

                            const wxKeyEvent& event,
                            bool pressed);
 };
 
                            const wxKeyEvent& event,
                            bool pressed);
 };
 

+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_TEXTCTRL
+

 class wxGTKTextCtrlInputHandler : public wxStdTextCtrlInputHandler
 {
 public:
     wxGTKTextCtrlInputHandler(wxInputHandler *handler)
         : wxStdTextCtrlInputHandler(handler) { }
 
 class wxGTKTextCtrlInputHandler : public wxStdTextCtrlInputHandler
 {
 public:
     wxGTKTextCtrlInputHandler(wxInputHandler *handler)
         : wxStdTextCtrlInputHandler(handler) { }
 

-    virtual bool HandleKey(wxControl *control,
+    virtual bool HandleKey(wxInputConsumer *control,

                            const wxKeyEvent& event,
                            bool pressed);
 };
 
                            const wxKeyEvent& event,
                            bool pressed);
 };
 

+#endif // wxUSE_TEXTCTRL
+

 // ----------------------------------------------------------------------------
 // wxGTKColourScheme: uses the standard GTK colours
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGTKColourScheme: uses the standard GTK colours
 // ----------------------------------------------------------------------------


@@ -497,11 +616,23 @@ public:
     virtual wxColour GetBackground(wxWindow *win) const;
 };
 
     virtual wxColour GetBackground(wxWindow *win) const;
 };
 

+// ----------------------------------------------------------------------------
+// wxGTKArtProvider
+// ----------------------------------------------------------------------------
+
+class wxGTKArtProvider : public wxArtProvider
+{
+protected:
+    virtual wxBitmap CreateBitmap(const wxArtID& id,
+                                  const wxArtClient& client,
+                                  const wxSize& size);
+};
+

 // ----------------------------------------------------------------------------
 // wxGTKTheme
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxGTKTheme
 // ----------------------------------------------------------------------------
 

-WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
+WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);

 
 class wxGTKTheme : public wxTheme
 {
 
 class wxGTKTheme : public wxTheme
 {


@@ -509,9 +640,10 @@ public:
     wxGTKTheme();
     virtual ~wxGTKTheme();
 
     wxGTKTheme();
     virtual ~wxGTKTheme();
 

-    virtual wxRenderer *GetRenderer() { return m_renderer; }
+    virtual wxRenderer *GetRenderer();
+    virtual wxArtProvider *GetArtProvider();

     virtual wxInputHandler *GetInputHandler(const wxString& control);
     virtual wxInputHandler *GetInputHandler(const wxString& control);

-    virtual wxColourScheme *GetColourScheme() { return m_scheme; }
+    virtual wxColourScheme *GetColourScheme();

 
 private:
     // get the default input handler
 
 private:
     // get the default input handler


@@ -519,6 +651,8 @@ private:
 
     wxGTKRenderer *m_renderer;
 
 
     wxGTKRenderer *m_renderer;
 

+    wxGTKArtProvider *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;


@@ -543,9 +677,10 @@ WX_IMPLEMENT_THEME(wxGTKTheme, gtk, wxTRANSLATE("GTK+ theme"));
 
 wxGTKTheme::wxGTKTheme()
 {
 
 wxGTKTheme::wxGTKTheme()
 {

-    m_scheme = new wxGTKColourScheme;
-    m_renderer = new wxGTKRenderer(m_scheme);
+    m_scheme = NULL;
+    m_renderer = NULL;

     m_handlerDefault = NULL;
     m_handlerDefault = NULL;

+    m_artProvider = NULL;

 }
 
 wxGTKTheme::~wxGTKTheme()
 }
 
 wxGTKTheme::~wxGTKTheme()


@@ -560,6 +695,36 @@ wxGTKTheme::~wxGTKTheme()
     delete m_handlerDefault;
     delete m_renderer;
     delete m_scheme;
     delete m_handlerDefault;
     delete m_renderer;
     delete m_scheme;

+    wxArtProvider::RemoveProvider(m_artProvider);
+}
+
+wxRenderer *wxGTKTheme::GetRenderer()
+{
+    if ( !m_renderer )
+    {
+        m_renderer = new wxGTKRenderer(GetColourScheme());
+    }
+
+    return m_renderer;
+}
+
+wxArtProvider *wxGTKTheme::GetArtProvider()
+{
+    if ( !m_artProvider )
+    {
+        m_artProvider = new wxGTKArtProvider;
+    }
+
+    return m_artProvider;
+}
+
+wxColourScheme *wxGTKTheme::GetColourScheme()
+{
+    if ( !m_scheme )
+    {
+        m_scheme = new wxGTKColourScheme;
+    }
+    return m_scheme;

 }
 
 wxInputHandler *wxGTKTheme::GetDefaultInputHandler()
 }
 
 wxInputHandler *wxGTKTheme::GetDefaultInputHandler()


@@ -574,14 +739,18 @@ wxInputHandler *wxGTKTheme::GetDefaultInputHandler()
 
 wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
 {
 
 wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
 {

-    wxInputHandler *handler;
+    wxInputHandler *handler = NULL;

     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {
         // create a new handler
         if ( control == wxINP_HANDLER_SCROLLBAR )
     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {
         // create a new handler
         if ( control == wxINP_HANDLER_SCROLLBAR )

+        {
+#if wxUSE_SCROLLBAR

             handler = new wxGTKScrollBarInputHandler(m_renderer,
                                                      GetDefaultInputHandler());
             handler = new wxGTKScrollBarInputHandler(m_renderer,
                                                      GetDefaultInputHandler());

+#endif // wxUSE_SCROLLBAR
+        }

 #if wxUSE_BUTTON
         else if ( control == wxINP_HANDLER_BUTTON )
             handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
 #if wxUSE_BUTTON
         else if ( control == wxINP_HANDLER_BUTTON )
             handler = new wxStdButtonInputHandler(GetDefaultInputHandler());


@@ -618,7 +787,14 @@ wxInputHandler *wxGTKTheme::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

-        else
+#if wxUSE_TOOLBAR
+        else if ( control == wxINP_HANDLER_TOOLBAR )
+            handler = new wxStdToolbarInputHandler(GetDefaultInputHandler());
+#endif // wxUSE_TOOLBAR
+        else if ( control == wxINP_HANDLER_TOPLEVEL )
+            handler = new wxStdFrameInputHandler(GetDefaultInputHandler());
+
+        if(!handler)

             handler = GetDefaultInputHandler();
 
         n = m_handlerNames.Add(control);
             handler = GetDefaultInputHandler();
 
         n = m_handlerNames.Add(control);


@@ -645,7 +821,7 @@ wxColour wxGTKColourScheme::GetBackground(wxWindow *win) const
         col = win->GetBackgroundColour();
     }
 
         col = win->GetBackgroundColour();
     }
 

-    if ( win->IsContainerWindow() )
+    if ( !win->ShouldInheritColours() )

     {
         // doesn't depend on the state
         if ( !col.Ok() )
     {
         // doesn't depend on the state
         if ( !col.Ok() )


@@ -661,9 +837,12 @@ wxColour wxGTKColourScheme::GetBackground(wxWindow *win) const
         // and for the states for which we don't have any specific colours
         if ( !col.Ok() || (flags != 0) )
         {
         // and for the states for which we don't have any specific colours
         if ( !col.Ok() || (flags != 0) )
         {

+#if wxUSE_SCROLLBAR

             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(SCROLLBAR);
             if ( wxDynamicCast(win, wxScrollBar) )
                 col = Get(SCROLLBAR);

-            else if ( (flags & wxCONTROL_CURRENT) && win->CanBeHighlighted() )
+            else
+#endif //wxUSE_SCROLLBAR
+                 if ( (flags & wxCONTROL_CURRENT) && win->CanBeHighlighted() )

                 col = Get(CONTROL_CURRENT);
             else if ( flags & wxCONTROL_PRESSED )
                 col = Get(CONTROL_PRESSED);
                 col = Get(CONTROL_CURRENT);
             else if ( flags & wxCONTROL_PRESSED )
                 col = Get(CONTROL_PRESSED);


@@ -702,6 +881,16 @@ wxColour wxGTKColourScheme::Get(wxGTKColourScheme::StdColour col) const
         case HIGHLIGHT:         return wxColour(0x9c0000);
         case HIGHLIGHT_TEXT:    return wxColour(0xffffff);
 
         case HIGHLIGHT:         return wxColour(0x9c0000);
         case HIGHLIGHT_TEXT:    return wxColour(0xffffff);
 

+        case GAUGE:             return Get(CONTROL_CURRENT);
+
+        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 *wxBLACK;
+

         case MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));
         case MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));


@@ -848,7 +1037,7 @@ void wxGTKRenderer::DrawAntiRaisedBorder(wxDC& dc, wxRect *rect)
 void wxGTKRenderer::DrawBorder(wxDC& dc,
                                wxBorder border,
                                const wxRect& rectTotal,
 void wxGTKRenderer::DrawBorder(wxDC& dc,
                                wxBorder border,
                                const wxRect& rectTotal,

-                               int flags,
+                               int WXUNUSED(flags),

                                wxRect *rectIn)
 {
     size_t width;
                                wxRect *rectIn)
 {
     size_t width;


@@ -949,7 +1138,7 @@ wxRect wxGTKRenderer::GetBorderDimensions(wxBorder border) const
 bool wxGTKRenderer::AreScrollbarsInsideBorder() const
 {
     // no, the scrollbars are outside the border in GTK+
 bool wxGTKRenderer::AreScrollbarsInsideBorder() const
 {
     // no, the scrollbars are outside the border in GTK+

-    return FALSE;
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1135,6 +1324,10 @@ void wxGTKRenderer::DrawButtonLabel(wxDC& dc,
         dc.DrawLabel(label, rectShadow, alignment, indexAccel);
         dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT_DISABLED));
     }
         dc.DrawLabel(label, rectShadow, alignment, indexAccel);
         dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT_DISABLED));
     }

+    else
+    {
+        dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT));
+    }

 
     dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
 }
 
     dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
 }


@@ -1193,11 +1386,12 @@ void wxGTKRenderer::DrawCheckItem(wxDC& dc,
     wxRect rectBitmap = rect;
     rectBitmap.x -= 1;
     rectBitmap.width = GetCheckBitmapSize().x;
     wxRect rectBitmap = rect;
     rectBitmap.x -= 1;
     rectBitmap.width = GetCheckBitmapSize().x;

+

     // never draw the focus rect around the check indicators here
     // never draw the focus rect around the check indicators here

-    DrawCheckButton(dc, _T(""), bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
+    DrawCheckButton(dc, wxEmptyString, bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);

 
     wxRect rectLabel = rect;
 
     wxRect rectLabel = rect;

-    wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin(); 
+    wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();

     rectLabel.x += shift;
     rectLabel.width -= shift;
     DrawItem(dc, label, rectLabel, flags);
     rectLabel.x += shift;
     rectLabel.width -= shift;
     DrawItem(dc, label, rectLabel, flags);


@@ -1207,6 +1401,35 @@ void wxGTKRenderer::DrawCheckItem(wxDC& dc,
 // check/radion buttons
 // ----------------------------------------------------------------------------
 
 // check/radion buttons
 // ----------------------------------------------------------------------------
 

+void wxGTKRenderer::DrawUndeterminedBitmap(wxDC& dc,
+                                           const wxRect& rectTotal,
+                                           bool isPressed)
+{
+    // FIXME: For sure it is not GTK look but it is better than nothing.
+    // Show me correct look and I will immediatelly make it better (ABX)
+    wxRect rect = rectTotal;
+
+    wxColour col1, col2;
+
+    if ( isPressed )
+    {
+        col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
+        col2 = wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED);
+    }
+    else
+    {
+        col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
+        col2 = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
+    }
+
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    dc.SetBrush(wxBrush(col1, wxSOLID));
+    dc.DrawRectangle(rect);
+    rect.Deflate(1);
+    dc.SetBrush(wxBrush(col2, wxSOLID));
+    dc.DrawRectangle(rect);
+}
+

 void wxGTKRenderer::DrawUncheckBitmap(wxDC& dc,
                                       const wxRect& rectTotal,
                                       bool isPressed)
 void wxGTKRenderer::DrawUncheckBitmap(wxDC& dc,
                                       const wxRect& rectTotal,
                                       bool isPressed)


@@ -1267,13 +1490,13 @@ void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
     DrawUpZag(dc, x, xRight, yMid, y);
     DrawUpZag(dc, x + 1, xRight - 1, yMid, y + 1);
 
     DrawUpZag(dc, x, xRight, yMid, y);
     DrawUpZag(dc, x + 1, xRight - 1, yMid, y + 1);
 

-    bool drawIt = TRUE;
+    bool drawIt = true;

     if ( flags & wxCONTROL_CHECKED )
         dc.SetPen(m_penBlack);
     else if ( flags & wxCONTROL_PRESSED )
         dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
     else // unchecked and unpressed
     if ( flags & wxCONTROL_CHECKED )
         dc.SetPen(m_penBlack);
     else if ( flags & wxCONTROL_PRESSED )
         dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
     else // unchecked and unpressed

-        drawIt = FALSE;
+        drawIt = false;

 
     if ( drawIt )
         DrawUpZag(dc, x + 2, xRight - 2, yMid, y + 2);
 
     if ( drawIt )
         DrawUpZag(dc, x + 2, xRight - 2, yMid, y + 2);


@@ -1286,14 +1509,14 @@ void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
     DrawDownZag(dc, x + 1, xRight - 1, yMid, yBottom - 1);
 
     if ( !(flags & wxCONTROL_CHECKED) )
     DrawDownZag(dc, x + 1, xRight - 1, yMid, yBottom - 1);
 
     if ( !(flags & wxCONTROL_CHECKED) )

-        drawIt = TRUE; // with the same pen
+        drawIt = true; // with the same pen

     else if ( flags & wxCONTROL_PRESSED )
     {
         dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
     else if ( flags & wxCONTROL_PRESSED )
     {
         dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));

-        drawIt = TRUE;
+        drawIt = true;

     }
     else // checked and unpressed
     }
     else // checked and unpressed

-        drawIt = FALSE;
+        drawIt = false;

 
     if ( drawIt )
         DrawDownZag(dc, x + 2, xRight - 2, yMid, yBottom - 2);
 
     if ( drawIt )
         DrawDownZag(dc, x + 2, xRight - 2, yMid, yBottom - 2);


@@ -1332,7 +1555,7 @@ wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
         rect.height = size.y;
         for ( int i = 0; i < 2; i++ )
         {
         rect.height = size.y;
         for ( int i = 0; i < 2; i++ )
         {

-            for ( int j = 0; j < 2; j++ )
+            for ( int j = 0; j < 3; j++ )

                 m_bitmapsCheckbox[i][j].Create(rect.width, rect.height);
         }
 
                 m_bitmapsCheckbox[i][j].Create(rect.width, rect.height);
         }
 


@@ -1344,23 +1567,37 @@ wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
 
         // normal unchecked
         dc.SelectObject(m_bitmapsCheckbox[0][1]);
 
         // normal unchecked
         dc.SelectObject(m_bitmapsCheckbox[0][1]);

-        DrawUncheckBitmap(dc, rect, FALSE);
+        DrawUncheckBitmap(dc, rect, false);
+
+        // normal undeterminated
+        dc.SelectObject(m_bitmapsCheckbox[0][2]);
+        DrawUndeterminedBitmap(dc, rect, false);

 
         // pressed checked
         m_bitmapsCheckbox[1][0] = m_bitmapsCheckbox[0][0];
 
         // pressed unchecked
         dc.SelectObject(m_bitmapsCheckbox[1][1]);
 
         // pressed checked
         m_bitmapsCheckbox[1][0] = m_bitmapsCheckbox[0][0];
 
         // pressed unchecked
         dc.SelectObject(m_bitmapsCheckbox[1][1]);

-        DrawUncheckBitmap(dc, rect, TRUE);
+        DrawUncheckBitmap(dc, rect, true);
+
+        // pressed undeterminated
+        dc.SelectObject(m_bitmapsCheckbox[1][2]);
+        DrawUndeterminedBitmap(dc, rect, true);

     }
 
     }
 

-    int row = flags & wxCONTROL_PRESSED ? 1 : 0;
-    int col = flags & wxCONTROL_CHECKED ? 0 : 1;
+    int row = flags & wxCONTROL_PRESSED
+                  ? 1
+                  : 0;
+    int col = flags & wxCONTROL_CHECKED
+                  ? 0
+                  : ( flags & wxCONTROL_UNDETERMINED
+                          ? 2
+                          : 1 );

 
     return m_bitmapsCheckbox[row][col];
 }
 
 
     return m_bitmapsCheckbox[row][col];
 }
 

-wxBitmap wxGTKRenderer::GetLineWrapBitmap()
+wxBitmap wxGTKRenderer::GetLineWrapBitmap() const

 {
     if ( !m_bmpLineWrap.Ok() )
     {
 {
     if ( !m_bmpLineWrap.Ok() )
     {


@@ -1379,7 +1616,7 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap()
         }
         else
         {
         }
         else
         {

-            m_bmpLineWrap = bmpLineWrap;
+            wxConstCast(this, wxGTKRenderer)->m_bmpLineWrap = bmpLineWrap;

         }
     }
 
         }
     }
 


@@ -1450,7 +1687,7 @@ void wxGTKRenderer::DoDrawCheckOrRadioBitmap(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 */);

 
     DrawLabel(dc, label, rectLabel, flags,
               wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);
 
     DrawLabel(dc, label, rectLabel, flags,
               wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);


@@ -1481,6 +1718,10 @@ void wxGTKRenderer::DrawRadioButton(wxDC& dc,
         dc.SetBackground(*wxLIGHT_GREY_BRUSH);
         dc.Clear();
         DrawRadioBitmap(dc, rect, flags);
         dc.SetBackground(*wxLIGHT_GREY_BRUSH);
         dc.Clear();
         DrawRadioBitmap(dc, rect, flags);

+
+        // must unselect the bitmap before setting a mask for it because of the
+        // MSW limitations
+        dc.SelectObject(wxNullBitmap);

         bitmap.SetMask(new wxMask(bitmap, *wxLIGHT_GREY));
     }
 
         bitmap.SetMask(new wxMask(bitmap, *wxLIGHT_GREY));
     }
 


@@ -1488,12 +1729,63 @@ void wxGTKRenderer::DrawRadioButton(wxDC& dc,
                              flags, align, indexAccel);
 }
 
                              flags, align, indexAccel);
 }
 

+#if wxUSE_TOOLBAR
+void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
+                                      const wxString& label,
+                                      const wxBitmap& bitmap,
+                                      const wxRect& rectOrig,
+                                      int flags,
+                                      long WXUNUSED(style),
+                                      int tbarStyle)
+{
+    // we don't draw the separators at all
+    if ( !label.empty() || bitmap.Ok() )
+    {
+        wxRect rect = rectOrig;
+        rect.Deflate(BORDER_THICKNESS);
+
+        if ( flags & wxCONTROL_PRESSED )
+        {
+            DrawBorder(dc, wxBORDER_SUNKEN, rect, flags, &rect);
+
+            DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), rect);
+        }
+        else if ( flags & wxCONTROL_CURRENT )
+        {
+            DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rect);
+
+            DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT), rect);
+        }
+
+        if(tbarStyle & wxTB_TEXT)
+        {
+            if(tbarStyle & wxTB_HORIZONTAL)
+            {
+                dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+            }
+            else
+            {
+                dc.DrawLabel(label, bitmap, rect, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL);
+            }
+        }
+        else
+        {
+            int xpoint = (rect.GetLeft() + rect.GetRight() + 1 - bitmap.GetWidth()) / 2;
+            int ypoint = (rect.GetTop() + rect.GetBottom() + 1 - bitmap.GetHeight()) / 2;
+            dc.DrawBitmap(bitmap, xpoint, ypoint);
+        }
+    }
+}
+#endif // wxUSE_TOOLBAR
+

 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 

-wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
-                                       const wxRect& rect)
+#if wxUSE_TEXTCTRL
+
+wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
+                                       const wxRect& rect) const

 {
     wxRect rectTotal = rect;
     rectTotal.Inflate(2*BORDER_THICKNESS);
 {
     wxRect rectTotal = rect;
     rectTotal.Inflate(2*BORDER_THICKNESS);


@@ -1502,10 +1794,10 @@ wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
 
 wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
                                         const wxRect& rect,
 
 wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
                                         const wxRect& rect,

-                                        wxCoord *extraSpaceBeyond)
+                                        wxCoord *extraSpaceBeyond) const

 {
     wxRect rectText = rect;
 {
     wxRect rectText = rect;

-    rectText.Inflate(-2*BORDER_THICKNESS);
+    rectText.Deflate(2*BORDER_THICKNESS);

 
     if ( text->WrapLines() )
     {
 
     if ( text->WrapLines() )
     {


@@ -1521,6 +1813,8 @@ wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
     return rectText;
 }
 
     return rectText;
 }
 

+#endif // wxUSE_TEXTCTRL
+

 void wxGTKRenderer::DrawTextLine(wxDC& dc,
                                  const wxString& text,
                                  const wxRect& rect,
 void wxGTKRenderer::DrawTextLine(wxDC& dc,
                                  const wxString& text,
                                  const wxRect& rect,


@@ -1570,13 +1864,23 @@ void wxGTKRenderer::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:


@@ -1584,19 +1888,17 @@ void wxGTKRenderer::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;
         }
     }
                 break;
         }
     }


@@ -1614,102 +1916,157 @@ void wxGTKRenderer::DrawTab(wxDC& dc,
         rectBorder.Deflate(4, 3);
         if ( dir == wxBOTTOM )
             rectBorder.Offset(0, -1);
         rectBorder.Deflate(4, 3);
         if ( dir == wxBOTTOM )
             rectBorder.Offset(0, -1);

+        if ( dir == wxRIGHT )
+            rectBorder.Offset(-1, 0);

 
         DrawRect(dc, &rectBorder, m_penBlack);
     }
 
     // draw the text, image and the focus around them (if necessary)
 
         DrawRect(dc, &rectBorder, m_penBlack);
     }
 
     // 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);

-    dc.DrawLabel(label, bitmap, rectLabel, wxALIGN_CENTRE, indexAccel);
+    if ( isVertical )
+    {
+        // draw it horizontally into memory and rotate for screen
+        wxMemoryDC dcMem;
+        wxBitmap bitmapRotated,
+                 bitmapMem( rectLabel.x + rectLabel.width,
+                            rectLabel.y + rectLabel.height );
+        dcMem.SelectObject(bitmapMem);
+        dcMem.SetBackground(dc.GetBackground());
+        dcMem.SetFont(dc.GetFont());
+        dcMem.SetTextForeground(dc.GetTextForeground());
+        dcMem.Clear();
+        bitmapRotated =
+#if wxUSE_IMAGE
+                        wxBitmap( wxImage( bitmap.ConvertToImage() ).Rotate90(dir==wxLEFT) )
+#else
+                        bitmap
+#endif // wxUSE_IMAGE
+                        ;
+        dcMem.DrawLabel(label, bitmapRotated, rectLabel, wxALIGN_CENTRE, indexAccel);
+        dcMem.SelectObject(wxNullBitmap);
+        bitmapMem = bitmapMem.GetSubBitmap(rectLabel);
+#if wxUSE_IMAGE
+        bitmapMem = wxBitmap(wxImage(bitmapMem.ConvertToImage()).Rotate90(dir==wxRIGHT))
+#endif
+                    ;
+
+        dc.DrawBitmap(bitmapMem, rectLabel.y, rectLabel.x, false);
+    }
+    else
+    {
+        dc.DrawLabel(label, bitmap, rectLabel, wxALIGN_CENTRE, indexAccel);
+    }

 
     // now draw the tab itself
 
     // now draw the tab itself

-    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());

     switch ( dir )
     {
         default:
     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);
-            dc.DrawLine(x + 1, y, x2, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y2),
+                        REVERSE_FOR_VERTICAL(x, y));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y),
+                        REVERSE_FOR_VERTICAL(x2, y));

 
             dc.SetPen(m_penBlack);
 
             dc.SetPen(m_penBlack);

-            dc.DrawLine(x2, y2, x2, y);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y2),
+                        REVERSE_FOR_VERTICAL(x2, y));

 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);

-            dc.DrawLine(x2 - 1, y2, x2 - 1, y + 1);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y2),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y + 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 + 2, x + 1, y2 + 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y + 2),
+                            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);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0)),
+                        REVERSE_FOR_VERTICAL(x, y2));

 
             // it doesn't work like this (TODO: implement it properly)
 #if 0
             // erase the corner of the tab to the right
             dc.SetPen(m_penLightGrey);
 
             // it doesn't work like this (TODO: implement it properly)
 #if 0
             // erase the corner of the tab to the right
             dc.SetPen(m_penLightGrey);

-            dc.DrawPoint(x2 - 1, y - 2);
-            dc.DrawPoint(x2 - 2, y - 2);
-            dc.DrawPoint(x2 - 2, y - 1);
+            dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 1, y - 2));
+            dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 2, y - 2));
+            dc.DrawPoint(REVERSE_FOR_VERTICAL(x2 - 2, y - 1));

 #endif // 0
 
             dc.SetPen(m_penBlack);
 #endif // 0
 
             dc.SetPen(m_penBlack);

-            dc.DrawLine(x + 1, y2, x2, y2);
-            dc.DrawLine(x2, y, x2, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2),
+                        REVERSE_FOR_VERTICAL(x2, y2));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2, y),
+                        REVERSE_FOR_VERTICAL(x2, y2));

 
             dc.SetPen(m_penDarkGrey);
 
             dc.SetPen(m_penDarkGrey);

-            dc.DrawLine(x + 2, y2 - 1, x2 - 1, y2 - 1);
-            dc.DrawLine(x2 - 1, y, x2 - 1, y2);
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x + 2, y2 - 1),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y2 - 1));
+            dc.DrawLine(REVERSE_FOR_VERTICAL(x2 - 1, y),
+                        REVERSE_FOR_VERTICAL(x2 - 1, y2));

 
             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 - 1, x + 1, y - 1);
+                dc.DrawLine(REVERSE_FOR_VERTICAL(x + 1, y2 - 1),
+                            REVERSE_FOR_VERTICAL(x + 1, y - 1));

             }
             break;
             }
             break;

-
-        case wxLEFT:
-        case wxRIGHT:
-            wxFAIL_MSG(_T("TODO"));

     }
 }
 
     }
 }
 

+#if wxUSE_SLIDER
+

 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
 wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
 wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,

+                                         int lenThumb,

                                          wxOrientation orient) const
 {
     static const wxCoord SLIDER_THUMB_LENGTH = 30;
 
     wxSize size;
 
                                          wxOrientation orient) const
 {
     static const wxCoord SLIDER_THUMB_LENGTH = 30;
 
     wxSize size;
 

-    wxRect rectShaft = GetSliderShaftRect(rect, orient);
+    wxRect rectShaft = GetSliderShaftRect(rect, lenThumb, orient);

     if ( orient == wxHORIZONTAL )
     {
         size.x = wxMin(SLIDER_THUMB_LENGTH, rectShaft.width);
     if ( orient == wxHORIZONTAL )
     {
         size.x = wxMin(SLIDER_THUMB_LENGTH, rectShaft.width);


@@ -1725,15 +2082,19 @@ wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
 }
 
 wxRect wxGTKRenderer::GetSliderShaftRect(const wxRect& rect,
 }
 
 wxRect wxGTKRenderer::GetSliderShaftRect(const wxRect& rect,

-                                         wxOrientation WXUNUSED(orient)) const
+                                         int WXUNUSED(lenThumb),
+                                         wxOrientation WXUNUSED(orient),
+                                         long WXUNUSED(style)) const

 {
     return rect.Deflate(2*BORDER_THICKNESS, 2*BORDER_THICKNESS);
 }
 
 void wxGTKRenderer::DrawSliderShaft(wxDC& dc,
                                     const wxRect& rectOrig,
 {
     return rect.Deflate(2*BORDER_THICKNESS, 2*BORDER_THICKNESS);
 }
 
 void wxGTKRenderer::DrawSliderShaft(wxDC& dc,
                                     const wxRect& rectOrig,

-                                    wxOrientation orient,
+                                    int WXUNUSED(lenThumb),
+                                    wxOrientation WXUNUSED(orient),

                                     int flags,
                                     int flags,

+                                    long WXUNUSED(style),

                                     wxRect *rectShaft)
 {
     wxRect rect = rectOrig;
                                     wxRect *rectShaft)
 {
     wxRect rect = rectOrig;


@@ -1760,7 +2121,8 @@ void wxGTKRenderer::DrawSliderShaft(wxDC& dc,
 void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
                                     const wxRect& rectOrig,
                                     wxOrientation orient,
 void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
                                     const wxRect& rectOrig,
                                     wxOrientation orient,

-                                    int flags)
+                                    int WXUNUSED(flags),
+                                    long WXUNUSED(style))

 {
     // draw the thumb border
     wxRect rect = rectOrig;
 {
     // draw the thumb border
     wxRect rect = rectOrig;


@@ -1781,53 +2143,298 @@ void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
     DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
 }
 
     DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
 }
 

+#endif // wxUSE_SLIDER
+

 #if wxUSE_MENUS
 #if wxUSE_MENUS

+

 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // menu and menubar
 // ----------------------------------------------------------------------------
 

+// wxGTKMenuGeometryInfo: the wxMenuGeometryInfo used by wxGTKRenderer
+class WXDLLEXPORT wxGTKMenuGeometryInfo : public wxMenuGeometryInfo
+{
+public:
+    virtual wxSize GetSize() const { return m_size; }
+
+    wxCoord GetLabelOffset() const { return m_ofsLabel; }
+    wxCoord GetAccelOffset() const { return m_ofsAccel; }
+
+    wxCoord GetItemHeight() const { return m_heightItem; }
+
+private:
+    // the total size of the menu
+    wxSize m_size;
+
+    // the offset of the start of the menu item label
+    wxCoord m_ofsLabel;
+
+    // the offset of the start of the accel label
+    wxCoord m_ofsAccel;
+
+    // the height of a normal (not separator) item
+    wxCoord m_heightItem;
+
+    friend wxMenuGeometryInfo *
+        wxGTKRenderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
+};
+
+// FIXME: all constants are hardcoded but shouldn't be
+static const wxCoord MENU_LEFT_MARGIN = 9;
+static const wxCoord MENU_RIGHT_MARGIN = 6;
+
+static const wxCoord MENU_HORZ_MARGIN = 6;
+static const wxCoord MENU_VERT_MARGIN = 3;
+
+// the margin around bitmap/check marks (on each side)
+static const wxCoord MENU_BMP_MARGIN = 2;
+
+// the margin between the labels and accel strings
+static const wxCoord MENU_ACCEL_MARGIN = 8;
+
+// the separator height in pixels: in fact, strangely enough, the real height
+// is 2 but Windows adds one extra pixel in the bottom margin, so take it into
+// account here
+static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
+
+// the size of the standard checkmark bitmap
+static const wxCoord MENU_CHECK_SIZE = 9;
+

 void wxGTKRenderer::DrawMenuBarItem(wxDC& dc,
                                     const wxRect& rect,
                                     const wxString& label,
                                     int flags,
                                     int indexAccel)
 {
 void wxGTKRenderer::DrawMenuBarItem(wxDC& dc,
                                     const wxRect& rect,
                                     const wxString& label,
                                     int flags,
                                     int indexAccel)
 {

-    DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE, indexAccel);
+    DoDrawMenuItem(dc, rect, label, flags, indexAccel);

 }
 
 void wxGTKRenderer::DrawMenuItem(wxDC& dc,
                                  wxCoord y,
 }
 
 void wxGTKRenderer::DrawMenuItem(wxDC& dc,
                                  wxCoord y,

-                                 const wxMenuGeometryInfo& geometryInfo,
+                                 const wxMenuGeometryInfo& gi,

                                  const wxString& label,
                                  const wxString& accel,
                                  const wxBitmap& bitmap,
                                  int flags,
                                  int indexAccel)
 {
                                  const wxString& label,
                                  const wxString& accel,
                                  const wxBitmap& bitmap,
                                  int flags,
                                  int indexAccel)
 {

-    wxFAIL_MSG(_T("TODO"));
+    const wxGTKMenuGeometryInfo& geomInfo = (const wxGTKMenuGeometryInfo&)gi;
+
+    wxRect rect;
+    rect.x = 0;
+    rect.y = y;
+    rect.width = geomInfo.GetSize().x;
+    rect.height = geomInfo.GetItemHeight();
+
+    DoDrawMenuItem(dc, rect, label, flags, indexAccel, accel, bitmap, &geomInfo);
+}
+
+void wxGTKRenderer::DoDrawMenuItem(wxDC& dc,
+                                   const wxRect& rectOrig,
+                                   const wxString& label,
+                                   int flags,
+                                   int indexAccel,
+                                   const wxString& accel,
+                                   const wxBitmap& bitmap,
+                                   const wxGTKMenuGeometryInfo *geometryInfo)
+{
+    wxRect rect = rectOrig;
+
+    // draw the selected item specially
+    if ( flags & wxCONTROL_SELECTED )
+    {
+        wxRect rectIn;
+        DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
+
+        DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT), rectIn);
+    }
+
+    rect.Deflate(MENU_HORZ_MARGIN, MENU_VERT_MARGIN);
+
+    // draw the bitmap: use the bitmap provided or the standard checkmark for
+    // the checkable items
+    if ( geometryInfo )
+    {
+        wxBitmap bmp = bitmap;
+        if ( !bmp.Ok() && (flags & wxCONTROL_CHECKABLE) )
+        {
+            bmp = GetCheckBitmap(flags);
+        }
+
+        if ( bmp.Ok() )
+        {
+            rect.SetRight(geometryInfo->GetLabelOffset());
+            wxControlRenderer::DrawBitmap(dc, bmp, rect);
+        }
+    }
+    //else: menubar items don't have bitmaps
+
+    // draw the label
+    if ( geometryInfo )
+    {
+        rect.x = geometryInfo->GetLabelOffset();
+        rect.SetRight(geometryInfo->GetAccelOffset());
+    }
+
+    DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE_VERTICAL, indexAccel);
+
+    // draw the accel string
+    if ( !accel.empty() )
+    {
+        // menubar items shouldn't have them
+        wxCHECK_RET( geometryInfo, _T("accel strings only valid for menus") );
+
+        rect.x = geometryInfo->GetAccelOffset();
+        rect.SetRight(geometryInfo->GetSize().x);
+
+        // NB: no accel index here
+        DrawLabel(dc, accel, rect, flags, wxALIGN_CENTRE_VERTICAL);
+    }
+
+    // draw the submenu indicator
+    if ( flags & wxCONTROL_ISSUBMENU )
+    {
+        wxCHECK_RET( geometryInfo, _T("wxCONTROL_ISSUBMENU only valid for menus") );
+
+        rect.x = geometryInfo->GetSize().x - MENU_RIGHT_MARGIN;
+        rect.width = MENU_RIGHT_MARGIN;
+
+        DrawArrow(dc, wxRIGHT, rect, flags);
+    }

 }
 
 void wxGTKRenderer::DrawMenuSeparator(wxDC& dc,
                                       wxCoord y,
                                       const wxMenuGeometryInfo& geomInfo)
 {
 }
 
 void wxGTKRenderer::DrawMenuSeparator(wxDC& dc,
                                       wxCoord y,
                                       const wxMenuGeometryInfo& geomInfo)
 {

-    wxFAIL_MSG(_T("TODO"));
+    DrawHorizontalLine(dc, y + MENU_VERT_MARGIN, 0, geomInfo.GetSize().x);

 }
 
 wxSize wxGTKRenderer::GetMenuBarItemSize(const wxSize& sizeText) const
 {
 }
 
 wxSize wxGTKRenderer::GetMenuBarItemSize(const wxSize& sizeText) const
 {

-    return sizeText;
+    wxSize size = sizeText;
+
+    // TODO: make this configurable
+    size.x += 2*MENU_HORZ_MARGIN;
+    size.y += 2*MENU_VERT_MARGIN;
+
+    return size;

 }
 
 wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
                                                    const wxMenu& menu) const
 {
 }
 
 wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
                                                    const wxMenu& menu) const
 {

-    wxFAIL_MSG(_T("TODO"));
+    // prepare the dc: for now we draw all the items with the system font
+    wxClientDC dc(win);
+    dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
+
+    // the height of a normal item
+    wxCoord heightText = dc.GetCharHeight();
+
+    // the total height
+    wxCoord height = 0;
+
+    // the max length of label and accel strings: the menu width is the sum of
+    // them, even if they're for different items (as the accels should be
+    // aligned)
+    //
+    // the max length of the bitmap is never 0 as Windows always leaves enough
+    // space for a check mark indicator
+    wxCoord widthLabelMax = 0,
+            widthAccelMax = 0,
+            widthBmpMax = MENU_LEFT_MARGIN;
+
+    for ( wxMenuItemList::compatibility_iterator node = menu.GetMenuItems().GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        // height of this item
+        wxCoord h;
+
+        wxMenuItem *item = node->GetData();
+        if ( item->IsSeparator() )
+        {
+            h = MENU_SEPARATOR_HEIGHT;
+        }
+        else // not separator
+        {
+            h = heightText;
+
+            wxCoord widthLabel;
+            dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
+            if ( widthLabel > widthLabelMax )
+            {
+                widthLabelMax = widthLabel;
+            }
+
+            wxCoord widthAccel;
+            dc.GetTextExtent(item->GetAccelString(), &widthAccel, NULL);
+            if ( widthAccel > widthAccelMax )
+            {
+                widthAccelMax = widthAccel;
+            }
+
+            const wxBitmap& bmp = item->GetBitmap();
+            if ( bmp.Ok() )
+            {
+                wxCoord widthBmp = bmp.GetWidth();
+                if ( widthBmp > widthBmpMax )
+                    widthBmpMax = widthBmp;
+            }
+            //else if ( item->IsCheckable() ): no need to check for this as
+            // MENU_LEFT_MARGIN is big enough to show the check mark
+        }
+
+        h += 2*MENU_VERT_MARGIN;
+
+        // remember the item position and height
+        item->SetGeometry(height, h);
+
+        height += h;
+    }
+
+    // bundle the metrics into a struct and return it
+    wxGTKMenuGeometryInfo *gi = new wxGTKMenuGeometryInfo;

 
 

-    return NULL;
+    gi->m_ofsLabel = widthBmpMax + 2*MENU_BMP_MARGIN;
+    gi->m_ofsAccel = gi->m_ofsLabel + widthLabelMax;
+    if ( widthAccelMax > 0 )
+    {
+        // if we actually have any accesl, add a margin
+        gi->m_ofsAccel += MENU_ACCEL_MARGIN;
+    }
+
+    gi->m_heightItem = heightText + 2*MENU_VERT_MARGIN;
+
+    gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
+    gi->m_size.y = height;
+
+    return gi;

 }
 }

+

 #endif // wxUSE_MENUS
 
 #endif // wxUSE_MENUS
 

+#if wxUSE_STATUSBAR
+
+// ----------------------------------------------------------------------------
+// status bar
+// ----------------------------------------------------------------------------
+
+wxSize
+wxGTKRenderer::GetStatusBarBorders(wxCoord * WXUNUSED(borderBetweenFields)) const
+{
+    return wxSize(0,0);
+}
+
+void wxGTKRenderer::DrawStatusField(wxDC& WXUNUSED(dc),
+                                    const wxRect& WXUNUSED(rect),
+                                    const wxString& WXUNUSED(label),
+                                    int WXUNUSED(flags), int WXUNUSED(style))
+{
+}
+
+#endif // wxUSE_STATUSBAR
+

 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // combobox
 // ----------------------------------------------------------------------------


@@ -1853,7 +2460,7 @@ void wxGTKRenderer::InitComboBitmaps()
         wxCONTROL_DISABLED,
     };
 
         wxCONTROL_DISABLED,
     };
 

-    wxRect rect(wxPoint(0, 0), sizeArrow);
+    wxRect rect(sizeArrow);

 
     wxMemoryDC dc;
     for ( n = ComboState_Normal; n < ComboState_Max; n++ )
 
     wxMemoryDC dc;
     for ( n = ComboState_Normal; n < ComboState_Max; n++ )


@@ -1892,7 +2499,8 @@ void wxGTKRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
 
 void wxGTKRenderer::DoDrawBackground(wxDC& dc,
                                      const wxColour& col,
 
 void wxGTKRenderer::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);


@@ -1903,10 +2511,11 @@ void wxGTKRenderer::DoDrawBackground(wxDC& dc,
 void wxGTKRenderer::DrawBackground(wxDC& dc,
                                    const wxColour& col,
                                    const wxRect& rect,
 void wxGTKRenderer::DrawBackground(wxDC& dc,
                                    const wxColour& col,
                                    const wxRect& rect,

-                                   int flags)
+                                   int flags,
+                                   wxWindow *window )

 {
     wxColour colBg = col.Ok() ? col : GetBackgroundColour(flags);
 {
     wxColour colBg = col.Ok() ? col : GetBackgroundColour(flags);

-    DoDrawBackground(dc, colBg, rect);
+    DoDrawBackground(dc, colBg, rect, window );

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -2237,7 +2846,7 @@ void wxGTKRenderer::DrawScrollbarThumb(wxDC& dc,
 void wxGTKRenderer::DrawScrollbarShaft(wxDC& dc,
                                        wxOrientation orient,
                                        const wxRect& rect,
 void wxGTKRenderer::DrawScrollbarShaft(wxDC& dc,
                                        wxOrientation orient,
                                        const wxRect& rect,

-                                       int flags)
+                                       int WXUNUSED(flags))

 {
     wxRect rectBar = rect;
     DrawThumbBorder(dc, &rectBar, orient);
 {
     wxRect rectBar = rect;
     DrawThumbBorder(dc, &rectBar, orient);


@@ -2249,6 +2858,7 @@ void wxGTKRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
     DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
 }
 
     DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
 }
 

+#if wxUSE_SCROLLBAR

 wxRect wxGTKRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
                                        wxScrollBar::Element elem,
                                        int thumbPos) const
 wxRect wxGTKRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
                                        wxScrollBar::Element elem,
                                        int thumbPos) const


@@ -2291,6 +2901,7 @@ int wxGTKRenderer::PixelToScrollbar(const wxScrollBar *scrollbar,
     return StandardPixelToScrollbar(scrollbar, coord,
                                     GetScrollbarArrowSize(scrollbar));
 }
     return StandardPixelToScrollbar(scrollbar, coord,
                                     GetScrollbarArrowSize(scrollbar));
 }

+#endif // wxUSE_SCROLLBAR

 
 // ----------------------------------------------------------------------------
 // size adjustments
 
 // ----------------------------------------------------------------------------
 // size adjustments


@@ -2305,8 +2916,15 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
         size->y += 4;
     } else
 #endif // wxUSE_BMPBUTTON
         size->y += 4;
     } else
 #endif // wxUSE_BMPBUTTON

-#if wxUSE_BUTTON
-    if ( wxDynamicCast(window, wxButton) )
+#if wxUSE_BUTTON || wxUSE_TOGGLEBTN
+    if ( 0
+#  if wxUSE_BUTTON
+         || wxDynamicCast(window, wxButton)
+#  endif // wxUSE_BUTTON
+#  if wxUSE_TOGGLEBTN
+         || wxDynamicCast(window, wxToggleButton)
+#  endif // wxUSE_TOGGLEBTN
+        )

     {
         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
         {
     {
         if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
         {


@@ -2320,7 +2938,8 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
             size->y += 4;
         }
     } else
             size->y += 4;
         }
     } else

-#endif wxUSE_BUTTON
+#endif // wxUSE_BUTTON || wxUSE_TOGGLEBTN
+#if wxUSE_SCROLLBAR

     if ( wxDynamicCast(window, wxScrollBar) )
     {
         // we only set the width of vert scrollbars and height of the
     if ( wxDynamicCast(window, wxScrollBar) )
     {
         // we only set the width of vert scrollbars and height of the


@@ -2331,6 +2950,7 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
             size->x = m_sizeScrollbarArrow.x;
     }
     else
             size->x = m_sizeScrollbarArrow.x;
     }
     else

+#endif // wxUSE_SCROLLBAR

     {
         // take into account the border width
         wxRect rectBorder = GetBorderDimensions(window->GetBorder());
     {
         // take into account the border width
         wxRect rectBorder = GetBorderDimensions(window->GetBorder());


@@ -2339,6 +2959,370 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
     }
 }
 
     }
 }
 

+// ----------------------------------------------------------------------------
+// top level windows
+// ----------------------------------------------------------------------------
+
+void wxGTKRenderer::DrawFrameTitleBar(wxDC& WXUNUSED(dc),
+                                      const wxRect& WXUNUSED(rect),
+                                      const wxString& WXUNUSED(title),
+                                      const wxIcon& WXUNUSED(icon),
+                                      int WXUNUSED(flags),
+                                      int WXUNUSED(specialButton),
+                                      int WXUNUSED(specialButtonFlag))
+{
+}
+
+void wxGTKRenderer::DrawFrameBorder(wxDC& WXUNUSED(dc),
+                                    const wxRect& WXUNUSED(rect),
+                                    int WXUNUSED(flags))
+{
+}
+
+void wxGTKRenderer::DrawFrameBackground(wxDC& WXUNUSED(dc),
+                                        const wxRect& WXUNUSED(rect),
+                                        int WXUNUSED(flags))
+{
+}
+
+void wxGTKRenderer::DrawFrameTitle(wxDC& WXUNUSED(dc),
+                                   const wxRect& WXUNUSED(rect),
+                                   const wxString& WXUNUSED(title),
+                                   int WXUNUSED(flags))
+{
+}
+
+void wxGTKRenderer::DrawFrameIcon(wxDC& WXUNUSED(dc),
+                                  const wxRect& WXUNUSED(rect),
+                                  const wxIcon& WXUNUSED(icon),
+                                  int WXUNUSED(flags))
+{
+}
+
+void wxGTKRenderer::DrawFrameButton(wxDC& WXUNUSED(dc),
+                                    wxCoord WXUNUSED(x),
+                                    wxCoord WXUNUSED(y),
+                                    int WXUNUSED(button),
+                                    int WXUNUSED(flags))
+{
+}
+
+wxRect
+wxGTKRenderer::GetFrameClientArea(const wxRect& rect,
+                                  int WXUNUSED(flags)) const
+{
+    return rect;
+}
+
+wxSize
+wxGTKRenderer::GetFrameTotalSize(const wxSize& clientSize,
+                                 int WXUNUSED(flags)) const
+{
+    return clientSize;
+}
+
+wxSize wxGTKRenderer::GetFrameMinSize(int WXUNUSED(flags)) const
+{
+    return wxSize(0,0);
+}
+
+wxSize wxGTKRenderer::GetFrameIconSize() const
+{
+    return wxSize(wxDefaultCoord, wxDefaultCoord);
+}
+
+int
+wxGTKRenderer::HitTestFrame(const wxRect& WXUNUSED(rect),
+                            const wxPoint& WXUNUSED(pt),
+                            int WXUNUSED(flags)) const
+{
+    return wxHT_TOPLEVEL_CLIENT_AREA;
+}
+
+
+// ----------------------------------------------------------------------------
+// standard icons
+// ----------------------------------------------------------------------------
+
+/* Copyright (c) Julian Smart */
+static const char *error_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 4 1",
+"  c None",
+"X c #242424",
+"o c #DCDF00",
+". c #C00000",
+/* pixels */
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                    .....                       ",
+"                .............                   ",
+"              .................                 ",
+"             ...................                ",
+"           .......................              ",
+"          .........................             ",
+"         ...........................            ",
+"         ...........................X           ",
+"        .............................X          ",
+"       ...............................          ",
+"       ...............................X         ",
+"      .................................X        ",
+"      .................................X        ",
+"      .................................XX       ",
+"      ...ooooooooooooooooooooooooooo...XX       ",
+"     ....ooooooooooooooooooooooooooo....X       ",
+"     ....ooooooooooooooooooooooooooo....X       ",
+"     ....ooooooooooooooooooooooooooo....XX      ",
+"     ....ooooooooooooooooooooooooooo....XX      ",
+"     ....ooooooooooooooooooooooooooo....XX      ",
+"      ...ooooooooooooooooooooooooooo...XXX      ",
+"      ...ooooooooooooooooooooooooooo...XXX      ",
+"      .................................XX       ",
+"      .................................XX       ",
+"       ...............................XXX       ",
+"       ...............................XXX       ",
+"        .............................XXX        ",
+"         ...........................XXXX        ",
+"         ...........................XXX         ",
+"          .........................XXX          ",
+"           .......................XXXX          ",
+"            X...................XXXXX           ",
+"             X.................XXXXX            ",
+"               X.............XXXXX              ",
+"                XXXX.....XXXXXXXX               ",
+"                  XXXXXXXXXXXXX                 ",
+"                      XXXXX                     ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *info_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 9 1",
+"$ c Black",
+"O c #FFFFFF",
+"@ c #808080",
+"+ c #000080",
+"o c #E8EB01",
+"  c None",
+"X c #FFFF40",
+"# c #C0C0C0",
+". c #ABAD01",
+/* pixels */
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                     .....                      ",
+"                   ..XXXXX..                    ",
+"                 ..XXXXXXXXo..                  ",
+"                .XXXOXXXXXXXoo.                 ",
+"                .XOOXXX+XXXXXo.                 ",
+"               .XOOOXX+++XXXXoo.                ",
+"               .XOOXXX+++XXXXXo.                ",
+"              .XOOOXXX+++XXXXXXo.               ",
+"              .XOOXXXX+++XXXXXXo.               ",
+"              .XXXXXXX+++XXXXXXX.               ",
+"              .XXXXXXX+++XXXXXXo.               ",
+"              .XXXXXXX+++XXXXXoo.               ",
+"               .XXXXXX+++XXXXXo.                ",
+"               .XXXXXXX+XXXXXXo.                ",
+"                .XXXXXXXXXXXXo.                 ",
+"                .XXXXX+++XXXoo.                 ",
+"                 .XXXX+++XXoo.                  ",
+"                  .XXXXXXXXo.                   ",
+"                  ..XXXXXXo..                   ",
+"                   .XXXXXo..                    ",
+"                   @#######@                    ",
+"                   @@@@@@@@@                    ",
+"                   @#######@                    ",
+"                   @@@@@@@@@                    ",
+"                   @#######@                    ",
+"                    @@@@@@@                     ",
+"                      ###                       ",
+"                      $$$                       ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *warning_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 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...           ",
+"       ..............................           ",
+"       ..............................           ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                "
+};
+
+/* Copyright (c) Julian Smart */
+static const char *question_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 21 1",
+". c Black",
+"> c #696969",
+"O c #1F1F00",
+"+ c #181818",
+"o c #F6F900",
+"; c #3F3F00",
+"$ c #111111",
+"  c None",
+"& c #202020",
+"X c #AAAA00",
+"@ c #949400",
+": c #303030",
+"1 c #383838",
+"% c #2A2A00",
+", c #404040",
+"= c #B4B400",
+"- c #484848",
+"# c #151500",
+"< c #9F9F00",
+"2 c #6A6A00",
+"* c #353500",
+/* pixels */
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                   .........                    ",
+"                 ...XXXXXXX..                   ",
+"               ..XXXXoooooXXXO+                 ",
+"             ..XXooooooooooooX@..               ",
+"            ..XoooooooooooooooXX#.              ",
+"           $%XoooooooooooooooooXX#.             ",
+"          &.XoooooooXXXXXXooooooXX..            ",
+"          .XooooooXX.$...$XXoooooX*.            ",
+"         $.XoooooX%.$     .*oooooo=..           ",
+"         .XooooooX..      -.XoooooX..           ",
+"         .XoooooX..+       .XoooooX;.           ",
+"         ...XXXX..:        .XoooooX;.           ",
+"          ........        >.XoooooX;.           ",
+"                          +.XoooooX..           ",
+"                         ,.Xoooooo<..           ",
+"                        1#XooooooXO..           ",
+"                       &#XooooooX2..            ",
+"                      $%XooooooXX..             ",
+"                     $%XooooooXX..              ",
+"                    $%XooooooXX..               ",
+"                   &.XooooooXX..                ",
+"                   .XooooooXX..                 ",
+"                  &.XoooooXX..                  ",
+"                  ..XooooXX..                   ",
+"                  ..XooooX...                   ",
+"                  ..XXooXX..&                   ",
+"                  ...XXXXX..                    ",
+"                   ........                     ",
+"                                                ",
+"                                                ",
+"                   .......                      ",
+"                  ..XXXXX..                     ",
+"                 ..XXoooXX..                    ",
+"                 ..XoooooX..                    ",
+"                 ..XoooooX..                    ",
+"                 ..XXoooXX..                    ",
+"                  ..XXXXX..                     ",
+"                   .......                      ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                "
+};
+
+wxBitmap wxGTKArtProvider::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;
+}
+
+

 // ============================================================================
 // wxInputHandler
 // ============================================================================
 // ============================================================================
 // wxInputHandler
 // ============================================================================


@@ -2352,51 +3336,53 @@ wxGTKInputHandler::wxGTKInputHandler(wxGTKRenderer *renderer)
     m_renderer = renderer;
 }
 
     m_renderer = renderer;
 }
 

-bool wxGTKInputHandler::HandleKey(wxControl *control,
-                                  const wxKeyEvent& event,
-                                  bool pressed)
+bool wxGTKInputHandler::HandleKey(wxInputConsumer * WXUNUSED(control),
+                                  const wxKeyEvent& WXUNUSED(event),
+                                  bool WXUNUSED(pressed))

 {
 {

-    return FALSE;
+    return false;

 }
 
 }
 

-bool wxGTKInputHandler::HandleMouse(wxControl *control,
+bool wxGTKInputHandler::HandleMouse(wxInputConsumer *control,

                                     const wxMouseEvent& event)
 {
     // clicking on the control gives it focus
                                     const wxMouseEvent& event)
 {
     // clicking on the control gives it focus

-    if ( event.ButtonDown() && wxWindow::FindFocus() != control )
+    if ( event.ButtonDown() && wxWindow::FindFocus() != control->GetInputWindow() )

     {
     {

-        control->SetFocus();
+        control->GetInputWindow()->SetFocus();

 
 

-        return TRUE;
+        return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 }
 

-bool wxGTKInputHandler::HandleMouseMove(wxControl *control,
+bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,

                                         const wxMouseEvent& event)
 {
     if ( event.Entering() )
     {
                                         const wxMouseEvent& event)
 {
     if ( event.Entering() )
     {

-        control->SetCurrent(TRUE);
+        control->GetInputWindow()->SetCurrent(true);

     }
     else if ( event.Leaving() )
     {
     }
     else if ( event.Leaving() )
     {

-        control->SetCurrent(FALSE);
+        control->GetInputWindow()->SetCurrent(false);

     }
     else
     {
     }
     else
     {

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

+#if wxUSE_CHECKBOX
+

 // ----------------------------------------------------------------------------
 // wxGTKCheckboxInputHandler
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxGTKCheckboxInputHandler
 // ----------------------------------------------------------------------------
 

-bool wxGTKCheckboxInputHandler::HandleKey(wxControl *control,
+bool wxGTKCheckboxInputHandler::HandleKey(wxInputConsumer *control,

                                           const wxKeyEvent& event,
                                           bool pressed)
 {
                                           const wxKeyEvent& event,
                                           bool pressed)
 {


@@ -2407,18 +3393,22 @@ bool wxGTKCheckboxInputHandler::HandleKey(wxControl *control,
         {
             control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
 
         {
             control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 }
 

+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_TEXTCTRL
+

 // ----------------------------------------------------------------------------
 // wxGTKTextCtrlInputHandler
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxGTKTextCtrlInputHandler
 // ----------------------------------------------------------------------------
 

-bool wxGTKTextCtrlInputHandler::HandleKey(wxControl *control,
+bool wxGTKTextCtrlInputHandler::HandleKey(wxInputConsumer *control,

                                           const wxKeyEvent& event,
                                           bool pressed)
 {
                                           const wxKeyEvent& event,
                                           bool pressed)
 {


@@ -2501,9 +3491,11 @@ bool wxGTKTextCtrlInputHandler::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);
 }

+
+#endif // wxUSE_TEXTCTRL