]> 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
new file added
[wxWidgets.git] / src / aui / dockart.cpp
diff --git a/src/aui/dockart.cpp b/src/aui/dockart.cpp
index 1eab5042d2a609048efc924d169a457ef3f6bdb1..c25509122c1ceaa9f9f98e8dd1e4cfdcfa74e699 100644 (file)
--- a/src/aui/dockart.cpp
+++ b/src/aui/dockart.cpp
@@ -35,38 +35,34 @@
 #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
 
 
-// -- wxDefaultDockArt class implementation --
+// -- wxAuiDefaultDockArt class implementation --
 
 
-// wxDefaultDockArt is an art provider class which does all of the drawing for
-// wxFrameManager.  This allows the library caller to customize the dock art
+// wxAuiDefaultDockArt is an art provider class which does all of the drawing for
+// wxAuiManager.  This allows the library caller to customize the dock art
 // (probably by deriving from this class), or to completely replace all drawing
 // with custom dock art (probably by writing a new stand-alone class derived
 // (probably by deriving from this class), or to completely replace all drawing
 // with custom dock art (probably by writing a new stand-alone class derived
-// from the wxDockArt base class). The active dock art class can be set via
-// wxFrameManager::SetDockArt()
-
-
-// StepColour() it a utility function that simply darkens
-// or lightens a color, based on the specified percentage
-static wxColor StepColour(const wxColor& c, int percent)
-{
-    int r = c.Red(), g = c.Green(), b = c.Blue();
-    return wxColour((unsigned char)wxMin((r*percent)/100,255),
-                    (unsigned char)wxMin((g*percent)/100,255),
-                    (unsigned char)wxMin((b*percent)/100,255));
-}
-
-static wxColor LightContrastColour(const wxColour& c)
+// from the wxAuiDockArt base class). The active dock art class can be set via
+// wxAuiManager::SetDockArt()
+wxColor wxAuiLightContrastColour(const wxColour& c)
 {
     int amount = 120;
 
 {
     int amount = 120;
 
@@ -75,13 +71,13 @@ static wxColor LightContrastColour(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 StepColour(c, amount);
+    return c.ChangeLightness(amount);
 }
 
 }
 
-// BitmapFromBits() is a utility function that creates a
+// wxAuiBitmapFromBits() is a utility function that creates a
 // masked bitmap from raw bits (XBM format)
 // masked bitmap from raw bits (XBM format)
-static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
-                               const wxColour& color)
+wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
+                             const wxColour& color)
 {
     wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
     img.Replace(0,0,0,123,123,123);
 {
     wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
     img.Replace(0,0,0,123,123,123);
@@ -104,14 +100,17 @@ 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)
     {
         high = rect.GetWidth()-1;
 
     for (int i = 0; i <= high; ++i)
     {
-        int r = start_color.Red() +  ((i*rd*100)/high)/100;
-        int g = start_color.Green() + ((i*gd*100)/high)/100;
-        int b = start_color.Blue() + ((i*bd*100)/high)/100;
+        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));
 
         wxPen p(wxColor((unsigned char)r,
                         (unsigned char)g,
 
         wxPen p(wxColor((unsigned char)r,
                         (unsigned char)g,
@@ -120,207 +119,272 @@ 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);
     }
+}
+
+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;
+
+    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;
+
+        last_good_length = i;
+    }
+
+    wxString ret = text.Left(last_good_length);
+    ret += wxT("...");
+    return ret;
 }
 
 }
 
-wxDefaultDockArt::wxDefaultDockArt()
+wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 {
 {
-#ifdef __WXMAC__
-    wxBrush toolbarbrush;
-    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
-    wxColor base_color = toolbarbrush.GetColour();
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+    wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
 #else
 #else
-    wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #endif
 
 #endif
 
-    wxColor darker1_color = StepColour(base_color, 85);
-    wxColor darker2_color = StepColour(base_color, 70);
-    wxColor darker3_color = StepColour(base_color, 60);
-    wxColor darker4_color = StepColour(base_color, 50);
-    wxColor darker5_color = StepColour(base_color, 40);
+    // the baseColour is too pale to use as our base colour,
+    // so darken it a bit --
+    if ((255-baseColour.Red()) +
+        (255-baseColour.Green()) +
+        (255-baseColour.Blue()) < 60)
+    {
+        baseColour = baseColour.ChangeLightness(92);
+    }
 
 
-    m_active_caption_colour = LightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
-    m_active_caption_gradient_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
-    m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
-    m_inactive_caption_colour = StepColour(darker1_color, 80);
-    m_inactive_caption_gradient_colour = darker1_color;
-    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_color);
-    m_background_brush = wxBrush(base_color);
-    m_gripper_brush = wxBrush(base_color);
+    m_captionFont = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
 #endif
 #endif
-    m_border_pen = wxPen(darker2_color);
-    m_gripper_pen1 = wxPen(darker5_color);
-    m_gripper_pen2 = wxPen(darker3_color);
-    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[]={
+#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
          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
-    static unsigned char close_bits[]={
-        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
-        0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
-        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 pin_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};
+
+    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};
+
+    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 = BitmapFromBits(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 = BitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
+    m_inactiveCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeCloseBitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_activeCaptionTextColour);
 #endif
 #endif
-    m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
+
 #ifdef __WXMAC__
 #ifdef __WXMAC__
-    m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE );
+    m_inactiveMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
+    m_activeMaximizeBitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
 #else
 #else
