Add default constructor to wxGraphicsGradientStop.

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

diff --git a/src/univ/themes/gtk.cpp b/src/univ/themes/gtk.cpp
index e385744196aba7507769d7e6239830fe7a63cb58..35d3924f79f1c4fdefd25f0a7049b8da5b02ec44 100644 (file)
--- a/src/univ/themes/gtk.cpp
+++ b/src/univ/themes/gtk.cpp
@@ -24,10 +24,15 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#include "wx/univ/theme.h"
+
+#if wxUSE_THEME_GTK
+

 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/dcmemory.h"
 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/dcmemory.h"

+    #include "wx/dcclient.h"

     #include "wx/window.h"
 
     #include "wx/menu.h"
     #include "wx/window.h"
 
     #include "wx/menu.h"


@@ -45,84 +50,59 @@
     #include "wx/statusbr.h"
 
     #include "wx/settings.h"
     #include "wx/statusbr.h"
 
     #include "wx/settings.h"

+    #include "wx/toplevel.h"
+    #include "wx/image.h"

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

-#include "wx/toplevel.h"

 #include "wx/artprov.h"
 #include "wx/artprov.h"

-#include "wx/image.h"

 #ifdef wxUSE_TOGGLEBTN
 #include "wx/tglbtn.h"
 #endif // wxUSE_TOGGLEBTN
 
 #ifdef wxUSE_TOGGLEBTN
 #include "wx/tglbtn.h"
 #endif // wxUSE_TOGGLEBTN
 

-#include "wx/univ/renderer.h"
+#include "wx/univ/stdrend.h"
+#include "wx/univ/inpcons.h"

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

-#include "wx/univ/theme.h"

 
 

-class WXDLLEXPORT wxGTKMenuGeometryInfo;
+class wxGTKMenuGeometryInfo;

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

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

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-static const size_t BORDER_THICKNESS = 1;
+// standard border size
+static const int BORDER_THICKNESS = 2;

 
 // ----------------------------------------------------------------------------
 // wxGTKRenderer: draw the GUI elements in GTK style
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxGTKRenderer: draw the GUI elements in GTK style
 // ----------------------------------------------------------------------------
 

-class wxGTKRenderer : public wxRenderer
+class wxGTKRenderer : public wxStdRenderer

 {
 public:
     wxGTKRenderer(const wxColourScheme *scheme);
 
 {
 public:
     wxGTKRenderer(const wxColourScheme *scheme);
 

-    // implement the base class pure virtuals
-    virtual void DrawBackground(wxDC& dc,
-                                const wxColour& col,
+    // wxRenderer methods
+    virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);
+    virtual void DrawTextBorder(wxDC& dc,
+                                wxBorder border,

                                 const wxRect& rect,
                                 int flags = 0,
                                 const wxRect& rect,
                                 int flags = 0,

-                                wxWindow *window = NULL );
-    virtual void DrawLabel(wxDC& dc,
-                           const wxString& label,
-                           const wxRect& rect,
-                           int flags = 0,
-                           int alignment = wxALIGN_LEFT | wxALIGN_TOP,
-                           int indexAccel = -1,
-                           wxRect *rectBounds = NULL);
+                                wxRect *rectIn = NULL);

     virtual void DrawButtonLabel(wxDC& dc,
                                  const wxString& label,
                                  const wxBitmap& image,
                                  const wxRect& rect,
     virtual void DrawButtonLabel(wxDC& dc,
                                  const wxString& label,
                                  const wxBitmap& image,
                                  const wxRect& rect,

-                                 int flags = 0,
-                                 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
-                                 int indexAccel = -1,
-                                 wxRect *rectBounds = NULL);
-    virtual void DrawBorder(wxDC& dc,
-                            wxBorder border,
-                            const wxRect& rect,
-                            int flags = 0,
-                            wxRect *rectIn = (wxRect *)NULL);
-    virtual void DrawHorizontalLine(wxDC& dc,
-                                    wxCoord y, wxCoord x1, wxCoord x2);
-    virtual void DrawVerticalLine(wxDC& dc,
-                                  wxCoord x, wxCoord y1, wxCoord y2);
-    virtual void DrawFrame(wxDC& dc,
-                           const wxString& label,
-                           const wxRect& rect,
-                           int flags = 0,
-                           int alignment = wxALIGN_LEFT,
-                           int indexAccel = -1);
-    virtual void DrawTextBorder(wxDC& dc,
-                                wxBorder border,
-                                const wxRect& rect,
-                                int flags = 0,
-                                wxRect *rectIn = (wxRect *)NULL);
+                                 int flags,
+                                 int alignment,
+                                 int indexAccel,
+                                 wxRect *rectBounds);

     virtual void DrawButtonBorder(wxDC& dc,
                                   const wxRect& rect,
                                   int flags = 0,
     virtual void DrawButtonBorder(wxDC& dc,
                                   const wxRect& rect,
                                   int flags = 0,

-                                  wxRect *rectIn = (wxRect *)NULL);
+                                  wxRect *rectIn = NULL);

     virtual void DrawArrow(wxDC& dc,
                            wxDirection dir,
                            const wxRect& rect,
     virtual void DrawArrow(wxDC& dc,
                            wxDirection dir,
                            const wxRect& rect,


@@ -139,32 +119,6 @@ public:
                                     wxOrientation orient,
                                     const wxRect& rect,
                                     int flags = 0);
                                     wxOrientation orient,
                                     const wxRect& rect,
                                     int flags = 0);

-    virtual void DrawScrollCorner(wxDC& dc,
-                                  const wxRect& rect);
-    virtual void DrawItem(wxDC& dc,
-                          const wxString& label,
-                          const wxRect& rect,
-                          int flags = 0);
-    virtual void DrawCheckItem(wxDC& dc,
-                               const wxString& label,
-                               const wxBitmap& bitmap,
-                               const wxRect& rect,
-                               int flags = 0);
-    virtual void DrawCheckButton(wxDC& dc,
-                                 const wxString& label,
-                                 const wxBitmap& bitmap,
-                                 const wxRect& rect,
-                                 int flags = 0,
-                                 wxAlignment align = wxALIGN_LEFT,
-                                 int indexAccel = -1);
-
-    virtual void DrawRadioButton(wxDC& dc,
-                                 const wxString& label,
-                                 const wxBitmap& bitmap,
-                                 const wxRect& rect,
-                                 int flags = 0,
-                                 wxAlignment align = wxALIGN_LEFT,
-                                 int indexAccel = -1);

 
 #if wxUSE_TOOLBAR
     virtual void DrawToolBarButton(wxDC& dc,
 
 #if wxUSE_TOOLBAR
     virtual void DrawToolBarButton(wxDC& dc,


@@ -176,13 +130,11 @@ public:
                                    int tbarStyle = 0);
 #endif // wxUSE_TOOLBAR
 
                                    int tbarStyle = 0);
 #endif // wxUSE_TOOLBAR
 

-    virtual void DrawTextLine(wxDC& dc,
-                              const wxString& text,
-                              const wxRect& rect,
-                              int selStart = -1,
-                              int selEnd = -1,
-                              int flags = 0);
+#if wxUSE_TEXTCTRL

     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);

+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_NOTEBOOK

     virtual void DrawTab(wxDC& dc,
                          const wxRect& rect,
                          wxDirection dir,
     virtual void DrawTab(wxDC& dc,
                          const wxRect& rect,
                          wxDirection dir,


@@ -190,6 +142,7 @@ public:
                          const wxBitmap& bitmap = wxNullBitmap,
                          int flags = 0,
                          int indexAccel = -1);
                          const wxBitmap& bitmap = wxNullBitmap,
                          int flags = 0,
                          int indexAccel = -1);

+#endif // wxUSE_NOTEBOOK

 
 #if wxUSE_SLIDER
     virtual void DrawSliderShaft(wxDC& dc,
 
 #if wxUSE_SLIDER
     virtual void DrawSliderShaft(wxDC& dc,


@@ -237,72 +190,19 @@ public:
                                    const wxMenuGeometryInfo& geomInfo);
 #endif // wxUSE_MENUS
 
                                    const wxMenuGeometryInfo& geomInfo);
 #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,
                                  wxBitmap *bmpDisabled);
 
     virtual void AdjustSize(wxSize *size, const wxWindow *window);
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
                                  wxBitmap *bmpPressed,
                                  wxBitmap *bmpDisabled);
 
     virtual void AdjustSize(wxSize *size, const wxWindow *window);

