]> git.saurik.com Git - wxWidgets.git/blobdiff - src/univ/themes/gtk.cpp
removed src/gtk/eggtrayicon.h
[wxWidgets.git] / src / univ / themes / gtk.cpp
index 39a0ba958efa6133c0e7f556a6a65ab1f905c812..098e4d0960409c34fbe6f7da8eea87630c0ea95c 100644 (file)
@@ -6,7 +6,7 @@
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
 // Created:     06.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ===========================================================================
@@ -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"
     #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/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"
-#include "wx/toplevel.h"
+
+class WXDLLEXPORT wxGTKMenuGeometryInfo;
 
 // ----------------------------------------------------------------------------
 // constants (to be removed, for testing only)
 
 // ----------------------------------------------------------------------------
 // constants (to be removed, for testing only)
@@ -69,7 +78,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,
@@ -152,6 +162,13 @@ public:
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
 
                                  wxAlignment align = wxALIGN_LEFT,
                                  int indexAccel = -1);
 
+    virtual void DrawToolBarButton(wxDC& dc,
+                                   const wxString& label,
+                                   const wxBitmap& bitmap,
+                                   const wxRect& rect,
+                                   int flags = 0,
+                                   long style = 0);
+
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
     virtual void DrawTextLine(wxDC& dc,
                               const wxString& text,
                               const wxRect& rect,
@@ -169,21 +186,25 @@ public:
 
     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,
 
     virtual void DrawSliderShaft(wxDC& dc,
                                  const wxRect& rect,
+                                 int lenThumb,
                                  wxOrientation orient,
                                  int flags = 0,
                                  wxOrientation orient,
                                  int flags = 0,
+                                 long style = 0,
                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,
                                  wxRect *rectShaft = NULL);
     virtual void DrawSliderThumb(wxDC& dc,
                                  const wxRect& rect,
                                  wxOrientation orient,
-                                 int flags = 0);
-    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
     }
@@ -208,7 +229,7 @@ public:
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
     virtual void DrawStatusField(wxDC& dc,
                                  const wxRect& rect,
                                  const wxString& label,
-                                 int flags = 0);
+                                 int flags = 0, int style = 0);
 
     virtual void DrawFrameTitleBar(wxDC& dc,
                                    const wxRect& rect,
 
     virtual void DrawFrameTitleBar(wxDC& dc,
                                    const wxRect& rect,
@@ -239,10 +260,9 @@ public:
     // titlebars
     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
     // 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 wxSize GetFrameIconSize() const;
     virtual int HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const;
-    
-    virtual wxIcon GetStdIcon(int which) const;
 
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
 
     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
                                  wxBitmap *bmpFocus,
@@ -274,11 +294,16 @@ 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); }
+
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
-                                    const wxRect& rect);
+                                    const wxRect& rect) const;
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
                                      const wxRect& rect,
-                                     wxCoord *extraSpaceBeyond);
+                                     wxCoord *extraSpaceBeyond) const;
 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
 
     virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
     virtual wxSize GetTabPadding() const { return wxSize(6, 6); }
@@ -286,8 +311,11 @@ public:
     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;
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 
                                       wxOrientation orient) const;
     virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
 
@@ -318,7 +346,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
@@ -384,7 +413,7 @@ protected:
     }
 
     // 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
 
@@ -412,6 +441,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 = _T(""),
+                        const wxBitmap& bitmap = wxNullBitmap,
+                        const wxGTKMenuGeometryInfo *geometryInfo = NULL);
+
     // initialize the combo bitmaps
     void InitComboBitmaps();
 
     // initialize the combo bitmaps
     void InitComboBitmaps();
 
@@ -495,7 +534,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
     {
@@ -537,11 +576,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
 {
@@ -550,6 +601,7 @@ public:
     virtual ~wxGTKTheme();
 
     virtual wxRenderer *GetRenderer();
     virtual ~wxGTKTheme();
 
     virtual wxRenderer *GetRenderer();
+    virtual wxArtProvider *GetArtProvider();
     virtual wxInputHandler *GetInputHandler(const wxString& control);
     virtual wxColourScheme *GetColourScheme();
 
     virtual wxInputHandler *GetInputHandler(const wxString& control);
     virtual wxColourScheme *GetColourScheme();
 
@@ -559,6 +611,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;
@@ -586,6 +640,7 @@ wxGTKTheme::wxGTKTheme()
     m_scheme = NULL;
     m_renderer = NULL;
     m_handlerDefault = NULL;
     m_scheme = NULL;
     m_renderer = NULL;
     m_handlerDefault = NULL;
+    m_artProvider = NULL;
 }
 
 wxGTKTheme::~wxGTKTheme()
 }
 
 wxGTKTheme::~wxGTKTheme()