-    m_active_close_bitmap = BitmapFromBits(close_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
 #endif
-    m_active_pin_bitmap = BitmapFromBits(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;
+#ifdef __WXMAC__
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
 #else
 #else
-    m_sash_size = 4;
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_activeCaptionTextColour);
 #endif
 #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 wxDefaultDockArt::GetMetric(int id)
+int wxAuiDefaultDockArt::GetMetric(int id)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_ART_SASH_SIZE:          return m_sash_size;
-        case wxAUI_ART_CAPTION_SIZE:       return m_caption_size;
-        case wxAUI_ART_GRIPPER_SIZE:       return m_gripper_size;
-        case wxAUI_ART_PANE_BORDER_SIZE:   return m_border_size;
-        case wxAUI_ART_PANE_BUTTON_SIZE:   return m_button_size;
-        case wxAUI_ART_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;
     }
 
     return 0;
 }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
     return 0;
 }
 
-void wxDefaultDockArt::SetMetric(int id, int new_val)
+void wxAuiDefaultDockArt::SetMetric(int id, int new_val)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_ART_SASH_SIZE:          m_sash_size = new_val; break;
-        case wxAUI_ART_CAPTION_SIZE:       m_caption_size = new_val; break;
-        case wxAUI_ART_GRIPPER_SIZE:       m_gripper_size = new_val; break;
-        case wxAUI_ART_PANE_BORDER_SIZE:   m_border_size = new_val; break;
-        case wxAUI_ART_PANE_BUTTON_SIZE:   m_button_size = new_val; break;
-        case wxAUI_ART_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;
     }
 }
 
-wxColour wxDefaultDockArt::GetColour(int id)
+wxColour wxAuiDefaultDockArt::GetColour(int id)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_ART_BACKGROUND_COLOUR:                return m_background_brush.GetColour();
-        case wxAUI_ART_SASH_COLOUR:                      return m_sash_brush.GetColour();
-        case wxAUI_ART_INACTIVE_CAPTION_COLOUR:          return m_inactive_caption_colour;
-        case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
-        case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactive_caption_text_colour;
-        case wxAUI_ART_ACTIVE_CAPTION_COLOUR:            return m_active_caption_colour;
-        case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_active_caption_gradient_colour;
-        case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_active_caption_text_colour;
-        case wxAUI_ART_BORDER_COLOUR:                    return m_border_pen.GetColour();
-        case wxAUI_ART_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;
     }
 
     return wxColour();
 }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
     return wxColour();
 }
 