-    virtual wxRect GetBorderDimensions(wxBorder border) const;
-    virtual bool AreScrollbarsInsideBorder() const;

 
     // geometry and hit testing
 
     // geometry and hit testing

+#if wxUSE_SCROLLBAR

     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }
     virtual wxSize GetScrollbarArrowSize() const
         { return m_sizeScrollbarArrow; }

-#if wxUSE_SCROLLBAR
-    virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
-                                    wxScrollBar::Element elem,
-                                    int thumbPos = -1) const;
-    virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
-    virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
-                                       const wxPoint& pt) const;
-    virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
-                                     int thumbPos = -1);
-    virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);

 #endif // wxUSE_SCROLLBAR
 
 #endif // wxUSE_SCROLLBAR
 

-    virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
-        { return fontHeight + 2; }

     virtual wxSize GetCheckBitmapSize() const
         { return wxSize(10, 10); }
     virtual wxSize GetRadioBitmapSize() const
     virtual wxSize GetCheckBitmapSize() const
         { return wxSize(10, 10); }
     virtual wxSize GetRadioBitmapSize() const


@@ -310,21 +210,23 @@ public:
     virtual wxCoord GetCheckItemMargin() const
         { return 2; }
 
     virtual wxCoord GetCheckItemMargin() const
         { return 2; }
 

+#if wxUSE_TOOLBAR

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

+#endif // wxUSE_TOOLBAR

 
 #if wxUSE_TEXTCTRL
 
 #if wxUSE_TEXTCTRL

-    virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rect) const;

     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
                                      wxCoord *extraSpaceBeyond) const;
 #endif // wxUSE_TEXTCTRL
 
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
                                      wxCoord *extraSpaceBeyond) const;
 #endif // wxUSE_TEXTCTRL
 

+#if wxUSE_NOTEBOOK

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

+#endif // wxUSE_NOTEBOOK

 
 #if wxUSE_SLIDER
     virtual wxCoord GetSliderDim() const { return 15; }
 
 #if wxUSE_SLIDER
     virtual wxCoord GetSliderDim() const { return 15; }


@@ -346,17 +248,27 @@ public:
                                                 const wxMenu& menu) const;
 #endif // wxUSE_MENUS
 
                                                 const wxMenu& menu) const;
 #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);
     void DrawUndeterminedBitmap(wxDC& dc, const wxRect& rect, bool isPressed);
 
 protected:
     // 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
+    // overridden wxStdRenderer methods
+    virtual void DrawSunkenBorder(wxDC& dc, wxRect *rect);
+
+    virtual void DrawFrameWithLabel(wxDC& dc,
+                                    const wxString& label,
+                                    const wxRect& rectFrame,
+                                    const wxRect& rectText,
+                                    int flags,
+                                    int alignment,
+                                    int indexAccel);
+
+    virtual void DrawCheckItemBitmap(wxDC& dc,
+                                     const wxBitmap& bitmap,
+                                     const wxRect& rect,
+                                     int flags);

 
     // get the colour to use for background
     wxColour GetBackgroundColour(int flags) const
 
     // get the colour to use for background
     wxColour GetBackgroundColour(int flags) const


@@ -369,26 +281,6 @@ protected:
             return wxSCHEME_COLOUR(m_scheme, CONTROL);
     }
 
             return wxSCHEME_COLOUR(m_scheme, CONTROL);
     }
 

-    // draw the background with any colour, not only the default one(s)
-    void DoDrawBackground(wxDC& dc,
-                          const wxColour& col,
-                          const wxRect& rect,
-                          wxWindow *window = NULL);
-
-    // DrawBorder() helpers: all of them shift and clip the DC after drawing
-    // the border
-
-    // just draw a rectangle with the given pen
-    void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
-    // draw the lower left part of rectangle
-    void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
-
-    // draw the rectange using the first brush for the left and top sides and
-    // the second one for the bottom and right ones
-    void DrawShadedRect(wxDC& dc, wxRect *rect,
-                        const wxPen& pen1, const wxPen& pen2);
-

     // as DrawShadedRect() but the pixels in the bottom left and upper right
     // border are drawn with the pen1, not pen2
     void DrawAntiShadedRect(wxDC& dc, wxRect *rect,
     // as DrawShadedRect() but the pixels in the bottom left and upper right
     // border are drawn with the pen1, not pen2
     void DrawAntiShadedRect(wxDC& dc, wxRect *rect,


@@ -412,41 +304,19 @@ protected:
                          wxRect *rect,
                          wxOrientation orient);
 
                          wxRect *rect,
                          wxOrientation orient);
 

-    // draw the normal 3D border
-    void DrawRaisedBorder(wxDC& dc, wxRect *rect);
-

     // just as DrawRaisedBorder() except that the bottom left and up right
     // pixels of the interior rect are drawn in another colour (i.e. the inner
     // rect is drawn with DrawAntiShadedRect() and not DrawShadedRect())
     void DrawAntiRaisedBorder(wxDC& dc, wxRect *rect);
 
     // just as DrawRaisedBorder() except that the bottom left and up right
     // pixels of the interior rect are drawn in another colour (i.e. the inner
     // 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
-    {
-        wxSize size;
-        if ( scrollbar->IsVertical() )
-        {
-            size = m_sizeScrollbarArrow;
-        }
-        else
-        {
-            size.x = m_sizeScrollbarArrow.y;
-            size.y = m_sizeScrollbarArrow.x;
-        }
-
-        return size;
-    }
-#endif // wxUSE_SCROLLBAR
+    // draw inner GTK shadow
+    void DrawInnerShadedRect(wxDC& dc, wxRect *rect);

 
     // get the line wrap indicator bitmap
     wxBitmap GetLineWrapBitmap() const;
 
 
     // get the line wrap indicator bitmap
     wxBitmap GetLineWrapBitmap() const;
 

-    // DrawCheckBitmap and DrawRadioBitmap helpers
-
-    // draw the check bitmaps once and cache them for later use
-    wxBitmap GetCheckBitmap(int flags);
+    virtual wxBitmap GetCheckBitmap(int flags);
+    virtual wxBitmap GetRadioBitmap(int flags);

 
     // draw a /\ or \/ line from (x1, y1) to (x2, y1) passing by the point
     // ((x1 + x2)/2, y2)
 
     // draw a /\ or \/ line from (x1, y1) to (x2, y1) passing by the point
     // ((x1 + x2)/2, y2)


@@ -458,16 +328,7 @@ protected:
                      wxCoord y1, wxCoord y2);
 
     // draw the radio button bitmap for the given state
                      wxCoord y1, wxCoord y2);
 
     // draw the radio button bitmap for the given state

