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