Add doc for wxGraphicsContext.Create(), which is a lightweight context with no target...

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

diff --git a/src/univ/themes/gtk.cpp b/src/univ/themes/gtk.cpp
index 65443dcff67659b6dafef2fbdad3cca261455634..40083c9747284dc11859d9bad6d46b0e55fd383c 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"


@@ -52,17 +57,14 @@
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
 #include "wx/artprov.h"
 #include "wx/notebook.h"
 #include "wx/spinbutt.h"
 #include "wx/artprov.h"

-#ifdef wxUSE_TOGGLEBTN

 #include "wx/tglbtn.h"
 #include "wx/tglbtn.h"

-#endif // wxUSE_TOGGLEBTN

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

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

 
 

-class WXDLLEXPORT wxGTKMenuGeometryInfo;
+class wxGTKMenuGeometryInfo;

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -81,7 +83,7 @@ public:
     wxGTKRenderer(const wxColourScheme *scheme);
 
     // wxRenderer methods
     wxGTKRenderer(const wxColourScheme *scheme);
 
     // wxRenderer methods

-    virtual void DrawFocusRect(wxDC& dc, const wxRect& rect);
+    virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);

     virtual void DrawTextBorder(wxDC& dc,
                                 wxBorder border,
                                 const wxRect& rect,
     virtual void DrawTextBorder(wxDC& dc,
                                 wxBorder border,
                                 const wxRect& rect,


@@ -194,12 +196,9 @@ public:
     virtual void AdjustSize(wxSize *size, const wxWindow *window);
 
     // geometry and hit testing
     virtual void AdjustSize(wxSize *size, const wxWindow *window);
 
     // 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;

 #endif // wxUSE_SCROLLBAR
 
     virtual wxSize GetCheckBitmapSize() const
 #endif // wxUSE_SCROLLBAR
 
     virtual wxSize GetCheckBitmapSize() const


@@ -209,10 +208,12 @@ 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
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
 
 #if wxUSE_TEXTCTRL
     virtual wxRect GetTextClientArea(const wxTextCtrl *text,


@@ -309,26 +310,6 @@ protected:
     // draw inner GTK shadow
     void DrawInnerShadedRect(wxDC& dc, wxRect *rect);
 
     // draw inner GTK shadow
     void DrawInnerShadedRect(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
-

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


@@ -345,7 +326,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);
+    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,


@@ -366,8 +347,6 @@ protected:
     }
 
 private:
     }
 
 private:

-    const wxColourScheme *m_scheme;
-

     // data
     wxSize m_sizeScrollbarArrow;
 
     // data
     wxSize m_sizeScrollbarArrow;
 


@@ -561,7 +540,7 @@ wxGTKTheme::~wxGTKTheme()
 {
     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()


@@ -665,7 +644,7 @@ wxColour wxGTKColourScheme::GetBackground(wxWindow *win) const
     if ( !win->ShouldInheritColours() )
     {
         // doesn't depend on the state
     if ( !win->ShouldInheritColours() )
     {
         // doesn't depend on the state

-        if ( !col.Ok() )
+        if ( !col.IsOk() )

         {
             col = Get(WINDOW);
         }
         {
             col = Get(WINDOW);
         }


@@ -676,7 +655,7 @@ wxColour wxGTKColourScheme::GetBackground(wxWindow *win) const
 
         // the colour set by the user should be used for the normal state
         // and for the states for which we don't have any specific colours
 
         // the colour set by the user should be used for the normal state
         // and for the states for which we don't have any specific colours

-        if ( !col.Ok() || (flags != 0) )
+        if ( !col.IsOk() || (flags != 0) )

         {
 #if wxUSE_SCROLLBAR
             if ( wxDynamicCast(win, wxScrollBar) )
         {
 #if wxUSE_SCROLLBAR
             if ( wxDynamicCast(win, wxScrollBar) )


@@ -699,6 +678,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;


@@ -734,7 +714,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;
     }
 }


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

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

     }
 }
 
     }
 }
 


