]> git.saurik.com Git - wxWidgets.git/blob - src/aui/tabart.cpp
Remove all lines containing cvs/svn "$Id$" keyword.
[wxWidgets.git] / src / aui / tabart.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/tabart.cpp
3 // Purpose: wxaui: wx advanced user interface - notebook-art
4 // Author: Benjamin I. Williams
5 // Modified by: Jens Lody (moved from auibook.cpp in extra file)
6 // Created: 2012-03-21
7 // Copyright: (C) Copyright 2006, Kirix Corporation, All Rights Reserved
8 // Licence: wxWindows Library Licence, Version 3.1
9 ///////////////////////////////////////////////////////////////////////////////
10
11 // ----------------------------------------------------------------------------
12 // headers
13 // ----------------------------------------------------------------------------
14
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #if wxUSE_AUI
22
23 #ifndef WX_PRECOMP
24 #include "wx/dc.h"
25 #include "wx/dcclient.h"
26 #include "wx/settings.h"
27 #include "wx/bitmap.h"
28 #include "wx/menu.h"
29 #endif
30
31 #include "wx/renderer.h"
32 #include "wx/aui/auibook.h"
33 #include "wx/aui/framemanager.h"
34 #include "wx/aui/dockart.h"
35
36 #ifdef __WXMAC__
37 #include "wx/osx/private.h"
38 #endif
39
40
41 // -- GUI helper classes and functions --
42
43 class wxAuiCommandCapture : public wxEvtHandler
44 {
45 public:
46
47 wxAuiCommandCapture() { m_lastId = 0; }
48 int GetCommandId() const { return m_lastId; }
49
50 bool ProcessEvent(wxEvent& evt)
51 {
52 if (evt.GetEventType() == wxEVT_MENU)
53 {
54 m_lastId = evt.GetId();
55 return true;
56 }
57
58 if (GetNextHandler())
59 return GetNextHandler()->ProcessEvent(evt);
60
61 return false;
62 }
63
64 private:
65 int m_lastId;
66 };
67
68
69 // these functions live in dockart.cpp -- they'll eventually
70 // be moved to a new utility cpp file
71
72 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
73 const wxColour& color);
74
75 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
76
77 static void DrawButtons(wxDC& dc,
78 const wxRect& _rect,
79 const wxBitmap& bmp,
80 const wxColour& bkcolour,
81 int button_state)
82 {
83 wxRect rect = _rect;
84
85 if (button_state == wxAUI_BUTTON_STATE_PRESSED)
86 {
87 rect.x++;
88 rect.y++;
89 }
90
91 if (button_state == wxAUI_BUTTON_STATE_HOVER ||
92 button_state == wxAUI_BUTTON_STATE_PRESSED)
93 {
94 dc.SetBrush(wxBrush(bkcolour.ChangeLightness(120)));
95 dc.SetPen(wxPen(bkcolour.ChangeLightness(75)));
96
97 // draw the background behind the button
98 dc.DrawRectangle(rect.x, rect.y, 15, 15);
99 }
100
101 // draw the button itself
102 dc.DrawBitmap(bmp, rect.x, rect.y, true);
103 }
104
105 static void IndentPressedBitmap(wxRect* rect, int button_state)
106 {
107 if (button_state == wxAUI_BUTTON_STATE_PRESSED)
108 {
109 rect->x++;
110 rect->y++;
111 }
112 }
113
114 // -- bitmaps --
115
116 #if defined( __WXMAC__ )
117 static const unsigned char close_bits[]={
118 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
119 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
120 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
121 #elif defined( __WXGTK__)
122 static const unsigned char close_bits[]={
123 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
124 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
125 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
126 #else
127 static const unsigned char close_bits[]={
128 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
129 0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
130 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
131 #endif
132
133 static const unsigned char left_bits[] = {
134 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
135 0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
136 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
137
138 static const unsigned char right_bits[] = {
139 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
140 0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
141 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
142
143 static const unsigned char list_bits[] = {
144 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
145 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
146 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
147
148
149
150
151
152
153 // -- wxAuiGenericTabArt class implementation --
154
155 wxAuiGenericTabArt::wxAuiGenericTabArt()
156 {
157 m_normalFont = *wxNORMAL_FONT;
158 m_selectedFont = *wxNORMAL_FONT;
159 m_selectedFont.SetWeight(wxBOLD);
160 m_measuringFont = m_selectedFont;
161
162 m_fixedTabWidth = 100;
163 m_tabCtrlHeight = 0;
164
165 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
166 wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
167 #else
168 wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
169 #endif
170
171 // the baseColour is too pale to use as our base colour,
172 // so darken it a bit --
173 if ((255-baseColour.Red()) +
174 (255-baseColour.Green()) +
175 (255-baseColour.Blue()) < 60)
176 {
177 baseColour = baseColour.ChangeLightness(92);
178 }
179
180 m_activeColour = baseColour;
181 m_baseColour = baseColour;
182 wxColor borderColour = baseColour.ChangeLightness(75);
183
184 m_borderPen = wxPen(borderColour);
185 m_baseColourPen = wxPen(m_baseColour);
186 m_baseColourBrush = wxBrush(m_baseColour);
187
188 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
189 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
190
191 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
192 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
193
194 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
195 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
196
197 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
198 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
199
200 m_flags = 0;
201 }
202
203 wxAuiGenericTabArt::~wxAuiGenericTabArt()
204 {
205 }
206
207 wxAuiTabArt* wxAuiGenericTabArt::Clone()
208 {
209 return new wxAuiGenericTabArt(*this);
210 }
211
212 void wxAuiGenericTabArt::SetFlags(unsigned int flags)
213 {
214 m_flags = flags;
215 }
216
217 void wxAuiGenericTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
218 size_t tab_count)
219 {
220 m_fixedTabWidth = 100;
221
222 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
223
224 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
225 tot_width -= m_activeCloseBmp.GetWidth();
226 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
227 tot_width -= m_activeWindowListBmp.GetWidth();
228
229 if (tab_count > 0)
230 {
231 m_fixedTabWidth = tot_width/(int)tab_count;
232 }
233
234
235 if (m_fixedTabWidth < 100)
236 m_fixedTabWidth = 100;
237
238 if (m_fixedTabWidth > tot_width/2)
239 m_fixedTabWidth = tot_width/2;
240
241 if (m_fixedTabWidth > 220)
242 m_fixedTabWidth = 220;
243
244 m_tabCtrlHeight = tab_ctrl_size.y;
245 }
246
247
248 void wxAuiGenericTabArt::DrawBorder(wxDC& dc, wxWindow* wnd, const wxRect& rect)
249 {
250 int i, border_width = GetBorderWidth(wnd);
251
252 wxRect theRect(rect);
253 for (i = 0; i < border_width; ++i)
254 {
255 dc.DrawRectangle(theRect.x, theRect.y, theRect.width, theRect.height);
256 theRect.Deflate(1);
257 }
258 }
259
260 void wxAuiGenericTabArt::DrawBackground(wxDC& dc,
261 wxWindow* WXUNUSED(wnd),
262 const wxRect& rect)
263 {
264 // draw background
265
266 wxColor top_color = m_baseColour.ChangeLightness(90);
267 wxColor bottom_color = m_baseColour.ChangeLightness(170);
268 wxRect r;
269
270 if (m_flags &wxAUI_NB_BOTTOM)
271 r = wxRect(rect.x, rect.y, rect.width+2, rect.height);
272 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
273 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
274 else //for wxAUI_NB_TOP
275 r = wxRect(rect.x, rect.y, rect.width+2, rect.height-3);
276
277 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
278
279
280 // draw base lines
281
282 dc.SetPen(m_borderPen);
283 int y = rect.GetHeight();
284 int w = rect.GetWidth();
285
286 if (m_flags &wxAUI_NB_BOTTOM)
287 {
288 dc.SetBrush(wxBrush(bottom_color));
289 dc.DrawRectangle(-1, 0, w+2, 4);
290 }
291 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
292 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
293 else //for wxAUI_NB_TOP
294 {
295 dc.SetBrush(m_baseColourBrush);
296 dc.DrawRectangle(-1, y-4, w+2, 4);
297 }
298 }
299
300
301 // DrawTab() draws an individual tab.
302 //
303 // dc - output dc
304 // in_rect - rectangle the tab should be confined to
305 // caption - tab's caption
306 // active - whether or not the tab is active
307 // out_rect - actual output rectangle
308 // x_extent - the advance x; where the next tab should start
309
310 void wxAuiGenericTabArt::DrawTab(wxDC& dc,
311 wxWindow* wnd,
312 const wxAuiNotebookPage& page,
313 const wxRect& in_rect,
314 int close_button_state,
315 wxRect* out_tab_rect,
316 wxRect* out_button_rect,
317 int* x_extent)
318 {
319 wxCoord normal_textx, normal_texty;
320 wxCoord selected_textx, selected_texty;
321 wxCoord texty;
322
323 // if the caption is empty, measure some temporary text
324 wxString caption = page.caption;
325 if (caption.empty())
326 caption = wxT("Xj");
327
328 dc.SetFont(m_selectedFont);
329 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
330
331 dc.SetFont(m_normalFont);
332 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
333
334 // figure out the size of the tab
335 wxSize tab_size = GetTabSize(dc,
336 wnd,
337 page.caption,
338 page.bitmap,
339 page.active,
340 close_button_state,
341 x_extent);
342
343 wxCoord tab_height = m_tabCtrlHeight - 3;
344 wxCoord tab_width = tab_size.x;
345 wxCoord tab_x = in_rect.x;
346 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
347
348
349 caption = page.caption;
350
351
352 // select pen, brush and font for the tab to be drawn
353
354 if (page.active)
355 {
356 dc.SetFont(m_selectedFont);
357 texty = selected_texty;
358 }
359 else
360 {
361 dc.SetFont(m_normalFont);
362 texty = normal_texty;
363 }
364
365
366 // create points that will make the tab outline
367
368 int clip_width = tab_width;
369 if (tab_x + clip_width > in_rect.x + in_rect.width)
370 clip_width = (in_rect.x + in_rect.width) - tab_x;
371
372 /*
373 wxPoint clip_points[6];
374 clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
375 clip_points[1] = wxPoint(tab_x, tab_y+2);
376 clip_points[2] = wxPoint(tab_x+2, tab_y);
377 clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
378 clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
379 clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
380
381 // FIXME: these ports don't provide wxRegion ctor from array of points
382 #if !defined(__WXDFB__) && !defined(__WXCOCOA__)
383 // set the clipping region for the tab --
384 wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
385 dc.SetClippingRegion(clipping_region);
386 #endif // !wxDFB && !wxCocoa
387 */
388 // since the above code above doesn't play well with WXDFB or WXCOCOA,
389 // we'll just use a rectangle for the clipping region for now --
390 dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
391
392
393 wxPoint border_points[6];
394 if (m_flags &wxAUI_NB_BOTTOM)
395 {
396 border_points[0] = wxPoint(tab_x, tab_y);
397 border_points[1] = wxPoint(tab_x, tab_y+tab_height-6);
398 border_points[2] = wxPoint(tab_x+2, tab_y+tab_height-4);
399 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
400 border_points[4] = wxPoint(tab_x+tab_width, tab_y+tab_height-6);
401 border_points[5] = wxPoint(tab_x+tab_width, tab_y);
402 }
403 else //if (m_flags & wxAUI_NB_TOP) {}
404 {
405 border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
406 border_points[1] = wxPoint(tab_x, tab_y+2);
407 border_points[2] = wxPoint(tab_x+2, tab_y);
408 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
409 border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
410 border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
411 }
412 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
413 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
414
415 int drawn_tab_yoff = border_points[1].y;
416 int drawn_tab_height = border_points[0].y - border_points[1].y;
417
418
419 if (page.active)
420 {
421 // draw active tab
422
423 // draw base background color
424 wxRect r(tab_x, tab_y, tab_width, tab_height);
425 dc.SetPen(wxPen(m_activeColour));
426 dc.SetBrush(wxBrush(m_activeColour));
427 dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
428
429 // this white helps fill out the gradient at the top of the tab
430 dc.SetPen(*wxWHITE_PEN);
431 dc.SetBrush(*wxWHITE_BRUSH);
432 dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
433
434 // these two points help the rounded corners appear more antialiased
435 dc.SetPen(wxPen(m_activeColour));
436 dc.DrawPoint(r.x+2, r.y+1);
437 dc.DrawPoint(r.x+r.width-2, r.y+1);
438
439 // set rectangle down a bit for gradient drawing
440 r.SetHeight(r.GetHeight()/2);
441 r.x += 2;
442 r.width -= 3;
443 r.y += r.height;
444 r.y -= 2;
445
446 // draw gradient background
447 wxColor top_color = *wxWHITE;
448 wxColor bottom_color = m_activeColour;
449 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
450 }
451 else
452 {
453 // draw inactive tab
454
455 wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
456
457 // start the gradent up a bit and leave the inside border inset
458 // by a pixel for a 3D look. Only the top half of the inactive
459 // tab will have a slight gradient
460 r.x += 3;
461 r.y++;
462 r.width -= 4;
463 r.height /= 2;
464 r.height--;
465
466 // -- draw top gradient fill for glossy look
467 wxColor top_color = m_baseColour;
468 wxColor bottom_color = top_color.ChangeLightness(160);
469 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
470
471 r.y += r.height;
472 r.y--;
473
474 // -- draw bottom fill for glossy look
475 top_color = m_baseColour;
476 bottom_color = m_baseColour;
477 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
478 }
479
480 // draw tab outline
481 dc.SetPen(m_borderPen);
482 dc.SetBrush(*wxTRANSPARENT_BRUSH);
483 dc.DrawPolygon(WXSIZEOF(border_points), border_points);
484
485 // there are two horizontal grey lines at the bottom of the tab control,
486 // this gets rid of the top one of those lines in the tab control
487 if (page.active)
488 {
489 if (m_flags &wxAUI_NB_BOTTOM)
490 dc.SetPen(wxPen(m_baseColour.ChangeLightness(170)));
491 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
492 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
493 else //for wxAUI_NB_TOP
494 dc.SetPen(m_baseColourPen);
495 dc.DrawLine(border_points[0].x+1,
496 border_points[0].y,
497 border_points[5].x,
498 border_points[5].y);
499 }
500
501
502 int text_offset = tab_x + 8;
503 int close_button_width = 0;
504 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
505 {
506 close_button_width = m_activeCloseBmp.GetWidth();
507 }
508
509 int bitmap_offset = 0;
510 if (page.bitmap.IsOk())
511 {
512 bitmap_offset = tab_x + 8;
513
514 // draw bitmap
515 dc.DrawBitmap(page.bitmap,
516 bitmap_offset,
517 drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
518 true);
519
520 text_offset = bitmap_offset + page.bitmap.GetWidth();
521 text_offset += 3; // bitmap padding
522
523 }
524 else
525 {
526 text_offset = tab_x + 8;
527 }
528
529
530 wxString draw_text = wxAuiChopText(dc,
531 caption,
532 tab_width - (text_offset-tab_x) - close_button_width);
533
534 // draw tab text
535 dc.DrawText(draw_text,
536 text_offset,
537 drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
538
539 // draw focus rectangle
540 if (page.active && (wnd->FindFocus() == wnd))
541 {
542 wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
543 selected_textx, selected_texty);
544
545 wxRect focusRect;
546 wxRect focusRectBitmap;
547
548 if (page.bitmap.IsOk())
549 focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
550 page.bitmap.GetWidth(), page.bitmap.GetHeight());
551
552 if (page.bitmap.IsOk() && draw_text.IsEmpty())
553 focusRect = focusRectBitmap;
554 else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
555 focusRect = focusRectText;
556 else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
557 focusRect = focusRectText.Union(focusRectBitmap);
558
559 focusRect.Inflate(2, 2);
560
561 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
562 }
563
564 // draw close button if necessary
565 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
566 {
567 wxBitmap bmp = m_disabledCloseBmp;
568
569 if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
570 close_button_state == wxAUI_BUTTON_STATE_PRESSED)
571 {
572 bmp = m_activeCloseBmp;
573 }
574
575 int offsetY = tab_y-1;
576 if (m_flags & wxAUI_NB_BOTTOM)
577 offsetY = 1;
578
579 wxRect rect(tab_x + tab_width - close_button_width - 1,
580 offsetY + (tab_height/2) - (bmp.GetHeight()/2),
581 close_button_width,
582 tab_height);
583
584 IndentPressedBitmap(&rect, close_button_state);
585 dc.DrawBitmap(bmp, rect.x, rect.y, true);
586
587 *out_button_rect = rect;
588 }
589
590 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
591
592 dc.DestroyClippingRegion();
593 }
594
595 int wxAuiGenericTabArt::GetIndentSize()
596 {
597 return 5;
598 }
599
600 int wxAuiGenericTabArt::GetBorderWidth(wxWindow* wnd)
601 {
602 wxAuiManager* mgr = wxAuiManager::GetManager(wnd);
603 if (mgr)
604 {
605 wxAuiDockArt* art = mgr->GetArtProvider();
606 if (art)
607 return art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
608 }
609 return 1;
610 }
611
612 int wxAuiGenericTabArt::GetAdditionalBorderSpace(wxWindow* WXUNUSED(wnd))
613 {
614 return 0;
615 }
616
617 wxSize wxAuiGenericTabArt::GetTabSize(wxDC& dc,
618 wxWindow* WXUNUSED(wnd),
619 const wxString& caption,
620 const wxBitmap& bitmap,
621 bool WXUNUSED(active),
622 int close_button_state,
623 int* x_extent)
624 {
625 wxCoord measured_textx, measured_texty, tmp;
626
627 dc.SetFont(m_measuringFont);
628 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
629
630 dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
631
632 // add padding around the text
633 wxCoord tab_width = measured_textx;
634 wxCoord tab_height = measured_texty;
635
636 // if the close button is showing, add space for it
637 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
638 tab_width += m_activeCloseBmp.GetWidth() + 3;
639
640 // if there's a bitmap, add space for it
641 if (bitmap.IsOk())
642 {
643 tab_width += bitmap.GetWidth();
644 tab_width += 3; // right side bitmap padding
645 tab_height = wxMax(tab_height, bitmap.GetHeight());
646 }
647
648 // add padding
649 tab_width += 16;
650 tab_height += 10;
651
652 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
653 {
654 tab_width = m_fixedTabWidth;
655 }
656
657 *x_extent = tab_width;
658
659 return wxSize(tab_width, tab_height);
660 }
661
662
663 void wxAuiGenericTabArt::DrawButton(wxDC& dc,
664 wxWindow* WXUNUSED(wnd),
665 const wxRect& in_rect,
666 int bitmap_id,
667 int button_state,
668 int orientation,
669 wxRect* out_rect)
670 {
671 wxBitmap bmp;
672 wxRect rect;
673
674 switch (bitmap_id)
675 {
676 case wxAUI_BUTTON_CLOSE:
677 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
678 bmp = m_disabledCloseBmp;
679 else
680 bmp = m_activeCloseBmp;
681 break;
682 case wxAUI_BUTTON_LEFT:
683 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
684 bmp = m_disabledLeftBmp;
685 else
686 bmp = m_activeLeftBmp;
687 break;
688 case wxAUI_BUTTON_RIGHT:
689 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
690 bmp = m_disabledRightBmp;
691 else
692 bmp = m_activeRightBmp;
693 break;
694 case wxAUI_BUTTON_WINDOWLIST:
695 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
696 bmp = m_disabledWindowListBmp;
697 else
698 bmp = m_activeWindowListBmp;
699 break;
700 }
701
702
703 if (!bmp.IsOk())
704 return;
705
706 rect = in_rect;
707
708 if (orientation == wxLEFT)
709 {
710 rect.SetX(in_rect.x);
711 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
712 rect.SetWidth(bmp.GetWidth());
713 rect.SetHeight(bmp.GetHeight());
714 }
715 else
716 {
717 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
718 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
719 bmp.GetWidth(), bmp.GetHeight());
720 }
721
722 IndentPressedBitmap(&rect, button_state);
723 dc.DrawBitmap(bmp, rect.x, rect.y, true);
724
725 *out_rect = rect;
726 }
727
728 int wxAuiGenericTabArt::ShowDropDown(wxWindow* wnd,
729 const wxAuiNotebookPageArray& pages,
730 int /*active_idx*/)
731 {
732 wxMenu menuPopup;
733
734 size_t i, count = pages.GetCount();
735 for (i = 0; i < count; ++i)
736 {
737 const wxAuiNotebookPage& page = pages.Item(i);
738 wxString caption = page.caption;
739
740 // if there is no caption, make it a space. This will prevent
741 // an assert in the menu code.
742 if (caption.IsEmpty())
743 caption = wxT(" ");
744
745 wxMenuItem* item = new wxMenuItem(NULL, 1000+i, caption);
746 if (page.bitmap.IsOk())
747 item->SetBitmap(page.bitmap);
748 menuPopup.Append(item);
749 }
750
751 // find out where to put the popup menu of window items
752 wxPoint pt = ::wxGetMousePosition();
753 pt = wnd->ScreenToClient(pt);
754
755 // find out the screen coordinate at the bottom of the tab ctrl
756 wxRect cli_rect = wnd->GetClientRect();
757 pt.y = cli_rect.y + cli_rect.height;
758
759 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
760 wnd->PushEventHandler(cc);
761 wnd->PopupMenu(&menuPopup, pt);
762 int command = cc->GetCommandId();
763 wnd->PopEventHandler(true);
764
765 if (command >= 1000)
766 return command-1000;
767
768 return -1;
769 }
770
771 int wxAuiGenericTabArt::GetBestTabCtrlSize(wxWindow* wnd,
772 const wxAuiNotebookPageArray& pages,
773 const wxSize& requiredBmp_size)
774 {
775 wxClientDC dc(wnd);
776 dc.SetFont(m_measuringFont);
777
778 // sometimes a standard bitmap size needs to be enforced, especially
779 // if some tabs have bitmaps and others don't. This is important because
780 // it prevents the tab control from resizing when tabs are added.
781 wxBitmap measureBmp;
782 if (requiredBmp_size.IsFullySpecified())
783 {
784 measureBmp.Create(requiredBmp_size.x,
785 requiredBmp_size.y);
786 }
787
788
789 int max_y = 0;
790 size_t i, page_count = pages.GetCount();
791 for (i = 0; i < page_count; ++i)
792 {
793 wxAuiNotebookPage& page = pages.Item(i);
794
795 wxBitmap bmp;
796 if (measureBmp.IsOk())
797 bmp = measureBmp;
798 else
799 bmp = page.bitmap;
800
801 // we don't use the caption text because we don't
802 // want tab heights to be different in the case
803 // of a very short piece of text on one tab and a very
804 // tall piece of text on another tab
805 int x_ext = 0;
806 wxSize s = GetTabSize(dc,
807 wnd,
808 wxT("ABCDEFGHIj"),
809 bmp,
810 true,
811 wxAUI_BUTTON_STATE_HIDDEN,
812 &x_ext);
813
814 max_y = wxMax(max_y, s.y);
815 }
816
817 return max_y+2;
818 }
819
820 void wxAuiGenericTabArt::SetNormalFont(const wxFont& font)
821 {
822 m_normalFont = font;
823 }
824
825 void wxAuiGenericTabArt::SetSelectedFont(const wxFont& font)
826 {
827 m_selectedFont = font;
828 }
829
830 void wxAuiGenericTabArt::SetMeasuringFont(const wxFont& font)
831 {
832 m_measuringFont = font;
833 }
834
835 void wxAuiGenericTabArt::SetColour(const wxColour& colour)
836 {
837 m_baseColour = colour;
838 m_borderPen = wxPen(m_baseColour.ChangeLightness(75));
839 m_baseColourPen = wxPen(m_baseColour);
840 m_baseColourBrush = wxBrush(m_baseColour);
841 }
842
843 void wxAuiGenericTabArt::SetActiveColour(const wxColour& colour)
844 {
845 m_activeColour = colour;
846 }
847
848 // -- wxAuiSimpleTabArt class implementation --
849
850 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
851 {
852 m_normalFont = *wxNORMAL_FONT;
853 m_selectedFont = *wxNORMAL_FONT;
854 m_selectedFont.SetWeight(wxBOLD);
855 m_measuringFont = m_selectedFont;
856
857 m_flags = 0;
858 m_fixedTabWidth = 100;
859
860 wxColour baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
861
862 wxColour backgroundColour = baseColour;
863 wxColour normaltabColour = baseColour;
864 wxColour selectedtabColour = *wxWHITE;
865
866 m_bkBrush = wxBrush(backgroundColour);
867 m_normalBkBrush = wxBrush(normaltabColour);
868 m_normalBkPen = wxPen(normaltabColour);
869 m_selectedBkBrush = wxBrush(selectedtabColour);
870 m_selectedBkPen = wxPen(selectedtabColour);
871
872 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
873 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
874
875 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
876 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
877
878 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
879 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
880
881 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
882 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
883
884 }
885
886 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
887 {
888 }
889
890 wxAuiTabArt* wxAuiSimpleTabArt::Clone()
891 {
892 return new wxAuiSimpleTabArt(*this);
893 }
894
895 void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
896 {
897 m_flags = flags;
898 }
899
900 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
901 size_t tab_count)
902 {
903 m_fixedTabWidth = 100;
904
905 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
906
907 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
908 tot_width -= m_activeCloseBmp.GetWidth();
909 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
910 tot_width -= m_activeWindowListBmp.GetWidth();
911
912 if (tab_count > 0)
913 {
914 m_fixedTabWidth = tot_width/(int)tab_count;
915 }
916
917
918 if (m_fixedTabWidth < 100)
919 m_fixedTabWidth = 100;
920
921 if (m_fixedTabWidth > tot_width/2)
922 m_fixedTabWidth = tot_width/2;
923
924 if (m_fixedTabWidth > 220)
925 m_fixedTabWidth = 220;
926 }
927
928 void wxAuiSimpleTabArt::SetColour(const wxColour& colour)
929 {
930 m_bkBrush = wxBrush(colour);
931 m_normalBkBrush = wxBrush(colour);
932 m_normalBkPen = wxPen(colour);
933 }
934
935 void wxAuiSimpleTabArt::SetActiveColour(const wxColour& colour)
936 {
937 m_selectedBkBrush = wxBrush(colour);
938 m_selectedBkPen = wxPen(colour);
939 }
940
941 void wxAuiSimpleTabArt::DrawBorder(wxDC& dc, wxWindow* wnd, const wxRect& rect)
942 {
943 int i, border_width = GetBorderWidth(wnd);
944
945 wxRect theRect(rect);
946 for (i = 0; i < border_width; ++i)
947 {
948 dc.DrawRectangle(theRect.x, theRect.y, theRect.width, theRect.height);
949 theRect.Deflate(1);
950 }
951 }
952
953 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
954 wxWindow* WXUNUSED(wnd),
955 const wxRect& rect)
956 {
957 // draw background
958 dc.SetBrush(m_bkBrush);
959 dc.SetPen(*wxTRANSPARENT_PEN);
960 dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
961
962 // draw base line
963 dc.SetPen(*wxGREY_PEN);
964 dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
965 }
966
967
968 // DrawTab() draws an individual tab.
969 //
970 // dc - output dc
971 // in_rect - rectangle the tab should be confined to
972 // caption - tab's caption
973 // active - whether or not the tab is active
974 // out_rect - actual output rectangle
975 // x_extent - the advance x; where the next tab should start
976
977 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
978 wxWindow* wnd,
979 const wxAuiNotebookPage& page,
980 const wxRect& in_rect,
981 int close_button_state,
982 wxRect* out_tab_rect,
983 wxRect* out_button_rect,
984 int* x_extent)
985 {
986 wxCoord normal_textx, normal_texty;
987 wxCoord selected_textx, selected_texty;
988 wxCoord textx, texty;
989
990 // if the caption is empty, measure some temporary text
991 wxString caption = page.caption;
992 if (caption.empty())
993 caption = wxT("Xj");
994
995 dc.SetFont(m_selectedFont);
996 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
997
998 dc.SetFont(m_normalFont);
999 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
1000
1001 // figure out the size of the tab
1002 wxSize tab_size = GetTabSize(dc,
1003 wnd,
1004 page.caption,
1005 page.bitmap,
1006 page.active,
1007 close_button_state,
1008 x_extent);
1009
1010 wxCoord tab_height = tab_size.y;
1011 wxCoord tab_width = tab_size.x;
1012 wxCoord tab_x = in_rect.x;
1013 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
1014
1015 caption = page.caption;
1016
1017 // select pen, brush and font for the tab to be drawn
1018
1019 if (page.active)
1020 {
1021 dc.SetPen(m_selectedBkPen);
1022 dc.SetBrush(m_selectedBkBrush);
1023 dc.SetFont(m_selectedFont);
1024 textx = selected_textx;
1025 texty = selected_texty;
1026 }
1027 else
1028 {
1029 dc.SetPen(m_normalBkPen);
1030 dc.SetBrush(m_normalBkBrush);
1031 dc.SetFont(m_normalFont);
1032 textx = normal_textx;
1033 texty = normal_texty;
1034 }
1035
1036
1037 // -- draw line --
1038
1039 wxPoint points[7];
1040 points[0].x = tab_x;
1041 points[0].y = tab_y + tab_height - 1;
1042 points[1].x = tab_x + tab_height - 3;
1043 points[1].y = tab_y + 2;
1044 points[2].x = tab_x + tab_height + 3;
1045 points[2].y = tab_y;
1046 points[3].x = tab_x + tab_width - 2;
1047 points[3].y = tab_y;
1048 points[4].x = tab_x + tab_width;
1049 points[4].y = tab_y + 2;
1050 points[5].x = tab_x + tab_width;
1051 points[5].y = tab_y + tab_height - 1;
1052 points[6] = points[0];
1053
1054 dc.SetClippingRegion(in_rect);
1055
1056 dc.DrawPolygon(WXSIZEOF(points) - 1, points);
1057
1058 dc.SetPen(*wxGREY_PEN);
1059
1060 //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
1061 dc.DrawLines(WXSIZEOF(points), points);
1062
1063
1064 int text_offset;
1065
1066 int close_button_width = 0;
1067 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1068 {
1069 close_button_width = m_activeCloseBmp.GetWidth();
1070 text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
1071 }
1072 else
1073 {
1074 text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
1075 }
1076
1077 // set minimum text offset
1078 if (text_offset < tab_x + tab_height)
1079 text_offset = tab_x + tab_height;
1080
1081 // chop text if necessary
1082 wxString draw_text = wxAuiChopText(dc,
1083 caption,
1084 tab_width - (text_offset-tab_x) - close_button_width);
1085
1086 // draw tab text
1087 dc.DrawText(draw_text,
1088 text_offset,
1089 (tab_y + tab_height)/2 - (texty/2) + 1);
1090
1091
1092 // draw focus rectangle
1093 if (page.active && (wnd->FindFocus() == wnd))
1094 {
1095 wxRect focusRect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
1096 selected_textx, selected_texty);
1097
1098 focusRect.Inflate(2, 2);
1099
1100 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
1101 }
1102
1103 // draw close button if necessary
1104 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1105 {
1106 wxBitmap bmp;
1107 if (page.active)
1108 bmp = m_activeCloseBmp;
1109 else
1110 bmp = m_disabledCloseBmp;
1111
1112 wxRect rect(tab_x + tab_width - close_button_width - 1,
1113 tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
1114 close_button_width,
1115 tab_height - 1);
1116 DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
1117
1118 *out_button_rect = rect;
1119 }
1120
1121
1122 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
1123
1124 dc.DestroyClippingRegion();
1125 }
1126
1127 int wxAuiSimpleTabArt::GetIndentSize()
1128 {
1129 return 0;
1130 }
1131
1132 int wxAuiSimpleTabArt::GetBorderWidth(wxWindow* wnd)
1133 {
1134 wxAuiManager* mgr = wxAuiManager::GetManager(wnd);
1135 if (mgr)
1136 {
1137 wxAuiDockArt* art = mgr->GetArtProvider();
1138 if (art)
1139 return art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1140 }
1141 return 1;
1142 }
1143
1144 int wxAuiSimpleTabArt::GetAdditionalBorderSpace(wxWindow* WXUNUSED(wnd))
1145 {
1146 return 0;
1147 }
1148
1149 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
1150 wxWindow* WXUNUSED(wnd),
1151 const wxString& caption,
1152 const wxBitmap& WXUNUSED(bitmap),
1153 bool WXUNUSED(active),
1154 int close_button_state,
1155 int* x_extent)
1156 {
1157 wxCoord measured_textx, measured_texty;
1158
1159 dc.SetFont(m_measuringFont);
1160 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
1161
1162 wxCoord tab_height = measured_texty + 4;
1163 wxCoord tab_width = measured_textx + tab_height + 5;
1164
1165 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1166 tab_width += m_activeCloseBmp.GetWidth();
1167
1168 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
1169 {
1170 tab_width = m_fixedTabWidth;
1171 }
1172
1173 *x_extent = tab_width - (tab_height/2) - 1;
1174
1175 return wxSize(tab_width, tab_height);
1176 }
1177
1178
1179 void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
1180 wxWindow* WXUNUSED(wnd),
1181 const wxRect& in_rect,
1182 int bitmap_id,
1183 int button_state,
1184 int orientation,
1185 wxRect* out_rect)
1186 {
1187 wxBitmap bmp;
1188 wxRect rect;
1189
1190 switch (bitmap_id)
1191 {
1192 case wxAUI_BUTTON_CLOSE:
1193 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1194 bmp = m_disabledCloseBmp;
1195 else
1196 bmp = m_activeCloseBmp;
1197 break;
1198 case wxAUI_BUTTON_LEFT:
1199 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1200 bmp = m_disabledLeftBmp;
1201 else
1202 bmp = m_activeLeftBmp;
1203 break;
1204 case wxAUI_BUTTON_RIGHT:
1205 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1206 bmp = m_disabledRightBmp;
1207 else
1208 bmp = m_activeRightBmp;
1209 break;
1210 case wxAUI_BUTTON_WINDOWLIST:
1211 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1212 bmp = m_disabledWindowListBmp;
1213 else
1214 bmp = m_activeWindowListBmp;
1215 break;
1216 }
1217
1218 if (!bmp.IsOk())
1219 return;
1220
1221 rect = in_rect;
1222
1223 if (orientation == wxLEFT)
1224 {
1225 rect.SetX(in_rect.x);
1226 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
1227 rect.SetWidth(bmp.GetWidth());
1228 rect.SetHeight(bmp.GetHeight());
1229 }
1230 else
1231 {
1232 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
1233 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
1234 bmp.GetWidth(), bmp.GetHeight());
1235 }
1236
1237
1238 DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
1239
1240 *out_rect = rect;
1241 }
1242
1243 int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
1244 const wxAuiNotebookPageArray& pages,
1245 int active_idx)
1246 {
1247 wxMenu menuPopup;
1248
1249 size_t i, count = pages.GetCount();
1250 for (i = 0; i < count; ++i)
1251 {
1252 const wxAuiNotebookPage& page = pages.Item(i);
1253 menuPopup.AppendCheckItem(1000+i, page.caption);
1254 }
1255
1256 if (active_idx != -1)
1257 {
1258 menuPopup.Check(1000+active_idx, true);
1259 }
1260
1261 // find out where to put the popup menu of window
1262 // items. Subtract 100 for now to center the menu
1263 // a bit, until a better mechanism can be implemented
1264 wxPoint pt = ::wxGetMousePosition();
1265 pt = wnd->ScreenToClient(pt);
1266 if (pt.x < 100)
1267 pt.x = 0;
1268 else
1269 pt.x -= 100;
1270
1271 // find out the screen coordinate at the bottom of the tab ctrl
1272 wxRect cli_rect = wnd->GetClientRect();
1273 pt.y = cli_rect.y + cli_rect.height;
1274
1275 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
1276 wnd->PushEventHandler(cc);
1277 wnd->PopupMenu(&menuPopup, pt);
1278 int command = cc->GetCommandId();
1279 wnd->PopEventHandler(true);
1280
1281 if (command >= 1000)
1282 return command-1000;
1283
1284 return -1;
1285 }
1286
1287 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
1288 const wxAuiNotebookPageArray& WXUNUSED(pages),
1289 const wxSize& WXUNUSED(requiredBmp_size))
1290 {
1291 wxClientDC dc(wnd);
1292 dc.SetFont(m_measuringFont);
1293 int x_ext = 0;
1294 wxSize s = GetTabSize(dc,
1295 wnd,
1296 wxT("ABCDEFGHIj"),
1297 wxNullBitmap,
1298 true,
1299 wxAUI_BUTTON_STATE_HIDDEN,
1300 &x_ext);
1301 return s.y+3;
1302 }
1303
1304 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
1305 {
1306 m_normalFont = font;
1307 }
1308
1309 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
1310 {
1311 m_selectedFont = font;
1312 }
1313
1314 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
1315 {
1316 m_measuringFont = font;
1317 }
1318
1319 #endif // wxUSE_AUI