-    void DrawRadioBitmap(wxDC& dc, const wxRect& rect, int flags);
-
-    // draw check/radio - the bitmap must be a valid one by now
-    void DoDrawCheckOrRadioBitmap(wxDC& dc,
-                                  const wxString& label,
-                                  const wxBitmap& bitmap,
-                                  const wxRect& rectTotal,
-                                  int flags,
-                                  wxAlignment align,
-                                  int indexAccel);
+    void DrawRadioButtonBitmap(wxDC& dc, const wxRect& rect, int flags);

 
     // common part of DrawMenuItem() and DrawMenuBarItem()
     void DoDrawMenuItem(wxDC& dc,
 
     // common part of DrawMenuItem() and DrawMenuBarItem()
     void DoDrawMenuItem(wxDC& dc,


@@ -482,23 +343,23 @@ protected:
     // initialize the combo bitmaps
     void InitComboBitmaps();
 
     // initialize the combo bitmaps
     void InitComboBitmaps();
 

-private:
-    const wxColourScheme *m_scheme;
+    virtual wxBitmap GetFrameButtonBitmap(FrameButtonType WXUNUSED(type))
+    {
+        return wxNullBitmap;
+    }

 
 

+private:

     // data
     wxSize m_sizeScrollbarArrow;
 
     // GDI objects
     // data
     wxSize m_sizeScrollbarArrow;
 
     // GDI objects

-    wxPen m_penBlack,
-          m_penDarkGrey,
-          m_penGrey,
-          m_penLightGrey,
-          m_penHighlight;
+    wxPen m_penGrey;

 
 

-    // the checkbox bitmaps: first row is for the normal, second for the
-    // pressed state and the columns are for checked, unchecked and
-    // undeterminated respectively
-    wxBitmap m_bitmapsCheckbox[2][3];
+    // the checkbox and radio button bitmaps: first row is for the normal,
+    // second for the pressed state and the columns are for checked, unchecked
+    // and undeterminated respectively
+    wxBitmap m_bitmapsCheckbox[IndicatorState_MaxCtrl][IndicatorStatus_Max],
+             m_bitmapsRadiobtn[IndicatorState_MaxCtrl][IndicatorStatus_Max];

 
     // 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;


@@ -524,17 +385,15 @@ private:
 class wxGTKInputHandler : public wxInputHandler
 {
 public:
 class wxGTKInputHandler : public wxInputHandler
 {
 public:

-    wxGTKInputHandler(wxGTKRenderer *renderer);
+    wxGTKInputHandler() { }

 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
                            bool pressed);
     virtual bool HandleMouse(wxInputConsumer *control,
                              const wxMouseEvent& event);

-    virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
-
-protected:
-    wxGTKRenderer *m_renderer;
+    virtual bool HandleMouseMove(wxInputConsumer *control,
+                                 const wxMouseEvent& event);

 };
 
 #if wxUSE_SCROLLBAR
 };
 
 #if wxUSE_SCROLLBAR


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

-    virtual bool IsAllowedButton(int WXUNUSED(button)) { return true; }
+    // any button can be used to drag the scrollbar under GTK+
+    virtual bool IsAllowedButton(int WXUNUSED(button)) const { return true; }

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


@@ -577,11 +437,11 @@ protected:
 
 #if wxUSE_CHECKBOX
 
 
 #if wxUSE_CHECKBOX
 

-class wxGTKCheckboxInputHandler : public wxStdCheckboxInputHandler
+class wxGTKCheckboxInputHandler : public wxStdInputHandler

 {
 public:
     wxGTKCheckboxInputHandler(wxInputHandler *handler)
 {
 public:
     wxGTKCheckboxInputHandler(wxInputHandler *handler)

-        : wxStdCheckboxInputHandler(handler) { }
+        : wxStdInputHandler(handler) { }

 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,


@@ -592,11 +452,11 @@ public:
 
 #if wxUSE_TEXTCTRL
 
 
 #if wxUSE_TEXTCTRL
 

-class wxGTKTextCtrlInputHandler : public wxStdTextCtrlInputHandler
+class wxGTKTextCtrlInputHandler : public wxStdInputHandler

 {
 public:
     wxGTKTextCtrlInputHandler(wxInputHandler *handler)
 {
 public:
     wxGTKTextCtrlInputHandler(wxInputHandler *handler)

-        : wxStdTextCtrlInputHandler(handler) { }
+        : wxStdInputHandler(handler) { }

 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,
 
     virtual bool HandleKey(wxInputConsumer *control,
                            const wxKeyEvent& event,


@@ -642,13 +502,11 @@ public:
 
     virtual wxRenderer *GetRenderer();
     virtual wxArtProvider *GetArtProvider();
 
     virtual wxRenderer *GetRenderer();
     virtual wxArtProvider *GetArtProvider();

-    virtual wxInputHandler *GetInputHandler(const wxString& control);
+    virtual wxInputHandler *GetInputHandler(const wxString& control,
+                                            wxInputConsumer *consumer);

     virtual wxColourScheme *GetColourScheme();
 
 private:
     virtual wxColourScheme *GetColourScheme();
 
 private:

-    // get the default input handler
-    wxInputHandler *GetDefaultInputHandler();
-

     wxGTKRenderer *m_renderer;
 
     wxGTKArtProvider *m_artProvider;
     wxGTKRenderer *m_renderer;
 
     wxGTKArtProvider *m_artProvider;


@@ -658,8 +516,6 @@ private:
     wxSortedArrayString m_handlerNames;
     wxArrayHandlers m_handlers;
 
     wxSortedArrayString m_handlerNames;
     wxArrayHandlers m_handlers;
 

-    wxGTKInputHandler *m_handlerDefault;
-

     wxGTKColourScheme *m_scheme;
 
     WX_DECLARE_THEME(gtk)
     wxGTKColourScheme *m_scheme;
 
     WX_DECLARE_THEME(gtk)


@@ -679,23 +535,14 @@ wxGTKTheme::wxGTKTheme()
 {
     m_scheme = NULL;
     m_renderer = NULL;
 {
     m_scheme = NULL;
     m_renderer = NULL;

-    m_handlerDefault = NULL;

     m_artProvider = NULL;
 }
 
 wxGTKTheme::~wxGTKTheme()
 {
     m_artProvider = NULL;
 }
 
 wxGTKTheme::~wxGTKTheme()
 {

-    size_t count = m_handlers.GetCount();
-    for ( size_t n = 0; n < count; n++ )
-    {
-        if ( m_handlers[n] != m_handlerDefault )
-            delete m_handlers[n];
-    }
-
-    delete m_handlerDefault;

     delete m_renderer;
     delete m_scheme;
     delete m_renderer;
     delete m_scheme;

-    wxArtProvider::RemoveProvider(m_artProvider);
+    delete m_artProvider;

 }
 
 wxRenderer *wxGTKTheme::GetRenderer()
 }
 
 wxRenderer *wxGTKTheme::GetRenderer()


@@ -727,75 +574,50 @@ wxColourScheme *wxGTKTheme::GetColourScheme()
     return m_scheme;
 }
 
     return m_scheme;
 }
 

-wxInputHandler *wxGTKTheme::GetDefaultInputHandler()
-{
-    if ( !m_handlerDefault )
-    {
-        m_handlerDefault = new wxGTKInputHandler(m_renderer);
-    }
-
-    return m_handlerDefault;
-}
-
-wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control)
+wxInputHandler *wxGTKTheme::GetInputHandler(const wxString& control,
+                                            wxInputConsumer *consumer)

 {
     wxInputHandler *handler = NULL;
     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {
 {
     wxInputHandler *handler = NULL;
     int n = m_handlerNames.Index(control);
     if ( n == wxNOT_FOUND )
     {

+        static wxGTKInputHandler s_handlerDef;
+
+        wxInputHandler * const
+          handlerStd = consumer->DoGetStdInputHandler(&s_handlerDef);
+

         // create a new handler
         // create a new handler

-        if ( control == wxINP_HANDLER_SCROLLBAR )
+#if wxUSE_CHECKBOX
+        if ( control == wxINP_HANDLER_CHECKBOX )

         {
         {

-#if wxUSE_SCROLLBAR
-            handler = new wxGTKScrollBarInputHandler(m_renderer,
-                                                     GetDefaultInputHandler());
-#endif // wxUSE_SCROLLBAR
+            static wxGTKCheckboxInputHandler s_handler(handlerStd);
+
+            handler = &s_handler;

         }
         }

-#if wxUSE_BUTTON
-        else if ( control == wxINP_HANDLER_BUTTON )
-            handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_CHECKBOX
-#if wxUSE_CHECKBOX
-        else if ( control == wxINP_HANDLER_CHECKBOX )
-            handler = new wxGTKCheckboxInputHandler(GetDefaultInputHandler());
+        else

 #endif // wxUSE_CHECKBOX
 #endif // wxUSE_CHECKBOX

-#if wxUSE_COMBOBOX
-        else if ( control == wxINP_HANDLER_COMBOBOX )
-            handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_COMBOBOX
-#if wxUSE_LISTBOX
-        else if ( control == wxINP_HANDLER_LISTBOX )
-            handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_LISTBOX
-#if wxUSE_CHECKLISTBOX
-        else if ( control == wxINP_HANDLER_CHECKLISTBOX )
-            handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_CHECKLISTBOX
+#if wxUSE_SCROLLBAR
+        if ( control == wxINP_HANDLER_SCROLLBAR )
+        {
+            static wxGTKScrollBarInputHandler s_handler(m_renderer, handlerStd);
+
+            handler = &s_handler;
+        }
+        else
+#endif // wxUSE_SCROLLBAR

 #if wxUSE_TEXTCTRL
 #if wxUSE_TEXTCTRL

-        else if ( control == wxINP_HANDLER_TEXTCTRL )
-            handler = new wxGTKTextCtrlInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_TEXTCTRL
-#if wxUSE_SLIDER
-        else if ( control == wxINP_HANDLER_SLIDER )
-            handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SLIDER
-#if wxUSE_SPINBTN
-        else if ( control == wxINP_HANDLER_SPINBTN )
-            handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_SPINBTN
-#if wxUSE_NOTEBOOK
-        else if ( control == wxINP_HANDLER_NOTEBOOK )
-            handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
-#endif // wxUSE_NOTEBOOK
-#if wxUSE_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 ( control == wxINP_HANDLER_TEXTCTRL )
+        {
+            static wxGTKTextCtrlInputHandler s_handler(handlerStd);

 
 

-        if(!handler)
-            handler = GetDefaultInputHandler();
+            handler = &s_handler;
+        }
+        else
+#endif // wxUSE_TEXTCTRL
+        {
+            // no special handler for this control
+            handler = handlerStd;
+        }

 
         n = m_handlerNames.Add(control);
         m_handlers.Insert(handler, n);
 
         n = m_handlerNames.Add(control);
         m_handlers.Insert(handler, n);


@@ -858,6 +680,7 @@ wxColour wxGTKColourScheme::Get(wxGTKColourScheme::StdColour col) const
 {
     switch ( col )
     {
 {
     switch ( col )
     {

+        case FRAME:

         case WINDOW:            return *wxWHITE;
 
         case SHADOW_DARK:       return *wxBLACK;
         case WINDOW:            return *wxWHITE;
 
         case SHADOW_DARK:       return *wxBLACK;


@@ -893,7 +716,7 @@ wxColour wxGTKColourScheme::Get(wxGTKColourScheme::StdColour col) const
 
         case MAX:
         default:
 
         case MAX:
         default:

-            wxFAIL_MSG(_T("invalid standard colour"));
+            wxFAIL_MSG(wxT("invalid standard colour"));

             return *wxBLACK;
     }
 }
             return *wxBLACK;
     }
 }


@@ -907,67 +730,17 @@ wxColour wxGTKColourScheme::Get(wxGTKColourScheme::StdColour col) const
 // ----------------------------------------------------------------------------
 
 wxGTKRenderer::wxGTKRenderer(const wxColourScheme *scheme)
 // ----------------------------------------------------------------------------
 
 wxGTKRenderer::wxGTKRenderer(const wxColourScheme *scheme)

+             : wxStdRenderer(scheme)

 {
 {

-    // init data
-    m_scheme = scheme;

     m_sizeScrollbarArrow = wxSize(15, 14);
 
     m_sizeScrollbarArrow = wxSize(15, 14);
 

-    // init pens
-    m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
-    m_penDarkGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT), 0, wxSOLID);
-    m_penGrey = wxPen(wxSCHEME_COLOUR(scheme, SCROLLBAR), 0, wxSOLID);
-    m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
-    m_penHighlight = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT), 0, wxSOLID);
+    m_penGrey = wxPen(wxSCHEME_COLOUR(scheme, SCROLLBAR));

 }
 
 // ----------------------------------------------------------------------------
 // border stuff
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // border stuff
 // ----------------------------------------------------------------------------
 

-void wxGTKRenderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
-{
-    // draw
-    dc.SetPen(pen);
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
-    dc.DrawRectangle(*rect);
-
-    // adjust the rect
-    rect->Inflate(-1);
-}
-
-void wxGTKRenderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
-{
-    // draw the bottom and right sides
-    dc.SetPen(pen);
-    dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
-                rect->GetRight() + 1, rect->GetBottom());
-    dc.DrawLine(rect->GetRight(), rect->GetTop(),
-                rect->GetRight(), rect->GetBottom());
-
-    // adjust the rect
-    rect->width--;
-    rect->height--;
-}
-
-void wxGTKRenderer::DrawShadedRect(wxDC& dc, wxRect *rect,
-                                   const wxPen& pen1, const wxPen& pen2)
-{
-    // draw the rectangle
-    dc.SetPen(pen1);
-    dc.DrawLine(rect->GetLeft(), rect->GetTop(),
-                rect->GetLeft(), rect->GetBottom());
-    dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
-                rect->GetRight(), rect->GetTop());
-    dc.SetPen(pen2);
-    dc.DrawLine(rect->GetRight(), rect->GetTop(),
-                rect->GetRight(), rect->GetBottom());
-    dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
-                rect->GetRight() + 1, rect->GetBottom());
-
-    // adjust the rect
-    rect->Inflate(-1);
-}
-

 void wxGTKRenderer::DrawAntiShadedRectSide(wxDC& dc,
                                            const wxRect& rect,
                                            const wxPen& pen1,
 void wxGTKRenderer::DrawAntiShadedRectSide(wxDC& dc,
                                            const wxRect& rect,
                                            const wxPen& pen1,


@@ -999,7 +772,7 @@ void wxGTKRenderer::DrawAntiShadedRectSide(wxDC& dc,
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("unknown rectangle side"));
+            wxFAIL_MSG(wxT("unknown rectangle side"));

     }
 }
 
     }
 }
 


