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