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     wxGCDCImpl *impl = (wxGCDCImpl*) dc.GetImpl();
 416     cgContext = (CGContextRef) impl->GetGraphicsContext()->GetNativeContext() ;
 417
 418     HIThemeSplitterDrawInfo drawInfo ;
 419     drawInfo.version = 0 ;
 420     drawInfo.state = kThemeStateActive ;
 421     drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
 422     HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
 423
 424 #elif defined(__WXGTK__)
 425     // clear out the rectangle first
 426     dc.SetPen(*wxTRANSPARENT_PEN);
 427     dc.SetBrush(m_sash_brush);
 428     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 429
 430 #if 0
 431     GdkRectangle gdk_rect;
 432     if (orientation == wxVERTICAL )
 433     {
 434         gdk_rect.x = rect.x;
 435         gdk_rect.y = rect.y;
 436         gdk_rect.width = m_sash_size;
 437         gdk_rect.height = rect.height;
 438     }
 439     else
 440     {
 441         gdk_rect.x = rect.x;
 442         gdk_rect.y = rect.y;
 443         gdk_rect.width = rect.width;
 444         gdk_rect.height = m_sash_size;
 445     }
 446 #endif
 447
 448     if (!window) return;
 449     if (!window->m_wxwindow) return;
 450     if (!GTK_WIDGET_DRAWABLE(window->m_wxwindow)) return;
 451
 452     gtk_paint_handle
 453     (
 454         window->m_wxwindow->style,
 455         window->GTKGetDrawingWindow(),
 456         // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
 457         GTK_STATE_NORMAL,
 458         GTK_SHADOW_NONE,
 459         NULL /* no clipping */,
 460         window->m_wxwindow,
 461         "paned",
 462         rect.x,
 463         rect.y,
 464         rect.width,
 465         rect.height,
 466         (orientation == wxVERTICAL) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL
 467     );
 468
 469 #else
 470     wxUnusedVar(window);
 471     wxUnusedVar(orientation);
 472     dc.SetPen(*wxTRANSPARENT_PEN);
 473     dc.SetBrush(m_sash_brush);
 474     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 475 #endif
 476 }
 477
 478
 479 void wxAuiDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect)
 480 {
 481     dc.SetPen(*wxTRANSPARENT_PEN);
 482 #ifdef __WXMAC__
 483     // we have to clear first, otherwise we are drawing a light striped pattern
 484     // over an already darker striped background
 485     dc.SetBrush(*wxWHITE_BRUSH) ;
 486     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 487 #endif
 488     dc.SetBrush(m_background_brush);
 489     dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 490 }
 491
 492 void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
 493                                   wxAuiPaneInfo& pane)
 494 {
 495     dc.SetPen(m_border_pen);
 496     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 497
 498     wxRect rect = _rect;
 499     int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
 500
 501     if (pane.IsToolbar())
 502     {
 503         for (i = 0; i < border_width; ++i)
 504         {
 505             dc.SetPen(*wxWHITE_PEN);
 506             dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
 507             dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
 508             dc.SetPen(m_border_pen);
 509             dc.DrawLine(rect.x, rect.y+rect.height-1,
 510                         rect.x+rect.width, rect.y+rect.height-1);
 511             dc.DrawLine(rect.x+rect.width-1, rect.y,
 512                         rect.x+rect.width-1, rect.y+rect.height);
 513             rect.Deflate(1);
 514         }
 515     }
 516     else
 517     {
 518         for (i = 0; i < border_width; ++i)
 519         {
 520             dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 521             rect.Deflate(1);
 522         }
 523     }
 524 }
 525
 526
 527 void wxAuiDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
 528 {
 529     if (m_gradient_type == wxAUI_GRADIENT_NONE)
 530     {
 531         if (active)
 532             dc.SetBrush(wxBrush(m_active_caption_colour));
 533         else
 534             dc.SetBrush(wxBrush(m_inactive_caption_colour));
 535
 536         dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 537     }
 538     else
 539     {
 540         if (active)
 541         {
 542             // on mac the gradients are expected to become darker from the top
 543 #ifdef __WXMAC__
 544             DrawGradientRectangle(dc, rect,
 545                                  m_active_caption_colour,
 546                                  m_active_caption_gradient_colour,
 547                                  m_gradient_type);
 548 #else
 549             // on other platforms, active gradients become lighter at the top
 550             DrawGradientRectangle(dc, rect,
 551                                  m_active_caption_gradient_colour,
 552                                  m_active_caption_colour,
 553                                  m_gradient_type);
 554 #endif
 555         }
 556         else
 557         {
 558 #ifdef __WXMAC__
 559             // on mac the gradients are expected to become darker from the top
 560             DrawGradientRectangle(dc, rect,
 561                                  m_inactive_caption_gradient_colour,
 562                                  m_inactive_caption_colour,
 563                                  m_gradient_type);
 564 #else
 565             // on other platforms, inactive gradients become lighter at the bottom
 566             DrawGradientRectangle(dc, rect,
 567                                  m_inactive_caption_colour,
 568                                  m_inactive_caption_gradient_colour,
 569                                  m_gradient_type);
 570 #endif
 571         }
 572     }
 573 }
 574
 575
 576 void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
 577                                    const wxString& text,
 578                                    const wxRect& rect,
 579                                    wxAuiPaneInfo& pane)
 580 {
 581     dc.SetPen(*wxTRANSPARENT_PEN);
 582     dc.SetFont(m_caption_font);
 583
 584     DrawCaptionBackground(dc, rect,
 585                           (pane.state & wxAuiPaneInfo::optionActive)?true:false);
 586
 587     if (pane.state & wxAuiPaneInfo::optionActive)
 588         dc.SetTextForeground(m_active_caption_text_colour);
 589     else
 590         dc.SetTextForeground(m_inactive_caption_text_colour);
 591
 592
 593     wxCoord w,h;
 594     dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
 595
 596     wxRect clip_rect = rect;
 597     clip_rect.width -= 3; // text offset
 598     clip_rect.width -= 2; // button padding
 599     if (pane.HasCloseButton())
 600         clip_rect.width -= m_button_size;
 601     if (pane.HasPinButton())
 602         clip_rect.width -= m_button_size;
 603     if (pane.HasMaximizeButton())
 604         clip_rect.width -= m_button_size;
 605
 606     wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
 607
 608     dc.SetClippingRegion(clip_rect);
 609     dc.DrawText(draw_text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
 610     dc.DestroyClippingRegion();
 611 }
 612
 613 void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
 614                                    const wxRect& rect,
 615                                    wxAuiPaneInfo& pane)
 616 {
 617     dc.SetPen(*wxTRANSPARENT_PEN);
 618     dc.SetBrush(m_gripper_brush);
 619
 620     dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
 621
 622     if (!pane.HasGripperTop())
 623     {
 624         int y = 5;
 625         while (1)
 626         {
 627             dc.SetPen(m_gripper_pen1);
 628             dc.DrawPoint(rect.x+3, rect.y+y);
 629             dc.SetPen(m_gripper_pen2);
 630             dc.DrawPoint(rect.x+3, rect.y+y+1);
 631             dc.DrawPoint(rect.x+4, rect.y+y);
 632             dc.SetPen(m_gripper_pen3);
 633             dc.DrawPoint(rect.x+5, rect.y+y+1);
 634             dc.DrawPoint(rect.x+5, rect.y+y+2);
 635             dc.DrawPoint(rect.x+4, rect.y+y+2);
 636
 637             y += 4;
 638             if (y > rect.GetHeight()-5)
 639                 break;
 640         }
 641     }
 642     else
 643     {
 644         int x = 5;
 645         while (1)
 646         {
 647             dc.SetPen(m_gripper_pen1);
 648             dc.DrawPoint(rect.x+x, rect.y+3);
 649             dc.SetPen(m_gripper_pen2);
 650             dc.DrawPoint(rect.x+x+1, rect.y+3);
 651             dc.DrawPoint(rect.x+x, rect.y+4);
 652             dc.SetPen(m_gripper_pen3);
 653             dc.DrawPoint(rect.x+x+1, rect.y+5);
 654             dc.DrawPoint(rect.x+x+2, rect.y+5);
 655             dc.DrawPoint(rect.x+x+2, rect.y+4);
 656
 657             x += 4;
 658             if (x > rect.GetWidth()-5)
 659                 break;
 660         }
 661     }
 662 }
 663
 664 void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
 665                                       int button,
 666                                       int button_state,
 667                                       const wxRect& _rect,
 668                                       wxAuiPaneInfo& pane)
 669 {
 670     wxBitmap bmp;
 671     if (!(&pane))
 672         return;
 673     switch (button)
 674     {
 675         default:
 676         case wxAUI_BUTTON_CLOSE:
 677             if (pane.state & wxAuiPaneInfo::optionActive)
 678                 bmp = m_active_close_bitmap;
 679             else
 680                 bmp = m_inactive_close_bitmap;
 681             break;
 682         case wxAUI_BUTTON_PIN:
 683             if (pane.state & wxAuiPaneInfo::optionActive)
 684                 bmp = m_active_pin_bitmap;
 685             else
 686                 bmp = m_inactive_pin_bitmap;
 687             break;
 688         case wxAUI_BUTTON_MAXIMIZE_RESTORE:
 689             if (pane.IsMaximized())
 690             {
 691                 if (pane.state & wxAuiPaneInfo::optionActive)
 692                     bmp = m_active_restore_bitmap;
 693                 else
 694                     bmp = m_inactive_restore_bitmap;
 695             }
 696             else
 697             {
 698                 if (pane.state & wxAuiPaneInfo::optionActive)
 699                     bmp = m_active_maximize_bitmap;
 700                 else
 701                     bmp = m_inactive_maximize_bitmap;
 702             }
 703             break;
 704     }
 705
 706
 707     wxRect rect = _rect;
 708
 709     int old_y = rect.y;
 710     rect.y = rect.y + (rect.height/2) - (bmp.GetHeight()/2);
 711     rect.height = old_y + rect.height - rect.y - 1;
 712
 713
 714     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
 715     {
 716         rect.x++;
 717         rect.y++;
 718     }
 719
 720     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
 721         button_state == wxAUI_BUTTON_STATE_PRESSED)
 722     {
 723         if (pane.state & wxAuiPaneInfo::optionActive)
 724         {
 725             dc.SetBrush(wxBrush(wxAuiStepColour(m_active_caption_colour, 120)));
 726             dc.SetPen(wxPen(wxAuiStepColour(m_active_caption_colour, 70)));
 727         }
 728         else
 729         {
 730             dc.SetBrush(wxBrush(wxAuiStepColour(m_inactive_caption_colour, 120)));
 731             dc.SetPen(wxPen(wxAuiStepColour(m_inactive_caption_colour, 70)));
 732         }
 733
 734         // draw the background behind the button
 735         dc.DrawRectangle(rect.x, rect.y, 15, 15);
 736     }
 737
 738
 739     // draw the button itself
 740     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 741 }
 742
 743
 744 #endif // wxUSE_AUI