@@ -1022,10 +795,10 @@ void wxGTKRenderer::DrawAntiShadedRect(wxDC& dc, wxRect *rect,
     rect->Inflate(-1);
 }
 
     rect->Inflate(-1);
 }
 

-void wxGTKRenderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
+void wxGTKRenderer::DrawInnerShadedRect(wxDC& dc, wxRect *rect)

 {
 {

-    DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
-    DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
+    DrawAntiShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
+    DrawAntiShadedRect(dc, rect, m_penBlack, m_penHighlight);

 }
 
 void wxGTKRenderer::DrawAntiRaisedBorder(wxDC& dc, wxRect *rect)
 }
 
 void wxGTKRenderer::DrawAntiRaisedBorder(wxDC& dc, wxRect *rect)


@@ -1034,117 +807,20 @@ void wxGTKRenderer::DrawAntiRaisedBorder(wxDC& dc, wxRect *rect)
     DrawAntiShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
 }
 
     DrawAntiShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
 }
 

-void wxGTKRenderer::DrawBorder(wxDC& dc,
-                               wxBorder border,
-                               const wxRect& rectTotal,
-                               int WXUNUSED(flags),
-                               wxRect *rectIn)
+void wxGTKRenderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)

 {
 {

-    size_t width;
-
-    wxRect rect = rectTotal;
-
-    switch ( border )
-    {
-        case wxBORDER_SUNKEN:
-            for ( width = 0; width < BORDER_THICKNESS; width++ )
-            {
-                DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
-                DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
-            }
-            break;
-
-        case wxBORDER_STATIC:
-            for ( width = 0; width < BORDER_THICKNESS; width++ )
-            {
-                DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
-            }
-            break;
-
-        case wxBORDER_RAISED:
-            for ( width = 0; width < BORDER_THICKNESS; width++ )
-            {
-                DrawRaisedBorder(dc, &rect);
-            }
-            break;
-
-        case wxBORDER_DOUBLE:
-            for ( width = 0; width < BORDER_THICKNESS; width++ )
-            {
-                DrawShadedRect(dc, &rect, m_penLightGrey, m_penBlack);
-                DrawShadedRect(dc, &rect, m_penHighlight, m_penDarkGrey);
-                DrawRect(dc, &rect, m_penLightGrey);
-            }
-            break;
-
-        case wxBORDER_SIMPLE:
-            for ( width = 0; width < BORDER_THICKNESS; width++ )
-            {
-                DrawRect(dc, &rect, m_penBlack);
-            }
-            break;
-
-        default:
-            wxFAIL_MSG(_T("unknown border type"));
-            // fall through
-
-        case wxBORDER_DEFAULT:
-        case wxBORDER_NONE:
-            break;
-    }
-
-    if ( rectIn )
-        *rectIn = rect;
+    DrawAntiShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
+    DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);

 }
 
 }
 

-wxRect wxGTKRenderer::GetBorderDimensions(wxBorder border) const
+void
+wxGTKRenderer::DrawFocusRect(wxWindow* WXUNUSED(win), wxDC& dc, const wxRect& rect, int WXUNUSED(flags))

 {
 {

-    wxCoord width;
-    switch ( border )
-    {
-        case wxBORDER_RAISED:
-        case wxBORDER_SUNKEN:
-            width = 2*BORDER_THICKNESS;
-            break;
-
-        case wxBORDER_SIMPLE:
-        case wxBORDER_STATIC:
-            width = BORDER_THICKNESS;
-            break;
-
-        case wxBORDER_DOUBLE:
-            width = 3*BORDER_THICKNESS;
-            break;
-
-        default:
-            wxFAIL_MSG(_T("unknown border type"));
-            // fall through
-
-        case wxBORDER_DEFAULT:
-        case wxBORDER_NONE:
-            width = 0;
-            break;
-    }
-
-    wxRect rect;
-    rect.x =
-    rect.y =
-    rect.width =
-    rect.height = width;
-
-    return rect;
-}
-
-bool wxGTKRenderer::AreScrollbarsInsideBorder() const
-{
-    // no, the scrollbars are outside the border in GTK+
-    return false;
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    wxRect rectFocus = rect;
+    DrawRect(dc, &rectFocus, m_penBlack);

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// special borders
-// ----------------------------------------------------------------------------
-

 void wxGTKRenderer::DrawTextBorder(wxDC& dc,
                                    wxBorder border,
                                    const wxRect& rectOrig,
 void wxGTKRenderer::DrawTextBorder(wxDC& dc,
                                    wxBorder border,
                                    const wxRect& rectOrig,


@@ -1162,8 +838,7 @@ void wxGTKRenderer::DrawTextBorder(wxDC& dc,
         }
         else // !focused
         {
         }
         else // !focused
         {

-            DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
-            DrawAntiShadedRect(dc, &rect, m_penBlack, m_penHighlight);
+            DrawInnerShadedRect(dc, &rect);

         }
     }
 
         }
     }
 


@@ -1171,6 +846,20 @@ void wxGTKRenderer::DrawTextBorder(wxDC& dc,
         *rectIn = rect;
 }
 
         *rectIn = rect;
 }
 

