1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/auibook.cpp
3 // Purpose: wxaui: wx advanced user interface - notebook
4 // Author: Benjamin I. Williams
7 // Copyright: (C) Copyright 2006, Kirix Corporation, All Rights Reserved
8 // Licence: wxWindows Library Licence, Version 3.1
9 ///////////////////////////////////////////////////////////////////////////////
11 // ----------------------------------------------------------------------------
13 // ----------------------------------------------------------------------------
15 #include "wx/wxprec.h"
23 #include "wx/aui/auibook.h"
26 #include "wx/settings.h"
30 #include "wx/aui/tabmdi.h"
31 #include "wx/dcbuffer.h"
34 #include "wx/arrimpl.cpp"
35 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray
)
36 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray
)
38 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE
)
39 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
)
40 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED
)
41 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BUTTON
)
42 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
)
43 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
)
44 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
)
45 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND
)
48 IMPLEMENT_CLASS(wxAuiNotebook
, wxControl
)
49 IMPLEMENT_CLASS(wxAuiTabCtrl
, wxControl
)
50 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent
, wxEvent
)
56 // This functions are here for this proof of concept
57 // and will be factored out later. See dockart.cpp
58 static wxColor
StepColour(const wxColor
& c
, int percent
)
60 int r
= c
.Red(), g
= c
.Green(), b
= c
.Blue();
61 return wxColour((unsigned char)wxMin((r
*percent
)/100,255),
62 (unsigned char)wxMin((g
*percent
)/100,255),
63 (unsigned char)wxMin((b
*percent
)/100,255));
66 // This functions are here for this proof of concept
67 // and will be factored out later. See dockart.cpp
68 static wxBitmap
BitmapFromBits(const unsigned char bits
[], int w
, int h
,
69 const wxColour
& color
)
71 wxImage img
= wxBitmap((const char*)bits
, w
, h
).ConvertToImage();
72 img
.Replace(0,0,0,123,123,123);
73 img
.Replace(255,255,255,color
.Red(),color
.Green(),color
.Blue());
74 img
.SetMaskColour(123,123,123);
78 static void DrawButtons(wxDC
& dc
,
81 const wxColour
& bkcolour
,
86 if (button_state
== wxAUI_BUTTON_STATE_PRESSED
)
92 if (button_state
== wxAUI_BUTTON_STATE_HOVER
||
93 button_state
== wxAUI_BUTTON_STATE_PRESSED
)
95 dc
.SetBrush(wxBrush(StepColour(bkcolour
, 120)));
96 dc
.SetPen(wxPen(StepColour(bkcolour
, 70)));
98 // draw the background behind the button
99 dc
.DrawRectangle(rect
.x
, rect
.y
, 15, 15);
102 // draw the button itself
103 dc
.DrawBitmap(bmp
, rect
.x
, rect
.y
, true);
106 static void IndentPressedBitmap(wxRect
* rect
, int button_state
)
108 if (button_state
== wxAUI_BUTTON_STATE_PRESSED
)
115 // chops the text so that it fits within |max_size| pixels.
116 // Also adds an elipsis if necessary
118 static wxString
ChopText(wxDC
& dc
, const wxString
& text
, int max_size
)
122 // first check if the text fits with no problems
123 dc
.GetTextExtent(text
, &x
, &y
);
127 size_t i
, len
= text
.Length();
128 size_t last_good_length
= 0;
129 for (i
= 0; i
< len
; ++i
)
131 wxString s
= text
.Left(i
);
134 dc
.GetTextExtent(s
, &x
, &y
);
138 last_good_length
= i
;
141 wxString ret
= text
.Left(last_good_length
);
147 // -- GUI helper classes and functions --
149 class wxAuiCommandCapture
: public wxEvtHandler
153 wxAuiCommandCapture() { m_last_id
= 0; }
154 int GetCommandId() const { return m_last_id
; }
156 bool ProcessEvent(wxEvent
& evt
)
158 if (evt
.GetEventType() == wxEVT_COMMAND_MENU_SELECTED
)
160 m_last_id
= evt
.GetId();
164 if (GetNextHandler())
165 return GetNextHandler()->ProcessEvent(evt
);
177 #if defined( __WXMAC__ )
178 static unsigned char close_bits
[]={
179 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
180 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
181 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
182 #elif defined( __WXGTK__)
183 static unsigned char close_bits
[]={
184 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
185 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
186 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
188 static unsigned char close_bits
[]={
189 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
190 0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
191 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
194 static unsigned char left_bits
[] = {
195 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
196 0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
197 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
199 static unsigned char right_bits
[] = {
200 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
201 0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
202 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
204 static unsigned char list_bits
[] = {
205 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
206 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
207 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
214 // -- wxAuiDefaultTabArt class implementation --
216 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
218 m_normal_font
= *wxNORMAL_FONT
;
219 m_selected_font
= *wxNORMAL_FONT
;
220 m_selected_font
.SetWeight(wxBOLD
);
221 m_measuring_font
= m_selected_font
;
223 m_fixed_tab_width
= 100;
225 wxColour base_colour
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
227 wxColour background_colour
= base_colour
;
228 wxColour normaltab_colour
= base_colour
;
229 wxColour selectedtab_colour
= base_colour
;
231 m_bkbrush
= wxBrush(background_colour
);
232 m_normal_bkbrush
= wxBrush(normaltab_colour
);
233 m_normal_bkpen
= wxPen(normaltab_colour
);
234 m_selected_bkbrush
= wxBrush(selectedtab_colour
);
235 m_selected_bkpen
= wxPen(selectedtab_colour
);
238 m_active_close_bmp
= BitmapFromBits(close_bits
, 16, 16, *wxBLACK
);
239 m_disabled_close_bmp
= BitmapFromBits(close_bits
, 16, 16, wxColour(128,128,128));
241 m_active_left_bmp
= BitmapFromBits(left_bits
, 16, 16, *wxBLACK
);
242 m_disabled_left_bmp
= BitmapFromBits(left_bits
, 16, 16, wxColour(128,128,128));
244 m_active_right_bmp
= BitmapFromBits(right_bits
, 16, 16, *wxBLACK
);
245 m_disabled_right_bmp
= BitmapFromBits(right_bits
, 16, 16, wxColour(128,128,128));
247 m_active_windowlist_bmp
= BitmapFromBits(list_bits
, 16, 16, *wxBLACK
);
248 m_disabled_windowlist_bmp
= BitmapFromBits(list_bits
, 16, 16, wxColour(128,128,128));
253 wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
257 wxAuiTabArt
* wxAuiDefaultTabArt::Clone()
259 return static_cast<wxAuiTabArt
*>(new wxAuiDefaultTabArt
);
262 void wxAuiDefaultTabArt::SetFlags(unsigned int flags
)
267 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize
& tab_ctrl_size
,
270 m_fixed_tab_width
= 100;
272 int tot_width
= (int)tab_ctrl_size
.x
- GetIndentSize() - 4;
275 m_fixed_tab_width
= tot_width
/(int)tab_count
;
279 if (m_fixed_tab_width
< 100)
280 m_fixed_tab_width
= 100;
282 if (m_fixed_tab_width
> tot_width
/2)
283 m_fixed_tab_width
= tot_width
/2;
285 if (m_fixed_tab_width
> 220)
286 m_fixed_tab_width
= 220;
290 void wxAuiDefaultTabArt::DrawBackground(wxDC
& dc
,
291 wxWindow
* WXUNUSED(wnd
),
295 dc
.SetBrush(m_bkbrush
);
296 dc
.SetPen(*wxTRANSPARENT_PEN
);
297 dc
.DrawRectangle(-1, -1, rect
.GetWidth()+2, rect
.GetHeight()+2);
300 dc
.SetPen(*wxGREY_PEN
);
301 dc
.DrawLine(0, rect
.GetHeight()-4, rect
.GetWidth(), rect
.GetHeight()-4);
302 dc
.DrawLine(0, rect
.GetHeight()-1, rect
.GetWidth(), rect
.GetHeight()-1);
306 // DrawTab() draws an individual tab.
309 // in_rect - rectangle the tab should be confined to
310 // caption - tab's caption
311 // active - whether or not the tab is active
312 // out_rect - actual output rectangle
313 // x_extent - the advance x; where the next tab should start
315 void wxAuiDefaultTabArt::DrawTab(wxDC
& dc
,
317 const wxRect
& in_rect
,
318 const wxString
& caption_text
,
320 int close_button_state
,
321 wxRect
* out_tab_rect
,
322 wxRect
* out_button_rect
,
325 wxCoord normal_textx
, normal_texty
;
326 wxCoord selected_textx
, selected_texty
;
327 wxCoord textx
, texty
;
329 // if the caption is empty, measure some temporary text
330 wxString caption
= caption_text
;
331 if (caption_text
.empty())
334 dc
.SetFont(m_selected_font
);
335 dc
.GetTextExtent(caption
, &selected_textx
, &selected_texty
);
337 dc
.SetFont(m_normal_font
);
338 dc
.GetTextExtent(caption
, &normal_textx
, &normal_texty
);
340 // figure out the size of the tab
341 wxSize tab_size
= GetTabSize(dc
, wnd
, caption
, active
, close_button_state
, x_extent
);
343 wxCoord tab_height
= tab_size
.y
;
344 wxCoord tab_width
= tab_size
.x
;
345 wxCoord tab_x
= in_rect
.x
;
346 wxCoord tab_y
= in_rect
.y
+ in_rect
.height
- tab_height
;
349 caption
= caption_text
;
351 dc
.SetClippingRegion(in_rect
);
355 // select pen, brush and font for the tab to be drawn
359 dc
.SetPen(m_selected_bkpen
);
360 dc
.SetBrush(m_selected_bkbrush
);
361 dc
.SetFont(m_selected_font
);
362 textx
= selected_textx
;
363 texty
= selected_texty
;
367 dc
.SetPen(m_normal_bkpen
);
368 dc
.SetBrush(m_normal_bkbrush
);
369 dc
.SetFont(m_normal_font
);
370 textx
= normal_textx
;
371 texty
= normal_texty
;
375 // create points that will make the tab outline
379 points
[0].y
= tab_y
+ tab_height
- 4;
381 points
[1].y
= tab_y
+ 2;
382 points
[2].x
= tab_x
+ 2;
384 points
[3].x
= tab_x
+ tab_width
- 2;
386 points
[4].x
= tab_x
+ tab_width
;
387 points
[4].y
= tab_y
+ 2;
388 points
[5].x
= tab_x
+ tab_width
;
389 points
[5].y
= tab_y
+ tab_height
- 4;
392 // draw gradient background
395 wxColour c
= m_bkbrush
.GetColour();
399 for (y
= points
[0].y
; y
> points
[2].y
; --y
)
401 if (y
< tab_y
+(tab_height
*3/5) && y
!= last_y
)
404 c
= StepColour(c
, 102);
408 dc
.DrawLine(points
[0].x
+1, y
, points
[5].x
, y
);
413 dc
.SetPen(*wxGREY_PEN
);
414 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
415 dc
.DrawPolygon(6, points
);
417 // there are two horizontal grey lines at the bottom of the tab control,
418 // this gets rid of the top one of those lines in the tab control
421 wxColour c
= m_bkbrush
.GetColour();
423 dc
.DrawLine(points
[0].x
, points
[0].y
, points
[5].x
+1, points
[5].y
);
428 int close_button_width
= 0;
430 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
432 close_button_width
= m_active_close_bmp
.GetWidth();
435 text_offset
= tab_x
+ 8;
438 wxString draw_text
= ChopText(dc
,
440 tab_width
- (text_offset
-tab_x
) - close_button_width
);
443 dc
.DrawText(draw_text
,
445 (tab_y
+ tab_height
)/2 - (texty
/2));
450 // draw close button if necessary
451 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
453 wxBitmap bmp
= m_disabled_close_bmp
;
455 if (close_button_state
== wxAUI_BUTTON_STATE_HOVER
||
456 close_button_state
== wxAUI_BUTTON_STATE_PRESSED
)
458 bmp
= m_active_close_bmp
;
461 wxRect
rect(tab_x
+ tab_width
- close_button_width
- 1,
462 tab_y
+ (tab_height
/2) - (bmp
.GetHeight()/2),
465 IndentPressedBitmap(&rect
, close_button_state
);
466 dc
.DrawBitmap(bmp
, rect
.x
, rect
.y
, true);
468 *out_button_rect
= rect
;
471 *out_tab_rect
= wxRect(tab_x
, tab_y
, tab_width
, tab_height
);
473 dc
.DestroyClippingRegion();
476 int wxAuiDefaultTabArt::GetIndentSize()
481 wxSize
wxAuiDefaultTabArt::GetTabSize(wxDC
& dc
,
482 wxWindow
* WXUNUSED(wnd
),
483 const wxString
& caption
,
484 bool WXUNUSED(active
),
485 int close_button_state
,
488 wxCoord measured_textx
, measured_texty
, tmp
;
490 dc
.SetFont(m_measuring_font
);
491 dc
.GetTextExtent(caption
, &measured_textx
, &measured_texty
);
493 dc
.GetTextExtent(wxT("ABCDEFXj"), &tmp
, &measured_texty
);
495 // add padding around the text
496 wxCoord tab_width
= measured_textx
+ 16;
497 wxCoord tab_height
= measured_texty
+ 10;
499 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
500 tab_width
+= m_active_close_bmp
.GetWidth() + 3;
503 if (m_flags
& wxAUI_NB_TAB_FIXED_WIDTH
)
505 tab_width
= m_fixed_tab_width
;
508 *x_extent
= tab_width
;
510 return wxSize(tab_width
, tab_height
);
514 void wxAuiDefaultTabArt::DrawButton(wxDC
& dc
,
515 wxWindow
* WXUNUSED(wnd
),
516 const wxRect
& in_rect
,
520 const wxBitmap
& bitmap_override
,
526 if (bitmap_override
.IsOk())
528 bmp
= bitmap_override
;
534 case wxAUI_BUTTON_CLOSE
:
535 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
536 bmp
= m_disabled_close_bmp
;
538 bmp
= m_active_close_bmp
;
540 case wxAUI_BUTTON_LEFT
:
541 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
542 bmp
= m_disabled_left_bmp
;
544 bmp
= m_active_left_bmp
;
546 case wxAUI_BUTTON_RIGHT
:
547 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
548 bmp
= m_disabled_right_bmp
;
550 bmp
= m_active_right_bmp
;
552 case wxAUI_BUTTON_WINDOWLIST
:
553 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
554 bmp
= m_disabled_windowlist_bmp
;
556 bmp
= m_active_windowlist_bmp
;
566 if (orientation
== wxLEFT
)
568 rect
.SetX(in_rect
.x
);
569 rect
.SetY(((in_rect
.y
+ in_rect
.height
)/2) - (bmp
.GetHeight()/2));
570 rect
.SetWidth(bmp
.GetWidth());
571 rect
.SetHeight(bmp
.GetHeight());
575 rect
= wxRect(in_rect
.x
+ in_rect
.width
- bmp
.GetWidth(),
576 ((in_rect
.y
+ in_rect
.height
)/2) - (bmp
.GetHeight()/2),
577 bmp
.GetWidth(), bmp
.GetHeight());
580 IndentPressedBitmap(&rect
, button_state
);
581 dc
.DrawBitmap(bmp
, rect
.x
, rect
.y
, true);
587 int wxAuiDefaultTabArt::ShowWindowList(wxWindow
* wnd
,
588 const wxArrayString
& items
,
593 size_t i
, count
= items
.GetCount();
594 for (i
= 0; i
< count
; ++i
)
596 menuPopup
.AppendCheckItem(1000+i
, items
.Item(i
));
599 if (active_idx
!= -1)
601 menuPopup
.Check(1000+active_idx
, true);
604 // find out where to put the popup menu of window
605 // items. Subtract 100 for now to center the menu
606 // a bit, until a better mechanism can be implemented
607 wxPoint pt
= ::wxGetMousePosition();
608 pt
= wnd
->ScreenToClient(pt
);
614 // find out the screen coordinate at the bottom of the tab ctrl
615 wxRect cli_rect
= wnd
->GetClientRect();
616 pt
.y
= cli_rect
.y
+ cli_rect
.height
;
618 wxAuiCommandCapture
* cc
= new wxAuiCommandCapture
;
619 wnd
->PushEventHandler(cc
);
620 wnd
->PopupMenu(&menuPopup
, pt
);
621 int command
= cc
->GetCommandId();
622 wnd
->PopEventHandler(true);
630 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow
* wnd
)
633 dc
.SetFont(m_measuring_font
);
635 wxSize s
= GetTabSize(dc
,
639 wxAUI_BUTTON_STATE_HIDDEN
,
644 void wxAuiDefaultTabArt::SetNormalFont(const wxFont
& font
)
646 m_normal_font
= font
;
649 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont
& font
)
651 m_selected_font
= font
;
654 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont
& font
)
656 m_measuring_font
= font
;
660 // -- wxAuiSimpleTabArt class implementation --
662 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
664 m_normal_font
= *wxNORMAL_FONT
;
665 m_selected_font
= *wxNORMAL_FONT
;
666 m_selected_font
.SetWeight(wxBOLD
);
667 m_measuring_font
= m_selected_font
;
670 m_fixed_tab_width
= 100;
672 wxColour base_colour
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
674 wxColour background_colour
= StepColour(base_colour
, 95);
675 wxColour normaltab_colour
= base_colour
;
676 wxColour selectedtab_colour
= *wxWHITE
;
678 m_bkbrush
= wxBrush(background_colour
);
679 m_normal_bkbrush
= wxBrush(normaltab_colour
);
680 m_normal_bkpen
= wxPen(normaltab_colour
);
681 m_selected_bkbrush
= wxBrush(selectedtab_colour
);
682 m_selected_bkpen
= wxPen(selectedtab_colour
);
684 m_active_close_bmp
= BitmapFromBits(close_bits
, 16, 16, *wxBLACK
);
685 m_disabled_close_bmp
= BitmapFromBits(close_bits
, 16, 16, wxColour(128,128,128));
687 m_active_left_bmp
= BitmapFromBits(left_bits
, 16, 16, *wxBLACK
);
688 m_disabled_left_bmp
= BitmapFromBits(left_bits
, 16, 16, wxColour(128,128,128));
690 m_active_right_bmp
= BitmapFromBits(right_bits
, 16, 16, *wxBLACK
);
691 m_disabled_right_bmp
= BitmapFromBits(right_bits
, 16, 16, wxColour(128,128,128));
693 m_active_windowlist_bmp
= BitmapFromBits(list_bits
, 16, 16, *wxBLACK
);
694 m_disabled_windowlist_bmp
= BitmapFromBits(list_bits
, 16, 16, wxColour(128,128,128));
698 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
702 wxAuiTabArt
* wxAuiSimpleTabArt::Clone()
704 return static_cast<wxAuiTabArt
*>(new wxAuiSimpleTabArt
);
708 void wxAuiSimpleTabArt::SetFlags(unsigned int flags
)
713 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize
& tab_ctrl_size
,
716 m_fixed_tab_width
= 100;
718 int tot_width
= (int)tab_ctrl_size
.x
- GetIndentSize() - 4;
721 m_fixed_tab_width
= tot_width
/(int)tab_count
;
725 if (m_fixed_tab_width
< 100)
726 m_fixed_tab_width
= 100;
728 if (m_fixed_tab_width
> tot_width
/2)
729 m_fixed_tab_width
= tot_width
/2;
731 if (m_fixed_tab_width
> 220)
732 m_fixed_tab_width
= 220;
735 void wxAuiSimpleTabArt::DrawBackground(wxDC
& dc
,
736 wxWindow
* WXUNUSED(wnd
),
740 dc
.SetBrush(m_bkbrush
);
741 dc
.SetPen(*wxTRANSPARENT_PEN
);
742 dc
.DrawRectangle(-1, -1, rect
.GetWidth()+2, rect
.GetHeight()+2);
745 dc
.SetPen(*wxGREY_PEN
);
746 dc
.DrawLine(0, rect
.GetHeight()-1, rect
.GetWidth(), rect
.GetHeight()-1);
750 // DrawTab() draws an individual tab.
753 // in_rect - rectangle the tab should be confined to
754 // caption - tab's caption
755 // active - whether or not the tab is active
756 // out_rect - actual output rectangle
757 // x_extent - the advance x; where the next tab should start
759 void wxAuiSimpleTabArt::DrawTab(wxDC
& dc
,
761 const wxRect
& in_rect
,
762 const wxString
& caption_text
,
764 int close_button_state
,
765 wxRect
* out_tab_rect
,
766 wxRect
* out_button_rect
,
769 wxCoord normal_textx
, normal_texty
;
770 wxCoord selected_textx
, selected_texty
;
771 wxCoord textx
, texty
;
773 // if the caption is empty, measure some temporary text
774 wxString caption
= caption_text
;
775 if (caption_text
.empty())
778 dc
.SetFont(m_selected_font
);
779 dc
.GetTextExtent(caption
, &selected_textx
, &selected_texty
);
781 dc
.SetFont(m_normal_font
);
782 dc
.GetTextExtent(caption
, &normal_textx
, &normal_texty
);
784 // figure out the size of the tab
785 wxSize tab_size
= GetTabSize(dc
, wnd
, caption
, active
, close_button_state
, x_extent
);
787 wxCoord tab_height
= tab_size
.y
;
788 wxCoord tab_width
= tab_size
.x
;
789 wxCoord tab_x
= in_rect
.x
;
790 wxCoord tab_y
= in_rect
.y
+ in_rect
.height
- tab_height
;
792 caption
= caption_text
;
794 // select pen, brush and font for the tab to be drawn
798 dc
.SetPen(m_selected_bkpen
);
799 dc
.SetBrush(m_selected_bkbrush
);
800 dc
.SetFont(m_selected_font
);
801 textx
= selected_textx
;
802 texty
= selected_texty
;
806 dc
.SetPen(m_normal_bkpen
);
807 dc
.SetBrush(m_normal_bkbrush
);
808 dc
.SetFont(m_normal_font
);
809 textx
= normal_textx
;
810 texty
= normal_texty
;
818 points
[0].y
= tab_y
+ tab_height
- 1;
819 points
[1].x
= tab_x
+ tab_height
- 3;
820 points
[1].y
= tab_y
+ 2;
821 points
[2].x
= tab_x
+ tab_height
+ 3;
823 points
[3].x
= tab_x
+ tab_width
- 2;
825 points
[4].x
= tab_x
+ tab_width
;
826 points
[4].y
= tab_y
+ 2;
827 points
[5].x
= tab_x
+ tab_width
;
828 points
[5].y
= tab_y
+ tab_height
- 1;
829 points
[6] = points
[0];
831 dc
.SetClippingRegion(in_rect
);
833 dc
.DrawPolygon(6, points
);
835 dc
.SetPen(*wxGREY_PEN
);
837 //dc.DrawLines(active ? 6 : 7, points);
838 dc
.DrawLines(7, points
);
843 int close_button_width
= 0;
844 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
846 close_button_width
= m_active_close_bmp
.GetWidth();
847 text_offset
= tab_x
+ (tab_height
/2) + ((tab_width
-close_button_width
)/2) - (textx
/2);
851 text_offset
= tab_x
+ (tab_height
/3) + (tab_width
/2) - (textx
/2);
854 // set minimum text offset
855 if (text_offset
< tab_x
+ tab_height
)
856 text_offset
= tab_x
+ tab_height
;
858 // chop text if necessary
859 wxString draw_text
= ChopText(dc
,
861 tab_width
- (text_offset
-tab_x
) - close_button_width
);
864 dc
.DrawText(draw_text
,
866 (tab_y
+ tab_height
)/2 - (texty
/2) + 1);
869 // draw close button if necessary
870 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
874 bmp
= m_active_close_bmp
;
876 bmp
= m_disabled_close_bmp
;
878 wxRect
rect(tab_x
+ tab_width
- close_button_width
- 1,
879 tab_y
+ (tab_height
/2) - (bmp
.GetHeight()/2) + 1,
882 DrawButtons(dc
, rect
, bmp
, *wxWHITE
, close_button_state
);
884 *out_button_rect
= rect
;
888 *out_tab_rect
= wxRect(tab_x
, tab_y
, tab_width
, tab_height
);
890 dc
.DestroyClippingRegion();
893 int wxAuiSimpleTabArt::GetIndentSize()
898 wxSize
wxAuiSimpleTabArt::GetTabSize(wxDC
& dc
,
899 wxWindow
* WXUNUSED(wnd
),
900 const wxString
& caption
,
901 bool WXUNUSED(active
),
902 int close_button_state
,
905 wxCoord measured_textx
, measured_texty
;
907 dc
.SetFont(m_measuring_font
);
908 dc
.GetTextExtent(caption
, &measured_textx
, &measured_texty
);
910 wxCoord tab_height
= measured_texty
+ 4;
911 wxCoord tab_width
= measured_textx
+ tab_height
+ 5;
913 if (close_button_state
!= wxAUI_BUTTON_STATE_HIDDEN
)
914 tab_width
+= m_active_close_bmp
.GetWidth();
916 if (m_flags
& wxAUI_NB_TAB_FIXED_WIDTH
)
918 tab_width
= m_fixed_tab_width
;
921 *x_extent
= tab_width
- (tab_height
/2) - 1;
923 return wxSize(tab_width
, tab_height
);
927 void wxAuiSimpleTabArt::DrawButton(wxDC
& dc
,
928 wxWindow
* WXUNUSED(wnd
),
929 const wxRect
& in_rect
,
933 const wxBitmap
& bitmap_override
,
939 if (bitmap_override
.IsOk())
941 bmp
= bitmap_override
;
947 case wxAUI_BUTTON_CLOSE
:
948 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
949 bmp
= m_disabled_close_bmp
;
951 bmp
= m_active_close_bmp
;
953 case wxAUI_BUTTON_LEFT
:
954 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
955 bmp
= m_disabled_left_bmp
;
957 bmp
= m_active_left_bmp
;
959 case wxAUI_BUTTON_RIGHT
:
960 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
961 bmp
= m_disabled_right_bmp
;
963 bmp
= m_active_right_bmp
;
965 case wxAUI_BUTTON_WINDOWLIST
:
966 if (button_state
& wxAUI_BUTTON_STATE_DISABLED
)
967 bmp
= m_disabled_windowlist_bmp
;
969 bmp
= m_active_windowlist_bmp
;
979 if (orientation
== wxLEFT
)
981 rect
.SetX(in_rect
.x
);
982 rect
.SetY(((in_rect
.y
+ in_rect
.height
)/2) - (bmp
.GetHeight()/2));
983 rect
.SetWidth(bmp
.GetWidth());
984 rect
.SetHeight(bmp
.GetHeight());
988 rect
= wxRect(in_rect
.x
+ in_rect
.width
- bmp
.GetWidth(),
989 ((in_rect
.y
+ in_rect
.height
)/2) - (bmp
.GetHeight()/2),
990 bmp
.GetWidth(), bmp
.GetHeight());
994 DrawButtons(dc
, rect
, bmp
, *wxWHITE
, button_state
);
1000 int wxAuiSimpleTabArt::ShowWindowList(wxWindow
* wnd
,
1001 const wxArrayString
& items
,
1006 size_t i
, count
= items
.GetCount();
1007 for (i
= 0; i
< count
; ++i
)
1009 menuPopup
.AppendCheckItem(1000+i
, items
.Item(i
));
1012 if (active_idx
!= -1)
1014 menuPopup
.Check(1000+active_idx
, true);
1017 // find out where to put the popup menu of window
1018 // items. Subtract 100 for now to center the menu
1019 // a bit, until a better mechanism can be implemented
1020 wxPoint pt
= ::wxGetMousePosition();
1021 pt
= wnd
->ScreenToClient(pt
);
1027 // find out the screen coordinate at the bottom of the tab ctrl
1028 wxRect cli_rect
= wnd
->GetClientRect();
1029 pt
.y
= cli_rect
.y
+ cli_rect
.height
;
1031 wxAuiCommandCapture
* cc
= new wxAuiCommandCapture
;
1032 wnd
->PushEventHandler(cc
);
1033 wnd
->PopupMenu(&menuPopup
, pt
);
1034 int command
= cc
->GetCommandId();
1035 wnd
->PopEventHandler(true);
1037 if (command
>= 1000)
1038 return command
-1000;
1043 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow
* wnd
)
1046 dc
.SetFont(m_measuring_font
);
1048 wxSize s
= GetTabSize(dc
,
1052 wxAUI_BUTTON_STATE_HIDDEN
,
1057 void wxAuiSimpleTabArt::SetNormalFont(const wxFont
& font
)
1059 m_normal_font
= font
;
1062 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont
& font
)
1064 m_selected_font
= font
;
1067 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont
& font
)
1069 m_measuring_font
= font
;
1075 // -- wxAuiTabContainer class implementation --
1078 // wxAuiTabContainer is a class which contains information about each
1079 // tab. It also can render an entire tab control to a specified DC.
1080 // It's not a window class itself, because this code will be used by
1081 // the wxFrameMananger, where it is disadvantageous to have separate
1082 // windows for each tab control in the case of "docked tabs"
1084 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
1085 // which can be used as a tab control in the normal sense.
1088 wxAuiTabContainer::wxAuiTabContainer()
1092 m_art
= new wxAuiDefaultTabArt
;
1094 AddButton(wxAUI_BUTTON_LEFT
, wxLEFT
);
1095 AddButton(wxAUI_BUTTON_RIGHT
, wxRIGHT
);
1096 AddButton(wxAUI_BUTTON_WINDOWLIST
, wxRIGHT
);
1097 AddButton(wxAUI_BUTTON_CLOSE
, wxRIGHT
);
1100 wxAuiTabContainer::~wxAuiTabContainer()
1105 void wxAuiTabContainer::SetArtProvider(wxAuiTabArt
* art
)
1112 m_art
->SetFlags(m_flags
);
1116 wxAuiTabArt
* wxAuiTabContainer::GetArtProvider()
1121 void wxAuiTabContainer::SetFlags(unsigned int flags
)
1125 // check for new close button settings
1126 RemoveButton(wxAUI_BUTTON_LEFT
);
1127 RemoveButton(wxAUI_BUTTON_RIGHT
);
1128 RemoveButton(wxAUI_BUTTON_WINDOWLIST
);
1129 RemoveButton(wxAUI_BUTTON_CLOSE
);
1132 if (flags
& wxAUI_NB_SCROLL_BUTTONS
)
1134 AddButton(wxAUI_BUTTON_LEFT
, wxLEFT
);
1135 AddButton(wxAUI_BUTTON_RIGHT
, wxRIGHT
);
1138 if (flags
& wxAUI_NB_WINDOWLIST_BUTTON
)
1140 AddButton(wxAUI_BUTTON_WINDOWLIST
, wxRIGHT
);
1143 if (flags
& wxAUI_NB_CLOSE_BUTTON
)
1145 AddButton(wxAUI_BUTTON_CLOSE
, wxRIGHT
);
1150 m_art
->SetFlags(m_flags
);
1154 unsigned int wxAuiTabContainer::GetFlags() const
1160 void wxAuiTabContainer::SetNormalFont(const wxFont
& font
)
1162 m_art
->SetNormalFont(font
);
1165 void wxAuiTabContainer::SetSelectedFont(const wxFont
& font
)
1167 m_art
->SetSelectedFont(font
);
1170 void wxAuiTabContainer::SetMeasuringFont(const wxFont
& font
)
1172 m_art
->SetMeasuringFont(font
);
1175 void wxAuiTabContainer::SetRect(const wxRect
& rect
)
1181 m_art
->SetSizingInfo(rect
.GetSize(), m_pages
.GetCount());
1185 bool wxAuiTabContainer::AddPage(wxWindow
* page
,
1186 const wxAuiNotebookPage
& info
)
1188 wxAuiNotebookPage page_info
;
1190 page_info
.window
= page
;
1192 m_pages
.Add(page_info
);
1194 // let the art provider know how many pages we have
1197 m_art
->SetSizingInfo(m_rect
.GetSize(), m_pages
.GetCount());
1203 bool wxAuiTabContainer::InsertPage(wxWindow
* page
,
1204 const wxAuiNotebookPage
& info
,
1207 wxAuiNotebookPage page_info
;
1209 page_info
.window
= page
;
1211 if (idx
>= m_pages
.GetCount())
1212 m_pages
.Add(page_info
);
1214 m_pages
.Insert(page_info
, idx
);
1216 // let the art provider know how many pages we have
1219 m_art
->SetSizingInfo(m_rect
.GetSize(), m_pages
.GetCount());
1225 bool wxAuiTabContainer::MovePage(wxWindow
* page
,
1228 int idx
= GetIdxFromWindow(page
);
1232 // get page entry, make a copy of it
1233 wxAuiNotebookPage p
= GetPage(idx
);
1235 // remove old page entry
1238 // insert page where it should be
1239 InsertPage(page
, p
, new_idx
);
1244 bool wxAuiTabContainer::RemovePage(wxWindow
* wnd
)
1246 size_t i
, page_count
= m_pages
.GetCount();
1247 for (i
= 0; i
< page_count
; ++i
)
1249 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1250 if (page
.window
== wnd
)
1252 m_pages
.RemoveAt(i
);
1254 // let the art provider know how many pages we have
1257 m_art
->SetSizingInfo(m_rect
.GetSize(), m_pages
.GetCount());
1267 bool wxAuiTabContainer::SetActivePage(wxWindow
* wnd
)
1271 size_t i
, page_count
= m_pages
.GetCount();
1272 for (i
= 0; i
< page_count
; ++i
)
1274 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1275 if (page
.window
== wnd
)
1282 page
.active
= false;
1289 void wxAuiTabContainer::SetNoneActive()
1291 size_t i
, page_count
= m_pages
.GetCount();
1292 for (i
= 0; i
< page_count
; ++i
)
1294 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1295 page
.active
= false;
1299 bool wxAuiTabContainer::SetActivePage(size_t page
)
1301 if (page
>= m_pages
.GetCount())
1304 return SetActivePage(m_pages
.Item(page
).window
);
1307 int wxAuiTabContainer::GetActivePage() const
1309 size_t i
, page_count
= m_pages
.GetCount();
1310 for (i
= 0; i
< page_count
; ++i
)
1312 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1320 wxWindow
* wxAuiTabContainer::GetWindowFromIdx(size_t idx
) const
1322 if (idx
>= m_pages
.GetCount())
1325 return m_pages
[idx
].window
;
1328 int wxAuiTabContainer::GetIdxFromWindow(wxWindow
* wnd
) const
1330 size_t i
, page_count
= m_pages
.GetCount();
1331 for (i
= 0; i
< page_count
; ++i
)
1333 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1334 if (page
.window
== wnd
)
1340 wxAuiNotebookPage
& wxAuiTabContainer::GetPage(size_t idx
)
1342 wxASSERT_MSG(idx
< m_pages
.GetCount(), wxT("Invalid Page index"));
1344 return m_pages
[idx
];
1347 wxAuiNotebookPageArray
& wxAuiTabContainer::GetPages()
1352 size_t wxAuiTabContainer::GetPageCount() const
1354 return m_pages
.GetCount();
1357 void wxAuiTabContainer::AddButton(int id
,
1359 const wxBitmap
& normal_bitmap
,
1360 const wxBitmap
& disabled_bitmap
)
1362 wxAuiTabContainerButton button
;
1364 button
.bitmap
= normal_bitmap
;
1365 button
.dis_bitmap
= disabled_bitmap
;
1366 button
.location
= location
;
1367 button
.cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
1369 m_buttons
.Add(button
);
1372 void wxAuiTabContainer::RemoveButton(int id
)
1374 size_t i
, button_count
= m_buttons
.GetCount();
1376 for (i
= 0; i
< button_count
; ++i
)
1378 if (m_buttons
.Item(i
).id
== id
)
1380 m_buttons
.RemoveAt(i
);
1388 size_t wxAuiTabContainer::GetTabOffset() const
1390 return m_tab_offset
;
1393 void wxAuiTabContainer::SetTabOffset(size_t offset
)
1395 m_tab_offset
= offset
;
1401 // Render() renders the tab catalog to the specified DC
1402 // It is a virtual function and can be overridden to
1403 // provide custom drawing capabilities
1404 void wxAuiTabContainer::Render(wxDC
* raw_dc
, wxWindow
* wnd
)
1409 size_t page_count
= m_pages
.GetCount();
1410 size_t button_count
= m_buttons
.GetCount();
1412 // create off-screen bitmap
1413 bmp
.Create(m_rect
.GetWidth(), m_rect
.GetHeight());
1414 dc
.SelectObject(bmp
);
1417 // find out if size of tabs is larger than can be
1418 // afforded on screen
1419 int total_width
= 0;
1420 int visible_width
= 0;
1421 for (i
= 0; i
< page_count
; ++i
)
1423 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1425 // determine if a close button is on this tab
1426 bool close_button
= false;
1427 if ((m_flags
& wxAUI_NB_CLOSE_ON_ALL_TABS
) != 0 ||
1428 ((m_flags
& wxAUI_NB_CLOSE_ON_ACTIVE_TAB
) != 0 && page
.active
))
1430 close_button
= true;
1435 wxSize size
= m_art
->GetTabSize(dc
,
1440 wxAUI_BUTTON_STATE_NORMAL
:
1441 wxAUI_BUTTON_STATE_HIDDEN
,
1444 if (i
+1 < page_count
)
1445 total_width
+= x_extent
;
1447 total_width
+= size
.x
;
1449 if (i
>= m_tab_offset
)
1451 if (i
+1 < page_count
)
1452 visible_width
+= x_extent
;
1454 visible_width
+= size
.x
;
1458 if (total_width
> m_rect
.GetWidth() || m_tab_offset
!= 0)
1460 // show left/right buttons
1461 for (i
= 0; i
< button_count
; ++i
)
1463 wxAuiTabContainerButton
& button
= m_buttons
.Item(i
);
1464 if (button
.id
== wxAUI_BUTTON_LEFT
||
1465 button
.id
== wxAUI_BUTTON_RIGHT
)
1467 button
.cur_state
&= ~wxAUI_BUTTON_STATE_HIDDEN
;
1473 // hide left/right buttons
1474 for (i
= 0; i
< button_count
; ++i
)
1476 wxAuiTabContainerButton
& button
= m_buttons
.Item(i
);
1477 if (button
.id
== wxAUI_BUTTON_LEFT
||
1478 button
.id
== wxAUI_BUTTON_RIGHT
)
1480 button
.cur_state
|= wxAUI_BUTTON_STATE_HIDDEN
;
1485 // determine whether left button should be enabled
1486 for (i
= 0; i
< button_count
; ++i
)
1488 wxAuiTabContainerButton
& button
= m_buttons
.Item(i
);
1489 if (button
.id
== wxAUI_BUTTON_LEFT
)
1491 if (m_tab_offset
== 0)
1492 button
.cur_state
|= wxAUI_BUTTON_STATE_DISABLED
;
1494 button
.cur_state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
1496 if (button
.id
== wxAUI_BUTTON_RIGHT
)
1498 if (visible_width
< m_rect
.GetWidth() - ((int)button_count
*16))
1499 button
.cur_state
|= wxAUI_BUTTON_STATE_DISABLED
;
1501 button
.cur_state
&= ~wxAUI_BUTTON_STATE_DISABLED
;
1508 m_art
->DrawBackground(dc
, wnd
, m_rect
);
1511 int left_buttons_width
= 0;
1512 int right_buttons_width
= 0;
1516 // draw the buttons on the right side
1517 offset
= m_rect
.x
+ m_rect
.width
;
1518 for (i
= 0; i
< button_count
; ++i
)
1520 wxAuiTabContainerButton
& button
= m_buttons
.Item(button_count
- i
- 1);
1522 if (button
.location
!= wxRIGHT
)
1524 if (button
.cur_state
& wxAUI_BUTTON_STATE_HIDDEN
)
1527 wxRect button_rect
= m_rect
;
1528 button_rect
.SetY(1);
1529 button_rect
.SetWidth(offset
);
1531 m_art
->DrawButton(dc
,
1540 offset
-= button
.rect
.GetWidth();
1541 right_buttons_width
+= button
.rect
.GetWidth();
1548 // draw the buttons on the left side
1550 for (i
= 0; i
< button_count
; ++i
)
1552 wxAuiTabContainerButton
& button
= m_buttons
.Item(button_count
- i
- 1);
1554 if (button
.location
!= wxLEFT
)
1556 if (button
.cur_state
& wxAUI_BUTTON_STATE_HIDDEN
)
1559 wxRect
button_rect(offset
, 1, 1000, m_rect
.height
);
1561 m_art
->DrawButton(dc
,
1570 offset
+= button
.rect
.GetWidth();
1571 left_buttons_width
+= button
.rect
.GetWidth();
1574 offset
= left_buttons_width
;
1577 offset
+= m_art
->GetIndentSize();
1579 // prepare the tab-close-button array
1580 while (m_tab_close_buttons
.GetCount() < page_count
)
1582 wxAuiTabContainerButton tempbtn
;
1583 tempbtn
.id
= wxAUI_BUTTON_CLOSE
;
1584 tempbtn
.location
= wxCENTER
;
1585 tempbtn
.cur_state
= wxAUI_BUTTON_STATE_HIDDEN
;
1586 m_tab_close_buttons
.Add(tempbtn
);
1589 for (i
= 0; i
< m_tab_offset
; ++i
)
1591 // buttons before the tab offset must be set to hidden
1592 m_tab_close_buttons
.Item(i
).cur_state
= wxAUI_BUTTON_STATE_HIDDEN
;
1598 size_t active
= 999;
1599 int active_offset
= 0;
1603 wxRect rect
= m_rect
;
1605 rect
.height
= m_rect
.height
;
1607 for (i
= m_tab_offset
; i
< page_count
; ++i
)
1609 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1610 wxAuiTabContainerButton
& tab_button
= m_tab_close_buttons
.Item(i
);
1612 // determine if a close button is on this tab
1613 bool close_button
= false;
1614 if ((m_flags
& wxAUI_NB_CLOSE_ON_ALL_TABS
) != 0 ||
1615 ((m_flags
& wxAUI_NB_CLOSE_ON_ACTIVE_TAB
) != 0 && page
.active
))
1617 close_button
= true;
1618 if (tab_button
.cur_state
== wxAUI_BUTTON_STATE_HIDDEN
)
1620 tab_button
.id
= wxAUI_BUTTON_CLOSE
;
1621 tab_button
.cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
1622 tab_button
.location
= wxCENTER
;
1627 tab_button
.cur_state
= wxAUI_BUTTON_STATE_HIDDEN
;
1631 rect
.width
= m_rect
.width
- right_buttons_width
- offset
- 2;
1633 if (rect
.width
<= 0)
1644 tab_button
.cur_state
,
1652 active_offset
= offset
;
1659 // draw the active tab again so it stands in the foreground
1660 if (active
>= m_tab_offset
&& active
< m_pages
.GetCount())
1662 wxAuiNotebookPage
& page
= m_pages
.Item(active
);
1664 wxAuiTabContainerButton
& tab_button
= m_tab_close_buttons
.Item(active
);
1666 // determine if a close button is on this tab
1667 bool close_button
= false;
1668 if ((m_flags
& wxAUI_NB_CLOSE_ON_ALL_TABS
) != 0 ||
1669 ((m_flags
& wxAUI_NB_CLOSE_ON_ACTIVE_TAB
) != 0 && page
.active
))
1671 close_button
= true;
1674 rect
.x
= active_offset
;
1680 tab_button
.cur_state
,
1687 raw_dc
->Blit(m_rect
.x
, m_rect
.y
,
1688 m_rect
.GetWidth(), m_rect
.GetHeight(),
1693 // TabHitTest() tests if a tab was hit, passing the window pointer
1694 // back if that condition was fulfilled. The function returns
1695 // true if a tab was hit, otherwise false
1696 bool wxAuiTabContainer::TabHitTest(int x
, int y
, wxWindow
** hit
) const
1698 if (!m_rect
.Contains(x
,y
))
1701 wxAuiTabContainerButton
* btn
= NULL
;
1702 if (ButtonHitTest(x
, y
, &btn
))
1704 if (m_buttons
.Index(*btn
) != wxNOT_FOUND
)
1708 size_t i
, page_count
= m_pages
.GetCount();
1710 for (i
= m_tab_offset
; i
< page_count
; ++i
)
1712 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
1713 if (page
.rect
.Contains(x
,y
))
1724 // ButtonHitTest() tests if a button was hit. The function returns
1725 // true if a button was hit, otherwise false
1726 bool wxAuiTabContainer::ButtonHitTest(int x
, int y
,
1727 wxAuiTabContainerButton
** hit
) const
1729 if (!m_rect
.Contains(x
,y
))
1732 size_t i
, button_count
;
1735 button_count
= m_buttons
.GetCount();
1736 for (i
= 0; i
< button_count
; ++i
)
1738 wxAuiTabContainerButton
& button
= m_buttons
.Item(i
);
1739 if (button
.rect
.Contains(x
,y
))
1747 button_count
= m_tab_close_buttons
.GetCount();
1748 for (i
= 0; i
< button_count
; ++i
)
1750 wxAuiTabContainerButton
& button
= m_tab_close_buttons
.Item(i
);
1751 if (button
.rect
.Contains(x
,y
))
1764 // the utility function ShowWnd() is the same as show,
1765 // except it handles wxAuiMDIChildFrame windows as well,
1766 // as the Show() method on this class is "unplugged"
1767 static void ShowWnd(wxWindow
* wnd
, bool show
)
1769 if (wnd
->IsKindOf(CLASSINFO(wxAuiMDIChildFrame
)))
1771 wxAuiMDIChildFrame
* cf
= (wxAuiMDIChildFrame
*)wnd
;
1781 // DoShowHide() this function shows the active window, then
1782 // hides all of the other windows (in that order)
1783 void wxAuiTabContainer::DoShowHide()
1785 wxAuiNotebookPageArray
& pages
= GetPages();
1786 size_t i
, page_count
= pages
.GetCount();
1788 // show new active page first
1789 for (i
= 0; i
< page_count
; ++i
)
1791 wxAuiNotebookPage
& page
= pages
.Item(i
);
1794 ShowWnd(page
.window
, true);
1799 // hide all other pages
1800 for (i
= 0; i
< page_count
; ++i
)
1802 wxAuiNotebookPage
& page
= pages
.Item(i
);
1803 ShowWnd(page
.window
, page
.active
);
1812 // -- wxAuiTabCtrl class implementation --
1816 BEGIN_EVENT_TABLE(wxAuiTabCtrl
, wxControl
)
1817 EVT_PAINT(wxAuiTabCtrl::OnPaint
)
1818 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground
)
1819 EVT_SIZE(wxAuiTabCtrl::OnSize
)
1820 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown
)
1821 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp
)
1822 EVT_MOTION(wxAuiTabCtrl::OnMotion
)
1823 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow
)
1824 EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton
)
1828 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow
* parent
,
1832 long style
) : wxControl(parent
, id
, pos
, size
, style
)
1834 m_click_pt
= wxDefaultPosition
;
1835 m_is_dragging
= false;
1836 m_hover_button
= NULL
;
1839 wxAuiTabCtrl::~wxAuiTabCtrl()
1843 void wxAuiTabCtrl::OnPaint(wxPaintEvent
&)
1847 dc
.SetFont(GetFont());
1849 if (GetPageCount() > 0)
1853 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent
& WXUNUSED(evt
))
1857 void wxAuiTabCtrl::OnSize(wxSizeEvent
& evt
)
1859 wxSize s
= evt
.GetSize();
1860 wxRect
r(0, 0, s
.GetWidth(), s
.GetHeight());
1864 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent
& evt
)
1867 m_click_pt
= wxDefaultPosition
;
1868 m_is_dragging
= false;
1873 if (TabHitTest(evt
.m_x
, evt
.m_y
, &wnd
))
1875 if (m_flags
& wxAUI_NB_CLOSE_ON_ACTIVE_TAB
)
1876 m_hover_button
= NULL
;
1878 wxAuiNotebookEvent
e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
, m_windowId
);
1879 e
.SetSelection(GetIdxFromWindow(wnd
));
1880 e
.SetOldSelection(GetActivePage());
1881 e
.SetEventObject(this);
1882 GetEventHandler()->ProcessEvent(e
);
1884 m_click_pt
.x
= evt
.m_x
;
1885 m_click_pt
.y
= evt
.m_y
;
1891 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_PRESSED
;
1897 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent
&)
1899 if (GetCapture() == this)
1904 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
, m_windowId
);
1905 evt
.SetSelection(GetIdxFromWindow(m_click_tab
));
1906 evt
.SetOldSelection(evt
.GetSelection());
1907 evt
.SetEventObject(this);
1908 GetEventHandler()->ProcessEvent(evt
);
1914 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_HOVER
;
1918 if (!(m_hover_button
->cur_state
& wxAUI_BUTTON_STATE_DISABLED
))
1920 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON
, m_windowId
);
1921 evt
.SetInt(m_hover_button
->id
);
1922 evt
.SetEventObject(this);
1923 GetEventHandler()->ProcessEvent(evt
);
1927 m_click_pt
= wxDefaultPosition
;
1928 m_is_dragging
= false;
1932 void wxAuiTabCtrl::OnMotion(wxMouseEvent
& evt
)
1934 wxPoint pos
= evt
.GetPosition();
1936 // check if the mouse is hovering above a button
1937 wxAuiTabContainerButton
* button
;
1938 if (ButtonHitTest(pos
.x
, pos
.y
, &button
))
1940 if (m_hover_button
&& button
!= m_hover_button
)
1942 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
1943 m_hover_button
= NULL
;
1948 if (button
->cur_state
!= wxAUI_BUTTON_STATE_HOVER
)
1950 button
->cur_state
= wxAUI_BUTTON_STATE_HOVER
;
1953 m_hover_button
= button
;
1961 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
1962 m_hover_button
= NULL
;
1969 if (!evt
.LeftIsDown() || m_click_pt
== wxDefaultPosition
)
1974 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
, m_windowId
);
1975 evt
.SetSelection(GetIdxFromWindow(m_click_tab
));
1976 evt
.SetOldSelection(evt
.GetSelection());
1977 evt
.SetEventObject(this);
1978 GetEventHandler()->ProcessEvent(evt
);
1983 int drag_x_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_X
);
1984 int drag_y_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_Y
);
1986 if (abs(pos
.x
- m_click_pt
.x
) > drag_x_threshold
||
1987 abs(pos
.y
- m_click_pt
.y
) > drag_y_threshold
)
1989 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
, m_windowId
);
1990 evt
.SetSelection(GetIdxFromWindow(m_click_tab
));
1991 evt
.SetOldSelection(evt
.GetSelection());
1992 evt
.SetEventObject(this);
1993 GetEventHandler()->ProcessEvent(evt
);
1995 m_is_dragging
= true;
1999 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent
& WXUNUSED(event
))
2003 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
2004 m_hover_button
= NULL
;
2010 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent
& event
)
2012 int button
= event
.GetInt();
2014 if (button
== wxAUI_BUTTON_LEFT
|| button
== wxAUI_BUTTON_RIGHT
)
2016 if (button
== wxAUI_BUTTON_LEFT
)
2018 if (GetTabOffset() > 0)
2020 SetTabOffset(GetTabOffset()-1);
2027 SetTabOffset(GetTabOffset()+1);
2032 else if (button
== wxAUI_BUTTON_WINDOWLIST
)
2036 size_t i
, page_count
= m_pages
.GetCount();
2037 for (i
= 0; i
< page_count
; ++i
)
2039 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
2040 as
.Add(page
.caption
);
2043 int idx
= GetArtProvider()->ShowWindowList(this, as
, GetActivePage());
2047 wxAuiNotebookEvent
e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
, m_windowId
);
2048 e
.SetSelection(idx
);
2049 e
.SetOldSelection(GetActivePage());
2050 e
.SetEventObject(this);
2051 GetEventHandler()->ProcessEvent(e
);
2060 // wxTabFrame is an interesting case. It's important that all child pages
2061 // of the multi-notebook control are all actually children of that control
2062 // (and not grandchildren). wxTabFrame facilitates this. There is one
2063 // instance of wxTabFrame for each tab control inside the multi-notebook.
2064 // It's important to know that wxTabFrame is not a real window, but it merely
2065 // used to capture the dimensions/positioning of the internal tab control and
2066 // it's managed page windows
2068 class wxTabFrame
: public wxWindow
2075 m_rect
= wxRect(0,0,200,200);
2076 m_tab_ctrl_height
= 20;
2079 void SetTabCtrlHeight(int h
)
2081 m_tab_ctrl_height
= h
;
2084 void DoSetSize(int x
, int y
,
2085 int width
, int height
,
2086 int WXUNUSED(sizeFlags
= wxSIZE_AUTO
))
2088 m_rect
= wxRect(x
, y
, width
, height
);
2092 void DoGetClientSize(int* x
, int* y
) const
2098 bool Show( bool WXUNUSED(show
= true) ) { return false; }
2105 m_tab_rect
= wxRect(m_rect
.x
, m_rect
.y
, m_rect
.width
, m_tab_ctrl_height
);
2106 m_tabs
->SetSize(m_rect
.x
, m_rect
.y
, m_rect
.width
, m_tab_ctrl_height
);
2107 m_tabs
->SetRect(wxRect(0, 0, m_rect
.width
, m_tab_ctrl_height
));
2111 wxAuiNotebookPageArray
& pages
= m_tabs
->GetPages();
2112 size_t i
, page_count
= pages
.GetCount();
2114 for (i
= 0; i
< page_count
; ++i
)
2116 wxAuiNotebookPage
& page
= pages
.Item(i
);
2117 page
.window
->SetSize(m_rect
.x
, m_rect
.y
+ m_tab_ctrl_height
,
2118 m_rect
.width
, m_rect
.height
- m_tab_ctrl_height
);
2120 if (page
.window
->IsKindOf(CLASSINFO(wxAuiMDIChildFrame
)))
2122 wxAuiMDIChildFrame
* wnd
= (wxAuiMDIChildFrame
*)page
.window
;
2123 wnd
->ApplyMDIChildFrameRect();
2128 void DoGetSize(int* x
, int* y
) const
2131 *x
= m_rect
.GetWidth();
2133 *y
= m_rect
.GetHeight();
2145 wxAuiTabCtrl
* m_tabs
;
2146 int m_tab_ctrl_height
;
2153 // -- wxAuiNotebook class implementation --
2155 BEGIN_EVENT_TABLE(wxAuiNotebook
, wxControl
)
2156 //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
2157 //EVT_SIZE(wxAuiNotebook::OnSize)
2158 //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
2159 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus
)
2160 EVT_COMMAND_RANGE(10000, 10100,
2161 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
,
2162 wxAuiNotebook::OnTabClicked
)
2163 EVT_COMMAND_RANGE(10000, 10100,
2164 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
,
2165 wxAuiNotebook::OnTabBeginDrag
)
2166 EVT_COMMAND_RANGE(10000, 10100,
2167 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
,
2168 wxAuiNotebook::OnTabEndDrag
)
2169 EVT_COMMAND_RANGE(10000, 10100,
2170 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
,
2171 wxAuiNotebook::OnTabDragMotion
)
2172 EVT_COMMAND_RANGE(10000, 10100,
2173 wxEVT_COMMAND_AUINOTEBOOK_BUTTON
,
2174 wxAuiNotebook::OnTabButton
)
2177 wxAuiNotebook::wxAuiNotebook()
2180 m_tab_id_counter
= 10000;
2182 m_tab_ctrl_height
= 20;
2185 wxAuiNotebook::wxAuiNotebook(wxWindow
*parent
,
2189 long style
) : wxControl(parent
, id
, pos
, size
, style
)
2191 InitNotebook(style
);
2194 bool wxAuiNotebook::Create(wxWindow
* parent
,
2200 if (!wxControl::Create(parent
, id
, pos
, size
, style
))
2203 InitNotebook(style
);
2208 // InitNotebook() contains common initialization
2209 // code called by all constructors
2210 void wxAuiNotebook::InitNotebook(long style
)
2213 m_tab_id_counter
= 10000;
2215 m_tab_ctrl_height
= 20;
2216 m_flags
= (unsigned int)style
;
2218 m_normal_font
= *wxNORMAL_FONT
;
2219 m_selected_font
= *wxNORMAL_FONT
;
2220 m_selected_font
.SetWeight(wxBOLD
);
2222 SetArtProvider(new wxAuiDefaultTabArt
);
2224 m_dummy_wnd
= new wxWindow(this, wxID_ANY
, wxPoint(0,0), wxSize(0,0));
2225 m_dummy_wnd
->SetSize(200, 200);
2226 m_dummy_wnd
->Show(false);
2228 m_mgr
.SetManagedWindow(this);
2230 m_mgr
.AddPane(m_dummy_wnd
,
2231 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
2236 wxAuiNotebook::~wxAuiNotebook()
2241 void wxAuiNotebook::SetArtProvider(wxAuiTabArt
* art
)
2243 m_tabs
.SetArtProvider(art
);
2245 // choose a default for the tab height
2246 m_tab_ctrl_height
= art
->GetBestTabCtrlSize(this);
2248 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2249 size_t i
, pane_count
= all_panes
.GetCount();
2250 for (i
= 0; i
< pane_count
; ++i
)
2252 wxAuiPaneInfo
& pane
= all_panes
.Item(i
);
2253 if (pane
.name
== wxT("dummy"))
2255 wxTabFrame
* tab_frame
= (wxTabFrame
*)pane
.window
;
2256 wxAuiTabCtrl
* tabctrl
= tab_frame
->m_tabs
;
2257 tab_frame
->SetTabCtrlHeight(m_tab_ctrl_height
);
2258 tabctrl
->SetArtProvider(art
->Clone());
2259 tab_frame
->DoSizing();
2264 wxAuiTabArt
* wxAuiNotebook::GetArtProvider()
2266 return m_tabs
.GetArtProvider();
2269 void wxAuiNotebook::SetWindowStyleFlag(long style
)
2271 wxControl::SetWindowStyleFlag(style
);
2273 m_flags
= (unsigned int)style
;
2275 // if the control is already initialized
2276 if (m_mgr
.GetManagedWindow() == (wxWindow
*)this)
2278 // let all of the tab children know about the new style
2280 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2281 size_t i
, pane_count
= all_panes
.GetCount();
2282 for (i
= 0; i
< pane_count
; ++i
)
2284 wxAuiPaneInfo
& pane
= all_panes
.Item(i
);
2285 if (pane
.name
== wxT("dummy"))
2287 wxAuiTabCtrl
* tabctrl
= ((wxTabFrame
*)pane
.window
)->m_tabs
;
2288 tabctrl
->SetFlags(m_flags
);
2296 bool wxAuiNotebook::AddPage(wxWindow
* page
,
2297 const wxString
& caption
,
2299 const wxBitmap
& bitmap
)
2301 return InsertPage(GetPageCount(), page
, caption
, select
, bitmap
);
2304 bool wxAuiNotebook::InsertPage(size_t page_idx
,
2306 const wxString
& caption
,
2308 const wxBitmap
& bitmap
)
2310 wxAuiNotebookPage info
;
2312 info
.caption
= caption
;
2313 info
.bitmap
= bitmap
;
2314 info
.active
= false;
2316 // if there are currently no tabs, the first added
2317 // tab must be active
2318 if (m_tabs
.GetPageCount() == 0)
2321 m_tabs
.InsertPage(page
, info
, page_idx
);
2323 wxAuiTabCtrl
* active_tabctrl
= GetActiveTabCtrl();
2324 if (page_idx
>= active_tabctrl
->GetPageCount())
2325 active_tabctrl
->AddPage(page
, info
);
2327 active_tabctrl
->InsertPage(page
, info
, page_idx
);
2330 active_tabctrl
->DoShowHide();
2334 int idx
= m_tabs
.GetIdxFromWindow(page
);
2335 wxASSERT_MSG(idx
!= -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
2344 // DeletePage() removes a tab from the multi-notebook,
2345 // and destroys the window as well
2346 bool wxAuiNotebook::DeletePage(size_t page_idx
)
2348 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(page_idx
);
2350 if (!RemovePage(page_idx
))
2354 // actually destroy the window now
2355 if (wnd
->IsKindOf(CLASSINFO(wxAuiMDIChildFrame
)))
2357 // delete the child frame with pending delete, as is
2358 // customary with frame windows
2359 if (!wxPendingDelete
.Member(wnd
))
2360 wxPendingDelete
.Append(wnd
);
2372 // RemovePage() removes a tab from the multi-notebook,
2373 // but does not destroy the window
2374 bool wxAuiNotebook::RemovePage(size_t page_idx
)
2376 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(page_idx
);
2377 wxWindow
* new_active
= NULL
;
2379 // find out which onscreen tab ctrl owns this tab
2382 if (!FindTab(wnd
, &ctrl
, &ctrl_idx
))
2385 // find a new page and set it as active
2386 int new_idx
= ctrl_idx
+1;
2387 if (new_idx
>= (int)ctrl
->GetPageCount())
2388 new_idx
= ctrl_idx
-1;
2390 if (new_idx
>= 0 && new_idx
< (int)ctrl
->GetPageCount())
2392 new_active
= ctrl
->GetWindowFromIdx(new_idx
);
2396 // set the active page to the first page that
2397 // isn't the one being deleted
2398 size_t i
, page_count
= m_tabs
.GetPageCount();
2399 for (i
= 0; i
< page_count
; ++i
)
2401 wxWindow
* w
= m_tabs
.GetWindowFromIdx(i
);
2404 new_active
= m_tabs
.GetWindowFromIdx(i
);
2410 // remove the tab from main catalog
2411 if (!m_tabs
.RemovePage(wnd
))
2414 // remove the tab from the onscreen tab ctrl
2415 ctrl
->RemovePage(wnd
);
2418 RemoveEmptyTabFrames();
2420 // set new active pane
2424 SetSelection(m_tabs
.GetIdxFromWindow(new_active
));
2430 // SetPageText() changes the tab caption of the specified page
2431 bool wxAuiNotebook::SetPageText(size_t page_idx
, const wxString
& text
)
2433 if (page_idx
>= m_tabs
.GetPageCount())
2436 // update our own tab catalog
2437 wxAuiNotebookPage
& page_info
= m_tabs
.GetPage(page_idx
);
2438 page_info
.caption
= text
;
2440 // update what's on screen
2443 if (FindTab(page_info
.window
, &ctrl
, &ctrl_idx
))
2445 wxAuiNotebookPage
& info
= ctrl
->GetPage(ctrl_idx
);
2446 info
.caption
= text
;
2454 // GetSelection() returns the index of the currently active page
2455 int wxAuiNotebook::GetSelection() const
2460 // SetSelection() sets the currently active page
2461 size_t wxAuiNotebook::SetSelection(size_t new_page
)
2463 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(new_page
);
2467 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
, m_windowId
);
2468 evt
.SetSelection(new_page
);
2469 evt
.SetOldSelection(m_curpage
);
2470 evt
.SetEventObject(this);
2471 if (!GetEventHandler()->ProcessEvent(evt
) || evt
.IsAllowed())
2473 // program allows the page change
2474 evt
.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED
);
2475 (void)GetEventHandler()->ProcessEvent(evt
);
2481 if (FindTab(wnd
, &ctrl
, &ctrl_idx
))
2483 m_tabs
.SetActivePage(wnd
);
2485 ctrl
->SetActivePage(ctrl_idx
);
2489 int old_curpage
= m_curpage
;
2490 m_curpage
= new_page
;
2494 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2495 size_t i
, pane_count
= all_panes
.GetCount();
2496 for (i
= 0; i
< pane_count
; ++i
)
2498 wxAuiPaneInfo
& pane
= all_panes
.Item(i
);
2499 if (pane
.name
== wxT("dummy"))
2501 wxAuiTabCtrl
* tabctrl
= ((wxTabFrame
*)pane
.window
)->m_tabs
;
2502 if (tabctrl
!= ctrl
)
2503 tabctrl
->SetSelectedFont(m_normal_font
);
2505 tabctrl
->SetSelectedFont(m_selected_font
);
2518 // GetPageCount() returns the total number of
2519 // pages managed by the multi-notebook
2520 size_t wxAuiNotebook::GetPageCount() const
2522 return m_tabs
.GetPageCount();
2525 // GetPage() returns the wxWindow pointer of the
2527 wxWindow
* wxAuiNotebook::GetPage(size_t page_idx
) const
2529 wxASSERT(page_idx
< m_tabs
.GetPageCount());
2531 return m_tabs
.GetWindowFromIdx(page_idx
);
2534 // DoSizing() performs all sizing operations in each tab control
2535 void wxAuiNotebook::DoSizing()
2537 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2538 size_t i
, pane_count
= all_panes
.GetCount();
2539 for (i
= 0; i
< pane_count
; ++i
)
2541 if (all_panes
.Item(i
).name
== wxT("dummy"))
2544 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
2545 tabframe
->DoSizing();
2549 // GetActiveTabCtrl() returns the active tab control. It is
2550 // called to determine which control gets new windows being added
2551 wxAuiTabCtrl
* wxAuiNotebook::GetActiveTabCtrl()
2553 if (m_curpage
>= 0 && m_curpage
< (int)m_tabs
.GetPageCount())
2558 // find the tab ctrl with the current page
2559 if (FindTab(m_tabs
.GetPage(m_curpage
).window
,
2566 // no current page, just find the first tab ctrl
2567 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2568 size_t i
, pane_count
= all_panes
.GetCount();
2569 for (i
= 0; i
< pane_count
; ++i
)
2571 if (all_panes
.Item(i
).name
== wxT("dummy"))
2574 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
2575 return tabframe
->m_tabs
;
2578 // If there is no tabframe at all, create one
2579 wxTabFrame
* tabframe
= new wxTabFrame
;
2580 tabframe
->SetTabCtrlHeight(m_tab_ctrl_height
);
2581 tabframe
->m_tabs
= new wxAuiTabCtrl(this,
2586 tabframe
->m_tabs
->SetFlags(m_flags
);
2587 tabframe
->m_tabs
->SetArtProvider(m_tabs
.GetArtProvider()->Clone());
2588 m_mgr
.AddPane(tabframe
,
2589 wxAuiPaneInfo().Center().CaptionVisible(false));
2593 return tabframe
->m_tabs
;
2596 // FindTab() finds the tab control that currently contains the window as well
2597 // as the index of the window in the tab control. It returns true if the
2598 // window was found, otherwise false.
2599 bool wxAuiNotebook::FindTab(wxWindow
* page
, wxAuiTabCtrl
** ctrl
, int* idx
)
2601 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2602 size_t i
, pane_count
= all_panes
.GetCount();
2603 for (i
= 0; i
< pane_count
; ++i
)
2605 if (all_panes
.Item(i
).name
== wxT("dummy"))
2608 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
2610 int page_idx
= tabframe
->m_tabs
->GetIdxFromWindow(page
);
2613 *ctrl
= tabframe
->m_tabs
;
2623 void wxAuiNotebook::OnEraseBackground(wxEraseEvent
&)
2627 void wxAuiNotebook::OnSize(wxSizeEvent
&)
2631 void wxAuiNotebook::OnTabClicked(wxCommandEvent
& command_evt
)
2633 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
2635 wxAuiTabCtrl
* ctrl
= (wxAuiTabCtrl
*)evt
.GetEventObject();
2636 wxASSERT(ctrl
!= NULL
);
2638 wxWindow
* wnd
= ctrl
->GetWindowFromIdx(evt
.GetSelection());
2639 wxASSERT(wnd
!= NULL
);
2641 int idx
= m_tabs
.GetIdxFromWindow(wnd
);
2642 wxASSERT(idx
!= -1);
2647 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent
&)
2652 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent
& evt
)
2654 wxPoint screen_pt
= ::wxGetMousePosition();
2655 wxPoint client_pt
= ScreenToClient(screen_pt
);
2658 wxAuiTabCtrl
* src_tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
2659 wxAuiTabCtrl
* dest_tabs
= GetTabCtrlFromPoint(client_pt
);
2661 if (dest_tabs
== src_tabs
)
2665 src_tabs
->SetCursor(wxCursor(wxCURSOR_ARROW
));
2668 // always hide the hint for inner-tabctrl drag
2671 // if tab moving is not allowed, leave
2672 if (!(m_flags
& wxAUI_NB_TAB_MOVE
))
2677 wxPoint pt
= dest_tabs
->ScreenToClient(screen_pt
);
2678 wxWindow
* dest_location_tab
;
2680 // this is an inner-tab drag/reposition
2681 if (dest_tabs
->TabHitTest(pt
.x
, pt
.y
, &dest_location_tab
))
2683 int src_idx
= evt
.GetSelection();
2684 int dest_idx
= dest_tabs
->GetIdxFromWindow(dest_location_tab
);
2686 // prevent jumpy drag
2687 if ((src_idx
== dest_idx
) || dest_idx
== -1 ||
2688 (src_idx
> dest_idx
&& m_last_drag_x
<= pt
.x
) ||
2689 (src_idx
< dest_idx
&& m_last_drag_x
>= pt
.x
))
2691 m_last_drag_x
= pt
.x
;
2696 wxWindow
* src_tab
= dest_tabs
->GetWindowFromIdx(src_idx
);
2697 dest_tabs
->MovePage(src_tab
, dest_idx
);
2698 dest_tabs
->SetActivePage((size_t)dest_idx
);
2699 dest_tabs
->DoShowHide();
2700 dest_tabs
->Refresh();
2701 m_last_drag_x
= pt
.x
;
2709 // if external drag is allowed, check if the tab is being dragged
2710 // over a different wxAuiNotebook control
2711 if (m_flags
& wxAUI_NB_TAB_EXTERNAL_MOVE
)
2713 wxWindow
* tab_ctrl
= ::wxFindWindowAtPoint(screen_pt
);
2715 // make sure we are not over the hint window
2716 if (tab_ctrl
&& !tab_ctrl
->IsKindOf(CLASSINFO(wxFrame
)))
2720 if (tab_ctrl
->IsKindOf(CLASSINFO(wxAuiTabCtrl
)))
2722 tab_ctrl
= tab_ctrl
->GetParent();
2727 wxAuiNotebook
* nb
= (wxAuiNotebook
*)tab_ctrl
->GetParent();
2731 wxRect hint_rect
= tab_ctrl
->GetRect();
2732 tab_ctrl
->ClientToScreen(&hint_rect
.x
, &hint_rect
.y
);
2733 m_mgr
.ShowHint(hint_rect
);
2742 // if there are less than two panes, split can't happen, so leave
2743 if (m_tabs
.GetPageCount() < 2)
2746 // if tab moving is not allowed, leave
2747 if (!(m_flags
& wxAUI_NB_TAB_SPLIT
))
2753 src_tabs
->SetCursor(wxCursor(wxCURSOR_SIZING
));
2759 wxRect hint_rect
= dest_tabs
->GetRect();
2760 ClientToScreen(&hint_rect
.x
, &hint_rect
.y
);
2761 m_mgr
.ShowHint(hint_rect
);
2765 m_mgr
.DrawHintRect(m_dummy_wnd
, client_pt
, zero
);
2771 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent
& command_evt
)
2773 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
2778 wxAuiTabCtrl
* src_tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
2779 wxAuiTabCtrl
* dest_tabs
= NULL
;
2782 // set cursor back to an arrow
2783 src_tabs
->SetCursor(wxCursor(wxCURSOR_ARROW
));
2786 // get the mouse position, which will be used to determine the drop point
2787 wxPoint mouse_screen_pt
= ::wxGetMousePosition();
2788 wxPoint mouse_client_pt
= ScreenToClient(mouse_screen_pt
);
2792 // check for an external move
2793 if (m_flags
& wxAUI_NB_TAB_EXTERNAL_MOVE
)
2795 wxWindow
* tab_ctrl
= ::wxFindWindowAtPoint(mouse_screen_pt
);
2799 if (tab_ctrl
->IsKindOf(CLASSINFO(wxAuiTabCtrl
)))
2801 tab_ctrl
= tab_ctrl
->GetParent();
2806 wxAuiNotebook
* nb
= (wxAuiNotebook
*)tab_ctrl
->GetParent();
2810 // find out from the destination control
2811 // if it's ok to drop this tab here
2812 wxAuiNotebookEvent
e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND
, m_windowId
);
2813 e
.SetSelection(evt
.GetSelection());
2814 e
.SetOldSelection(evt
.GetSelection());
2815 e
.SetEventObject(this);
2816 e
.SetDragSource(this);
2817 e
.Veto(); // dropping must be explicitly approved by control owner
2819 nb
->GetEventHandler()->ProcessEvent(e
);
2823 // no answer or negative answer
2829 int src_idx
= evt
.GetSelection();
2830 wxWindow
* src_page
= src_tabs
->GetWindowFromIdx(src_idx
);
2832 // get main index of the page
2833 int main_idx
= m_tabs
.GetIdxFromWindow(src_page
);
2835 // make a copy of the page info
2836 wxAuiNotebookPage page_info
= m_tabs
.GetPage((size_t)main_idx
);
2838 // remove the page from the source notebook
2839 RemovePage(main_idx
);
2841 // reparent the page
2842 src_page
->Reparent(nb
);
2845 // found out the insert idx
2846 wxAuiTabCtrl
* dest_tabs
= (wxAuiTabCtrl
*)tab_ctrl
;
2847 wxPoint pt
= dest_tabs
->ScreenToClient(mouse_screen_pt
);
2849 wxWindow
* target
= NULL
;
2850 int insert_idx
= -1;
2851 dest_tabs
->TabHitTest(pt
.x
, pt
.y
, &target
);
2854 insert_idx
= dest_tabs
->GetIdxFromWindow(target
);
2858 // add the page to the new notebook
2859 if (insert_idx
== -1)
2860 insert_idx
= dest_tabs
->GetPageCount();
2861 dest_tabs
->InsertPage(page_info
.window
, page_info
, insert_idx
);
2862 nb
->m_tabs
.AddPage(page_info
.window
, page_info
);
2865 dest_tabs
->DoShowHide();
2866 dest_tabs
->Refresh();
2868 // set the selection in the destination tab control
2869 nb
->SetSelection(nb
->m_tabs
.GetIdxFromWindow(page_info
.window
));
2879 // only perform a tab split if it's allowed
2880 if ((m_flags
& wxAUI_NB_TAB_SPLIT
) && m_tabs
.GetPageCount() >= 2)
2882 // If the pointer is in an existing tab frame, do a tab insert
2883 wxWindow
* hit_wnd
= ::wxFindWindowAtPoint(mouse_screen_pt
);
2884 wxTabFrame
* tab_frame
= (wxTabFrame
*)GetTabFrameFromTabCtrl(hit_wnd
);
2885 int insert_idx
= -1;
2888 dest_tabs
= tab_frame
->m_tabs
;
2890 if (dest_tabs
== src_tabs
)
2894 wxPoint pt
= dest_tabs
->ScreenToClient(mouse_screen_pt
);
2895 wxWindow
* target
= NULL
;
2896 dest_tabs
->TabHitTest(pt
.x
, pt
.y
, &target
);
2899 insert_idx
= dest_tabs
->GetIdxFromWindow(target
);
2904 // If there is no tabframe at all, create one
2905 wxTabFrame
* new_tabs
= new wxTabFrame
;
2906 new_tabs
->SetTabCtrlHeight(m_tab_ctrl_height
);
2907 new_tabs
->m_tabs
= new wxAuiTabCtrl(this,
2912 new_tabs
->m_tabs
->SetArtProvider(m_tabs
.GetArtProvider()->Clone());
2913 new_tabs
->m_tabs
->SetFlags(m_flags
);
2915 m_mgr
.AddPane(new_tabs
,
2916 wxAuiPaneInfo().Bottom().CaptionVisible(false),
2919 dest_tabs
= new_tabs
->m_tabs
;
2924 // remove the page from the source tabs
2925 wxAuiNotebookPage page_info
= src_tabs
->GetPage(evt
.GetSelection());
2926 page_info
.active
= false;
2927 src_tabs
->RemovePage(page_info
.window
);
2928 if (src_tabs
->GetPageCount() > 0)
2930 src_tabs
->SetActivePage((size_t)0);
2931 src_tabs
->DoShowHide();
2932 src_tabs
->Refresh();
2937 // add the page to the destination tabs
2938 if (insert_idx
== -1)
2939 insert_idx
= dest_tabs
->GetPageCount();
2940 dest_tabs
->InsertPage(page_info
.window
, page_info
, insert_idx
);
2942 if (src_tabs
->GetPageCount() == 0)
2944 RemoveEmptyTabFrames();
2948 dest_tabs
->DoShowHide();
2949 dest_tabs
->Refresh();
2951 SetSelection(m_tabs
.GetIdxFromWindow(page_info
.window
));
2957 wxAuiTabCtrl
* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint
& pt
)
2959 // if we've just removed the last tab from the source
2960 // tab set, the remove the tab control completely
2961 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2962 size_t i
, pane_count
= all_panes
.GetCount();
2963 for (i
= 0; i
< pane_count
; ++i
)
2965 if (all_panes
.Item(i
).name
== wxT("dummy"))
2968 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
2969 if (tabframe
->m_tab_rect
.Contains(pt
))
2970 return tabframe
->m_tabs
;
2976 wxWindow
* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow
* tab_ctrl
)
2978 // if we've just removed the last tab from the source
2979 // tab set, the remove the tab control completely
2980 wxAuiPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
2981 size_t i
, pane_count
= all_panes
.GetCount();
2982 for (i
= 0; i
< pane_count
; ++i
)
2984 if (all_panes
.Item(i
).name
== wxT("dummy"))
2987 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
2988 if (tabframe
->m_tabs
== tab_ctrl
)
2997 void wxAuiNotebook::RemoveEmptyTabFrames()
2999 // if we've just removed the last tab from the source
3000 // tab set, the remove the tab control completely
3001 wxAuiPaneInfoArray all_panes
= m_mgr
.GetAllPanes();
3002 size_t i
, pane_count
= all_panes
.GetCount();
3003 for (i
= 0; i
< pane_count
; ++i
)
3005 if (all_panes
.Item(i
).name
== wxT("dummy"))
3008 wxTabFrame
* tab_frame
= (wxTabFrame
*)all_panes
.Item(i
).window
;
3009 if (tab_frame
->m_tabs
->GetPageCount() == 0)
3011 m_mgr
.DetachPane(tab_frame
);
3013 // use pending delete because sometimes during
3014 // window closing, refreshs are pending
3015 if (!wxPendingDelete
.Member(tab_frame
->m_tabs
))
3016 wxPendingDelete
.Append(tab_frame
->m_tabs
);
3017 //tab_frame->m_tabs->Destroy();
3024 // check to see if there is still a center pane;
3025 // if there isn't, make a frame the center pane
3026 wxAuiPaneInfoArray panes
= m_mgr
.GetAllPanes();
3027 pane_count
= panes
.GetCount();
3028 wxWindow
* first_good
= NULL
;
3029 bool center_found
= false;
3030 for (i
= 0; i
< pane_count
; ++i
)
3032 if (panes
.Item(i
).name
== wxT("dummy"))
3034 if (panes
.Item(i
).dock_direction
== wxAUI_DOCK_CENTRE
)
3035 center_found
= true;
3037 first_good
= panes
.Item(i
).window
;
3040 if (!center_found
&& first_good
)
3042 m_mgr
.GetPane(first_good
).Centre();
3048 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent
& evt
)
3050 int idx
= m_tabs
.GetIdxFromWindow(evt
.GetWindow());
3051 if (idx
!= -1 && idx
!= m_curpage
)
3058 void wxAuiNotebook::OnTabButton(wxCommandEvent
& command_evt
)
3060 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
3061 wxAuiTabCtrl
* tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
3063 int button_id
= evt
.GetInt();
3065 if (button_id
== wxAUI_BUTTON_CLOSE
)
3067 int selection
= tabs
->GetActivePage();
3069 if (selection
!= -1)
3071 wxWindow
* close_wnd
= tabs
->GetWindowFromIdx(selection
);
3074 // ask owner if it's ok to close the tab
3075 wxAuiNotebookEvent
e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE
, m_windowId
);
3076 e
.SetSelection(m_tabs
.GetIdxFromWindow(close_wnd
));
3077 e
.SetOldSelection(evt
.GetSelection());
3078 e
.SetEventObject(this);
3079 GetEventHandler()->ProcessEvent(e
);
3084 if (close_wnd
->IsKindOf(CLASSINFO(wxAuiMDIChildFrame
)))
3090 int main_idx
= m_tabs
.GetIdxFromWindow(close_wnd
);
3091 DeletePage(main_idx
);