]> git.saurik.com Git - wxWidgets.git/blobdiff - src/aui/dockart.cpp
Compilation fir for VC6 after r73124.
[wxWidgets.git] / src / aui / dockart.cpp
index 68c5bb373b2b2a3c3fe12f670ad6af7b76a12477..8187939b028984f9039636d238bc6c56955c00cc 100644 (file)
@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        dockart.cpp
+// Name:        src/aui/dockart.cpp
 // Purpose:     wxaui: wx advanced user interface - docking window manager
 // Author:      Benjamin I. Williams
 // Modified by:
 // Created:     2005-05-17
-// RCS-ID:      
+// RCS-ID:      $Id$
 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
 // Licence:     wxWindows Library Licence, Version 3.1
 ///////////////////////////////////////////////////////////////////////////////
 
 #if wxUSE_AUI
 
-#include "wx/image.h"
-#include "wx/dcclient.h"
-#include "wx/settings.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/log.h"
+    #include "wx/settings.h"
+    #include "wx/dcclient.h"
+    #include "wx/image.h"
 #endif
 
-// -- wxDefaultDockArt class implementation --
+#ifdef __WXMAC__
+#include "wx/osx/private.h"
+#include "wx/graphics.h"
+#include "wx/dcgraph.h"
+#endif
 
-// wxDefaultDockArt is an art provider class which does all of the drawing for
-// wxFrameManager.  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
-// from the wxDockArt base class). The active dock art class can be set via
-// wxFrameManager::SetDockArt()
+#ifdef __WXGTK__
+#include <gtk/gtk.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
 
 
-// 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(wxMin((r*percent)/100,255),
-                    wxMin((g*percent)/100,255),
-                    wxMin((b*percent)/100,255));
-}
+// -- wxAuiDefaultDockArt class implementation --
 
-static wxColor LightContrastColour(const wxColour& c)
+// 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
+// from the wxAuiDockArt base class). The active dock art class can be set via
+// wxAuiManager::SetDockArt()
+wxColor wxAuiLightContrastColour(const wxColour& c)
 {
     int amount = 120;
 
@@ -64,17 +73,17 @@ static wxColor LightContrastColour(const wxColour& c)
     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)
-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(255,255,255,123,123,123);
-    img.Replace(0,0,0,color.Red(),color.Green(),color.Blue());
+    img.Replace(0,0,0,123,123,123);
+    img.Replace(255,255,255,color.Red(),color.Green(),color.Blue());
     img.SetMaskColour(123,123,123);
     return wxBitmap(img);
 }
@@ -93,235 +102,360 @@ static void DrawGradientRectangle(wxDC& dc,
 
     if (direction == wxAUI_GRADIENT_VERTICAL)
         high = rect.GetHeight()-1;
-         else
+    else
         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;
 
-        wxPen p(wxColor(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,
+                        (unsigned char)b));
         dc.SetPen(p);
 
         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);
     }
+}
+
+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
-    wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #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);
-
-    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;
+
+    // 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_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__
-    m_sash_brush = toolbarbrush;
-    m_background_brush = toolbarbrush;
-    m_gripper_brush = toolbarbrush;
+    m_captionFont = *wxSMALL_FONT;
 #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
-    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
-    m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
+    m_sashSize = 4;
 #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
-#ifdef __WXMAC__
-     static unsigned char close_bits[]={
+#if defined( __WXMAC__ )
+     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 };
+#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
-    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
 
-    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__
-    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
-    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
-    m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
+
 #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
-    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
-    m_active_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
 
-    // default metric values
 #ifdef __WXMAC__
-    SInt32 height;
-    GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
-    m_sash_size = height;
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
 #else
-    m_sash_size = 4;
+    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactiveCaptionTextColour);
+    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_activeCaptionTextColour);
 #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)
     {
-        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;
 }
 
-void wxDefaultDockArt::SetMetric(int id, int new_val)
+void wxAuiDefaultDockArt::SetMetric(int id, int new_val)
 {
     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;
     }
 }
 
-wxColour wxDefaultDockArt::GetColour(int id)
+wxColour wxAuiDefaultDockArt::GetColour(int id)
 {
     switch (id)
     {
-        case wxAUI_ART_BACKGROUND_COLOUR:                return m_background_brush.GetColour(); break;
-        case wxAUI_ART_SASH_COLOUR:                      return m_sash_brush.GetColour(); break;
-        case wxAUI_ART_INACTIVE_CAPTION_COLOUR:          return m_inactive_caption_colour; break;
-        case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour; break;
-        case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactive_caption_text_colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_COLOUR:            return m_active_caption_colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_active_caption_gradient_colour; break;
-        case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_active_caption_text_colour; break;
-        case wxAUI_ART_BORDER_COLOUR:                    return m_border_pen.GetColour(); break;
-        case wxAUI_ART_GRIPPER_COLOUR:                   return m_gripper_brush.GetColour(); break;
+        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();
 }
 
-void wxDefaultDockArt::SetColour(int id, const wxColor& colour)
+void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
 {
     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;
     }
+
+    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;
 }
 
