#include "wx/aui/tabmdi.h"
#include "wx/dcbuffer.h"
+#include "wx/renderer.h"
+
#ifdef __WXMAC__
-#include "wx/mac/carbon/private.h"
+#include "wx/osx/private.h"
+// for themeing support
+#include <Carbon/Carbon.h>
#endif
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BUTTON)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN)
-
IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
m_fixed_tab_width = 100;
m_tab_ctrl_height = 0;
-#ifdef __WXMAC__
- wxBrush toolbarbrush;
- toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
- wxColor base_colour = toolbarbrush.GetColour();
+#if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
+ wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
#else
wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
#endif
const wxRect& rect)
{
// draw background
- wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
- wxColor top_color = wxAuiStepColour(m_base_colour, 90);
- wxColor bottom_color = wxAuiStepColour(m_base_colour, 170);
+
+ wxColor top_color = wxAuiStepColour(m_base_colour, 90);
+ wxColor bottom_color = wxAuiStepColour(m_base_colour, 170);
+ wxRect r;
+
+ if (m_flags &wxAUI_NB_BOTTOM)
+ r = wxRect(rect.x, rect.y, rect.width+2, rect.height);
+ // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
+ // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
+ else //for wxAUI_NB_TOP
+ r = wxRect(rect.x, rect.y, rect.width+2, rect.height-3);
+
dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
- // draw base lines
- int y = rect.GetHeight();
- int w = rect.GetWidth();
- dc.SetPen(m_border_pen);
- dc.SetBrush(m_base_colour_brush);
- dc.DrawRectangle(-1, y-4, w+2, 4);
+
+ // draw base lines
+
+ dc.SetPen(m_border_pen);
+ int y = rect.GetHeight();
+ int w = rect.GetWidth();
+
+ if (m_flags &wxAUI_NB_BOTTOM)
+ {
+ dc.SetBrush(wxBrush(bottom_color));
+ dc.DrawRectangle(-1, 0, w+2, 4);
+ }
+ // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
+ // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
+ else //for wxAUI_NB_TOP
+ {
+ dc.SetBrush(m_base_colour_brush);
+ dc.DrawRectangle(-1, y-4, w+2, 4);
+ }
}
wxPoint border_points[6];
- border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
- border_points[1] = wxPoint(tab_x, tab_y+2);
- border_points[2] = wxPoint(tab_x+2, tab_y);
- border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
- border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
- border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
-
+ if (m_flags &wxAUI_NB_BOTTOM)
+ {
+ border_points[0] = wxPoint(tab_x, tab_y);
+ border_points[1] = wxPoint(tab_x, tab_y+tab_height-6);
+ border_points[2] = wxPoint(tab_x+2, tab_y+tab_height-4);
+ border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
+ border_points[4] = wxPoint(tab_x+tab_width, tab_y+tab_height-6);
+ border_points[5] = wxPoint(tab_x+tab_width, tab_y);
+ }
+ else //if (m_flags & wxAUI_NB_TOP) {}
+ {
+ border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
+ border_points[1] = wxPoint(tab_x, tab_y+2);
+ border_points[2] = wxPoint(tab_x+2, tab_y);
+ border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
+ border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
+ border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
+ }
+ // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
+ // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
int drawn_tab_yoff = border_points[1].y;
int drawn_tab_height = border_points[0].y - border_points[1].y;
// this gets rid of the top one of those lines in the tab control
if (page.active)
{
- dc.SetPen(m_base_colour_pen);
+ if (m_flags &wxAUI_NB_BOTTOM)
+ dc.SetPen(wxPen(wxColour(wxAuiStepColour(m_base_colour, 170))));
+ // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
+ // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
+ else //for wxAUI_NB_TOP
+ dc.SetPen(m_base_colour_pen);
dc.DrawLine(border_points[0].x+1,
border_points[0].y,
border_points[5].x,
close_button_width = m_active_close_bmp.GetWidth();
}
-
+ int bitmap_offset = 0;
if (page.bitmap.IsOk())
{
- int bitmap_offset = tab_x + 8;
+ bitmap_offset = tab_x + 8;
// draw bitmap
dc.DrawBitmap(page.bitmap,
text_offset = bitmap_offset + page.bitmap.GetWidth();
text_offset += 3; // bitmap padding
+
}
else
{
text_offset,
drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
+ // draw focus rectangle
+ if (page.active && (wnd->FindFocus() == wnd))
+ {
+ wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
+ selected_textx, selected_texty);
+
+ wxRect focusRect;
+ wxRect focusRectBitmap;
+
+ if (page.bitmap.IsOk())
+ focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
+ page.bitmap.GetWidth(), page.bitmap.GetHeight());
+ if (page.bitmap.IsOk() && draw_text.IsEmpty())
+ focusRect = focusRectBitmap;
+ else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
+ focusRect = focusRectText;
+ else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
+ focusRect = focusRectText.Union(focusRectBitmap);
+ focusRect.Inflate(2, 2);
+
+ wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
+ }
// draw close button if necessary
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
*out_rect = rect;
}
-
int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
const wxAuiNotebookPageArray& pages,
int active_idx)
(tab_y + tab_height)/2 - (texty/2) + 1);
+ // draw focus rectangle
+ if (page.active && (wnd->FindFocus() == wnd))
+ {
+ wxRect focusRect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
+ selected_textx, selected_texty);
+
+ focusRect.Inflate(2, 2);
+
+ wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
+ }
+
// draw close button if necessary
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
*out_rect = rect;
}
-
int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
const wxAuiNotebookPageArray& pages,
int active_idx)
return;
wxMemoryDC dc;
+
+ // use the same layout direction as the window DC uses to ensure that the
+ // text is rendered correctly
+ dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
+
wxBitmap bmp;
size_t i;
size_t page_count = m_pages.GetCount();
&dc, 0, 0);
}
+// Is the tab visible?
+bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
+{
+ if (!dc || !dc->IsOk())
+ return false;
+
+ size_t i;
+ size_t page_count = m_pages.GetCount();
+ size_t button_count = m_buttons.GetCount();
+
+ // Hasn't been rendered yet; assume it's visible
+ if (m_tab_close_buttons.GetCount() < page_count)
+ return true;
+
+ // First check if both buttons are disabled - if so, there's no need to
+ // check further for visibility.
+ int arrowButtonVisibleCount = 0;
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.id == wxAUI_BUTTON_LEFT ||
+ button.id == wxAUI_BUTTON_RIGHT)
+ {
+ if ((button.cur_state & wxAUI_BUTTON_STATE_HIDDEN) == 0)
+ arrowButtonVisibleCount ++;
+ }
+ }
+
+ // Tab must be visible
+ if (arrowButtonVisibleCount == 0)
+ return true;
+
+ // If tab is less than the given offset, it must be invisible by definition
+ if (tabPage < tabOffset)
+ return false;
+
+ // draw buttons
+ int left_buttons_width = 0;
+ int right_buttons_width = 0;
+
+ int offset = 0;
+
+ // calculate size of the buttons on the right side
+ offset = m_rect.x + m_rect.width;
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
+
+ if (button.location != wxRIGHT)
+ continue;
+ if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ offset -= button.rect.GetWidth();
+ right_buttons_width += button.rect.GetWidth();
+ }
+
+ offset = 0;
+
+ // calculate size of the buttons on the left side
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
+
+ if (button.location != wxLEFT)
+ continue;
+ if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ offset += button.rect.GetWidth();
+ left_buttons_width += button.rect.GetWidth();
+ }
+
+ offset = left_buttons_width;
+
+ if (offset == 0)
+ offset += m_art->GetIndentSize();
+
+ wxRect active_rect;
+
+ wxRect rect = m_rect;
+ rect.y = 0;
+ rect.height = m_rect.height;
+
+ // See if the given page is visible at the given tab offset (effectively scroll position)
+ for (i = tabOffset; i < page_count; ++i)
+ {
+ wxAuiNotebookPage& page = m_pages.Item(i);
+ wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
+
+ rect.x = offset;
+ rect.width = m_rect.width - right_buttons_width - offset - 2;
+
+ if (rect.width <= 0)
+ return false; // haven't found the tab, and we've run out of space, so return false
+
+ int x_extent = 0;
+ wxSize size = m_art->GetTabSize(*dc,
+ wnd,
+ page.caption,
+ page.bitmap,
+ page.active,
+ tab_button.cur_state,
+ &x_extent);
+
+ offset += x_extent;
+
+ if (i == (size_t) tabPage)
+ {
+ // If not all of the tab is visible, and supposing there's space to display it all,
+ // we could do better so we return false.
+ if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
+ return false;
+ else
+ return true;
+ }
+ }
+
+ // Shouldn't really get here, but if it does, assume the tab is visible to prevent
+ // further looping in calling code.
+ return true;
+}
+
+// Make the tab visible if it wasn't already
+void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
+{
+ wxClientDC dc(win);
+ if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
+ {
+ int i;
+ for (i = 0; i < (int) m_pages.GetCount(); i++)
+ {
+ if (IsTabVisible(tabPage, i, & dc, win))
+ {
+ SetTabOffset(i);
+ win->Refresh();
+ return;
+ }
+ }
+ }
+}
// TabHitTest() tests if a tab was hit, passing the window pointer
// back if that condition was fulfilled. The function returns
// as the Show() method on this class is "unplugged"
static void ShowWnd(wxWindow* wnd, bool show)
{
+#if wxUSE_MDI
if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
cf->DoShow(show);
}
else
+#endif
{
wnd->Show(show);
}
EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
EVT_SIZE(wxAuiTabCtrl::OnSize)
EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
- EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDown)
+ EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
EVT_MOTION(wxAuiTabCtrl::OnMotion)
EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
+ EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
+ EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
+ EVT_CHAR(wxAuiTabCtrl::OnChar)
+ EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
END_EVENT_TABLE()
const wxSize& size,
long style) : wxControl(parent, id, pos, size, style)
{
+ SetName(wxT("wxAuiTabCtrl"));
m_click_pt = wxDefaultPosition;
m_is_dragging = false;
m_hover_button = NULL;
}
}
+void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+{
+}
+
void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
{
if (GetCapture() == this)
GetEventHandler()->ProcessEvent(e);
}
+void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
+{
+ wxWindow* wnd;
+ wxAuiTabContainerButton* button;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+ }
+}
+
void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
{
wxPoint pos = evt.GetPosition();
}
}
+void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
+{
+ Refresh();
+}
+
+void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
+{
+ Refresh();
+}
+
+void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
+{
+ if (GetActivePage() == -1)
+ {
+ event.Skip();
+ return;
+ }
+
+ // We can't leave tab processing to the system; on Windows, tabs and keys
+ // get eaten by the system and not processed properly if we specify both
+ // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
+ // we don't key arrow key events.
+
+ int key = event.GetKeyCode();
+
+ if (key == WXK_NUMPAD_PAGEUP)
+ key = WXK_PAGEUP;
+ if (key == WXK_NUMPAD_PAGEDOWN)
+ key = WXK_PAGEDOWN;
+ if (key == WXK_NUMPAD_HOME)
+ key = WXK_HOME;
+ if (key == WXK_NUMPAD_END)
+ key = WXK_END;
+ if (key == WXK_NUMPAD_LEFT)
+ key = WXK_LEFT;
+ if (key == WXK_NUMPAD_RIGHT)
+ key = WXK_RIGHT;
+
+ if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
+ {
+ bool bCtrlDown = event.ControlDown();
+ bool bShiftDown = event.ShiftDown();
+
+ bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
+ bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
+ bool bFromTab = (key == WXK_TAB);
+
+ wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
+ if (!nb)
+ {
+ event.Skip();
+ return;
+ }
+
+ wxNavigationKeyEvent keyEvent;
+ keyEvent.SetDirection(bForward);
+ keyEvent.SetWindowChange(bWindowChange);
+ keyEvent.SetFromTab(bFromTab);
+ keyEvent.SetEventObject(nb);
+
+ if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
+ {
+ // Not processed? Do an explicit tab into the page.
+ wxWindow* win = GetWindowFromIdx(GetActivePage());
+ if (win)
+ win->SetFocus();
+ }
+ return;
+ }
+
+ if (m_pages.GetCount() < 2)
+ {
+ event.Skip();
+ return;
+ }
+
+ int newPage = -1;
+
+ int forwardKey, backwardKey;
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ {
+ forwardKey = WXK_LEFT;
+ backwardKey = WXK_RIGHT;
+ }
+ else
+ {
+ forwardKey = WXK_RIGHT;
+ backwardKey = WXK_LEFT;
+ }
+
+ if (key == forwardKey)
+ {
+ if (m_pages.GetCount() > 1)
+ {
+ if (GetActivePage() == -1)
+ newPage = 0;
+ else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
+ newPage = GetActivePage() + 1;
+ }
+ }
+ else if (key == backwardKey)
+ {
+ if (m_pages.GetCount() > 1)
+ {
+ if (GetActivePage() == -1)
+ newPage = (int) (m_pages.GetCount() - 1);
+ else if (GetActivePage() > 0)
+ newPage = GetActivePage() - 1;
+ }
+ }
+ else if (key == WXK_HOME)
+ {
+ newPage = 0;
+ }
+ else if (key == WXK_END)
+ {
+ newPage = (int) (m_pages.GetCount() - 1);
+ }
+ else
+ event.Skip();
+
+ if (newPage != -1)
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+ e.SetSelection(newPage);
+ e.SetOldSelection(newPage);
+ e.SetEventObject(this);
+ this->GetEventHandler()->ProcessEvent(e);
+ }
+ else
+ event.Skip();
+}
+
// wxTabFrame is an interesting case. It's important that all child pages
// of the multi-notebook control are all actually children of that control
// (and not grandchildren). wxTabFrame facilitates this. There is one
return;
m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
- m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
- m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
+ if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
+ {
+ m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
+ m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
+ m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
+ }
+ else //TODO: if (GetFlags() & wxAUI_NB_TOP)
+ {
+ m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
+ m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
+ m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
+ }
+ // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
+ // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
+
m_tabs->Refresh();
m_tabs->Update();
for (i = 0; i < page_count; ++i)
{
+ int height = m_rect.height - m_tab_ctrl_height;
+ if ( height < 0 )
+ {
+ // avoid passing negative height to wxWindow::SetSize(), this
+ // results in assert failures/GTK+ warnings
+ height = 0;
+ }
+
wxAuiNotebookPage& page = pages.Item(i);
- page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
- m_rect.width, m_rect.height - m_tab_ctrl_height);
+ if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
+ {
+ page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
+ }
+ else //TODO: if (GetFlags() & wxAUI_NB_TOP)
+ {
+ page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
+ m_rect.width, height);
+ }
+ // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
+ // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
+#if wxUSE_MDI
if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
wnd->ApplyMDIChildFrameRect();
}
+#endif
}
}
BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
EVT_SIZE(wxAuiNotebook::OnSize)
- EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
+ EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
wxAuiNotebook::OnTabClicked)
EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
wxAuiNotebook::OnTabRightUp)
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
+ wxAuiNotebook::OnTabBgDClick)
+ EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
+
+#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
+ WX_EVENT_TABLE_CONTROL_CONTAINER(wxAuiNotebook)
+#else
+ // Avoid clash with container event handler functions
+ EVT_SET_FOCUS(wxAuiNotebook::OnFocus)
+#endif
END_EVENT_TABLE()
+WX_DELEGATE_TO_CONTROL_CONTAINER(wxAuiNotebook, wxControl)
+
wxAuiNotebook::wxAuiNotebook()
{
m_curpage = -1;
// code called by all constructors
void wxAuiNotebook::InitNotebook(long style)
{
+ WX_INIT_CONTROL_CONTAINER();
+ // SetCanFocus(false);
+
+ SetName(wxT("wxAuiNotebook"));
m_curpage = -1;
m_tab_id_counter = wxAuiBaseTabCtrlId;
m_dummy_wnd = NULL;
wxAuiNotebook::~wxAuiNotebook()
{
+ // Indicate we're deleting pages
+ m_isBeingDeleted = true;
+
+ while ( GetPageCount() > 0 )
+ DeletePage(0);
+
m_mgr.UnInit();
}
bool select,
const wxBitmap& bitmap)
{
+ wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
+ if (!page)
+ return false;
+
+ page->Reparent(this);
+
wxAuiNotebookPage info;
info.window = page;
info.caption = caption;
DoSizing();
active_tabctrl->DoShowHide();
+ // adjust selected index
+ if(m_curpage >= (int) page_idx)
+ m_curpage++;
+
if (select)
{
SetSelectionToWindow(page);
if (!RemovePage(page_idx))
return false;
+#if wxUSE_MDI
// actually destroy the window now
if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
wxPendingDelete.Append(wnd);
}
else
+#endif
{
wnd->Destroy();
}
RemoveEmptyTabFrames();
// set new active pane
- if (new_active)
+ if (new_active && !m_isBeingDeleted)
{
m_curpage = -1;
SetSelectionToWindow(new_active);
// SetSelection() sets the currently active page
size_t wxAuiNotebook::SetSelection(size_t new_page)
{
- // don't change the page unless necessary
- if ((int)new_page == m_curpage)
- return m_curpage;
-
wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
if (!wnd)
return m_curpage;
+ // don't change the page unless necessary;
+ // however, clicking again on a tab should give it the focus.
+ if ((int)new_page == m_curpage)
+ {
+ wxAuiTabCtrl* ctrl;
+ int ctrl_idx;
+ if (FindTab(wnd, &ctrl, &ctrl_idx))
+ {
+ if (FindFocus() != ctrl)
+ ctrl->SetFocus();
+ }
+ return m_curpage;
+ }
+
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
evt.SetSelection(new_page);
evt.SetOldSelection(m_curpage);
DoSizing();
ctrl->DoShowHide();
-
+ ctrl->MakeTabVisible(ctrl_idx, ctrl);
// set fonts
wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
tabctrl->Refresh();
}
- wnd->SetFocus();
+ // Set the focus to the page if we're not currently focused on the tab.
+ // This is Firefox-like behaviour.
+ if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
+ wnd->SetFocus();
return old_curpage;
}
m_tab_id_counter++,
wxDefaultPosition,
wxDefaultSize,
- wxNO_BORDER);
+ wxNO_BORDER|wxWANTS_CHARS);
tabframe->m_tabs->SetFlags(m_flags);
tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
m_mgr.AddPane(tabframe,
m_tab_id_counter++,
wxDefaultPosition,
wxDefaultSize,
- wxNO_BORDER);
+ wxNO_BORDER|wxWANTS_CHARS);
new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
new_tabs->m_tabs->SetFlags(m_flags);
dest_tabs = new_tabs->m_tabs;
SetSelectionToWindow(wnd);
}
+void wxAuiNotebook::OnTabBgDClick(wxCommandEvent& WXUNUSED(evt))
+{
+ // notify owner that the tabbar background has been double-clicked
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+}
+
void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
{
m_last_drag_x = 0;
int src_idx = evt.GetSelection();
wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
+ // Check that it's not an impossible parent relationship
+ wxWindow* p = nb;
+ while (p && !p->IsTopLevel())
+ {
+ if (p == src_page)
+ {
+ return;
+ }
+ p = p->GetParent();
+ }
+
// get main index of the page
int main_idx = m_tabs.GetIdxFromWindow(src_page);
wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no source page?") );
// set the selection in the destination tab control
nb->SetSelectionToPage(page_info);
+ // notify owner that the tab has been dragged
+ wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
+ e2.SetSelection(evt.GetSelection());
+ e2.SetOldSelection(evt.GetSelection());
+ e2.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e2);
+
return;
}
}
m_tab_id_counter++,
wxDefaultPosition,
wxDefaultSize,
- wxNO_BORDER);
+ wxNO_BORDER|wxWANTS_CHARS);
new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
new_tabs->m_tabs->SetFlags(m_flags);
UpdateHintWindowSize();
}
+
+ // notify owner that the tab has been dragged
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
+ e.SetSelection(evt.GetSelection());
+ e.SetOldSelection(evt.GetSelection());
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
}
m_mgr.GetPane(first_good).Centre();
}
- m_mgr.Update();
+ if (!m_isBeingDeleted)
+ m_mgr.Update();
}
-void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
+void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
{
// if we're dragging a tab, don't change the current selection.
// This code prevents a bug that used to happen when the hint window
}
}
+void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
+{
+ if ( event.IsWindowChange() ) {
+ // change pages
+ // FIXME: the problem with this is that if we have a split notebook,
+ // we selection may go all over the place.
+ AdvanceSelection(event.GetDirection());
+ }
+ else {
+ // we get this event in 3 cases
+ //
+ // a) one of our pages might have generated it because the user TABbed
+ // out from it in which case we should propagate the event upwards and
+ // our parent will take care of setting the focus to prev/next sibling
+ //
+ // or
+ //
+ // b) the parent panel wants to give the focus to us so that we
+ // forward it to our selected page. We can't deal with this in
+ // OnSetFocus() because we don't know which direction the focus came
+ // from in this case and so can't choose between setting the focus to
+ // first or last panel child
+ //
+ // or
+ //
+ // c) we ourselves (see MSWTranslateMessage) generated the event
+ //
+ wxWindow * const parent = GetParent();
+
+ // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
+ const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
+ const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
+
+ if ( isFromParent || isFromSelf )
+ {
+ // no, it doesn't come from child, case (b) or (c): forward to a
+ // page but only if direction is backwards (TAB) or from ourselves,
+ if ( GetSelection() != wxNOT_FOUND &&
+ (!event.GetDirection() || isFromSelf) )
+ {
+ // so that the page knows that the event comes from it's parent
+ // and is being propagated downwards
+ event.SetEventObject(this);
+
+ wxWindow *page = GetPage(GetSelection());
+ if ( !page->GetEventHandler()->ProcessEvent(event) )
+ {
+ page->SetFocus();
+ }
+ //else: page manages focus inside it itself
+ }
+ else // otherwise set the focus to the notebook itself
+ {
+ SetFocus();
+ }
+ }
+ else
+ {
+ // it comes from our child, case (a), pass to the parent, but only
+ // if the direction is forwards. Otherwise set the focus to the
+ // notebook itself. The notebook is always the 'first' control of a
+ // page.
+ if ( !event.GetDirection() )
+ {
+ SetFocus();
+ }
+ else if ( parent )
+ {
+ event.SetCurrentFocus(this);
+ parent->GetEventHandler()->ProcessEvent(event);
+ }
+ }
+ }
+}
void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
{
{
// if the close button is to the right, use the active
// page selection to determine which page to close
- selection = GetSelection();
+ selection = tabs->GetActivePage();
}
-
+
if (selection != -1)
{
wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
// ask owner if it's ok to close the tab
wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
+ const int idx = m_tabs.GetIdxFromWindow(close_wnd);
+ e.SetSelection(idx);
e.SetOldSelection(evt.GetSelection());
e.SetEventObject(this);
GetEventHandler()->ProcessEvent(e);
return;
+#if wxUSE_MDI
if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
close_wnd->Close();
}
else
+#endif
{
int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no page to delete?") );
DeletePage(main_idx);
}
+
+ // notify owner that the tab has been closed
+ wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
+ e2.SetSelection(idx);
+ e2.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e2);
}
}
}
return tabCtrlHeight + pageHeight + decorHeight;
}
+// Advances the selection, generation page selection events
+void wxAuiNotebook::AdvanceSelection(bool forward)
+{
+ if (GetPageCount() <= 1)
+ return;
+
+ int currentSelection = GetSelection();
+
+ if (forward)
+ {
+ if (currentSelection == (int) (GetPageCount() - 1))
+ return;
+ else if (currentSelection == -1)
+ currentSelection = 0;
+ else
+ currentSelection ++;
+ }
+ else
+ {
+ if (currentSelection <= 0)
+ return;
+ else
+ currentSelection --;
+ }
+
+ SetSelection(currentSelection);
+}
+
+// Shows the window menu
+bool wxAuiNotebook::ShowWindowMenu()
+{
+ wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
+
+ int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
+
+ if (idx != -1)
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
+ e.SetSelection(idx);
+ e.SetOldSelection(tabCtrl->GetActivePage());
+ e.SetEventObject(tabCtrl);
+ GetEventHandler()->ProcessEvent(e);
+
+ return true;
+ }
+ else
+ return false;
+}
#endif // wxUSE_AUI
projects / wxWidgets.git / blobdiff