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