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