1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/notebook.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/settings.h"
24 #include "wx/aui/auibook.h"
25 #include "wx/aui/tabmdi.h"
26 #include "wx/dcbuffer.h"
31 #include "wx/arrimpl.cpp"
32 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray
)
33 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray
)
35 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
)
36 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED
)
37 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BUTTON
)
38 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
)
39 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
)
40 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
)
44 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent
, wxEvent
)
46 // -- wxAuiTabContainer class implementation --
49 // wxAuiTabContainer is a class which contains information about each
50 // tab. It also can render an entire tab control to a specified DC.
51 // It's not a window class itself, because this code will be used by
52 // the wxFrameMananger, where it is disadvantageous to have separate
53 // windows for each tab control in the case of "docked tabs"
55 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
56 // which can be used as a tab control in the normal sense.
59 // This functions are here for this proof of concept
60 // and will be factored out later. See dockart.cpp
61 static wxColor
StepColour(const wxColor
& c
, int percent
)
63 int r
= c
.Red(), g
= c
.Green(), b
= c
.Blue();
64 return wxColour((unsigned char)wxMin((r
*percent
)/100,255),
65 (unsigned char)wxMin((g
*percent
)/100,255),
66 (unsigned char)wxMin((b
*percent
)/100,255));
69 // This functions are here for this proof of concept
70 // and will be factored out later. See dockart.cpp
71 static wxBitmap
BitmapFromBits(const unsigned char bits
[], int w
, int h
,
72 const wxColour
& color
)
74 wxImage img
= wxBitmap((const char*)bits
, w
, h
).ConvertToImage();
75 img
.Replace(255,255,255,123,123,123);
76 img
.Replace(0,0,0,color
.Red(),color
.Green(),color
.Blue());
77 img
.SetMaskColour(123,123,123);
81 static void DrawButton(wxDC
& dc
,
84 const wxColour
& bkcolour
,
89 if (button_state
== wxAUI_BUTTON_STATE_PRESSED
)
95 if (button_state
== wxAUI_BUTTON_STATE_HOVER
||
96 button_state
== wxAUI_BUTTON_STATE_PRESSED
)
98 dc
.SetBrush(wxBrush(StepColour(bkcolour
, 120)));
99 dc
.SetPen(wxPen(StepColour(bkcolour
, 70)));
101 // draw the background behind the button
102 dc
.DrawRectangle(rect
.x
, rect
.y
, 15, 15);
105 // draw the button itself
106 dc
.DrawBitmap(bmp
, rect
.x
, rect
.y
, true);
112 wxAuiTabContainer::wxAuiTabContainer()
114 m_normal_font
= *wxNORMAL_FONT
;
115 m_selected_font
= *wxNORMAL_FONT
;
116 m_selected_font
.SetWeight(wxBOLD
);
117 m_measuring_font
= m_selected_font
;
119 wxColour base_colour
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
121 wxColour background_colour
= StepColour(base_colour
, 95);
122 wxColour normaltab_colour
= base_colour
;
123 wxColour selectedtab_colour
= *wxWHITE
;
125 m_bkbrush
= wxBrush(background_colour
);
126 m_normal_bkbrush
= wxBrush(normaltab_colour
);
127 m_normal_bkpen
= wxPen(normaltab_colour
);
128 m_selected_bkbrush
= wxBrush(selectedtab_colour
);
129 m_selected_bkpen
= wxPen(selectedtab_colour
);
132 wxAuiTabContainer::~wxAuiTabContainer()
136 void wxAuiTabContainer::SetNormalFont(const wxFont
& font
)
138 m_normal_font
= font
;
141 void wxAuiTabContainer::SetSelectedFont(const wxFont
& font
)
143 m_selected_font
= font
;
146 void wxAuiTabContainer::SetMeasuringFont(const wxFont
& font
)
148 m_measuring_font
= font
;
151 void wxAuiTabContainer::SetRect(const wxRect
& rect
)
156 bool wxAuiTabContainer::AddPage(wxWindow
* page
,
157 const wxAuiNotebookPage
& info
)
159 wxAuiNotebookPage page_info
;
161 page_info
.window
= page
;
163 m_pages
.Add(page_info
);
168 bool wxAuiTabContainer::InsertPage(wxWindow
* page
,
169 const wxAuiNotebookPage
& info
,
172 wxAuiNotebookPage page_info
;
174 page_info
.window
= page
;
176 if (idx
>= m_pages
.GetCount())
177 m_pages
.Add(page_info
);
179 m_pages
.Insert(page_info
, idx
);
184 bool wxAuiTabContainer::RemovePage(wxWindow
* wnd
)
186 size_t i
, page_count
= m_pages
.GetCount();
187 for (i
= 0; i
< page_count
; ++i
)
189 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
190 if (page
.window
== wnd
)
200 bool wxAuiTabContainer::SetActivePage(wxWindow
* wnd
)
204 size_t i
, page_count
= m_pages
.GetCount();
205 for (i
= 0; i
< page_count
; ++i
)
207 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
208 if (page
.window
== wnd
)
222 void wxAuiTabContainer::SetNoneActive()
224 size_t i
, page_count
= m_pages
.GetCount();
225 for (i
= 0; i
< page_count
; ++i
)
227 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
232 bool wxAuiTabContainer::SetActivePage(size_t page
)
234 if (page
>= m_pages
.GetCount())
237 return SetActivePage(m_pages
.Item(page
).window
);
240 int wxAuiTabContainer::GetActivePage() const
242 size_t i
, page_count
= m_pages
.GetCount();
243 for (i
= 0; i
< page_count
; ++i
)
245 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
253 wxWindow
* wxAuiTabContainer::GetWindowFromIdx(size_t idx
) const
255 if (idx
>= m_pages
.GetCount())
258 return m_pages
[idx
].window
;
261 int wxAuiTabContainer::GetIdxFromWindow(wxWindow
* wnd
) const
263 size_t i
, page_count
= m_pages
.GetCount();
264 for (i
= 0; i
< page_count
; ++i
)
266 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
267 if (page
.window
== wnd
)
273 wxAuiNotebookPage
& wxAuiTabContainer::GetPage(size_t idx
)
275 wxASSERT_MSG(idx
< m_pages
.GetCount(), wxT("Invalid Page index"));
280 wxAuiNotebookPageArray
& wxAuiTabContainer::GetPages()
285 size_t wxAuiTabContainer::GetPageCount() const
287 return m_pages
.GetCount();
290 void wxAuiTabContainer::AddButton(int id
, const wxBitmap
& bmp
)
292 wxAuiTabContainerButton button
;
295 button
.cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
297 m_buttons
.Add(button
);
302 // DrawTab() draws an individual tab.
303 // As it is virtual it may be overridden.
306 // in_rect - rectangle the tab should be confined to
307 // caption - tab's caption
308 // active - whether or not the tab is active
309 // out_rect - actual output rectangle
310 // x_extent - the advance x; where the next tab should start
312 void wxAuiTabContainer::DrawTab(wxDC
* dc
,
313 const wxRect
& in_rect
,
314 const wxString
& caption
,
319 wxCoord normal_textx
, normal_texty
;
320 wxCoord selected_textx
, selected_texty
;
321 wxCoord measured_textx
, measured_texty
;
322 wxCoord textx
, texty
;
326 dc
->SetFont(m_measuring_font
);
327 dc
->GetTextExtent(caption
, &measured_textx
, &measured_texty
);
329 dc
->SetFont(m_selected_font
);
330 dc
->GetTextExtent(caption
, &selected_textx
, &selected_texty
);
332 dc
->SetFont(m_normal_font
);
333 dc
->GetTextExtent(caption
, &normal_textx
, &normal_texty
);
336 wxCoord tab_height
= measured_texty
+ 4;
337 wxCoord tab_width
= measured_textx
+ tab_height
+ 5;
338 wxCoord tab_x
= in_rect
.x
;
339 wxCoord tab_y
= in_rect
.y
+ in_rect
.height
- tab_height
;
342 // select pen, brush and font for the tab to be drawn
346 dc
->SetPen(m_selected_bkpen
);
347 dc
->SetBrush(m_selected_bkbrush
);
348 dc
->SetFont(m_selected_font
);
349 textx
= selected_textx
;
350 texty
= selected_texty
;
354 dc
->SetPen(m_normal_bkpen
);
355 dc
->SetBrush(m_normal_bkbrush
);
356 dc
->SetFont(m_normal_font
);
357 textx
= normal_textx
;
358 texty
= normal_texty
;
366 points
[0].y
= tab_y
+ tab_height
- 1;
367 points
[1].x
= tab_x
+ tab_height
- 3;
368 points
[1].y
= tab_y
+ 2;
369 points
[2].x
= tab_x
+ tab_height
+ 3;
371 points
[3].x
= tab_x
+ tab_width
- 2;
373 points
[4].x
= tab_x
+ tab_width
;
374 points
[4].y
= tab_y
+ 2;
375 points
[5].x
= tab_x
+ tab_width
;
376 points
[5].y
= tab_y
+ tab_height
- 1;
377 points
[6] = points
[0];
380 dc
->DrawPolygon(6, points
);
382 dc
->SetPen(*wxGREY_PEN
);
384 //dc->DrawLines(active ? 6 : 7, points);
385 dc
->DrawLines(7, points
);
389 dc
->DrawText(caption
,
390 tab_x
+ (tab_height
/3) + (tab_width
/2) - (textx
/2),
391 tab_y
+ tab_height
- texty
- 2);
393 *out_rect
= wxRect(tab_x
, tab_y
, tab_width
, tab_height
);
394 *x_extent
= tab_width
- (tab_height
/2) - 1;
398 // Render() renders the tab catalog to the specified DC
399 // It is a virtual function and can be overridden to
400 // provide custom drawing capabilities
401 void wxAuiTabContainer::Render(wxDC
* raw_dc
)
405 bmp
.Create(m_rect
.GetWidth(), m_rect
.GetHeight());
406 dc
.SelectObject(bmp
);
409 dc
.SetBrush(m_bkbrush
);
410 dc
.SetPen(*wxTRANSPARENT_PEN
);
411 dc
.DrawRectangle(-1, -1, m_rect
.GetWidth()+2, m_rect
.GetHeight()+2);
414 dc
.SetPen(*wxGREY_PEN
);
415 dc
.DrawLine(0, m_rect
.GetHeight()-1, m_rect
.GetWidth(), m_rect
.GetHeight()-1);
418 size_t i
, page_count
= m_pages
.GetCount();
422 int active_offset
= 0;
425 wxRect rect
= m_rect
;
428 rect
.height
= m_rect
.height
;
430 for (i
= 0; i
< page_count
; ++i
)
432 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
446 active_offset
= offset
;
452 // draw the active tab again so it stands in the foreground
453 if (active
< m_pages
.GetCount())
455 wxAuiNotebookPage
& page
= m_pages
.Item(active
);
457 rect
.x
= active_offset
;
467 offset
= m_rect
.x
+ m_rect
.width
;
468 size_t button_count
= m_buttons
.GetCount();
469 for (i
= 0; i
< button_count
; ++i
)
471 wxAuiTabContainerButton
& button
= m_buttons
.Item(button_count
- i
- 1);
473 wxRect
button_rect(offset
- button
.bitmap
.GetWidth(), 1,
474 button
.bitmap
.GetWidth(), button
.bitmap
.GetHeight());
476 button
.rect
= button_rect
;
478 DrawButton(dc
, button
.rect
, button
.bitmap
,
479 m_bkbrush
.GetColour(),
482 offset
-= button
.bitmap
.GetWidth();
486 raw_dc
->Blit(m_rect
.x
, m_rect
.y
, m_rect
.GetWidth(), m_rect
.GetHeight(), &dc
, 0, 0);
490 // TabHitTest() tests if a tab was hit, passing the window pointer
491 // back if that condition was fulfilled. The function returns
492 // true if a tab was hit, otherwise false
493 bool wxAuiTabContainer::TabHitTest(int x
, int y
, wxWindow
** hit
) const
495 if (!m_rect
.Inside(x
,y
))
498 size_t i
, page_count
= m_pages
.GetCount();
500 for (i
= 0; i
< page_count
; ++i
)
502 wxAuiNotebookPage
& page
= m_pages
.Item(i
);
503 if (page
.rect
.Inside(x
,y
))
513 // ButtonHitTest() tests if a button was hit. The function returns
514 // true if a button was hit, otherwise false
515 bool wxAuiTabContainer::ButtonHitTest(int x
, int y
,
516 wxAuiTabContainerButton
** hit
) const
518 if (!m_rect
.Inside(x
,y
))
521 size_t i
, button_count
= m_buttons
.GetCount();
523 for (i
= 0; i
< button_count
; ++i
)
525 wxAuiTabContainerButton
& button
= m_buttons
.Item(i
);
526 if (button
.rect
.Inside(x
,y
))
538 // the utility function ShowWnd() is the same as show,
539 // except it handles wxTabMDIChildFrame windows as well,
540 // as the Show() method on this class is "unplugged"
541 static void ShowWnd(wxWindow
* wnd
, bool show
)
543 if (wnd
->IsKindOf(CLASSINFO(wxTabMDIChildFrame
)))
545 wxTabMDIChildFrame
* cf
= (wxTabMDIChildFrame
*)wnd
;
555 // DoShowHide() this function shows the active window, then
556 // hides all of the other windows (in that order)
557 void wxAuiTabContainer::DoShowHide()
559 wxAuiNotebookPageArray
& pages
= GetPages();
560 size_t i
, page_count
= pages
.GetCount();
562 // show new active page first
563 for (i
= 0; i
< page_count
; ++i
)
565 wxAuiNotebookPage
& page
= pages
.Item(i
);
568 ShowWnd(page
.window
, true);
573 // hide all other pages
574 for (i
= 0; i
< page_count
; ++i
)
576 wxAuiNotebookPage
& page
= pages
.Item(i
);
577 ShowWnd(page
.window
, page
.active
);
586 // -- wxAuiTabCtrl class implementation --
589 const int wxAuiButtonClose
= 101;
591 BEGIN_EVENT_TABLE(wxAuiTabCtrl
, wxControl
)
592 EVT_PAINT(wxAuiTabCtrl::OnPaint
)
593 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground
)
594 EVT_SIZE(wxAuiTabCtrl::OnSize
)
595 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown
)
596 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp
)
597 EVT_MOTION(wxAuiTabCtrl::OnMotion
)
598 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow
)
602 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow
* parent
,
606 long style
) : wxControl(parent
, id
, pos
, size
, style
)
608 m_click_pt
= wxDefaultPosition
;
609 m_is_dragging
= false;
610 m_hover_button
= NULL
;
612 // copied from dockart-- needs to put in a common place
613 static unsigned char close_bits
[]={
614 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
615 0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
616 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
618 AddButton(101, BitmapFromBits(close_bits
, 16, 16, *wxBLACK
));
622 void wxAuiTabCtrl::OnPaint(wxPaintEvent
&)
626 dc
.SetFont(GetFont());
628 if (GetPageCount() > 0)
632 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent
& WXUNUSED(evt
))
636 void wxAuiTabCtrl::OnSize(wxSizeEvent
& evt
)
638 wxSize s
= evt
.GetSize();
639 wxRect
r(0, 0, s
.GetWidth(), s
.GetHeight());
643 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent
& evt
)
646 m_click_pt
= wxDefaultPosition
;
647 m_is_dragging
= false;
651 if (TabHitTest(evt
.m_x
, evt
.m_y
, &wnd
))
653 wxAuiNotebookEvent
e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
, m_windowId
);
654 e
.SetSelection(GetIdxFromWindow(wnd
));
655 e
.SetOldSelection(GetActivePage());
656 e
.SetEventObject(this);
657 GetEventHandler()->ProcessEvent(e
);
659 m_click_pt
.x
= evt
.m_x
;
660 m_click_pt
.y
= evt
.m_y
;
661 m_click_tab
= e
.GetSelection();
666 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_PRESSED
;
672 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent
&)
674 if (GetCapture() == this)
679 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
, m_windowId
);
680 evt
.SetSelection(m_click_tab
);
681 evt
.SetOldSelection(m_click_tab
);
682 evt
.SetEventObject(this);
683 GetEventHandler()->ProcessEvent(evt
);
689 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_HOVER
;
693 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON
, m_windowId
);
694 evt
.SetInt(m_hover_button
->id
);
695 evt
.SetEventObject(this);
696 GetEventHandler()->ProcessEvent(evt
);
699 m_click_pt
= wxDefaultPosition
;
700 m_is_dragging
= false;
704 void wxAuiTabCtrl::OnMotion(wxMouseEvent
& evt
)
706 wxPoint pos
= evt
.GetPosition();
708 // check if the mouse is hovering above a button
709 wxAuiTabContainerButton
* button
;
710 if (ButtonHitTest(pos
.x
, pos
.y
, &button
))
712 if (button
->cur_state
!= wxAUI_BUTTON_STATE_HOVER
)
714 button
->cur_state
= wxAUI_BUTTON_STATE_HOVER
;
717 m_hover_button
= button
;
725 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
726 m_hover_button
= NULL
;
733 if (!evt
.LeftIsDown() || m_click_pt
== wxDefaultPosition
)
738 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
, m_windowId
);
739 evt
.SetSelection(m_click_tab
);
740 evt
.SetOldSelection(m_click_tab
);
741 evt
.SetEventObject(this);
742 GetEventHandler()->ProcessEvent(evt
);
747 int drag_x_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_X
);
748 int drag_y_threshold
= wxSystemSettings::GetMetric(wxSYS_DRAG_Y
);
750 if (abs(pos
.x
- m_click_pt
.x
) > drag_x_threshold
||
751 abs(pos
.y
- m_click_pt
.y
) > drag_y_threshold
)
753 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
, m_windowId
);
754 evt
.SetSelection(m_click_tab
);
755 evt
.SetOldSelection(m_click_tab
);
756 evt
.SetEventObject(this);
757 GetEventHandler()->ProcessEvent(evt
);
759 m_is_dragging
= true;
763 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent
& WXUNUSED(event
))
767 m_hover_button
->cur_state
= wxAUI_BUTTON_STATE_NORMAL
;
768 m_hover_button
= NULL
;
775 // wxTabFrame is an interesting case. It's important that all child pages
776 // of the multi-notebook control are all actually children of that control
777 // (and not grandchildren). wxTabFrame facilitates this. There is one
778 // instance of wxTabFrame for each tab control inside the multi-notebook.
779 // It's important to know that wxTabFrame is not a real window, but it merely
780 // used to capture the dimensions/positioning of the internal tab control and
781 // it's managed page windows
783 class wxTabFrame
: public wxWindow
790 m_rect
= wxRect(0,0,200,200);
791 m_tab_ctrl_height
= 20;
794 void SetTabCtrlHeight(int h
)
796 m_tab_ctrl_height
= h
;
799 void DoSetSize(int x
, int y
,
800 int width
, int height
,
801 int WXUNUSED(sizeFlags
= wxSIZE_AUTO
))
803 m_rect
= wxRect(x
, y
, width
, height
);
807 void DoGetClientSize(int* x
, int* y
) const
813 bool Show( bool WXUNUSED(show
= true) ) { return false; }
820 int tab_height
= wxMin(m_rect
.height
, m_tab_ctrl_height
);
821 m_tab_rect
= wxRect(m_rect
.x
, m_rect
.y
, m_rect
.width
, tab_height
);
822 m_tabs
->SetSize(m_rect
.x
, m_rect
.y
, m_rect
.width
, tab_height
);
823 m_tabs
->SetRect(wxRect(0, 0, m_rect
.width
, tab_height
));
826 wxAuiNotebookPageArray
& pages
= m_tabs
->GetPages();
827 size_t i
, page_count
= pages
.GetCount();
829 for (i
= 0; i
< page_count
; ++i
)
831 wxAuiNotebookPage
& page
= pages
.Item(i
);
832 page
.window
->SetSize(m_rect
.x
, m_rect
.y
+tab_height
, m_rect
.width
, m_rect
.height
-tab_height
);
834 if (page
.window
->IsKindOf(CLASSINFO(wxTabMDIChildFrame
)))
836 wxTabMDIChildFrame
* wnd
= (wxTabMDIChildFrame
*)page
.window
;
837 wnd
->ApplyMDIChildFrameRect();
842 void DoGetSize(int* x
, int* y
) const
845 *x
= m_rect
.GetWidth();
847 *y
= m_rect
.GetHeight();
859 wxAuiTabCtrl
* m_tabs
;
860 int m_tab_ctrl_height
;
867 // -- wxAuiMultiNotebook class implementation --
869 BEGIN_EVENT_TABLE(wxAuiMultiNotebook
, wxControl
)
870 //EVT_ERASE_BACKGROUND(wxAuiMultiNotebook::OnEraseBackground)
871 //EVT_SIZE(wxAuiMultiNotebook::OnSize)
872 //EVT_LEFT_DOWN(wxAuiMultiNotebook::OnLeftDown)
873 EVT_CHILD_FOCUS(wxAuiMultiNotebook::OnChildFocus
)
874 EVT_COMMAND_RANGE(10000, 10100,
875 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
,
876 wxAuiMultiNotebook::OnTabClicked
)
877 EVT_COMMAND_RANGE(10000, 10100,
878 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG
,
879 wxAuiMultiNotebook::OnTabBeginDrag
)
880 EVT_COMMAND_RANGE(10000, 10100,
881 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG
,
882 wxAuiMultiNotebook::OnTabEndDrag
)
883 EVT_COMMAND_RANGE(10000, 10100,
884 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION
,
885 wxAuiMultiNotebook::OnTabDragMotion
)
886 EVT_COMMAND_RANGE(10000, 10100,
887 wxEVT_COMMAND_AUINOTEBOOK_BUTTON
,
888 wxAuiMultiNotebook::OnTabButton
)
891 wxAuiMultiNotebook::wxAuiMultiNotebook()
894 m_tab_id_counter
= 10000;
896 m_tab_ctrl_height
= 20;
899 wxAuiMultiNotebook::wxAuiMultiNotebook(wxWindow
*parent
,
903 long style
) : wxControl(parent
, id
, pos
, size
, style
)
908 bool wxAuiMultiNotebook::Create(wxWindow
* parent
,
914 if (!wxControl::Create(parent
, id
, pos
, size
, style
))
922 // InitNotebook() contains common initialization
923 // code called by all constructors
924 void wxAuiMultiNotebook::InitNotebook()
927 m_tab_id_counter
= 10000;
929 m_tab_ctrl_height
= 20;
931 m_normal_font
= *wxNORMAL_FONT
;
932 m_selected_font
= *wxNORMAL_FONT
;
933 m_selected_font
.SetWeight(wxBOLD
);
935 // choose a default for the tab height
938 dc
.SetFont(m_selected_font
);
939 dc
.GetTextExtent(wxT("ABCDEFGHhijklm"), &tx
, &ty
);
940 m_tab_ctrl_height
= (ty
*150)/100;
942 m_dummy_wnd
= new wxWindow(this, -1, wxPoint(0,0), wxSize(0,0));
943 m_dummy_wnd
->SetSize(200, 200);
944 m_dummy_wnd
->Show(false);
946 m_mgr
.SetManagedWindow(this);
948 m_mgr
.AddPane(m_dummy_wnd
,
949 wxPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
954 wxAuiMultiNotebook::~wxAuiMultiNotebook()
959 bool wxAuiMultiNotebook::AddPage(wxWindow
* page
,
960 const wxString
& caption
,
962 const wxBitmap
& bitmap
)
964 return InsertPage(GetPageCount(), page
, caption
, select
, bitmap
);
967 bool wxAuiMultiNotebook::InsertPage(size_t page_idx
,
969 const wxString
& caption
,
971 const wxBitmap
& bitmap
)
973 wxAuiNotebookPage info
;
975 info
.caption
= caption
;
976 info
.bitmap
= bitmap
;
979 // if there are currently no tabs, the first added
980 // tab must be active
981 if (m_tabs
.GetPageCount() == 0)
984 m_tabs
.InsertPage(page
, info
, page_idx
);
986 wxAuiTabCtrl
* active_tabctrl
= GetActiveTabCtrl();
987 if (page_idx
>= active_tabctrl
->GetPageCount())
988 active_tabctrl
->AddPage(page
, info
);
990 active_tabctrl
->InsertPage(page
, info
, page_idx
);
993 active_tabctrl
->DoShowHide();
997 int idx
= m_tabs
.GetIdxFromWindow(page
);
998 wxASSERT_MSG(idx
!= -1, wxT("Invalid Page index returned on wxAuiMultiNotebook::InsertPage()"));
1007 // DeletePage() removes a tab from the multi-notebook,
1008 // and destroys the window as well
1009 bool wxAuiMultiNotebook::DeletePage(size_t page_idx
)
1011 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(page_idx
);
1014 // find out which onscreen tab ctrl owns this tab
1017 if (!FindTab(wnd
, &ctrl
, &ctrl_idx
))
1020 // find a new page and set it as active
1021 int new_idx
= ctrl_idx
+1;
1022 if (new_idx
>= (int)ctrl
->GetPageCount())
1023 new_idx
= ctrl_idx
-1;
1025 if (new_idx
>= 0 && new_idx
< (int)ctrl
->GetPageCount())
1027 wxWindow
* new_wnd
= ctrl
->GetWindowFromIdx(new_idx
);
1028 int main_idx
= m_tabs
.GetIdxFromWindow(new_wnd
);
1029 wxASSERT(main_idx
!= -1);
1030 SetSelection(main_idx
);
1034 // set the active page to the first page that
1035 // isn't the one being deleted
1037 size_t i
, page_count
= m_tabs
.GetPageCount();
1038 for (i
= 0; i
< page_count
; ++i
)
1040 wxWindow
* w
= m_tabs
.GetWindowFromIdx(i
);
1054 // remove the tab from main catalog
1055 if (!m_tabs
.RemovePage(wnd
))
1058 // remove the tab from the onscreen tab ctrl
1059 ctrl
->RemovePage(wnd
);
1061 // actually destroy the window now
1062 if (wnd
->IsKindOf(CLASSINFO(wxTabMDIChildFrame
)))
1064 // delete the child frame with pending delete, as is
1065 // customary with frame windows
1066 if (!wxPendingDelete
.Member(wnd
))
1067 wxPendingDelete
.Append(wnd
);
1074 RemoveEmptyTabFrames();
1081 // RemovePage() removes a tab from the multi-notebook,
1082 // but does not destroy the window
1083 bool wxAuiMultiNotebook::RemovePage(size_t page_idx
)
1085 // remove the tab from our own catalog
1086 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(page_idx
);
1087 if (!m_tabs
.RemovePage(wnd
))
1090 // remove the tab from the onscreen tab ctrl
1093 if (FindTab(wnd
, &ctrl
, &ctrl_idx
))
1095 ctrl
->RemovePage(wnd
);
1102 // SetPageText() changes the tab caption of the specified page
1103 bool wxAuiMultiNotebook::SetPageText(size_t page_idx
, const wxString
& text
)
1105 if (page_idx
>= m_tabs
.GetPageCount())
1108 // update our own tab catalog
1109 wxAuiNotebookPage
& page_info
= m_tabs
.GetPage(page_idx
);
1110 page_info
.caption
= text
;
1112 // update what's on screen
1115 if (FindTab(page_info
.window
, &ctrl
, &ctrl_idx
))
1117 wxAuiNotebookPage
& info
= ctrl
->GetPage(ctrl_idx
);
1118 info
.caption
= text
;
1126 // GetSelection() returns the index of the currently active page
1127 int wxAuiMultiNotebook::GetSelection() const
1132 // SetSelection() sets the currently active page
1133 size_t wxAuiMultiNotebook::SetSelection(size_t new_page
)
1135 wxWindow
* wnd
= m_tabs
.GetWindowFromIdx(new_page
);
1139 wxAuiNotebookEvent
evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING
, m_windowId
);
1140 evt
.SetSelection(new_page
);
1141 evt
.SetOldSelection(m_curpage
);
1142 evt
.SetEventObject(this);
1143 if (!GetEventHandler()->ProcessEvent(evt
) || evt
.IsAllowed())
1145 // program allows the page change
1146 evt
.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED
);
1147 (void)GetEventHandler()->ProcessEvent(evt
);
1153 if (FindTab(wnd
, &ctrl
, &ctrl_idx
))
1155 m_tabs
.SetActivePage(wnd
);
1157 ctrl
->SetActivePage(ctrl_idx
);
1161 int old_curpage
= m_curpage
;
1162 m_curpage
= new_page
;
1166 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1167 size_t i
, pane_count
= all_panes
.GetCount();
1168 for (i
= 0; i
< pane_count
; ++i
)
1170 wxPaneInfo
& pane
= all_panes
.Item(i
);
1171 if (pane
.name
== wxT("dummy"))
1173 wxAuiTabCtrl
* tabctrl
= ((wxTabFrame
*)pane
.window
)->m_tabs
;
1174 if (tabctrl
!= ctrl
)
1175 tabctrl
->SetSelectedFont(m_normal_font
);
1177 tabctrl
->SetSelectedFont(m_selected_font
);
1190 // GetPageCount() returns the total number of
1191 // pages managed by the multi-notebook
1192 size_t wxAuiMultiNotebook::GetPageCount() const
1194 return m_tabs
.GetPageCount();
1197 // GetPage() returns the wxWindow pointer of the
1199 wxWindow
* wxAuiMultiNotebook::GetPage(size_t page_idx
) const
1201 wxASSERT(page_idx
< m_tabs
.GetPageCount());
1203 return m_tabs
.GetWindowFromIdx(page_idx
);
1206 // DoSizing() performs all sizing operations in each tab control
1207 void wxAuiMultiNotebook::DoSizing()
1209 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1210 size_t i
, pane_count
= all_panes
.GetCount();
1211 for (i
= 0; i
< pane_count
; ++i
)
1213 if (all_panes
.Item(i
).name
== wxT("dummy"))
1216 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1217 tabframe
->DoSizing();
1221 // GetActiveTabCtrl() returns the active tab control. It is
1222 // called to determine which control gets new windows being added
1223 wxAuiTabCtrl
* wxAuiMultiNotebook::GetActiveTabCtrl()
1225 if (m_curpage
>= 0 && m_curpage
< (int)m_tabs
.GetPageCount())
1230 // find the tab ctrl with the current page
1231 if (FindTab(m_tabs
.GetPage(m_curpage
).window
,
1238 // no current page, just find the first tab ctrl
1239 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1240 size_t i
, pane_count
= all_panes
.GetCount();
1241 for (i
= 0; i
< pane_count
; ++i
)
1243 if (all_panes
.Item(i
).name
== wxT("dummy"))
1246 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1247 return tabframe
->m_tabs
;
1250 // If there is no tabframe at all, create one
1251 wxTabFrame
* tabframe
= new wxTabFrame
;
1252 tabframe
->SetTabCtrlHeight(m_tab_ctrl_height
);
1253 tabframe
->m_tabs
= new wxAuiTabCtrl(this,
1258 m_mgr
.AddPane(tabframe
,
1259 wxPaneInfo().Center().CaptionVisible(false));
1263 return tabframe
->m_tabs
;
1266 // FindTab() finds the tab control that currently contains the window as well
1267 // as the index of the window in the tab control. It returns true if the
1268 // window was found, otherwise false.
1269 bool wxAuiMultiNotebook::FindTab(wxWindow
* page
, wxAuiTabCtrl
** ctrl
, int* idx
)
1271 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1272 size_t i
, pane_count
= all_panes
.GetCount();
1273 for (i
= 0; i
< pane_count
; ++i
)
1275 if (all_panes
.Item(i
).name
== wxT("dummy"))
1278 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1280 int page_idx
= tabframe
->m_tabs
->GetIdxFromWindow(page
);
1283 *ctrl
= tabframe
->m_tabs
;
1293 void wxAuiMultiNotebook::OnEraseBackground(wxEraseEvent
&)
1297 void wxAuiMultiNotebook::OnSize(wxSizeEvent
&)
1301 void wxAuiMultiNotebook::OnTabClicked(wxCommandEvent
& command_evt
)
1303 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
1305 wxAuiTabCtrl
* ctrl
= (wxAuiTabCtrl
*)evt
.GetEventObject();
1306 wxASSERT(ctrl
!= NULL
);
1308 wxWindow
* wnd
= ctrl
->GetWindowFromIdx(evt
.GetSelection());
1309 wxASSERT(wnd
!= NULL
);
1311 int idx
= m_tabs
.GetIdxFromWindow(wnd
);
1312 wxASSERT(idx
!= -1);
1317 void wxAuiMultiNotebook::OnTabBeginDrag(wxCommandEvent
&)
1321 void wxAuiMultiNotebook::OnTabDragMotion(wxCommandEvent
& evt
)
1323 wxPoint screen_pt
= ::wxGetMousePosition();
1324 wxPoint client_pt
= ScreenToClient(screen_pt
);
1327 wxAuiTabCtrl
* src_tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
1329 wxAuiTabCtrl
* tab_ctrl
= GetTabCtrlFromPoint(client_pt
);
1330 if (tab_ctrl
== src_tabs
)
1332 // inner-tabctrl dragging is not yet implemented
1339 wxRect hint_rect
= tab_ctrl
->GetRect();
1340 ClientToScreen(&hint_rect
.x
, &hint_rect
.y
);
1341 m_mgr
.ShowHint(hint_rect
);
1345 m_mgr
.DrawHintRect(m_dummy_wnd
, client_pt
, zero
);
1351 void wxAuiMultiNotebook::OnTabEndDrag(wxCommandEvent
& command_evt
)
1353 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
1358 // get the mouse position, which will be used to determine the drop point
1359 wxPoint mouse_screen_pt
= ::wxGetMousePosition();
1360 wxPoint mouse_client_pt
= ScreenToClient(mouse_screen_pt
);
1363 // the src tab control is the control that fired this event
1364 wxAuiTabCtrl
* src_tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
1365 wxAuiTabCtrl
* dest_tabs
= NULL
;
1368 // If the pointer is in an existing tab frame, do a tab insert
1369 wxWindow
* hit_wnd
= ::wxFindWindowAtPoint(mouse_screen_pt
);
1370 wxTabFrame
* tab_frame
= (wxTabFrame
*)GetTabFrameFromTabCtrl(hit_wnd
);
1373 dest_tabs
= tab_frame
->m_tabs
;
1375 if (dest_tabs
== src_tabs
)
1380 // If there is no tabframe at all, create one
1381 wxTabFrame
* new_tabs
= new wxTabFrame
;
1382 new_tabs
->SetTabCtrlHeight(m_tab_ctrl_height
);
1383 new_tabs
->m_tabs
= new wxAuiTabCtrl(this,
1388 m_mgr
.AddPane(new_tabs
,
1389 wxPaneInfo().Bottom().CaptionVisible(false),
1392 dest_tabs
= new_tabs
->m_tabs
;
1397 // remove the page from the source tabs
1398 wxAuiNotebookPage page_info
= src_tabs
->GetPage(evt
.GetSelection());
1399 page_info
.active
= false;
1400 src_tabs
->RemovePage(page_info
.window
);
1401 if (src_tabs
->GetPageCount() > 0)
1403 src_tabs
->SetActivePage((size_t)0);
1404 src_tabs
->DoShowHide();
1405 src_tabs
->Refresh();
1410 // add the page to the destination tabs
1411 dest_tabs
->AddPage(page_info
.window
, page_info
);
1413 if (src_tabs
->GetPageCount() == 0)
1415 RemoveEmptyTabFrames();
1419 dest_tabs
->DoShowHide();
1420 dest_tabs
->Refresh();
1422 SetSelection(m_tabs
.GetIdxFromWindow(page_info
.window
));
1425 wxAuiTabCtrl
* wxAuiMultiNotebook::GetTabCtrlFromPoint(const wxPoint
& pt
)
1427 // if we've just removed the last tab from the source
1428 // tab set, the remove the tab control completely
1429 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1430 size_t i
, pane_count
= all_panes
.GetCount();
1431 for (i
= 0; i
< pane_count
; ++i
)
1433 if (all_panes
.Item(i
).name
== wxT("dummy"))
1436 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1437 if (tabframe
->m_tab_rect
.Inside(pt
))
1438 return tabframe
->m_tabs
;
1444 wxWindow
* wxAuiMultiNotebook::GetTabFrameFromTabCtrl(wxWindow
* tab_ctrl
)
1446 // if we've just removed the last tab from the source
1447 // tab set, the remove the tab control completely
1448 wxPaneInfoArray
& all_panes
= m_mgr
.GetAllPanes();
1449 size_t i
, pane_count
= all_panes
.GetCount();
1450 for (i
= 0; i
< pane_count
; ++i
)
1452 if (all_panes
.Item(i
).name
== wxT("dummy"))
1455 wxTabFrame
* tabframe
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1456 if (tabframe
->m_tabs
== tab_ctrl
)
1465 void wxAuiMultiNotebook::RemoveEmptyTabFrames()
1467 bool must_update
= false;
1469 // if we've just removed the last tab from the source
1470 // tab set, the remove the tab control completely
1471 wxPaneInfoArray all_panes
= m_mgr
.GetAllPanes();
1472 size_t i
, pane_count
= all_panes
.GetCount();
1473 for (i
= 0; i
< pane_count
; ++i
)
1475 if (all_panes
.Item(i
).name
== wxT("dummy"))
1478 wxTabFrame
* tab_frame
= (wxTabFrame
*)all_panes
.Item(i
).window
;
1479 if (tab_frame
->m_tabs
->GetPageCount() == 0)
1481 m_mgr
.DetachPane(tab_frame
);
1483 // use pending delete because sometimes during
1484 // window closing, refreshs are pending
1485 if (!wxPendingDelete
.Member(tab_frame
->m_tabs
))
1486 wxPendingDelete
.Append(tab_frame
->m_tabs
);
1487 //tab_frame->m_tabs->Destroy();
1495 // check to see if there is still a center pane;
1496 // if there isn't, make a frame the center pane
1497 wxPaneInfoArray panes
= m_mgr
.GetAllPanes();
1498 pane_count
= panes
.GetCount();
1499 wxWindow
* first_good
= NULL
;
1500 bool center_found
= false;
1501 for (i
= 0; i
< pane_count
; ++i
)
1503 if (panes
.Item(i
).name
== wxT("dummy"))
1505 if (panes
.Item(i
).dock_direction
== wxAUI_DOCK_CENTRE
)
1506 center_found
= true;
1508 first_good
= panes
.Item(i
).window
;
1511 if (!center_found
&& first_good
)
1513 m_mgr
.GetPane(first_good
).Centre();
1520 void wxAuiMultiNotebook::OnChildFocus(wxChildFocusEvent
& evt
)
1522 int idx
= m_tabs
.GetIdxFromWindow(evt
.GetWindow());
1523 if (idx
!= -1 && idx
!= m_curpage
)
1530 void wxAuiMultiNotebook::OnTabButton(wxCommandEvent
& command_evt
)
1532 wxAuiNotebookEvent
& evt
= (wxAuiNotebookEvent
&)command_evt
;
1533 wxAuiTabCtrl
* tabs
= (wxAuiTabCtrl
*)evt
.GetEventObject();
1535 int button_id
= evt
.GetInt();
1537 if (button_id
== wxAuiButtonClose
)
1539 int selection
= tabs
->GetActivePage();
1541 if (selection
!= -1)
1543 wxWindow
* close_wnd
= tabs
->GetWindowFromIdx(selection
);
1545 if (close_wnd
->IsKindOf(CLASSINFO(wxTabMDIChildFrame
)))
1551 int main_idx
= m_tabs
.GetIdxFromWindow(close_wnd
);
1552 DeletePage(main_idx
);