]> git.saurik.com Git - wxWidgets.git/blobdiff - src/aui/dockart.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix broken and missing DataView interface items for Phoenix
[wxWidgets.git] / src / aui / dockart.cpp
diff --git a/src/aui/dockart.cpp b/src/aui/dockart.cpp
index 116fb7980477320c3cb7a65d501f846cdce4632c..8187939b028984f9039636d238bc6c56955c00cc 100644 (file)
--- a/src/aui/dockart.cpp
+++ b/src/aui/dockart.cpp
@@ -27,6 +27,8 @@
 
 #include "wx/aui/framemanager.h"
 #include "wx/aui/dockart.h"
 
 #include "wx/aui/framemanager.h"
 #include "wx/aui/dockart.h"
+#include "wx/aui/auibook.h"
+#include "wx/aui/tabart.h"
 
 #ifndef WX_PRECOMP
     #include "wx/settings.h"
 
 #ifndef WX_PRECOMP
     #include "wx/settings.h"
@@ -35,14 +37,22 @@
 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__
-#include "wx/mac/private.h"
+#include "wx/osx/private.h"
 #include "wx/graphics.h"
 #include "wx/graphics.h"
+#include "wx/dcgraph.h"
 #endif
 
 #ifdef __WXGTK__
 #include <gtk/gtk.h>
 #endif
 
 #ifdef __WXGTK__
 #include <gtk/gtk.h>
-#include "wx/gtk/win_gtk.h"
 #include "wx/renderer.h"
 #include "wx/renderer.h"
+#ifdef __WXGTK20__
+   #include "wx/gtk/private/gtk2-compat.h"
+#else
+   #define gtk_widget_is_drawable GTK_WIDGET_DRAWABLE
+#endif
+#ifdef __WXGTK3__
+    #include "wx/graphics.h"
+#endif
 #endif
 
 
 #endif
 
 
@@ -54,59 +64,6 @@
 // with custom dock art (probably by writing a new stand-alone class derived
 // from the wxAuiDockArt base class). The active dock art class can be set via
 // wxAuiManager::SetDockArt()
 // with custom dock art (probably by writing a new stand-alone class derived
 // from the wxAuiDockArt base class). The active dock art class can be set via
 // wxAuiManager::SetDockArt()
-
-
-// wxAuiBlendColour is used by wxAuiStepColour
-double wxAuiBlendColour(double fg, double bg, double alpha)
-{
-    double result = bg + (alpha * (fg - bg));
-    if (result < 0.0)
-        result = 0.0;
-    if (result > 255)
-        result = 255;
-    return result;
-}
-
-// wxAuiStepColour() it a utility function that simply darkens
-// or lightens a color, based on the specified percentage
-// ialpha of 0 would be completely black, 100 completely white
-// an ialpha of 100 returns the same colour
-wxColor wxAuiStepColour(const wxColor& c, int ialpha)
-{
-    if (ialpha == 100)
-        return c;
-        
-    double r = c.Red(), g = c.Green(), b = c.Blue();
-    double bg;
-    
-    // ialpha is 0..200 where 0 is completely black
-    // and 200 is completely white and 100 is the same
-    // convert that to normal alpha 0.0 - 1.0
-    ialpha = wxMin(ialpha, 200);
-    ialpha = wxMax(ialpha, 0);
-    double alpha = ((double)(ialpha - 100.0))/100.0;
-    
-    if (ialpha > 100)
-    {
-        // blend with white
-        bg = 255.0;
-        alpha = 1.0 - alpha;  // 0 = transparent fg; 1 = opaque fg
-    }
-     else
-    {
-        // blend with black
-        bg = 0.0;
-        alpha = 1.0 + alpha;  // 0 = transparent fg; 1 = opaque fg
-    }
-    
-    r = wxAuiBlendColour(r, bg, alpha);
-    g = wxAuiBlendColour(g, bg, alpha);
-    b = wxAuiBlendColour(b, bg, alpha);
-    
-    return wxColour((int)r, (int)g, (int)b);
-}
-
-
 wxColor wxAuiLightContrastColour(const wxColour& c)
 {
     int amount = 120;
 wxColor wxAuiLightContrastColour(const wxColour& c)
 {
     int amount = 120;
@@ -116,7 +73,7 @@ wxColor wxAuiLightContrastColour(const wxColour& c)
     if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
         amount = 160;
 
     if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
         amount = 160;
 
-    return wxAuiStepColour(c, amount);
+    return c.ChangeLightness(amount);
 }
 
 // wxAuiBitmapFromBits() is a utility function that creates a
 }
 
 // wxAuiBitmapFromBits() is a utility function that creates a
@@ -130,7 +87,7 @@ wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
     img.SetMaskColour(123,123,123);
     return wxBitmap(img);
 }
     img.SetMaskColour(123,123,123);
     return wxBitmap(img);
 }
