move Ellipsize() to wxControl so it can be easily used by other controls

[wxWidgets.git] / src / aui / dockart.cpp

diff --git a/src/aui/dockart.cpp b/src/aui/dockart.cpp
index 9e3e793c6e3e1cbde9951697f828889f3a994690..55b5e89258d496502b2d9561237db11822775b7e 100644 (file)
--- a/src/aui/dockart.cpp
+++ b/src/aui/dockart.cpp
@@ -35,13 +35,15 @@
 #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"
+// for themeing support
+#include <Carbon/Carbon.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"
 #endif
 
 #include "wx/renderer.h"
 #endif
 


@@ -56,17 +58,60 @@
 // wxAuiManager::SetDockArt()
 
 
 // wxAuiManager::SetDockArt()
 
 

-// StepColour() it a utility function that simply darkens
+// wxAuiBlendColour is used by wxAuiStepColour
+unsigned char wxAuiBlendColour(unsigned char fg, unsigned char bg, double alpha)
+{
+    double result = bg + (alpha * (fg - bg));
+    if (result < 0.0)
+        result = 0.0;
+    if (result > 255)
+        result = 255;
+    return (unsigned char)result;
+}
+
+// wxAuiStepColour() it a utility function that simply darkens

 // or lightens a color, based on the specified percentage
 // or lightens a color, based on the specified percentage

-static wxColor StepColour(const wxColor& c, int percent)
+// 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)

 {
 {

-    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));
+    if (ialpha == 100)
+        return c;
+
+    unsigned char r = c.Red(),
+                  g = c.Green(),
+                  b = c.Blue();
+    unsigned char 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;
+        alpha = 1.0 - alpha;  // 0 = transparent fg; 1 = opaque fg
+    }
+    else
+    {
+        // blend with black
+        bg = 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(r, g, b);

 }
 
 }
 

-static wxColor LightContrastColour(const wxColour& c)
+
+wxColor wxAuiLightContrastColour(const wxColour& c)

 {
     int amount = 120;
 
 {
     int amount = 120;
 


@@ -75,13 +120,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 wxAuiStepColour(c, 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 +149,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,47 +168,77 @@ 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;

 }
 
 wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 {
 }
 
 wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 {

-#ifdef __WXMAC__
-    wxBrush toolbarbrush;
-    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
-    wxColor base_color = toolbarbrush.GetColour();
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+    wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));

 #else
 #else

-    wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+    wxColor base_colour = 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 base_colour is too pale to use as our base colour,
+    // so darken it a bit --
+    if ((255-base_colour.Red()) +
+        (255-base_colour.Green()) +
+        (255-base_colour.Blue()) < 60)
+    {
+        base_colour = wxAuiStepColour(base_colour, 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 = LightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
-    m_active_caption_gradient_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+    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_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_colour = darker1_colour;
+    m_inactive_caption_gradient_colour = wxAuiStepColour(base_colour, 97);

     m_inactive_caption_text_colour = *wxBLACK;
 
     m_inactive_caption_text_colour = *wxBLACK;
 

-#ifdef __WXMAC__
-    m_sash_brush = toolbarbrush;
-    m_background_brush = toolbarbrush;
-    m_gripper_brush = toolbarbrush;
-#else
-    m_sash_brush = wxBrush(base_color);
-    m_background_brush = wxBrush(base_color);
-    m_gripper_brush = wxBrush(base_color);
-#endif
-    m_border_pen = wxPen(darker2_color);
-    m_gripper_pen1 = wxPen(darker5_color);
-    m_gripper_pen2 = wxPen(darker3_color);
+    m_sash_brush = wxBrush(base_colour);
+    m_background_brush = wxBrush(base_colour);
+    m_gripper_brush = wxBrush(base_colour);
+
+    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_gripper_pen3 = *wxWHITE_PEN;
 
 #ifdef __WXMAC__


@@ -175,16 +253,23 @@ wxAuiDefaultDockArt::wxAuiDefaultDockArt()
          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 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, 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};
+         // 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 maximize_bits[] = {
 #endif
 
     static unsigned char maximize_bits[] = {


@@ -196,41 +281,41 @@ wxAuiDefaultDockArt::wxAuiDefaultDockArt()
         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[]={
         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__
     static 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_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE );
+    m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE);
+    m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE );

 #else
 #else

-    m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
+    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);

 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__