@@ -600,6 +655,7 @@ 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()
 }
 
 wxRenderer *wxGTKTheme::GetRenderer()
@@ -612,6 +668,16 @@ wxRenderer *wxGTKTheme::GetRenderer()
     return m_renderer;
 }
 
     return m_renderer;
 }
 
+wxArtProvider *wxGTKTheme::GetArtProvider()
+{
+    if ( !m_artProvider )
+    {
+        m_artProvider = new wxGTKArtProvider;
+    }
+
+    return m_artProvider;
+}
+
 wxColourScheme *wxGTKTheme::GetColourScheme()
 {
     if ( !m_scheme )
 wxColourScheme *wxGTKTheme::GetColourScheme()
 {
     if ( !m_scheme )
@@ -677,6 +743,10 @@ 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
+#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());
         else
         else if ( control == wxINP_HANDLER_TOPLEVEL )
             handler = new wxStdFrameInputHandler(GetDefaultInputHandler());
         else
@@ -706,7 +776,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() )
@@ -763,6 +833,8 @@ 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 MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));
         case MAX:
         default:
             wxFAIL_MSG(_T("invalid standard colour"));
@@ -909,7 +981,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;
@@ -1010,7 +1082,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;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1196,6 +1268,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);
 }
@@ -1254,11 +1330,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
     DrawCheckButton(dc, _T(""), bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
 
     wxRect rectLabel = rect;
     // never draw the focus rect around the check indicators here
     DrawCheckButton(dc, _T(""), bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
 
     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);
@@ -1328,13 +1405,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);
@@ -1347,14 +1424,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);
@@ -1405,14 +1482,14 @@ 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);
 
         // 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);
     }
 
     int row = flags & wxCONTROL_PRESSED ? 1 : 0;
     }
 
     int row = flags & wxCONTROL_PRESSED ? 1 : 0;
@@ -1421,7 +1498,7 @@ wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
     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() )
     {
@@ -1440,7 +1517,7 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap()
         }
         else
         {
         }
         else
         {
-            m_bmpLineWrap = bmpLineWrap;
+            wxConstCast(this, wxGTKRenderer)->m_bmpLineWrap = bmpLineWrap;
         }
     }
 
         }
     }
 
@@ -1511,7 +1588,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);
@@ -1542,6 +1619,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));
     }
 
@@ -1549,12 +1630,42 @@ void wxGTKRenderer::DrawRadioButton(wxDC& dc,
                              flags, align, indexAccel);
 }
 
                              flags, align, indexAccel);
 }
 
+void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
+                                      const wxString& label,
+                                      const wxBitmap& bitmap,
+                                      const wxRect& rectOrig,
+                                      int flags,
+                                      long WXUNUSED(style))
+{
+    // 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);
+        }
+
+        dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
+    }
+}
+
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // text control
 // ----------------------------------------------------------------------------
 
-wxRect wxGTKRenderer::GetTextTotalArea(const wxTextCtrl *text,
-                                       const wxRect& rect)
+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);
@@ -1563,7 +1674,7 @@ 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;
     rectText.Deflate(2*BORDER_THICKNESS);
 {
     wxRect rectText = rect;
     rectText.Deflate(2*BORDER_THICKNESS);
@@ -1764,13 +1875,14 @@ void wxGTKRenderer::DrawTab(wxDC& dc,
 // ----------------------------------------------------------------------------
 
 wxSize wxGTKRenderer::GetSliderThumbSize(const wxRect& rect,
 // ----------------------------------------------------------------------------
 
 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);
@@ -1786,15 +1898,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;
@@ -1821,7 +1937,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;
@@ -1846,60 +1963,281 @@ void wxGTKRenderer::DrawSliderThumb(wxDC& dc,
 // 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;
 
 
-    return NULL;
+        // 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;
+
+    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;
 }
 
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // status bar
 // ----------------------------------------------------------------------------
 
-wxSize wxGTKRenderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
+wxSize
+wxGTKRenderer::GetStatusBarBorders(wxCoord * WXUNUSED(borderBetweenFields)) const
 {
     return wxSize(0, 0);
 }
 
 {
     return wxSize(0, 0);
 }
 
-void wxGTKRenderer::DrawStatusField(wxDC& dc,
-                                    const wxRect& rect,
-                                    const wxString& label,
-                                    int flags)
+void wxGTKRenderer::DrawStatusField(wxDC& WXUNUSED(dc),
+                                    const wxRect& WXUNUSED(rect),
+                                    const wxString& WXUNUSED(label),
+                                    int WXUNUSED(flags), int WXUNUSED(style))
 {
 }
 
 {
 }
 
@@ -1967,7 +2305,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);
@@ -1978,10 +2317,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 );
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -2312,7 +2652,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);
@@ -2418,65 +2758,78 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
 // top level windows
 // ----------------------------------------------------------------------------
 
 // top level windows
 // ----------------------------------------------------------------------------
 
