]> git.saurik.com Git - wxWidgets.git/blob - src/aui/dockart.cpp
projects / wxWidgets.git / blob
? search:


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