src/aui/dockart.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/aui/dockart.cpp
   3 // Purpose:     wxaui: wx advanced user interface - docking window manager
   4 // Author:      Benjamin I. Williams
   5 // Modified by:
   6 // Created:     2005-05-17
   7 // RCS-ID:      $Id$
   8 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
   9 // Licence:     wxWindows Library Licence, Version 3.1
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_AUI
  27
  28 #include "wx/aui/framemanager.h"
  29 #include "wx/aui/dockart.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/settings.h"
  33     #include "wx/dcclient.h"
  34     #include "wx/image.h"
  35 #endif
  36
  37 #ifdef __WXMAC__
  38 #include "wx/osx/private.h"
  39 #include "wx/graphics.h"
  40 #include "wx/dcgraph.h"
  41 #endif
  42
  43 #ifdef __WXGTK__
  44 #include <gtk/gtk.h>
  45 #include "wx/renderer.h"
  46 #endif
  47
  48
  49 // -- wxAuiDefaultDockArt class implementation --
  50
  51 // wxAuiDefaultDockArt is an art provider class which does all of the drawing for
  52 // wxAuiManager.  This allows the library caller to customize the dock art
  53 // (probably by deriving from this class), or to completely replace all drawing
  54 // with custom dock art (probably by writing a new stand-alone class derived
  55 // from the wxAuiDockArt base class). The active dock art class can be set via
  56 // wxAuiManager::SetDockArt()
  57 wxColor wxAuiLightContrastColour(const wxColour& c)
  58 {
  59     int amount = 120;
  60
  61     // if the color is especially dark, then
  62     // make the contrast even lighter
  63     if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
  64         amount = 160;
  65
  66     return c.ChangeLightness(amount);
  67 }
  68
  69 // wxAuiBitmapFromBits() is a utility function that creates a
  70 // masked bitmap from raw bits (XBM format)
  71 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
  72                              const wxColour& color)
  73 {
  74     wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
  75     img.Replace(0,0,0,123,123,123);
  76     img.Replace(255,255,255,color.Red(),color.Green(),color.Blue());
  77     img.SetMaskColour(123,123,123);
  78     return wxBitmap(img);
  79 }
  80
  81
  82 static void DrawGradientRectangle(wxDC& dc,
  83                                   const wxRect& rect,
  84                                   const wxColour& start_color,
  85                                   const wxColour& end_color,
  86                                   int direction)
  87 {
  88     int rd, gd, bd, high = 0;
  89     rd = end_color.Red() - start_color.Red();
  90     gd = end_color.Green() - start_color.Green();
  91     bd = end_color.Blue() - start_color.Blue();
  92
  93     if (direction == wxAUI_GRADIENT_VERTICAL)
  94         high = rect.GetHeight()-1;
  95     else
  96         high = rect.GetWidth()-1;
  97
  98     for (int i = 0; i <= high; ++i)
  99     {
 100         int r,g,b;
 101
 102
 103         r = start_color.Red() + (high <= 0 ? 0 : (((i*rd*100)/high)/100));
 104         g = start_color.Green() + (high <= 0 ? 0 : (((i*gd*100)/high)/100));
 105         b = start_color.Blue() + (high <= 0 ? 0 : (((i*bd*100)/high)/100));
 106
 107         wxPen p(wxColor((unsigned char)r,
 108                         (unsigned char)g,
 109                         (unsigned char)b));
 110         dc.SetPen(p);
 111
 112         if (direction == wxAUI_GRADIENT_VERTICAL)
 113             dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
 114         else
 115             dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
 116     }
 117 }
 118
 119 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size)
 120 {
 121     wxCoord x,y;
 122
 123     // first check if the text fits with no problems
 124     dc.GetTextExtent(text, &x, &y);
 125     if (x <= max_size)
 126         return text;
 127
 128     size_t i, len = text.Length();
 129     size_t last_good_length = 0;
 130     for (i = 0; i < len; ++i)
 131     {
 132         wxString s = text.Left(i);
 133         s += wxT("...");
 134
 135         dc.GetTextExtent(s, &x, &y);
 136         if (x > max_size)
 137             break;
 138
 139         last_good_length = i;
 140     }
 141
 142     wxString ret = text.Left(last_good_length);
 143     ret += wxT("...");
 144     return ret;
 145 }
 146
 147 wxAuiDefaultDockArt::wxAuiDefaultDockArt()
 148 {
 149 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 150     wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
 151 #else
 152     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 153 #endif
 154
 155     // the base_colour is too pale to use as our base colour,
 156     // so darken it a bit --
 157     if ((255-base_colour.Red()) +
 158         (255-base_colour.Green()) +
 159         (255-base_colour.Blue()) < 60)
 160     {
 161         base_colour = base_colour.ChangeLightness(92);
 162     }
 163
 164     m_base_colour = base_colour;
 165     wxColor darker1_colour = base_colour.ChangeLightness(85);
 166     wxColor darker2_colour = base_colour.ChangeLightness(75);
 167     wxColor darker3_colour = base_colour.ChangeLightness(60);
 168     //wxColor darker4_colour = base_colour.ChangeLightness(50);
 169     wxColor darker5_colour = base_colour.ChangeLightness(40);
 170
 171     m_active_caption_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
 172     m_active_caption_gradient_colour = wxAuiLightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
 173     m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
 174     m_inactive_caption_colour = darker1_colour;
 175     m_inactive_caption_gradient_colour = base_colour.ChangeLightness(97);
 176     m_inactive_caption_text_colour = *wxBLACK;
 177
 178     m_sash_brush = wxBrush(base_colour);
 179     m_background_brush = wxBrush(base_colour);
 180     m_gripper_brush = wxBrush(base_colour);
 181
 182     m_border_pen = wxPen(darker2_colour);
 183     m_gripper_pen1 = wxPen(darker5_colour);
 184     m_gripper_pen2 = wxPen(darker3_colour);
 185     m_gripper_pen3 = *wxWHITE_PEN;
 186
 187 #ifdef __WXMAC__
 188     m_caption_font = *wxSMALL_FONT;
 189 #else
 190     m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
 191 #endif
 192
 193     // default metric values
 194 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 195     SInt32 height;
 196     GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
 197     m_sash_size = height;
 198 #elif defined(__WXGTK__)
 199     m_sash_size = wxRendererNative::Get().GetSplitterParams(NULL).widthSash;
 200 #else
 201     m_sash_size = 4;
 202 #endif
 203     m_caption_size = 17;
 204     m_border_size = 1;
 205     m_button_size = 14;
 206     m_gripper_size = 9;
 207     m_gradient_type = wxAUI_GRADIENT_VERTICAL;
 208
 209     InitBitmaps();
 210 }
 211
 212 void
 213 wxAuiDefaultDockArt::InitBitmaps ()
 214 {
 215     // some built in bitmaps
 216 #if defined( __WXMAC__ )
 217      static const unsigned char close_bits[]={
 218          0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
 219          0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
 220          0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
 221 #elif defined(__WXGTK__)
 222      static const unsigned char close_bits[]={
 223          0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
 224          0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
 225          0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 226 #else
 227     static const unsigned char close_bits[]={
 228          // reduced height, symmetric
 229          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf3, 0x9f, 0xf9,
 230          0x3f, 0xfc, 0x7f, 0xfe, 0x3f, 0xfc, 0x9f, 0xf9, 0xcf, 0xf3, 0xff, 0xff,
 231          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 232       /*
 233          // same height as maximize/restore
 234          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xcf, 0xf3, 0x9f, 0xf9,
 235          0x3f, 0xfc, 0x7f, 0xfe, 0x3f, 0xfc, 0x9f, 0xf9, 0xcf, 0xf3, 0xe7, 0xe7,
 236          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 237       */
 238 #endif
 239
 240     static const unsigned char maximize_bits[] = {
 241         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
 242         0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
 243         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 244
 245     static const unsigned char restore_bits[]={
 246         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
 247         0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
 248         0x07, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 249
 250     static const unsigned char pin_bits[]={
 251         0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
 252         0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
 253         0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
 254
 255 #ifdef __WXMAC__
 256     m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE);
 257     m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, *wxWHITE );
 258 #else
 259     m_inactive_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
 260     m_active_close_bitmap = wxAuiBitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
 261 #endif
 262
 263 #ifdef __WXMAC__
 264     m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE);
 265     m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, *wxWHITE );
 266 #else
 267     m_inactive_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_inactive_caption_text_colour);
 268     m_active_maximize_bitmap = wxAuiBitmapFromBits(maximize_bits, 16, 16, m_active_caption_text_colour);
 269 #endif
 270
 271 #ifdef __WXMAC__
 272     m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
 273     m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
 274 #else
 275     m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_inactive_caption_text_colour);
 276     m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, m_active_caption_text_colour);
 277 #endif
 278
 279     m_inactive_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
 280     m_active_pin_bitmap = wxAuiBitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
 281 }
 282
 283 int wxAuiDefaultDockArt::GetMetric(int id)
 284 {
 285     switch (id)
 286     {
 287         case wxAUI_DOCKART_SASH_SIZE:          return m_sash_size;
 288         case wxAUI_DOCKART_CAPTION_SIZE:       return m_caption_size;
 289         case wxAUI_DOCKART_GRIPPER_SIZE:       return m_gripper_size;
 290         case wxAUI_DOCKART_PANE_BORDER_SIZE:   return m_border_size;
 291         case wxAUI_DOCKART_PANE_BUTTON_SIZE:   return m_button_size;
 292         case wxAUI_DOCKART_GRADIENT_TYPE:      return m_gradient_type;
 293         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
 294     }
 295
 296     return 0;
 297 }
 298
 299 void wxAuiDefaultDockArt::SetMetric(int id, int new_val)
 300 {
 301     switch (id)
 302     {
 303         case wxAUI_DOCKART_SASH_SIZE:          m_sash_size = new_val; break;
 304         case wxAUI_DOCKART_CAPTION_SIZE:       m_caption_size = new_val; break;
 305         case wxAUI_DOCKART_GRIPPER_SIZE:       m_gripper_size = new_val; break;
 306         case wxAUI_DOCKART_PANE_BORDER_SIZE:   m_border_size = new_val; break;
 307         case wxAUI_DOCKART_PANE_BUTTON_SIZE:   m_button_size = new_val; break;
 308         case wxAUI_DOCKART_GRADIENT_TYPE:      m_gradient_type = new_val; break;
 309         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
 310     }
 311 }
 312
 313 wxColour wxAuiDefaultDockArt::GetColour(int id)
 314 {
 315     switch (id)
 316     {
 317         case wxAUI_DOCKART_BACKGROUND_COLOUR:                return m_background_brush.GetColour();
 318         case wxAUI_DOCKART_SASH_COLOUR:                      return m_sash_brush.GetColour();
 319         case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          return m_inactive_caption_colour;
 320         case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
 321         case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactive_caption_text_colour;
 322         case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            return m_active_caption_colour;
 323         case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_active_caption_gradient_colour;
 324         case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_active_caption_text_colour;
 325         case wxAUI_DOCKART_BORDER_COLOUR:                    return m_border_pen.GetColour();
 326         case wxAUI_DOCKART_GRIPPER_COLOUR:                   return m_gripper_brush.GetColour();
 327         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
 328     }
 329
 330     return wxColour();
 331 }
 332
 333 void wxAuiDefaultDockArt::SetColour(int id, const wxColor& colour)
 334 {
 335     switch (id)
 336     {
 337         case wxAUI_DOCKART_BACKGROUND_COLOUR:                m_background_brush.SetColour(colour); break;
 338         case wxAUI_DOCKART_SASH_COLOUR:                      m_sash_brush.SetColour(colour); break;
 339         case wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR:          m_inactive_caption_colour = colour; break;
 340         case wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
 341         case wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR:     m_inactive_caption_text_colour = colour; break;
 342         case wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR:            m_active_caption_colour = colour; break;
 343         case wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR:   m_active_caption_gradient_colour = colour; break;
 344         case wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR:       m_active_caption_text_colour = colour; break;
 345         case wxAUI_DOCKART_BORDER_COLOUR:                    m_border_pen.SetColour(colour); break;
 346         case wxAUI_DOCKART_GRIPPER_COLOUR:
 347             m_gripper_brush.SetColour(colour);
 348             m_gripper_pen1.SetColour(colour.ChangeLightness(40));
 349             m_gripper_pen2.SetColour(colour.ChangeLightness(60));
 350             break;
 351         default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
 352     }
 353
 354     InitBitmaps();
 355 }
 356
 357 void wxAuiDefaultDockArt::SetFont(int id, const wxFont& font)
 358 {
 359     if (id == wxAUI_DOCKART_CAPTION_FONT)
 360         m_caption_font = font;
 361 }
 362
 363 wxFont wxAuiDefaultDockArt::GetFont(int id)
 364 {
 365     if (id == wxAUI_DOCKART_CAPTION_FONT)
 366         return m_caption_font;
 367     return wxNullFont;
 368 }
 369
 370 void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect)
 371 {
 372 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 373     wxUnusedVar(window);
 374     wxUnusedVar(orientation);
 375
 376     HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
 377     CGContextRef cgContext ;
 378     wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
 379     cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext() ;
 380
 381     HIThemeSplitterDrawInfo drawInfo ;
 382     drawInfo.version = 0 ;
 383     drawInfo.state = kThemeStateActive ;
 384     drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
 385     HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
 386
 387 #elif defined(__WXGTK__)
 388     // clear out the rectangle first
 389     dc.SetPen(*wxTRANSPARENT_PEN);
 390     dc.SetBrush(m_sash_brush);
 391     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 392
 393 #if 0
 394     GdkRectangle gdk_rect;
 395     if (orientation == wxVERTICAL )
 396     {
 397         gdk_rect.x = rect.x;
 398         gdk_rect.y = rect.y;
 399         gdk_rect.width = m_sash_size;
 400         gdk_rect.height = rect.height;
 401     }
 402     else
 403     {
 404         gdk_rect.x = rect.x;
 405         gdk_rect.y = rect.y;
 406         gdk_rect.width = rect.width;
 407         gdk_rect.height = m_sash_size;
 408     }
 409 #endif
 410
 411     if (!window) return;
 412     if (!window->m_wxwindow) return;
 413     if (!GTK_WIDGET_DRAWABLE(window->m_wxwindow)) return;
 414
 415     gtk_paint_handle
 416     (
 417         window->m_wxwindow->style,
 418         window->GTKGetDrawingWindow(),
 419         // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
 420         GTK_STATE_NORMAL,
 421         GTK_SHADOW_NONE,
 422         NULL /* no clipping */,
 423         window->m_wxwindow,
 424         "paned",
 425         rect.x,
 426         rect.y,
 427         rect.width,
 428         rect.height,
 429         (orientation == wxVERTICAL) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
 430     );
 431
 432 #else
 433     wxUnusedVar(window);
 434     wxUnusedVar(orientation);
 435     dc.SetPen(*wxTRANSPARENT_PEN);
 436     dc.SetBrush(m_sash_brush);
 437     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 438 #endif
 439 }
 440
 441
 442 void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
 443 {
 444     dc.SetPen(*wxTRANSPARENT_PEN);
 445 #ifdef __WXMAC__
 446     // we have to clear first, otherwise we are drawing a light striped pattern
 447     // over an already darker striped background
 448     dc.SetBrush(*wxWHITE_BRUSH) ;
 449     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 450 #endif
 451     dc.SetBrush(m_background_brush);
 452     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 453 }
 454
 455 void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
 456                                   wxAuiPaneInfo& pane)
 457 {
 458     dc.SetPen(m_border_pen);
 459     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 460
 461     wxRect rect = _rect;
 462     int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
 463
 464     if (pane.IsToolbar())
 465     {
 466         for (i = 0; i < border_width; ++i)
 467         {
 468             dc.SetPen(*wxWHITE_PEN);
 469             dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
 470             dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
 471             dc.SetPen(m_border_pen);
 472             dc.DrawLine(rect.x, rect.y+rect.height-1,
 473                         rect.x+rect.width, rect.y+rect.height-1);
 474             dc.DrawLine(rect.x+rect.width-1, rect.y,
 475                         rect.x+rect.width-1, rect.y+rect.height);
 476             rect.Deflate(1);
 477         }
 478     }
 479     else
 480     {
 481         for (i = 0; i < border_width; ++i)
 482         {
 483             dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 484             rect.Deflate(1);
 485         }
 486     }
 487 }
 488
 489
 490 void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
 491 {
 492     if (m_gradient_type == wxAUI_GRADIENT_NONE)
 493     {
 494         if (active)
 495             dc.SetBrush(wxBrush(m_active_caption_colour));
 496         else
 497             dc.SetBrush(wxBrush(m_inactive_caption_colour));
 498
 499         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 500     }
 501     else
 502     {
 503         if (active)
 504         {
 505             // on mac the gradients are expected to become darker from the top
 506 #ifdef __WXMAC__
 507             DrawGradientRectangle(dc, rect,
 508                                  m_active_caption_colour,
 509                                  m_active_caption_gradient_colour,
 510                                  m_gradient_type);
 511 #else
 512             // on other platforms, active gradients become lighter at the top
 513             DrawGradientRectangle(dc, rect,
 514                                  m_active_caption_gradient_colour,
 515                                  m_active_caption_colour,
 516                                  m_gradient_type);
 517 #endif
 518         }
 519         else
 520         {
 521 #ifdef __WXMAC__
 522             // on mac the gradients are expected to become darker from the top
 523             DrawGradientRectangle(dc, rect,
 524                                  m_inactive_caption_gradient_colour,
 525                                  m_inactive_caption_colour,
 526                                  m_gradient_type);
 527 #else
 528             // on other platforms, inactive gradients become lighter at the bottom
 529             DrawGradientRectangle(dc, rect,
 530                                  m_inactive_caption_colour,
 531                                  m_inactive_caption_gradient_colour,
 532                                  m_gradient_type);
 533 #endif
 534         }
 535     }
 536 }
 537
 538
 539 void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
 540                                    const wxString& text,
 541                                    const wxRect& rect,
 542                                    wxAuiPaneInfo& pane)
 543 {
 544     dc.SetPen(*wxTRANSPARENT_PEN);
 545     dc.SetFont(m_caption_font);
 546
 547     DrawCaptionBackground(dc, rect,
 548                           (pane.state & wxAuiPaneInfo::optionActive)?true:false);
 549
 550     int caption_offset = 0;
 551     if ( pane.icon.IsOk() )
 552     {
 553         DrawIcon(dc, rect, pane);
 554
 555         caption_offset += pane.icon.GetWidth() + 3;
 556     }
 557
 558     if (pane.state & wxAuiPaneInfo::optionActive)
 559         dc.SetTextForeground(m_active_caption_text_colour);
 560     else
 561         dc.SetTextForeground(m_inactive_caption_text_colour);
 562
 563
 564     wxCoord w,h;
 565     dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
 566
 567     wxRect clip_rect = rect;
 568     clip_rect.width -= 3; // text offset
 569     clip_rect.width -= 2; // button padding
 570     if (pane.HasCloseButton())
 571         clip_rect.width -= m_button_size;
 572     if (pane.HasPinButton())
 573         clip_rect.width -= m_button_size;
 574     if (pane.HasMaximizeButton())
 575         clip_rect.width -= m_button_size;
 576
 577     wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
 578
 579     dc.SetClippingRegion(clip_rect);
 580     dc.DrawText(draw_text, rect.x+3 + caption_offset, rect.y+(rect.height/2)-(h/2)-1);
 581     dc.DestroyClippingRegion();
 582 }
 583
 584 void
 585 wxAuiDefaultDockArt::DrawIcon(wxDC& dc, const wxRect& rect, wxAuiPaneInfo& pane)
 586 {
 587    // Draw the icon centered vertically
 588    dc.DrawBitmap(pane.icon,
 589                  rect.x+2, rect.y+(rect.height-pane.icon.GetHeight())/2,
 590                  true);
 591 }
 592
 593 void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
 594                                    const wxRect& rect,
 595                                    wxAuiPaneInfo& pane)
 596 {
 597     dc.SetPen(*wxTRANSPARENT_PEN);
 598     dc.SetBrush(m_gripper_brush);
 599
 600     dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
 601
 602     if (!pane.HasGripperTop())
 603     {
 604         int y = 5;
 605         while (1)
 606         {
 607             dc.SetPen(m_gripper_pen1);
 608             dc.DrawPoint(rect.x+3, rect.y+y);
 609             dc.SetPen(m_gripper_pen2);
 610             dc.DrawPoint(rect.x+3, rect.y+y+1);
 611             dc.DrawPoint(rect.x+4, rect.y+y);
 612             dc.SetPen(m_gripper_pen3);
 613             dc.DrawPoint(rect.x+5, rect.y+y+1);
 614             dc.DrawPoint(rect.x+5, rect.y+y+2);
 615             dc.DrawPoint(rect.x+4, rect.y+y+2);
 616
 617             y += 4;
 618             if (y > rect.GetHeight()-5)
 619                 break;
 620         }
 621     }
 622     else
 623     {
 624         int x = 5;
 625         while (1)
 626         {
 627             dc.SetPen(m_gripper_pen1);
 628             dc.DrawPoint(rect.x+x, rect.y+3);
 629             dc.SetPen(m_gripper_pen2);
 630             dc.DrawPoint(rect.x+x+1, rect.y+3);
 631             dc.DrawPoint(rect.x+x, rect.y+4);
 632             dc.SetPen(m_gripper_pen3);
 633             dc.DrawPoint(rect.x+x+1, rect.y+5);
 634             dc.DrawPoint(rect.x+x+2, rect.y+5);
 635             dc.DrawPoint(rect.x+x+2, rect.y+4);
 636
 637             x += 4;
 638             if (x > rect.GetWidth()-5)
 639                 break;
 640         }
 641     }
 642 }
 643
 644 void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
 645                                       int button,
 646                                       int button_state,
 647                                       const wxRect& _rect,
 648                                       wxAuiPaneInfo& pane)
 649 {
 650     wxBitmap bmp;
 651     if (!(&pane))
 652         return;
 653     switch (button)
 654     {
 655         default:
 656         case wxAUI_BUTTON_CLOSE:
 657             if (pane.state & wxAuiPaneInfo::optionActive)
 658                 bmp = m_active_close_bitmap;
 659             else
 660                 bmp = m_inactive_close_bitmap;
 661             break;
 662         case wxAUI_BUTTON_PIN:
 663             if (pane.state & wxAuiPaneInfo::optionActive)
 664                 bmp = m_active_pin_bitmap;
 665             else
 666                 bmp = m_inactive_pin_bitmap;
 667             break;
 668         case wxAUI_BUTTON_MAXIMIZE_RESTORE:
 669             if (pane.IsMaximized())
 670             {
 671                 if (pane.state & wxAuiPaneInfo::optionActive)
 672                     bmp = m_active_restore_bitmap;
 673                 else
 674                     bmp = m_inactive_restore_bitmap;
 675             }
 676             else
 677             {
 678                 if (pane.state & wxAuiPaneInfo::optionActive)
 679                     bmp = m_active_maximize_bitmap;
 680                 else
 681                     bmp = m_inactive_maximize_bitmap;
 682             }
 683             break;
 684     }
 685
 686
 687     wxRect rect = _rect;
 688
 689     int old_y = rect.y;
 690     rect.y = rect.y + (rect.height/2) - (bmp.GetHeight()/2);
 691     rect.height = old_y + rect.height - rect.y - 1;
 692
 693
 694     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
 695     {
 696         rect.x++;
 697         rect.y++;
 698     }
 699
 700     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
 701         button_state == wxAUI_BUTTON_STATE_PRESSED)
 702     {
 703         if (pane.state & wxAuiPaneInfo::optionActive)
 704         {
 705             dc.SetBrush(wxBrush(m_active_caption_colour.ChangeLightness(120)));
 706             dc.SetPen(wxPen(m_active_caption_colour.ChangeLightness(70)));
 707         }
 708         else
 709         {
 710             dc.SetBrush(wxBrush(m_inactive_caption_colour.ChangeLightness(120)));
 711             dc.SetPen(wxPen(m_inactive_caption_colour.ChangeLightness(70)));
 712         }
 713
 714         // draw the background behind the button
 715         dc.DrawRectangle(rect.x, rect.y, 15, 15);
 716     }
 717
 718
 719     // draw the button itself
 720     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 721 }
 722
 723
 724 #endif // wxUSE_AUI