-void wxDefaultDockArt::DrawSash(wxDC& dc, int, const wxRect& rect)
+void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
 {
-#ifdef __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 ;
-#if wxMAC_USE_CORE_GRAPHICS
-    cgContext = ((wxMacCGContext*)(dc.GetGraphicContext()))->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 ;
     drawInfo.state = kThemeStateActive ;
     drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
-    HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;    
-    
-#if wxMAC_USE_CORE_GRAPHICS
+    HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
+
+#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;
+        gdk_rect.width = m_sashSize;
+        gdk_rect.height = rect.height;
+    }
+    else
+    {
+        gdk_rect.x = rect.x;
+        gdk_rect.y = rect.y;
+        gdk_rect.width = rect.width;
+        gdk_rect.height = m_sashSize;
+    }
+#endif
+
+    if (!window) return;
+    if (!window->m_wxwindow) return;
+    if (!gtk_widget_is_drawable(window->m_wxwindow)) return;
+
+    gtk_paint_handle
+    (
+        gtk_widget_get_style(window->m_wxwindow),
+#ifdef __WXGTK3__
+        static_cast<cairo_t*>(dc.GetGraphicsContext()->GetNativeContext()),
 #else
-    QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
+        window->GTKGetDrawingWindow(),
+#endif
+        // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
+        GTK_STATE_NORMAL,
+        GTK_SHADOW_NONE,
+#ifndef __WXGTK3__
+        NULL /* no clipping */,
 #endif
+        window->m_wxwindow,
+        "paned",
+        rect.x,
+        rect.y,
+        rect.width,
+        rect.height,
+        (orientation == wxVERTICAL) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
+    );
 
 #else
+    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
 }
 
 
-void wxDefaultDockArt::DrawBackground(wxDC& dc, int, const wxRect& rect)
+void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
 #ifdef __WXMAC__
@@ -330,18 +464,18 @@ void wxDefaultDockArt::DrawBackground(wxDC& dc, int, const wxRect& rect)
     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);
 }
 
-void wxDefaultDockArt::DrawBorder(wxDC& dc, const wxRect& _rect,
-                                  wxPaneInfo& pane)
+void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow* window, const wxRect& _rect,
+                                  wxAuiPaneInfo& pane)
 {
-    dc.SetPen(m_border_pen);
+    dc.SetPen(m_borderPen);
     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())
     {
@@ -350,7 +484,7 @@ void wxDefaultDockArt::DrawBorder(wxDC& dc, const wxRect& _rect,
             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,
@@ -358,95 +492,137 @@ void wxDefaultDockArt::DrawBorder(wxDC& dc, const wxRect& _rect,
             rect.Deflate(1);
         }
     }
-     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);
+            }
         }
     }
 }
 
 
-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)
-            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);
     }
-     else
+    else
     {
         if (active)
         {
             // 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
+            // on other platforms, active gradients become lighter at the top
             DrawGradientRectangle(dc, rect,
-                                 m_active_caption_colour,
-                                 m_active_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_activeCaptionGradientColour,
+                                 m_activeCaptionColour,
+                                 m_gradientType);
 #endif
         }
-         else
+        else
         {
-            // on mac the gradients are expected to become darker from the top
 #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,
-                                 m_inactive_caption_colour,
-                                 m_inactive_caption_gradient_colour,
-                                 m_gradient_type);
+                                 m_inactiveCaptionColour,
+                                 m_inactiveCaptionGradientColour,
+                                 m_gradientType);
 #endif
         }
     }
 }
 
 
-void wxDefaultDockArt::DrawCaption(wxDC& dc,
+void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
                                    const wxString& text,
                                    const wxRect& rect,
-                                   wxPaneInfo& pane)
+                                   wxAuiPaneInfo& pane)
 {
     dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetFont(m_caption_font);
+    dc.SetFont(m_captionFont);
 
     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);
+
+        caption_offset += pane.icon.GetWidth() + 3;
+    }
 
-    if (pane.state & wxPaneInfo::optionActive)
-        dc.SetTextForeground(m_active_caption_text_colour);
-     else
-        dc.SetTextForeground(m_inactive_caption_text_colour);
+    if (pane.state & wxAuiPaneInfo::optionActive)
+        dc.SetTextForeground(m_activeCaptionTextColour);
+    else
+        dc.SetTextForeground(m_inactiveCaptionTextColour);
 
 
     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();
 }
 
-void wxDefaultDockArt::DrawGripper(wxDC& dc,
+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,
-                                   wxPaneInfo& pane)
+                                   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);
 
@@ -455,12 +631,12 @@ void wxDefaultDockArt::DrawGripper(wxDC& dc,
         int y = 5;
         while (1)
         {
-            dc.SetPen(m_gripper_pen1);
+            dc.SetPen(m_gripperPen1);
             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.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);
@@ -475,12 +651,12 @@ void wxDefaultDockArt::DrawGripper(wxDC& dc,
         int x = 5;
         while (1)
         {
-            dc.SetPen(m_gripper_pen1);
+            dc.SetPen(m_gripperPen1);
             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.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);
@@ -492,14 +668,56 @@ void wxDefaultDockArt::DrawGripper(wxDC& dc,
     }
 }
 
-void wxDefaultDockArt::DrawPaneButton(wxDC& dc,
+void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
                                       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;
 
+    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++;
@@ -509,38 +727,21 @@ void wxDefaultDockArt::DrawPaneButton(wxDC& dc,
     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);
     }
 
-    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);