-void wxDefaultDockArt::SetColour(int id, const wxColor& colour)
+void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
 {
     switch (id)
     {
 {
     switch (id)
     {
-        case wxAUI_ART_BACKGROUND_COLOUR:                m_background_brush.SetColour(colour); break;
-        case wxAUI_ART_SASH_COLOUR:                      m_sash_brush.SetColour(colour); break;
-        case wxAUI_ART_INACTIVE_CAPTION_COLOUR:          m_inactive_caption_colour = colour; break;
-        case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
-        case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR:     m_inactive_caption_text_colour = colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_COLOUR:            m_active_caption_colour = colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR:   m_active_caption_gradient_colour = colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR:       m_active_caption_text_colour = colour; break;
-        case wxAUI_ART_BORDER_COLOUR:                    m_border_pen.SetColour(colour); break;
-        case wxAUI_ART_GRIPPER_COLOUR:
-            m_gripper_brush.SetColour(colour);
-            m_gripper_pen1.SetColour(StepColour(colour, 40));
-            m_gripper_pen2.SetColour(StepColour(colour, 60));
+        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:
+            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 wxDefaultDockArt::SetFont(int id, const wxFont& font)
+void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 {
 {
-    if (id == wxAUI_ART_CAPTION_FONT)
-        m_caption_font = font;
+    if (id == wxAUI_DOCKART_CAPTION_FONT)
+        m_captionFont = font;
 }
 
 }
 
-wxFont wxDefaultDockArt::GetFont(int id)
+wxFont wxAuiDefaultDockArt::GetFont(int id)
 {
 {
-    if (id == wxAUI_ART_CAPTION_FONT)
-        return m_caption_font;
+    if (id == wxAUI_DOCKART_CAPTION_FONT)
+        return m_captionFont;
     return wxNullFont;
 }
 
     return wxNullFont;
 }
 
-void wxDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
+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 ;
@@ -328,19 +392,19 @@ void wxDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, con
     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__)
 #elif defined(__WXGTK__)
+    // clear out the rectangle first
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    dc.SetBrush(m_sashBrush);
+    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
@@ -348,21 +412,28 @@ void wxDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, con
         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,
@@ -376,13 +447,13 @@ void wxDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, con
     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
 }
 
 
-void wxDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
+void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 #ifdef __WXMAC__
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 #ifdef __WXMAC__
@@ -391,18 +462,18 @@ void wxDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int,
     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 wxDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
-                                  wxPaneInfo& pane)
+void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
+                                  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;
-    int i, border_width = GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
+    int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
 
     if (pane.IsToolbar())
     {
 
     if (pane.IsToolbar())
     {
@@ -411,7 +482,7 @@ void wxDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wx
             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,
@@ -430,14 +501,14 @@ void wxDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wx
 }
 
 
 }
 
 
-void wxDefaultDockArt::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);
     }
@@ -448,66 +519,97 @@ void wxDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool
             // 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_gradient_colour,
-                                 m_active_caption_colour,
-                                 m_gradient_type);
+                                 m_activeCaptionColour,
+                                 m_activeCaptionGradientColour,
+                                 m_gradientType);
 #else
 #else
+            // on other platforms, active gradients become lighter at the top
             DrawGradientRectangle(dc, rect,
             DrawGradientRectangle(dc, rect,
-                                 m_active_caption_colour,
-                                 m_active_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_activeCaptionGradientColour,
+                                 m_activeCaptionColour,
+                                 m_gradientType);
 #endif
         }
 #endif
         }
-         else
+        else
         {
         {
-            // on mac the gradients are expected to become darker from the top
 #ifdef __WXMAC__
 #ifdef __WXMAC__
+            // on mac the gradients are expected to become darker from the top
             DrawGradientRectangle(dc, rect,
             DrawGradientRectangle(dc, rect,
-                                 m_inactive_caption_gradient_colour,
-                                 m_inactive_caption_colour,
-                                 m_gradient_type);
+                                 m_inactiveCaptionGradientColour,
+                                 m_inactiveCaptionColour,
+                                 m_gradientType);
 #else
 #else
+            // on other platforms, inactive gradients become lighter at the bottom
             DrawGradientRectangle(dc, rect,
             DrawGradientRectangle(dc, rect,
-                                 m_inactive_caption_colour,
-                                 m_inactive_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_inactiveCaptionColour,
+                                 m_inactiveCaptionGradientColour,
+                                 m_gradientType);
 #endif
         }
     }
 }
 
 
 #endif
         }
     }
 }
 
 
-void wxDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
+void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
                                    const wxString& text,
                                    const wxRect& rect,
                                    const wxString& text,
                                    const wxRect& rect,
-                                   wxPaneInfo& pane)
+                                   wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetFont(m_caption_font);
+    dc.SetFont(m_captionFont);
 
     DrawCaptionBackground(dc, rect,
 
     DrawCaptionBackground(dc, rect,
-                          (pane.state & wxPaneInfo::optionActive)?true:false);
+                          (pane.state & wxAuiPaneInfo::optionActive)?true:false);
+
+    int caption_offset = 0;
+    if ( pane.icon.IsOk() )
+    {
+        DrawIcon(dc, rect, pane);
 
 
-    if (pane.state & wxPaneInfo::optionActive)
-        dc.SetTextForeground(m_active_caption_text_colour);
+        caption_offset += pane.icon.GetWidth() + 3;
+    }
+
+    if (pane.state & wxAuiPaneInfo::optionActive)
+        dc.SetTextForeground(m_activeCaptionTextColour);
     else
     else
-        dc.SetTextForeground(m_inactive_caption_text_colour);
+        dc.SetTextForeground(m_inactiveCaptionTextColour);
 
 
     wxCoord w,h;
     dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
 
 
 
     wxCoord w,h;
     dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
 