-    m_inactive_maximize_bitmap = BitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
-    m_active_maximize_bitmap = BitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
+    m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
+    m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );

 #else
 #else

-    m_inactive_maximize_bitmap = BitmapFromBits(maximize_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_maximize_bitmap = BitmapFromBits(maximize_bits, 16, 16, m_active_caption_text_colour);
+    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);

 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__

-    m_inactive_restore_bitmap = BitmapFromBits(restore_bits, 16, 16, *wxWHITE);
-    m_active_restore_bitmap = BitmapFromBits(restore_bits, 16, 16, *wxWHITE );
+    m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
+    m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );

 #else
 #else

-    m_inactive_restore_bitmap = BitmapFromBits(restore_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_restore_bitmap = BitmapFromBits(restore_bits, 16, 16, m_active_caption_text_colour);
+    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);

 #endif
 
 #endif
 

-    m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
-    m_active_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
+    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
 
     // default metric values

-#if defined(__WXMAC__)
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON

     SInt32 height;
     GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
     m_sash_size = height;
     SInt32 height;
     GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
     m_sash_size = height;


@@ -250,12 +335,12 @@ 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_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;

         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 


@@ -266,12 +351,12 @@ 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_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;

         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 }
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 }


@@ -280,16 +365,16 @@ 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_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();

         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
 


@@ -300,19 +385,19 @@ 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:
+        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_GRIPPER_COLOUR:

             m_gripper_brush.SetColour(colour);
             m_gripper_brush.SetColour(colour);

-            m_gripper_pen1.SetColour(StepColour(colour, 40));
-            m_gripper_pen2.SetColour(StepColour(colour, 60));
+            m_gripper_pen1.SetColour(wxAuiStepColour(colour, 40));
+            m_gripper_pen2.SetColour(wxAuiStepColour(colour, 60));

             break;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }
             break;
         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
     }


@@ -320,31 +405,27 @@ void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
 
 void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 {
 
 void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 {

-    if (id == wxAUI_ART_CAPTION_FONT)
+    if (id == wxAUI_DOCKART_CAPTION_FONT)

         m_caption_font = font;
 }
 
 wxFont wxAuiDefaultDockArt::GetFont(int id)
 {
         m_caption_font = font;
 }
 
 wxFont wxAuiDefaultDockArt::GetFont(int id)
 {

-    if (id == wxAUI_ART_CAPTION_FONT)
+    if (id == wxAUI_DOCKART_CAPTION_FONT)

         return m_caption_font;
     return wxNullFont;
 }
 
 void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
 {
         return m_caption_font;
     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 ;


@@ -352,13 +433,13 @@ 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__)
 #elif defined(__WXGTK__)

+    // clear out the rectangle first
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    dc.SetBrush(m_sash_brush);
+    dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);

 
 

+#if 0

     GdkRectangle gdk_rect;
     if (orientation == wxVERTICAL )
     {
     GdkRectangle gdk_rect;
     if (orientation == wxVERTICAL )
     {


@@ -374,15 +455,16 @@ void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation,
         gdk_rect.width = rect.width;
         gdk_rect.height = m_sash_size;
     }
         gdk_rect.width = rect.width;
         gdk_rect.height = m_sash_size;
     }