-                             
+
 
 static void DrawGradientRectangle(wxDC& dc,
                                   const wxRect& rect,
 
 static void DrawGradientRectangle(wxDC& dc,
                                   const wxRect& rect,
@@ -145,14 +102,14 @@ static void DrawGradientRectangle(wxDC& dc,
 
     if (direction == wxAUI_GRADIENT_VERTICAL)
         high = rect.GetHeight()-1;
 
     if (direction == wxAUI_GRADIENT_VERTICAL)
         high = rect.GetHeight()-1;
-         else
+    else
         high = rect.GetWidth()-1;
 
     for (int i = 0; i <= high; ++i)
     {
         int r,g,b;
         high = rect.GetWidth()-1;
 
     for (int i = 0; i <= high; ++i)
     {
         int r,g,b;
-        
-        
+
+
         r = start_color.Red() + (high <= 0 ? 0 : (((i*rd*100)/high)/100));
         g = start_color.Green() + (high <= 0 ? 0 : (((i*gd*100)/high)/100));
         b = start_color.Blue() + (high <= 0 ? 0 : (((i*bd*100)/high)/100));
         r = start_color.Red() + (high <= 0 ? 0 : (((i*rd*100)/high)/100));
         g = start_color.Green() + (high <= 0 ? 0 : (((i*gd*100)/high)/100));
         b = start_color.Blue() + (high <= 0 ? 0 : (((i*bd*100)/high)/100));
@@ -164,7 +121,7 @@ static void DrawGradientRectangle(wxDC& dc,
 
         if (direction == wxAUI_GRADIENT_VERTICAL)
             dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
 
         if (direction == wxAUI_GRADIENT_VERTICAL)
             dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
-             else
+        else
             dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
     }
 }
             dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
     }
 }
@@ -172,23 +129,23 @@ static void DrawGradientRectangle(wxDC& dc,
 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
 {
     wxCoord x,y;
 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
 {
     wxCoord x,y;
-    
+
     // first check if the text fits with no problems
     dc.GetTextExtent(text, &x, &y);
     if (x <= max_size)
         return text;
     // first check if the text fits with no problems
     dc.GetTextExtent(text, &x, &y);
     if (x <= max_size)
         return text;
-        
+
     size_t i, len = text.Length();
     size_t last_good_length = 0;
     for (i = 0; i < len; ++i)
     {
         wxString s = text.Left(i);
         s += wxT("...");
     size_t i, len = text.Length();
     size_t last_good_length = 0;
     for (i = 0; i < len; ++i)
     {
         wxString s = text.Left(i);
         s += wxT("...");
-        
+
         dc.GetTextExtent(s, &x, &y);
         if (x > max_size)
             break;
         dc.GetTextExtent(s, &x, &y);
         if (x > max_size)
             break;
-        
+
         last_good_length = i;
     }
 
         last_good_length = i;
     }
 
@@ -199,144 +156,150 @@ wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
 
 wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 {
 
 wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 {
-#ifdef __WXMAC__
-    wxBrush toolbarbrush;
-    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
-    wxColor base_colour = toolbarbrush.GetColour();
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+    wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
 #else
 #else
-    wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #endif
 
 #endif
 
-    // the base_colour is too pale to use as our base colour,
+    // the baseColour is too pale to use as our base colour,
     // so darken it a bit --
     // so darken it a bit --
-    if ((255-base_colour.Red()) +
-        (255-base_colour.Green()) +
-        (255-base_colour.Blue()) < 60)
+    if ((255-baseColour.Red()) +
+        (255-baseColour.Green()) +
+        (255-baseColour.Blue()) < 60)
     {
     {
-        base_colour = wxAuiStepColour(base_colour, 92);
+        baseColour = baseColour.ChangeLightness(92);
     }
     }
-    
-    m_base_colour = base_colour;
-    wxColor darker1_colour = wxAuiStepColour(base_colour, 85);
-    wxColor darker2_colour = wxAuiStepColour(base_colour, 75);
-    wxColor darker3_colour = wxAuiStepColour(base_colour, 60);
-    wxColor darker4_colour = wxAuiStepColour(base_colour, 50);
-    wxColor darker5_colour = wxAuiStepColour(base_colour, 40);
-
-    m_active_caption_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
-    m_active_caption_gradient_colour = wxAuiLightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
-    m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
-    m_inactive_caption_colour = darker1_colour;
-    m_inactive_caption_gradient_colour = wxAuiStepColour(base_colour, 97);
-    m_inactive_caption_text_colour = *wxBLACK;
+
+    m_baseColour = baseColour;
+    wxColor darker1Colour = baseColour.ChangeLightness(85);
+    wxColor darker2Colour = baseColour.ChangeLightness(75);
+    wxColor darker3Colour = baseColour.ChangeLightness(60);
+    //wxColor darker4Colour = baseColour.ChangeLightness(50);
+    wxColor darker5Colour = baseColour.ChangeLightness(40);
+
+    m_activeCaptionColour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+    m_activeCaptionGradientColour = wxAuiLightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
+    m_activeCaptionTextColour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+    m_inactiveCaptionColour = darker1Colour;
+    m_inactiveCaptionGradientColour = baseColour.ChangeLightness(97);
+    m_inactiveCaptionTextColour = *wxBLACK;
+
+    m_sashBrush = wxBrush(baseColour);
+    m_backgroundBrush = wxBrush(baseColour);
+    m_gripperBrush = wxBrush(baseColour);
+
+    m_borderPen = wxPen(darker2Colour);
+    m_gripperPen1 = wxPen(darker5Colour);
+    m_gripperPen2 = wxPen(darker3Colour);
+    m_gripperPen3 = *wxWHITE_PEN;
 
 #ifdef __WXMAC__
 
 #ifdef __WXMAC__
-    m_sash_brush = toolbarbrush;
-    m_background_brush = toolbarbrush;
-    m_gripper_brush = toolbarbrush;
+    m_captionFont = *wxSMALL_FONT;
 #else
 #else
-    m_sash_brush = wxBrush(base_colour);
-    m_background_brush = wxBrush(base_colour);
-    m_gripper_brush = wxBrush(base_colour);
+    m_captionFont = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
 #endif
 #endif
-    m_border_pen = wxPen(darker2_colour);
-    m_gripper_pen1 = wxPen(darker5_colour);
-    m_gripper_pen2 = wxPen(darker3_colour);
-    m_gripper_pen3 = *wxWHITE_PEN;
 
 
-#ifdef __WXMAC__
-    m_caption_font = *wxSMALL_FONT;
+    // default metric values
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+    SInt32 height;
+    GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
+    m_sashSize = height;
+#elif defined(__WXGTK__)
+    m_sashSize = wxRendererNative::Get().GetSplitterParams(NULL).widthSash;
 #else
 #else
-    m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
+    m_sashSize = 4;
 #endif
 #endif
+    m_captionSize = 17;
+    m_borderSize = 1;
+    m_buttonSize = 14;
+    m_gripperSize = 9;
+    m_gradientType = wxAUI_GRADIENT_VERTICAL;
+
+    InitBitmaps();
+}
 
 
+void
+wxAuiDefaultDockArt::InitBitmaps ()
+{
     // some built in bitmaps
 #if defined( __WXMAC__ )
     // some built in bitmaps
 #if defined( __WXMAC__ )
-     static unsigned char close_bits[]={
+     static const unsigned char close_bits[]={
          0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
          0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
          0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
          0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
          0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
          0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
-#elif defined( __WXGTK__)       
-     static unsigned char close_bits[]={        
-         0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,        
-         0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,        
-         0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };      
+#elif defined(__WXGTK__)
+     static const unsigned char close_bits[]={
+         0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
+         0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
+         0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 #else
 #else
-    static unsigned char close_bits[]={
-         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
-         0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
-         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+    static const unsigned char close_bits[]={
+         // reduced height, symmetric
+         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf3, 0x9f, 0xf9,
+         0x3f, 0xfc, 0x7f, 0xfe, 0x3f, 0xfc, 0x9f, 0xf9, 0xcf, 0xf3, 0xff, 0xff,
+         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+      /*
+         // same height as maximize/restore
+         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xcf, 0xf3, 0x9f, 0xf9,
+         0x3f, 0xfc, 0x7f, 0xfe, 0x3f, 0xfc, 0x9f, 0xf9, 0xcf, 0xf3, 0xe7, 0xe7,
+         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+      */
 #endif
 
 #endif
 
-    static unsigned char maximize_bits[] = {
+    static const unsigned char maximize_bits[] = {
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
         0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
         0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
-    static unsigned char restore_bits[]={
+    static const unsigned char restore_bits[]={
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
         0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
         0x07, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
         0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
         0x07, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-        
-    static unsigned char pin_bits[]={
+
+    static const unsigned char pin_bits[]={
         0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
         0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
         0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
 
 #ifdef __WXMAC__
         0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
         0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
         0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
 
 #ifdef __WXMAC__
-    m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE);
-    m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE );
+    m_inactiveCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE);
+    m_activeCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE );
 #else
 #else
-    m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
+    m_inactiveCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_activeCaptionTextColour);
 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__
-    m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
-    m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
+    m_inactiveMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
+    m_activeMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
 #else
 #else
-    m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_active_caption_text_colour);
+    m_inactiveMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_activeCaptionTextColour);
 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__
-    m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
-    m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
 #else
 #else
-    m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_active_caption_text_colour);
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_activeCaptionTextColour);
 #endif
 
 #endif
 
-    m_inactive_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
-
-    // default metric values
-#if defined(__WXMAC__)
-    SInt32 height;
-    GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
-    m_sash_size = height;
-#elif defined(__WXGTK__)
-    m_sash_size = wxRendererNative::Get().GetSplitterParams(NULL).widthSash;
-#else
-    m_sash_size = 4;
-#endif
-    m_caption_size = 17;
-    m_border_size = 1;
-    m_button_size = 14;
-    m_gripper_size = 9;
-    m_gradient_type = wxAUI_GRADIENT_VERTICAL;
+    m_inactivePinBitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activePinBitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_activeCaptionTextColour);
 }
 
 int wxAuiDefaultDockArt::GetMetric(int id)
 {
     switch (id)
     {
 }
 
 int wxAuiDefaultDockArt::GetMetric(int id)
 {
     switch (id)
     {
-        case wxAUI_DOCKART_SASH_SIZE:          return m_sash_size;
-        case wxAUI_DOCKART_CAPTION_SIZE:       return m_caption_size;
-        case wxAUI_DOCKART_GRIPPER_SIZE:       return m_gripper_size;
-        case wxAUI_DOCKART_PANE_BORDER_SIZE:   return m_border_size;
-        case wxAUI_DOCKART_PANE_BUTTON_SIZE:   return m_button_size;
-        case wxAUI_DOCKART_GRADIENT_TYPE:      return m_gradient_type;
+        case wxAUI_DOCKART_SASH_SIZE:          return m_sashSize;
+        case wxAUI_DOCKART_CAPTION_SIZE:       return m_captionSize;
+        case wxAUI_DOCKART_GRIPPER_SIZE:       return m_gripperSize;
+        case wxAUI_DOCKART_PANE_BORDER_SIZE:   return m_borderSize;
+        case wxAUI_DOCKART_PANE_BUTTON_SIZE:   return m_buttonSize;
+        case wxAUI_DOCKART_GRADIENT_TYPE:      return m_gradientType;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
@@ -347,12 +310,12 @@ void wxAuiDefaultDockArt::SetMetric(int id, int new_val)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_DOCKART_SASH_SIZE:          m_sash_size = new_val; break;
-        case wxAUI_DOCKART_CAPTION_SIZE:       m_caption_size = new_val; break;
-        case wxAUI_DOCKART_GRIPPER_SIZE:       m_gripper_size = new_val; break;
-        case wxAUI_DOCKART_PANE_BORDER_SIZE:   m_border_size = new_val; break;
-        case wxAUI_DOCKART_PANE_BUTTON_SIZE:   m_button_size = new_val; break;
-        case wxAUI_DOCKART_GRADIENT_TYPE:      m_gradient_type = new_val; break;
+        case wxAUI_DOCKART_SASH_SIZE:          m_sashSize = new_val; break;
+        case wxAUI_DOCKART_CAPTION_SIZE:       m_captionSize = new_val; break;
+        case wxAUI_DOCKART_GRIPPER_SIZE:       m_gripperSize = new_val; break;
+        case wxAUI_DOCKART_PANE_BORDER_SIZE:   m_borderSize = new_val; break;
+        case wxAUI_DOCKART_PANE_BUTTON_SIZE:   m_buttonSize = new_val; break;
+        case wxAUI_DOCKART_GRADIENT_TYPE:      m_gradientType = new_val; break;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 }
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 }
@@ -361,16 +324,16 @@ wxColour wxAuiDefaultDockArt::GetColour(int id)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_DOCKART_BACKGROUND_COLOUR:                return m_background_brush.GetColour();
-        case wxAUI_DOCKART_SASH_COLOUR:                      return m_sash_brush.GetColour();
-        case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          return m_inactive_caption_colour;
-        case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
-        case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactive_caption_text_colour;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            return m_active_caption_colour;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_active_caption_gradient_colour;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_active_caption_text_colour;
-        case wxAUI_DOCKART_BORDER_COLOUR:                    return m_border_pen.GetColour();
-        case wxAUI_DOCKART_GRIPPER_COLOUR:                   return m_gripper_brush.GetColour();
+        case wxAUI_DOCKART_BACKGROUND_COLOUR:                return m_backgroundBrush.GetColour();
+        case wxAUI_DOCKART_SASH_COLOUR:                      return m_sashBrush.GetColour();
+        case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          return m_inactiveCaptionColour;
+        case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactiveCaptionGradientColour;
+        case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactiveCaptionTextColour;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            return m_activeCaptionColour;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_activeCaptionGradientColour;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_activeCaptionTextColour;
+        case wxAUI_DOCKART_BORDER_COLOUR:                    return m_borderPen.GetColour();
+        case wxAUI_DOCKART_GRIPPER_COLOUR:                   return m_gripperBrush.GetColour();
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
@@ -381,51 +344,49 @@ void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_DOCKART_BACKGROUND_COLOUR:                m_background_brush.SetColour(colour); break;
-        case wxAUI_DOCKART_SASH_COLOUR:                      m_sash_brush.SetColour(colour); break;
-        case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          m_inactive_caption_colour = colour; break;
-        case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
-        case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     m_inactive_caption_text_colour = colour; break;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            m_active_caption_colour = colour; break;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   m_active_caption_gradient_colour = colour; break;
-        case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       m_active_caption_text_colour = colour; break;
-        case wxAUI_DOCKART_BORDER_COLOUR:                    m_border_pen.SetColour(colour); break;
+        case wxAUI_DOCKART_BACKGROUND_COLOUR:                m_backgroundBrush.SetColour(colour); break;
+        case wxAUI_DOCKART_SASH_COLOUR:                      m_sashBrush.SetColour(colour); break;
+        case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          m_inactiveCaptionColour = colour; break;
+        case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactiveCaptionGradientColour = colour; break;
+        case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     m_inactiveCaptionTextColour = colour; break;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            m_activeCaptionColour = colour; break;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   m_activeCaptionGradientColour = colour; break;
+        case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       m_activeCaptionTextColour = colour; break;
+        case wxAUI_DOCKART_BORDER_COLOUR:                    m_borderPen.SetColour(colour); break;
         case wxAUI_DOCKART_GRIPPER_COLOUR:
         case wxAUI_DOCKART_GRIPPER_COLOUR:
-            m_gripper_brush.SetColour(colour);
-            m_gripper_pen1.SetColour(wxAuiStepColour(colour, 40));
-            m_gripper_pen2.SetColour(wxAuiStepColour(colour, 60));
+            m_gripperBrush.SetColour(colour);
+            m_gripperPen1.SetColour(colour.ChangeLightness(40));
+            m_gripperPen2.SetColour(colour.ChangeLightness(60));
             break;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
             break;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
+
+    InitBitmaps();
 }
 
 void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 {
     if (id == wxAUI_DOCKART_CAPTION_FONT)
 }
 
 void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 {
     if (id == wxAUI_DOCKART_CAPTION_FONT)
-        m_caption_font = font;
+        m_captionFont = font;
 }
 
 wxFont wxAuiDefaultDockArt::GetFont(int id)
 {
     if (id == wxAUI_DOCKART_CAPTION_FONT)
 }
 
 wxFont wxAuiDefaultDockArt::GetFont(int id)
 {
     if (id == wxAUI_DOCKART_CAPTION_FONT)
-        return m_caption_font;
+        return m_captionFont;
     return wxNullFont;
 }
 
 void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
 {
     return wxNullFont;
 }
 
 void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
 {
-#if defined(__WXMAC__)
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+    wxUnusedVar(window);
+    wxUnusedVar(orientation);
+
     HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
     CGContextRef cgContext ;
     HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
     CGContextRef cgContext ;
-#if wxMAC_USE_CORE_GRAPHICS
-    cgContext = (CGContextRef) dc.GetGraphicsContext()->GetNativeContext() ;
-#else
-    Rect bounds ;
-    GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
-    QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
-    CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
-    CGContextScaleCTM( cgContext , 1 , -1 ) ;
-#endif
+    wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
+    cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext() ;
 
     HIThemeSplitterDrawInfo drawInfo ;
     drawInfo.version = 0 ;
 
     HIThemeSplitterDrawInfo drawInfo ;
     drawInfo.version = 0 ;
@@ -433,23 +394,19 @@ void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation,
     drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
     HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
 
     drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
     HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
 
-#if wxMAC_USE_CORE_GRAPHICS
-#else
-    QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
-#endif
-
 #elif defined(__WXGTK__)
     // clear out the rectangle first
     dc.SetPen(*wxTRANSPARENT_PEN);
 #elif defined(__WXGTK__)
     // clear out the rectangle first
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetBrush(m_sash_brush);
+    dc.SetBrush(m_sashBrush);
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 
+#if 0
     GdkRectangle gdk_rect;
     if (orientation == wxVERTICAL )
     {
         gdk_rect.x = rect.x;
         gdk_rect.y = rect.y;
     GdkRectangle gdk_rect;
     if (orientation == wxVERTICAL )
     {
         gdk_rect.x = rect.x;
         gdk_rect.y = rect.y;
-        gdk_rect.width = m_sash_size;
+        gdk_rect.width = m_sashSize;
         gdk_rect.height = rect.height;
     }
     else
         gdk_rect.height = rect.height;
     }
     else
@@ -457,21 +414,28 @@ void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation,
         gdk_rect.x = rect.x;
         gdk_rect.y = rect.y;
         gdk_rect.width = rect.width;
         gdk_rect.x = rect.x;
         gdk_rect.y = rect.y;
         gdk_rect.width = rect.width;
-        gdk_rect.height = m_sash_size;
+        gdk_rect.height = m_sashSize;
     }
     }
+#endif
 
     if (!window) return;
     if (!window->m_wxwindow) return;
 
     if (!window) return;
     if (!window->m_wxwindow) return;
-    if (!GTK_PIZZA(window->m_wxwindow)->bin_window) return;
+    if (!gtk_widget_is_drawable(window->m_wxwindow)) return;
 
     gtk_paint_handle
     (
 
     gtk_paint_handle
     (
-        window->m_wxwindow->style,
-        GTK_PIZZA(window->m_wxwindow)->bin_window,
+        gtk_widget_get_style(window->m_wxwindow),
+#ifdef __WXGTK3__
+        static_cast<cairo_t*>(dc.GetGraphicsContext()->GetNativeContext()),
+#else
+        window->GTKGetDrawingWindow(),
+#endif
         // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
         GTK_STATE_NORMAL,
         GTK_SHADOW_NONE,
         // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
         GTK_STATE_NORMAL,
         GTK_SHADOW_NONE,
+#ifndef __WXGTK3__
         NULL /* no clipping */,
         NULL /* no clipping */,
+#endif
         window->m_wxwindow,
         "paned",
         rect.x,
         window->m_wxwindow,
         "paned",
         rect.x,
@@ -485,7 +449,7 @@ void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation,
     wxUnusedVar(window);
     wxUnusedVar(orientation);
     dc.SetPen(*wxTRANSPARENT_PEN);
     wxUnusedVar(window);
     wxUnusedVar(orientation);
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetBrush(m_sash_brush);
+    dc.SetBrush(m_sashBrush);
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 #endif
 }
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 #endif
 }
@@ -500,14 +464,14 @@ void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), i
     dc.SetBrush(*wxWHITE_BRUSH) ;
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 #endif
     dc.SetBrush(*wxWHITE_BRUSH) ;
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 #endif
-    dc.SetBrush(m_background_brush);
+    dc.SetBrush(m_backgroundBrush);
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 }
 
     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 }
 
-void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
+void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow* window, const wxRect& _rect,
                                   wxAuiPaneInfo& pane)
 {
                                   wxAuiPaneInfo& pane)
 {
-    dc.SetPen(m_border_pen);
+    dc.SetPen(m_borderPen);
     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
     wxRect rect = _rect;
     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
     wxRect rect = _rect;
@@ -520,7 +484,7 @@ void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const
             dc.SetPen(*wxWHITE_PEN);
             dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
             dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
             dc.SetPen(*wxWHITE_PEN);
             dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
             dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
-            dc.SetPen(m_border_pen);
+            dc.SetPen(m_borderPen);
             dc.DrawLine(rect.x, rect.y+rect.height-1,
                         rect.x+rect.width, rect.y+rect.height-1);
             dc.DrawLine(rect.x+rect.width-1, rect.y,
             dc.DrawLine(rect.x, rect.y+rect.height-1,
                         rect.x+rect.width, rect.y+rect.height-1);
             dc.DrawLine(rect.x+rect.width-1, rect.y,
@@ -530,10 +494,21 @@ void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const
     }
     else
     {
     }
     else
     {
-        for (i = 0; i < border_width; ++i)
+        // notebooks draw the border themselves, so they can use native rendering (e.g. tabartgtk)
+        wxAuiTabArt* art = 0;
+        wxAuiNotebook* nb = wxDynamicCast(window, wxAuiNotebook);
+        if (nb)
+            art = nb->GetArtProvider();
+
+        if (art)
+            art->DrawBorder(dc, window, rect);
+        else
         {
         {
-            dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
-            rect.Deflate(1);
+            for (i = 0; i < border_width; ++i)
+            {
+                dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
+                rect.Deflate(1);
+            }
         }
     }
 }
         }
     }
 }
@@ -541,12 +516,12 @@ void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const
 
 void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
 {
 
 void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
 {
-    if (m_gradient_type == wxAUI_GRADIENT_NONE)
+    if (m_gradientType == wxAUI_GRADIENT_NONE)
     {
         if (active)
     {
         if (active)
-            dc.SetBrush(wxBrush(m_active_caption_colour));
-             else
-            dc.SetBrush(wxBrush(m_inactive_caption_colour));
+            dc.SetBrush(wxBrush(m_activeCaptionColour));
+        else
+            dc.SetBrush(wxBrush(m_inactiveCaptionColour));
 
         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
     }
 
         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
     }
@@ -557,31 +532,31 @@ void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bo
             // on mac the gradients are expected to become darker from the top
 #ifdef __WXMAC__
             DrawGradientRectangle(dc, rect,
             // on mac the gradients are expected to become darker from the top
 #ifdef __WXMAC__
             DrawGradientRectangle(dc, rect,
-                                 m_active_caption_colour,
-                                 m_active_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_activeCaptionColour,
+                                 m_activeCaptionGradientColour,
+                                 m_gradientType);
 #else
             // on other platforms, active gradients become lighter at the top
             DrawGradientRectangle(dc, rect,
 #else
             // on other platforms, active gradients become lighter at the top
             DrawGradientRectangle(dc, rect,
-                                 m_active_caption_gradient_colour,
-                                 m_active_caption_colour,
-                                 m_gradient_type);
+                                 m_activeCaptionGradientColour,
+                                 m_activeCaptionColour,
+                                 m_gradientType);
 #endif
         }
 #endif
         }
-         else
+        else
         {
 #ifdef __WXMAC__
             // on mac the gradients are expected to become darker from the top
             DrawGradientRectangle(dc, rect,
         {
 #ifdef __WXMAC__
             // on mac the gradients are expected to become darker from the top
             DrawGradientRectangle(dc, rect,
-                                 m_inactive_caption_gradient_colour,
-                                 m_inactive_caption_colour,
-                                 m_gradient_type);
+                                 m_inactiveCaptionGradientColour,
+                                 m_inactiveCaptionColour,
+                                 m_gradientType);
 #else
             // on other platforms, inactive gradients become lighter at the bottom
             DrawGradientRectangle(dc, rect,
 #else
             // on other platforms, inactive gradients become lighter at the bottom
             DrawGradientRectangle(dc, rect,
-                                 m_inactive_caption_colour,
-                                 m_inactive_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_inactiveCaptionColour,
+                                 m_inactiveCaptionGradientColour,
+                                 m_gradientType);
 #endif
         }
     }
 #endif
         }
     }
@@ -594,15 +569,23 @@ void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
                                    wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
                                    wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetFont(m_caption_font);
+    dc.SetFont(m_captionFont);
 
     DrawCaptionBackground(dc, rect,
                           (pane.state & wxAuiPaneInfo::optionActive)?true:false);
 
 
     DrawCaptionBackground(dc, rect,
                           (pane.state & wxAuiPaneInfo::optionActive)?true:false);
 
+    int caption_offset = 0;
+    if ( pane.icon.IsOk() )
+    {
+        DrawIcon(dc, rect, pane);
+
+        caption_offset += pane.icon.GetWidth() + 3;
+    }
+
     if (pane.state & wxAuiPaneInfo::optionActive)
     if (pane.state & wxAuiPaneInfo::optionActive)
-        dc.SetTextForeground(m_active_caption_text_colour);
+        dc.SetTextForeground(m_activeCaptionTextColour);
     else
     else
-        dc.SetTextForeground(m_inactive_caption_text_colour);
+        dc.SetTextForeground(m_inactiveCaptionTextColour);
 
 
     wxCoord w,h;
 
 
     wxCoord w,h;
@@ -612,25 +595,34 @@ void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
     clip_rect.width -= 3; // text offset
     clip_rect.width -= 2; // button padding
     if (pane.HasCloseButton())
     clip_rect.width -= 3; // text offset
     clip_rect.width -= 2; // button padding
     if (pane.HasCloseButton())
-        clip_rect.width -= m_button_size;
+        clip_rect.width -= m_buttonSize;
     if (pane.HasPinButton())
     if (pane.HasPinButton())
-        clip_rect.width -= m_button_size;    
+        clip_rect.width -= m_buttonSize;
     if (pane.HasMaximizeButton())
     if (pane.HasMaximizeButton())
-        clip_rect.width -= m_button_size;    
+        clip_rect.width -= m_buttonSize;
 
     wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
 
     dc.SetClippingRegion(clip_rect);
 
     wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
 
     dc.SetClippingRegion(clip_rect);
-    dc.DrawText(draw_text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
+    dc.DrawText(draw_text, rect.x+3 + caption_offset, rect.y+(rect.height/2)-(h/2)-1);
     dc.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 
+void
+wxAuiDefaultDockArt::DrawIcon(wxDC& dc, const wxRect& rect, wxAuiPaneInfo& pane)
+{
+   // Draw the icon centered vertically
+   dc.DrawBitmap(pane.icon,
+                 rect.x+2, rect.y+(rect.height-pane.icon.GetHeight())/2,
+                 true);
+}
+
 void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
                                    const wxRect& rect,
                                    wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
                                    const wxRect& rect,
                                    wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetBrush(m_gripper_brush);
+    dc.SetBrush(m_gripperBrush);
 
     dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
 
 
     dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
 
@@ -639,12 +631,12 @@ void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
         int y = 5;
         while (1)
         {
         int y = 5;
         while (1)
         {
-            dc.SetPen(m_gripper_pen1);
+            dc.SetPen(m_gripperPen1);
             dc.DrawPoint(rect.x+3, rect.y+y);
             dc.DrawPoint(rect.x+3, rect.y+y);
-            dc.SetPen(m_gripper_pen2);
+            dc.SetPen(m_gripperPen2);
             dc.DrawPoint(rect.x+3, rect.y+y+1);
             dc.DrawPoint(rect.x+4, rect.y+y);
             dc.DrawPoint(rect.x+3, rect.y+y+1);
             dc.DrawPoint(rect.x+4, rect.y+y);
-            dc.SetPen(m_gripper_pen3);
+            dc.SetPen(m_gripperPen3);
             dc.DrawPoint(rect.x+5, rect.y+y+1);
             dc.DrawPoint(rect.x+5, rect.y+y+2);
             dc.DrawPoint(rect.x+4, rect.y+y+2);
             dc.DrawPoint(rect.x+5, rect.y+y+1);
             dc.DrawPoint(rect.x+5, rect.y+y+2);
             dc.DrawPoint(rect.x+4, rect.y+y+2);
@@ -659,12 +651,12 @@ void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
         int x = 5;
         while (1)
         {
         int x = 5;
         while (1)
         {
-            dc.SetPen(m_gripper_pen1);
+            dc.SetPen(m_gripperPen1);
             dc.DrawPoint(rect.x+x, rect.y+3);
             dc.DrawPoint(rect.x+x, rect.y+3);
-            dc.SetPen(m_gripper_pen2);
+            dc.SetPen(m_gripperPen2);
             dc.DrawPoint(rect.x+x+1, rect.y+3);
             dc.DrawPoint(rect.x+x, rect.y+4);
             dc.DrawPoint(rect.x+x+1, rect.y+3);
             dc.DrawPoint(rect.x+x, rect.y+4);
-            dc.SetPen(m_gripper_pen3);
+            dc.SetPen(m_gripperPen3);
             dc.DrawPoint(rect.x+x+1, rect.y+5);
             dc.DrawPoint(rect.x+x+2, rect.y+5);
             dc.DrawPoint(rect.x+x+2, rect.y+4);
             dc.DrawPoint(rect.x+x+1, rect.y+5);
             dc.DrawPoint(rect.x+x+2, rect.y+5);
             dc.DrawPoint(rect.x+x+2, rect.y+4);
@@ -683,35 +675,37 @@ void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
                                       wxAuiPaneInfo& pane)
 {
     wxBitmap bmp;
                                       wxAuiPaneInfo& pane)
 {
     wxBitmap bmp;
+    if (!(&pane))
+        return;
     switch (button)
     {
         default:
         case wxAUI_BUTTON_CLOSE:
             if (pane.state & wxAuiPaneInfo::optionActive)
     switch (button)
     {
         default:
         case wxAUI_BUTTON_CLOSE:
             if (pane.state & wxAuiPaneInfo::optionActive)
-                bmp = m_active_close_bitmap;
-                 else
-                bmp = m_inactive_close_bitmap;
+                bmp = m_activeCloseBitmap;
+            else
+                bmp = m_inactiveCloseBitmap;
             break;
         case wxAUI_BUTTON_PIN:
             if (pane.state & wxAuiPaneInfo::optionActive)
             break;
         case wxAUI_BUTTON_PIN:
             if (pane.state & wxAuiPaneInfo::optionActive)
-                bmp = m_active_pin_bitmap;
-                 else
-                bmp = m_inactive_pin_bitmap;
+                bmp = m_activePinBitmap;
+            else
+                bmp = m_inactivePinBitmap;
             break;
         case wxAUI_BUTTON_MAXIMIZE_RESTORE:
             if (pane.IsMaximized())
             {
                 if (pane.state & wxAuiPaneInfo::optionActive)
             break;
         case wxAUI_BUTTON_MAXIMIZE_RESTORE:
             if (pane.IsMaximized())
             {
                 if (pane.state & wxAuiPaneInfo::optionActive)
-                    bmp = m_active_restore_bitmap;
-                     else
-                    bmp = m_inactive_restore_bitmap;
+                    bmp = m_activeRestoreBitmap;
+                else
+                    bmp = m_inactiveRestoreBitmap;
             }
             }
-             else
+            else
             {
                 if (pane.state & wxAuiPaneInfo::optionActive)
             {
                 if (pane.state & wxAuiPaneInfo::optionActive)
-                    bmp = m_active_maximize_bitmap;
-                     else
-                    bmp = m_inactive_maximize_bitmap;
+                    bmp = m_activeMaximizeBitmap;
+                else
+                    bmp = m_inactiveMaximizeBitmap;
             }
             break;
     }
             }
             break;
     }
@@ -735,13 +729,13 @@ void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
     {
         if (pane.state & wxAuiPaneInfo::optionActive)
         {
     {
         if (pane.state & wxAuiPaneInfo::optionActive)
         {
-            dc.SetBrush(wxBrush(wxAuiStepColour(m_active_caption_colour, 120)));
-            dc.SetPen(wxPen(wxAuiStepColour(m_active_caption_colour, 70)));
+            dc.SetBrush(wxBrush(m_activeCaptionColour.ChangeLightness(120)));
+            dc.SetPen(wxPen(m_activeCaptionColour.ChangeLightness(70)));
         }
         }
-         else
+        else
         {
         {
-            dc.SetBrush(wxBrush(wxAuiStepColour(m_inactive_caption_colour, 120)));
-            dc.SetPen(wxPen(wxAuiStepColour(m_inactive_caption_colour, 70)));
+            dc.SetBrush(wxBrush(m_inactiveCaptionColour.ChangeLightness(120)));
+            dc.SetPen(wxPen(m_inactiveCaptionColour.ChangeLightness(70)));
         }
 
         // draw the background behind the button
         }
 
         // draw the background behind the button
wxWidgets (Impactor)