+void wxGTKRenderer::DrawButtonLabel(wxDC& dc,
+                                    const wxString& label,
+                                    const wxBitmap& image,
+                                    const wxRect& rect,
+                                    int flags,
+                                    int alignment,
+                                    int indexAccel,
+                                    wxRect *rectBounds)
+{
+    // no focus rect around buttons label in GTK+
+    wxStdRenderer::DrawButtonLabel(dc, label, image, rect, flags,
+                                   alignment, indexAccel, rectBounds);
+}
+

 void wxGTKRenderer::DrawButtonBorder(wxDC& dc,
                                      const wxRect& rectTotal,
                                      int flags,
 void wxGTKRenderer::DrawButtonBorder(wxDC& dc,
                                      const wxRect& rectTotal,
                                      int flags,


@@ -1183,16 +872,10 @@ void wxGTKRenderer::DrawButtonBorder(wxDC& dc,
         // button pressed: draw a black border around it and an inward shade
         DrawRect(dc, &rect, m_penBlack);
 
         // button pressed: draw a black border around it and an inward shade
         DrawRect(dc, &rect, m_penBlack);
 

-        for ( size_t width = 0; width < BORDER_THICKNESS; width++ )
-        {
-            DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
-            DrawAntiShadedRect(dc, &rect, m_penBlack, m_penDarkGrey);
-        }
+        DrawInnerShadedRect(dc, &rect);

     }
     }

-    else
+    else // button not pressed

     {
     {

-        // button not pressed
-

         if ( flags & wxCONTROL_ISDEFAULT )
         {
             // TODO
         if ( flags & wxCONTROL_ISDEFAULT )
         {
             // TODO


@@ -1205,202 +888,55 @@ void wxGTKRenderer::DrawButtonBorder(wxDC& dc,
         }
 
         // now draw a normal button
         }
 
         // now draw a normal button

-        for ( size_t width = 0; width < BORDER_THICKNESS; width++ )
-        {
-            DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
-            DrawAntiShadedRect(dc, &rect,
-                               wxPen(GetBackgroundColour(flags), 0, wxSOLID),
-                               m_penDarkGrey);
-        }
+        DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
+        DrawAntiShadedRect(dc, &rect, GetBackgroundColour(flags), m_penDarkGrey);

     }
 
     if ( rectIn )
     }
 
     if ( rectIn )

-    {

         *rectIn = rect;
         *rectIn = rect;

-    }

 }
 
 // ----------------------------------------------------------------------------
 // lines and frames
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // lines and frames
 // ----------------------------------------------------------------------------
 

-void wxGTKRenderer::DrawHorizontalLine(wxDC& dc,
-                                       wxCoord y, wxCoord x1, wxCoord x2)
-{
-    dc.SetPen(m_penDarkGrey);
-    dc.DrawLine(x1, y, x2 + 1, y);
-    dc.SetPen(m_penHighlight);
-    y++;
-    dc.DrawLine(x1, y, x2 + 1, y);
-}
-
-void wxGTKRenderer::DrawVerticalLine(wxDC& dc,
-                                     wxCoord x, wxCoord y1, wxCoord y2)
+void wxGTKRenderer::DrawFrameWithLabel(wxDC& dc,
+                                       const wxString& label,
+                                       const wxRect& rectFrame,
+                                       const wxRect& rectTextOrig,
+                                       int flags,
+                                       int alignment,
+                                       int indexAccel)

 {
 {

-    dc.SetPen(m_penDarkGrey);
-    dc.DrawLine(x, y1, x, y2 + 1);
-    dc.SetPen(m_penHighlight);
-    x++;
-    dc.DrawLine(x, y1, x, y2 + 1);
-}
-
-void wxGTKRenderer::DrawFrame(wxDC& dc,
-                              const wxString& label,
-                              const wxRect& rect,
-                              int flags,
-                              int alignment,
-                              int indexAccel)
-{
-    wxCoord height = 0; // of the label
-    wxRect rectFrame = rect;
-    if ( !label.empty() )
-    {
-        // the text should touch the top border of the rect, so the frame
-        // itself should be lower
-        dc.GetTextExtent(label, NULL, &height);
-        rectFrame.y += height / 2;
-        rectFrame.height -= height / 2;
+    wxRect rectText(rectTextOrig);
+    rectText.Inflate(1, 0);

 
 

-        // TODO: the +4 should be customizable
-
-        wxRect rectText;
-        rectText.x = rectFrame.x + 4;
-        rectText.y = rect.y;
-        rectText.width = rectFrame.width - 8;
-        rectText.height = height;
-
-        wxRect rectLabel;
-        DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
-        rectLabel.x -= 1;
-        rectLabel.width += 2;
+    wxRect rectLabel;
+    DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
+    rectLabel.x -= 1;
+    rectLabel.width += 2;

 
 

-        StandardDrawFrame(dc, rectFrame, rectLabel);
+    DrawFrameWithoutLabel(dc, rectFrame, rectLabel);

 
 

-        // GTK+ does it like this
-        dc.SetPen(m_penHighlight);
-        dc.DrawPoint(rectText.x, rectFrame.y);
-        dc.DrawPoint(rectText.x + rectLabel.width - 3, rectFrame.y);
-    }
-    else
-    {
-        // just draw the complete frame
-        DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
-        DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
-    }
+    // GTK+ does it like this
+    dc.SetPen(m_penHighlight);
+    dc.DrawPoint(rectText.x, rectFrame.y);
+    dc.DrawPoint(rectText.x + rectLabel.width - 3, rectFrame.y);

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

-// label
+// check/radio buttons

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxGTKRenderer::DrawLabel(wxDC& dc,
-                              const wxString& label,
-                              const wxRect& rect,
-                              int flags,
-                              int alignment,
-                              int indexAccel,
-                              wxRect *rectBounds)
-{
-    DrawButtonLabel(dc, label, wxNullBitmap, rect, flags,
-                    alignment, indexAccel, rectBounds);
-}
-
-void wxGTKRenderer::DrawButtonLabel(wxDC& dc,
-                                    const wxString& label,
-                                    const wxBitmap& image,
-                                    const wxRect& rect,
-                                    int flags,
-                                    int alignment,
-                                    int indexAccel,
-                                    wxRect *rectBounds)
-{
-    if ( flags & wxCONTROL_DISABLED )
-    {
-        // make the text grey and draw a shade for it
-        dc.SetTextForeground(*wxWHITE); // FIXME hardcoded colour
-        wxRect rectShadow = rect;
-        rectShadow.x++;
-        rectShadow.y++;
-        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);
-}
-
-void wxGTKRenderer::DrawItem(wxDC& dc,
-                             const wxString& label,
-                             const wxRect& rect,
-                             int flags)
-{
-    wxLogTrace(_T("listbox"), _T("drawing item '%s' at (%d, %d)-(%d, %d)"),
-               label.c_str(),
-               rect.x, rect.y,
-               rect.x + rect.width, rect.y + rect.height);
-
-    wxColour colFg;
-    if ( flags & wxCONTROL_SELECTED )
-    {
-        dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT), wxSOLID));
-        dc.SetPen(*wxTRANSPARENT_PEN);
-        dc.DrawRectangle(rect);
-
-        colFg = dc.GetTextForeground();
-        dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
-    }
-
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        dc.SetBrush(*wxTRANSPARENT_BRUSH);
-        wxRect rectFocus = rect;
-        DrawRect(dc, &rectFocus, m_penBlack);
-    }
-
-    wxRect rectText = rect;
-    rectText.x += 2;
-    rectText.y++;
-    dc.DrawLabel(label, wxNullBitmap, rectText);
-
-    if ( flags & wxCONTROL_SELECTED )
-    {
-        dc.SetBackgroundMode(wxTRANSPARENT);
-    }
-
-    // restore the text colour
-    if ( colFg.Ok() )
-    {
-        dc.SetTextForeground(colFg);
-    }
-}
-
-void wxGTKRenderer::DrawCheckItem(wxDC& dc,
-                                  const wxString& label,
-                                  const wxBitmap& bitmap,
-                                  const wxRect& rect,
-                                  int flags)
+void wxGTKRenderer::DrawCheckItemBitmap(wxDC& dc,
+                                        const wxBitmap& bitmap,
+                                        const wxRect& rect,
+                                        int flags)

 {
 {

-    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, wxEmptyString, bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
-
-    wxRect rectLabel = rect;
-    wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
-    rectLabel.x += shift;
-    rectLabel.width -= shift;
-    DrawItem(dc, label, rectLabel, flags);
+    DrawCheckButton(dc, wxEmptyString, bitmap, rect, flags & ~wxCONTROL_FOCUSED);

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// check/radion buttons
-// ----------------------------------------------------------------------------
-

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


@@ -1423,10 +959,10 @@ void wxGTKRenderer::DrawUndeterminedBitmap(wxDC& dc,
     }
 
     dc.SetPen(*wxTRANSPARENT_PEN);
     }
 
     dc.SetPen(*wxTRANSPARENT_PEN);

-    dc.SetBrush(wxBrush(col1, wxSOLID));
+    dc.SetBrush(col1);

     dc.DrawRectangle(rect);
     rect.Deflate(1);
     dc.DrawRectangle(rect);
     rect.Deflate(1);

-    dc.SetBrush(wxBrush(col2, wxSOLID));
+    dc.SetBrush(col2);

     dc.DrawRectangle(rect);
 }
 
     dc.DrawRectangle(rect);
 }
 


