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