#include "wx/aui/tabmdi.h"
#include "wx/dcbuffer.h"
+#include "wx/menu.h"
+
+#ifdef __WXMAC__
+#include "wx/mac/carbon/private.h"
+#endif
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE)
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_BEGIN_DRAG)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND)
-
+IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
+IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
return wxBitmap(img);
}
-static void DrawButton(wxDC& dc,
- const wxRect& _rect,
- const wxBitmap& bmp,
- const wxColour& bkcolour,
- int button_state)
+static void DrawButtons(wxDC& dc,
+ const wxRect& _rect,
+ const wxBitmap& bmp,
+ const wxColour& bkcolour,
+ int button_state)
{
wxRect rect = _rect;
dc.DrawBitmap(bmp, rect.x, rect.y, true);
}
+static void IndentPressedBitmap(wxRect* rect, int button_state)
+{
+ if (button_state == wxAUI_BUTTON_STATE_PRESSED)
+ {
+ rect->x++;
+ rect->y++;
+ }
+}
+
+// chops the text so that it fits within |max_size| pixels.
+// Also adds an elipsis if necessary
+
+static wxString ChopText(wxDC& dc, const wxString& text, int max_size)
+{
+ wxCoord x,y;
+
+ // first check if the text fits with no problems
+ dc.GetTextExtent(text, &x, &y);
+ if (x <= max_size)
+ return text;
+
+ size_t i, len = text.Length();
+ size_t last_good_length = 0;
+ for (i = 0; i < len; ++i)
+ {
+ wxString s = text.Left(i);
+ s += wxT("...");
+
+ dc.GetTextExtent(s, &x, &y);
+ if (x > max_size)
+ break;
+
+ last_good_length = i;
+ }
+
+ wxString ret = text.Left(last_good_length);
+ ret += wxT("...");
+ return ret;
+}
+
+
+// -- GUI helper classes and functions --
+
+class wxAuiCommandCapture : public wxEvtHandler
+{
+public:
+
+ wxAuiCommandCapture() { m_last_id = 0; }
+ int GetCommandId() const { return m_last_id; }
+
+ bool ProcessEvent(wxEvent& evt)
+ {
+ if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
+ {
+ m_last_id = evt.GetId();
+ return true;
+ }
+
+ if (GetNextHandler())
+ return GetNextHandler()->ProcessEvent(evt);
+
+ return false;
+ }
+
+private:
+ int m_last_id;
+};
+
+
+// -- bitmaps --
+
+#if defined( __WXMAC__ )
+ static unsigned char close_bits[]={
+ 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
+ 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
+ 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
+#elif defined( __WXGTK__)
+ static unsigned char close_bits[]={
+ 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
+ 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
+ 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+#else
+ static unsigned char close_bits[]={
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
+ 0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+#endif
+
+static unsigned char left_bits[] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
+ 0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+static unsigned char right_bits[] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
+ 0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+static unsigned char list_bits[] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+
-// -- wxDefaultTabArt class implementation --
+// -- wxAuiDefaultTabArt class implementation --
-wxDefaultTabArt::wxDefaultTabArt()
+wxAuiDefaultTabArt::wxAuiDefaultTabArt()
{
m_normal_font = *wxNORMAL_FONT;
m_selected_font = *wxNORMAL_FONT;
m_selected_font.SetWeight(wxBOLD);
m_measuring_font = m_selected_font;
+
+ m_fixed_tab_width = 100;
+ m_tab_ctrl_height = 0;
+
+#ifdef __WXMAC__
+ wxBrush toolbarbrush;
+ toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
+ wxColor base_colour = toolbarbrush.GetColour();
+#else
+ wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+#endif
+
+ m_base_colour = base_colour;
+ wxColor darker2_colour = StepColour(base_colour, 70);
+
+ m_border_pen = wxPen(darker2_colour);
+ m_base_colour_pen = wxPen(m_base_colour);
+ m_base_colour_brush = wxBrush(m_base_colour);
+
+ m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
+ m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_left_bmp = BitmapFromBits(left_bits, 16, 16, *wxBLACK);
+ m_disabled_left_bmp = BitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_right_bmp = BitmapFromBits(right_bits, 16, 16, *wxBLACK);
+ m_disabled_right_bmp = BitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, *wxBLACK);
+ m_disabled_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
+
+ m_flags = 0;
+}
+
+wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
+{
+}
+
+wxAuiTabArt* wxAuiDefaultTabArt::Clone()
+{
+ return static_cast<wxAuiTabArt*>(new wxAuiDefaultTabArt);
+}
+
+void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
+{
+ m_flags = flags;
+}
+
+void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
+ size_t tab_count)
+{
+ m_fixed_tab_width = 100;
+
+ int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+ if (tab_count > 0)
+ {
+ m_fixed_tab_width = tot_width/(int)tab_count;
+ }
+
+
+ if (m_fixed_tab_width < 100)
+ m_fixed_tab_width = 100;
+
+ if (m_fixed_tab_width > tot_width/2)
+ m_fixed_tab_width = tot_width/2;
+
+ if (m_fixed_tab_width > 220)
+ m_fixed_tab_width = 220;
+
+ m_tab_ctrl_height = tab_ctrl_size.y;
+}
+
+
+void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxRect& rect)
+{
+ // draw background
+ wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
+ wxColor start_colour = StepColour(m_base_colour, 90);
+ wxColor end_colour = StepColour(m_base_colour, 110);
+ dc.GradientFillLinear(r, start_colour, end_colour, wxSOUTH);
+
+ // draw base lines
+ int y = rect.GetHeight();
+ int w = rect.GetWidth();
+ dc.SetPen(m_border_pen);
+ dc.DrawLine(0, y-4, w, y-4);
+ dc.DrawLine(0, y-1, w, y-1);
+ dc.SetPen(wxPen(start_colour));
+ dc.DrawLine(0, y-3, w, y-3);
+ dc.DrawLine(0, y-2, w, y-2);
+}
+
+
+// DrawTab() draws an individual tab.
+//
+// dc - output dc
+// in_rect - rectangle the tab should be confined to
+// caption - tab's caption
+// active - whether or not the tab is active
+// out_rect - actual output rectangle
+// x_extent - the advance x; where the next tab should start
+
+void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
+ wxWindow* wnd,
+ const wxRect& in_rect,
+ const wxString& caption_text,
+ const wxBitmap& bitmap,
+ bool active,
+ int close_button_state,
+ wxRect* out_tab_rect,
+ wxRect* out_button_rect,
+ int* x_extent)
+{
+ wxCoord normal_textx, normal_texty;
+ wxCoord selected_textx, selected_texty;
+ wxCoord textx, texty;
+
+ // if the caption is empty, measure some temporary text
+ wxString caption = caption_text;
+ if (caption_text.empty())
+ caption = wxT("Xj");
+
+ dc.SetFont(m_selected_font);
+ dc.GetTextExtent(caption, &selected_textx, &selected_texty);
+
+ dc.SetFont(m_normal_font);
+ dc.GetTextExtent(caption, &normal_textx, &normal_texty);
+
+ // figure out the size of the tab
+ wxSize tab_size = GetTabSize(dc,
+ wnd,
+ caption,
+ bitmap,
+ active,
+ close_button_state,
+ x_extent);
+
+ wxCoord tab_height = m_tab_ctrl_height - 3;
+ wxCoord tab_width = tab_size.x;
+ wxCoord tab_x = in_rect.x;
+ wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
+
+
+ caption = caption_text;
+
+
+ // select pen, brush and font for the tab to be drawn
+
+ if (active)
+ {
+ dc.SetFont(m_selected_font);
+ textx = selected_textx;
+ texty = selected_texty;
+ }
+ else
+ {
+ dc.SetFont(m_normal_font);
+ textx = normal_textx;
+ texty = normal_texty;
+ }
+
+
+ // create points that will make the tab outline
+
+ wxPoint clip_points[6];
+ clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
+ clip_points[1] = wxPoint(tab_x, tab_y+2);
+ clip_points[2] = wxPoint(tab_x+2, tab_y);
+ clip_points[3] = wxPoint(tab_x+tab_width-1, tab_y);
+ clip_points[4] = wxPoint(tab_x+tab_width+1, tab_y+2);
+ clip_points[5] = wxPoint(tab_x+tab_width+1, tab_y+tab_height-3);
+
+ // set the clipping region for the tab --
+ wxRegion clipping_region(6, clip_points);
+ dc.SetClippingRegion(clipping_region);
+
+ 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);
+
+
+ int drawn_tab_yoff = border_points[1].y;
+ int drawn_tab_height = border_points[0].y - border_points[1].y;
+
+
+ if (active)
+ {
+ // draw active tab
+
+ // draw base background color
+ wxRect r(tab_x, tab_y, tab_width, tab_height);
+ dc.SetPen(m_base_colour_pen);
+ dc.SetBrush(m_base_colour_brush);
+ dc.DrawRectangle(r.x, r.y, r.width, r.height);
+
+ // this white helps fill out the gradient at the top of the tab
+ dc.SetPen(*wxWHITE_PEN);
+ dc.SetBrush(*wxWHITE_BRUSH);
+ dc.DrawRectangle(r.x+2, r.y+2, r.width-3, r.height);
+
+ // these two points help the rounded corners appear more antialiased
+ dc.SetPen(m_base_colour_pen);
+ dc.DrawPoint(r.x+2, r.y+2);
+ dc.DrawPoint(r.x+r.width-2, r.y+2);
+
+ // set rectangle down a bit for gradient drawing
+ r.SetHeight(r.GetHeight()/2);
+ r.x += 2;
+ r.width -= 2;
+ r.y += r.height;
+
+ // draw gradient background
+ wxColor start_color = StepColour(m_base_colour, 95);
+ wxColor end_color = *wxWHITE;
+ dc.GradientFillLinear(r, start_color, end_color, wxNORTH);
+ }
+ else
+ {
+ // draw inactive tab
+
+ wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
+
+ // draw base background color for inactive tabs
+ dc.SetPen(m_base_colour_pen);
+ dc.SetBrush(m_base_colour_brush);
+ dc.DrawRectangle(r.x, r.y, r.width, r.height);
+
+ // start the gradent up a bit and leave the inside border inset
+ // by a pixel for a 3D look. Only the top half of the inactive
+ // tab will have a slight gradient
+ r.x += 2;
+ r.width -= 2;
+ r.height /= 2;
+
+ // -- draw bottom gradient fill for glossy look
+ wxColor top_color = m_base_colour;
+ wxColor bottom_color = StepColour(top_color, 106);
+ dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
+ }
+
+ // draw tab outline
+ dc.SetPen(m_border_pen);
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+ dc.DrawPolygon(6, border_points);
+
+ // there are two horizontal grey lines at the bottom of the tab control,
+ // this gets rid of the top one of those lines in the tab control
+ if (active)
+ {
+ wxColor start_color = StepColour(m_base_colour, 93);
+ dc.SetPen(wxPen(start_color));
+ dc.DrawLine(border_points[0].x,
+ border_points[0].y,
+ border_points[5].x+1,
+ border_points[5].y);
+ }
+
+
+ int text_offset = tab_x + 8;
+ int close_button_width = 0;
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ {
+ close_button_width = m_active_close_bmp.GetWidth();
+ }
+
+
+ if (bitmap.IsOk())
+ {
+ int bitmap_offset = tab_x + 8;
+
+ // draw bitmap
+ dc.DrawBitmap(bitmap,
+ bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2) + 1,
+ true);
+
+ text_offset = bitmap_offset + bitmap.GetWidth();
+ text_offset += 3; // bitmap padding
+ }
+ else
+ {
+ text_offset = tab_x + 8;
+ }
+
+
+ wxString draw_text = ChopText(dc,
+ caption,
+ tab_width - (text_offset-tab_x) - close_button_width);
+
+ // draw tab text
+ dc.DrawText(draw_text,
+ text_offset,
+ drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
+
+
+
+
+ // draw close button if necessary
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ {
+ wxBitmap bmp = m_disabled_close_bmp;
+
+ if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
+ close_button_state == wxAUI_BUTTON_STATE_PRESSED)
+ {
+ bmp = m_active_close_bmp;
+ }
+
+ wxRect rect(tab_x + tab_width - close_button_width - 1,
+ tab_y + (tab_height/2) - (bmp.GetHeight()/2),
+ close_button_width,
+ tab_height);
+ IndentPressedBitmap(&rect, close_button_state);
+ dc.DrawBitmap(bmp, rect.x, rect.y, true);
+
+ *out_button_rect = rect;
+ }
+
+ *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
+
+ dc.DestroyClippingRegion();
+}
+
+int wxAuiDefaultTabArt::GetIndentSize()
+{
+ return 5;
+}
+
+wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxString& caption,
+ const wxBitmap& bitmap,
+ bool WXUNUSED(active),
+ int close_button_state,
+ int* x_extent)
+{
+ wxCoord measured_textx, measured_texty, tmp;
+
+ dc.SetFont(m_measuring_font);
+ dc.GetTextExtent(caption, &measured_textx, &measured_texty);
+
+ dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
+
+ // add padding around the text
+ wxCoord tab_width = measured_textx;
+ wxCoord tab_height = measured_texty;
+
+ // if the close button is showing, add space for it
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ tab_width += m_active_close_bmp.GetWidth() + 3;
+
+ // if there's a bitmap, add space for it
+ if (bitmap.IsOk())
+ {
+ tab_width += bitmap.GetWidth();
+ tab_width += 3; // right side bitmap padding
+ tab_height = wxMax(tab_height, bitmap.GetHeight());
+ }
+
+ // add padding
+ tab_width += 16;
+ tab_height += 10;
+
+ if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
+ {
+ tab_width = m_fixed_tab_width;
+ }
+
+ *x_extent = tab_width;
+
+ return wxSize(tab_width, tab_height);
+}
+
+
+void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxRect& in_rect,
+ int bitmap_id,
+ int button_state,
+ int orientation,
+ const wxBitmap& bitmap_override,
+ wxRect* out_rect)
+{
+ wxBitmap bmp;
+ wxRect rect;
+
+ if (bitmap_override.IsOk())
+ {
+ bmp = bitmap_override;
+ }
+ else
+ {
+ switch (bitmap_id)
+ {
+ case wxAUI_BUTTON_CLOSE:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_close_bmp;
+ else
+ bmp = m_active_close_bmp;
+ break;
+ case wxAUI_BUTTON_LEFT:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_left_bmp;
+ else
+ bmp = m_active_left_bmp;
+ break;
+ case wxAUI_BUTTON_RIGHT:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_right_bmp;
+ else
+ bmp = m_active_right_bmp;
+ break;
+ case wxAUI_BUTTON_WINDOWLIST:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_windowlist_bmp;
+ else
+ bmp = m_active_windowlist_bmp;
+ break;
+ }
+ }
+
+ if (!bmp.IsOk())
+ return;
+
+ rect = in_rect;
+
+ if (orientation == wxLEFT)
+ {
+ rect.SetX(in_rect.x);
+ rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
+ rect.SetWidth(bmp.GetWidth());
+ rect.SetHeight(bmp.GetHeight());
+ }
+ else
+ {
+ rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
+ ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
+ bmp.GetWidth(), bmp.GetHeight());
+ }
+
+ IndentPressedBitmap(&rect, button_state);
+ dc.DrawBitmap(bmp, rect.x, rect.y, true);
+
+ *out_rect = rect;
+}
+
+
+int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
+ const wxArrayString& items,
+ int active_idx)
+{
+ wxMenu menuPopup;
+
+ size_t i, count = items.GetCount();
+ for (i = 0; i < count; ++i)
+ {
+ menuPopup.AppendCheckItem(1000+i, items.Item(i));
+ }
+
+ if (active_idx != -1)
+ {
+ menuPopup.Check(1000+active_idx, true);
+ }
+
+ // find out where to put the popup menu of window
+ // items. Subtract 100 for now to center the menu
+ // a bit, until a better mechanism can be implemented
+ wxPoint pt = ::wxGetMousePosition();
+ pt = wnd->ScreenToClient(pt);
+ if (pt.x < 100)
+ pt.x = 0;
+ else
+ pt.x -= 100;
+
+ // find out the screen coordinate at the bottom of the tab ctrl
+ wxRect cli_rect = wnd->GetClientRect();
+ pt.y = cli_rect.y + cli_rect.height;
+
+ wxAuiCommandCapture* cc = new wxAuiCommandCapture;
+ wnd->PushEventHandler(cc);
+ wnd->PopupMenu(&menuPopup, pt);
+ int command = cc->GetCommandId();
+ wnd->PopEventHandler(true);
+
+ if (command >= 1000)
+ return command-1000;
+
+ return -1;
+}
+
+int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+ wxAuiNotebookPageArray& pages)
+{
+ wxClientDC dc(wnd);
+ dc.SetFont(m_measuring_font);
+
+ int max_y = 0;
+ size_t i, page_count = pages.GetCount();
+ for (i = 0; i < page_count; ++i)
+ {
+ wxAuiNotebookPage& page = pages.Item(i);
+
+ // we don't use the caption text because we don't
+ // want tab heights to be different in the case
+ // of a very short piece of text on one tab and a very
+ // tall piece of text on another tab
+ int x_ext = 0;
+ wxSize s = GetTabSize(dc,
+ wnd,
+ wxT("ABCDEFGHIj"),
+ page.bitmap,
+ true,
+ wxAUI_BUTTON_STATE_HIDDEN,
+ &x_ext);
+ max_y = wxMax(max_y, s.y);
+ }
+
+ return max_y+2;
+}
+
+void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
+{
+ m_normal_font = font;
+}
+
+void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
+{
+ m_selected_font = font;
+}
+
+void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
+{
+ m_measuring_font = font;
+}
+
+
+// -- wxAuiSimpleTabArt class implementation --
+
+wxAuiSimpleTabArt::wxAuiSimpleTabArt()
+{
+ m_normal_font = *wxNORMAL_FONT;
+ m_selected_font = *wxNORMAL_FONT;
+ m_selected_font.SetWeight(wxBOLD);
+ m_measuring_font = m_selected_font;
+
+ m_flags = 0;
+ m_fixed_tab_width = 100;
wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
m_normal_bkpen = wxPen(normaltab_colour);
m_selected_bkbrush = wxBrush(selectedtab_colour);
m_selected_bkpen = wxPen(selectedtab_colour);
+
+ m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
+ m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_left_bmp = BitmapFromBits(left_bits, 16, 16, *wxBLACK);
+ m_disabled_left_bmp = BitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_right_bmp = BitmapFromBits(right_bits, 16, 16, *wxBLACK);
+ m_disabled_right_bmp = BitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+
+ m_active_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, *wxBLACK);
+ m_disabled_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
+
+}
+
+wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
+{
+}
+
+wxAuiTabArt* wxAuiSimpleTabArt::Clone()
+{
+ return static_cast<wxAuiTabArt*>(new wxAuiSimpleTabArt);
+}
+
+
+void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
+{
+ m_flags = flags;
}
-wxDefaultTabArt::~wxDefaultTabArt()
+void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
+ size_t tab_count)
{
+ m_fixed_tab_width = 100;
+
+ int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+ if (tab_count > 0)
+ {
+ m_fixed_tab_width = tot_width/(int)tab_count;
+ }
+
+
+ if (m_fixed_tab_width < 100)
+ m_fixed_tab_width = 100;
+
+ if (m_fixed_tab_width > tot_width/2)
+ m_fixed_tab_width = tot_width/2;
+
+ if (m_fixed_tab_width > 220)
+ m_fixed_tab_width = 220;
}
-void wxDefaultTabArt::DrawBackground(
- wxDC* dc,
- const wxRect& rect)
+void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxRect& rect)
{
// draw background
- dc->SetBrush(m_bkbrush);
- dc->SetPen(*wxTRANSPARENT_PEN);
- dc->DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
+ dc.SetBrush(m_bkbrush);
+ dc.SetPen(*wxTRANSPARENT_PEN);
+ dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
// draw base line
- dc->SetPen(*wxGREY_PEN);
- dc->DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
+ dc.SetPen(*wxGREY_PEN);
+ dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
}
+
// DrawTab() draws an individual tab.
//
// dc - output dc
// out_rect - actual output rectangle
// x_extent - the advance x; where the next tab should start
-void wxDefaultTabArt::DrawTab(wxDC* dc,
- const wxRect& in_rect,
- const wxString& caption_text,
- bool active,
- wxRect* out_rect,
- int* x_extent)
+void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
+ wxWindow* wnd,
+ const wxRect& in_rect,
+ const wxString& caption_text,
+ const wxBitmap& bitmap,
+ bool active,
+ int close_button_state,
+ wxRect* out_tab_rect,
+ wxRect* out_button_rect,
+ int* x_extent)
{
wxCoord normal_textx, normal_texty;
wxCoord selected_textx, selected_texty;
- wxCoord measured_textx, measured_texty;
wxCoord textx, texty;
-
-
+
// if the caption is empty, measure some temporary text
wxString caption = caption_text;
if (caption_text.empty())
caption = wxT("Xj");
+
+ dc.SetFont(m_selected_font);
+ dc.GetTextExtent(caption, &selected_textx, &selected_texty);
+
+ dc.SetFont(m_normal_font);
+ dc.GetTextExtent(caption, &normal_textx, &normal_texty);
- // measure text
- dc->SetFont(m_measuring_font);
- dc->GetTextExtent(caption, &measured_textx, &measured_texty);
+ // figure out the size of the tab
+ wxSize tab_size = GetTabSize(dc,
+ wnd,
+ caption,
+ bitmap,
+ active,
+ close_button_state,
+ x_extent);
+
+ wxCoord tab_height = tab_size.y;
+ wxCoord tab_width = tab_size.x;
+ wxCoord tab_x = in_rect.x;
+ wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
- dc->SetFont(m_selected_font);
- dc->GetTextExtent(caption, &selected_textx, &selected_texty);
+ caption = caption_text;
- dc->SetFont(m_normal_font);
- dc->GetTextExtent(caption, &normal_textx, &normal_texty);
+ // select pen, brush and font for the tab to be drawn
+
+ if (active)
+ {
+ dc.SetPen(m_selected_bkpen);
+ dc.SetBrush(m_selected_bkbrush);
+ dc.SetFont(m_selected_font);
+ textx = selected_textx;
+ texty = selected_texty;
+ }
+ else
+ {
+ dc.SetPen(m_normal_bkpen);
+ dc.SetBrush(m_normal_bkbrush);
+ dc.SetFont(m_normal_font);
+ textx = normal_textx;
+ texty = normal_texty;
+ }
- caption = caption_text;
+ // -- draw line --
+
+ wxPoint points[7];
+ points[0].x = tab_x;
+ points[0].y = tab_y + tab_height - 1;
+ points[1].x = tab_x + tab_height - 3;
+ points[1].y = tab_y + 2;
+ points[2].x = tab_x + tab_height + 3;
+ points[2].y = tab_y;
+ points[3].x = tab_x + tab_width - 2;
+ points[3].y = tab_y;
+ points[4].x = tab_x + tab_width;
+ points[4].y = tab_y + 2;
+ points[5].x = tab_x + tab_width;
+ points[5].y = tab_y + tab_height - 1;
+ points[6] = points[0];
+
+ dc.SetClippingRegion(in_rect);
+
+ dc.DrawPolygon(6, points);
+
+ dc.SetPen(*wxGREY_PEN);
+
+ //dc.DrawLines(active ? 6 : 7, points);
+ dc.DrawLines(7, points);
+
+
+ int text_offset;
+
+ int close_button_width = 0;
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ {
+ close_button_width = m_active_close_bmp.GetWidth();
+ text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
+ }
+ else
+ {
+ text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
+ }
+
+ // set minimum text offset
+ if (text_offset < tab_x + tab_height)
+ text_offset = tab_x + tab_height;
+
+ // chop text if necessary
+ wxString draw_text = ChopText(dc,
+ caption,
+ tab_width - (text_offset-tab_x) - close_button_width);
+
+ // draw tab text
+ dc.DrawText(draw_text,
+ text_offset,
+ (tab_y + tab_height)/2 - (texty/2) + 1);
+
+
+ // draw close button if necessary
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ {
+ wxBitmap bmp;
+ if (active)
+ bmp = m_active_close_bmp;
+ else
+ bmp = m_disabled_close_bmp;
+
+ wxRect rect(tab_x + tab_width - close_button_width - 1,
+ tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
+ close_button_width,
+ tab_height - 1);
+ DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
+
+ *out_button_rect = rect;
+ }
+
+
+ *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
+
+ dc.DestroyClippingRegion();
+}
+
+int wxAuiSimpleTabArt::GetIndentSize()
+{
+ return 0;
+}
+
+wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxString& caption,
+ const wxBitmap& WXUNUSED(bitmap),
+ bool WXUNUSED(active),
+ int close_button_state,
+ int* x_extent)
+{
+ wxCoord measured_textx, measured_texty;
+
+ dc.SetFont(m_measuring_font);
+ dc.GetTextExtent(caption, &measured_textx, &measured_texty);
+
wxCoord tab_height = measured_texty + 4;
- wxCoord tab_width = measured_textx + tab_height + 5;
- wxCoord tab_x = in_rect.x;
- wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
+ wxCoord tab_width = measured_textx + tab_height + 5;
+ if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+ tab_width += m_active_close_bmp.GetWidth();
+
+ if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
+ {
+ tab_width = m_fixed_tab_width;
+ }
+
+ *x_extent = tab_width - (tab_height/2) - 1;
- // select pen, brush and font for the tab to be drawn
+ return wxSize(tab_width, tab_height);
+}
- if (active)
+
+void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
+ wxWindow* WXUNUSED(wnd),
+ const wxRect& in_rect,
+ int bitmap_id,
+ int button_state,
+ int orientation,
+ const wxBitmap& bitmap_override,
+ wxRect* out_rect)
+{
+ wxBitmap bmp;
+ wxRect rect;
+
+ if (bitmap_override.IsOk())
{
- dc->SetPen(m_selected_bkpen);
- dc->SetBrush(m_selected_bkbrush);
- dc->SetFont(m_selected_font);
- textx = selected_textx;
- texty = selected_texty;
+ bmp = bitmap_override;
}
else
{
- dc->SetPen(m_normal_bkpen);
- dc->SetBrush(m_normal_bkbrush);
- dc->SetFont(m_normal_font);
- textx = normal_textx;
- texty = normal_texty;
+ switch (bitmap_id)
+ {
+ case wxAUI_BUTTON_CLOSE:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_close_bmp;
+ else
+ bmp = m_active_close_bmp;
+ break;
+ case wxAUI_BUTTON_LEFT:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_left_bmp;
+ else
+ bmp = m_active_left_bmp;
+ break;
+ case wxAUI_BUTTON_RIGHT:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_right_bmp;
+ else
+ bmp = m_active_right_bmp;
+ break;
+ case wxAUI_BUTTON_WINDOWLIST:
+ if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+ bmp = m_disabled_windowlist_bmp;
+ else
+ bmp = m_active_windowlist_bmp;
+ break;
+ }
}
+ if (!bmp.IsOk())
+ return;
+
+ rect = in_rect;
+
+ if (orientation == wxLEFT)
+ {
+ rect.SetX(in_rect.x);
+ rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
+ rect.SetWidth(bmp.GetWidth());
+ rect.SetHeight(bmp.GetHeight());
+ }
+ else
+ {
+ rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
+ ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
+ bmp.GetWidth(), bmp.GetHeight());
+ }
+
+
+ DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
+
+ *out_rect = rect;
+}
- // -- draw line --
-
- wxPoint points[7];
- points[0].x = tab_x;
- points[0].y = tab_y + tab_height - 1;
- points[1].x = tab_x + tab_height - 3;
- points[1].y = tab_y + 2;
- points[2].x = tab_x + tab_height + 3;
- points[2].y = tab_y;
- points[3].x = tab_x + tab_width - 2;
- points[3].y = tab_y;
- points[4].x = tab_x + tab_width;
- points[4].y = tab_y + 2;
- points[5].x = tab_x + tab_width;
- points[5].y = tab_y + tab_height - 1;
- points[6] = points[0];
-
-
- dc->DrawPolygon(6, points);
-
- dc->SetPen(*wxGREY_PEN);
-
- //dc->DrawLines(active ? 6 : 7, points);
- dc->DrawLines(7, points);
-
- // -- draw text --
- dc->DrawText(caption,
- tab_x + (tab_height/3) + (tab_width/2) - (textx/2),
- tab_y + tab_height - texty - 2);
+int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
+ const wxArrayString& items,
+ int active_idx)
+{
+ wxMenu menuPopup;
- *out_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
- *x_extent = tab_width - (tab_height/2) - 1;
+ size_t i, count = items.GetCount();
+ for (i = 0; i < count; ++i)
+ {
+ menuPopup.AppendCheckItem(1000+i, items.Item(i));
+ }
+
+ if (active_idx != -1)
+ {
+ menuPopup.Check(1000+active_idx, true);
+ }
+
+ // find out where to put the popup menu of window
+ // items. Subtract 100 for now to center the menu
+ // a bit, until a better mechanism can be implemented
+ wxPoint pt = ::wxGetMousePosition();
+ pt = wnd->ScreenToClient(pt);
+ if (pt.x < 100)
+ pt.x = 0;
+ else
+ pt.x -= 100;
+
+ // find out the screen coordinate at the bottom of the tab ctrl
+ wxRect cli_rect = wnd->GetClientRect();
+ pt.y = cli_rect.y + cli_rect.height;
+
+ wxAuiCommandCapture* cc = new wxAuiCommandCapture;
+ wnd->PushEventHandler(cc);
+ wnd->PopupMenu(&menuPopup, pt);
+ int command = cc->GetCommandId();
+ wnd->PopEventHandler(true);
+
+ if (command >= 1000)
+ return command-1000;
+
+ return -1;
}
+int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+ wxAuiNotebookPageArray& WXUNUSED(pages))
+{
+ wxClientDC dc(wnd);
+ dc.SetFont(m_measuring_font);
+ int x_ext = 0;
+ wxSize s = GetTabSize(dc,
+ wnd,
+ wxT("ABCDEFGHIj"),
+ wxNullBitmap,
+ true,
+ wxAUI_BUTTON_STATE_HIDDEN,
+ &x_ext);
+ return s.y+3;
+}
-void wxDefaultTabArt::SetNormalFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
{
m_normal_font = font;
}
-void wxDefaultTabArt::SetSelectedFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
{
m_selected_font = font;
}
-void wxDefaultTabArt::SetMeasuringFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
{
m_measuring_font = font;
}
-
-
// -- wxAuiTabContainer class implementation --
wxAuiTabContainer::wxAuiTabContainer()
{
- m_art = new wxDefaultTabArt;
+ m_tab_offset = 0;
+ m_flags = 0;
+ m_art = new wxAuiDefaultTabArt;
+
+ AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
+ AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
+ AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
+ AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
}
wxAuiTabContainer::~wxAuiTabContainer()
delete m_art;
}
-void wxAuiTabContainer::SetArtProvider(wxTabArt* art)
+void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
{
delete m_art;
m_art = art;
+
+ if (m_art)
+ {
+ m_art->SetFlags(m_flags);
+ }
}
-wxTabArt* wxAuiTabContainer::GetArtProvider()
+wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
{
return m_art;
}
+void wxAuiTabContainer::SetFlags(unsigned int flags)
+{
+ m_flags = flags;
+
+ // check for new close button settings
+ RemoveButton(wxAUI_BUTTON_LEFT);
+ RemoveButton(wxAUI_BUTTON_RIGHT);
+ RemoveButton(wxAUI_BUTTON_WINDOWLIST);
+ RemoveButton(wxAUI_BUTTON_CLOSE);
+
+
+ if (flags & wxAUI_NB_SCROLL_BUTTONS)
+ {
+ AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
+ AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
+ }
+
+ if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
+ {
+ AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
+ }
+
+ if (flags & wxAUI_NB_CLOSE_BUTTON)
+ {
+ AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
+ }
+
+ if (m_art)
+ {
+ m_art->SetFlags(m_flags);
+ }
+}
+
+unsigned int wxAuiTabContainer::GetFlags() const
+{
+ return m_flags;
+}
+
+
void wxAuiTabContainer::SetNormalFont(const wxFont& font)
{
m_art->SetNormalFont(font);
void wxAuiTabContainer::SetRect(const wxRect& rect)
{
m_rect = rect;
+
+ if (m_art)
+ {
+ m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
+ }
}
bool wxAuiTabContainer::AddPage(wxWindow* page,
m_pages.Add(page_info);
+ // let the art provider know how many pages we have
+ if (m_art)
+ {
+ m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
+ }
+
return true;
}
else
m_pages.Insert(page_info, idx);
+ // let the art provider know how many pages we have
+ if (m_art)
+ {
+ m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
+ }
+
+ return true;
+}
+
+bool wxAuiTabContainer::MovePage(wxWindow* page,
+ size_t new_idx)
+{
+ int idx = GetIdxFromWindow(page);
+ if (idx == -1)
+ return false;
+
+ // get page entry, make a copy of it
+ wxAuiNotebookPage p = GetPage(idx);
+
+ // remove old page entry
+ RemovePage(page);
+
+ // insert page where it should be
+ InsertPage(page, p, new_idx);
+
return true;
}
if (page.window == wnd)
{
m_pages.RemoveAt(i);
+
+ // let the art provider know how many pages we have
+ if (m_art)
+ {
+ m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
+ }
+
return true;
}
}
return m_pages.GetCount();
}
-void wxAuiTabContainer::AddButton(int id, int location, const wxBitmap& bmp)
+void wxAuiTabContainer::AddButton(int id,
+ int location,
+ const wxBitmap& normal_bitmap,
+ const wxBitmap& disabled_bitmap)
{
wxAuiTabContainerButton button;
button.id = id;
- button.bitmap = bmp;
+ button.bitmap = normal_bitmap;
+ button.dis_bitmap = disabled_bitmap;
button.location = location;
button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
m_buttons.Add(button);
}
+void wxAuiTabContainer::RemoveButton(int id)
+{
+ size_t i, button_count = m_buttons.GetCount();
+
+ for (i = 0; i < button_count; ++i)
+ {
+ if (m_buttons.Item(i).id == id)
+ {
+ m_buttons.RemoveAt(i);
+ return;
+ }
+ }
+}
+
+
+
+size_t wxAuiTabContainer::GetTabOffset() const
+{
+ return m_tab_offset;
+}
+
+void wxAuiTabContainer::SetTabOffset(size_t offset)
+{
+ m_tab_offset = offset;
+}
+
+
// Render() renders the tab catalog to the specified DC
// It is a virtual function and can be overridden to
// provide custom drawing capabilities
-void wxAuiTabContainer::Render(wxDC* raw_dc)
+void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
{
+ if (!raw_dc || !raw_dc->IsOk())
+ return;
+
wxMemoryDC dc;
wxBitmap bmp;
+ size_t i;
+ size_t page_count = m_pages.GetCount();
+ size_t button_count = m_buttons.GetCount();
+
+ // create off-screen bitmap
bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
dc.SelectObject(bmp);
- m_art->DrawBackground(&dc, m_rect);
+ if (!dc.IsOk())
+ return;
+
+ // find out if size of tabs is larger than can be
+ // afforded on screen
+ int total_width = 0;
+ int visible_width = 0;
+ for (i = 0; i < page_count; ++i)
+ {
+ wxAuiNotebookPage& page = m_pages.Item(i);
+
+ // determine if a close button is on this tab
+ bool close_button = false;
+ if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
+ ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
+ {
+ close_button = true;
+ }
+
+
+ int x_extent = 0;
+ wxSize size = m_art->GetTabSize(dc,
+ wnd,
+ page.caption,
+ page.bitmap,
+ page.active,
+ close_button ?
+ wxAUI_BUTTON_STATE_NORMAL :
+ wxAUI_BUTTON_STATE_HIDDEN,
+ &x_extent);
+
+ if (i+1 < page_count)
+ total_width += x_extent;
+ else
+ total_width += size.x;
+
+ if (i >= m_tab_offset)
+ {
+ if (i+1 < page_count)
+ visible_width += x_extent;
+ else
+ visible_width += size.x;
+ }
+ }
+
+ if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
+ {
+ // show left/right buttons
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.id == wxAUI_BUTTON_LEFT ||
+ button.id == wxAUI_BUTTON_RIGHT)
+ {
+ button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
+ }
+ }
+ }
+ else
+ {
+ // hide left/right buttons
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.id == wxAUI_BUTTON_LEFT ||
+ button.id == wxAUI_BUTTON_RIGHT)
+ {
+ button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
+ }
+ }
+ }
+
+ // determine whether left button should be enabled
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.id == wxAUI_BUTTON_LEFT)
+ {
+ if (m_tab_offset == 0)
+ button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
+ else
+ button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
+ }
+ if (button.id == wxAUI_BUTTON_RIGHT)
+ {
+ if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
+ button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
+ else
+ button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
+ }
+ }
+
+
+
+ // draw background
+ m_art->DrawBackground(dc, wnd, m_rect);
+ // draw buttons
+ int left_buttons_width = 0;
+ int right_buttons_width = 0;
+
int offset = 0;
- size_t i;
// draw the buttons on the right side
offset = m_rect.x + m_rect.width;
- size_t button_count = m_buttons.GetCount();
for (i = 0; i < button_count; ++i)
{
wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
if (button.location != wxRIGHT)
continue;
-
- wxRect button_rect(offset - button.bitmap.GetWidth(), 1,
- button.bitmap.GetWidth(), button.bitmap.GetHeight());
-
- button.rect = button_rect;
-
- DrawButton(dc, button.rect, button.bitmap,
- //m_bkbrush.GetColour(),
- *wxWHITE,
- button.cur_state);
-
- offset -= button.bitmap.GetWidth();
+ if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ wxRect button_rect = m_rect;
+ button_rect.SetY(1);
+ button_rect.SetWidth(offset);
+
+ m_art->DrawButton(dc,
+ wnd,
+ button_rect,
+ button.id,
+ button.cur_state,
+ wxRIGHT,
+ wxNullBitmap,
+ &button.rect);
+
+ offset -= button.rect.GetWidth();
+ right_buttons_width += button.rect.GetWidth();
}
if (button.location != wxLEFT)
continue;
-
- wxRect button_rect(offset, 1,
- button.bitmap.GetWidth(),
- button.bitmap.GetHeight());
-
- button.rect = button_rect;
-
- DrawButton(dc, button.rect, button.bitmap,
- //m_bkbrush.GetColour(),
- *wxWHITE,
- button.cur_state);
-
- offset += button.bitmap.GetWidth();
+ if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ wxRect button_rect(offset, 1, 1000, m_rect.height);
+
+ m_art->DrawButton(dc,
+ wnd,
+ button_rect,
+ button.id,
+ button.cur_state,
+ wxLEFT,
+ wxNullBitmap,
+ &button.rect);
+
+ offset += button.rect.GetWidth();
+ left_buttons_width += button.rect.GetWidth();
}
+ offset = left_buttons_width;
+
+ if (offset == 0)
+ offset += m_art->GetIndentSize();
+
+ // prepare the tab-close-button array
+ // make sure tab button entries which aren't used are marked as hidden
+ for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
+ m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+
+ // make sure there are enough tab button entries to accommodate all tabs
+ while (m_tab_close_buttons.GetCount() < page_count)
+ {
+ wxAuiTabContainerButton tempbtn;
+ tempbtn.id = wxAUI_BUTTON_CLOSE;
+ tempbtn.location = wxCENTER;
+ tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ m_tab_close_buttons.Add(tempbtn);
+ }
+
+
+ // buttons before the tab offset must be set to hidden
+ for (i = 0; i < m_tab_offset; ++i)
+ {
+ m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ }
+
+
// draw the tabs
- size_t page_count = m_pages.GetCount();
size_t active = 999;
int active_offset = 0;
+ wxRect active_rect;
int x_extent = 0;
wxRect rect = m_rect;
rect.y = 0;
- rect.width = 1000;
rect.height = m_rect.height;
- for (i = 0; i < page_count; ++i)
+ for (i = m_tab_offset; i < page_count; ++i)
{
wxAuiNotebookPage& page = m_pages.Item(i);
+ wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
+
+ // determine if a close button is on this tab
+ bool close_button = false;
+ if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
+ ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
+ {
+ close_button = true;
+ if (tab_button.cur_state == wxAUI_BUTTON_STATE_HIDDEN)
+ {
+ tab_button.id = wxAUI_BUTTON_CLOSE;
+ tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
+ tab_button.location = wxCENTER;
+ }
+ }
+ else
+ {
+ tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ }
rect.x = offset;
+ rect.width = m_rect.width - right_buttons_width - offset - 2;
+
+ if (rect.width <= 0)
+ break;
- m_art->DrawTab(&dc,
- rect,
- page.caption,
- page.active,
- &page.rect,
- &x_extent);
+ m_art->DrawTab(dc,
+ wnd,
+ rect,
+ page.caption,
+ page.bitmap,
+ page.active,
+ tab_button.cur_state,
+ &page.rect,
+ &tab_button.rect,
+ &x_extent);
if (page.active)
{
active = i;
active_offset = offset;
+ active_rect = rect;
}
-
+
offset += x_extent;
}
+
+ // make sure to deactivate buttons which are off the screen to the right
+ for (++i; i < m_tab_close_buttons.GetCount(); ++i)
+ {
+ m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ }
+
+
// draw the active tab again so it stands in the foreground
- if (active < m_pages.GetCount())
+ if (active >= m_tab_offset && active < m_pages.GetCount())
{
wxAuiNotebookPage& page = m_pages.Item(active);
+ wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
+
+ // determine if a close button is on this tab
+ bool close_button = false;
+ if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
+ ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
+ {
+ close_button = true;
+ }
+
rect.x = active_offset;
- m_art->DrawTab(&dc,
- rect,
- page.caption,
- page.active,
- &page.rect,
- &x_extent);
+ m_art->DrawTab(dc,
+ wnd,
+ active_rect,
+ page.caption,
+ page.bitmap,
+ page.active,
+ tab_button.cur_state,
+ &page.rect,
+ &tab_button.rect,
+ &x_extent);
}
-
- raw_dc->Blit(m_rect.x, m_rect.y, m_rect.GetWidth(), m_rect.GetHeight(), &dc, 0, 0);
+
+ raw_dc->Blit(m_rect.x, m_rect.y,
+ m_rect.GetWidth(), m_rect.GetHeight(),
+ &dc, 0, 0);
}
{
if (!m_rect.Contains(x,y))
return false;
+
+ wxAuiTabContainerButton* btn = NULL;
+ if (ButtonHitTest(x, y, &btn))
+ {
+ if (m_buttons.Index(*btn) != wxNOT_FOUND)
+ return false;
+ }
size_t i, page_count = m_pages.GetCount();
- for (i = 0; i < page_count; ++i)
+ for (i = m_tab_offset; i < page_count; ++i)
{
wxAuiNotebookPage& page = m_pages.Item(i);
if (page.rect.Contains(x,y))
{
- *hit = page.window;
+ if (hit)
+ *hit = page.window;
return true;
}
}
if (!m_rect.Contains(x,y))
return false;
- size_t i, button_count = m_buttons.GetCount();
-
+ size_t i, button_count;
+
+
+ button_count = m_buttons.GetCount();
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.rect.Contains(x,y) &&
+ !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
+ wxAUI_BUTTON_STATE_DISABLED)))
+ {
+ if (hit)
+ *hit = &button;
+ return true;
+ }
+ }
+
+ button_count = m_tab_close_buttons.GetCount();
for (i = 0; i < button_count; ++i)
{
- wxAuiTabContainerButton& button = m_buttons.Item(i);
- if (button.rect.Contains(x,y))
+ wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
+ if (button.rect.Contains(x,y) &&
+ !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
+ wxAUI_BUTTON_STATE_DISABLED)))
{
- *hit = &button;
+ if (hit)
+ *hit = &button;
return true;
}
}
-
+
return false;
}
// the utility function ShowWnd() is the same as show,
-// except it handles wxTabMDIChildFrame windows as well,
+// except it handles wxAuiMDIChildFrame windows as well,
// as the Show() method on this class is "unplugged"
static void ShowWnd(wxWindow* wnd, bool show)
{
- if (wnd->IsKindOf(CLASSINFO(wxTabMDIChildFrame)))
+ if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
- wxTabMDIChildFrame* cf = (wxTabMDIChildFrame*)wnd;
+ wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
cf->DoShow(show);
}
else
// -- wxAuiTabCtrl class implementation --
-const int wxAuiButtonClose = 101;
BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
EVT_PAINT(wxAuiTabCtrl::OnPaint)
EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
EVT_MOTION(wxAuiTabCtrl::OnMotion)
EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
+ EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton)
END_EVENT_TABLE()
m_click_pt = wxDefaultPosition;
m_is_dragging = false;
m_hover_button = NULL;
-
- // FIXME: copied from dockart-- needs to put in a common place
-#if defined( __WXMAC__ )
- static unsigned char close_bits[]={
- 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
- 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
- 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
-#elif defined( __WXGTK__)
- static unsigned char close_bits[]={
- 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
- 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
- 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-#else
- static unsigned char close_bits[]={
- 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
- 0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
- 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
-#endif
-
- AddButton(101, wxRIGHT, BitmapFromBits(close_bits, 16, 16, *wxBLACK));
+ m_pressed_button = NULL;
}
+wxAuiTabCtrl::~wxAuiTabCtrl()
+{
+}
void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
{
dc.SetFont(GetFont());
if (GetPageCount() > 0)
- Render(&dc);
+ Render(&dc, this);
}
void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
CaptureMouse();
m_click_pt = wxDefaultPosition;
m_is_dragging = false;
- m_click_tab = -1;
+ m_click_tab = NULL;
+ m_pressed_button = NULL;
+
wxWindow* wnd;
if (TabHitTest(evt.m_x, evt.m_y, &wnd))
{
- wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
- e.SetSelection(GetIdxFromWindow(wnd));
- e.SetOldSelection(GetActivePage());
- e.SetEventObject(this);
- GetEventHandler()->ProcessEvent(e);
+ int new_selection = GetIdxFromWindow(wnd);
+
+ if (new_selection != GetActivePage())
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+ e.SetSelection(new_selection);
+ e.SetOldSelection(GetActivePage());
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+ }
m_click_pt.x = evt.m_x;
m_click_pt.y = evt.m_y;
- m_click_tab = e.GetSelection();
+ m_click_tab = wnd;
}
-
+
if (m_hover_button)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
+ m_pressed_button = m_hover_button;
+ m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
Refresh();
Update();
}
}
-void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
+void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
{
if (GetCapture() == this)
ReleaseMouse();
if (m_is_dragging)
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
- evt.SetSelection(m_click_tab);
- evt.SetOldSelection(m_click_tab);
+ evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
return;
}
- if (m_hover_button)
+ if (m_pressed_button)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_HOVER;
+ // make sure we're still clicking the button
+ wxAuiTabContainerButton* button = NULL;
+ if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
+ return;
+
+ if (button != m_pressed_button)
+ {
+ m_pressed_button = NULL;
+ return;
+ }
+
Refresh();
Update();
- wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
- evt.SetInt(m_hover_button->id);
- evt.SetEventObject(this);
- GetEventHandler()->ProcessEvent(evt);
+ if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+ {
+ wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
+ evt.SetInt(m_pressed_button->id);
+ evt.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(evt);
+ }
+
+ m_pressed_button = NULL;
}
m_click_pt = wxDefaultPosition;
m_is_dragging = false;
- m_click_tab = -1;
+ m_click_tab = NULL;
}
void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
if (m_is_dragging)
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
- evt.SetSelection(m_click_tab);
- evt.SetOldSelection(m_click_tab);
+ evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
return;
abs(pos.y - m_click_pt.y) > drag_y_threshold)
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
- evt.SetSelection(m_click_tab);
- evt.SetOldSelection(m_click_tab);
+ evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
}
}
+void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
+{
+ int button = event.GetInt();
+
+ if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
+ {
+ if (button == wxAUI_BUTTON_LEFT)
+ {
+ if (GetTabOffset() > 0)
+ {
+ SetTabOffset(GetTabOffset()-1);
+ Refresh();
+ Update();
+ }
+ }
+ else
+ {
+ SetTabOffset(GetTabOffset()+1);
+ Refresh();
+ Update();
+ }
+ }
+ else if (button == wxAUI_BUTTON_WINDOWLIST)
+ {
+ wxArrayString as;
+
+ size_t i, page_count = m_pages.GetCount();
+ for (i = 0; i < page_count; ++i)
+ {
+ wxAuiNotebookPage& page = m_pages.Item(i);
+ as.Add(page.caption);
+ }
+
+ int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
+
+ if (idx != -1)
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+ e.SetSelection(idx);
+ e.SetOldSelection(GetActivePage());
+ e.SetEventObject(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
if (!m_tabs)
return;
- int tab_height = wxMin(m_rect.height, m_tab_ctrl_height);
- m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, tab_height);
- m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, tab_height);
- m_tabs->SetRect(wxRect(0, 0, m_rect.width, tab_height));
+ 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));
m_tabs->Refresh();
m_tabs->Update();
for (i = 0; i < page_count; ++i)
{
wxAuiNotebookPage& page = pages.Item(i);
- page.window->SetSize(m_rect.x, m_rect.y+tab_height, m_rect.width, m_rect.height-tab_height);
+ page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
+ m_rect.width, m_rect.height - m_tab_ctrl_height);
- if (page.window->IsKindOf(CLASSINFO(wxTabMDIChildFrame)))
+ if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
- wxTabMDIChildFrame* wnd = (wxTabMDIChildFrame*)page.window;
+ wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
wnd->ApplyMDIChildFrameRect();
}
}
-// -- wxAuiMultiNotebook class implementation --
+// -- wxAuiNotebook class implementation --
-BEGIN_EVENT_TABLE(wxAuiMultiNotebook, wxControl)
- //EVT_ERASE_BACKGROUND(wxAuiMultiNotebook::OnEraseBackground)
- //EVT_SIZE(wxAuiMultiNotebook::OnSize)
- //EVT_LEFT_DOWN(wxAuiMultiNotebook::OnLeftDown)
- EVT_CHILD_FOCUS(wxAuiMultiNotebook::OnChildFocus)
+BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
+ //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
+ //EVT_SIZE(wxAuiNotebook::OnSize)
+ //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
+ EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
EVT_COMMAND_RANGE(10000, 10100,
wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
- wxAuiMultiNotebook::OnTabClicked)
+ wxAuiNotebook::OnTabClicked)
EVT_COMMAND_RANGE(10000, 10100,
wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
- wxAuiMultiNotebook::OnTabBeginDrag)
+ wxAuiNotebook::OnTabBeginDrag)
EVT_COMMAND_RANGE(10000, 10100,
wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
- wxAuiMultiNotebook::OnTabEndDrag)
+ wxAuiNotebook::OnTabEndDrag)
EVT_COMMAND_RANGE(10000, 10100,
wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
- wxAuiMultiNotebook::OnTabDragMotion)
+ wxAuiNotebook::OnTabDragMotion)
EVT_COMMAND_RANGE(10000, 10100,
wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
- wxAuiMultiNotebook::OnTabButton)
+ wxAuiNotebook::OnTabButton)
END_EVENT_TABLE()
-wxAuiMultiNotebook::wxAuiMultiNotebook()
+wxAuiNotebook::wxAuiNotebook()
{
m_curpage = -1;
m_tab_id_counter = 10000;
m_tab_ctrl_height = 20;
}
-wxAuiMultiNotebook::wxAuiMultiNotebook(wxWindow *parent,
+wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style) : wxControl(parent, id, pos, size, style)
{
- InitNotebook();
+ InitNotebook(style);
}
-bool wxAuiMultiNotebook::Create(wxWindow* parent,
+bool wxAuiNotebook::Create(wxWindow* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
if (!wxControl::Create(parent, id, pos, size, style))
return false;
- InitNotebook();
+ InitNotebook(style);
return true;
}
// InitNotebook() contains common initialization
// code called by all constructors
-void wxAuiMultiNotebook::InitNotebook()
+void wxAuiNotebook::InitNotebook(long style)
{
m_curpage = -1;
m_tab_id_counter = 10000;
m_dummy_wnd = NULL;
m_tab_ctrl_height = 20;
-
+ m_flags = (unsigned int)style;
+
m_normal_font = *wxNORMAL_FONT;
m_selected_font = *wxNORMAL_FONT;
m_selected_font.SetWeight(wxBOLD);
- // choose a default for the tab height
- wxClientDC dc(this);
- int tx, ty;
- dc.SetFont(m_selected_font);
- dc.GetTextExtent(wxT("ABCDEFGHhijklm"), &tx, &ty);
- m_tab_ctrl_height = (ty*150)/100;
+ SetArtProvider(new wxAuiDefaultTabArt);
m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
m_dummy_wnd->SetSize(200, 200);
m_mgr.SetManagedWindow(this);
m_mgr.AddPane(m_dummy_wnd,
- wxPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
+ wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
m_mgr.Update();
}
-wxAuiMultiNotebook::~wxAuiMultiNotebook()
+wxAuiNotebook::~wxAuiNotebook()
{
m_mgr.UnInit();
}
-void wxAuiMultiNotebook::SetArtProvider(wxTabArt* art)
+void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
{
m_tabs.SetArtProvider(art);
+
+ SetTabCtrlHeight(CalculateTabCtrlHeight());
+}
+
+void wxAuiNotebook::SetTabCtrlHeight(int height)
+{
+ // if the tab control height needs to change, update
+ // all of our tab controls with the new height
+ if (m_tab_ctrl_height != height)
+ {
+ wxAuiTabArt* art = m_tabs.GetArtProvider();
+
+ m_tab_ctrl_height = height;
+
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ size_t i, pane_count = all_panes.GetCount();
+ for (i = 0; i < pane_count; ++i)
+ {
+ wxAuiPaneInfo& pane = all_panes.Item(i);
+ if (pane.name == wxT("dummy"))
+ continue;
+ wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
+ wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
+ tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
+ tabctrl->SetArtProvider(art->Clone());
+ tab_frame->DoSizing();
+ }
+ }
+}
+
+int wxAuiNotebook::CalculateTabCtrlHeight()
+{
+ // find out new best tab height
+ wxAuiTabArt* art = m_tabs.GetArtProvider();
+
+ return art->GetBestTabCtrlSize(this, m_tabs.GetPages());
}
-wxTabArt* wxAuiMultiNotebook::GetArtProvider()
+
+wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
{
return m_tabs.GetArtProvider();
}
-bool wxAuiMultiNotebook::AddPage(wxWindow* page,
+void wxAuiNotebook::SetWindowStyleFlag(long style)
+{
+ wxControl::SetWindowStyleFlag(style);
+
+ m_flags = (unsigned int)style;
+
+ // if the control is already initialized
+ if (m_mgr.GetManagedWindow() == (wxWindow*)this)
+ {
+ // let all of the tab children know about the new style
+
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ size_t i, pane_count = all_panes.GetCount();
+ for (i = 0; i < pane_count; ++i)
+ {
+ wxAuiPaneInfo& pane = all_panes.Item(i);
+ if (pane.name == wxT("dummy"))
+ continue;
+ wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
+ tabctrl->SetFlags(m_flags);
+ tabctrl->Refresh();
+ tabctrl->Update();
+ }
+ }
+}
+
+
+bool wxAuiNotebook::AddPage(wxWindow* page,
const wxString& caption,
bool select,
const wxBitmap& bitmap)
return InsertPage(GetPageCount(), page, caption, select, bitmap);
}
-bool wxAuiMultiNotebook::InsertPage(size_t page_idx,
+bool wxAuiNotebook::InsertPage(size_t page_idx,
wxWindow* page,
const wxString& caption,
bool select,
else
active_tabctrl->InsertPage(page, info, page_idx);
+ SetTabCtrlHeight(CalculateTabCtrlHeight());
DoSizing();
active_tabctrl->DoShowHide();
if (select)
{
int idx = m_tabs.GetIdxFromWindow(page);
- wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiMultiNotebook::InsertPage()"));
+ wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
SetSelection(idx);
}
// DeletePage() removes a tab from the multi-notebook,
// and destroys the window as well
-bool wxAuiMultiNotebook::DeletePage(size_t page_idx)
+bool wxAuiNotebook::DeletePage(size_t page_idx)
{
wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
+
+ if (!RemovePage(page_idx))
+ return false;
+
+ // actually destroy the window now
+ if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
+ {
+ // delete the child frame with pending delete, as is
+ // customary with frame windows
+ if (!wxPendingDelete.Member(wnd))
+ wxPendingDelete.Append(wnd);
+ }
+ else
+ {
+ wnd->Destroy();
+ }
+
+ return true;
+}
+
+
+
+// RemovePage() removes a tab from the multi-notebook,
+// but does not destroy the window
+bool wxAuiNotebook::RemovePage(size_t page_idx)
+{
+ wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
wxWindow* new_active = NULL;
// find out which onscreen tab ctrl owns this tab
// remove the tab from the onscreen tab ctrl
ctrl->RemovePage(wnd);
- // actually destroy the window now
- if (wnd->IsKindOf(CLASSINFO(wxTabMDIChildFrame)))
- {
- // delete the child frame with pending delete, as is
- // customary with frame windows
- if (!wxPendingDelete.Member(wnd))
- wxPendingDelete.Append(wnd);
- }
- else
- {
- wnd->Destroy();
- }
RemoveEmptyTabFrames();
return true;
}
+// GetPageIndex() returns the index of the page, or -1 if the
+// page could not be located in the notebook
+int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
+{
+ return m_tabs.GetIdxFromWindow(page_wnd);
+}
+
-// RemovePage() removes a tab from the multi-notebook,
-// but does not destroy the window
-bool wxAuiMultiNotebook::RemovePage(size_t page_idx)
+// SetPageText() changes the tab caption of the specified page
+bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
{
- // remove the tab from our own catalog
- wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
- if (!m_tabs.RemovePage(wnd))
+ if (page_idx >= m_tabs.GetPageCount())
return false;
- // remove the tab from the onscreen tab ctrl
+ // update our own tab catalog
+ wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+ page_info.caption = text;
+
+ // update what's on screen
wxAuiTabCtrl* ctrl;
int ctrl_idx;
- if (FindTab(wnd, &ctrl, &ctrl_idx))
+ if (FindTab(page_info.window, &ctrl, &ctrl_idx))
{
- ctrl->RemovePage(wnd);
- return true;
+ wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
+ info.caption = text;
+ ctrl->Refresh();
+ ctrl->Update();
}
- return false;
+ return true;
}
-// SetPageText() changes the tab caption of the specified page
-bool wxAuiMultiNotebook::SetPageText(size_t page_idx, const wxString& text)
+
+bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
{
if (page_idx >= m_tabs.GetPageCount())
return false;
-
+
// update our own tab catalog
wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
- page_info.caption = text;
-
+ page_info.bitmap = bitmap;
+
+ // tab height might have changed
+ SetTabCtrlHeight(CalculateTabCtrlHeight());
+
// update what's on screen
wxAuiTabCtrl* ctrl;
int ctrl_idx;
if (FindTab(page_info.window, &ctrl, &ctrl_idx))
{
wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
- info.caption = text;
+ info.bitmap = bitmap;
ctrl->Refresh();
ctrl->Update();
}
-
+
return true;
}
+
// GetSelection() returns the index of the currently active page
-int wxAuiMultiNotebook::GetSelection() const
+int wxAuiNotebook::GetSelection() const
{
return m_curpage;
}
// SetSelection() sets the currently active page
-size_t wxAuiMultiNotebook::SetSelection(size_t new_page)
+size_t wxAuiNotebook::SetSelection(size_t new_page)
{
wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
if (!wnd)
evt.SetEventObject(this);
if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
{
+ int old_curpage = m_curpage;
+ m_curpage = new_page;
+
// program allows the page change
evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
(void)GetEventHandler()->ProcessEvent(evt);
-
wxAuiTabCtrl* ctrl;
int ctrl_idx;
if (FindTab(wnd, &ctrl, &ctrl_idx))
DoSizing();
ctrl->DoShowHide();
- int old_curpage = m_curpage;
- m_curpage = new_page;
// set fonts
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
- wxPaneInfo& pane = all_panes.Item(i);
+ wxAuiPaneInfo& pane = all_panes.Item(i);
if (pane.name == wxT("dummy"))
continue;
wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
// GetPageCount() returns the total number of
// pages managed by the multi-notebook
-size_t wxAuiMultiNotebook::GetPageCount() const
+size_t wxAuiNotebook::GetPageCount() const
{
return m_tabs.GetPageCount();
}
// GetPage() returns the wxWindow pointer of the
// specified page
-wxWindow* wxAuiMultiNotebook::GetPage(size_t page_idx) const
+wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
{
wxASSERT(page_idx < m_tabs.GetPageCount());
}
// DoSizing() performs all sizing operations in each tab control
-void wxAuiMultiNotebook::DoSizing()
+void wxAuiNotebook::DoSizing()
{
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
// GetActiveTabCtrl() returns the active tab control. It is
// called to determine which control gets new windows being added
-wxAuiTabCtrl* wxAuiMultiNotebook::GetActiveTabCtrl()
+wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
{
if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
{
}
// no current page, just find the first tab ctrl
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
wxDefaultPosition,
wxDefaultSize,
wxNO_BORDER);
+ tabframe->m_tabs->SetFlags(m_flags);
+ tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
m_mgr.AddPane(tabframe,
- wxPaneInfo().Center().CaptionVisible(false));
+ wxAuiPaneInfo().Center().CaptionVisible(false));
m_mgr.Update();
// FindTab() finds the tab control that currently contains the window as well
// as the index of the window in the tab control. It returns true if the
// window was found, otherwise false.
-bool wxAuiMultiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
+bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
{
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
}
-void wxAuiMultiNotebook::OnEraseBackground(wxEraseEvent&)
+void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
{
}
-void wxAuiMultiNotebook::OnSize(wxSizeEvent&)
+void wxAuiNotebook::OnSize(wxSizeEvent&)
{
}
-void wxAuiMultiNotebook::OnTabClicked(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
{
wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
SetSelection(idx);
}
-void wxAuiMultiNotebook::OnTabBeginDrag(wxCommandEvent&)
+void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
{
+ m_last_drag_x = 0;
}
-void wxAuiMultiNotebook::OnTabDragMotion(wxCommandEvent& evt)
+void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
{
wxPoint screen_pt = ::wxGetMousePosition();
wxPoint client_pt = ScreenToClient(screen_pt);
wxPoint zero(0,0);
wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
-
- wxAuiTabCtrl* tab_ctrl = GetTabCtrlFromPoint(client_pt);
- if (tab_ctrl == src_tabs)
+ wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
+
+ if (dest_tabs == src_tabs)
{
- // inner-tabctrl dragging is not yet implemented
+ if (src_tabs)
+ {
+ src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
+ }
+
+ // always hide the hint for inner-tabctrl drag
m_mgr.HideHint();
+
+ // if tab moving is not allowed, leave
+ if (!(m_flags & wxAUI_NB_TAB_MOVE))
+ {
+ return;
+ }
+
+ wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
+ wxWindow* dest_location_tab;
+
+ // this is an inner-tab drag/reposition
+ if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
+ {
+ int src_idx = evt.GetSelection();
+ int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
+
+ // prevent jumpy drag
+ if ((src_idx == dest_idx) || dest_idx == -1 ||
+ (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
+ (src_idx < dest_idx && m_last_drag_x >= pt.x))
+ {
+ m_last_drag_x = pt.x;
+ return;
+ }
+
+
+ wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
+ dest_tabs->MovePage(src_tab, dest_idx);
+ dest_tabs->SetActivePage((size_t)dest_idx);
+ dest_tabs->DoShowHide();
+ dest_tabs->Refresh();
+ m_last_drag_x = pt.x;
+
+ }
+
return;
}
- if (tab_ctrl)
+
+ // if external drag is allowed, check if the tab is being dragged
+ // over a different wxAuiNotebook control
+ if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
+ {
+ wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
+
+ // if we aren't over any window, stop here
+ if (!tab_ctrl)
+ return;
+
+ // make sure we are not over the hint window
+ if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ while (tab_ctrl)
+ {
+ if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
+ break;
+ tab_ctrl = tab_ctrl->GetParent();
+ }
+
+ if (tab_ctrl)
+ {
+ wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
+
+ if (nb != this)
+ {
+ wxRect hint_rect = tab_ctrl->GetClientRect();
+ tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
+ m_mgr.ShowHint(hint_rect);
+ return;
+ }
+ }
+ }
+ else
+ {
+ if (!dest_tabs)
+ {
+ // we are either over a hint window, or not over a tab
+ // window, and there is no where to drag to, so exit
+ return;
+ }
+ }
+ }
+
+
+ // if there are less than two panes, split can't happen, so leave
+ if (m_tabs.GetPageCount() < 2)
+ return;
+
+ // if tab moving is not allowed, leave
+ if (!(m_flags & wxAUI_NB_TAB_SPLIT))
+ return;
+
+
+ if (src_tabs)
+ {
+ src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
+ }
+
+
+ if (dest_tabs)
{
- wxRect hint_rect = tab_ctrl->GetRect();
+ wxRect hint_rect = dest_tabs->GetRect();
ClientToScreen(&hint_rect.x, &hint_rect.y);
m_mgr.ShowHint(hint_rect);
}
-void wxAuiMultiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
{
wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
m_mgr.HideHint();
-
+
+ wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxAuiTabCtrl* dest_tabs = NULL;
+ if (src_tabs)
+ {
+ // set cursor back to an arrow
+ src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
+ }
+
// get the mouse position, which will be used to determine the drop point
wxPoint mouse_screen_pt = ::wxGetMousePosition();
wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
- // the src tab control is the control that fired this event
- wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
- wxAuiTabCtrl* dest_tabs = NULL;
-
- // If the pointer is in an existing tab frame, do a tab insert
- wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
- wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
- if (tab_frame)
+ // check for an external move
+ if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
{
- dest_tabs = tab_frame->m_tabs;
+ wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
+
+ while (tab_ctrl)
+ {
+ if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
+ break;
+ tab_ctrl = tab_ctrl->GetParent();
+ }
+
+ if (tab_ctrl)
+ {
+ wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
+
+ if (nb != this)
+ {
+ // find out from the destination control
+ // if it's ok to drop this tab here
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
+ e.SetSelection(evt.GetSelection());
+ e.SetOldSelection(evt.GetSelection());
+ e.SetEventObject(this);
+ e.SetDragSource(this);
+ e.Veto(); // dropping must be explicitly approved by control owner
+
+ nb->GetEventHandler()->ProcessEvent(e);
+
+ if (!e.IsAllowed())
+ {
+ // no answer or negative answer
+ m_mgr.HideHint();
+ return;
+ }
+
+ // drop was allowed
+ int src_idx = evt.GetSelection();
+ wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
+
+ // get main index of the page
+ int main_idx = m_tabs.GetIdxFromWindow(src_page);
+
+ // make a copy of the page info
+ wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
+
+ // remove the page from the source notebook
+ RemovePage(main_idx);
+
+ // reparent the page
+ src_page->Reparent(nb);
+
+
+ // found out the insert idx
+ wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
+ wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
+
+ wxWindow* target = NULL;
+ int insert_idx = -1;
+ dest_tabs->TabHitTest(pt.x, pt.y, &target);
+ if (target)
+ {
+ insert_idx = dest_tabs->GetIdxFromWindow(target);
+ }
+
+
+ // add the page to the new notebook
+ if (insert_idx == -1)
+ insert_idx = dest_tabs->GetPageCount();
+ dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
+ nb->m_tabs.AddPage(page_info.window, page_info);
+
+ nb->DoSizing();
+ dest_tabs->DoShowHide();
+ dest_tabs->Refresh();
+
+ // set the selection in the destination tab control
+ nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
- if (dest_tabs == src_tabs)
- return;
- }
- else
- {
- // If there is no tabframe at all, create one
- wxTabFrame* new_tabs = new wxTabFrame;
- new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
- new_tabs->m_tabs = new wxAuiTabCtrl(this,
- m_tab_id_counter++,
- wxDefaultPosition,
- wxDefaultSize,
- wxNO_BORDER);
- m_mgr.AddPane(new_tabs,
- wxPaneInfo().Bottom().CaptionVisible(false),
- mouse_client_pt);
- m_mgr.Update();
- dest_tabs = new_tabs->m_tabs;
+ return;
+ }
+ }
}
- // remove the page from the source tabs
- wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
- page_info.active = false;
- src_tabs->RemovePage(page_info.window);
- if (src_tabs->GetPageCount() > 0)
+
+ // only perform a tab split if it's allowed
+ if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
{
- src_tabs->SetActivePage((size_t)0);
- src_tabs->DoShowHide();
- src_tabs->Refresh();
- }
+ // If the pointer is in an existing tab frame, do a tab insert
+ wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
+ wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
+ int insert_idx = -1;
+ if (tab_frame)
+ {
+ dest_tabs = tab_frame->m_tabs;
+ if (dest_tabs == src_tabs)
+ return;
+
+
+ wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
+ wxWindow* target = NULL;
+ dest_tabs->TabHitTest(pt.x, pt.y, &target);
+ if (target)
+ {
+ insert_idx = dest_tabs->GetIdxFromWindow(target);
+ }
+ }
+ else
+ {
+ // If there is no tabframe at all, create one
+ wxTabFrame* new_tabs = new wxTabFrame;
+ new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
+ new_tabs->m_tabs = new wxAuiTabCtrl(this,
+ m_tab_id_counter++,
+ wxDefaultPosition,
+ wxDefaultSize,
+ wxNO_BORDER);
+ new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
+ new_tabs->m_tabs->SetFlags(m_flags);
+
+ m_mgr.AddPane(new_tabs,
+ wxAuiPaneInfo().Bottom().CaptionVisible(false),
+ mouse_client_pt);
+ m_mgr.Update();
+ dest_tabs = new_tabs->m_tabs;
+ }
- // add the page to the destination tabs
- dest_tabs->AddPage(page_info.window, page_info);
- if (src_tabs->GetPageCount() == 0)
- {
- RemoveEmptyTabFrames();
- }
+ // remove the page from the source tabs
+ wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
+ page_info.active = false;
+ src_tabs->RemovePage(page_info.window);
+ if (src_tabs->GetPageCount() > 0)
+ {
+ src_tabs->SetActivePage((size_t)0);
+ src_tabs->DoShowHide();
+ src_tabs->Refresh();
+ }
- DoSizing();
- dest_tabs->DoShowHide();
- dest_tabs->Refresh();
- SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+
+ // add the page to the destination tabs
+ if (insert_idx == -1)
+ insert_idx = dest_tabs->GetPageCount();
+ dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
+
+ if (src_tabs->GetPageCount() == 0)
+ {
+ RemoveEmptyTabFrames();
+ }
+
+ DoSizing();
+ dest_tabs->DoShowHide();
+ dest_tabs->Refresh();
+
+ SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+ }
}
-wxAuiTabCtrl* wxAuiMultiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
+
+
+wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
{
// if we've just removed the last tab from the source
// tab set, the remove the tab control completely
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
return NULL;
}
-wxWindow* wxAuiMultiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
+wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
{
// if we've just removed the last tab from the source
// tab set, the remove the tab control completely
- wxPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
return NULL;
}
-void wxAuiMultiNotebook::RemoveEmptyTabFrames()
+void wxAuiNotebook::RemoveEmptyTabFrames()
{
// if we've just removed the last tab from the source
// tab set, the remove the tab control completely
- wxPaneInfoArray all_panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
size_t i, pane_count = all_panes.GetCount();
for (i = 0; i < pane_count; ++i)
{
// check to see if there is still a center pane;
// if there isn't, make a frame the center pane
- wxPaneInfoArray panes = m_mgr.GetAllPanes();
+ wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
pane_count = panes.GetCount();
wxWindow* first_good = NULL;
bool center_found = false;
m_mgr.Update();
}
-void wxAuiMultiNotebook::OnChildFocus(wxChildFocusEvent& evt)
+void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
{
int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
if (idx != -1 && idx != m_curpage)
}
-void wxAuiMultiNotebook::OnTabButton(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
{
wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
int button_id = evt.GetInt();
- if (button_id == wxAuiButtonClose)
+ if (button_id == wxAUI_BUTTON_CLOSE)
{
int selection = tabs->GetActivePage();
{
wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
- if (close_wnd->IsKindOf(CLASSINFO(wxTabMDIChildFrame)))
+
+ // 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));
+ e.SetOldSelection(evt.GetSelection());
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+ if (!e.IsAllowed())
+ return;
+
+
+ if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
close_wnd->Close();
}
projects / wxWidgets.git / blobdiff