@@ -1438,7 +974,7 @@ void wxGTKRenderer::DrawUncheckBitmap(wxDC& dc,
     DrawAntiRaisedBorder(dc, &rect);
 
     wxColour col = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
     DrawAntiRaisedBorder(dc, &rect);
 
     wxColour col = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);

-    dc.SetPen(wxPen(col, 0, wxSOLID));
+    dc.SetPen(wxPen(col));

     dc.DrawPoint(rect.GetRight() - 1, rect.GetBottom() - 1);
 
     if ( isPressed )
     dc.DrawPoint(rect.GetRight() - 1, rect.GetBottom() - 1);
 
     if ( isPressed )


@@ -1446,7 +982,7 @@ void wxGTKRenderer::DrawUncheckBitmap(wxDC& dc,
     //else: it is SHADOW_IN, leave as is
 
     dc.SetPen(*wxTRANSPARENT_PEN);
     //else: it is SHADOW_IN, leave as is
 
     dc.SetPen(*wxTRANSPARENT_PEN);

-    dc.SetBrush(wxBrush(col, wxSOLID));
+    dc.SetBrush(col);

     dc.DrawRectangle(rect);
 }
 
     dc.DrawRectangle(rect);
 }
 


@@ -1457,13 +993,13 @@ void wxGTKRenderer::DrawCheckBitmap(wxDC& dc, const wxRect& rectTotal)
     DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
 
     dc.SetPen(*wxTRANSPARENT_PEN);
     DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
 
     dc.SetPen(*wxTRANSPARENT_PEN);

-    dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), wxSOLID));
+    dc.SetBrush(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED));

     dc.DrawRectangle(rect);
 }
 
     dc.DrawRectangle(rect);
 }
 

-void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
-                                    const wxRect& rect,
-                                    int flags)
+void wxGTKRenderer::DrawRadioButtonBitmap(wxDC& dc,
+                                          const wxRect& rect,
+                                          int flags)

 {
     wxCoord x = rect.x,
             y = rect.y,
 {
     wxCoord x = rect.x,
             y = rect.y,


@@ -1472,19 +1008,6 @@ void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
 
     wxCoord yMid = (y + yBottom) / 2;
 
 
     wxCoord yMid = (y + yBottom) / 2;
 

-    // this looks ugly when the background colour of the control is not the
-    // same ours - radiobox is not transparent as it should be
-#if 0
-    // first fill the middle: as FloodFill() is not implemented on all
-    // platforms, this is the only thing to do
-    wxColour colBg = flags & wxCONTROL_CURRENT
-                        ? wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT)
-                        : wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
-    dc.SetBrush(wxBrush(colBg, wxSOLID));
-    dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.DrawRectangle(rect);
-#endif // 0
-

     // then draw the upper half
     dc.SetPen(flags & wxCONTROL_CHECKED ? m_penDarkGrey : m_penHighlight);
     DrawUpZag(dc, x, xRight, yMid, y);
     // then draw the upper half
     dc.SetPen(flags & wxCONTROL_CHECKED ? m_penDarkGrey : m_penHighlight);
     DrawUpZag(dc, x, xRight, yMid, y);


@@ -1494,7 +1017,7 @@ void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
     if ( flags & wxCONTROL_CHECKED )
         dc.SetPen(m_penBlack);
     else if ( flags & wxCONTROL_PRESSED )
     if ( flags & wxCONTROL_CHECKED )
         dc.SetPen(m_penBlack);
     else if ( flags & wxCONTROL_PRESSED )

-        dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
+        dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED)));

     else // unchecked and unpressed
         drawIt = false;
 
     else // unchecked and unpressed
         drawIt = false;
 


@@ -1512,7 +1035,7 @@ void wxGTKRenderer::DrawRadioBitmap(wxDC& dc,
         drawIt = true; // with the same pen
     else if ( flags & wxCONTROL_PRESSED )
     {
         drawIt = true; // with the same pen
     else if ( flags & wxCONTROL_PRESSED )
     {

-        dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
+        dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED)));

         drawIt = true;
     }
     else // checked and unpressed
         drawIt = true;
     }
     else // checked and unpressed


@@ -1585,16 +1108,36 @@ wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
         DrawUndeterminedBitmap(dc, rect, true);
     }
 
         DrawUndeterminedBitmap(dc, rect, true);
     }
 

-    int row = flags & wxCONTROL_PRESSED
-                  ? 1
-                  : 0;
-    int col = flags & wxCONTROL_CHECKED
-                  ? 0
-                  : ( flags & wxCONTROL_UNDETERMINED
-                          ? 2
-                          : 1 );
+    IndicatorState state;
+    IndicatorStatus status;
+    GetIndicatorsFromFlags(flags, state, status);
+
+    // disabled looks the same as normal
+    if ( state == IndicatorState_Disabled )
+        state = IndicatorState_Normal;

 
 

-    return m_bitmapsCheckbox[row][col];
+    return m_bitmapsCheckbox[state][status];
+}
+
+wxBitmap wxGTKRenderer::GetRadioBitmap(int flags)
+{
+    IndicatorState state;
+    IndicatorStatus status;
+    GetIndicatorsFromFlags(flags, state, status);
+
+    wxBitmap& bmp = m_bitmapsRadiobtn[state][status];
+    if ( !bmp.Ok() )
+    {
+        const wxSize size = GetRadioBitmapSize();
+
+        wxMemoryDC dc;
+        bmp.Create(size.x, size.y);
+        dc.SelectObject(bmp);
+
+        DrawRadioButtonBitmap(dc, size, flags);
+    }
+
+    return bmp;

 }
 
 wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
 }
 
 wxBitmap wxGTKRenderer::GetLineWrapBitmap() const


@@ -1612,7 +1155,7 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
         wxBitmap bmpLineWrap(line_wrap_bits, line_wrap_width, line_wrap_height);
         if ( !bmpLineWrap.Ok() )
         {
         wxBitmap bmpLineWrap(line_wrap_bits, line_wrap_width, line_wrap_height);
         if ( !bmpLineWrap.Ok() )
         {

-            wxFAIL_MSG( _T("Failed to create line wrap XBM") );
+            wxFAIL_MSG( wxT("Failed to create line wrap XBM") );

         }
         else
         {
         }
         else
         {


@@ -1623,112 +1166,6 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
     return m_bmpLineWrap;
 }
 
     return m_bmpLineWrap;
 }
 

