]> 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
don't lose the contents of the combobox if it was set to a value not in a list and...
[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
1615 // use the same layout direction as the window DC uses to ensure that the
1616 // text is rendered correctly
1617 dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
1618
1619 wxBitmap bmp;
1620 size_t i;
1621 size_t page_count = m_pages.GetCount();
1622 size_t button_count = m_buttons.GetCount();
1623
1624 // create off-screen bitmap
1625 bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
1626 dc.SelectObject(bmp);
1627
1628 if (!dc.IsOk())
1629 return;
1630
1631 // find out if size of tabs is larger than can be
1632 // afforded on screen
1633 int total_width = 0;
1634 int visible_width = 0;
1635 for (i = 0; i < page_count; ++i)
1636 {
1637 wxAuiNotebookPage& page = m_pages.Item(i);
1638
1639 // determine if a close button is on this tab
1640 bool close_button = false;
1641 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1642 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1643 {
1644 close_button = true;
1645 }
1646
1647
1648 int x_extent = 0;
1649 wxSize size = m_art->GetTabSize(dc,
1650 wnd,
1651 page.caption,
1652 page.bitmap,
1653 page.active,
1654 close_button ?
1655 wxAUI_BUTTON_STATE_NORMAL :
1656 wxAUI_BUTTON_STATE_HIDDEN,
1657 &x_extent);
1658
1659 if (i+1 < page_count)
1660 total_width += x_extent;
1661 else
1662 total_width += size.x;
1663
1664 if (i >= m_tab_offset)
1665 {
1666 if (i+1 < page_count)
1667 visible_width += x_extent;
1668 else
1669 visible_width += size.x;
1670 }
1671 }
1672
1673 if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
1674 {
1675 // show left/right buttons
1676 for (i = 0; i < button_count; ++i)
1677 {
1678 wxAuiTabContainerButton& button = m_buttons.Item(i);
1679 if (button.id == wxAUI_BUTTON_LEFT ||
1680 button.id == wxAUI_BUTTON_RIGHT)
1681 {
1682 button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
1683 }
1684 }
1685 }
1686 else
1687 {
1688 // hide left/right buttons
1689 for (i = 0; i < button_count; ++i)
1690 {
1691 wxAuiTabContainerButton& button = m_buttons.Item(i);
1692 if (button.id == wxAUI_BUTTON_LEFT ||
1693 button.id == wxAUI_BUTTON_RIGHT)
1694 {
1695 button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
1696 }
1697 }
1698 }
1699
1700 // determine whether left button should be enabled
1701 for (i = 0; i < button_count; ++i)
1702 {
1703 wxAuiTabContainerButton& button = m_buttons.Item(i);
1704 if (button.id == wxAUI_BUTTON_LEFT)
1705 {
1706 if (m_tab_offset == 0)
1707 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1708 else
1709 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1710 }
1711 if (button.id == wxAUI_BUTTON_RIGHT)
1712 {
1713 if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
1714 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1715 else
1716 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1717 }
1718 }
1719
1720
1721
1722 // draw background
1723 m_art->DrawBackground(dc, wnd, m_rect);
1724
1725 // draw buttons
1726 int left_buttons_width = 0;
1727 int right_buttons_width = 0;
1728
1729 int offset = 0;
1730
1731 // draw the buttons on the right side
1732 offset = m_rect.x + m_rect.width;
1733 for (i = 0; i < button_count; ++i)
1734 {
1735 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1736
1737 if (button.location != wxRIGHT)
1738 continue;
1739 if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1740 continue;
1741
1742 wxRect button_rect = m_rect;
1743 button_rect.SetY(1);
1744 button_rect.SetWidth(offset);
1745
1746 m_art->DrawButton(dc,
1747 wnd,
1748 button_rect,
1749 button.id,
1750 button.cur_state,
1751 wxRIGHT,
1752 &button.rect);
1753
1754 offset -= button.rect.GetWidth();
1755 right_buttons_width += button.rect.GetWidth();
1756 }
1757
1758
1759
1760 offset = 0;
1761
1762 // draw the buttons on the left side
1763
1764 for (i = 0; i < button_count; ++i)
1765 {
1766 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1767
1768 if (button.location != wxLEFT)
1769 continue;
1770 if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1771 continue;
1772
1773 wxRect button_rect(offset, 1, 1000, m_rect.height);
1774
1775 m_art->DrawButton(dc,
1776 wnd,
1777 button_rect,
1778 button.id,
1779 button.cur_state,
1780 wxLEFT,
1781 &button.rect);
1782
1783 offset += button.rect.GetWidth();
1784 left_buttons_width += button.rect.GetWidth();
1785 }
1786
1787 offset = left_buttons_width;
1788
1789 if (offset == 0)
1790 offset += m_art->GetIndentSize();
1791
1792
1793 // prepare the tab-close-button array
1794 // make sure tab button entries which aren't used are marked as hidden
1795 for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
1796 m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1797
1798 // make sure there are enough tab button entries to accommodate all tabs
1799 while (m_tab_close_buttons.GetCount() < page_count)
1800 {
1801 wxAuiTabContainerButton tempbtn;
1802 tempbtn.id = wxAUI_BUTTON_CLOSE;
1803 tempbtn.location = wxCENTER;
1804 tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1805 m_tab_close_buttons.Add(tempbtn);
1806 }
1807
1808
1809 // buttons before the tab offset must be set to hidden
1810 for (i = 0; i < m_tab_offset; ++i)
1811 {
1812 m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1813 }
1814
1815
1816 // draw the tabs
1817
1818 size_t active = 999;
1819 int active_offset = 0;
1820 wxRect active_rect;
1821
1822 int x_extent = 0;
1823 wxRect rect = m_rect;
1824 rect.y = 0;
1825 rect.height = m_rect.height;
1826
1827 for (i = m_tab_offset; i < page_count; ++i)
1828 {
1829 wxAuiNotebookPage& page = m_pages.Item(i);
1830 wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
1831
1832 // determine if a close button is on this tab
1833 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1834 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1835 {
1836 if (tab_button.cur_state == wxAUI_BUTTON_STATE_HIDDEN)
1837 {
1838 tab_button.id = wxAUI_BUTTON_CLOSE;
1839 tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
1840 tab_button.location = wxCENTER;
1841 }
1842 }
1843 else
1844 {
1845 tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1846 }
1847
1848 rect.x = offset;
1849 rect.width = m_rect.width - right_buttons_width - offset - 2;
1850
1851 if (rect.width <= 0)
1852 break;
1853
1854 m_art->DrawTab(dc,
1855 wnd,
1856 page,
1857 rect,
1858 tab_button.cur_state,
1859 &page.rect,
1860 &tab_button.rect,
1861 &x_extent);
1862
1863 if (page.active)
1864 {
1865 active = i;
1866 active_offset = offset;
1867 active_rect = rect;
1868 }
1869
1870 offset += x_extent;
1871 }
1872
1873
1874 // make sure to deactivate buttons which are off the screen to the right
1875 for (++i; i < m_tab_close_buttons.GetCount(); ++i)
1876 {
1877 m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1878 }
1879
1880
1881 // draw the active tab again so it stands in the foreground
1882 if (active >= m_tab_offset && active < m_pages.GetCount())
1883 {
1884 wxAuiNotebookPage& page = m_pages.Item(active);
1885
1886 wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
1887
1888 rect.x = active_offset;
1889 m_art->DrawTab(dc,
1890 wnd,
1891 page,
1892 active_rect,
1893 tab_button.cur_state,
1894 &page.rect,
1895 &tab_button.rect,
1896 &x_extent);
1897 }
1898
1899
1900 raw_dc->Blit(m_rect.x, m_rect.y,
1901 m_rect.GetWidth(), m_rect.GetHeight(),
1902 &dc, 0, 0);
1903}
1904
1905// Is the tab visible?
1906bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
1907{
1908 if (!dc || !dc->IsOk())
1909 return false;
1910
1911 size_t i;
1912 size_t page_count = m_pages.GetCount();
1913 size_t button_count = m_buttons.GetCount();
1914
1915 // Hasn't been rendered yet; assume it's visible
1916 if (m_tab_close_buttons.GetCount() < page_count)
1917 return true;
1918
1919 // First check if both buttons are disabled - if so, there's no need to
1920 // check further for visibility.
1921 int arrowButtonVisibleCount = 0;
1922 for (i = 0; i < button_count; ++i)
1923 {
1924 wxAuiTabContainerButton& button = m_buttons.Item(i);
1925 if (button.id == wxAUI_BUTTON_LEFT ||
1926 button.id == wxAUI_BUTTON_RIGHT)
1927 {
1928 if ((button.cur_state & wxAUI_BUTTON_STATE_HIDDEN) == 0)
1929 arrowButtonVisibleCount ++;
1930 }
1931 }
1932
1933 // Tab must be visible
1934 if (arrowButtonVisibleCount == 0)
1935 return true;
1936
1937 // If tab is less than the given offset, it must be invisible by definition
1938 if (tabPage < tabOffset)
1939 return false;
1940
1941 // draw buttons
1942 int left_buttons_width = 0;
1943 int right_buttons_width = 0;
1944
1945 int offset = 0;
1946
1947 // calculate size of the buttons on the right side
1948 offset = m_rect.x + m_rect.width;
1949 for (i = 0; i < button_count; ++i)
1950 {
1951 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1952
1953 if (button.location != wxRIGHT)
1954 continue;
1955 if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1956 continue;
1957
1958 offset -= button.rect.GetWidth();
1959 right_buttons_width += button.rect.GetWidth();
1960 }
1961
1962 offset = 0;
1963
1964 // calculate size of the buttons on the left side
1965 for (i = 0; i < button_count; ++i)
1966 {
1967 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1968
1969 if (button.location != wxLEFT)
1970 continue;
1971 if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1972 continue;
1973
1974 offset += button.rect.GetWidth();
1975 left_buttons_width += button.rect.GetWidth();
1976 }
1977
1978 offset = left_buttons_width;
1979
1980 if (offset == 0)
1981 offset += m_art->GetIndentSize();
1982
1983 wxRect active_rect;
1984
1985 wxRect rect = m_rect;
1986 rect.y = 0;
1987 rect.height = m_rect.height;
1988
1989 // See if the given page is visible at the given tab offset (effectively scroll position)
1990 for (i = tabOffset; i < page_count; ++i)
1991 {
1992 wxAuiNotebookPage& page = m_pages.Item(i);
1993 wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
1994
1995 rect.x = offset;
1996 rect.width = m_rect.width - right_buttons_width - offset - 2;
1997
1998 if (rect.width <= 0)
1999 return false; // haven't found the tab, and we've run out of space, so return false
2000
2001 int x_extent = 0;
2002 wxSize size = m_art->GetTabSize(*dc,
2003 wnd,
2004 page.caption,
2005 page.bitmap,
2006 page.active,
2007 tab_button.cur_state,
2008 &x_extent);
2009
2010 offset += x_extent;
2011
2012 if (i == (size_t) tabPage)
2013 {
2014 // If not all of the tab is visible, and supposing there's space to display it all,
2015 // we could do better so we return false.
2016 if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
2017 return false;
2018 else
2019 return true;
2020 }
2021 }
2022
2023 // Shouldn't really get here, but if it does, assume the tab is visible to prevent
2024 // further looping in calling code.
2025 return true;
2026}
2027
2028// Make the tab visible if it wasn't already
2029void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
2030{
2031 wxClientDC dc(win);
2032 if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
2033 {
2034 int i;
2035 for (i = 0; i < (int) m_pages.GetCount(); i++)
2036 {
2037 if (IsTabVisible(tabPage, i, & dc, win))
2038 {
2039 SetTabOffset(i);
2040 win->Refresh();
2041 return;
2042 }
2043 }
2044 }
2045}
2046
2047// TabHitTest() tests if a tab was hit, passing the window pointer
2048// back if that condition was fulfilled. The function returns
2049// true if a tab was hit, otherwise false
2050bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
2051{
2052 if (!m_rect.Contains(x,y))
2053 return false;
2054
2055 wxAuiTabContainerButton* btn = NULL;
2056 if (ButtonHitTest(x, y, &btn))
2057 {
2058 if (m_buttons.Index(*btn) != wxNOT_FOUND)
2059 return false;
2060 }
2061
2062 size_t i, page_count = m_pages.GetCount();
2063
2064 for (i = m_tab_offset; i < page_count; ++i)
2065 {
2066 wxAuiNotebookPage& page = m_pages.Item(i);
2067 if (page.rect.Contains(x,y))
2068 {
2069 if (hit)
2070 *hit = page.window;
2071 return true;
2072 }
2073 }
2074
2075 return false;
2076}
2077
2078// ButtonHitTest() tests if a button was hit. The function returns
2079// true if a button was hit, otherwise false
2080bool wxAuiTabContainer::ButtonHitTest(int x, int y,
2081 wxAuiTabContainerButton** hit) const
2082{
2083 if (!m_rect.Contains(x,y))
2084 return false;
2085
2086 size_t i, button_count;
2087
2088
2089 button_count = m_buttons.GetCount();
2090 for (i = 0; i < button_count; ++i)
2091 {
2092 wxAuiTabContainerButton& button = m_buttons.Item(i);
2093 if (button.rect.Contains(x,y) &&
2094 !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
2095 wxAUI_BUTTON_STATE_DISABLED)))
2096 {
2097 if (hit)
2098 *hit = &button;
2099 return true;
2100 }
2101 }
2102
2103 button_count = m_tab_close_buttons.GetCount();
2104 for (i = 0; i < button_count; ++i)
2105 {
2106 wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
2107 if (button.rect.Contains(x,y) &&
2108 !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
2109 wxAUI_BUTTON_STATE_DISABLED)))
2110 {
2111 if (hit)
2112 *hit = &button;
2113 return true;
2114 }
2115 }
2116
2117 return false;
2118}
2119
2120
2121
2122// the utility function ShowWnd() is the same as show,
2123// except it handles wxAuiMDIChildFrame windows as well,
2124// as the Show() method on this class is "unplugged"
2125static void ShowWnd(wxWindow* wnd, bool show)
2126{
2127#if wxUSE_MDI
2128 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2129 {
2130 wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
2131 cf->DoShow(show);
2132 }
2133 else
2134#endif
2135 {
2136 wnd->Show(show);
2137 }
2138}
2139
2140
2141// DoShowHide() this function shows the active window, then
2142// hides all of the other windows (in that order)
2143void wxAuiTabContainer::DoShowHide()
2144{
2145 wxAuiNotebookPageArray& pages = GetPages();
2146 size_t i, page_count = pages.GetCount();
2147
2148 // show new active page first
2149 for (i = 0; i < page_count; ++i)
2150 {
2151 wxAuiNotebookPage& page = pages.Item(i);
2152 if (page.active)
2153 {
2154 ShowWnd(page.window, true);
2155 break;
2156 }
2157 }
2158
2159 // hide all other pages
2160 for (i = 0; i < page_count; ++i)
2161 {
2162 wxAuiNotebookPage& page = pages.Item(i);
2163 if (!page.active)
2164 ShowWnd(page.window, false);
2165 }
2166}
2167
2168
2169
2170
2171
2172
2173// -- wxAuiTabCtrl class implementation --
2174
2175
2176
2177BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
2178 EVT_PAINT(wxAuiTabCtrl::OnPaint)
2179 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
2180 EVT_SIZE(wxAuiTabCtrl::OnSize)
2181 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
2182 EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
2183 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
2184 EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
2185 EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
2186 EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
2187 EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
2188 EVT_MOTION(wxAuiTabCtrl::OnMotion)
2189 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
2190 EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
2191 EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
2192 EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
2193 EVT_CHAR(wxAuiTabCtrl::OnChar)
2194END_EVENT_TABLE()
2195
2196
2197wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
2198 wxWindowID id,
2199 const wxPoint& pos,
2200 const wxSize& size,
2201 long style) : wxControl(parent, id, pos, size, style)
2202{
2203 SetName(wxT("wxAuiTabCtrl"));
2204 m_click_pt = wxDefaultPosition;
2205 m_is_dragging = false;
2206 m_hover_button = NULL;
2207 m_pressed_button = NULL;
2208}
2209
2210wxAuiTabCtrl::~wxAuiTabCtrl()
2211{
2212}
2213
2214void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
2215{
2216 wxPaintDC dc(this);
2217
2218 dc.SetFont(GetFont());
2219
2220 if (GetPageCount() > 0)
2221 Render(&dc, this);
2222}
2223
2224void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2225{
2226}
2227
2228void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2229{
2230 wxSize s = evt.GetSize();
2231 wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2232 SetRect(r);
2233}
2234
2235void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2236{
2237 CaptureMouse();
2238 m_click_pt = wxDefaultPosition;
2239 m_is_dragging = false;
2240 m_click_tab = NULL;
2241 m_pressed_button = NULL;
2242
2243
2244 wxWindow* wnd;
2245 if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2246 {
2247 int new_selection = GetIdxFromWindow(wnd);
2248
2249 // wxAuiNotebooks always want to receive this event
2250 // even if the tab is already active, because they may
2251 // have multiple tab controls
2252 if (new_selection != GetActivePage() ||
2253 GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
2254 {
2255 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2256 e.SetSelection(new_selection);
2257 e.SetOldSelection(GetActivePage());
2258 e.SetEventObject(this);
2259 GetEventHandler()->ProcessEvent(e);
2260 }
2261
2262 m_click_pt.x = evt.m_x;
2263 m_click_pt.y = evt.m_y;
2264 m_click_tab = wnd;
2265 }
2266
2267 if (m_hover_button)
2268 {
2269 m_pressed_button = m_hover_button;
2270 m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
2271 Refresh();
2272 Update();
2273 }
2274}
2275
2276void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2277{
2278 if (GetCapture() == this)
2279 ReleaseMouse();
2280
2281 if (m_is_dragging)
2282 {
2283 m_is_dragging = false;
2284
2285 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2286 evt.SetSelection(GetIdxFromWindow(m_click_tab));
2287 evt.SetOldSelection(evt.GetSelection());
2288 evt.SetEventObject(this);
2289 GetEventHandler()->ProcessEvent(evt);
2290
2291 return;
2292 }
2293
2294 if (m_pressed_button)
2295 {
2296 // make sure we're still clicking the button
2297 wxAuiTabContainerButton* button = NULL;
2298 if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
2299 return;
2300
2301 if (button != m_pressed_button)
2302 {
2303 m_pressed_button = NULL;
2304 return;
2305 }
2306
2307 Refresh();
2308 Update();
2309
2310 if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
2311 {
2312 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2313 evt.SetSelection(GetIdxFromWindow(m_click_tab));
2314 evt.SetInt(m_pressed_button->id);
2315 evt.SetEventObject(this);
2316 GetEventHandler()->ProcessEvent(evt);
2317 }
2318
2319 m_pressed_button = NULL;
2320 }
2321
2322 m_click_pt = wxDefaultPosition;
2323 m_is_dragging = false;
2324 m_click_tab = NULL;
2325}
2326
2327void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
2328{
2329 wxWindow* wnd = NULL;
2330 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2331 return;
2332
2333 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
2334 e.SetEventObject(this);
2335 e.SetSelection(GetIdxFromWindow(wnd));
2336 GetEventHandler()->ProcessEvent(e);
2337}
2338
2339void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
2340{
2341 wxWindow* wnd = NULL;
2342 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2343 return;
2344
2345 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
2346 e.SetEventObject(this);
2347 e.SetSelection(GetIdxFromWindow(wnd));
2348 GetEventHandler()->ProcessEvent(e);
2349}
2350
2351void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
2352{
2353 wxWindow* wnd = NULL;
2354 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2355 return;
2356
2357 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
2358 e.SetEventObject(this);
2359 e.SetSelection(GetIdxFromWindow(wnd));
2360 GetEventHandler()->ProcessEvent(e);
2361}
2362
2363void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
2364{
2365 wxWindow* wnd = NULL;
2366 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2367 return;
2368
2369 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
2370 e.SetEventObject(this);
2371 e.SetSelection(GetIdxFromWindow(wnd));
2372 GetEventHandler()->ProcessEvent(e);
2373}
2374
2375void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
2376{
2377 wxWindow* wnd;
2378 wxAuiTabContainerButton* button;
2379 if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
2380 {
2381 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2382 e.SetEventObject(this);
2383 GetEventHandler()->ProcessEvent(e);
2384 }
2385}
2386
2387void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2388{
2389 wxPoint pos = evt.GetPosition();
2390
2391 // check if the mouse is hovering above a button
2392 wxAuiTabContainerButton* button;
2393 if (ButtonHitTest(pos.x, pos.y, &button))
2394 {
2395 if (m_hover_button && button != m_hover_button)
2396 {
2397 m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2398 m_hover_button = NULL;
2399 Refresh();
2400 Update();
2401 }
2402
2403 if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
2404 {
2405 button->cur_state = wxAUI_BUTTON_STATE_HOVER;
2406 Refresh();
2407 Update();
2408 m_hover_button = button;
2409 return;
2410 }
2411 }
2412 else
2413 {
2414 if (m_hover_button)
2415 {
2416 m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2417 m_hover_button = NULL;
2418 Refresh();
2419 Update();
2420 }
2421 }
2422
2423
2424 if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
2425 return;
2426
2427 if (m_is_dragging)
2428 {
2429 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2430 evt.SetSelection(GetIdxFromWindow(m_click_tab));
2431 evt.SetOldSelection(evt.GetSelection());
2432 evt.SetEventObject(this);
2433 GetEventHandler()->ProcessEvent(evt);
2434 return;
2435 }
2436
2437
2438 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2439 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2440
2441 if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
2442 abs(pos.y - m_click_pt.y) > drag_y_threshold)
2443 {
2444 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2445 evt.SetSelection(GetIdxFromWindow(m_click_tab));
2446 evt.SetOldSelection(evt.GetSelection());
2447 evt.SetEventObject(this);
2448 GetEventHandler()->ProcessEvent(evt);
2449
2450 m_is_dragging = true;
2451 }
2452}
2453
2454void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2455{
2456 if (m_hover_button)
2457 {
2458 m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2459 m_hover_button = NULL;
2460 Refresh();
2461 Update();
2462 }
2463}
2464
2465void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2466{
2467 int button = event.GetInt();
2468
2469 if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2470 {
2471 if (button == wxAUI_BUTTON_LEFT)
2472 {
2473 if (GetTabOffset() > 0)
2474 {
2475 SetTabOffset(GetTabOffset()-1);
2476 Refresh();
2477 Update();
2478 }
2479 }
2480 else
2481 {
2482 SetTabOffset(GetTabOffset()+1);
2483 Refresh();
2484 Update();
2485 }
2486 }
2487 else if (button == wxAUI_BUTTON_WINDOWLIST)
2488 {
2489 int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
2490
2491 if (idx != -1)
2492 {
2493 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2494 e.SetSelection(idx);
2495 e.SetOldSelection(GetActivePage());
2496 e.SetEventObject(this);
2497 GetEventHandler()->ProcessEvent(e);
2498 }
2499 }
2500 else
2501 {
2502 event.Skip();
2503 }
2504}
2505
2506void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2507{
2508 Refresh();
2509}
2510
2511void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
2512{
2513 Refresh();
2514}
2515
2516void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
2517{
2518 if (GetActivePage() == -1)
2519 {
2520 event.Skip();
2521 return;
2522 }
2523
2524 // We can't leave tab processing to the system; on Windows, tabs and keys
2525 // get eaten by the system and not processed properly if we specify both
2526 // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
2527 // we don't key arrow key events.
2528
2529 int key = event.GetKeyCode();
2530
2531 if (key == WXK_NUMPAD_PAGEUP)
2532 key = WXK_PAGEUP;
2533 if (key == WXK_NUMPAD_PAGEDOWN)
2534 key = WXK_PAGEDOWN;
2535 if (key == WXK_NUMPAD_HOME)
2536 key = WXK_HOME;
2537 if (key == WXK_NUMPAD_END)
2538 key = WXK_END;
2539 if (key == WXK_NUMPAD_LEFT)
2540 key = WXK_LEFT;
2541 if (key == WXK_NUMPAD_RIGHT)
2542 key = WXK_RIGHT;
2543
2544 if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
2545 {
2546 bool bCtrlDown = event.ControlDown();
2547 bool bShiftDown = event.ShiftDown();
2548
2549 bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
2550 bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
2551 bool bFromTab = (key == WXK_TAB);
2552
2553 wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
2554 if (!nb)
2555 {
2556 event.Skip();
2557 return;
2558 }
2559
2560 wxNavigationKeyEvent keyEvent;
2561 keyEvent.SetDirection(bForward);
2562 keyEvent.SetWindowChange(bWindowChange);
2563 keyEvent.SetFromTab(bFromTab);
2564 keyEvent.SetEventObject(nb);
2565
2566 if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
2567 {
2568 // Not processed? Do an explicit tab into the page.
2569 wxWindow* win = GetWindowFromIdx(GetActivePage());
2570 if (win)
2571 win->SetFocus();
2572 }
2573 return;
2574 }
2575
2576 if (m_pages.GetCount() < 2)
2577 {
2578 event.Skip();
2579 return;
2580 }
2581
2582 int newPage = -1;
2583
2584 int forwardKey, backwardKey;
2585 if (GetLayoutDirection() == wxLayout_RightToLeft)
2586 {
2587 forwardKey = WXK_LEFT;
2588 backwardKey = WXK_RIGHT;
2589 }
2590 else
2591 {
2592 forwardKey = WXK_RIGHT;
2593 backwardKey = WXK_LEFT;
2594 }
2595
2596 if (key == forwardKey)
2597 {
2598 if (m_pages.GetCount() > 1)
2599 {
2600 if (GetActivePage() == -1)
2601 newPage = 0;
2602 else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
2603 newPage = GetActivePage() + 1;
2604 }
2605 }
2606 else if (key == backwardKey)
2607 {
2608 if (m_pages.GetCount() > 1)
2609 {
2610 if (GetActivePage() == -1)
2611 newPage = (int) (m_pages.GetCount() - 1);
2612 else if (GetActivePage() > 0)
2613 newPage = GetActivePage() - 1;
2614 }
2615 }
2616 else if (key == WXK_HOME)
2617 {
2618 newPage = 0;
2619 }
2620 else if (key == WXK_END)
2621 {
2622 newPage = (int) (m_pages.GetCount() - 1);
2623 }
2624 else
2625 event.Skip();
2626
2627 if (newPage != -1)
2628 {
2629 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2630 e.SetSelection(newPage);
2631 e.SetOldSelection(newPage);
2632 e.SetEventObject(this);
2633 this->GetEventHandler()->ProcessEvent(e);
2634 }
2635 else
2636 event.Skip();
2637}
2638
2639// wxTabFrame is an interesting case. It's important that all child pages
2640// of the multi-notebook control are all actually children of that control
2641// (and not grandchildren). wxTabFrame facilitates this. There is one
2642// instance of wxTabFrame for each tab control inside the multi-notebook.
2643// It's important to know that wxTabFrame is not a real window, but it merely
2644// used to capture the dimensions/positioning of the internal tab control and
2645// it's managed page windows
2646
2647class wxTabFrame : public wxWindow
2648{
2649public:
2650
2651 wxTabFrame()
2652 {
2653 m_tabs = NULL;
2654 m_rect = wxRect(0,0,200,200);
2655 m_tab_ctrl_height = 20;
2656 }
2657
2658 ~wxTabFrame()
2659 {
2660 wxDELETE(m_tabs);
2661 }
2662
2663 void SetTabCtrlHeight(int h)
2664 {
2665 m_tab_ctrl_height = h;
2666 }
2667
2668protected:
2669 void DoSetSize(int x, int y,
2670 int width, int height,
2671 int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2672 {
2673 m_rect = wxRect(x, y, width, height);
2674 DoSizing();
2675 }
2676
2677 void DoGetClientSize(int* x, int* y) const
2678 {
2679 *x = m_rect.width;
2680 *y = m_rect.height;
2681 }
2682
2683public:
2684 bool Show( bool WXUNUSED(show = true) ) { return false; }
2685
2686 void DoSizing()
2687 {
2688 if (!m_tabs)
2689 return;
2690
2691 m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2692 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2693 {
2694 m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
2695 m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
2696 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2697 }
2698 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2699 {
2700 m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2701 m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2702 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2703 }
2704 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2705 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2706
2707 m_tabs->Refresh();
2708 m_tabs->Update();
2709
2710 wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2711 size_t i, page_count = pages.GetCount();
2712
2713 for (i = 0; i < page_count; ++i)
2714 {
2715 wxAuiNotebookPage& page = pages.Item(i);
2716 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2717 {
2718 page.window->SetSize(m_rect.x, m_rect.y,
2719 m_rect.width, m_rect.height - m_tab_ctrl_height);
2720 }
2721 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2722 {
2723 page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
2724 m_rect.width, m_rect.height - m_tab_ctrl_height);
2725 }
2726 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2727 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2728
2729#if wxUSE_MDI
2730 if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2731 {
2732 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2733 wnd->ApplyMDIChildFrameRect();
2734 }
2735#endif
2736 }
2737 }
2738
2739protected:
2740 void DoGetSize(int* x, int* y) const
2741 {
2742 if (x)
2743 *x = m_rect.GetWidth();
2744 if (y)
2745 *y = m_rect.GetHeight();
2746 }
2747
2748public:
2749 void Update()
2750 {
2751 // does nothing
2752 }
2753
2754 wxRect m_rect;
2755 wxRect m_tab_rect;
2756 wxAuiTabCtrl* m_tabs;
2757 int m_tab_ctrl_height;
2758};
2759
2760
2761const int wxAuiBaseTabCtrlId = 5380;
2762
2763
2764// -- wxAuiNotebook class implementation --
2765
2766BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2767 EVT_SIZE(wxAuiNotebook::OnSize)
2768 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
2769 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2770 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2771 wxAuiNotebook::OnTabClicked)
2772 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2773 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2774 wxAuiNotebook::OnTabBeginDrag)
2775 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2776 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2777 wxAuiNotebook::OnTabEndDrag)
2778 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2779 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2780 wxAuiNotebook::OnTabDragMotion)
2781 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2782 wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2783 wxAuiNotebook::OnTabButton)
2784 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2785 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
2786 wxAuiNotebook::OnTabMiddleDown)
2787 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2788 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
2789 wxAuiNotebook::OnTabMiddleUp)
2790 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2791 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
2792 wxAuiNotebook::OnTabRightDown)
2793 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2794 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
2795 wxAuiNotebook::OnTabRightUp)
2796 EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2797 wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
2798 wxAuiNotebook::OnTabBgDClick)
2799 EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
2800
2801#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
2802 WX_EVENT_TABLE_CONTROL_CONTAINER(wxAuiNotebook)
2803#else
2804 // Avoid clash with container event handler functions
2805 EVT_SET_FOCUS(wxAuiNotebook::OnFocus)
2806#endif
2807END_EVENT_TABLE()
2808
2809WX_DELEGATE_TO_CONTROL_CONTAINER(wxAuiNotebook, wxControl)
2810
2811wxAuiNotebook::wxAuiNotebook()
2812{
2813 m_curpage = -1;
2814 m_tab_id_counter = wxAuiBaseTabCtrlId;
2815 m_dummy_wnd = NULL;
2816 m_tab_ctrl_height = 20;
2817 m_requested_bmp_size = wxDefaultSize;
2818 m_requested_tabctrl_height = -1;
2819}
2820
2821wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2822 wxWindowID id,
2823 const wxPoint& pos,
2824 const wxSize& size,
2825 long style) : wxControl(parent, id, pos, size, style)
2826{
2827 m_dummy_wnd = NULL;
2828 m_requested_bmp_size = wxDefaultSize;
2829 m_requested_tabctrl_height = -1;
2830 InitNotebook(style);
2831}
2832
2833bool wxAuiNotebook::Create(wxWindow* parent,
2834 wxWindowID id,
2835 const wxPoint& pos,
2836 const wxSize& size,
2837 long style)
2838{
2839 if (!wxControl::Create(parent, id, pos, size, style))
2840 return false;
2841
2842 InitNotebook(style);
2843
2844 return true;
2845}
2846
2847// InitNotebook() contains common initialization
2848// code called by all constructors
2849void wxAuiNotebook::InitNotebook(long style)
2850{
2851 WX_INIT_CONTROL_CONTAINER();
2852 // SetCanFocus(false);
2853
2854 SetName(wxT("wxAuiNotebook"));
2855 m_curpage = -1;
2856 m_tab_id_counter = wxAuiBaseTabCtrlId;
2857 m_dummy_wnd = NULL;
2858 m_flags = (unsigned int)style;
2859 m_tab_ctrl_height = 20;
2860
2861 m_normal_font = *wxNORMAL_FONT;
2862 m_selected_font = *wxNORMAL_FONT;
2863 m_selected_font.SetWeight(wxBOLD);
2864
2865 SetArtProvider(new wxAuiDefaultTabArt);
2866
2867 m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2868 m_dummy_wnd->SetSize(200, 200);
2869 m_dummy_wnd->Show(false);
2870
2871 m_mgr.SetManagedWindow(this);
2872 m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
2873 m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
2874
2875 m_mgr.AddPane(m_dummy_wnd,
2876 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2877
2878 m_mgr.Update();
2879}
2880
2881wxAuiNotebook::~wxAuiNotebook()
2882{
2883 // Indicate we're deleting pages
2884 m_isBeingDeleted = true;
2885
2886 while ( GetPageCount() > 0 )
2887 DeletePage(0);
2888
2889 m_mgr.UnInit();
2890}
2891
2892void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2893{
2894 m_tabs.SetArtProvider(art);
2895
2896 UpdateTabCtrlHeight();
2897}
2898
2899// SetTabCtrlHeight() is the highest-level override of the
2900// tab height. A call to this function effectively enforces a
2901// specified tab ctrl height, overriding all other considerations,
2902// such as text or bitmap height. It overrides any call to
2903// SetUniformBitmapSize(). Specifying a height of -1 reverts
2904// any previous call and returns to the default behavior
2905
2906void wxAuiNotebook::SetTabCtrlHeight(int height)
2907{
2908 m_requested_tabctrl_height = height;
2909
2910 // if window is already initialized, recalculate the tab height
2911 if (m_dummy_wnd)
2912 {
2913 UpdateTabCtrlHeight();
2914 }
2915}
2916
2917
2918// SetUniformBitmapSize() ensures that all tabs will have
2919// the same height, even if some tabs don't have bitmaps
2920// Passing wxDefaultSize to this function will instruct
2921// the control to use dynamic tab height-- so when a tab
2922// with a large bitmap is added, the tab ctrl's height will
2923// automatically increase to accommodate the bitmap
2924
2925void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2926{
2927 m_requested_bmp_size = size;
2928
2929 // if window is already initialized, recalculate the tab height
2930 if (m_dummy_wnd)
2931 {
2932 UpdateTabCtrlHeight();
2933 }
2934}
2935
2936// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2937// to be used interally
2938void wxAuiNotebook::UpdateTabCtrlHeight()
2939{
2940 // get the tab ctrl height we will use
2941 int height = CalculateTabCtrlHeight();
2942
2943 // if the tab control height needs to change, update
2944 // all of our tab controls with the new height
2945 if (m_tab_ctrl_height != height)
2946 {
2947 wxAuiTabArt* art = m_tabs.GetArtProvider();
2948
2949 m_tab_ctrl_height = height;
2950
2951 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2952 size_t i, pane_count = all_panes.GetCount();
2953 for (i = 0; i < pane_count; ++i)
2954 {
2955 wxAuiPaneInfo& pane = all_panes.Item(i);
2956 if (pane.name == wxT("dummy"))
2957 continue;
2958 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2959 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2960 tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2961 tabctrl->SetArtProvider(art->Clone());
2962 tab_frame->DoSizing();
2963 }
2964 }
2965}
2966
2967void wxAuiNotebook::UpdateHintWindowSize()
2968{
2969 wxSize size = CalculateNewSplitSize();
2970
2971 // the placeholder hint window should be set to this size
2972 wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2973 if (info.IsOk())
2974 {
2975 info.MinSize(size);
2976 info.BestSize(size);
2977 m_dummy_wnd->SetSize(size);
2978 }
2979}
2980
2981
2982// calculates the size of the new split
2983wxSize wxAuiNotebook::CalculateNewSplitSize()
2984{
2985 // count number of tab controls
2986 int tab_ctrl_count = 0;
2987 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2988 size_t i, pane_count = all_panes.GetCount();
2989 for (i = 0; i < pane_count; ++i)
2990 {
2991 wxAuiPaneInfo& pane = all_panes.Item(i);
2992 if (pane.name == wxT("dummy"))
2993 continue;
2994 tab_ctrl_count++;
2995 }
2996
2997 wxSize new_split_size;
2998
2999 // if there is only one tab control, the first split
3000 // should happen around the middle
3001 if (tab_ctrl_count < 2)
3002 {
3003 new_split_size = GetClientSize();
3004 new_split_size.x /= 2;
3005 new_split_size.y /= 2;
3006 }
3007 else
3008 {
3009 // this is in place of a more complicated calculation
3010 // that needs to be implemented
3011 new_split_size = wxSize(180,180);
3012 }
3013
3014 return new_split_size;
3015}
3016
3017int wxAuiNotebook::CalculateTabCtrlHeight()
3018{
3019 // if a fixed tab ctrl height is specified,
3020 // just return that instead of calculating a
3021 // tab height
3022 if (m_requested_tabctrl_height != -1)
3023 return m_requested_tabctrl_height;
3024
3025 // find out new best tab height
3026 wxAuiTabArt* art = m_tabs.GetArtProvider();
3027
3028 return art->GetBestTabCtrlSize(this,
3029 m_tabs.GetPages(),
3030 m_requested_bmp_size);
3031}
3032
3033
3034wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
3035{
3036 return m_tabs.GetArtProvider();
3037}
3038
3039void wxAuiNotebook::SetWindowStyleFlag(long style)
3040{
3041 wxControl::SetWindowStyleFlag(style);
3042
3043 m_flags = (unsigned int)style;
3044
3045 // if the control is already initialized
3046 if (m_mgr.GetManagedWindow() == (wxWindow*)this)
3047 {
3048 // let all of the tab children know about the new style
3049
3050 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3051 size_t i, pane_count = all_panes.GetCount();
3052 for (i = 0; i < pane_count; ++i)
3053 {
3054 wxAuiPaneInfo& pane = all_panes.Item(i);
3055 if (pane.name == wxT("dummy"))
3056 continue;
3057 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
3058 wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
3059 tabctrl->SetFlags(m_flags);
3060 tabframe->DoSizing();
3061 tabctrl->Refresh();
3062 tabctrl->Update();
3063 }
3064 }
3065}
3066
3067
3068bool wxAuiNotebook::AddPage(wxWindow* page,
3069 const wxString& caption,
3070 bool select,
3071 const wxBitmap& bitmap)
3072{
3073 return InsertPage(GetPageCount(), page, caption, select, bitmap);
3074}
3075
3076bool wxAuiNotebook::InsertPage(size_t page_idx,
3077 wxWindow* page,
3078 const wxString& caption,
3079 bool select,
3080 const wxBitmap& bitmap)
3081{
3082 wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
3083 if (!page)
3084 return false;
3085
3086 page->Reparent(this);
3087
3088 wxAuiNotebookPage info;
3089 info.window = page;
3090 info.caption = caption;
3091 info.bitmap = bitmap;
3092 info.active = false;
3093
3094 // if there are currently no tabs, the first added
3095 // tab must be active
3096 if (m_tabs.GetPageCount() == 0)
3097 info.active = true;
3098
3099 m_tabs.InsertPage(page, info, page_idx);
3100
3101 // if that was the first page added, even if
3102 // select is false, it must become the "current page"
3103 // (though no select events will be fired)
3104 if (!select && m_tabs.GetPageCount() == 1)
3105 select = true;
3106 //m_curpage = GetPageIndex(page);
3107
3108 wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3109 if (page_idx >= active_tabctrl->GetPageCount())
3110 active_tabctrl->AddPage(page, info);
3111 else
3112 active_tabctrl->InsertPage(page, info, page_idx);
3113
3114 UpdateTabCtrlHeight();
3115 DoSizing();
3116 active_tabctrl->DoShowHide();
3117
3118 // adjust selected index
3119 if(m_curpage >= (int) page_idx)
3120 m_curpage++;
3121
3122 if (select)
3123 {
3124 SetSelectionToWindow(page);
3125 }
3126
3127 return true;
3128}
3129
3130
3131// DeletePage() removes a tab from the multi-notebook,
3132// and destroys the window as well
3133bool wxAuiNotebook::DeletePage(size_t page_idx)
3134{
3135 if (page_idx >= m_tabs.GetPageCount())
3136 return false;
3137
3138 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3139
3140 // hide the window in advance, as this will
3141 // prevent flicker
3142 ShowWnd(wnd, false);
3143
3144 if (!RemovePage(page_idx))
3145 return false;
3146
3147#if wxUSE_MDI
3148 // actually destroy the window now
3149 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3150 {
3151 // delete the child frame with pending delete, as is
3152 // customary with frame windows
3153 if (!wxPendingDelete.Member(wnd))
3154 wxPendingDelete.Append(wnd);
3155 }
3156 else
3157#endif
3158 {
3159 wnd->Destroy();
3160 }
3161
3162 return true;
3163}
3164
3165
3166
3167// RemovePage() removes a tab from the multi-notebook,
3168// but does not destroy the window
3169bool wxAuiNotebook::RemovePage(size_t page_idx)
3170{
3171 // save active window pointer
3172 wxWindow* active_wnd = NULL;
3173 if (m_curpage >= 0)
3174 active_wnd = m_tabs.GetWindowFromIdx(m_curpage);
3175
3176 // save pointer of window being deleted
3177 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3178 wxWindow* new_active = NULL;
3179
3180 // make sure we found the page
3181 if (!wnd)
3182 return false;
3183
3184 // find out which onscreen tab ctrl owns this tab
3185 wxAuiTabCtrl* ctrl;
3186 int ctrl_idx;
3187 if (!FindTab(wnd, &ctrl, &ctrl_idx))
3188 return false;
3189
3190 bool is_curpage = (m_curpage == (int)page_idx);
3191 bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3192
3193
3194 // remove the tab from main catalog
3195 if (!m_tabs.RemovePage(wnd))
3196 return false;
3197
3198 // remove the tab from the onscreen tab ctrl
3199 ctrl->RemovePage(wnd);
3200
3201 if (is_active_in_split)
3202 {
3203 int ctrl_new_page_count = (int)ctrl->GetPageCount();
3204
3205 if (ctrl_idx >= ctrl_new_page_count)
3206 ctrl_idx = ctrl_new_page_count-1;
3207
3208 if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3209 {
3210 // set new page as active in the tab split
3211 ctrl->SetActivePage(ctrl_idx);
3212
3213 // if the page deleted was the current page for the
3214 // entire tab control, then record the window
3215 // pointer of the new active page for activation
3216 if (is_curpage)
3217 {
3218 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3219 }
3220 }
3221 }
3222 else
3223 {
3224 // we are not deleting the active page, so keep it the same
3225 new_active = active_wnd;
3226 }
3227
3228
3229 if (!new_active)
3230 {
3231 // we haven't yet found a new page to active,
3232 // so select the next page from the main tab
3233 // catalogue
3234
3235 if (page_idx < m_tabs.GetPageCount())
3236 {
3237 new_active = m_tabs.GetPage(page_idx).window;
3238 }
3239
3240 if (!new_active && m_tabs.GetPageCount() > 0)
3241 {
3242 new_active = m_tabs.GetPage(0).window;
3243 }
3244 }
3245
3246
3247 RemoveEmptyTabFrames();
3248
3249 // set new active pane
3250 if (new_active && !m_isBeingDeleted)
3251 {
3252 m_curpage = -1;
3253 SetSelectionToWindow(new_active);
3254 }
3255
3256 return true;
3257}
3258
3259// GetPageIndex() returns the index of the page, or -1 if the
3260// page could not be located in the notebook
3261int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3262{
3263 return m_tabs.GetIdxFromWindow(page_wnd);
3264}
3265
3266
3267
3268// SetPageText() changes the tab caption of the specified page
3269bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3270{
3271 if (page_idx >= m_tabs.GetPageCount())
3272 return false;
3273
3274 // update our own tab catalog
3275 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3276 page_info.caption = text;
3277
3278 // update what's on screen
3279 wxAuiTabCtrl* ctrl;
3280 int ctrl_idx;
3281 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3282 {
3283 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3284 info.caption = text;
3285 ctrl->Refresh();
3286 ctrl->Update();
3287 }
3288
3289 return true;
3290}
3291
3292// returns the page caption
3293wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3294{
3295 if (page_idx >= m_tabs.GetPageCount())
3296 return wxEmptyString;
3297
3298 // update our own tab catalog
3299 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3300 return page_info.caption;
3301}
3302
3303bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3304{
3305 if (page_idx >= m_tabs.GetPageCount())
3306 return false;
3307
3308 // update our own tab catalog
3309 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3310 page_info.bitmap = bitmap;
3311
3312 // tab height might have changed
3313 UpdateTabCtrlHeight();
3314
3315 // update what's on screen
3316 wxAuiTabCtrl* ctrl;
3317 int ctrl_idx;
3318 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3319 {
3320 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3321 info.bitmap = bitmap;
3322 ctrl->Refresh();
3323 ctrl->Update();
3324 }
3325
3326 return true;
3327}
3328
3329// returns the page bitmap
3330wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3331{
3332 if (page_idx >= m_tabs.GetPageCount())
3333 return wxBitmap();
3334
3335 // update our own tab catalog
3336 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3337 return page_info.bitmap;
3338}
3339
3340// GetSelection() returns the index of the currently active page
3341int wxAuiNotebook::GetSelection() const
3342{
3343 return m_curpage;
3344}
3345
3346// SetSelection() sets the currently active page
3347size_t wxAuiNotebook::SetSelection(size_t new_page)
3348{
3349 wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
3350 if (!wnd)
3351 return m_curpage;
3352
3353 // don't change the page unless necessary;
3354 // however, clicking again on a tab should give it the focus.
3355 if ((int)new_page == m_curpage)
3356 {
3357 wxAuiTabCtrl* ctrl;
3358 int ctrl_idx;
3359 if (FindTab(wnd, &ctrl, &ctrl_idx))
3360 {
3361 if (FindFocus() != ctrl)
3362 ctrl->SetFocus();
3363 }
3364 return m_curpage;
3365 }
3366
3367 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3368 evt.SetSelection(new_page);
3369 evt.SetOldSelection(m_curpage);
3370 evt.SetEventObject(this);
3371 if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
3372 {
3373 int old_curpage = m_curpage;
3374 m_curpage = new_page;
3375
3376 // program allows the page change
3377 evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3378 (void)GetEventHandler()->ProcessEvent(evt);
3379
3380
3381 wxAuiTabCtrl* ctrl;
3382 int ctrl_idx;
3383 if (FindTab(wnd, &ctrl, &ctrl_idx))
3384 {
3385 m_tabs.SetActivePage(wnd);
3386
3387 ctrl->SetActivePage(ctrl_idx);
3388 DoSizing();
3389 ctrl->DoShowHide();
3390
3391 ctrl->MakeTabVisible(ctrl_idx, ctrl);
3392
3393 // set fonts
3394 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3395 size_t i, pane_count = all_panes.GetCount();
3396 for (i = 0; i < pane_count; ++i)
3397 {
3398 wxAuiPaneInfo& pane = all_panes.Item(i);
3399 if (pane.name == wxT("dummy"))
3400 continue;
3401 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3402 if (tabctrl != ctrl)
3403 tabctrl->SetSelectedFont(m_normal_font);
3404 else
3405 tabctrl->SetSelectedFont(m_selected_font);
3406 tabctrl->Refresh();
3407 }
3408
3409 // Set the focus to the page if we're not currently focused on the tab.
3410 // This is Firefox-like behaviour.
3411 if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
3412 wnd->SetFocus();
3413
3414 return old_curpage;
3415 }
3416 }
3417
3418 return m_curpage;
3419}
3420
3421void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3422{
3423 const int idx = m_tabs.GetIdxFromWindow(win);
3424 wxCHECK_RET( idx != wxNOT_FOUND, _T("invalid notebook page") );
3425
3426 SetSelection(idx);
3427}
3428
3429// GetPageCount() returns the total number of
3430// pages managed by the multi-notebook
3431size_t wxAuiNotebook::GetPageCount() const
3432{
3433 return m_tabs.GetPageCount();
3434}
3435
3436// GetPage() returns the wxWindow pointer of the
3437// specified page
3438wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3439{
3440 wxASSERT(page_idx < m_tabs.GetPageCount());
3441
3442 return m_tabs.GetWindowFromIdx(page_idx);
3443}
3444
3445// DoSizing() performs all sizing operations in each tab control
3446void wxAuiNotebook::DoSizing()
3447{
3448 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3449 size_t i, pane_count = all_panes.GetCount();
3450 for (i = 0; i < pane_count; ++i)
3451 {
3452 if (all_panes.Item(i).name == wxT("dummy"))
3453 continue;
3454
3455 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3456 tabframe->DoSizing();
3457 }
3458}
3459
3460// GetActiveTabCtrl() returns the active tab control. It is
3461// called to determine which control gets new windows being added
3462wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3463{
3464 if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
3465 {
3466 wxAuiTabCtrl* ctrl;
3467 int idx;
3468
3469 // find the tab ctrl with the current page
3470 if (FindTab(m_tabs.GetPage(m_curpage).window,
3471 &ctrl, &idx))
3472 {
3473 return ctrl;
3474 }
3475 }
3476
3477 // no current page, just find the first tab ctrl
3478 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3479 size_t i, pane_count = all_panes.GetCount();
3480 for (i = 0; i < pane_count; ++i)
3481 {
3482 if (all_panes.Item(i).name == wxT("dummy"))
3483 continue;
3484
3485 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3486 return tabframe->m_tabs;
3487 }
3488
3489 // If there is no tabframe at all, create one
3490 wxTabFrame* tabframe = new wxTabFrame;
3491 tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
3492 tabframe->m_tabs = new wxAuiTabCtrl(this,
3493 m_tab_id_counter++,
3494 wxDefaultPosition,
3495 wxDefaultSize,
3496 wxNO_BORDER|wxWANTS_CHARS);
3497 tabframe->m_tabs->SetFlags(m_flags);
3498 tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3499 m_mgr.AddPane(tabframe,
3500 wxAuiPaneInfo().Center().CaptionVisible(false));
3501
3502 m_mgr.Update();
3503
3504 return tabframe->m_tabs;
3505}
3506
3507// FindTab() finds the tab control that currently contains the window as well
3508// as the index of the window in the tab control. It returns true if the
3509// window was found, otherwise false.
3510bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3511{
3512 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3513 size_t i, pane_count = all_panes.GetCount();
3514 for (i = 0; i < pane_count; ++i)
3515 {
3516 if (all_panes.Item(i).name == wxT("dummy"))
3517 continue;
3518
3519 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3520
3521 int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3522 if (page_idx != -1)
3523 {
3524 *ctrl = tabframe->m_tabs;
3525 *idx = page_idx;
3526 return true;
3527 }
3528 }
3529
3530 return false;
3531}
3532
3533void wxAuiNotebook::Split(size_t page, int direction)
3534{
3535 wxSize cli_size = GetClientSize();
3536
3537 // get the page's window pointer
3538 wxWindow* wnd = GetPage(page);
3539 if (!wnd)
3540 return;
3541
3542 // notebooks with 1 or less pages can't be split
3543 if (GetPageCount() < 2)
3544 return;
3545
3546 // find out which tab control the page currently belongs to
3547 wxAuiTabCtrl *src_tabs, *dest_tabs;
3548 int src_idx = -1;
3549 src_tabs = NULL;
3550 if (!FindTab(wnd, &src_tabs, &src_idx))
3551 return;
3552 if (!src_tabs || src_idx == -1)
3553 return;
3554
3555 // choose a split size
3556 wxSize split_size;
3557 if (GetPageCount() > 2)
3558 {
3559 split_size = CalculateNewSplitSize();
3560 }
3561 else
3562 {
3563 // because there are two panes, always split them
3564 // equally
3565 split_size = GetClientSize();
3566 split_size.x /= 2;
3567 split_size.y /= 2;
3568 }
3569
3570
3571 // create a new tab frame
3572 wxTabFrame* new_tabs = new wxTabFrame;
3573 new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3574 new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3575 new_tabs->m_tabs = new wxAuiTabCtrl(this,
3576 m_tab_id_counter++,
3577 wxDefaultPosition,
3578 wxDefaultSize,
3579 wxNO_BORDER|wxWANTS_CHARS);
3580 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3581 new_tabs->m_tabs->SetFlags(m_flags);
3582 dest_tabs = new_tabs->m_tabs;
3583
3584 // create a pane info structure with the information
3585 // about where the pane should be added
3586 wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3587 wxPoint mouse_pt;
3588
3589 if (direction == wxLEFT)
3590 {
3591 pane_info.Left();
3592 mouse_pt = wxPoint(0, cli_size.y/2);
3593 }
3594 else if (direction == wxRIGHT)
3595 {
3596 pane_info.Right();
3597 mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3598 }
3599 else if (direction == wxTOP)
3600 {
3601 pane_info.Top();
3602 mouse_pt = wxPoint(cli_size.x/2, 0);
3603 }
3604 else if (direction == wxBOTTOM)
3605 {
3606 pane_info.Bottom();
3607 mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3608 }
3609
3610 m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
3611 m_mgr.Update();
3612
3613 // remove the page from the source tabs
3614 wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3615 page_info.active = false;
3616 src_tabs->RemovePage(page_info.window);
3617 if (src_tabs->GetPageCount() > 0)
3618 {
3619 src_tabs->SetActivePage((size_t)0);
3620 src_tabs->DoShowHide();
3621 src_tabs->Refresh();
3622 }
3623
3624
3625 // add the page to the destination tabs
3626 dest_tabs->InsertPage(page_info.window, page_info, 0);
3627
3628 if (src_tabs->GetPageCount() == 0)
3629 {
3630 RemoveEmptyTabFrames();
3631 }
3632
3633 DoSizing();
3634 dest_tabs->DoShowHide();
3635 dest_tabs->Refresh();
3636
3637 // force the set selection function reset the selection
3638 m_curpage = -1;
3639
3640 // set the active page to the one we just split off
3641 SetSelectionToPage(page_info);
3642
3643 UpdateHintWindowSize();
3644}
3645
3646
3647void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3648{
3649 UpdateHintWindowSize();
3650
3651 evt.Skip();
3652}
3653
3654void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
3655{
3656 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3657
3658 wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3659 wxASSERT(ctrl != NULL);
3660
3661 wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3662 wxASSERT(wnd != NULL);
3663
3664 SetSelectionToWindow(wnd);
3665}
3666
3667void wxAuiNotebook::OnTabBgDClick(wxCommandEvent& WXUNUSED(evt))
3668{
3669 // notify owner that the tabbar background has been double-clicked
3670 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
3671 e.SetEventObject(this);
3672 GetEventHandler()->ProcessEvent(e);
3673}
3674
3675void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
3676{
3677 m_last_drag_x = 0;
3678}
3679
3680void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
3681{
3682 wxPoint screen_pt = ::wxGetMousePosition();
3683 wxPoint client_pt = ScreenToClient(screen_pt);
3684 wxPoint zero(0,0);
3685
3686 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3687 wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3688
3689 if (dest_tabs == src_tabs)
3690 {
3691 if (src_tabs)
3692 {
3693 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3694 }
3695
3696 // always hide the hint for inner-tabctrl drag
3697 m_mgr.HideHint();
3698
3699 // if tab moving is not allowed, leave
3700 if (!(m_flags & wxAUI_NB_TAB_MOVE))
3701 {
3702 return;
3703 }
3704
3705 wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3706 wxWindow* dest_location_tab;
3707
3708 // this is an inner-tab drag/reposition
3709 if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3710 {
3711 int src_idx = evt.GetSelection();
3712 int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3713
3714 // prevent jumpy drag
3715 if ((src_idx == dest_idx) || dest_idx == -1 ||
3716 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3717 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3718 {
3719 m_last_drag_x = pt.x;
3720 return;
3721 }
3722
3723
3724 wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3725 dest_tabs->MovePage(src_tab, dest_idx);
3726 dest_tabs->SetActivePage((size_t)dest_idx);
3727 dest_tabs->DoShowHide();
3728 dest_tabs->Refresh();
3729 m_last_drag_x = pt.x;
3730
3731 }
3732
3733 return;
3734 }
3735
3736
3737 // if external drag is allowed, check if the tab is being dragged
3738 // over a different wxAuiNotebook control
3739 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3740 {
3741 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3742
3743 // if we aren't over any window, stop here
3744 if (!tab_ctrl)
3745 return;
3746
3747 // make sure we are not over the hint window
3748 if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3749 {
3750 while (tab_ctrl)
3751 {
3752 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3753 break;
3754 tab_ctrl = tab_ctrl->GetParent();
3755 }
3756
3757 if (tab_ctrl)
3758 {
3759 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3760
3761 if (nb != this)
3762 {
3763 wxRect hint_rect = tab_ctrl->GetClientRect();
3764 tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3765 m_mgr.ShowHint(hint_rect);
3766 return;
3767 }
3768 }
3769 }
3770 else
3771 {
3772 if (!dest_tabs)
3773 {
3774 // we are either over a hint window, or not over a tab
3775 // window, and there is no where to drag to, so exit
3776 return;
3777 }
3778 }
3779 }
3780
3781
3782 // if there are less than two panes, split can't happen, so leave
3783 if (m_tabs.GetPageCount() < 2)
3784 return;
3785
3786 // if tab moving is not allowed, leave
3787 if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3788 return;
3789
3790
3791 if (src_tabs)
3792 {
3793 src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3794 }
3795
3796
3797 if (dest_tabs)
3798 {
3799 wxRect hint_rect = dest_tabs->GetRect();
3800 ClientToScreen(&hint_rect.x, &hint_rect.y);
3801 m_mgr.ShowHint(hint_rect);
3802 }
3803 else
3804 {
3805 m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3806 }
3807}
3808
3809
3810
3811void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3812{
3813 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3814
3815 m_mgr.HideHint();
3816
3817
3818 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3819 wxCHECK_RET( src_tabs, _T("no source object?") );
3820
3821 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3822
3823 // get the mouse position, which will be used to determine the drop point
3824 wxPoint mouse_screen_pt = ::wxGetMousePosition();
3825 wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3826
3827
3828
3829 // check for an external move
3830 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3831 {
3832 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3833
3834 while (tab_ctrl)
3835 {
3836 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3837 break;
3838 tab_ctrl = tab_ctrl->GetParent();
3839 }
3840
3841 if (tab_ctrl)
3842 {
3843 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3844
3845 if (nb != this)
3846 {
3847 // find out from the destination control
3848 // if it's ok to drop this tab here
3849 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3850 e.SetSelection(evt.GetSelection());
3851 e.SetOldSelection(evt.GetSelection());
3852 e.SetEventObject(this);
3853 e.SetDragSource(this);
3854 e.Veto(); // dropping must be explicitly approved by control owner
3855
3856 nb->GetEventHandler()->ProcessEvent(e);
3857
3858 if (!e.IsAllowed())
3859 {
3860 // no answer or negative answer
3861 m_mgr.HideHint();
3862 return;
3863 }
3864
3865 // drop was allowed
3866 int src_idx = evt.GetSelection();
3867 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3868
3869 // Check that it's not an impossible parent relationship
3870 wxWindow* p = nb;
3871 while (p && !p->IsTopLevel())
3872 {
3873 if (p == src_page)
3874 {
3875 return;
3876 }
3877 p = p->GetParent();
3878 }
3879
3880 // get main index of the page
3881 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3882 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no source page?") );
3883
3884
3885 // make a copy of the page info
3886 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3887
3888 // remove the page from the source notebook
3889 RemovePage(main_idx);
3890
3891 // reparent the page
3892 src_page->Reparent(nb);
3893
3894
3895 // found out the insert idx
3896 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3897 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3898
3899 wxWindow* target = NULL;
3900 int insert_idx = -1;
3901 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3902 if (target)
3903 {
3904 insert_idx = dest_tabs->GetIdxFromWindow(target);
3905 }
3906
3907
3908 // add the page to the new notebook
3909 if (insert_idx == -1)
3910 insert_idx = dest_tabs->GetPageCount();
3911 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3912 nb->m_tabs.AddPage(page_info.window, page_info);
3913
3914 nb->DoSizing();
3915 dest_tabs->DoShowHide();
3916 dest_tabs->Refresh();
3917
3918 // set the selection in the destination tab control
3919 nb->SetSelectionToPage(page_info);
3920
3921 // notify owner that the tab has been dragged
3922 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
3923 e2.SetSelection(evt.GetSelection());
3924 e2.SetOldSelection(evt.GetSelection());
3925 e2.SetEventObject(this);
3926 GetEventHandler()->ProcessEvent(e2);
3927
3928 return;
3929 }
3930 }
3931 }
3932
3933
3934
3935
3936 // only perform a tab split if it's allowed
3937 wxAuiTabCtrl* dest_tabs = NULL;
3938
3939 if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3940 {
3941 // If the pointer is in an existing tab frame, do a tab insert
3942 wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3943 wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3944 int insert_idx = -1;
3945 if (tab_frame)
3946 {
3947 dest_tabs = tab_frame->m_tabs;
3948
3949 if (dest_tabs == src_tabs)
3950 return;
3951
3952
3953 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3954 wxWindow* target = NULL;
3955 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3956 if (target)
3957 {
3958 insert_idx = dest_tabs->GetIdxFromWindow(target);
3959 }
3960 }
3961 else
3962 {
3963 wxPoint zero(0,0);
3964 wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3965 mouse_client_pt,
3966 zero);
3967 if (rect.IsEmpty())
3968 {
3969 // there is no suitable drop location here, exit out
3970 return;
3971 }
3972
3973 // If there is no tabframe at all, create one
3974 wxTabFrame* new_tabs = new wxTabFrame;
3975 new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3976 new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3977 new_tabs->m_tabs = new wxAuiTabCtrl(this,
3978 m_tab_id_counter++,
3979 wxDefaultPosition,
3980 wxDefaultSize,
3981 wxNO_BORDER|wxWANTS_CHARS);
3982 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3983 new_tabs->m_tabs->SetFlags(m_flags);
3984
3985 m_mgr.AddPane(new_tabs,
3986 wxAuiPaneInfo().Bottom().CaptionVisible(false),
3987 mouse_client_pt);
3988 m_mgr.Update();
3989 dest_tabs = new_tabs->m_tabs;
3990 }
3991
3992
3993
3994 // remove the page from the source tabs
3995 wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3996 page_info.active = false;
3997 src_tabs->RemovePage(page_info.window);
3998 if (src_tabs->GetPageCount() > 0)
3999 {
4000 src_tabs->SetActivePage((size_t)0);
4001 src_tabs->DoShowHide();
4002 src_tabs->Refresh();
4003 }
4004
4005
4006
4007 // add the page to the destination tabs
4008 if (insert_idx == -1)
4009 insert_idx = dest_tabs->GetPageCount();
4010 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
4011
4012 if (src_tabs->GetPageCount() == 0)
4013 {
4014 RemoveEmptyTabFrames();
4015 }
4016
4017 DoSizing();
4018 dest_tabs->DoShowHide();
4019 dest_tabs->Refresh();
4020
4021 // force the set selection function reset the selection
4022 m_curpage = -1;
4023
4024 // set the active page to the one we just split off
4025 SetSelectionToPage(page_info);
4026
4027 UpdateHintWindowSize();
4028 }
4029
4030 // notify owner that the tab has been dragged
4031 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
4032 e.SetSelection(evt.GetSelection());
4033 e.SetOldSelection(evt.GetSelection());
4034 e.SetEventObject(this);
4035 GetEventHandler()->ProcessEvent(e);
4036}
4037
4038
4039
4040wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
4041{
4042 // if we've just removed the last tab from the source
4043 // tab set, the remove the tab control completely
4044 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4045 size_t i, pane_count = all_panes.GetCount();
4046 for (i = 0; i < pane_count; ++i)
4047 {
4048 if (all_panes.Item(i).name == wxT("dummy"))
4049 continue;
4050
4051 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4052 if (tabframe->m_tab_rect.Contains(pt))
4053 return tabframe->m_tabs;
4054 }
4055
4056 return NULL;
4057}
4058
4059wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
4060{
4061 // if we've just removed the last tab from the source
4062 // tab set, the remove the tab control completely
4063 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4064 size_t i, pane_count = all_panes.GetCount();
4065 for (i = 0; i < pane_count; ++i)
4066 {
4067 if (all_panes.Item(i).name == wxT("dummy"))
4068 continue;
4069
4070 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4071 if (tabframe->m_tabs == tab_ctrl)
4072 {
4073 return tabframe;
4074 }
4075 }
4076
4077 return NULL;
4078}
4079
4080void wxAuiNotebook::RemoveEmptyTabFrames()
4081{
4082 // if we've just removed the last tab from the source
4083 // tab set, the remove the tab control completely
4084 wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
4085 size_t i, pane_count = all_panes.GetCount();
4086 for (i = 0; i < pane_count; ++i)
4087 {
4088 if (all_panes.Item(i).name == wxT("dummy"))
4089 continue;
4090
4091 wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
4092 if (tab_frame->m_tabs->GetPageCount() == 0)
4093 {
4094 m_mgr.DetachPane(tab_frame);
4095
4096 // use pending delete because sometimes during
4097 // window closing, refreshs are pending
4098 if (!wxPendingDelete.Member(tab_frame->m_tabs))
4099 wxPendingDelete.Append(tab_frame->m_tabs);
4100
4101 tab_frame->m_tabs = NULL;
4102
4103 delete tab_frame;
4104 }
4105 }
4106
4107
4108 // check to see if there is still a center pane;
4109 // if there isn't, make a frame the center pane
4110 wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
4111 pane_count = panes.GetCount();
4112 wxWindow* first_good = NULL;
4113 bool center_found = false;
4114 for (i = 0; i < pane_count; ++i)
4115 {
4116 if (panes.Item(i).name == wxT("dummy"))
4117 continue;
4118 if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
4119 center_found = true;
4120 if (!first_good)
4121 first_good = panes.Item(i).window;
4122 }
4123
4124 if (!center_found && first_good)
4125 {
4126 m_mgr.GetPane(first_good).Centre();
4127 }
4128
4129 if (!m_isBeingDeleted)
4130 m_mgr.Update();
4131}
4132
4133void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
4134{
4135 // if we're dragging a tab, don't change the current selection.
4136 // This code prevents a bug that used to happen when the hint window
4137 // was hidden. In the bug, the focus would return to the notebook
4138 // child, which would then enter this handler and call
4139 // SetSelection, which is not desired turn tab dragging.
4140
4141 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4142 size_t i, pane_count = all_panes.GetCount();
4143 for (i = 0; i < pane_count; ++i)
4144 {
4145 wxAuiPaneInfo& pane = all_panes.Item(i);
4146 if (pane.name == wxT("dummy"))
4147 continue;
4148 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4149 if (tabframe->m_tabs->IsDragging())
4150 return;
4151 }
4152
4153
4154 // change the tab selection to the child
4155 // which was focused
4156 int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4157 if (idx != -1 && idx != m_curpage)
4158 {
4159 SetSelection(idx);
4160 }
4161}
4162
4163void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
4164{
4165 if ( event.IsWindowChange() ) {
4166 // change pages
4167 // FIXME: the problem with this is that if we have a split notebook,
4168 // we selection may go all over the place.
4169 AdvanceSelection(event.GetDirection());
4170 }
4171 else {
4172 // we get this event in 3 cases
4173 //
4174 // a) one of our pages might have generated it because the user TABbed
4175 // out from it in which case we should propagate the event upwards and
4176 // our parent will take care of setting the focus to prev/next sibling
4177 //
4178 // or
4179 //
4180 // b) the parent panel wants to give the focus to us so that we
4181 // forward it to our selected page. We can't deal with this in
4182 // OnSetFocus() because we don't know which direction the focus came
4183 // from in this case and so can't choose between setting the focus to
4184 // first or last panel child
4185 //
4186 // or
4187 //
4188 // c) we ourselves (see MSWTranslateMessage) generated the event
4189 //
4190 wxWindow * const parent = GetParent();
4191
4192 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4193 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4194 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4195
4196 if ( isFromParent || isFromSelf )
4197 {
4198 // no, it doesn't come from child, case (b) or (c): forward to a
4199 // page but only if direction is backwards (TAB) or from ourselves,
4200 if ( GetSelection() != wxNOT_FOUND &&
4201 (!event.GetDirection() || isFromSelf) )
4202 {
4203 // so that the page knows that the event comes from it's parent
4204 // and is being propagated downwards
4205 event.SetEventObject(this);
4206
4207 wxWindow *page = GetPage(GetSelection());
4208 if ( !page->GetEventHandler()->ProcessEvent(event) )
4209 {
4210 page->SetFocus();
4211 }
4212 //else: page manages focus inside it itself
4213 }
4214 else // otherwise set the focus to the notebook itself
4215 {
4216 SetFocus();
4217 }
4218 }
4219 else
4220 {
4221 // it comes from our child, case (a), pass to the parent, but only
4222 // if the direction is forwards. Otherwise set the focus to the
4223 // notebook itself. The notebook is always the 'first' control of a
4224 // page.
4225 if ( !event.GetDirection() )
4226 {
4227 SetFocus();
4228 }
4229 else if ( parent )
4230 {
4231 event.SetCurrentFocus(this);
4232 parent->GetEventHandler()->ProcessEvent(event);
4233 }
4234 }
4235 }
4236}
4237
4238void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
4239{
4240 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
4241 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4242
4243 int button_id = evt.GetInt();
4244
4245 if (button_id == wxAUI_BUTTON_CLOSE)
4246 {
4247 int selection = evt.GetSelection();
4248
4249 if (selection == -1)
4250 {
4251 // if the close button is to the right, use the active
4252 // page selection to determine which page to close
4253 selection = GetSelection();
4254 }
4255
4256 if (selection != -1)
4257 {
4258 wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4259
4260 // ask owner if it's ok to close the tab
4261 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4262 e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4263 const int idx = m_tabs.GetIdxFromWindow(close_wnd);
4264 e.SetSelection(idx);
4265 e.SetOldSelection(evt.GetSelection());
4266 e.SetEventObject(this);
4267 GetEventHandler()->ProcessEvent(e);
4268 if (!e.IsAllowed())
4269 return;
4270
4271
4272#if wxUSE_MDI
4273 if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4274 {
4275 close_wnd->Close();
4276 }
4277 else
4278#endif
4279 {
4280 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4281 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no page to delete?") );
4282
4283 DeletePage(main_idx);
4284 }
4285
4286 // notify owner that the tab has been closed
4287 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
4288 e2.SetSelection(idx);
4289 e2.SetEventObject(this);
4290 GetEventHandler()->ProcessEvent(e2);
4291 }
4292 }
4293}
4294
4295
4296void wxAuiNotebook::OnTabMiddleDown(wxCommandEvent& evt)
4297{
4298 // patch event through to owner
4299 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4300 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4301
4302 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4303 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4304 e.SetEventObject(this);
4305 GetEventHandler()->ProcessEvent(e);
4306}
4307
4308void wxAuiNotebook::OnTabMiddleUp(wxCommandEvent& evt)
4309{
4310 // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4311 // click should act like a tab close action. However, first
4312 // give the owner an opportunity to handle the middle up event
4313 // for custom action
4314
4315 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4316 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4317
4318 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4319 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4320 e.SetEventObject(this);
4321 if (GetEventHandler()->ProcessEvent(e))
4322 return;
4323 if (!e.IsAllowed())
4324 return;
4325
4326 // check if we are supposed to close on middle-up
4327 if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4328 return;
4329
4330 // simulate the user pressing the close button on the tab
4331 evt.SetInt(wxAUI_BUTTON_CLOSE);
4332 OnTabButton(evt);
4333}
4334
4335void wxAuiNotebook::OnTabRightDown(wxCommandEvent& evt)
4336{
4337 // patch event through to owner
4338 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4339 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4340
4341 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4342 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4343 e.SetEventObject(this);
4344 GetEventHandler()->ProcessEvent(e);
4345}
4346
4347void wxAuiNotebook::OnTabRightUp(wxCommandEvent& evt)
4348{
4349 // patch event through to owner
4350 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4351 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4352
4353 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4354 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4355 e.SetEventObject(this);
4356 GetEventHandler()->ProcessEvent(e);
4357}
4358
4359// Sets the normal font
4360void wxAuiNotebook::SetNormalFont(const wxFont& font)
4361{
4362 m_normal_font = font;
4363 GetArtProvider()->SetNormalFont(font);
4364}
4365
4366// Sets the selected tab font
4367void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4368{
4369 m_selected_font = font;
4370 GetArtProvider()->SetSelectedFont(font);
4371}
4372
4373// Sets the measuring font
4374void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4375{
4376 GetArtProvider()->SetMeasuringFont(font);
4377}
4378
4379// Sets the tab font
4380bool wxAuiNotebook::SetFont(const wxFont& font)
4381{
4382 wxControl::SetFont(font);
4383
4384 wxFont normalFont(font);
4385 wxFont selectedFont(normalFont);
4386 selectedFont.SetWeight(wxBOLD);
4387
4388 SetNormalFont(normalFont);
4389 SetSelectedFont(selectedFont);
4390 SetMeasuringFont(selectedFont);
4391
4392 return true;
4393}
4394
4395// Gets the tab control height
4396int wxAuiNotebook::GetTabCtrlHeight() const
4397{
4398 return m_tab_ctrl_height;
4399}
4400
4401// Gets the height of the notebook for a given page height
4402int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4403{
4404 UpdateTabCtrlHeight();
4405
4406 int tabCtrlHeight = GetTabCtrlHeight();
4407 int decorHeight = 2;
4408 return tabCtrlHeight + pageHeight + decorHeight;
4409}
4410
4411// Advances the selection, generation page selection events
4412void wxAuiNotebook::AdvanceSelection(bool forward)
4413{
4414 if (GetPageCount() <= 1)
4415 return;
4416
4417 int currentSelection = GetSelection();
4418
4419 if (forward)
4420 {
4421 if (currentSelection == (int) (GetPageCount() - 1))
4422 return;
4423 else if (currentSelection == -1)
4424 currentSelection = 0;
4425 else
4426 currentSelection ++;
4427 }
4428 else
4429 {
4430 if (currentSelection <= 0)
4431 return;
4432 else
4433 currentSelection --;
4434 }
4435
4436 SetSelection(currentSelection);
4437}
4438
4439// Shows the window menu
4440bool wxAuiNotebook::ShowWindowMenu()
4441{
4442 wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4443
4444 int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4445
4446 if (idx != -1)
4447 {
4448 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4449 e.SetSelection(idx);
4450 e.SetOldSelection(tabCtrl->GetActivePage());
4451 e.SetEventObject(tabCtrl);
4452 GetEventHandler()->ProcessEvent(e);
4453
4454 return true;
4455 }
4456 else
4457 return false;
4458}
4459
4460#endif // wxUSE_AUI
wxWidgets (Impactor)