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