| 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 | #endif |
| 40 | |
| 41 | #ifdef __WXGTK__ |
| 42 | #include <gtk/gtk.h> |
| 43 | #include "wx/gtk/win_gtk.h" |
| 44 | #include "wx/renderer.h" |
| 45 | #endif |
| 46 | |
| 47 | |
| 48 | // -- wxDefaultDockArt class implementation -- |
| 49 | |
| 50 | // wxDefaultDockArt is an art provider class which does all of the drawing for |
| 51 | // wxFrameManager. 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 wxDockArt base class). The active dock art class can be set via |
| 55 | // wxFrameManager::SetDockArt() |
| 56 | |
| 57 | |
| 58 | // StepColour() it a utility function that simply darkens |
| 59 | // or lightens a color, based on the specified percentage |
| 60 | static wxColor StepColour(const wxColor& c, int percent) |
| 61 | { |
| 62 | int r = c.Red(), g = c.Green(), b = c.Blue(); |
| 63 | return wxColour((unsigned char)wxMin((r*percent)/100,255), |
| 64 | (unsigned char)wxMin((g*percent)/100,255), |
| 65 | (unsigned char)wxMin((b*percent)/100,255)); |
| 66 | } |
| 67 | |
| 68 | static wxColor LightContrastColour(const wxColour& c) |
| 69 | { |
| 70 | int amount = 120; |
| 71 | |
| 72 | // if the color is especially dark, then |
| 73 | // make the contrast even lighter |
| 74 | if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128) |
| 75 | amount = 160; |
| 76 | |
| 77 | return StepColour(c, amount); |
| 78 | } |
| 79 | |
| 80 | // BitmapFromBits() is a utility function that creates a |
| 81 | // masked bitmap from raw bits (XBM format) |
| 82 | static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h, |
| 83 | const wxColour& color) |
| 84 | { |
| 85 | wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage(); |
| 86 | img.Replace(0,0,0,123,123,123); |
| 87 | img.Replace(255,255,255,color.Red(),color.Green(),color.Blue()); |
| 88 | img.SetMaskColour(123,123,123); |
| 89 | return wxBitmap(img); |
| 90 | } |
| 91 | |
| 92 | |
| 93 | static void DrawGradientRectangle(wxDC& dc, |
| 94 | const wxRect& rect, |
| 95 | const wxColour& start_color, |
| 96 | const wxColour& end_color, |
| 97 | int direction) |
| 98 | { |
| 99 | int rd, gd, bd, high = 0; |
| 100 | rd = end_color.Red() - start_color.Red(); |
| 101 | gd = end_color.Green() - start_color.Green(); |
| 102 | bd = end_color.Blue() - start_color.Blue(); |
| 103 | |
| 104 | if (direction == wxAUI_GRADIENT_VERTICAL) |
| 105 | high = rect.GetHeight()-1; |
| 106 | else |
| 107 | high = rect.GetWidth()-1; |
| 108 | |
| 109 | for (int i = 0; i <= high; ++i) |
| 110 | { |
| 111 | int r = start_color.Red() + ((i*rd*100)/high)/100; |
| 112 | int g = start_color.Green() + ((i*gd*100)/high)/100; |
| 113 | int b = start_color.Blue() + ((i*bd*100)/high)/100; |
| 114 | |
| 115 | wxPen p(wxColor((unsigned char)r, |
| 116 | (unsigned char)g, |
| 117 | (unsigned char)b)); |
| 118 | dc.SetPen(p); |
| 119 | |
| 120 | if (direction == wxAUI_GRADIENT_VERTICAL) |
| 121 | dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i); |
| 122 | else |
| 123 | dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height); |
| 124 | } |
| 125 | |
| 126 | } |
| 127 | |
| 128 | wxDefaultDockArt::wxDefaultDockArt() |
| 129 | { |
| 130 | #ifdef __WXMAC__ |
| 131 | wxBrush toolbarbrush; |
| 132 | toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground ); |
| 133 | wxColor base_color = toolbarbrush.GetColour(); |
| 134 | #else |
| 135 | wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); |
| 136 | #endif |
| 137 | |
| 138 | wxColor darker1_color = StepColour(base_color, 85); |
| 139 | wxColor darker2_color = StepColour(base_color, 70); |
| 140 | wxColor darker3_color = StepColour(base_color, 60); |
| 141 | wxColor darker4_color = StepColour(base_color, 50); |
| 142 | wxColor darker5_color = StepColour(base_color, 40); |
| 143 | |
| 144 | m_active_caption_colour = LightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT)); |
| 145 | m_active_caption_gradient_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT); |
| 146 | m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); |
| 147 | m_inactive_caption_colour = StepColour(darker1_color, 80); |
| 148 | m_inactive_caption_gradient_colour = darker1_color; |
| 149 | m_inactive_caption_text_colour = *wxBLACK; |
| 150 | |
| 151 | #ifdef __WXMAC__ |
| 152 | m_sash_brush = toolbarbrush; |
| 153 | m_background_brush = toolbarbrush; |
| 154 | m_gripper_brush = toolbarbrush; |
| 155 | #else |
| 156 | m_sash_brush = wxBrush(base_color); |
| 157 | m_background_brush = wxBrush(base_color); |
| 158 | m_gripper_brush = wxBrush(base_color); |
| 159 | #endif |
| 160 | m_border_pen = wxPen(darker2_color); |
| 161 | m_gripper_pen1 = wxPen(darker5_color); |
| 162 | m_gripper_pen2 = wxPen(darker3_color); |
| 163 | m_gripper_pen3 = *wxWHITE_PEN; |
| 164 | |
| 165 | #ifdef __WXMAC__ |
| 166 | m_caption_font = *wxSMALL_FONT; |
| 167 | #else |
| 168 | m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE); |
| 169 | #endif |
| 170 | |
| 171 | // some built in bitmaps |
| 172 | #if defined( __WXMAC__ ) |
| 173 | static unsigned char close_bits[]={ |
| 174 | 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3, |
| 175 | 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3, |
| 176 | 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF }; |
| 177 | #elif defined( __WXGTK__) |
| 178 | static unsigned char close_bits[]={ |
| 179 | 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8, |
| 180 | 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef, |
| 181 | 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
| 182 | #else |
| 183 | static unsigned char close_bits[]={ |
| 184 | 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9, |
| 185 | 0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb, |
| 186 | 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}; |
| 187 | #endif |
| 188 | |
| 189 | static unsigned char pin_bits[]={ |
| 190 | 0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc, |
| 191 | 0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff, |
| 192 | 0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff}; |
| 193 | |
| 194 | #ifdef __WXMAC__ |
| 195 | m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE); |
| 196 | #else |
| 197 | m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour); |
| 198 | #endif |
| 199 | m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour); |
| 200 | #ifdef __WXMAC__ |
| 201 | m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE ); |
| 202 | #else |
| 203 | m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour); |
| 204 | #endif |
| 205 | m_active_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour); |
| 206 | |
| 207 | // default metric values |
| 208 | #if defined(__WXMAC__) |
| 209 | SInt32 height; |
| 210 | GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height ); |
| 211 | m_sash_size = height; |
| 212 | #elif defined(__WXGTK__) |
| 213 | m_sash_size = wxRendererNative::Get().GetSplitterParams(NULL).widthSash; |
| 214 | #else |
| 215 | m_sash_size = 4; |
| 216 | #endif |
| 217 | m_caption_size = 17; |
| 218 | m_border_size = 1; |
| 219 | m_button_size = 14; |
| 220 | m_gripper_size = 9; |
| 221 | m_gradient_type = wxAUI_GRADIENT_VERTICAL; |
| 222 | } |
| 223 | |
| 224 | int wxDefaultDockArt::GetMetric(int id) |
| 225 | { |
| 226 | switch (id) |
| 227 | { |
| 228 | case wxAUI_ART_SASH_SIZE: return m_sash_size; |
| 229 | case wxAUI_ART_CAPTION_SIZE: return m_caption_size; |
| 230 | case wxAUI_ART_GRIPPER_SIZE: return m_gripper_size; |
| 231 | case wxAUI_ART_PANE_BORDER_SIZE: return m_border_size; |
| 232 | case wxAUI_ART_PANE_BUTTON_SIZE: return m_button_size; |
| 233 | case wxAUI_ART_GRADIENT_TYPE: return m_gradient_type; |
| 234 | default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break; |
| 235 | } |
| 236 | |
| 237 | return 0; |
| 238 | } |
| 239 | |
| 240 | void wxDefaultDockArt::SetMetric(int id, int new_val) |
| 241 | { |
| 242 | switch (id) |
| 243 | { |
| 244 | case wxAUI_ART_SASH_SIZE: m_sash_size = new_val; break; |
| 245 | case wxAUI_ART_CAPTION_SIZE: m_caption_size = new_val; break; |
| 246 | case wxAUI_ART_GRIPPER_SIZE: m_gripper_size = new_val; break; |
| 247 | case wxAUI_ART_PANE_BORDER_SIZE: m_border_size = new_val; break; |
| 248 | case wxAUI_ART_PANE_BUTTON_SIZE: m_button_size = new_val; break; |
| 249 | case wxAUI_ART_GRADIENT_TYPE: m_gradient_type = new_val; break; |
| 250 | default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break; |
| 251 | } |
| 252 | } |
| 253 | |
| 254 | wxColour wxDefaultDockArt::GetColour(int id) |
| 255 | { |
| 256 | switch (id) |
| 257 | { |
| 258 | case wxAUI_ART_BACKGROUND_COLOUR: return m_background_brush.GetColour(); |
| 259 | case wxAUI_ART_SASH_COLOUR: return m_sash_brush.GetColour(); |
| 260 | case wxAUI_ART_INACTIVE_CAPTION_COLOUR: return m_inactive_caption_colour; |
| 261 | case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour; |
| 262 | case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR: return m_inactive_caption_text_colour; |
| 263 | case wxAUI_ART_ACTIVE_CAPTION_COLOUR: return m_active_caption_colour; |
| 264 | case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR: return m_active_caption_gradient_colour; |
| 265 | case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR: return m_active_caption_text_colour; |
| 266 | case wxAUI_ART_BORDER_COLOUR: return m_border_pen.GetColour(); |
| 267 | case wxAUI_ART_GRIPPER_COLOUR: return m_gripper_brush.GetColour(); |
| 268 | default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break; |
| 269 | } |
| 270 | |
| 271 | return wxColour(); |
| 272 | } |
| 273 | |
| 274 | void wxDefaultDockArt::SetColour(int id, const wxColor& colour) |
| 275 | { |
| 276 | switch (id) |
| 277 | { |
| 278 | case wxAUI_ART_BACKGROUND_COLOUR: m_background_brush.SetColour(colour); break; |
| 279 | case wxAUI_ART_SASH_COLOUR: m_sash_brush.SetColour(colour); break; |
| 280 | case wxAUI_ART_INACTIVE_CAPTION_COLOUR: m_inactive_caption_colour = colour; break; |
| 281 | case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break; |
| 282 | case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR: m_inactive_caption_text_colour = colour; break; |
| 283 | case wxAUI_ART_ACTIVE_CAPTION_COLOUR: m_active_caption_colour = colour; break; |
| 284 | case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR: m_active_caption_gradient_colour = colour; break; |
| 285 | case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR: m_active_caption_text_colour = colour; break; |
| 286 | case wxAUI_ART_BORDER_COLOUR: m_border_pen.SetColour(colour); break; |
| 287 | case wxAUI_ART_GRIPPER_COLOUR: |
| 288 | m_gripper_brush.SetColour(colour); |
| 289 | m_gripper_pen1.SetColour(StepColour(colour, 40)); |
| 290 | m_gripper_pen2.SetColour(StepColour(colour, 60)); |
| 291 | break; |
| 292 | default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break; |
| 293 | } |
| 294 | } |
| 295 | |
| 296 | void wxDefaultDockArt::SetFont(int id, const wxFont& font) |
| 297 | { |
| 298 | if (id == wxAUI_ART_CAPTION_FONT) |
| 299 | m_caption_font = font; |
| 300 | } |
| 301 | |
| 302 | wxFont wxDefaultDockArt::GetFont(int id) |
| 303 | { |
| 304 | if (id == wxAUI_ART_CAPTION_FONT) |
| 305 | return m_caption_font; |
| 306 | return wxNullFont; |
| 307 | } |
| 308 | |
| 309 | void wxDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation, const wxRect& rect) |
| 310 | { |
| 311 | #if defined(__WXMAC__) |
| 312 | HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height ); |
| 313 | CGContextRef cgContext ; |
| 314 | #if wxMAC_USE_CORE_GRAPHICS |
| 315 | cgContext = ((wxMacCGContext*)(dc.GetGraphicContext()))->GetNativeContext() ; |
| 316 | #else |
| 317 | Rect bounds ; |
| 318 | GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ; |
| 319 | QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ; |
| 320 | CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ; |
| 321 | CGContextScaleCTM( cgContext , 1 , -1 ) ; |
| 322 | #endif |
| 323 | |
| 324 | HIThemeSplitterDrawInfo drawInfo ; |
| 325 | drawInfo.version = 0 ; |
| 326 | drawInfo.state = kThemeStateActive ; |
| 327 | drawInfo.adornment = kHIThemeSplitterAdornmentNone ; |
| 328 | HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ; |
| 329 | |
| 330 | #if wxMAC_USE_CORE_GRAPHICS |
| 331 | #else |
| 332 | QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ; |
| 333 | #endif |
| 334 | |
| 335 | #elif defined(__WXGTK__) |
| 336 | |
| 337 | GdkRectangle gdk_rect; |
| 338 | if (orientation == wxVERTICAL ) |
| 339 | { |
| 340 | gdk_rect.x = rect.x; |
| 341 | gdk_rect.y = rect.y; |
| 342 | gdk_rect.width = m_sash_size; |
| 343 | gdk_rect.height = rect.height; |
| 344 | } |
| 345 | else |
| 346 | { |
| 347 | gdk_rect.x = rect.x; |
| 348 | gdk_rect.y = rect.y; |
| 349 | gdk_rect.width = rect.width; |
| 350 | gdk_rect.height = m_sash_size; |
| 351 | } |
| 352 | |
| 353 | if (!window) return; |
| 354 | if (!window->m_wxwindow) return; |
| 355 | if (!GTK_PIZZA(window->m_wxwindow)->bin_window) return; |
| 356 | |
| 357 | gtk_paint_handle |
| 358 | ( |
| 359 | window->m_wxwindow->style, |
| 360 | GTK_PIZZA(window->m_wxwindow)->bin_window, |
| 361 | // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL, |
| 362 | GTK_STATE_NORMAL, |
| 363 | GTK_SHADOW_NONE, |
| 364 | NULL /* no clipping */, |
| 365 | window->m_wxwindow, |
| 366 | "paned", |
| 367 | rect.x, |
| 368 | rect.y, |
| 369 | rect.width, |
| 370 | rect.height, |
| 371 | (orientation == wxVERTICAL) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL |
| 372 | ); |
| 373 | |
| 374 | #else |
| 375 | wxUnusedVar(window); |
| 376 | wxUnusedVar(orientation); |
| 377 | dc.SetPen(*wxTRANSPARENT_PEN); |
| 378 | dc.SetBrush(m_sash_brush); |
| 379 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); |
| 380 | #endif |
| 381 | } |
| 382 | |
| 383 | |
| 384 | void wxDefaultDockArt::DrawBackground(wxDC& dc, wxWindow *WXUNUSED(window), int, const wxRect& rect) |
| 385 | { |
| 386 | dc.SetPen(*wxTRANSPARENT_PEN); |
| 387 | #ifdef __WXMAC__ |
| 388 | // we have to clear first, otherwise we are drawing a light striped pattern |
| 389 | // over an already darker striped background |
| 390 | dc.SetBrush(*wxWHITE_BRUSH) ; |
| 391 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); |
| 392 | #endif |
| 393 | dc.SetBrush(m_background_brush); |
| 394 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); |
| 395 | } |
| 396 | |
| 397 | void wxDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect, |
| 398 | wxPaneInfo& pane) |
| 399 | { |
| 400 | dc.SetPen(m_border_pen); |
| 401 | dc.SetBrush(*wxTRANSPARENT_BRUSH); |
| 402 | |
| 403 | wxRect rect = _rect; |
| 404 | int i, border_width = GetMetric(wxAUI_ART_PANE_BORDER_SIZE); |
| 405 | |
| 406 | if (pane.IsToolbar()) |
| 407 | { |
| 408 | for (i = 0; i < border_width; ++i) |
| 409 | { |
| 410 | dc.SetPen(*wxWHITE_PEN); |
| 411 | dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y); |
| 412 | dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height); |
| 413 | dc.SetPen(m_border_pen); |
| 414 | dc.DrawLine(rect.x, rect.y+rect.height-1, |
| 415 | rect.x+rect.width, rect.y+rect.height-1); |
| 416 | dc.DrawLine(rect.x+rect.width-1, rect.y, |
| 417 | rect.x+rect.width-1, rect.y+rect.height); |
| 418 | rect.Deflate(1); |
| 419 | } |
| 420 | } |
| 421 | else |
| 422 | { |
| 423 | for (i = 0; i < border_width; ++i) |
| 424 | { |
| 425 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); |
| 426 | rect.Deflate(1); |
| 427 | } |
| 428 | } |
| 429 | } |
| 430 | |
| 431 | |
| 432 | void wxDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active) |
| 433 | { |
| 434 | if (m_gradient_type == wxAUI_GRADIENT_NONE) |
| 435 | { |
| 436 | if (active) |
| 437 | dc.SetBrush(wxBrush(m_active_caption_colour)); |
| 438 | else |
| 439 | dc.SetBrush(wxBrush(m_inactive_caption_colour)); |
| 440 | |
| 441 | dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height); |
| 442 | } |
| 443 | else |
| 444 | { |
| 445 | if (active) |
| 446 | { |
| 447 | // on mac the gradients are expected to become darker from the top |
| 448 | #ifdef __WXMAC__ |
| 449 | DrawGradientRectangle(dc, rect, |
| 450 | m_active_caption_gradient_colour, |
| 451 | m_active_caption_colour, |
| 452 | m_gradient_type); |
| 453 | #else |
| 454 | DrawGradientRectangle(dc, rect, |
| 455 | m_active_caption_colour, |
| 456 | m_active_caption_gradient_colour, |
| 457 | m_gradient_type); |
| 458 | #endif |
| 459 | } |
| 460 | else |
| 461 | { |
| 462 | // on mac the gradients are expected to become darker from the top |
| 463 | #ifdef __WXMAC__ |
| 464 | DrawGradientRectangle(dc, rect, |
| 465 | m_inactive_caption_gradient_colour, |
| 466 | m_inactive_caption_colour, |
| 467 | m_gradient_type); |
| 468 | #else |
| 469 | DrawGradientRectangle(dc, rect, |
| 470 | m_inactive_caption_colour, |
| 471 | m_inactive_caption_gradient_colour, |
| 472 | m_gradient_type); |
| 473 | #endif |
| 474 | } |
| 475 | } |
| 476 | } |
| 477 | |
| 478 | |
| 479 | void wxDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window), |
| 480 | const wxString& text, |
| 481 | const wxRect& rect, |
| 482 | wxPaneInfo& pane) |
| 483 | { |
| 484 | dc.SetPen(*wxTRANSPARENT_PEN); |
| 485 | dc.SetFont(m_caption_font); |
| 486 | |
| 487 | DrawCaptionBackground(dc, rect, |
| 488 | (pane.state & wxPaneInfo::optionActive)?true:false); |
| 489 | |
| 490 | if (pane.state & wxPaneInfo::optionActive) |
| 491 | dc.SetTextForeground(m_active_caption_text_colour); |
| 492 | else |
| 493 | dc.SetTextForeground(m_inactive_caption_text_colour); |
| 494 | |
| 495 | |
| 496 | wxCoord w,h; |
| 497 | dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h); |
| 498 | |
| 499 | dc.SetClippingRegion(rect); |
| 500 | dc.DrawText(text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1); |
| 501 | dc.DestroyClippingRegion(); |
| 502 | } |
| 503 | |
| 504 | void wxDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window), |
| 505 | const wxRect& rect, |
| 506 | wxPaneInfo& pane) |
| 507 | { |
| 508 | dc.SetPen(*wxTRANSPARENT_PEN); |
| 509 | dc.SetBrush(m_gripper_brush); |
| 510 | |
| 511 | dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height); |
| 512 | |
| 513 | if (!pane.HasGripperTop()) |
| 514 | { |
| 515 | int y = 5; |
| 516 | while (1) |
| 517 | { |
| 518 | dc.SetPen(m_gripper_pen1); |
| 519 | dc.DrawPoint(rect.x+3, rect.y+y); |
| 520 | dc.SetPen(m_gripper_pen2); |
| 521 | dc.DrawPoint(rect.x+3, rect.y+y+1); |
| 522 | dc.DrawPoint(rect.x+4, rect.y+y); |
| 523 | dc.SetPen(m_gripper_pen3); |
| 524 | dc.DrawPoint(rect.x+5, rect.y+y+1); |
| 525 | dc.DrawPoint(rect.x+5, rect.y+y+2); |
| 526 | dc.DrawPoint(rect.x+4, rect.y+y+2); |
| 527 | |
| 528 | y += 4; |
| 529 | if (y > rect.GetHeight()-5) |
| 530 | break; |
| 531 | } |
| 532 | } |
| 533 | else |
| 534 | { |
| 535 | int x = 5; |
| 536 | while (1) |
| 537 | { |
| 538 | dc.SetPen(m_gripper_pen1); |
| 539 | dc.DrawPoint(rect.x+x, rect.y+3); |
| 540 | dc.SetPen(m_gripper_pen2); |
| 541 | dc.DrawPoint(rect.x+x+1, rect.y+3); |
| 542 | dc.DrawPoint(rect.x+x, rect.y+4); |
| 543 | dc.SetPen(m_gripper_pen3); |
| 544 | dc.DrawPoint(rect.x+x+1, rect.y+5); |
| 545 | dc.DrawPoint(rect.x+x+2, rect.y+5); |
| 546 | dc.DrawPoint(rect.x+x+2, rect.y+4); |
| 547 | |
| 548 | x += 4; |
| 549 | if (x > rect.GetWidth()-5) |
| 550 | break; |
| 551 | } |
| 552 | } |
| 553 | } |
| 554 | |
| 555 | void wxDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window), |
| 556 | int button, |
| 557 | int button_state, |
| 558 | const wxRect& _rect, |
| 559 | wxPaneInfo& pane) |
| 560 | { |
| 561 | wxRect rect = _rect; |
| 562 | |
| 563 | if (button_state == wxAUI_BUTTON_STATE_PRESSED) |
| 564 | { |
| 565 | rect.x++; |
| 566 | rect.y++; |
| 567 | } |
| 568 | |
| 569 | if (button_state == wxAUI_BUTTON_STATE_HOVER || |
| 570 | button_state == wxAUI_BUTTON_STATE_PRESSED) |
| 571 | { |
| 572 | if (pane.state & wxPaneInfo::optionActive) |
| 573 | { |
| 574 | dc.SetBrush(wxBrush(StepColour(m_active_caption_colour, 120))); |
| 575 | dc.SetPen(wxPen(StepColour(m_active_caption_colour, 70))); |
| 576 | } |
| 577 | else |
| 578 | { |
| 579 | dc.SetBrush(wxBrush(StepColour(m_inactive_caption_colour, 120))); |
| 580 | dc.SetPen(wxPen(StepColour(m_inactive_caption_colour, 70))); |
| 581 | } |
| 582 | |
| 583 | // draw the background behind the button |
| 584 | dc.DrawRectangle(rect.x, rect.y, 15, 15); |
| 585 | } |
| 586 | |
| 587 | wxBitmap bmp; |
| 588 | switch (button) |
| 589 | { |
| 590 | default: |
| 591 | case wxPaneInfo::buttonClose: |
| 592 | if (pane.state & wxPaneInfo::optionActive) |
| 593 | bmp = m_active_close_bitmap; |
| 594 | else |
| 595 | bmp = m_inactive_close_bitmap; |
| 596 | break; |
| 597 | case wxPaneInfo::buttonPin: |
| 598 | if (pane.state & wxPaneInfo::optionActive) |
| 599 | bmp = m_active_pin_bitmap; |
| 600 | else |
| 601 | bmp = m_inactive_pin_bitmap; |
| 602 | break; |
| 603 | } |
| 604 | |
| 605 | // draw the button itself |
| 606 | dc.DrawBitmap(bmp, rect.x, rect.y, true); |
| 607 | } |
| 608 | |
| 609 | |
| 610 | #endif // wxUSE_AUI |