-void wxGTKRenderer::DrawFrameTitleBar(wxDC& dc,
-                                      const wxRect& rect,
-                                      const wxString& title,
-                                      const wxIcon& icon,
-                                      int flags,
-                                      int specialButton,
-                                      int specialButtonFlag)
+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& dc,
-                                    const wxRect& rect,
-                                    int flags)
+void wxGTKRenderer::DrawFrameBorder(wxDC& WXUNUSED(dc),
+                                    const wxRect& WXUNUSED(rect),
+                                    int WXUNUSED(flags))
 {
 }
 
 {
 }
 
-void wxGTKRenderer::DrawFrameBackground(wxDC& dc,
-                                        const wxRect& rect,
-                                        int flags)
+void wxGTKRenderer::DrawFrameBackground(wxDC& WXUNUSED(dc),
+                                        const wxRect& WXUNUSED(rect),
+                                        int WXUNUSED(flags))
 {
 }
 
 {
 }
 
-void wxGTKRenderer::DrawFrameTitle(wxDC& dc,
-                                   const wxRect& rect,
-                                   const wxString& title,
-                                   int flags)
+void wxGTKRenderer::DrawFrameTitle(wxDC& WXUNUSED(dc),
+                                   const wxRect& WXUNUSED(rect),
+                                   const wxString& WXUNUSED(title),
+                                   int WXUNUSED(flags))
 {
 }
 
 {
 }
 
-void wxGTKRenderer::DrawFrameIcon(wxDC& dc,
-                                  const wxRect& rect,
-                                  const wxIcon& icon,
-                                  int flags)
+void wxGTKRenderer::DrawFrameIcon(wxDC& WXUNUSED(dc),
+                                  const wxRect& WXUNUSED(rect),
+                                  const wxIcon& WXUNUSED(icon),
+                                  int WXUNUSED(flags))
 {
 }
 
 {
 }
 
-void wxGTKRenderer::DrawFrameButton(wxDC& dc,
-                                    wxCoord x, wxCoord y,
-                                    int button,
-                                    int 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 flags) const
+wxRect
+wxGTKRenderer::GetFrameClientArea(const wxRect& rect,
+                                  int WXUNUSED(flags)) const
 {
     return rect;
 }
 
 {
     return rect;
 }
 
-wxSize wxGTKRenderer::GetFrameTotalSize(const wxSize& clientSize, int flags) const
+wxSize
+wxGTKRenderer::GetFrameTotalSize(const wxSize& clientSize,
+                                 int WXUNUSED(flags)) const
 {
     return clientSize;
 }
 
 {
     return clientSize;
 }
 
+wxSize wxGTKRenderer::GetFrameMinSize(int WXUNUSED(flags)) const
+{
+    return wxSize(0,0);
+}
+
 wxSize wxGTKRenderer::GetFrameIconSize() const
 {
 wxSize wxGTKRenderer::GetFrameIconSize() const
 {
-    return wxSize(-1, -1);
+    return wxSize(wxDefaultCoord, wxDefaultCoord);
 }
 
 }
 
-int wxGTKRenderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
+int
+wxGTKRenderer::HitTestFrame(const wxRect& WXUNUSED(rect),
+                            const wxPoint& WXUNUSED(pt),
+                            int WXUNUSED(flags)) const
 {
     return wxHT_TOPLEVEL_CLIENT_AREA;
 }
 {
     return wxHT_TOPLEVEL_CLIENT_AREA;
 }