@@ -831,7 +811,8 @@ void wxGTKRenderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
     DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
 }
 
     DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
 }
 

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

 {
     dc.SetBrush(*wxTRANSPARENT_BRUSH);
     wxRect rectFocus = rect;
 {
     dc.SetBrush(*wxTRANSPARENT_BRUSH);
     wxRect rectFocus = rect;


@@ -942,7 +923,7 @@ void wxGTKRenderer::DrawFrameWithLabel(wxDC& dc,
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// check/radion buttons
+// check/radio buttons

 // ----------------------------------------------------------------------------
 
 void wxGTKRenderer::DrawCheckItemBitmap(wxDC& dc,
 // ----------------------------------------------------------------------------
 
 void wxGTKRenderer::DrawCheckItemBitmap(wxDC& dc,


@@ -1014,9 +995,9 @@ void wxGTKRenderer::DrawCheckBitmap(wxDC& dc, const wxRect& rectTotal)
     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,


@@ -1086,7 +1067,7 @@ void wxGTKRenderer::DrawDownZag(wxDC& dc,
 
 wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
 {
 
 wxBitmap wxGTKRenderer::GetCheckBitmap(int flags)
 {

-    if ( !m_bitmapsCheckbox[0][0].Ok() )
+    if ( !m_bitmapsCheckbox[0][0].IsOk() )

     {
         // init the bitmaps once only
         wxRect rect;
     {
         // init the bitmaps once only
         wxRect rect;


@@ -1143,7 +1124,7 @@ wxBitmap wxGTKRenderer::GetRadioBitmap(int flags)
     GetIndicatorsFromFlags(flags, state, status);
 
     wxBitmap& bmp = m_bitmapsRadiobtn[state][status];
     GetIndicatorsFromFlags(flags, state, status);
 
     wxBitmap& bmp = m_bitmapsRadiobtn[state][status];

-    if ( !bmp.Ok() )
+    if ( !bmp.IsOk() )

     {
         const wxSize size = GetRadioBitmapSize();
 
     {
         const wxSize size = GetRadioBitmapSize();
 


@@ -1151,7 +1132,7 @@ wxBitmap wxGTKRenderer::GetRadioBitmap(int flags)
         bmp.Create(size.x, size.y);
         dc.SelectObject(bmp);
 
         bmp.Create(size.x, size.y);
         dc.SelectObject(bmp);
 

-        DrawRadioBitmap(dc, size, flags);
+        DrawRadioButtonBitmap(dc, size, flags);

     }
 
     return bmp;
     }
 
     return bmp;


@@ -1159,7 +1140,7 @@ wxBitmap wxGTKRenderer::GetRadioBitmap(int flags)
 
 wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
 {
 
 wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
 {

-    if ( !m_bmpLineWrap.Ok() )
+    if ( !m_bmpLineWrap.IsOk() )

     {
         // the line wrap bitmap as used by GTK+
         #define line_wrap_width 6
     {
         // the line wrap bitmap as used by GTK+
         #define line_wrap_width 6


@@ -1170,9 +1151,9 @@ wxBitmap wxGTKRenderer::GetLineWrapBitmap() const
         };
 
         wxBitmap bmpLineWrap(line_wrap_bits, line_wrap_width, line_wrap_height);
         };
 
         wxBitmap bmpLineWrap(line_wrap_bits, line_wrap_width, line_wrap_height);

-        if ( !bmpLineWrap.Ok() )
+        if ( !bmpLineWrap.IsOk() )

         {
         {

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

         }
         else
         {
         }
         else
         {


@@ -1193,7 +1174,7 @@ void wxGTKRenderer::DrawToolBarButton(wxDC& dc,
                                       int tbarStyle)
 {
     // we don't draw the separators at all
                                       int tbarStyle)
 {
     // we don't draw the separators at all

-    if ( !label.empty() || bitmap.Ok() )
+    if ( !label.empty() || bitmap.IsOk() )

     {
         wxRect rect = rectOrig;
         rect.Deflate(BORDER_THICKNESS);
     {
         wxRect rect = rectOrig;
         rect.Deflate(BORDER_THICKNESS);


@@ -1277,7 +1258,7 @@ void wxGTKRenderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
     dc.DrawBitmap(bmpLineWrap,
                   rect.x, rect.y + (rect.height - bmpLineWrap.GetHeight())/2);
 
     dc.DrawBitmap(bmpLineWrap,
                   rect.x, rect.y + (rect.height - bmpLineWrap.GetHeight())/2);
 

-    if ( colFgOld.Ok() )
+    if ( colFgOld.IsOk() )

     {
         // restore old colour
         dc.SetTextForeground(colFgOld);
     {
         // restore old colour
         dc.SetTextForeground(colFgOld);


@@ -1320,7 +1301,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:


@@ -1590,7 +1571,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; }


@@ -1694,12 +1675,12 @@ void wxGTKRenderer::DoDrawMenuItem(wxDC& dc,
     if ( geometryInfo )
     {
         wxBitmap bmp = bitmap;
     if ( geometryInfo )
     {
         wxBitmap bmp = bitmap;

-        if ( !bmp.Ok() && (flags & wxCONTROL_CHECKABLE) )
+        if ( !bmp.IsOk() && (flags & wxCONTROL_CHECKABLE) )

         {
             bmp = GetCheckBitmap(flags);
         }
 
         {
             bmp = GetCheckBitmap(flags);
         }
 

-        if ( bmp.Ok() )
+        if ( bmp.IsOk() )

         {
             rect.SetRight(geometryInfo->GetLabelOffset());
             wxControlRenderer::DrawBitmap(dc, bmp, rect);
         {
             rect.SetRight(geometryInfo->GetLabelOffset());
             wxControlRenderer::DrawBitmap(dc, bmp, rect);


@@ -1720,7 +1701,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);


@@ -1732,7 +1713,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;


@@ -1799,7 +1780,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;


@@ -1813,7 +1794,7 @@ wxMenuGeometryInfo *wxGTKRenderer::GetMenuGeometry(wxWindow *win,
             }
 
             const wxBitmap& bmp = item->GetBitmap();
             }
 
             const wxBitmap& bmp = item->GetBitmap();

-            if ( bmp.Ok() )
+            if ( bmp.IsOk() )

             {
                 wxCoord widthBmp = bmp.GetWidth();
                 if ( widthBmp > widthBmpMax )
             {
                 wxCoord widthBmp = bmp.GetWidth();
                 if ( widthBmp > widthBmpMax )


@@ -1895,7 +1876,7 @@ void wxGTKRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
                                     wxBitmap *bmpPressed,
                                     wxBitmap *bmpDisabled)
 {
                                     wxBitmap *bmpPressed,
                                     wxBitmap *bmpDisabled)
 {

-    if ( !m_bitmapsCombo[ComboState_Normal].Ok() )
+    if ( !m_bitmapsCombo[ComboState_Normal].IsOk() )

     {
         InitComboBitmaps();
     }
     {
         InitComboBitmaps();
     }


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

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

             return;
     }
 
             return;
     }
 


@@ -2102,7 +2083,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);


@@ -2114,7 +2095,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
         case wxUP:
             dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
             dc.DrawPoint(ptArrow[Point_First]);
         case wxUP:
             dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
             dc.DrawPoint(ptArrow[Point_First]);

-            if ( penShadow[3].Ok() )
+            if ( penShadow[3].IsOk() )

             {
                 dc.SetPen(penShadow[3]);
                 dc.DrawLine(ptArrow[Point_First].x + 1, ptArrow[Point_First].y,
             {
                 dc.SetPen(penShadow[3]);
                 dc.DrawLine(ptArrow[Point_First].x + 1, ptArrow[Point_First].y,


@@ -2126,7 +2107,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
             dc.DrawPoint(ptArrow[Point_Third]);
             dc.DrawLine(ptArrow[Point_Third].x - 2, ptArrow[Point_Third].y,
                         ptArrow[Point_First].x + 1, ptArrow[Point_First].y);
             dc.DrawPoint(ptArrow[Point_Third]);
             dc.DrawLine(ptArrow[Point_Third].x - 2, ptArrow[Point_Third].y,
                         ptArrow[Point_First].x + 1, ptArrow[Point_First].y);

-            if ( penShadow[2].Ok() )
+            if ( penShadow[2].IsOk() )

             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,
             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,


@@ -2140,7 +2121,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
             dc.DrawLine(ptArrow[Point_First], ptArrow[Point_Second]);
             dc.DrawLine(ptArrow[Point_First].x + 2, ptArrow[Point_First].y,
                         ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y);
             dc.DrawLine(ptArrow[Point_First], ptArrow[Point_Second]);
             dc.DrawLine(ptArrow[Point_First].x + 2, ptArrow[Point_First].y,
                         ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y);

-            if ( penShadow[2].Ok() )
+            if ( penShadow[2].IsOk() )

             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Second].x, ptArrow[Point_Second].y - 1,
             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Second].x, ptArrow[Point_Second].y - 1,


@@ -2154,7 +2135,7 @@ void wxGTKRenderer::DrawArrow(wxDC& dc,
         case wxLEFT:
             dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
             dc.DrawPoint(ptArrow[Point_First]);
         case wxLEFT:
             dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
             dc.DrawPoint(ptArrow[Point_First]);

-            if ( penShadow[2].Ok() )
+            if ( penShadow[2].IsOk() )

             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,
             {
                 dc.SetPen(penShadow[2]);
                 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,


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

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

             return;
     }
 }
             return;
     }
 }


@@ -2245,24 +2226,6 @@ void wxGTKRenderer::DrawScrollbarShaft(wxDC& dc,
     DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
 }
 
     DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
 }
 

-#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 wxStdRenderer::GetScrollbarRect(scrollbar, elem, thumbPos);
-}
-
-#endif // wxUSE_SCROLLBAR
-

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


@@ -2302,12 +2265,13 @@ void wxGTKRenderer::AdjustSize(wxSize *size, const wxWindow *window)
 #if wxUSE_SCROLLBAR
     if ( wxDynamicCast(window, wxScrollBar) )
     {
 #if wxUSE_SCROLLBAR
     if ( wxDynamicCast(window, wxScrollBar) )
     {

-        // we only set the width of vert scrollbars and height of the
-        // horizontal ones
-        if ( window->GetWindowStyle() & wxSB_HORIZONTAL )
-            size->y = m_sizeScrollbarArrow.x;
-        else
-            size->x = m_sizeScrollbarArrow.x;
+        /*
+        Don't adjust the size for a scrollbar as its DoGetBestClientSize
+        already has the correct size set. Any size changes here would get
+        added to the best size, making the scrollbar larger.
+        Also skip border width adjustments, they don't make sense for us.
+        */
+        return;

     }
     else
 #endif // wxUSE_SCROLLBAR
     }
     else
 #endif // wxUSE_SCROLLBAR


@@ -2771,3 +2735,5 @@ bool wxGTKTextCtrlInputHandler::HandleKey(wxInputConsumer *control,
 }
 
 #endif // wxUSE_TEXTCTRL
 }
 
 #endif // wxUSE_TEXTCTRL

+
+#endif // wxUSE_THEME_GTK