-void wxGTKRenderer::DrawCheckButton(wxDC& dc,
-                                    const wxString& label,
-                                    const wxBitmap& bitmapOrig,
-                                    const wxRect& rectTotal,
-                                    int flags,
-                                    wxAlignment align,
-                                    int indexAccel)
-{
-    wxBitmap bitmap;
-    if ( bitmapOrig.Ok() )
-    {
-        bitmap = bitmapOrig;
-    }
-    else
-    {
-        bitmap = GetCheckBitmap(flags);
-    }
-
-    DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
-                             flags, align, indexAccel);
-}
-
-void wxGTKRenderer::DoDrawCheckOrRadioBitmap(wxDC& dc,
-                                             const wxString& label,
-                                             const wxBitmap& bitmap,
-                                             const wxRect& rectTotal,
-                                             int flags,
-                                             wxAlignment align,
-                                             int indexAccel)
-{
-    wxRect rect = rectTotal;
-
-    if ( flags & wxCONTROL_FOCUSED )
-    {
-        // draw the focus border around everything
-        DrawRect(dc, &rect, m_penBlack);
-    }
-    else
-    {
-        // the border does not offset the string under GTK
-        rect.Inflate(-1);
-    }
-
-    // calculate the position of the bitmap and of the label
-    wxCoord xBmp,
-            yBmp = rect.y + (rect.height - bitmap.GetHeight()) / 2;
-
-    wxRect rectLabel;
-    dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
-    rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
-
-    if ( align == wxALIGN_RIGHT )
-    {
-        xBmp = rect.GetRight() - bitmap.GetWidth();
-        rectLabel.x = rect.x + 2;
-        rectLabel.SetRight(xBmp);
-    }
-    else // normal (checkbox to the left of the text) case
-    {
-        xBmp = rect.x + 2;
-        rectLabel.x = xBmp + bitmap.GetWidth() + 4;
-        rectLabel.SetRight(rect.GetRight());
-    }
-
-    dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
-
-    DrawLabel(dc, label, rectLabel, flags,
-              wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);
-}
-
-void wxGTKRenderer::DrawRadioButton(wxDC& dc,
-                                    const wxString& label,
-                                    const wxBitmap& bitmapOrig,
-                                    const wxRect& rectTotal,
-                                    int flags,
-                                    wxAlignment align,
-                                    int indexAccel)
-{
-    wxBitmap bitmap;
-    if ( bitmapOrig.Ok() )
-    {
-        bitmap = bitmapOrig;
-    }
-    else
-    {
-        wxRect rect;
-        wxSize size = GetRadioBitmapSize();
-        rect.width = size.x;
-        rect.height = size.y;
-        bitmap.Create(rect.width, rect.height);
-        wxMemoryDC dc;
-        dc.SelectObject(bitmap);
-        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));
-    }
-
-    DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
-                             flags, align, indexAccel);
-}
-

 #if wxUSE_TOOLBAR
 void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
                                       const wxString& label,
 #if wxUSE_TOOLBAR
 void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
                                       const wxString& label,


@@ -1784,20 +1221,12 @@ void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
 
 #if wxUSE_TEXTCTRL
 
 
 #if wxUSE_TEXTCTRL
 

-wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
-                                       const wxRect& rect) const
-{
-    wxRect rectTotal = rect;
-    rectTotal.Inflate(2*BORDER_THICKNESS);
-    return rectTotal;
-}
-

 wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
                                         const wxRect& rect,
                                         wxCoord *extraSpaceBeyond) const
 {
 wxRect wxGTKRenderer::GetTextClientArea(const wxTextCtrl *text,
                                         const wxRect& rect,
                                         wxCoord *extraSpaceBeyond) const
 {

-    wxRect rectText = rect;
-    rectText.Deflate(2*BORDER_THICKNESS);
+    wxRect
+      rectText = wxStdRenderer::GetTextClientArea(text, rect, extraSpaceBeyond);

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


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

-#endif // wxUSE_TEXTCTRL
-
-void wxGTKRenderer::DrawTextLine(wxDC& dc,
-                                 const wxString& text,
-                                 const wxRect& rect,
-                                 int selStart,
-                                 int selEnd,
-                                 int flags)
-{
-    // TODO: GTK+ draws selection even for unfocused controls, just with
-    //       different colours
-    StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
-}
-

 void wxGTKRenderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
 {
     wxBitmap bmpLineWrap = GetLineWrapBitmap();
 void wxGTKRenderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
 {
     wxBitmap bmpLineWrap = GetLineWrapBitmap();


@@ -1852,10 +1267,14 @@ void wxGTKRenderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
     }
 }
 
     }
 }
 

+#endif // wxUSE_TEXTCTRL
+

 // ----------------------------------------------------------------------------
 // notebook
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // notebook
 // ----------------------------------------------------------------------------
 

+#if wxUSE_NOTEBOOK
+

 void wxGTKRenderer::DrawTab(wxDC& dc,
                             const wxRect& rectOrig,
                             wxDirection dir,
 void wxGTKRenderer::DrawTab(wxDC& dc,
                             const wxRect& rectOrig,
                             wxDirection dir,


@@ -1884,7 +1303,7 @@ void wxGTKRenderer::DrawTab(wxDC& dc,
         switch ( dir )
         {
             default:
         switch ( dir )
         {
             default:

-                wxFAIL_MSG(_T("invaild notebook tab orientation"));
+                wxFAIL_MSG(wxT("invaild notebook tab orientation"));

                 // fall through
 
             case wxTOP:
                 // fall through
 
             case wxTOP:


@@ -1907,7 +1326,7 @@ void wxGTKRenderer::DrawTab(wxDC& dc,
     wxColour col = flags & wxCONTROL_SELECTED
                         ? wxSCHEME_COLOUR(m_scheme, SHADOW_IN)
                         : wxSCHEME_COLOUR(m_scheme, SCROLLBAR);
     wxColour col = flags & wxCONTROL_SELECTED
                         ? wxSCHEME_COLOUR(m_scheme, SHADOW_IN)
                         : wxSCHEME_COLOUR(m_scheme, SCROLLBAR);

-    DoDrawBackground(dc, col, rect);
+    DrawSolidRect(dc, col, rect);

 
     if ( flags & wxCONTROL_FOCUSED )
     {
 
     if ( flags & wxCONTROL_FOCUSED )
     {


@@ -2052,12 +1471,14 @@ void wxGTKRenderer::DrawTab(wxDC& dc,
     }
 }
 
     }
 }
 

-#if wxUSE_SLIDER
+#endif // wxUSE_NOTEBOOK

 
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // slider
 // ----------------------------------------------------------------------------
 

+#if wxUSE_SLIDER
+

 wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
                                          int lenThumb,
                                          wxOrientation orient) const
 wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
                                          int lenThumb,
                                          wxOrientation orient) const


@@ -2103,16 +1524,16 @@ void wxGTKRenderer::DrawSliderShaft(wxDC& dc,
     if ( flags & wxCONTROL_FOCUSED )
     {
         DrawRect(dc, &rect, m_penBlack);
     if ( flags & wxCONTROL_FOCUSED )
     {
         DrawRect(dc, &rect, m_penBlack);

-        DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);

     }
     else // not focused, normal
     {
         DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
     }
     else // not focused, normal
     {
         DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);

-        DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);

     }
 
     }
 

+    DrawAntiShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
+

     // and the background
     // and the background

-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rect);
+    DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rect);

 
     if ( rectShaft )
         *rectShaft = rect;
 
     if ( rectShaft )
         *rectShaft = rect;


@@ -2152,7 +1573,7 @@ void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
 // ----------------------------------------------------------------------------
 
 // wxGTKMenuGeometryInfo: the wxMenuGeometryInfo used by wxGTKRenderer
 // ----------------------------------------------------------------------------
 
 // wxGTKMenuGeometryInfo: the wxMenuGeometryInfo used by wxGTKRenderer