-    dc.SetClippingRegion(rect);
-    dc.DrawText(text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
+    wxRect clip_rect = rect;
+    clip_rect.width -= 3; // text offset
+    clip_rect.width -= 2; // button padding
+    if (pane.HasCloseButton())
+        clip_rect.width -= m_buttonSize;
+    if (pane.HasPinButton())
+        clip_rect.width -= m_buttonSize;
+    if (pane.HasMaximizeButton())
+        clip_rect.width -= m_buttonSize;
+
+    wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
+
+    dc.SetClippingRegion(clip_rect);
+    dc.DrawText(draw_text, rect.x+3 + caption_offset, rect.y+(rect.height/2)-(h/2)-1);
     dc.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 
-void wxDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
+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,
                                    const wxRect& rect,
-                                   wxPaneInfo& pane)
+                                   wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 {
     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);
 
@@ -516,12 +618,12 @@ void wxDefaultDockArt::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);
@@ -536,12 +638,12 @@ void wxDefaultDockArt::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);
@@ -553,14 +655,56 @@ void wxDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
     }
 }
 
     }
 }
 
-void wxDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
+void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
                                       int button,
                                       int button_state,
                                       const wxRect& _rect,
                                       int button,
                                       int button_state,
                                       const wxRect& _rect,
-                                      wxPaneInfo& pane)
+                                      wxAuiPaneInfo& pane)
 {
 {
+    wxBitmap bmp;
+    if (!(&pane))
+        return;
+    switch (button)
+    {
+        default:
+        case wxAUI_BUTTON_CLOSE:
+            if (pane.state & wxAuiPaneInfo::optionActive)
+                bmp = m_activeCloseBitmap;
+            else
+                bmp = m_inactiveCloseBitmap;
+            break;
+        case wxAUI_BUTTON_PIN:
+            if (pane.state & wxAuiPaneInfo::optionActive)
+                bmp = m_activePinBitmap;
+            else
+                bmp = m_inactivePinBitmap;
+            break;
+        case wxAUI_BUTTON_MAXIMIZE_RESTORE:
+            if (pane.IsMaximized())
+            {
+                if (pane.state & wxAuiPaneInfo::optionActive)
+                    bmp = m_activeRestoreBitmap;
+                else
+                    bmp = m_inactiveRestoreBitmap;
+            }
+            else
+            {
+                if (pane.state & wxAuiPaneInfo::optionActive)
+                    bmp = m_activeMaximizeBitmap;
+                else
+                    bmp = m_inactiveMaximizeBitmap;
+            }
+            break;
+    }
+
+
     wxRect rect = _rect;
 
     wxRect rect = _rect;
 
+    int old_y = rect.y;
+    rect.y = rect.y + (rect.height/2) - (bmp.GetHeight()/2);
+    rect.height = old_y + rect.height - rect.y - 1;
+
+
     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
     {
         rect.x++;
     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
     {
         rect.x++;
@@ -570,38 +714,21 @@ void wxDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
         button_state == wxAUI_BUTTON_STATE_PRESSED)
     {
     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
         button_state == wxAUI_BUTTON_STATE_PRESSED)
     {
-        if (pane.state & wxPaneInfo::optionActive)
+        if (pane.state & wxAuiPaneInfo::optionActive)
         {
         {
-            dc.SetBrush(wxBrush(StepColour(m_active_caption_colour, 120)));
-            dc.SetPen(wxPen(StepColour(m_active_caption_colour, 70)));
+            dc.SetBrush(wxBrush(m_activeCaptionColour.ChangeLightness(120)));
+            dc.SetPen(wxPen(m_activeCaptionColour.ChangeLightness(70)));
         }
         }
-         else
+        else
         {
         {
-            dc.SetBrush(wxBrush(StepColour(m_inactive_caption_colour, 120)));
-            dc.SetPen(wxPen(StepColour(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
         dc.DrawRectangle(rect.x, rect.y, 15, 15);
     }
 
         }
 
         // draw the background behind the button
         dc.DrawRectangle(rect.x, rect.y, 15, 15);
     }
 
-    wxBitmap bmp;
-    switch (button)
-    {
-        default:
-        case wxPaneInfo::buttonClose:
-            if (pane.state & wxPaneInfo::optionActive)
-                bmp = m_active_close_bitmap;
-                 else
-                bmp = m_inactive_close_bitmap;
-            break;
-        case wxPaneInfo::buttonPin:
-            if (pane.state & wxPaneInfo::optionActive)
-                bmp = m_active_pin_bitmap;
-                 else
-                bmp = m_inactive_pin_bitmap;
-            break;
-    }
 
     // draw the button itself
     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 
     // draw the button itself
     dc.DrawBitmap(bmp, rect.x, rect.y, true);
wxWidgets (Impactor)