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