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