-class WXDLLEXPORT wxGTKMenuGeometryInfo : public wxMenuGeometryInfo
+class wxGTKMenuGeometryInfo : public wxMenuGeometryInfo

 {
 public:
     virtual wxSize GetSize() const { return m_size; }
 {
 public:
     virtual wxSize GetSize() const { return m_size; }


@@ -2282,7 +1703,7 @@ void wxGTKRenderer::DoDrawMenuItem(wxDC& dc,
     if ( !accel.empty() )
     {
         // menubar items shouldn't have them
     if ( !accel.empty() )
     {
         // menubar items shouldn't have them

-        wxCHECK_RET( geometryInfo, _T("accel strings only valid for menus") );
+        wxCHECK_RET( geometryInfo, wxT("accel strings only valid for menus") );

 
         rect.x = geometryInfo->GetAccelOffset();
         rect.SetRight(geometryInfo->GetSize().x);
 
         rect.x = geometryInfo->GetAccelOffset();
         rect.SetRight(geometryInfo->GetSize().x);


@@ -2294,7 +1715,7 @@ void wxGTKRenderer::DoDrawMenuItem(wxDC& dc,
     // draw the submenu indicator
     if ( flags & wxCONTROL_ISSUBMENU )
     {
     // draw the submenu indicator
     if ( flags & wxCONTROL_ISSUBMENU )
     {

-        wxCHECK_RET( geometryInfo, _T("wxCONTROL_ISSUBMENU only valid for menus") );
+        wxCHECK_RET( geometryInfo, wxT("wxCONTROL_ISSUBMENU only valid for menus") );

 
         rect.x = geometryInfo->GetSize().x - MENU_RIGHT_MARGIN;
         rect.width = MENU_RIGHT_MARGIN;
 
         rect.x = geometryInfo->GetSize().x - MENU_RIGHT_MARGIN;
         rect.width = MENU_RIGHT_MARGIN;


@@ -2361,7 +1782,7 @@ wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
             h = heightText;
 
             wxCoord widthLabel;
             h = heightText;
 
             wxCoord widthLabel;

-            dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
+            dc.GetTextExtent(item->GetItemLabelText(), &widthLabel, NULL);

             if ( widthLabel > widthLabelMax )
             {
                 widthLabelMax = widthLabel;
             if ( widthLabel > widthLabelMax )
             {
                 widthLabelMax = widthLabel;


@@ -2414,27 +1835,6 @@ wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
 
 #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
 // ----------------------------------------------------------------------------


@@ -2468,7 +1868,7 @@ void wxGTKRenderer::InitComboBitmaps()
         int flags = comboButtonFlags[n];
 
         dc.SelectObject(m_bitmapsCombo[n]);
         int flags = comboButtonFlags[n];
 
         dc.SelectObject(m_bitmapsCombo[n]);

-        DoDrawBackground(dc, GetBackgroundColour(flags), rect);
+        DrawSolidRect(dc, GetBackgroundColour(flags), rect);

         DrawArrow(dc, wxDOWN, rect, flags);
     }
 }
         DrawArrow(dc, wxDOWN, rect, flags);
     }
 }


@@ -2493,31 +1893,6 @@ void wxGTKRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
         *bmpDisabled = m_bitmapsCombo[ComboState_Disabled];
 }
 
         *bmpDisabled = m_bitmapsCombo[ComboState_Disabled];
 }
 

-// ----------------------------------------------------------------------------
-// background
-// ----------------------------------------------------------------------------
-
-void wxGTKRenderer::DoDrawBackground(wxDC& dc,
-                                     const wxColour& col,
-                                     const wxRect& rect,
-                                     wxWindow * WXUNUSED(window))
-{
-    wxBrush brush(col, wxSOLID);
-    dc.SetBrush(brush);
-    dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.DrawRectangle(rect);
-}
-
-void wxGTKRenderer::DrawBackground(wxDC& dc,
-                                   const wxColour& col,
-                                   const wxRect& rect,
-                                   int flags,
-                                   wxWindow *window )
-{
-    wxColour colBg = col.Ok() ? col : GetBackgroundColour(flags);
-    DoDrawBackground(dc, colBg, rect, window );
-}
-

 // ----------------------------------------------------------------------------
 // scrollbar
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // scrollbar
 // ----------------------------------------------------------------------------


@@ -2539,7 +1914,7 @@ void wxGTKRenderer::DrawArrowBorder(wxDC& dc,
     rect2.Inflate(-1);
     rectInner.Inflate(-2);
 
     rect2.Inflate(-1);
     rectInner.Inflate(-2);
 

-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), *rect);
+    DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), *rect);

 
     // find the side not to draw and also adjust the rectangles to compensate
     // for it
 
     // find the side not to draw and also adjust the rectangles to compensate
     // for it


@@ -2575,7 +1950,7 @@ void wxGTKRenderer::DrawArrowBorder(wxDC& dc,
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("unknown arrow direction"));
+            wxFAIL_MSG(wxT("unknown arrow direction"));

             return;
     }
 
             return;
     }
 


@@ -2671,7 +2046,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
 
     // draw the arrow interior
     dc.SetPen(*wxTRANSPARENT_PEN);
 
     // draw the arrow interior
     dc.SetPen(*wxTRANSPARENT_PEN);

-    dc.SetBrush(wxBrush(colInside, wxSOLID));
+    dc.SetBrush(colInside);

 
     switch ( dir )
     {
 
     switch ( dir )
     {


@@ -2710,7 +2085,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("unknown arrow direction"));
+            wxFAIL_MSG(wxT("unknown arrow direction"));

     }
 
     dc.DrawPolygon(WXSIZEOF(ptArrow), ptArrow);
     }
 
     dc.DrawPolygon(WXSIZEOF(ptArrow), ptArrow);


@@ -2787,7 +2162,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG(_T("unknown arrow direction"));
+            wxFAIL_MSG(wxT("unknown arrow direction"));

             return;
     }
 }
             return;
     }
 }


@@ -2850,59 +2225,9 @@ void wxGTKRenderer::DrawScrollbarShaft(wxDC& dc,
 {
     wxRect rectBar = rect;
     DrawThumbBorder(dc, &rectBar, orient);
 {
     wxRect rectBar = rect;
     DrawThumbBorder(dc, &rectBar, orient);

-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
-}
-
-void wxGTKRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
-{
-    DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
-}
-
-#if wxUSE_SCROLLBAR
-wxRect wxGTKRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
-                                       wxScrollBar::Element elem,
-                                       int thumbPos) const
-{
-    // as GTK scrollbars can't be disabled, it makes no sense to remove the
-    // thumb for a scrollbar with range 0 - instead, make it fill the entire
-    // scrollbar shaft
-    if ( (elem == wxScrollBar::Element_Thumb) && !scrollbar->GetRange() )
-    {
-        elem = wxScrollBar::Element_Bar_2;
-    }
-
-    return StandardGetScrollbarRect(scrollbar, elem,
-                                    thumbPos,
-                                    GetScrollbarArrowSize(scrollbar));
+    DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);

 }
 
 }
 

-wxCoord wxGTKRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
-{
-    return StandardScrollBarSize(scrollbar, GetScrollbarArrowSize(scrollbar));
-}
-
-wxHitTest wxGTKRenderer::HitTestScrollbar(const wxScrollBar *scrollbar,
-                                          const wxPoint& pt) const
-{
-    return StandardHitTestScrollbar(scrollbar, pt,
-                                    GetScrollbarArrowSize(scrollbar));
-}
-
-wxCoord wxGTKRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
-                                        int thumbPos)
-{
-    return StandardScrollbarToPixel(scrollbar, thumbPos,
-                                    GetScrollbarArrowSize(scrollbar));
-}
-
-int wxGTKRenderer::PixelToScrollbar(const wxScrollBar *scrollbar,
-                                    wxCoord coord)
-{
-    return StandardPixelToScrollbar(scrollbar, coord,
-                                    GetScrollbarArrowSize(scrollbar));
-}
-#endif // wxUSE_SCROLLBAR
-

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


@@ -2953,93 +2278,10 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
 #endif // wxUSE_SCROLLBAR
     {
         // take into account the border width
 #endif // wxUSE_SCROLLBAR
     {
         // take into account the border width

-        wxRect rectBorder = GetBorderDimensions(window->GetBorder());
-        size->x += rectBorder.x + rectBorder.width;
-        size->y += rectBorder.y + rectBorder.height;
+        wxStdRenderer::AdjustSize(size, 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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // standard icons
 // ----------------------------------------------------------------------------


@@ -3331,11 +2573,6 @@ wxBitmap wxGTKArtProvider::CreateBitmap(const wxArtID& id,
 // wxGTKInputHandler
 // ----------------------------------------------------------------------------
 
 // wxGTKInputHandler
 // ----------------------------------------------------------------------------
 

-wxGTKInputHandler::wxGTKInputHandler(wxGTKRenderer *renderer)
-{
-    m_renderer = renderer;
-}
-

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


@@ -3495,7 +2732,9 @@ bool wxGTKTextCtrlInputHandler::HandleKey(wxInputConsumer *control,
         }
     }
 
         }
     }
 

-    return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
+    return wxStdInputHandler::HandleKey(control, event, pressed);

 }
 
 #endif // wxUSE_TEXTCTRL
 }
 
 #endif // wxUSE_TEXTCTRL

+
+#endif // wxUSE_THEME_GTK