@@ -2486,7 +2839,7 @@ int wxGTKRenderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags
 // standard icons
 // ----------------------------------------------------------------------------
 
 // standard icons
 // ----------------------------------------------------------------------------
 
-static char *error_xpm[] = {
+static const char *error_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "48 48 537 2",
 "   c Gray0",
 /* columns rows colors chars-per-pixel */
 "48 48 537 2",
 "   c Gray0",
@@ -3077,7 +3430,7 @@ static char *error_xpm[] = {
 "W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+"
 };
 
 "W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+W+"
 };
 
-static char *info_xpm[] = {
+static const char *info_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "48 48 478 2",
 "   c Gray0",
 /* columns rows colors chars-per-pixel */
 "48 48 478 2",
 "   c Gray0",
@@ -3610,7 +3963,7 @@ static char *info_xpm[] = {
 };
 
 /* XPM */
 };
 
 /* XPM */
-static char *warning_xpm[] = {
+static const char *warning_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "48 48 270 2",
 "   c Gray0",
 /* columns rows colors chars-per-pixel */
 "48 48 270 2",
 "   c Gray0",
@@ -3935,7 +4288,7 @@ static char *warning_xpm[] = {
 };
 
 /* XPM */
 };
 
 /* XPM */
-static char *question_xpm[] = {
+static const char *question_xpm[] = {
 /* columns rows colors chars-per-pixel */
 "48 48 101 2",
 "   c Gray0",
 /* columns rows colors chars-per-pixel */
 "48 48 101 2",
 "   c Gray0",
@@ -4090,27 +4443,19 @@ static char *question_xpm[] = {
 "$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$."
 };
 
 "$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$.$."
 };
 
-
-wxIcon wxGTKRenderer::GetStdIcon(int which) const
+wxBitmap wxGTKArtProvider::CreateBitmap(const wxArtID& id,
+                                        const wxArtClient& WXUNUSED(client),
+                                        const wxSize& WXUNUSED(size))
 {
 {
-    switch(which)
-    {
-        case wxICON_INFORMATION:
-            return wxIcon(info_xpm);
-
-        case wxICON_QUESTION:
-            return wxIcon(question_xpm);
-
-        case wxICON_EXCLAMATION:
-            return wxIcon(warning_xpm);
-
-        default:
-            wxFAIL_MSG(wxT("requested non existent standard icon"));
-            // still fall through
-
-        case wxICON_HAND:
-            return wxIcon(error_xpm);
-    }
+    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;
 }
 
 
 }
 
 
@@ -4127,11 +4472,11 @@ wxGTKInputHandler::wxGTKInputHandler(wxGTKRenderer *renderer)
     m_renderer = renderer;
 }
 
     m_renderer = renderer;
 }
 
-bool wxGTKInputHandler::HandleKey(wxInputConsumer *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(wxInputConsumer *control,
 }
 
 bool wxGTKInputHandler::HandleMouse(wxInputConsumer *control,
@@ -4142,10 +4487,10 @@ bool wxGTKInputHandler::HandleMouse(wxInputConsumer *control,
     {
         control->GetInputWindow()->SetFocus();
 
     {
         control->GetInputWindow()->SetFocus();
 
-        return TRUE;
+        return true;
     }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,
 }
 
 bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,
@@ -4153,18 +4498,18 @@ bool wxGTKInputHandler::HandleMouseMove(wxInputConsumer *control,
 {
     if ( event.Entering() )
     {
 {
     if ( event.Entering() )
     {
-        control->GetInputWindow()->SetCurrent(TRUE);
+        control->GetInputWindow()->SetCurrent(true);
     }
     else if ( event.Leaving() )
     {
     }
     else if ( event.Leaving() )
     {
-        control->GetInputWindow()->SetCurrent(FALSE);
+        control->GetInputWindow()->SetCurrent(false);
     }
     else
     {
     }
     else
     {
-        return FALSE;
+        return false;
     }
 
     }
 
-    return TRUE;
+    return true;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -4182,11 +4527,11 @@ bool wxGTKCheckboxInputHandler::HandleKey(wxInputConsumer *control,
         {
             control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
 
         {
             control->PerformAction(wxACTION_CHECKBOX_TOGGLE);
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -4276,7 +4621,7 @@ bool wxGTKTextCtrlInputHandler::HandleKey(wxInputConsumer *control,
         {
             control->PerformAction(action);
 
         {
             control->PerformAction(action);
 
-            return TRUE;
+            return true;
         }
     }
 
         }
     }