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