+#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_DRAWABLE(window->m_wxwindow)) return;

 
     gtk_paint_handle
     (
         window->m_wxwindow->style,
 
     gtk_paint_handle
     (
         window->m_wxwindow->style,

-        GTK_PIZZA(window->m_wxwindow)->bin_window,
+        window->GTKGetDrawingWindow(),

         // 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,


@@ -426,7 +508,7 @@ void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const
     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())
     {


@@ -460,7 +542,7 @@ void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bo
     {
         if (active)
             dc.SetBrush(wxBrush(m_active_caption_colour));
     {
         if (active)
             dc.SetBrush(wxBrush(m_active_caption_colour));

-             else
+        else

             dc.SetBrush(wxBrush(m_inactive_caption_colour));
 
         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
             dc.SetBrush(wxBrush(m_inactive_caption_colour));
 
         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);


@@ -472,25 +554,27 @@ 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_gradient_colour,

                                  m_active_caption_colour,
                                  m_active_caption_colour,

+                                 m_active_caption_gradient_colour,

                                  m_gradient_type);
 #else
                                  m_gradient_type);
 #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_active_caption_gradient_colour,

+                                 m_active_caption_colour,

                                  m_gradient_type);
 #endif
         }
                                  m_gradient_type);
 #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,
                                  m_inactive_caption_gradient_colour,
                                  m_inactive_caption_colour,
                                  m_gradient_type);
 #else
             DrawGradientRectangle(dc, rect,
                                  m_inactive_caption_gradient_colour,
                                  m_inactive_caption_colour,
                                  m_gradient_type);
 #else

+            // on other platforms, inactive gradients become lighter at the bottom

             DrawGradientRectangle(dc, rect,
                                  m_inactive_caption_colour,
                                  m_inactive_caption_gradient_colour,
             DrawGradientRectangle(dc, rect,
                                  m_inactive_caption_colour,
                                  m_inactive_caption_gradient_colour,


@@ -521,8 +605,20 @@ void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
     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_button_size;
+    if (pane.HasPinButton())
+        clip_rect.width -= m_button_size;
+    if (pane.HasMaximizeButton())
+        clip_rect.width -= m_button_size;
+
+    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.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 


@@ -583,8 +679,50 @@ void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
                                       const wxRect& _rect,
                                       wxAuiPaneInfo& pane)
 {
                                       const wxRect& _rect,
                                       wxAuiPaneInfo& pane)
 {

+    wxBitmap bmp;
+    if (!(&pane))
+        return;
+    switch (button)
+    {
+        default:
+        case wxAUI_BUTTON_CLOSE:
+            if (pane.state & wxAuiPaneInfo::optionActive)
+                bmp = m_active_close_bitmap;
+            else
+                bmp = m_inactive_close_bitmap;
+            break;
+        case wxAUI_BUTTON_PIN:
+            if (pane.state & wxAuiPaneInfo::optionActive)
+                bmp = m_active_pin_bitmap;
+            else
+                bmp = m_inactive_pin_bitmap;
+            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;
+            }
+            else
+            {
+                if (pane.state & wxAuiPaneInfo::optionActive)
+                    bmp = m_active_maximize_bitmap;
+                else
+                    bmp = m_inactive_maximize_bitmap;
+            }
+            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++;


@@ -596,49 +734,19 @@ void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
     {
         if (pane.state & wxAuiPaneInfo::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(wxAuiStepColour(m_active_caption_colour, 120)));
+            dc.SetPen(wxPen(wxAuiStepColour(m_active_caption_colour, 70)));

         }
         }

-         else
+        else

         {
         {

-            dc.SetBrush(wxBrush(StepColour(m_inactive_caption_colour, 120)));
-            dc.SetPen(wxPen(StepColour(m_inactive_caption_colour, 70)));
+            dc.SetBrush(wxBrush(wxAuiStepColour(m_inactive_caption_colour, 120)));
+            dc.SetPen(wxPen(wxAuiStepColour(m_inactive_caption_colour, 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 wxAUI_BUTTON_MAXIMIZE_RESTORE:
-            if (pane.IsMaximized()) {
-                if (pane.state & wxAuiPaneInfo::optionActive)
-                    bmp = m_active_restore_bitmap;
-                    else
-                    bmp = m_inactive_restore_bitmap;
-            } else {
-                if (pane.state & wxAuiPaneInfo::optionActive)
-                    bmp = m_active_maximize_bitmap;
-                    else
-                    bmp = m_inactive_maximize_bitmap;
-            }
-            break;
-        case wxAUI_BUTTON_CLOSE:
-            if (pane.state & wxAuiPaneInfo::optionActive)
-                bmp = m_active_close_bitmap;
-                 else
-                bmp = m_inactive_close_bitmap;
-            break;
-        case wxAUI_BUTTON_PIN:
-            if (pane.state & wxAuiPaneInfo::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);