]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/aui/auibook.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Use string column identifiers with NSTableColumns in wxDataViewCtrl.
[wxWidgets.git] / src / aui / auibook.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: src/aui/auibook.cpp
3// Purpose: wxaui: wx advanced user interface - notebook
4// Author: Benjamin I. Williams
5// Modified by:
6// Created: 2006-06-28
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#include "wx/aui/auibook.h"
24
25#ifndef WX_PRECOMP
26 #include "wx/settings.h"
27 #include "wx/image.h"
28 #include "wx/menu.h"
29#endif
30
31#include "wx/aui/tabmdi.h"
32#include "wx/dcbuffer.h"
33
34#include "wx/renderer.h"
35
36#ifdef __WXMAC__
37#include "wx/osx/private.h"
38#endif
39
40#include "wx/arrimpl.cpp"
41WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
42WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
43
44wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEvent);
45wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, wxAuiNotebookEvent);
46wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, wxAuiNotebookEvent);
47wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEvent);
48wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, wxAuiNotebookEvent);
49wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, wxAuiNotebookEvent);
50wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, wxAuiNotebookEvent);
51wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, wxAuiNotebookEvent);
52wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, wxAuiNotebookEvent);
53wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, wxAuiNotebookEvent);
54wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, wxAuiNotebookEvent);
55wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, wxAuiNotebookEvent);
56wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, wxAuiNotebookEvent);
57wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, wxAuiNotebookEvent);
58wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, wxAuiNotebookEvent);
59wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, wxAuiNotebookEvent);
60
61IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
62IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
63IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxBookCtrlEvent)
64
65
66
67
68
69// these functions live in dockart.cpp -- they'll eventually
70// be moved to a new utility cpp file
71
72wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
73 const wxColour& color);
74
75wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
76
77static 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
105static 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
115
116// -- GUI helper classes and functions --
117
118class wxAuiCommandCapture : public wxEvtHandler
119{
120public:
121
122 wxAuiCommandCapture() { m_lastId = 0; }
123 int GetCommandId() const { return m_lastId; }
124
125 bool ProcessEvent(wxEvent& evt)
126 {
127 if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
128 {
129 m_lastId = evt.GetId();
130 return true;
131 }
132
133 if (GetNextHandler())
134 return GetNextHandler()->ProcessEvent(evt);
135
136 return false;
137 }
138
139private:
140 int m_lastId;
141};
142
143
144// -- bitmaps --
145
146#if defined( __WXMAC__ )
147 static const unsigned char close_bits[]={
148 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
149 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
150 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
151#elif defined( __WXGTK__)
152 static const unsigned char close_bits[]={
153 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
154 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
155 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
156#else
157 static const unsigned char close_bits[]={
158 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
159 0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
160 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
161#endif
162
163static const unsigned char left_bits[] = {
164 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
165 0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
166 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
167
168static const unsigned char right_bits[] = {
169 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
170 0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
171 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
172
173static const unsigned char list_bits[] = {
174 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
175 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
176 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
177
178
179
180
181
182
183// -- wxAuiDefaultTabArt class implementation --
184
185wxAuiDefaultTabArt::wxAuiDefaultTabArt()
186{
187 m_normalFont = *wxNORMAL_FONT;
188 m_selectedFont = *wxNORMAL_FONT;
189 m_selectedFont.SetWeight(wxBOLD);
190 m_measuringFont = m_selectedFont;
191
192 m_fixedTabWidth = 100;
193 m_tabCtrlHeight = 0;
194
195#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
196 wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
197#else
198 wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
199#endif
200
201 // the baseColour is too pale to use as our base colour,
202 // so darken it a bit --
203 if ((255-baseColour.Red()) +
204 (255-baseColour.Green()) +
205 (255-baseColour.Blue()) < 60)
206 {
207 baseColour = baseColour.ChangeLightness(92);
208 }
209
210 m_activeColour = baseColour;
211 m_baseColour = baseColour;
212 wxColor borderColour = baseColour.ChangeLightness(75);
213
214 m_borderPen = wxPen(borderColour);
215 m_baseColourPen = wxPen(m_baseColour);
216 m_baseColourBrush = wxBrush(m_baseColour);
217
218 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
219 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
220
221 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
222 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
223
224 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
225 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
226
227 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
228 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
229
230 m_flags = 0;
231}
232
233wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
234{
235}
236
237wxAuiTabArt* wxAuiDefaultTabArt::Clone()
238{
239 return new wxAuiDefaultTabArt(*this);
240}
241
242void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
243{
244 m_flags = flags;
245}
246
247void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
248 size_t tab_count)
249{
250 m_fixedTabWidth = 100;
251
252 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
253
254 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
255 tot_width -= m_activeCloseBmp.GetWidth();
256 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
257 tot_width -= m_activeWindowListBmp.GetWidth();
258
259 if (tab_count > 0)
260 {
261 m_fixedTabWidth = tot_width/(int)tab_count;
262 }
263
264
265 if (m_fixedTabWidth < 100)
266 m_fixedTabWidth = 100;
267
268 if (m_fixedTabWidth > tot_width/2)
269 m_fixedTabWidth = tot_width/2;
270
271 if (m_fixedTabWidth > 220)
272 m_fixedTabWidth = 220;
273
274 m_tabCtrlHeight = tab_ctrl_size.y;
275}
276
277
278void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
279 wxWindow* WXUNUSED(wnd),
280 const wxRect& rect)
281{
282 // draw background
283
284 wxColor top_color = m_baseColour.ChangeLightness(90);
285 wxColor bottom_color = m_baseColour.ChangeLightness(170);
286 wxRect r;
287
288 if (m_flags &wxAUI_NB_BOTTOM)
289 r = wxRect(rect.x, rect.y, rect.width+2, rect.height);
290 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
291 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
292 else //for wxAUI_NB_TOP
293 r = wxRect(rect.x, rect.y, rect.width+2, rect.height-3);
294
295 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
296
297
298 // draw base lines
299
300 dc.SetPen(m_borderPen);
301 int y = rect.GetHeight();
302 int w = rect.GetWidth();
303
304 if (m_flags &wxAUI_NB_BOTTOM)
305 {
306 dc.SetBrush(wxBrush(bottom_color));
307 dc.DrawRectangle(-1, 0, w+2, 4);
308 }
309 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
310 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
311 else //for wxAUI_NB_TOP
312 {
313 dc.SetBrush(m_baseColourBrush);
314 dc.DrawRectangle(-1, y-4, w+2, 4);
315 }
316}
317
318
319// DrawTab() draws an individual tab.
320//
321// dc - output dc
322// in_rect - rectangle the tab should be confined to
323// caption - tab's caption
324// active - whether or not the tab is active
325// out_rect - actual output rectangle
326// x_extent - the advance x; where the next tab should start
327
328void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
329 wxWindow* wnd,
330 const wxAuiNotebookPage& page,
331 const wxRect& in_rect,
332 int close_button_state,
333 wxRect* out_tab_rect,
334 wxRect* out_button_rect,
335 int* x_extent)
336{
337 wxCoord normal_textx, normal_texty;
338 wxCoord selected_textx, selected_texty;
339 wxCoord texty;
340
341 // if the caption is empty, measure some temporary text
342 wxString caption = page.caption;
343 if (caption.empty())
344 caption = wxT("Xj");
345
346 dc.SetFont(m_selectedFont);
347 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
348
349 dc.SetFont(m_normalFont);
350 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
351
352 // figure out the size of the tab
353 wxSize tab_size = GetTabSize(dc,
354 wnd,
355 page.caption,
356 page.bitmap,
357 page.active,
358 close_button_state,
359 x_extent);
360
361 wxCoord tab_height = m_tabCtrlHeight - 3;
362 wxCoord tab_width = tab_size.x;
363 wxCoord tab_x = in_rect.x;
364 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
365
366
367 caption = page.caption;
368
369
370 // select pen, brush and font for the tab to be drawn
371
372 if (page.active)
373 {
374 dc.SetFont(m_selectedFont);
375 texty = selected_texty;
376 }
377 else
378 {
379 dc.SetFont(m_normalFont);
380 texty = normal_texty;
381 }
382
383
384 // create points that will make the tab outline
385
386 int clip_width = tab_width;
387 if (tab_x + clip_width > in_rect.x + in_rect.width)
388 clip_width = (in_rect.x + in_rect.width) - tab_x;
389
390/*
391 wxPoint clip_points[6];
392 clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
393 clip_points[1] = wxPoint(tab_x, tab_y+2);
394 clip_points[2] = wxPoint(tab_x+2, tab_y);
395 clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
396 clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
397 clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
398
399 // FIXME: these ports don't provide wxRegion ctor from array of points
400#if !defined(__WXDFB__) && !defined(__WXCOCOA__)
401 // set the clipping region for the tab --
402 wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
403 dc.SetClippingRegion(clipping_region);
404#endif // !wxDFB && !wxCocoa
405*/
406 // since the above code above doesn't play well with WXDFB or WXCOCOA,
407 // we'll just use a rectangle for the clipping region for now --
408 dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
409
410
411 wxPoint border_points[6];
412 if (m_flags &wxAUI_NB_BOTTOM)
413 {
414 border_points[0] = wxPoint(tab_x, tab_y);
415 border_points[1] = wxPoint(tab_x, tab_y+tab_height-6);
416 border_points[2] = wxPoint(tab_x+2, tab_y+tab_height-4);
417 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
418 border_points[4] = wxPoint(tab_x+tab_width, tab_y+tab_height-6);
419 border_points[5] = wxPoint(tab_x+tab_width, tab_y);
420 }
421 else //if (m_flags & wxAUI_NB_TOP) {}
422 {
423 border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
424 border_points[1] = wxPoint(tab_x, tab_y+2);
425 border_points[2] = wxPoint(tab_x+2, tab_y);
426 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
427 border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
428 border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
429 }
430 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
431 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
432
433 int drawn_tab_yoff = border_points[1].y;
434 int drawn_tab_height = border_points[0].y - border_points[1].y;
435
436
437 if (page.active)
438 {
439 // draw active tab
440
441 // draw base background color
442 wxRect r(tab_x, tab_y, tab_width, tab_height);
443 dc.SetPen(wxPen(m_activeColour));
444 dc.SetBrush(wxBrush(m_activeColour));
445 dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
446
447 // this white helps fill out the gradient at the top of the tab
448 dc.SetPen(*wxWHITE_PEN);
449 dc.SetBrush(*wxWHITE_BRUSH);
450 dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
451
452 // these two points help the rounded corners appear more antialiased
453 dc.SetPen(wxPen(m_activeColour));
454 dc.DrawPoint(r.x+2, r.y+1);
455 dc.DrawPoint(r.x+r.width-2, r.y+1);
456
457 // set rectangle down a bit for gradient drawing
458 r.SetHeight(r.GetHeight()/2);
459 r.x += 2;
460 r.width -= 3;
461 r.y += r.height;
462 r.y -= 2;
463
464 // draw gradient background
465 wxColor top_color = *wxWHITE;
466 wxColor bottom_color = m_activeColour;
467 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
468 }
469 else
470 {
471 // draw inactive tab
472
473 wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
474
475 // start the gradent up a bit and leave the inside border inset
476 // by a pixel for a 3D look. Only the top half of the inactive
477 // tab will have a slight gradient
478 r.x += 3;
479 r.y++;
480 r.width -= 4;
481 r.height /= 2;
482 r.height--;
483
484 // -- draw top gradient fill for glossy look
485 wxColor top_color = m_baseColour;
486 wxColor bottom_color = top_color.ChangeLightness(160);
487 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
488
489 r.y += r.height;
490 r.y--;
491
492 // -- draw bottom fill for glossy look
493 top_color = m_baseColour;
494 bottom_color = m_baseColour;
495 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
496 }
497
498 // draw tab outline
499 dc.SetPen(m_borderPen);
500 dc.SetBrush(*wxTRANSPARENT_BRUSH);
501 dc.DrawPolygon(WXSIZEOF(border_points), border_points);
502
503 // there are two horizontal grey lines at the bottom of the tab control,
504 // this gets rid of the top one of those lines in the tab control
505 if (page.active)
506 {
507 if (m_flags &wxAUI_NB_BOTTOM)
508 dc.SetPen(wxPen(m_baseColour.ChangeLightness(170)));
509 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
510 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
511 else //for wxAUI_NB_TOP
512 dc.SetPen(m_baseColourPen);
513 dc.DrawLine(border_points[0].x+1,
514 border_points[0].y,
515 border_points[5].x,
516 border_points[5].y);
517 }
518
519
520 int text_offset = tab_x + 8;
521 int close_button_width = 0;
522 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
523 {
524 close_button_width = m_activeCloseBmp.GetWidth();
525 }
526
527 int bitmap_offset = 0;
528 if (page.bitmap.IsOk())
529 {
530 bitmap_offset = tab_x + 8;
531
532 // draw bitmap
533 dc.DrawBitmap(page.bitmap,
534 bitmap_offset,
535 drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
536 true);
537
538 text_offset = bitmap_offset + page.bitmap.GetWidth();
539 text_offset += 3; // bitmap padding
540
541 }
542 else
543 {
544 text_offset = tab_x + 8;
545 }
546
547
548 wxString draw_text = wxAuiChopText(dc,
549 caption,
550 tab_width - (text_offset-tab_x) - close_button_width);
551
552 // draw tab text
553 dc.DrawText(draw_text,
554 text_offset,
555 drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
556
557 // draw focus rectangle
558 if (page.active && (wnd->FindFocus() == wnd))
559 {
560 wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
561 selected_textx, selected_texty);
562
563 wxRect focusRect;
564 wxRect focusRectBitmap;
565
566 if (page.bitmap.IsOk())
567 focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
568 page.bitmap.GetWidth(), page.bitmap.GetHeight());
569
570 if (page.bitmap.IsOk() && draw_text.IsEmpty())
571 focusRect = focusRectBitmap;
572 else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
573 focusRect = focusRectText;
574 else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
575 focusRect = focusRectText.Union(focusRectBitmap);
576
577 focusRect.Inflate(2, 2);
578
579 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
580 }
581
582 // draw close button if necessary
583 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
584 {
585 wxBitmap bmp = m_disabledCloseBmp;
586
587 if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
588 close_button_state == wxAUI_BUTTON_STATE_PRESSED)
589 {
590 bmp = m_activeCloseBmp;
591 }
592
593 int offsetY = tab_y-1;
594 if (m_flags & wxAUI_NB_BOTTOM)
595 offsetY = 1;
596
597 wxRect rect(tab_x + tab_width - close_button_width - 1,
598 offsetY + (tab_height/2) - (bmp.GetHeight()/2),
599 close_button_width,
600 tab_height);
601
602 IndentPressedBitmap(&rect, close_button_state);
603 dc.DrawBitmap(bmp, rect.x, rect.y, true);
604
605 *out_button_rect = rect;
606 }
607
608 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
609
610 dc.DestroyClippingRegion();
611}
612
613int wxAuiDefaultTabArt::GetIndentSize()
614{
615 return 5;
616}
617
618wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
619 wxWindow* WXUNUSED(wnd),
620 const wxString& caption,
621 const wxBitmap& bitmap,
622 bool WXUNUSED(active),
623 int close_button_state,
624 int* x_extent)
625{
626 wxCoord measured_textx, measured_texty, tmp;
627
628 dc.SetFont(m_measuringFont);
629 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
630
631 dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
632
633 // add padding around the text
634 wxCoord tab_width = measured_textx;
635 wxCoord tab_height = measured_texty;
636
637 // if the close button is showing, add space for it
638 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
639 tab_width += m_activeCloseBmp.GetWidth() + 3;
640
641 // if there's a bitmap, add space for it
642 if (bitmap.IsOk())
643 {
644 tab_width += bitmap.GetWidth();
645 tab_width += 3; // right side bitmap padding
646 tab_height = wxMax(tab_height, bitmap.GetHeight());
647 }
648
649 // add padding
650 tab_width += 16;
651 tab_height += 10;
652
653 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
654 {
655 tab_width = m_fixedTabWidth;
656 }
657
658 *x_extent = tab_width;
659
660 return wxSize(tab_width, tab_height);
661}
662
663
664void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
665 wxWindow* WXUNUSED(wnd),
666 const wxRect& in_rect,
667 int bitmap_id,
668 int button_state,
669 int orientation,
670 wxRect* out_rect)
671{
672 wxBitmap bmp;
673 wxRect rect;
674
675 switch (bitmap_id)
676 {
677 case wxAUI_BUTTON_CLOSE:
678 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
679 bmp = m_disabledCloseBmp;
680 else
681 bmp = m_activeCloseBmp;
682 break;
683 case wxAUI_BUTTON_LEFT:
684 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
685 bmp = m_disabledLeftBmp;
686 else
687 bmp = m_activeLeftBmp;
688 break;
689 case wxAUI_BUTTON_RIGHT:
690 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
691 bmp = m_disabledRightBmp;
692 else
693 bmp = m_activeRightBmp;
694 break;
695 case wxAUI_BUTTON_WINDOWLIST:
696 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
697 bmp = m_disabledWindowListBmp;
698 else
699 bmp = m_activeWindowListBmp;
700 break;
701 }
702
703
704 if (!bmp.IsOk())
705 return;
706
707 rect = in_rect;
708
709 if (orientation == wxLEFT)
710 {
711 rect.SetX(in_rect.x);
712 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
713 rect.SetWidth(bmp.GetWidth());
714 rect.SetHeight(bmp.GetHeight());
715 }
716 else
717 {
718 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
719 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
720 bmp.GetWidth(), bmp.GetHeight());
721 }
722
723 IndentPressedBitmap(&rect, button_state);
724 dc.DrawBitmap(bmp, rect.x, rect.y, true);
725
726 *out_rect = rect;
727}
728
729int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
730 const wxAuiNotebookPageArray& pages,
731 int /*active_idx*/)
732{
733 wxMenu menuPopup;
734
735 size_t i, count = pages.GetCount();
736 for (i = 0; i < count; ++i)
737 {
738 const wxAuiNotebookPage& page = pages.Item(i);
739 wxString caption = page.caption;
740
741 // if there is no caption, make it a space. This will prevent
742 // an assert in the menu code.
743 if (caption.IsEmpty())
744 caption = wxT(" ");
745
746 wxMenuItem* item = new wxMenuItem(NULL, 1000+i, caption);
747 if (page.bitmap.IsOk())
748 item->SetBitmap(page.bitmap);
749 menuPopup.Append(item);
750 }
751
752 // find out where to put the popup menu of window items
753 wxPoint pt = ::wxGetMousePosition();
754 pt = wnd->ScreenToClient(pt);
755
756 // find out the screen coordinate at the bottom of the tab ctrl
757 wxRect cli_rect = wnd->GetClientRect();
758 pt.y = cli_rect.y + cli_rect.height;
759
760 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
761 wnd->PushEventHandler(cc);
762 wnd->PopupMenu(&menuPopup, pt);
763 int command = cc->GetCommandId();
764 wnd->PopEventHandler(true);
765
766 if (command >= 1000)
767 return command-1000;
768
769 return -1;
770}
771
772int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
773 const wxAuiNotebookPageArray& pages,
774 const wxSize& requiredBmp_size)
775{
776 wxClientDC dc(wnd);
777 dc.SetFont(m_measuringFont);
778
779 // sometimes a standard bitmap size needs to be enforced, especially
780 // if some tabs have bitmaps and others don't. This is important because
781 // it prevents the tab control from resizing when tabs are added.
782 wxBitmap measureBmp;
783 if (requiredBmp_size.IsFullySpecified())
784 {
785 measureBmp.Create(requiredBmp_size.x,
786 requiredBmp_size.y);
787 }
788
789
790 int max_y = 0;
791 size_t i, page_count = pages.GetCount();
792 for (i = 0; i < page_count; ++i)
793 {
794 wxAuiNotebookPage& page = pages.Item(i);
795
796 wxBitmap bmp;
797 if (measureBmp.IsOk())
798 bmp = measureBmp;
799 else
800 bmp = page.bitmap;
801
802 // we don't use the caption text because we don't
803 // want tab heights to be different in the case
804 // of a very short piece of text on one tab and a very
805 // tall piece of text on another tab
806 int x_ext = 0;
807 wxSize s = GetTabSize(dc,
808 wnd,
809 wxT("ABCDEFGHIj"),
810 bmp,
811 true,
812 wxAUI_BUTTON_STATE_HIDDEN,
813 &x_ext);
814
815 max_y = wxMax(max_y, s.y);
816 }
817
818 return max_y+2;
819}
820
821void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
822{
823 m_normalFont = font;
824}
825
826void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
827{
828 m_selectedFont = font;
829}
830
831void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
832{
833 m_measuringFont = font;
834}
835
836void wxAuiDefaultTabArt::SetColour(const wxColour& colour)
837{
838 m_baseColour = colour;
839 m_borderPen = wxPen(m_baseColour.ChangeLightness(75));
840 m_baseColourPen = wxPen(m_baseColour);
841 m_baseColourBrush = wxBrush(m_baseColour);
842}
843
844void wxAuiDefaultTabArt::SetActiveColour(const wxColour& colour)
845{
846 m_activeColour = colour;
847}
848
849// -- wxAuiSimpleTabArt class implementation --
850
851wxAuiSimpleTabArt::wxAuiSimpleTabArt()
852{
853 m_normalFont = *wxNORMAL_FONT;
854 m_selectedFont = *wxNORMAL_FONT;
855 m_selectedFont.SetWeight(wxBOLD);
856 m_measuringFont = m_selectedFont;
857
858 m_flags = 0;
859 m_fixedTabWidth = 100;
860
861 wxColour baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
862
863 wxColour backgroundColour = baseColour;
864 wxColour normaltabColour = baseColour;
865 wxColour selectedtabColour = *wxWHITE;
866
867 m_bkBrush = wxBrush(backgroundColour);
868 m_normalBkBrush = wxBrush(normaltabColour);
869 m_normalBkPen = wxPen(normaltabColour);
870 m_selectedBkBrush = wxBrush(selectedtabColour);
871 m_selectedBkPen = wxPen(selectedtabColour);
872
873 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
874 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
875
876 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
877 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
878
879 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
880 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
881
882 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
883 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
884
885}
886
887wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
888{
889}
890
891wxAuiTabArt* wxAuiSimpleTabArt::Clone()
892{
893 return new wxAuiSimpleTabArt(*this);
894}
895
896void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
897{
898 m_flags = flags;
899}
900
901void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
902 size_t tab_count)
903{
904 m_fixedTabWidth = 100;
905
906 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
907
908 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
909 tot_width -= m_activeCloseBmp.GetWidth();
910 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
911 tot_width -= m_activeWindowListBmp.GetWidth();
912
913 if (tab_count > 0)
914 {
915 m_fixedTabWidth = tot_width/(int)tab_count;
916 }
917
918
919 if (m_fixedTabWidth < 100)
920 m_fixedTabWidth = 100;
921
922 if (m_fixedTabWidth > tot_width/2)
923 m_fixedTabWidth = tot_width/2;
924
925 if (m_fixedTabWidth > 220)
926 m_fixedTabWidth = 220;
927}
928
929void wxAuiSimpleTabArt::SetColour(const wxColour& colour)
930{
931 m_bkBrush = wxBrush(colour);
932 m_normalBkBrush = wxBrush(colour);
933 m_normalBkPen = wxPen(colour);
934}
935
936void wxAuiSimpleTabArt::SetActiveColour(const wxColour& colour)
937{
938 m_selectedBkBrush = wxBrush(colour);
939 m_selectedBkPen = wxPen(colour);
940}
941
942void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
943 wxWindow* WXUNUSED(wnd),
944 const wxRect& rect)
945{
946 // draw background
947 dc.SetBrush(m_bkBrush);
948 dc.SetPen(*wxTRANSPARENT_PEN);
949 dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
950
951 // draw base line
952 dc.SetPen(*wxGREY_PEN);
953 dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
954}
955
956
957// DrawTab() draws an individual tab.
958//
959// dc - output dc
960// in_rect - rectangle the tab should be confined to
961// caption - tab's caption
962// active - whether or not the tab is active
963// out_rect - actual output rectangle
964// x_extent - the advance x; where the next tab should start
965
966void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
967 wxWindow* wnd,
968 const wxAuiNotebookPage& page,
969 const wxRect& in_rect,
970 int close_button_state,
971 wxRect* out_tab_rect,
972 wxRect* out_button_rect,
973 int* x_extent)
974{
975 wxCoord normal_textx, normal_texty;
976 wxCoord selected_textx, selected_texty;
977 wxCoord textx, texty;
978
979 // if the caption is empty, measure some temporary text
980 wxString caption = page.caption;
981 if (caption.empty())
982 caption = wxT("Xj");
983
984 dc.SetFont(m_selectedFont);
985 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
986
987 dc.SetFont(m_normalFont);
988 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
989
990 // figure out the size of the tab
991 wxSize tab_size = GetTabSize(dc,
992 wnd,
993 page.caption,
994 page.bitmap,
995 page.active,
996 close_button_state,
997 x_extent);
998
999 wxCoord tab_height = tab_size.y;
1000 wxCoord tab_width = tab_size.x;
1001 wxCoord tab_x = in_rect.x;
1002 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
1003
1004 caption = page.caption;
1005
1006 // select pen, brush and font for the tab to be drawn
1007
1008 if (page.active)
1009 {
1010 dc.SetPen(m_selectedBkPen);
1011 dc.SetBrush(m_selectedBkBrush);
1012 dc.SetFont(m_selectedFont);
1013 textx = selected_textx;
1014 texty = selected_texty;
1015 }
1016 else
1017 {
1018 dc.SetPen(m_normalBkPen);
1019 dc.SetBrush(m_normalBkBrush);
1020 dc.SetFont(m_normalFont);
1021 textx = normal_textx;
1022 texty = normal_texty;
1023 }
1024
1025
1026 // -- draw line --
1027
1028 wxPoint points[7];
1029 points[0].x = tab_x;
1030 points[0].y = tab_y + tab_height - 1;
1031 points[1].x = tab_x + tab_height - 3;
1032 points[1].y = tab_y + 2;
1033 points[2].x = tab_x + tab_height + 3;
1034 points[2].y = tab_y;
1035 points[3].x = tab_x + tab_width - 2;
1036 points[3].y = tab_y;
1037 points[4].x = tab_x + tab_width;
1038 points[4].y = tab_y + 2;
1039 points[5].x = tab_x + tab_width;
1040 points[5].y = tab_y + tab_height - 1;
1041 points[6] = points[0];
1042
1043 dc.SetClippingRegion(in_rect);
1044
1045 dc.DrawPolygon(WXSIZEOF(points) - 1, points);
1046
1047 dc.SetPen(*wxGREY_PEN);
1048
1049 //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
1050 dc.DrawLines(WXSIZEOF(points), points);
1051
1052
1053 int text_offset;
1054
1055 int close_button_width = 0;
1056 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1057 {
1058 close_button_width = m_activeCloseBmp.GetWidth();
1059 text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
1060 }
1061 else
1062 {
1063 text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
1064 }
1065
1066 // set minimum text offset
1067 if (text_offset < tab_x + tab_height)
1068 text_offset = tab_x + tab_height;
1069
1070 // chop text if necessary
1071 wxString draw_text = wxAuiChopText(dc,
1072 caption,
1073 tab_width - (text_offset-tab_x) - close_button_width);
1074
1075 // draw tab text
1076 dc.DrawText(draw_text,
1077 text_offset,
1078 (tab_y + tab_height)/2 - (texty/2) + 1);
1079
1080
1081 // draw focus rectangle
1082 if (page.active && (wnd->FindFocus() == wnd))
1083 {
1084 wxRect focusRect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
1085 selected_textx, selected_texty);
1086
1087 focusRect.Inflate(2, 2);
1088
1089 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
1090 }
1091
1092 // draw close button if necessary
1093 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1094 {
1095 wxBitmap bmp;
1096 if (page.active)
1097 bmp = m_activeCloseBmp;
1098 else
1099 bmp = m_disabledCloseBmp;
1100
1101 wxRect rect(tab_x + tab_width - close_button_width - 1,
1102 tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
1103 close_button_width,
1104 tab_height - 1);
1105 DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
1106
1107 *out_button_rect = rect;
1108 }
1109
1110
1111 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
1112
1113 dc.DestroyClippingRegion();
1114}
1115
1116int wxAuiSimpleTabArt::GetIndentSize()
1117{
1118 return 0;
1119}
1120
1121wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
1122 wxWindow* WXUNUSED(wnd),
1123 const wxString& caption,
1124 const wxBitmap& WXUNUSED(bitmap),
1125 bool WXUNUSED(active),
1126 int close_button_state,
1127 int* x_extent)
1128{
1129 wxCoord measured_textx, measured_texty;
1130
1131 dc.SetFont(m_measuringFont);
1132 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
1133
1134 wxCoord tab_height = measured_texty + 4;
1135 wxCoord tab_width = measured_textx + tab_height + 5;
1136
1137 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1138 tab_width += m_activeCloseBmp.GetWidth();
1139
1140 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
1141 {
1142 tab_width = m_fixedTabWidth;
1143 }
1144
1145 *x_extent = tab_width - (tab_height/2) - 1;
1146
1147 return wxSize(tab_width, tab_height);
1148}
1149
1150
1151void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
1152 wxWindow* WXUNUSED(wnd),
1153 const wxRect& in_rect,
1154 int bitmap_id,
1155 int button_state,
1156 int orientation,
1157 wxRect* out_rect)
1158{
1159 wxBitmap bmp;
1160 wxRect rect;
1161
1162 switch (bitmap_id)
1163 {
1164 case wxAUI_BUTTON_CLOSE:
1165 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1166 bmp = m_disabledCloseBmp;
1167 else
1168 bmp = m_activeCloseBmp;
1169 break;
1170 case wxAUI_BUTTON_LEFT:
1171 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1172 bmp = m_disabledLeftBmp;
1173 else
1174 bmp = m_activeLeftBmp;
1175 break;
1176 case wxAUI_BUTTON_RIGHT:
1177 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1178 bmp = m_disabledRightBmp;
1179 else
1180 bmp = m_activeRightBmp;
1181 break;
1182 case wxAUI_BUTTON_WINDOWLIST:
1183 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1184 bmp = m_disabledWindowListBmp;
1185 else
1186 bmp = m_activeWindowListBmp;
1187 break;
1188 }
1189
1190 if (!bmp.IsOk())
1191 return;
1192
1193 rect = in_rect;
1194
1195 if (orientation == wxLEFT)
1196 {
1197 rect.SetX(in_rect.x);
1198 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
1199 rect.SetWidth(bmp.GetWidth());
1200 rect.SetHeight(bmp.GetHeight());
1201 }
1202 else
1203 {
1204 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
1205 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
1206 bmp.GetWidth(), bmp.GetHeight());
1207 }
1208
1209
1210 DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
1211
1212 *out_rect = rect;
1213}
1214
1215int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
1216 const wxAuiNotebookPageArray& pages,
1217 int active_idx)
1218{
1219 wxMenu menuPopup;
1220
1221 size_t i, count = pages.GetCount();
1222 for (i = 0; i < count; ++i)
1223 {
1224 const wxAuiNotebookPage& page = pages.Item(i);
1225 menuPopup.AppendCheckItem(1000+i, page.caption);
1226 }
1227
1228 if (active_idx != -1)
1229 {
1230 menuPopup.Check(1000+active_idx, true);
1231 }
1232
1233 // find out where to put the popup menu of window
1234 // items. Subtract 100 for now to center the menu
1235 // a bit, until a better mechanism can be implemented
1236 wxPoint pt = ::wxGetMousePosition();
1237 pt = wnd->ScreenToClient(pt);
1238 if (pt.x < 100)
1239 pt.x = 0;
1240 else
1241 pt.x -= 100;
1242
1243 // find out the screen coordinate at the bottom of the tab ctrl
1244 wxRect cli_rect = wnd->GetClientRect();
1245 pt.y = cli_rect.y + cli_rect.height;
1246
1247 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
1248 wnd->PushEventHandler(cc);
1249 wnd->PopupMenu(&menuPopup, pt);
1250 int command = cc->GetCommandId();
1251 wnd->PopEventHandler(true);
1252
1253 if (command >= 1000)
1254 return command-1000;
1255
1256 return -1;
1257}
1258
1259int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
1260 const wxAuiNotebookPageArray& WXUNUSED(pages),
1261 const wxSize& WXUNUSED(requiredBmp_size))
1262{
1263 wxClientDC dc(wnd);
1264 dc.SetFont(m_measuringFont);
1265 int x_ext = 0;
1266 wxSize s = GetTabSize(dc,
1267 wnd,
1268 wxT("ABCDEFGHIj"),
1269 wxNullBitmap,
1270 true,
1271 wxAUI_BUTTON_STATE_HIDDEN,
1272 &x_ext);
1273 return s.y+3;
1274}
1275
1276void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
1277{
1278 m_normalFont = font;
1279}
1280
1281void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
1282{
1283 m_selectedFont = font;
1284}
1285
1286void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
1287{
1288 m_measuringFont = font;
1289}
1290
1291
1292
1293
1294// -- wxAuiTabContainer class implementation --
1295
1296
1297// wxAuiTabContainer is a class which contains information about each
1298// tab. It also can render an entire tab control to a specified DC.
1299// It's not a window class itself, because this code will be used by
1300// the wxFrameMananger, where it is disadvantageous to have separate
1301// windows for each tab control in the case of "docked tabs"
1302
1303// A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
1304// which can be used as a tab control in the normal sense.
1305
1306
1307wxAuiTabContainer::wxAuiTabContainer()
1308{
1309 m_tabOffset = 0;
1310 m_flags = 0;
1311 m_art = new wxAuiDefaultTabArt;
1312
1313 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1314 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1315 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1316 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1317}
1318
1319wxAuiTabContainer::~wxAuiTabContainer()
1320{
1321 delete m_art;
1322}
1323
1324void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
1325{
1326 delete m_art;
1327 m_art = art;
1328
1329 if (m_art)
1330 {
1331 m_art->SetFlags(m_flags);
1332 }
1333}
1334
1335wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
1336{
1337 return m_art;
1338}
1339
1340void wxAuiTabContainer::SetFlags(unsigned int flags)
1341{
1342 m_flags = flags;
1343
1344 // check for new close button settings
1345 RemoveButton(wxAUI_BUTTON_LEFT);
1346 RemoveButton(wxAUI_BUTTON_RIGHT);
1347 RemoveButton(wxAUI_BUTTON_WINDOWLIST);
1348 RemoveButton(wxAUI_BUTTON_CLOSE);
1349
1350
1351 if (flags & wxAUI_NB_SCROLL_BUTTONS)
1352 {
1353 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1354 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1355 }
1356
1357 if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
1358 {
1359 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1360 }
1361
1362 if (flags & wxAUI_NB_CLOSE_BUTTON)
1363 {
1364 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1365 }
1366
1367 if (m_art)
1368 {
1369 m_art->SetFlags(m_flags);
1370 }
1371}
1372
1373unsigned int wxAuiTabContainer::GetFlags() const
1374{
1375 return m_flags;
1376}
1377
1378
1379void wxAuiTabContainer::SetNormalFont(const wxFont& font)
1380{
1381 m_art->SetNormalFont(font);
1382}
1383
1384void wxAuiTabContainer::SetSelectedFont(const wxFont& font)
1385{
1386 m_art->SetSelectedFont(font);
1387}
1388
1389void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
1390{
1391 m_art->SetMeasuringFont(font);
1392}
1393
1394void wxAuiTabContainer::SetColour(const wxColour& colour)
1395{
1396 m_art->SetColour(colour);
1397}
1398
1399void wxAuiTabContainer::SetActiveColour(const wxColour& colour)
1400{
1401 m_art->SetActiveColour(colour);
1402}
1403
1404void wxAuiTabContainer::SetRect(const wxRect& rect)
1405{
1406 m_rect = rect;
1407
1408 if (m_art)
1409 {
1410 m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
1411 }
1412}
1413
1414bool wxAuiTabContainer::AddPage(wxWindow* page,
1415 const wxAuiNotebookPage& info)
1416{
1417 wxAuiNotebookPage page_info;
1418 page_info = info;
1419 page_info.window = page;
1420
1421 m_pages.Add(page_info);
1422
1423 // let the art provider know how many pages we have
1424 if (m_art)
1425 {
1426 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1427 }
1428
1429 return true;
1430}
1431
1432bool wxAuiTabContainer::InsertPage(wxWindow* page,
1433 const wxAuiNotebookPage& info,
1434 size_t idx)
1435{
1436 wxAuiNotebookPage page_info;
1437 page_info = info;
1438 page_info.window = page;
1439
1440 if (idx >= m_pages.GetCount())
1441 m_pages.Add(page_info);
1442 else
1443 m_pages.Insert(page_info, idx);
1444
1445 // let the art provider know how many pages we have
1446 if (m_art)
1447 {
1448 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1449 }
1450
1451 return true;
1452}
1453
1454bool wxAuiTabContainer::MovePage(wxWindow* page,
1455 size_t new_idx)
1456{
1457 int idx = GetIdxFromWindow(page);
1458 if (idx == -1)
1459 return false;
1460
1461 // get page entry, make a copy of it
1462 wxAuiNotebookPage p = GetPage(idx);
1463
1464 // remove old page entry
1465 RemovePage(page);
1466
1467 // insert page where it should be
1468 InsertPage(page, p, new_idx);
1469
1470 return true;
1471}
1472
1473bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
1474{
1475 size_t i, page_count = m_pages.GetCount();
1476 for (i = 0; i < page_count; ++i)
1477 {
1478 wxAuiNotebookPage& page = m_pages.Item(i);
1479 if (page.window == wnd)
1480 {
1481 m_pages.RemoveAt(i);
1482
1483 // let the art provider know how many pages we have
1484 if (m_art)
1485 {
1486 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1487 }
1488
1489 return true;
1490 }
1491 }
1492
1493 return false;
1494}
1495
1496bool wxAuiTabContainer::SetActivePage(wxWindow* wnd)
1497{
1498 bool found = false;
1499
1500 size_t i, page_count = m_pages.GetCount();
1501 for (i = 0; i < page_count; ++i)
1502 {
1503 wxAuiNotebookPage& page = m_pages.Item(i);
1504 if (page.window == wnd)
1505 {
1506 page.active = true;
1507 found = true;
1508 }
1509 else
1510 {
1511 page.active = false;
1512 }
1513 }
1514
1515 return found;
1516}
1517
1518void wxAuiTabContainer::SetNoneActive()
1519{
1520 size_t i, page_count = m_pages.GetCount();
1521 for (i = 0; i < page_count; ++i)
1522 {
1523 wxAuiNotebookPage& page = m_pages.Item(i);
1524 page.active = false;
1525 }
1526}
1527
1528bool wxAuiTabContainer::SetActivePage(size_t page)
1529{
1530 if (page >= m_pages.GetCount())
1531 return false;
1532
1533 return SetActivePage(m_pages.Item(page).window);
1534}
1535
1536int wxAuiTabContainer::GetActivePage() const
1537{
1538 size_t i, page_count = m_pages.GetCount();
1539 for (i = 0; i < page_count; ++i)
1540 {
1541 wxAuiNotebookPage& page = m_pages.Item(i);
1542 if (page.active)
1543 return i;
1544 }
1545
1546 return -1;
1547}
1548
1549wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
1550{
1551 if (idx >= m_pages.GetCount())
1552 return NULL;
1553
1554 return m_pages[idx].window;
1555}
1556
1557int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
1558{
1559 const size_t page_count = m_pages.GetCount();
1560 for ( size_t i = 0; i < page_count; ++i )
1561 {
1562 wxAuiNotebookPage& page = m_pages.Item(i);
1563 if (page.window == wnd)
1564 return i;
1565 }
1566 return wxNOT_FOUND;
1567}
1568
1569wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
1570{
1571 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1572
1573 return m_pages[idx];
1574}
1575
1576const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
1577{
1578 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1579
1580 return m_pages[idx];
1581}
1582
1583wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
1584{
1585 return m_pages;
1586}
1587
1588size_t wxAuiTabContainer::GetPageCount() const
1589{
1590 return m_pages.GetCount();
1591}
1592
1593void wxAuiTabContainer::AddButton(int id,
1594 int location,
1595 const wxBitmap& normalBitmap,
1596 const wxBitmap& disabledBitmap)
1597{
1598 wxAuiTabContainerButton button;
1599 button.id = id;
1600 button.bitmap = normalBitmap;
1601 button.disBitmap = disabledBitmap;
1602 button.location = location;
1603 button.curState = wxAUI_BUTTON_STATE_NORMAL;
1604
1605 m_buttons.Add(button);
1606}
1607
1608void wxAuiTabContainer::RemoveButton(int id)
1609{
1610 size_t i, button_count = m_buttons.GetCount();
1611
1612 for (i = 0; i < button_count; ++i)
1613 {
1614 if (m_buttons.Item(i).id == id)
1615 {
1616 m_buttons.RemoveAt(i);
1617 return;
1618 }
1619 }
1620}
1621
1622
1623
1624size_t wxAuiTabContainer::GetTabOffset() const
1625{
1626 return m_tabOffset;
1627}
1628
1629void wxAuiTabContainer::SetTabOffset(size_t offset)
1630{
1631 m_tabOffset = offset;
1632}
1633
1634
1635
1636
1637// Render() renders the tab catalog to the specified DC
1638// It is a virtual function and can be overridden to
1639// provide custom drawing capabilities
1640void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
1641{
1642 if (!raw_dc || !raw_dc->IsOk())
1643 return;
1644
1645 wxMemoryDC dc;
1646
1647 // use the same layout direction as the window DC uses to ensure that the
1648 // text is rendered correctly
1649 dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
1650
1651 wxBitmap bmp;
1652 size_t i;
1653 size_t page_count = m_pages.GetCount();
1654 size_t button_count = m_buttons.GetCount();
1655
1656 // create off-screen bitmap
1657 bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
1658 dc.SelectObject(bmp);
1659
1660 if (!dc.IsOk())
1661 return;
1662
1663 // find out if size of tabs is larger than can be
1664 // afforded on screen
1665 int total_width = 0;
1666 int visible_width = 0;
1667 for (i = 0; i < page_count; ++i)
1668 {
1669 wxAuiNotebookPage& page = m_pages.Item(i);
1670
1671 // determine if a close button is on this tab
1672 bool close_button = false;
1673 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1674 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1675 {
1676 close_button = true;
1677 }
1678
1679
1680 int x_extent = 0;
1681 wxSize size = m_art->GetTabSize(dc,
1682 wnd,
1683 page.caption,
1684 page.bitmap,
1685 page.active,
1686 close_button ?
1687 wxAUI_BUTTON_STATE_NORMAL :
1688 wxAUI_BUTTON_STATE_HIDDEN,
1689 &x_extent);
1690
1691 if (i+1 < page_count)
1692 total_width += x_extent;
1693 else
1694 total_width += size.x;
1695
1696 if (i >= m_tabOffset)
1697 {
1698 if (i+1 < page_count)
1699 visible_width += x_extent;
1700 else
1701 visible_width += size.x;
1702 }
1703 }
1704
1705 if (total_width > m_rect.GetWidth() || m_tabOffset != 0)
1706 {
1707 // show left/right buttons
1708 for (i = 0; i < button_count; ++i)
1709 {
1710 wxAuiTabContainerButton& button = m_buttons.Item(i);
1711 if (button.id == wxAUI_BUTTON_LEFT ||
1712 button.id == wxAUI_BUTTON_RIGHT)
1713 {
1714 button.curState &= ~wxAUI_BUTTON_STATE_HIDDEN;
1715 }
1716 }
1717 }
1718 else
1719 {
1720 // hide left/right buttons
1721 for (i = 0; i < button_count; ++i)
1722 {
1723 wxAuiTabContainerButton& button = m_buttons.Item(i);
1724 if (button.id == wxAUI_BUTTON_LEFT ||
1725 button.id == wxAUI_BUTTON_RIGHT)
1726 {
1727 button.curState |= wxAUI_BUTTON_STATE_HIDDEN;
1728 }
1729 }
1730 }
1731
1732 // determine whether left button should be enabled
1733 for (i = 0; i < button_count; ++i)
1734 {
1735 wxAuiTabContainerButton& button = m_buttons.Item(i);
1736 if (button.id == wxAUI_BUTTON_LEFT)
1737 {
1738 if (m_tabOffset == 0)
1739 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
1740 else
1741 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
1742 }
1743 if (button.id == wxAUI_BUTTON_RIGHT)
1744 {
1745 if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
1746 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
1747 else
1748 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
1749 }
1750 }
1751
1752
1753
1754 // draw background
1755 m_art->DrawBackground(dc, wnd, m_rect);
1756
1757 // draw buttons
1758 int left_buttons_width = 0;
1759 int right_buttons_width = 0;
1760
1761 int offset = 0;
1762
1763 // draw the buttons on the right side
1764 offset = m_rect.x + m_rect.width;
1765 for (i = 0; i < button_count; ++i)
1766 {
1767 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1768
1769 if (button.location != wxRIGHT)
1770 continue;
1771 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1772 continue;
1773
1774 wxRect button_rect = m_rect;
1775 button_rect.SetY(1);
1776 button_rect.SetWidth(offset);
1777
1778 m_art->DrawButton(dc,
1779 wnd,
1780 button_rect,
1781 button.id,
1782 button.curState,
1783 wxRIGHT,
1784 &button.rect);
1785
1786 offset -= button.rect.GetWidth();
1787 right_buttons_width += button.rect.GetWidth();
1788 }
1789
1790
1791
1792 offset = 0;
1793
1794 // draw the buttons on the left side
1795
1796 for (i = 0; i < button_count; ++i)
1797 {
1798 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1799
1800 if (button.location != wxLEFT)
1801 continue;
1802 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1803 continue;
1804
1805 wxRect button_rect(offset, 1, 1000, m_rect.height);
1806
1807 m_art->DrawButton(dc,
1808 wnd,
1809 button_rect,
1810 button.id,
1811 button.curState,
1812 wxLEFT,
1813 &button.rect);
1814
1815 offset += button.rect.GetWidth();
1816 left_buttons_width += button.rect.GetWidth();
1817 }
1818
1819 offset = left_buttons_width;
1820
1821 if (offset == 0)
1822 offset += m_art->GetIndentSize();
1823
1824
1825 // prepare the tab-close-button array
1826 // make sure tab button entries which aren't used are marked as hidden
1827 for (i = page_count; i < m_tabCloseButtons.GetCount(); ++i)
1828 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1829
1830 // make sure there are enough tab button entries to accommodate all tabs
1831 while (m_tabCloseButtons.GetCount() < page_count)
1832 {
1833 wxAuiTabContainerButton tempbtn;
1834 tempbtn.id = wxAUI_BUTTON_CLOSE;
1835 tempbtn.location = wxCENTER;
1836 tempbtn.curState = wxAUI_BUTTON_STATE_HIDDEN;
1837 m_tabCloseButtons.Add(tempbtn);
1838 }
1839
1840
1841 // buttons before the tab offset must be set to hidden
1842 for (i = 0; i < m_tabOffset; ++i)
1843 {
1844 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1845 }
1846
1847
1848 // draw the tabs
1849
1850 size_t active = 999;
1851 int active_offset = 0;
1852 wxRect active_rect;
1853
1854 int x_extent = 0;
1855 wxRect rect = m_rect;
1856 rect.y = 0;
1857 rect.height = m_rect.height;
1858
1859 for (i = m_tabOffset; i < page_count; ++i)
1860 {
1861 wxAuiNotebookPage& page = m_pages.Item(i);
1862 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
1863
1864 // determine if a close button is on this tab
1865 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1866 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1867 {
1868 if (tab_button.curState == wxAUI_BUTTON_STATE_HIDDEN)
1869 {
1870 tab_button.id = wxAUI_BUTTON_CLOSE;
1871 tab_button.curState = wxAUI_BUTTON_STATE_NORMAL;
1872 tab_button.location = wxCENTER;
1873 }
1874 }
1875 else
1876 {
1877 tab_button.curState = wxAUI_BUTTON_STATE_HIDDEN;
1878 }
1879
1880 rect.x = offset;
1881 rect.width = m_rect.width - right_buttons_width - offset - 2;
1882
1883 if (rect.width <= 0)
1884 break;
1885
1886 m_art->DrawTab(dc,
1887 wnd,
1888 page,
1889 rect,
1890 tab_button.curState,
1891 &page.rect,
1892 &tab_button.rect,
1893 &x_extent);
1894
1895 if (page.active)
1896 {
1897 active = i;
1898 active_offset = offset;
1899 active_rect = rect;
1900 }
1901
1902 offset += x_extent;
1903 }
1904
1905
1906 // make sure to deactivate buttons which are off the screen to the right
1907 for (++i; i < m_tabCloseButtons.GetCount(); ++i)
1908 {
1909 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1910 }
1911
1912
1913 // draw the active tab again so it stands in the foreground
1914 if (active >= m_tabOffset && active < m_pages.GetCount())
1915 {
1916 wxAuiNotebookPage& page = m_pages.Item(active);
1917
1918 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(active);
1919
1920 rect.x = active_offset;
1921 m_art->DrawTab(dc,
1922 wnd,
1923 page,
1924 active_rect,
1925 tab_button.curState,
1926 &page.rect,
1927 &tab_button.rect,
1928 &x_extent);
1929 }
1930
1931
1932 raw_dc->Blit(m_rect.x, m_rect.y,
1933 m_rect.GetWidth(), m_rect.GetHeight(),
1934 &dc, 0, 0);
1935}
1936
1937// Is the tab visible?
1938bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* /*wnd*/)
1939{
1940 if (!dc || !dc->IsOk())
1941 return false;
1942
1943 size_t i;
1944 size_t page_count = m_pages.GetCount();
1945 size_t button_count = m_buttons.GetCount();
1946
1947 // Hasn't been rendered yet; assume it's visible
1948 if (m_tabCloseButtons.GetCount() < page_count)
1949 return true;
1950
1951 // First check if both buttons are disabled - if so, there's no need to
1952 // check further for visibility.
1953 int arrowButtonVisibleCount = 0;
1954 for (i = 0; i < button_count; ++i)
1955 {
1956 wxAuiTabContainerButton& button = m_buttons.Item(i);
1957 if (button.id == wxAUI_BUTTON_LEFT ||
1958 button.id == wxAUI_BUTTON_RIGHT)
1959 {
1960 if ((button.curState & wxAUI_BUTTON_STATE_HIDDEN) == 0)
1961 arrowButtonVisibleCount ++;
1962 }
1963 }
1964
1965 // Tab must be visible
1966 if (arrowButtonVisibleCount == 0)
1967 return true;
1968
1969 // If tab is less than the given offset, it must be invisible by definition
1970 if (tabPage < tabOffset)
1971 return false;
1972
1973 // draw buttons
1974 int left_buttons_width = 0;
1975 int right_buttons_width = 0;
1976
1977 int offset = 0;
1978
1979 // calculate size of the buttons on the right side
1980 offset = m_rect.x + m_rect.width;
1981 for (i = 0; i < button_count; ++i)
1982 {
1983 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1984
1985 if (button.location != wxRIGHT)
1986 continue;
1987 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1988 continue;
1989
1990 offset -= button.rect.GetWidth();
1991 right_buttons_width += button.rect.GetWidth();
1992 }
1993
1994 offset = 0;
1995
1996 // calculate size of the buttons on the left side
1997 for (i = 0; i < button_count; ++i)
1998 {
1999 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
2000
2001 if (button.location != wxLEFT)
2002 continue;
2003 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
2004 continue;
2005
2006 offset += button.rect.GetWidth();
2007 left_buttons_width += button.rect.GetWidth();
2008 }
2009
2010 offset = left_buttons_width;
2011
2012 if (offset == 0)
2013 offset += m_art->GetIndentSize();
2014
2015 wxRect active_rect;
2016
2017 wxRect rect = m_rect;
2018 rect.y = 0;
2019 rect.height = m_rect.height;
2020
2021 // See if the given page is visible at the given tab offset (effectively scroll position)
2022 for (i = tabOffset; i < page_count; ++i)
2023 {
2024 rect.x = offset;
2025 rect.width = m_rect.width - right_buttons_width - offset - 2;
2026
2027 if (rect.width <= 0)
2028 return false; // haven't found the tab, and we've run out of space, so return false
2029
2030 int x_extent = 0;
2031 offset += x_extent;
2032
2033 if (i == (size_t) tabPage)
2034 {
2035 // If not all of the tab is visible, and supposing there's space to display it all,
2036 // we could do better so we return false.
2037 if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
2038 return false;
2039 else
2040 return true;
2041 }
2042 }
2043
2044 // Shouldn't really get here, but if it does, assume the tab is visible to prevent
2045 // further looping in calling code.
2046 return true;
2047}
2048
2049// Make the tab visible if it wasn't already
2050void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
2051{
2052 wxClientDC dc(win);
2053 if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
2054 {
2055 int i;
2056 for (i = 0; i < (int) m_pages.GetCount(); i++)
2057 {
2058 if (IsTabVisible(tabPage, i, & dc, win))
2059 {
2060 SetTabOffset(i);
2061 win->Refresh();
2062 return;
2063 }
2064 }
2065 }
2066}
2067
2068// TabHitTest() tests if a tab was hit, passing the window pointer
2069// back if that condition was fulfilled. The function returns
2070// true if a tab was hit, otherwise false
2071bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
2072{
2073 if (!m_rect.Contains(x,y))
2074 return false;
2075
2076 wxAuiTabContainerButton* btn = NULL;
2077 if (ButtonHitTest(x, y, &btn) && !(btn->curState & wxAUI_BUTTON_STATE_DISABLED))
2078 {
2079 if (m_buttons.Index(*btn) != wxNOT_FOUND)
2080 return false;
2081 }
2082
2083 size_t i, page_count = m_pages.GetCount();
2084
2085 for (i = m_tabOffset; i < page_count; ++i)
2086 {
2087 wxAuiNotebookPage& page = m_pages.Item(i);
2088 if (page.rect.Contains(x,y))
2089 {
2090 if (hit)
2091 *hit = page.window;
2092 return true;
2093 }
2094 }
2095
2096 return false;
2097}
2098
2099// ButtonHitTest() tests if a button was hit. The function returns
2100// true if a button was hit, otherwise false
2101bool wxAuiTabContainer::ButtonHitTest(int x, int y,
2102 wxAuiTabContainerButton** hit) const
2103{
2104 if (!m_rect.Contains(x,y))
2105 return false;
2106
2107 size_t i, button_count;
2108
2109
2110 button_count = m_buttons.GetCount();
2111 for (i = 0; i < button_count; ++i)
2112 {
2113 wxAuiTabContainerButton& button = m_buttons.Item(i);
2114 if (button.rect.Contains(x,y) &&
2115 !(button.curState & wxAUI_BUTTON_STATE_HIDDEN ))
2116 {
2117 if (hit)
2118 *hit = &button;
2119 return true;
2120 }
2121 }
2122
2123 button_count = m_tabCloseButtons.GetCount();
2124 for (i = 0; i < button_count; ++i)
2125 {
2126 wxAuiTabContainerButton& button = m_tabCloseButtons.Item(i);
2127 if (button.rect.Contains(x,y) &&
2128 !(button.curState & (wxAUI_BUTTON_STATE_HIDDEN |
2129 wxAUI_BUTTON_STATE_DISABLED)))
2130 {
2131 if (hit)
2132 *hit = &button;
2133 return true;
2134 }
2135 }
2136
2137 return false;
2138}
2139
2140
2141
2142// the utility function ShowWnd() is the same as show,
2143// except it handles wxAuiMDIChildFrame windows as well,
2144// as the Show() method on this class is "unplugged"
2145static void ShowWnd(wxWindow* wnd, bool show)
2146{
2147#if wxUSE_MDI
2148 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2149 {
2150 wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
2151 cf->DoShow(show);
2152 }
2153 else
2154#endif
2155 {
2156 wnd->Show(show);
2157 }
2158}
2159
2160
2161// DoShowHide() this function shows the active window, then
2162// hides all of the other windows (in that order)
2163void wxAuiTabContainer::DoShowHide()
2164{
2165 wxAuiNotebookPageArray& pages = GetPages();
2166 size_t i, page_count = pages.GetCount();
2167
2168 // show new active page first
2169 for (i = 0; i < page_count; ++i)
2170 {
2171 wxAuiNotebookPage& page = pages.Item(i);
2172 if (page.active)
2173 {
2174 ShowWnd(page.window, true);
2175 break;
2176 }
2177 }
2178
2179 // hide all other pages
2180 for (i = 0; i < page_count; ++i)
2181 {
2182 wxAuiNotebookPage& page = pages.Item(i);
2183 if (!page.active)
2184 ShowWnd(page.window, false);
2185 }
2186}
2187
2188
2189
2190
2191
2192
2193// -- wxAuiTabCtrl class implementation --
2194
2195
2196
2197BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
2198 EVT_PAINT(wxAuiTabCtrl::OnPaint)
2199 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
2200 EVT_SIZE(wxAuiTabCtrl::OnSize)
2201 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
2202 EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
2203 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
2204 EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
2205 EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
2206 EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
2207 EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
2208 EVT_MOTION(wxAuiTabCtrl::OnMotion)
2209 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
2210 EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
2211 EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
2212 EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
2213 EVT_CHAR(wxAuiTabCtrl::OnChar)
2214 EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
2215END_EVENT_TABLE()
2216
2217
2218wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
2219 wxWindowID id,
2220 const wxPoint& pos,
2221 const wxSize& size,
2222 long style) : wxControl(parent, id, pos, size, style)
2223{
2224 SetName(wxT("wxAuiTabCtrl"));
2225 m_clickPt = wxDefaultPosition;
2226 m_isDragging = false;
2227 m_hoverButton = NULL;
2228 m_pressedButton = NULL;
2229}
2230
2231wxAuiTabCtrl::~wxAuiTabCtrl()
2232{
2233}
2234
2235void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
2236{
2237 wxPaintDC dc(this);
2238
2239 dc.SetFont(GetFont());
2240
2241 if (GetPageCount() > 0)
2242 Render(&dc, this);
2243}
2244
2245void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2246{
2247}
2248
2249void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2250{
2251 wxSize s = evt.GetSize();
2252 wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2253 SetRect(r);
2254}
2255
2256void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2257{
2258 CaptureMouse();
2259 m_clickPt = wxDefaultPosition;
2260 m_isDragging = false;
2261 m_clickTab = NULL;
2262 m_pressedButton = NULL;
2263
2264
2265 wxWindow* wnd;
2266 if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2267 {
2268 int new_selection = GetIdxFromWindow(wnd);
2269
2270 // wxAuiNotebooks always want to receive this event
2271 // even if the tab is already active, because they may
2272 // have multiple tab controls
2273 if (new_selection != GetActivePage() ||
2274 GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
2275 {
2276 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2277 e.SetSelection(new_selection);
2278 e.SetOldSelection(GetActivePage());
2279 e.SetEventObject(this);
2280 GetEventHandler()->ProcessEvent(e);
2281 }
2282
2283 m_clickPt.x = evt.m_x;
2284 m_clickPt.y = evt.m_y;
2285 m_clickTab = wnd;
2286 }
2287
2288 if (m_hoverButton)
2289 {
2290 m_pressedButton = m_hoverButton;
2291 m_pressedButton->curState = wxAUI_BUTTON_STATE_PRESSED;
2292 Refresh();
2293 Update();
2294 }
2295}
2296
2297void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
2298{
2299 if (m_isDragging)
2300 {
2301 m_isDragging = false;
2302
2303 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);
2304 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2305 evt.SetOldSelection(evt.GetSelection());
2306 evt.SetEventObject(this);
2307 GetEventHandler()->ProcessEvent(evt);
2308 }
2309}
2310
2311void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2312{
2313 if (GetCapture() == this)
2314 ReleaseMouse();
2315
2316 if (m_isDragging)
2317 {
2318 m_isDragging = false;
2319
2320 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2321 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2322 evt.SetOldSelection(evt.GetSelection());
2323 evt.SetEventObject(this);
2324 GetEventHandler()->ProcessEvent(evt);
2325
2326 return;
2327 }
2328
2329 if (m_pressedButton)
2330 {
2331 // make sure we're still clicking the button
2332 wxAuiTabContainerButton* button = NULL;
2333 if (!ButtonHitTest(evt.m_x, evt.m_y, &button) ||
2334 button->curState & wxAUI_BUTTON_STATE_DISABLED)
2335 return;
2336
2337 if (button != m_pressedButton)
2338 {
2339 m_pressedButton = NULL;
2340 return;
2341 }
2342
2343 Refresh();
2344 Update();
2345
2346 if (!(m_pressedButton->curState & wxAUI_BUTTON_STATE_DISABLED))
2347 {
2348 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2349 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2350 evt.SetInt(m_pressedButton->id);
2351 evt.SetEventObject(this);
2352 GetEventHandler()->ProcessEvent(evt);
2353 }
2354
2355 m_pressedButton = NULL;
2356 }
2357
2358 m_clickPt = wxDefaultPosition;
2359 m_isDragging = false;
2360 m_clickTab = NULL;
2361}
2362
2363void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
2364{
2365 wxWindow* wnd = NULL;
2366 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2367 return;
2368
2369 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
2370 e.SetEventObject(this);
2371 e.SetSelection(GetIdxFromWindow(wnd));
2372 GetEventHandler()->ProcessEvent(e);
2373}
2374
2375void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
2376{
2377 wxWindow* wnd = NULL;
2378 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2379 return;
2380
2381 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
2382 e.SetEventObject(this);
2383 e.SetSelection(GetIdxFromWindow(wnd));
2384 GetEventHandler()->ProcessEvent(e);
2385}
2386
2387void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
2388{
2389 wxWindow* wnd = NULL;
2390 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2391 return;
2392
2393 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
2394 e.SetEventObject(this);
2395 e.SetSelection(GetIdxFromWindow(wnd));
2396 GetEventHandler()->ProcessEvent(e);
2397}
2398
2399void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
2400{
2401 wxWindow* wnd = NULL;
2402 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2403 return;
2404
2405 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
2406 e.SetEventObject(this);
2407 e.SetSelection(GetIdxFromWindow(wnd));
2408 GetEventHandler()->ProcessEvent(e);
2409}
2410
2411void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
2412{
2413 wxWindow* wnd;
2414 wxAuiTabContainerButton* button;
2415 if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
2416 {
2417 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2418 e.SetEventObject(this);
2419 GetEventHandler()->ProcessEvent(e);
2420 }
2421}
2422
2423void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2424{
2425 wxPoint pos = evt.GetPosition();
2426
2427 // check if the mouse is hovering above a button
2428 wxAuiTabContainerButton* button;
2429 if (ButtonHitTest(pos.x, pos.y, &button) && !(button->curState & wxAUI_BUTTON_STATE_DISABLED))
2430 {
2431 if (m_hoverButton && button != m_hoverButton)
2432 {
2433 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2434 m_hoverButton = NULL;
2435 Refresh();
2436 Update();
2437 }
2438
2439 if (button->curState != wxAUI_BUTTON_STATE_HOVER)
2440 {
2441 button->curState = wxAUI_BUTTON_STATE_HOVER;
2442 Refresh();
2443 Update();
2444 m_hoverButton = button;
2445 return;
2446 }
2447 }
2448 else
2449 {
2450 if (m_hoverButton)
2451 {
2452 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2453 m_hoverButton = NULL;
2454 Refresh();
2455 Update();
2456 }
2457 }
2458
2459
2460 if (!evt.LeftIsDown() || m_clickPt == wxDefaultPosition)
2461 return;
2462
2463 if (m_isDragging)
2464 {
2465 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2466 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2467 evt.SetOldSelection(evt.GetSelection());
2468 evt.SetEventObject(this);
2469 GetEventHandler()->ProcessEvent(evt);
2470 return;
2471 }
2472
2473
2474 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2475 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2476
2477 if (abs(pos.x - m_clickPt.x) > drag_x_threshold ||
2478 abs(pos.y - m_clickPt.y) > drag_y_threshold)
2479 {
2480 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2481 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2482 evt.SetOldSelection(evt.GetSelection());
2483 evt.SetEventObject(this);
2484 GetEventHandler()->ProcessEvent(evt);
2485
2486 m_isDragging = true;
2487 }
2488}
2489
2490void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2491{
2492 if (m_hoverButton)
2493 {
2494 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2495 m_hoverButton = NULL;
2496 Refresh();
2497 Update();
2498 }
2499}
2500
2501void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2502{
2503 int button = event.GetInt();
2504
2505 if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2506 {
2507 if (button == wxAUI_BUTTON_LEFT)
2508 {
2509 if (GetTabOffset() > 0)
2510 {
2511 SetTabOffset(GetTabOffset()-1);
2512 Refresh();
2513 Update();
2514 }
2515 }
2516 else
2517 {
2518 SetTabOffset(GetTabOffset()+1);
2519 Refresh();
2520 Update();
2521 }
2522 }
2523 else if (button == wxAUI_BUTTON_WINDOWLIST)
2524 {
2525 int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
2526
2527 if (idx != -1)
2528 {
2529 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2530 e.SetSelection(idx);
2531 e.SetOldSelection(GetActivePage());
2532 e.SetEventObject(this);
2533 GetEventHandler()->ProcessEvent(e);
2534 }
2535 }
2536 else
2537 {
2538 event.Skip();
2539 }
2540}
2541
2542void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2543{
2544 Refresh();
2545}
2546
2547void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
2548{
2549 Refresh();
2550}
2551
2552void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
2553{
2554 if (GetActivePage() == -1)
2555 {
2556 event.Skip();
2557 return;
2558 }
2559
2560 // We can't leave tab processing to the system; on Windows, tabs and keys
2561 // get eaten by the system and not processed properly if we specify both
2562 // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
2563 // we don't key arrow key events.
2564
2565 int key = event.GetKeyCode();
2566
2567 if (key == WXK_NUMPAD_PAGEUP)
2568 key = WXK_PAGEUP;
2569 if (key == WXK_NUMPAD_PAGEDOWN)
2570 key = WXK_PAGEDOWN;
2571 if (key == WXK_NUMPAD_HOME)
2572 key = WXK_HOME;
2573 if (key == WXK_NUMPAD_END)
2574 key = WXK_END;
2575 if (key == WXK_NUMPAD_LEFT)
2576 key = WXK_LEFT;
2577 if (key == WXK_NUMPAD_RIGHT)
2578 key = WXK_RIGHT;
2579
2580 if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
2581 {
2582 bool bCtrlDown = event.ControlDown();
2583 bool bShiftDown = event.ShiftDown();
2584
2585 bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
2586 bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
2587 bool bFromTab = (key == WXK_TAB);
2588
2589 wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
2590 if (!nb)
2591 {
2592 event.Skip();
2593 return;
2594 }
2595
2596 wxNavigationKeyEvent keyEvent;
2597 keyEvent.SetDirection(bForward);
2598 keyEvent.SetWindowChange(bWindowChange);
2599 keyEvent.SetFromTab(bFromTab);
2600 keyEvent.SetEventObject(nb);
2601
2602 if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
2603 {
2604 // Not processed? Do an explicit tab into the page.
2605 wxWindow* win = GetWindowFromIdx(GetActivePage());
2606 if (win)
2607 win->SetFocus();
2608 }
2609 return;
2610 }
2611
2612 if (m_pages.GetCount() < 2)
2613 {
2614 event.Skip();
2615 return;
2616 }
2617
2618 int newPage = -1;
2619
2620 int forwardKey, backwardKey;
2621 if (GetLayoutDirection() == wxLayout_RightToLeft)
2622 {
2623 forwardKey = WXK_LEFT;
2624 backwardKey = WXK_RIGHT;
2625 }
2626 else
2627 {
2628 forwardKey = WXK_RIGHT;
2629 backwardKey = WXK_LEFT;
2630 }
2631
2632 if (key == forwardKey)
2633 {
2634 if (m_pages.GetCount() > 1)
2635 {
2636 if (GetActivePage() == -1)
2637 newPage = 0;
2638 else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
2639 newPage = GetActivePage() + 1;
2640 }
2641 }
2642 else if (key == backwardKey)
2643 {
2644 if (m_pages.GetCount() > 1)
2645 {
2646 if (GetActivePage() == -1)
2647 newPage = (int) (m_pages.GetCount() - 1);
2648 else if (GetActivePage() > 0)
2649 newPage = GetActivePage() - 1;
2650 }
2651 }
2652 else if (key == WXK_HOME)
2653 {
2654 newPage = 0;
2655 }
2656 else if (key == WXK_END)
2657 {
2658 newPage = (int) (m_pages.GetCount() - 1);
2659 }
2660 else
2661 event.Skip();
2662
2663 if (newPage != -1)
2664 {
2665 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2666 e.SetSelection(newPage);
2667 e.SetOldSelection(newPage);
2668 e.SetEventObject(this);
2669 this->GetEventHandler()->ProcessEvent(e);
2670 }
2671 else
2672 event.Skip();
2673}
2674
2675// wxTabFrame is an interesting case. It's important that all child pages
2676// of the multi-notebook control are all actually children of that control
2677// (and not grandchildren). wxTabFrame facilitates this. There is one
2678// instance of wxTabFrame for each tab control inside the multi-notebook.
2679// It's important to know that wxTabFrame is not a real window, but it merely
2680// used to capture the dimensions/positioning of the internal tab control and
2681// it's managed page windows
2682
2683class wxTabFrame : public wxWindow
2684{
2685public:
2686
2687 wxTabFrame()
2688 {
2689 m_tabs = NULL;
2690 m_rect = wxRect(0,0,200,200);
2691 m_tabCtrlHeight = 20;
2692 }
2693
2694 ~wxTabFrame()
2695 {
2696 wxDELETE(m_tabs);
2697 }
2698
2699 void SetTabCtrlHeight(int h)
2700 {
2701 m_tabCtrlHeight = h;
2702 }
2703
2704protected:
2705 void DoSetSize(int x, int y,
2706 int width, int height,
2707 int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2708 {
2709 m_rect = wxRect(x, y, width, height);
2710 DoSizing();
2711 }
2712
2713 void DoGetClientSize(int* x, int* y) const
2714 {
2715 *x = m_rect.width;
2716 *y = m_rect.height;
2717 }
2718
2719public:
2720 bool Show( bool WXUNUSED(show = true) ) { return false; }
2721
2722 void DoSizing()
2723 {
2724 if (!m_tabs)
2725 return;
2726
2727 if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
2728 return;
2729
2730 m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2731 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2732 {
2733 m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
2734 m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
2735 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
2736 }
2737 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2738 {
2739 m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2740 m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2741 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
2742 }
2743 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2744 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2745
2746 m_tabs->Refresh();
2747 m_tabs->Update();
2748
2749 wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2750 size_t i, page_count = pages.GetCount();
2751
2752 for (i = 0; i < page_count; ++i)
2753 {
2754 int height = m_rect.height - m_tabCtrlHeight;
2755 if ( height < 0 )
2756 {
2757 // avoid passing negative height to wxWindow::SetSize(), this
2758 // results in assert failures/GTK+ warnings
2759 height = 0;
2760 }
2761
2762 wxAuiNotebookPage& page = pages.Item(i);
2763 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2764 {
2765 page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
2766 }
2767 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2768 {
2769 page.window->SetSize(m_rect.x, m_rect.y + m_tabCtrlHeight,
2770 m_rect.width, height);
2771 }
2772 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2773 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2774
2775#if wxUSE_MDI
2776 if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2777 {
2778 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2779 wnd->ApplyMDIChildFrameRect();
2780 }
2781#endif
2782 }
2783 }
2784
2785protected:
2786 void DoGetSize(int* x, int* y) const
2787 {
2788 if (x)
2789 *x = m_rect.GetWidth();
2790 if (y)
2791 *y = m_rect.GetHeight();
2792 }
2793
2794public:
2795 void Update()
2796 {
2797 // does nothing
2798 }
2799
2800 wxRect m_rect;
2801 wxRect m_tab_rect;
2802 wxAuiTabCtrl* m_tabs;
2803 int m_tabCtrlHeight;
2804};
2805
2806
2807const int wxAuiBaseTabCtrlId = 5380;
2808
2809
2810// -- wxAuiNotebook class implementation --
2811
2812#define EVT_AUI_RANGE(id1, id2, event, func) \
2813 wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
2814
2815BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2816 EVT_SIZE(wxAuiNotebook::OnSize)
2817 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
2818 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2819 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2820 wxAuiNotebook::OnTabClicked)
2821 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2822 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2823 wxAuiNotebook::OnTabBeginDrag)
2824 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2825 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2826 wxAuiNotebook::OnTabEndDrag)
2827 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2828 wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG,
2829 wxAuiNotebook::OnTabCancelDrag)
2830 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2831 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2832 wxAuiNotebook::OnTabDragMotion)
2833 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2834 wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2835 wxAuiNotebook::OnTabButton)
2836 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2837 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
2838 wxAuiNotebook::OnTabMiddleDown)
2839 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2840 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
2841 wxAuiNotebook::OnTabMiddleUp)
2842 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2843 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
2844 wxAuiNotebook::OnTabRightDown)
2845 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2846 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
2847 wxAuiNotebook::OnTabRightUp)
2848 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2849 wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
2850 wxAuiNotebook::OnTabBgDClick)
2851 EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
2852END_EVENT_TABLE()
2853
2854void wxAuiNotebook::Init()
2855{
2856 m_curPage = -1;
2857 m_tabIdCounter = wxAuiBaseTabCtrlId;
2858 m_dummyWnd = NULL;
2859 m_tabCtrlHeight = 20;
2860 m_requestedBmpSize = wxDefaultSize;
2861 m_requestedTabCtrlHeight = -1;
2862}
2863
2864bool wxAuiNotebook::Create(wxWindow* parent,
2865 wxWindowID id,
2866 const wxPoint& pos,
2867 const wxSize& size,
2868 long style)
2869{
2870 if (!wxControl::Create(parent, id, pos, size, style))
2871 return false;
2872
2873 InitNotebook(style);
2874
2875 return true;
2876}
2877
2878// InitNotebook() contains common initialization
2879// code called by all constructors
2880void wxAuiNotebook::InitNotebook(long style)
2881{
2882 SetName(wxT("wxAuiNotebook"));
2883 m_curPage = -1;
2884 m_tabIdCounter = wxAuiBaseTabCtrlId;
2885 m_dummyWnd = NULL;
2886 m_flags = (unsigned int)style;
2887 m_tabCtrlHeight = 20;
2888
2889 m_normalFont = *wxNORMAL_FONT;
2890 m_selectedFont = *wxNORMAL_FONT;
2891 m_selectedFont.SetWeight(wxBOLD);
2892
2893 SetArtProvider(new wxAuiDefaultTabArt);
2894
2895 m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2896 m_dummyWnd->SetSize(200, 200);
2897 m_dummyWnd->Show(false);
2898
2899 m_mgr.SetManagedWindow(this);
2900 m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
2901 m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
2902
2903 m_mgr.AddPane(m_dummyWnd,
2904 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2905
2906 m_mgr.Update();
2907}
2908
2909wxAuiNotebook::~wxAuiNotebook()
2910{
2911 // Indicate we're deleting pages
2912 SendDestroyEvent();
2913
2914 while ( GetPageCount() > 0 )
2915 DeletePage(0);
2916
2917 m_mgr.UnInit();
2918}
2919
2920void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2921{
2922 m_tabs.SetArtProvider(art);
2923
2924 // Update the height and do nothing else if it did something but otherwise
2925 // (i.e. if the new art provider uses the same height as the old one) we
2926 // need to manually set the art provider for all tabs ourselves.
2927 if ( !UpdateTabCtrlHeight() )
2928 {
2929 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2930 const size_t pane_count = all_panes.GetCount();
2931 for (size_t i = 0; i < pane_count; ++i)
2932 {
2933 wxAuiPaneInfo& pane = all_panes.Item(i);
2934 if (pane.name == wxT("dummy"))
2935 continue;
2936 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2937 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2938 tabctrl->SetArtProvider(art->Clone());
2939 }
2940 }
2941}
2942
2943// SetTabCtrlHeight() is the highest-level override of the
2944// tab height. A call to this function effectively enforces a
2945// specified tab ctrl height, overriding all other considerations,
2946// such as text or bitmap height. It overrides any call to
2947// SetUniformBitmapSize(). Specifying a height of -1 reverts
2948// any previous call and returns to the default behaviour
2949
2950void wxAuiNotebook::SetTabCtrlHeight(int height)
2951{
2952 m_requestedTabCtrlHeight = height;
2953
2954 // if window is already initialized, recalculate the tab height
2955 if (m_dummyWnd)
2956 {
2957 UpdateTabCtrlHeight();
2958 }
2959}
2960
2961
2962// SetUniformBitmapSize() ensures that all tabs will have
2963// the same height, even if some tabs don't have bitmaps
2964// Passing wxDefaultSize to this function will instruct
2965// the control to use dynamic tab height-- so when a tab
2966// with a large bitmap is added, the tab ctrl's height will
2967// automatically increase to accommodate the bitmap
2968
2969void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2970{
2971 m_requestedBmpSize = size;
2972
2973 // if window is already initialized, recalculate the tab height
2974 if (m_dummyWnd)
2975 {
2976 UpdateTabCtrlHeight();
2977 }
2978}
2979
2980// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2981// to be used internally
2982bool wxAuiNotebook::UpdateTabCtrlHeight()
2983{
2984 // get the tab ctrl height we will use
2985 int height = CalculateTabCtrlHeight();
2986
2987 // if the tab control height needs to change, update
2988 // all of our tab controls with the new height
2989 if (m_tabCtrlHeight == height)
2990 return false;
2991
2992 wxAuiTabArt* art = m_tabs.GetArtProvider();
2993
2994 m_tabCtrlHeight = height;
2995
2996 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2997 size_t i, pane_count = all_panes.GetCount();
2998 for (i = 0; i < pane_count; ++i)
2999 {
3000 wxAuiPaneInfo& pane = all_panes.Item(i);
3001 if (pane.name == wxT("dummy"))
3002 continue;
3003 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
3004 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
3005 tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);
3006 tabctrl->SetArtProvider(art->Clone());
3007 tab_frame->DoSizing();
3008 }
3009
3010 return true;
3011}
3012
3013void wxAuiNotebook::UpdateHintWindowSize()
3014{
3015 wxSize size = CalculateNewSplitSize();
3016
3017 // the placeholder hint window should be set to this size
3018 wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
3019 if (info.IsOk())
3020 {
3021 info.MinSize(size);
3022 info.BestSize(size);
3023 m_dummyWnd->SetSize(size);
3024 }
3025}
3026
3027
3028// calculates the size of the new split
3029wxSize wxAuiNotebook::CalculateNewSplitSize()
3030{
3031 // count number of tab controls
3032 int tab_ctrl_count = 0;
3033 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3034 size_t i, pane_count = all_panes.GetCount();
3035 for (i = 0; i < pane_count; ++i)
3036 {
3037 wxAuiPaneInfo& pane = all_panes.Item(i);
3038 if (pane.name == wxT("dummy"))
3039 continue;
3040 tab_ctrl_count++;
3041 }
3042
3043 wxSize new_split_size;
3044
3045 // if there is only one tab control, the first split
3046 // should happen around the middle
3047 if (tab_ctrl_count < 2)
3048 {
3049 new_split_size = GetClientSize();
3050 new_split_size.x /= 2;
3051 new_split_size.y /= 2;
3052 }
3053 else
3054 {
3055 // this is in place of a more complicated calculation
3056 // that needs to be implemented
3057 new_split_size = wxSize(180,180);
3058 }
3059
3060 return new_split_size;
3061}
3062
3063int wxAuiNotebook::CalculateTabCtrlHeight()
3064{
3065 // if a fixed tab ctrl height is specified,
3066 // just return that instead of calculating a
3067 // tab height
3068 if (m_requestedTabCtrlHeight != -1)
3069 return m_requestedTabCtrlHeight;
3070
3071 // find out new best tab height
3072 wxAuiTabArt* art = m_tabs.GetArtProvider();
3073
3074 return art->GetBestTabCtrlSize(this,
3075 m_tabs.GetPages(),
3076 m_requestedBmpSize);
3077}
3078
3079
3080wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
3081{
3082 return m_tabs.GetArtProvider();
3083}
3084
3085void wxAuiNotebook::SetWindowStyleFlag(long style)
3086{
3087 wxControl::SetWindowStyleFlag(style);
3088
3089 m_flags = (unsigned int)style;
3090
3091 // if the control is already initialized
3092 if (m_mgr.GetManagedWindow() == (wxWindow*)this)
3093 {
3094 // let all of the tab children know about the new style
3095
3096 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3097 size_t i, pane_count = all_panes.GetCount();
3098 for (i = 0; i < pane_count; ++i)
3099 {
3100 wxAuiPaneInfo& pane = all_panes.Item(i);
3101 if (pane.name == wxT("dummy"))
3102 continue;
3103 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
3104 wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
3105 tabctrl->SetFlags(m_flags);
3106 tabframe->DoSizing();
3107 tabctrl->Refresh();
3108 tabctrl->Update();
3109 }
3110 }
3111}
3112
3113
3114bool wxAuiNotebook::AddPage(wxWindow* page,
3115 const wxString& caption,
3116 bool select,
3117 const wxBitmap& bitmap)
3118{
3119 return InsertPage(GetPageCount(), page, caption, select, bitmap);
3120}
3121
3122bool wxAuiNotebook::InsertPage(size_t page_idx,
3123 wxWindow* page,
3124 const wxString& caption,
3125 bool select,
3126 const wxBitmap& bitmap)
3127{
3128 wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
3129 if (!page)
3130 return false;
3131
3132 page->Reparent(this);
3133
3134 wxAuiNotebookPage info;
3135 info.window = page;
3136 info.caption = caption;
3137 info.bitmap = bitmap;
3138 info.active = false;
3139
3140 // if there are currently no tabs, the first added
3141 // tab must be active
3142 if (m_tabs.GetPageCount() == 0)
3143 info.active = true;
3144
3145 m_tabs.InsertPage(page, info, page_idx);
3146
3147 // if that was the first page added, even if
3148 // select is false, it must become the "current page"
3149 // (though no select events will be fired)
3150 if (!select && m_tabs.GetPageCount() == 1)
3151 select = true;
3152 //m_curPage = GetPageIndex(page);
3153
3154 wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3155 if (page_idx >= active_tabctrl->GetPageCount())
3156 active_tabctrl->AddPage(page, info);
3157 else
3158 active_tabctrl->InsertPage(page, info, page_idx);
3159
3160 UpdateTabCtrlHeight();
3161 DoSizing();
3162 active_tabctrl->DoShowHide();
3163
3164 // adjust selected index
3165 if(m_curPage >= (int) page_idx)
3166 m_curPage++;
3167
3168 if (select)
3169 {
3170 SetSelectionToWindow(page);
3171 }
3172
3173 return true;
3174}
3175
3176
3177// DeletePage() removes a tab from the multi-notebook,
3178// and destroys the window as well
3179bool wxAuiNotebook::DeletePage(size_t page_idx)
3180{
3181 if (page_idx >= m_tabs.GetPageCount())
3182 return false;
3183
3184 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3185
3186 // hide the window in advance, as this will
3187 // prevent flicker
3188 ShowWnd(wnd, false);
3189
3190 if (!RemovePage(page_idx))
3191 return false;
3192
3193#if wxUSE_MDI
3194 // actually destroy the window now
3195 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3196 {
3197 // delete the child frame with pending delete, as is
3198 // customary with frame windows
3199 if (!wxPendingDelete.Member(wnd))
3200 wxPendingDelete.Append(wnd);
3201 }
3202 else
3203#endif
3204 {
3205 wnd->Destroy();
3206 }
3207
3208 return true;
3209}
3210
3211
3212
3213// RemovePage() removes a tab from the multi-notebook,
3214// but does not destroy the window
3215bool wxAuiNotebook::RemovePage(size_t page_idx)
3216{
3217 // save active window pointer
3218 wxWindow* active_wnd = NULL;
3219 if (m_curPage >= 0)
3220 active_wnd = m_tabs.GetWindowFromIdx(m_curPage);
3221
3222 // save pointer of window being deleted
3223 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3224 wxWindow* new_active = NULL;
3225
3226 // make sure we found the page
3227 if (!wnd)
3228 return false;
3229
3230 // find out which onscreen tab ctrl owns this tab
3231 wxAuiTabCtrl* ctrl;
3232 int ctrl_idx;
3233 if (!FindTab(wnd, &ctrl, &ctrl_idx))
3234 return false;
3235
3236 bool is_curpage = (m_curPage == (int)page_idx);
3237 bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3238
3239
3240 // remove the tab from main catalog
3241 if (!m_tabs.RemovePage(wnd))
3242 return false;
3243
3244 // remove the tab from the onscreen tab ctrl
3245 ctrl->RemovePage(wnd);
3246
3247 if (is_active_in_split)
3248 {
3249 int ctrl_new_page_count = (int)ctrl->GetPageCount();
3250
3251 if (ctrl_idx >= ctrl_new_page_count)
3252 ctrl_idx = ctrl_new_page_count-1;
3253
3254 if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3255 {
3256 // set new page as active in the tab split
3257 ctrl->SetActivePage(ctrl_idx);
3258
3259 // if the page deleted was the current page for the
3260 // entire tab control, then record the window
3261 // pointer of the new active page for activation
3262 if (is_curpage)
3263 {
3264 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3265 }
3266 }
3267 }
3268 else
3269 {
3270 // we are not deleting the active page, so keep it the same
3271 new_active = active_wnd;
3272 }
3273
3274
3275 if (!new_active)
3276 {
3277 // we haven't yet found a new page to active,
3278 // so select the next page from the main tab
3279 // catalogue
3280
3281 if (page_idx < m_tabs.GetPageCount())
3282 {
3283 new_active = m_tabs.GetPage(page_idx).window;
3284 }
3285
3286 if (!new_active && m_tabs.GetPageCount() > 0)
3287 {
3288 new_active = m_tabs.GetPage(0).window;
3289 }
3290 }
3291
3292
3293 RemoveEmptyTabFrames();
3294
3295 m_curPage = wxNOT_FOUND;
3296
3297 // set new active pane unless we're being destroyed anyhow
3298 if (new_active && !m_isBeingDeleted)
3299 SetSelectionToWindow(new_active);
3300
3301 return true;
3302}
3303
3304// GetPageIndex() returns the index of the page, or -1 if the
3305// page could not be located in the notebook
3306int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3307{
3308 return m_tabs.GetIdxFromWindow(page_wnd);
3309}
3310
3311
3312
3313// SetPageText() changes the tab caption of the specified page
3314bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3315{
3316 if (page_idx >= m_tabs.GetPageCount())
3317 return false;
3318
3319 // update our own tab catalog
3320 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3321 page_info.caption = text;
3322
3323 // update what's on screen
3324 wxAuiTabCtrl* ctrl;
3325 int ctrl_idx;
3326 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3327 {
3328 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3329 info.caption = text;
3330 ctrl->Refresh();
3331 ctrl->Update();
3332 }
3333
3334 return true;
3335}
3336
3337// returns the page caption
3338wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3339{
3340 if (page_idx >= m_tabs.GetPageCount())
3341 return wxEmptyString;
3342
3343 // update our own tab catalog
3344 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3345 return page_info.caption;
3346}
3347
3348bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3349{
3350 if (page_idx >= m_tabs.GetPageCount())
3351 return false;
3352
3353 // update our own tab catalog
3354 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3355 page_info.bitmap = bitmap;
3356
3357 // tab height might have changed
3358 UpdateTabCtrlHeight();
3359
3360 // update what's on screen
3361 wxAuiTabCtrl* ctrl;
3362 int ctrl_idx;
3363 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3364 {
3365 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3366 info.bitmap = bitmap;
3367 ctrl->Refresh();
3368 ctrl->Update();
3369 }
3370
3371 return true;
3372}
3373
3374// returns the page bitmap
3375wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3376{
3377 if (page_idx >= m_tabs.GetPageCount())
3378 return wxBitmap();
3379
3380 // update our own tab catalog
3381 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3382 return page_info.bitmap;
3383}
3384
3385// GetSelection() returns the index of the currently active page
3386int wxAuiNotebook::GetSelection() const
3387{
3388 return m_curPage;
3389}
3390
3391// SetSelection() sets the currently active page
3392int wxAuiNotebook::SetSelection(size_t new_page)
3393{
3394 return DoModifySelection(new_page, true);
3395}
3396
3397void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3398{
3399 const int idx = m_tabs.GetIdxFromWindow(win);
3400 wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
3401
3402
3403 // since a tab was clicked, let the parent know that we received
3404 // the focus, even if we will assign that focus immediately
3405 // to the child tab in the SetSelection call below
3406 // (the child focus event will also let wxAuiManager, if any,
3407 // know that the notebook control has been activated)
3408
3409 wxWindow* parent = GetParent();
3410 if (parent)
3411 {
3412 wxChildFocusEvent eventFocus(this);
3413 parent->GetEventHandler()->ProcessEvent(eventFocus);
3414 }
3415
3416
3417 SetSelection(idx);
3418}
3419
3420// GetPageCount() returns the total number of
3421// pages managed by the multi-notebook
3422size_t wxAuiNotebook::GetPageCount() const
3423{
3424 return m_tabs.GetPageCount();
3425}
3426
3427// GetPage() returns the wxWindow pointer of the
3428// specified page
3429wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3430{
3431 wxASSERT(page_idx < m_tabs.GetPageCount());
3432
3433 return m_tabs.GetWindowFromIdx(page_idx);
3434}
3435
3436// DoSizing() performs all sizing operations in each tab control
3437void wxAuiNotebook::DoSizing()
3438{
3439 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3440 size_t i, pane_count = all_panes.GetCount();
3441 for (i = 0; i < pane_count; ++i)
3442 {
3443 if (all_panes.Item(i).name == wxT("dummy"))
3444 continue;
3445
3446 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3447 tabframe->DoSizing();
3448 }
3449}
3450
3451// GetActiveTabCtrl() returns the active tab control. It is
3452// called to determine which control gets new windows being added
3453wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3454{
3455 if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())
3456 {
3457 wxAuiTabCtrl* ctrl;
3458 int idx;
3459
3460 // find the tab ctrl with the current page
3461 if (FindTab(m_tabs.GetPage(m_curPage).window,
3462 &ctrl, &idx))
3463 {
3464 return ctrl;
3465 }
3466 }
3467
3468 // no current page, just find the first tab ctrl
3469 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3470 size_t i, pane_count = all_panes.GetCount();
3471 for (i = 0; i < pane_count; ++i)
3472 {
3473 if (all_panes.Item(i).name == wxT("dummy"))
3474 continue;
3475
3476 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3477 return tabframe->m_tabs;
3478 }
3479
3480 // If there is no tabframe at all, create one
3481 wxTabFrame* tabframe = new wxTabFrame;
3482 tabframe->SetTabCtrlHeight(m_tabCtrlHeight);
3483 tabframe->m_tabs = new wxAuiTabCtrl(this,
3484 m_tabIdCounter++,
3485 wxDefaultPosition,
3486 wxDefaultSize,
3487 wxNO_BORDER|wxWANTS_CHARS);
3488 tabframe->m_tabs->SetFlags(m_flags);
3489 tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3490 m_mgr.AddPane(tabframe,
3491 wxAuiPaneInfo().Center().CaptionVisible(false));
3492
3493 m_mgr.Update();
3494
3495 return tabframe->m_tabs;
3496}
3497
3498// FindTab() finds the tab control that currently contains the window as well
3499// as the index of the window in the tab control. It returns true if the
3500// window was found, otherwise false.
3501bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3502{
3503 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3504 size_t i, pane_count = all_panes.GetCount();
3505 for (i = 0; i < pane_count; ++i)
3506 {
3507 if (all_panes.Item(i).name == wxT("dummy"))
3508 continue;
3509
3510 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3511
3512 int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3513 if (page_idx != -1)
3514 {
3515 *ctrl = tabframe->m_tabs;
3516 *idx = page_idx;
3517 return true;
3518 }
3519 }
3520
3521 return false;
3522}
3523
3524void wxAuiNotebook::Split(size_t page, int direction)
3525{
3526 wxSize cli_size = GetClientSize();
3527
3528 // get the page's window pointer
3529 wxWindow* wnd = GetPage(page);
3530 if (!wnd)
3531 return;
3532
3533 // notebooks with 1 or less pages can't be split
3534 if (GetPageCount() < 2)
3535 return;
3536
3537 // find out which tab control the page currently belongs to
3538 wxAuiTabCtrl *src_tabs, *dest_tabs;
3539 int src_idx = -1;
3540 src_tabs = NULL;
3541 if (!FindTab(wnd, &src_tabs, &src_idx))
3542 return;
3543 if (!src_tabs || src_idx == -1)
3544 return;
3545
3546 // choose a split size
3547 wxSize split_size;
3548 if (GetPageCount() > 2)
3549 {
3550 split_size = CalculateNewSplitSize();
3551 }
3552 else
3553 {
3554 // because there are two panes, always split them
3555 // equally
3556 split_size = GetClientSize();
3557 split_size.x /= 2;
3558 split_size.y /= 2;
3559 }
3560
3561
3562 // create a new tab frame
3563 wxTabFrame* new_tabs = new wxTabFrame;
3564 new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3565 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
3566 new_tabs->m_tabs = new wxAuiTabCtrl(this,
3567 m_tabIdCounter++,
3568 wxDefaultPosition,
3569 wxDefaultSize,
3570 wxNO_BORDER|wxWANTS_CHARS);
3571 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3572 new_tabs->m_tabs->SetFlags(m_flags);
3573 dest_tabs = new_tabs->m_tabs;
3574
3575 // create a pane info structure with the information
3576 // about where the pane should be added
3577 wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3578 wxPoint mouse_pt;
3579
3580 if (direction == wxLEFT)
3581 {
3582 paneInfo.Left();
3583 mouse_pt = wxPoint(0, cli_size.y/2);
3584 }
3585 else if (direction == wxRIGHT)
3586 {
3587 paneInfo.Right();
3588 mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3589 }
3590 else if (direction == wxTOP)
3591 {
3592 paneInfo.Top();
3593 mouse_pt = wxPoint(cli_size.x/2, 0);
3594 }
3595 else if (direction == wxBOTTOM)
3596 {
3597 paneInfo.Bottom();
3598 mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3599 }
3600
3601 m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);
3602 m_mgr.Update();
3603
3604 // remove the page from the source tabs
3605 wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3606 page_info.active = false;
3607 src_tabs->RemovePage(page_info.window);
3608 if (src_tabs->GetPageCount() > 0)
3609 {
3610 src_tabs->SetActivePage((size_t)0);
3611 src_tabs->DoShowHide();
3612 src_tabs->Refresh();
3613 }
3614
3615
3616 // add the page to the destination tabs
3617 dest_tabs->InsertPage(page_info.window, page_info, 0);
3618
3619 if (src_tabs->GetPageCount() == 0)
3620 {
3621 RemoveEmptyTabFrames();
3622 }
3623
3624 DoSizing();
3625 dest_tabs->DoShowHide();
3626 dest_tabs->Refresh();
3627
3628 // force the set selection function reset the selection
3629 m_curPage = -1;
3630
3631 // set the active page to the one we just split off
3632 SetSelectionToPage(page_info);
3633
3634 UpdateHintWindowSize();
3635}
3636
3637
3638void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3639{
3640 UpdateHintWindowSize();
3641
3642 evt.Skip();
3643}
3644
3645void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
3646{
3647 wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3648 wxASSERT(ctrl != NULL);
3649
3650 wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3651 wxASSERT(wnd != NULL);
3652
3653 SetSelectionToWindow(wnd);
3654}
3655
3656void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
3657{
3658 // notify owner that the tabbar background has been double-clicked
3659 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
3660 e.SetEventObject(this);
3661 GetEventHandler()->ProcessEvent(e);
3662}
3663
3664void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
3665{
3666 m_lastDragX = 0;
3667}
3668
3669void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
3670{
3671 wxPoint screen_pt = ::wxGetMousePosition();
3672 wxPoint client_pt = ScreenToClient(screen_pt);
3673 wxPoint zero(0,0);
3674
3675 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3676 wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3677
3678 if (dest_tabs == src_tabs)
3679 {
3680 if (src_tabs)
3681 {
3682 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3683 }
3684
3685 // always hide the hint for inner-tabctrl drag
3686 m_mgr.HideHint();
3687
3688 // if tab moving is not allowed, leave
3689 if (!(m_flags & wxAUI_NB_TAB_MOVE))
3690 {
3691 return;
3692 }
3693
3694 wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3695 wxWindow* dest_location_tab;
3696
3697 // this is an inner-tab drag/reposition
3698 if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3699 {
3700 int src_idx = evt.GetSelection();
3701 int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3702
3703 // prevent jumpy drag
3704 if ((src_idx == dest_idx) || dest_idx == -1 ||
3705 (src_idx > dest_idx && m_lastDragX <= pt.x) ||
3706 (src_idx < dest_idx && m_lastDragX >= pt.x))
3707 {
3708 m_lastDragX = pt.x;
3709 return;
3710 }
3711
3712
3713 wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3714 dest_tabs->MovePage(src_tab, dest_idx);
3715 dest_tabs->SetActivePage((size_t)dest_idx);
3716 dest_tabs->DoShowHide();
3717 dest_tabs->Refresh();
3718 m_lastDragX = pt.x;
3719
3720 }
3721
3722 return;
3723 }
3724
3725
3726 // if external drag is allowed, check if the tab is being dragged
3727 // over a different wxAuiNotebook control
3728 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3729 {
3730 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3731
3732 // if we aren't over any window, stop here
3733 if (!tab_ctrl)
3734 return;
3735
3736 // make sure we are not over the hint window
3737 if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3738 {
3739 while (tab_ctrl)
3740 {
3741 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3742 break;
3743 tab_ctrl = tab_ctrl->GetParent();
3744 }
3745
3746 if (tab_ctrl)
3747 {
3748 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3749
3750 if (nb != this)
3751 {
3752 wxRect hint_rect = tab_ctrl->GetClientRect();
3753 tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3754 m_mgr.ShowHint(hint_rect);
3755 return;
3756 }
3757 }
3758 }
3759 else
3760 {
3761 if (!dest_tabs)
3762 {
3763 // we are either over a hint window, or not over a tab
3764 // window, and there is no where to drag to, so exit
3765 return;
3766 }
3767 }
3768 }
3769
3770
3771 // if there are less than two panes, split can't happen, so leave
3772 if (m_tabs.GetPageCount() < 2)
3773 return;
3774
3775 // if tab moving is not allowed, leave
3776 if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3777 return;
3778
3779
3780 if (src_tabs)
3781 {
3782 src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3783 }
3784
3785
3786 if (dest_tabs)
3787 {
3788 wxRect hint_rect = dest_tabs->GetRect();
3789 ClientToScreen(&hint_rect.x, &hint_rect.y);
3790 m_mgr.ShowHint(hint_rect);
3791 }
3792 else
3793 {
3794 m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);
3795 }
3796}
3797
3798
3799
3800void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
3801{
3802 m_mgr.HideHint();
3803
3804
3805 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3806 wxCHECK_RET( src_tabs, wxT("no source object?") );
3807
3808 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3809
3810 // get the mouse position, which will be used to determine the drop point
3811 wxPoint mouse_screen_pt = ::wxGetMousePosition();
3812 wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3813
3814
3815
3816 // check for an external move
3817 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3818 {
3819 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3820
3821 while (tab_ctrl)
3822 {
3823 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3824 break;
3825 tab_ctrl = tab_ctrl->GetParent();
3826 }
3827
3828 if (tab_ctrl)
3829 {
3830 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3831
3832 if (nb != this)
3833 {
3834 // find out from the destination control
3835 // if it's ok to drop this tab here
3836 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3837 e.SetSelection(evt.GetSelection());
3838 e.SetOldSelection(evt.GetSelection());
3839 e.SetEventObject(this);
3840 e.SetDragSource(this);
3841 e.Veto(); // dropping must be explicitly approved by control owner
3842
3843 nb->GetEventHandler()->ProcessEvent(e);
3844
3845 if (!e.IsAllowed())
3846 {
3847 // no answer or negative answer
3848 m_mgr.HideHint();
3849 return;
3850 }
3851
3852 // drop was allowed
3853 int src_idx = evt.GetSelection();
3854 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3855
3856 // Check that it's not an impossible parent relationship
3857 wxWindow* p = nb;
3858 while (p && !p->IsTopLevel())
3859 {
3860 if (p == src_page)
3861 {
3862 return;
3863 }
3864 p = p->GetParent();
3865 }
3866
3867 // get main index of the page
3868 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3869 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
3870
3871
3872 // make a copy of the page info
3873 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3874
3875 // remove the page from the source notebook
3876 RemovePage(main_idx);
3877
3878 // reparent the page
3879 src_page->Reparent(nb);
3880
3881
3882 // found out the insert idx
3883 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3884 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3885
3886 wxWindow* target = NULL;
3887 int insert_idx = -1;
3888 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3889 if (target)
3890 {
3891 insert_idx = dest_tabs->GetIdxFromWindow(target);
3892 }
3893
3894
3895 // add the page to the new notebook
3896 if (insert_idx == -1)
3897 insert_idx = dest_tabs->GetPageCount();
3898 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3899 nb->m_tabs.AddPage(page_info.window, page_info);
3900
3901 nb->DoSizing();
3902 dest_tabs->DoShowHide();
3903 dest_tabs->Refresh();
3904
3905 // set the selection in the destination tab control
3906 nb->SetSelectionToPage(page_info);
3907
3908 // notify owner that the tab has been dragged
3909 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
3910 e2.SetSelection(evt.GetSelection());
3911 e2.SetOldSelection(evt.GetSelection());
3912 e2.SetEventObject(this);
3913 GetEventHandler()->ProcessEvent(e2);
3914
3915 return;
3916 }
3917 }
3918 }
3919
3920
3921
3922
3923 // only perform a tab split if it's allowed
3924 wxAuiTabCtrl* dest_tabs = NULL;
3925
3926 if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3927 {
3928 // If the pointer is in an existing tab frame, do a tab insert
3929 wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3930 wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3931 int insert_idx = -1;
3932 if (tab_frame)
3933 {
3934 dest_tabs = tab_frame->m_tabs;
3935
3936 if (dest_tabs == src_tabs)
3937 return;
3938
3939
3940 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3941 wxWindow* target = NULL;
3942 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3943 if (target)
3944 {
3945 insert_idx = dest_tabs->GetIdxFromWindow(target);
3946 }
3947 }
3948 else
3949 {
3950 wxPoint zero(0,0);
3951 wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,
3952 mouse_client_pt,
3953 zero);
3954 if (rect.IsEmpty())
3955 {
3956 // there is no suitable drop location here, exit out
3957 return;
3958 }
3959
3960 // If there is no tabframe at all, create one
3961 wxTabFrame* new_tabs = new wxTabFrame;
3962 new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3963 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
3964 new_tabs->m_tabs = new wxAuiTabCtrl(this,
3965 m_tabIdCounter++,
3966 wxDefaultPosition,
3967 wxDefaultSize,
3968 wxNO_BORDER|wxWANTS_CHARS);
3969 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3970 new_tabs->m_tabs->SetFlags(m_flags);
3971
3972 m_mgr.AddPane(new_tabs,
3973 wxAuiPaneInfo().Bottom().CaptionVisible(false),
3974 mouse_client_pt);
3975 m_mgr.Update();
3976 dest_tabs = new_tabs->m_tabs;
3977 }
3978
3979
3980
3981 // remove the page from the source tabs
3982 wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3983 page_info.active = false;
3984 src_tabs->RemovePage(page_info.window);
3985 if (src_tabs->GetPageCount() > 0)
3986 {
3987 src_tabs->SetActivePage((size_t)0);
3988 src_tabs->DoShowHide();
3989 src_tabs->Refresh();
3990 }
3991
3992
3993
3994 // add the page to the destination tabs
3995 if (insert_idx == -1)
3996 insert_idx = dest_tabs->GetPageCount();
3997 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3998
3999 if (src_tabs->GetPageCount() == 0)
4000 {
4001 RemoveEmptyTabFrames();
4002 }
4003
4004 DoSizing();
4005 dest_tabs->DoShowHide();
4006 dest_tabs->Refresh();
4007
4008 // force the set selection function reset the selection
4009 m_curPage = -1;
4010
4011 // set the active page to the one we just split off
4012 SetSelectionToPage(page_info);
4013
4014 UpdateHintWindowSize();
4015 }
4016
4017 // notify owner that the tab has been dragged
4018 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
4019 e.SetSelection(evt.GetSelection());
4020 e.SetOldSelection(evt.GetSelection());
4021 e.SetEventObject(this);
4022 GetEventHandler()->ProcessEvent(e);
4023}
4024
4025
4026
4027void wxAuiNotebook::OnTabCancelDrag(wxAuiNotebookEvent& command_evt)
4028{
4029 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
4030
4031 m_mgr.HideHint();
4032
4033 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4034 wxCHECK_RET( src_tabs, wxT("no source object?") );
4035
4036 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
4037}
4038
4039wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
4040{
4041 // if we've just removed the last tab from the source
4042 // tab set, the remove the tab control completely
4043 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4044 size_t i, pane_count = all_panes.GetCount();
4045 for (i = 0; i < pane_count; ++i)
4046 {
4047 if (all_panes.Item(i).name == wxT("dummy"))
4048 continue;
4049
4050 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4051 if (tabframe->m_tab_rect.Contains(pt))
4052 return tabframe->m_tabs;
4053 }
4054
4055 return NULL;
4056}
4057
4058wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
4059{
4060 // if we've just removed the last tab from the source
4061 // tab set, the remove the tab control completely
4062 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4063 size_t i, pane_count = all_panes.GetCount();
4064 for (i = 0; i < pane_count; ++i)
4065 {
4066 if (all_panes.Item(i).name == wxT("dummy"))
4067 continue;
4068
4069 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4070 if (tabframe->m_tabs == tab_ctrl)
4071 {
4072 return tabframe;
4073 }
4074 }
4075
4076 return NULL;
4077}
4078
4079void wxAuiNotebook::RemoveEmptyTabFrames()
4080{
4081 // if we've just removed the last tab from the source
4082 // tab set, the remove the tab control completely
4083 wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
4084 size_t i, pane_count = all_panes.GetCount();
4085 for (i = 0; i < pane_count; ++i)
4086 {
4087 if (all_panes.Item(i).name == wxT("dummy"))
4088 continue;
4089
4090 wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
4091 if (tab_frame->m_tabs->GetPageCount() == 0)
4092 {
4093 m_mgr.DetachPane(tab_frame);
4094
4095 // use pending delete because sometimes during
4096 // window closing, refreshs are pending
4097 if (!wxPendingDelete.Member(tab_frame->m_tabs))
4098 wxPendingDelete.Append(tab_frame->m_tabs);
4099
4100 tab_frame->m_tabs = NULL;
4101
4102 delete tab_frame;
4103 }
4104 }
4105
4106
4107 // check to see if there is still a center pane;
4108 // if there isn't, make a frame the center pane
4109 wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
4110 pane_count = panes.GetCount();
4111 wxWindow* first_good = NULL;
4112 bool center_found = false;
4113 for (i = 0; i < pane_count; ++i)
4114 {
4115 if (panes.Item(i).name == wxT("dummy"))
4116 continue;
4117 if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
4118 center_found = true;
4119 if (!first_good)
4120 first_good = panes.Item(i).window;
4121 }
4122
4123 if (!center_found && first_good)
4124 {
4125 m_mgr.GetPane(first_good).Centre();
4126 }
4127
4128 if (!m_isBeingDeleted)
4129 m_mgr.Update();
4130}
4131
4132void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
4133{
4134 evt.Skip();
4135
4136 // if we're dragging a tab, don't change the current selection.
4137 // This code prevents a bug that used to happen when the hint window
4138 // was hidden. In the bug, the focus would return to the notebook
4139 // child, which would then enter this handler and call
4140 // SetSelection, which is not desired turn tab dragging.
4141
4142 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4143 size_t i, pane_count = all_panes.GetCount();
4144 for (i = 0; i < pane_count; ++i)
4145 {
4146 wxAuiPaneInfo& pane = all_panes.Item(i);
4147 if (pane.name == wxT("dummy"))
4148 continue;
4149 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4150 if (tabframe->m_tabs->IsDragging())
4151 return;
4152 }
4153
4154
4155 // change the tab selection to the child
4156 // which was focused
4157 int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4158 if (idx != -1 && idx != m_curPage)
4159 {
4160 SetSelection(idx);
4161 }
4162}
4163
4164void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
4165{
4166 if ( event.IsWindowChange() ) {
4167 // change pages
4168 // FIXME: the problem with this is that if we have a split notebook,
4169 // we selection may go all over the place.
4170 AdvanceSelection(event.GetDirection());
4171 }
4172 else {
4173 // we get this event in 3 cases
4174 //
4175 // a) one of our pages might have generated it because the user TABbed
4176 // out from it in which case we should propagate the event upwards and
4177 // our parent will take care of setting the focus to prev/next sibling
4178 //
4179 // or
4180 //
4181 // b) the parent panel wants to give the focus to us so that we
4182 // forward it to our selected page. We can't deal with this in
4183 // OnSetFocus() because we don't know which direction the focus came
4184 // from in this case and so can't choose between setting the focus to
4185 // first or last panel child
4186 //
4187 // or
4188 //
4189 // c) we ourselves (see MSWTranslateMessage) generated the event
4190 //
4191 wxWindow * const parent = GetParent();
4192
4193 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4194 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4195 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4196
4197 if ( isFromParent || isFromSelf )
4198 {
4199 // no, it doesn't come from child, case (b) or (c): forward to a
4200 // page but only if direction is backwards (TAB) or from ourselves,
4201 if ( GetSelection() != wxNOT_FOUND &&
4202 (!event.GetDirection() || isFromSelf) )
4203 {
4204 // so that the page knows that the event comes from it's parent
4205 // and is being propagated downwards
4206 event.SetEventObject(this);
4207
4208 wxWindow *page = GetPage(GetSelection());
4209 if ( !page->GetEventHandler()->ProcessEvent(event) )
4210 {
4211 page->SetFocus();
4212 }
4213 //else: page manages focus inside it itself
4214 }
4215 else // otherwise set the focus to the notebook itself
4216 {
4217 SetFocus();
4218 }
4219 }
4220 else
4221 {
4222 // it comes from our child, case (a), pass to the parent, but only
4223 // if the direction is forwards. Otherwise set the focus to the
4224 // notebook itself. The notebook is always the 'first' control of a
4225 // page.
4226 if ( !event.GetDirection() )
4227 {
4228 SetFocus();
4229 }
4230 else if ( parent )
4231 {
4232 event.SetCurrentFocus(this);
4233 parent->GetEventHandler()->ProcessEvent(event);
4234 }
4235 }
4236 }
4237}
4238
4239void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
4240{
4241 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4242
4243 int button_id = evt.GetInt();
4244
4245 if (button_id == wxAUI_BUTTON_CLOSE)
4246 {
4247 int selection = evt.GetSelection();
4248
4249 if (selection == -1)
4250 {
4251 // if the close button is to the right, use the active
4252 // page selection to determine which page to close
4253 selection = tabs->GetActivePage();
4254 }
4255
4256 if (selection != -1)
4257 {
4258 wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4259
4260 // ask owner if it's ok to close the tab
4261 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4262 e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4263 const int idx = m_tabs.GetIdxFromWindow(close_wnd);
4264 e.SetSelection(idx);
4265 e.SetOldSelection(evt.GetSelection());
4266 e.SetEventObject(this);
4267 GetEventHandler()->ProcessEvent(e);
4268 if (!e.IsAllowed())
4269 return;
4270
4271
4272#if wxUSE_MDI
4273 if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4274 {
4275 close_wnd->Close();
4276 }
4277 else
4278#endif
4279 {
4280 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4281 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
4282
4283 DeletePage(main_idx);
4284 }
4285
4286 // notify owner that the tab has been closed
4287 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
4288 e2.SetSelection(idx);
4289 e2.SetEventObject(this);
4290 GetEventHandler()->ProcessEvent(e2);
4291 }
4292 }
4293}
4294
4295
4296void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
4297{
4298 // patch event through to owner
4299 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4300 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4301
4302 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4303 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4304 e.SetEventObject(this);
4305 GetEventHandler()->ProcessEvent(e);
4306}
4307
4308void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
4309{
4310 // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4311 // click should act like a tab close action. However, first
4312 // give the owner an opportunity to handle the middle up event
4313 // for custom action
4314
4315 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4316 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4317
4318 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4319 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4320 e.SetEventObject(this);
4321 if (GetEventHandler()->ProcessEvent(e))
4322 return;
4323 if (!e.IsAllowed())
4324 return;
4325
4326 // check if we are supposed to close on middle-up
4327 if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4328 return;
4329
4330 // simulate the user pressing the close button on the tab
4331 evt.SetInt(wxAUI_BUTTON_CLOSE);
4332 OnTabButton(evt);
4333}
4334
4335void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
4336{
4337 // patch event through to owner
4338 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4339 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4340
4341 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4342 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4343 e.SetEventObject(this);
4344 GetEventHandler()->ProcessEvent(e);
4345}
4346
4347void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
4348{
4349 // patch event through to owner
4350 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4351 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4352
4353 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4354 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4355 e.SetEventObject(this);
4356 GetEventHandler()->ProcessEvent(e);
4357}
4358
4359// Sets the normal font
4360void wxAuiNotebook::SetNormalFont(const wxFont& font)
4361{
4362 m_normalFont = font;
4363 GetArtProvider()->SetNormalFont(font);
4364}
4365
4366// Sets the selected tab font
4367void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4368{
4369 m_selectedFont = font;
4370 GetArtProvider()->SetSelectedFont(font);
4371}
4372
4373// Sets the measuring font
4374void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4375{
4376 GetArtProvider()->SetMeasuringFont(font);
4377}
4378
4379// Sets the tab font
4380bool wxAuiNotebook::SetFont(const wxFont& font)
4381{
4382 wxControl::SetFont(font);
4383
4384 wxFont normalFont(font);
4385 wxFont selectedFont(normalFont);
4386 selectedFont.SetWeight(wxBOLD);
4387
4388 SetNormalFont(normalFont);
4389 SetSelectedFont(selectedFont);
4390 SetMeasuringFont(selectedFont);
4391
4392 return true;
4393}
4394
4395// Gets the tab control height
4396int wxAuiNotebook::GetTabCtrlHeight() const
4397{
4398 return m_tabCtrlHeight;
4399}
4400
4401// Gets the height of the notebook for a given page height
4402int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4403{
4404 UpdateTabCtrlHeight();
4405
4406 int tabCtrlHeight = GetTabCtrlHeight();
4407 int decorHeight = 2;
4408 return tabCtrlHeight + pageHeight + decorHeight;
4409}
4410
4411// Advances the selection, generation page selection events
4412void wxAuiNotebook::AdvanceSelection(bool forward)
4413{
4414 if (GetPageCount() <= 1)
4415 return;
4416
4417 int currentSelection = GetSelection();
4418
4419 if (forward)
4420 {
4421 if (currentSelection == (int) (GetPageCount() - 1))
4422 return;
4423 else if (currentSelection == -1)
4424 currentSelection = 0;
4425 else
4426 currentSelection ++;
4427 }
4428 else
4429 {
4430 if (currentSelection <= 0)
4431 return;
4432 else
4433 currentSelection --;
4434 }
4435
4436 SetSelection(currentSelection);
4437}
4438
4439// Shows the window menu
4440bool wxAuiNotebook::ShowWindowMenu()
4441{
4442 wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4443
4444 int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4445
4446 if (idx != -1)
4447 {
4448 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4449 e.SetSelection(idx);
4450 e.SetOldSelection(tabCtrl->GetActivePage());
4451 e.SetEventObject(tabCtrl);
4452 GetEventHandler()->ProcessEvent(e);
4453
4454 return true;
4455 }
4456 else
4457 return false;
4458}
4459
4460void wxAuiNotebook::Thaw()
4461{
4462 DoSizing();
4463
4464 wxControl::Thaw();
4465}
4466
4467void wxAuiNotebook::SetPageSize (const wxSize& WXUNUSED(size))
4468{
4469 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4470}
4471
4472int wxAuiNotebook::HitTest (const wxPoint& WXUNUSED(pt), long* WXUNUSED(flags)) const
4473{
4474 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4475 return wxNOT_FOUND;
4476}
4477
4478int wxAuiNotebook::GetPageImage(size_t WXUNUSED(n)) const
4479{
4480 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4481 return -1;
4482}
4483
4484bool wxAuiNotebook::SetPageImage(size_t n, int imageId)
4485{
4486 return SetPageBitmap(n, GetImageList()->GetBitmap(imageId));
4487}
4488
4489wxWindow* wxAuiNotebook::GetCurrentPage () const
4490{
4491 return GetPage(GetSelection());
4492}
4493
4494int wxAuiNotebook::ChangeSelection(size_t n)
4495{
4496 return DoModifySelection(n, false);
4497}
4498
4499bool wxAuiNotebook::AddPage(wxWindow *page, const wxString &text, bool select,
4500 int imageId)
4501{
4502 if(HasImageList())
4503 {
4504 return AddPage(page, text, select, GetImageList()->GetBitmap(imageId));
4505 }
4506 else
4507 {
4508 return AddPage(page, text, select, wxNullBitmap);
4509 }
4510}
4511
4512bool wxAuiNotebook::DeleteAllPages()
4513{
4514 size_t count = GetPageCount();
4515 for(size_t i = 0; i < count; i++)
4516 {
4517 DeletePage(0);
4518 }
4519 return true;
4520}
4521
4522bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
4523 const wxString &text, bool select,
4524 int imageId)
4525{
4526 if(HasImageList())
4527 {
4528 return InsertPage(index, page, text, select,
4529 GetImageList()->GetBitmap(imageId));
4530 }
4531 else
4532 {
4533 return InsertPage(index, page, text, select, wxNullBitmap);
4534 }
4535}
4536
4537int wxAuiNotebook::DoModifySelection(size_t n, bool events)
4538{
4539 wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
4540 if (!wnd)
4541 return m_curPage;
4542
4543 // don't change the page unless necessary;
4544 // however, clicking again on a tab should give it the focus.
4545 if ((int)n == m_curPage)
4546 {
4547 wxAuiTabCtrl* ctrl;
4548 int ctrl_idx;
4549 if (FindTab(wnd, &ctrl, &ctrl_idx))
4550 {
4551 if (FindFocus() != ctrl)
4552 ctrl->SetFocus();
4553 }
4554 return m_curPage;
4555 }
4556
4557 bool vetoed = false;
4558
4559 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
4560
4561 if(events)
4562 {
4563 evt.SetSelection(n);
4564 evt.SetOldSelection(m_curPage);
4565 evt.SetEventObject(this);
4566 GetEventHandler()->ProcessEvent(evt);
4567 vetoed = !evt.IsAllowed();
4568 }
4569
4570 if (!vetoed)
4571 {
4572 int old_curpage = m_curPage;
4573 m_curPage = n;
4574
4575 // program allows the page change
4576 if(events)
4577 {
4578 evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
4579 (void)GetEventHandler()->ProcessEvent(evt);
4580 }
4581
4582
4583 wxAuiTabCtrl* ctrl;
4584 int ctrl_idx;
4585 if (FindTab(wnd, &ctrl, &ctrl_idx))
4586 {
4587 m_tabs.SetActivePage(wnd);
4588
4589 ctrl->SetActivePage(ctrl_idx);
4590 DoSizing();
4591 ctrl->DoShowHide();
4592
4593 ctrl->MakeTabVisible(ctrl_idx, ctrl);
4594
4595 // set fonts
4596 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4597 size_t i, pane_count = all_panes.GetCount();
4598 for (i = 0; i < pane_count; ++i)
4599 {
4600 wxAuiPaneInfo& pane = all_panes.Item(i);
4601 if (pane.name == wxT("dummy"))
4602 continue;
4603 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
4604 if (tabctrl != ctrl)
4605 tabctrl->SetSelectedFont(m_normalFont);
4606 else
4607 tabctrl->SetSelectedFont(m_selectedFont);
4608 tabctrl->Refresh();
4609 }
4610
4611 // Set the focus to the page if we're not currently focused on the tab.
4612 // This is Firefox-like behaviour.
4613 if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
4614 wnd->SetFocus();
4615
4616 return old_curpage;
4617 }
4618 }
4619
4620 return m_curPage;
4621}
4622
4623
4624#endif // wxUSE_AUI
wxWidgets (Impactor)