X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/41b76acdc7cad34f4bcdd43e3440544fe714e6d5..e83a2e04900ec19e809d32d985669e1c664dd5a8:/src/aui/auibook.cpp?ds=sidebyside diff --git a/src/aui/auibook.cpp b/src/aui/auibook.cpp index 17c824f1de..84ed97b2b2 100644 --- a/src/aui/auibook.cpp +++ b/src/aui/auibook.cpp @@ -29,20 +29,28 @@ #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) @@ -71,11 +79,11 @@ static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h, return wxBitmap(img); } -static void DrawButtonS(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; @@ -99,6 +107,110 @@ static void DrawButtonS(wxDC& dc, 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}; + + @@ -106,12 +218,565 @@ static void DrawButtonS(wxDC& dc, // -- wxAuiDefaultTabArt class implementation -- 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(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); wxColour background_colour = StepColour(base_colour, 95); @@ -124,34 +789,6 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt() m_selected_bkbrush = wxBrush(selectedtab_colour); m_selected_bkpen = wxPen(selectedtab_colour); - -#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 - - 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}; - m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK); m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128)); @@ -160,23 +797,61 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt() 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)); + } -wxAuiDefaultTabArt::~wxAuiDefaultTabArt() +wxAuiSimpleTabArt::~wxAuiSimpleTabArt() +{ +} + +wxAuiTabArt* wxAuiSimpleTabArt::Clone() +{ + return static_cast(new wxAuiSimpleTabArt); +} + + +void wxAuiSimpleTabArt::SetFlags(unsigned int flags) { + m_flags = flags; } -void wxAuiDefaultTabArt::DrawBackground(wxDC* dc, - const wxRect& rect) +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 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); } @@ -189,14 +864,16 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC* dc, // out_rect - actual output rectangle // x_extent - the advance x; where the next tab should start -void wxAuiDefaultTabArt::DrawTab(wxDC* dc, - const wxRect& in_rect, - const wxString& caption_text, - bool active, - int close_button_state, - wxRect* out_tab_rect, - wxRect* out_button_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; @@ -207,35 +884,43 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc, if (caption_text.empty()) caption = wxT("Xj"); - dc->SetFont(m_selected_font); - dc->GetTextExtent(caption, &selected_textx, &selected_texty); + dc.SetFont(m_selected_font); + dc.GetTextExtent(caption, &selected_textx, &selected_texty); - dc->SetFont(m_normal_font); - dc->GetTextExtent(caption, &normal_textx, &normal_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, caption, active, close_button_state, x_extent); + 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; + caption = caption_text; + // 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); + 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); + dc.SetPen(m_normal_bkpen); + dc.SetBrush(m_normal_bkbrush); + dc.SetFont(m_normal_font); textx = normal_textx; texty = normal_texty; } @@ -258,13 +943,14 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc, points[5].y = tab_y + tab_height - 1; points[6] = points[0]; + dc.SetClippingRegion(in_rect); - dc->DrawPolygon(6, points); + dc.DrawPolygon(6, points); - dc->SetPen(*wxGREY_PEN); + dc.SetPen(*wxGREY_PEN); - //dc->DrawLines(active ? 6 : 7, points); - dc->DrawLines(7, points); + //dc.DrawLines(active ? 6 : 7, points); + dc.DrawLines(7, points); int text_offset; @@ -280,9 +966,17 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc, 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(caption, + dc.DrawText(draw_text, text_offset, (tab_y + tab_height)/2 - (texty/2) + 1); @@ -296,49 +990,64 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc, else bmp = m_disabled_close_bmp; - wxRect rect(tab_x + tab_width - close_button_width - 1, tab_y + 1, - close_button_width, tab_height - 1); - DrawButtonS(*dc, rect, bmp, *wxWHITE, close_button_state); + 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 wxAuiDefaultTabArt::GetTabSize(wxDC* dc, - const wxString& caption, - bool WXUNUSED(active), - int close_button_state, - int* x_extent) +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); + 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; 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; return wxSize(tab_width, tab_height); } -void wxAuiDefaultTabArt::DrawButton( - wxDC* dc, - const wxRect& in_rect, - int bitmap_id, - int button_state, - int orientation, - const wxBitmap& bitmap_override, - wxRect* out_rect) +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; @@ -369,6 +1078,12 @@ void wxAuiDefaultTabArt::DrawButton( 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; } } @@ -392,33 +1107,82 @@ void wxAuiDefaultTabArt::DrawButton( } - DrawButtonS(*dc, rect, bmp, *wxWHITE, button_state); + DrawButtons(dc, rect, bmp, *wxWHITE, button_state); *out_rect = rect; } +int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd, + const wxArrayString& items, + int active_idx) +{ + wxMenu menuPopup; -int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd) + 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, wxT("ABCDEFGHIj"), true, wxAUI_BUTTON_STATE_HIDDEN, &x_ext); + wxSize s = GetTabSize(dc, + wnd, + wxT("ABCDEFGHIj"), + wxNullBitmap, + true, + wxAUI_BUTTON_STATE_HIDDEN, + &x_ext); return s.y+3; } -void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font) +void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font) { m_normal_font = font; } -void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font) +void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font) { m_selected_font = font; } -void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font) +void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font) { m_measuring_font = font; } @@ -426,8 +1190,6 @@ void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font) - - // -- wxAuiTabContainer class implementation -- @@ -448,7 +1210,8 @@ wxAuiTabContainer::wxAuiTabContainer() m_art = new wxAuiDefaultTabArt; AddButton(wxAUI_BUTTON_LEFT, wxLEFT); - AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT); + AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT); + AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT); AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT); } @@ -461,9 +1224,14 @@ void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art) { delete m_art; m_art = art; + + if (m_art) + { + m_art->SetFlags(m_flags); + } } -wxAuiTabArt* wxAuiTabContainer::GetArtProvider() +wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const { return m_art; } @@ -473,11 +1241,32 @@ 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 @@ -504,6 +1293,11 @@ void wxAuiTabContainer::SetMeasuringFont(const wxFont& 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, @@ -515,6 +1309,12 @@ 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; } @@ -531,6 +1331,12 @@ bool wxAuiTabContainer::InsertPage(wxWindow* page, 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; } @@ -562,6 +1368,13 @@ bool wxAuiTabContainer::RemovePage(wxWindow* wnd) 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; } } @@ -700,11 +1513,17 @@ 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; @@ -715,6 +1534,8 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) bmp.Create(m_rect.GetWidth(), m_rect.GetHeight()); dc.SelectObject(bmp); + if (!dc.IsOk()) + return; // find out if size of tabs is larger than can be // afforded on screen @@ -734,8 +1555,10 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) int x_extent = 0; - wxSize size = m_art->GetTabSize(&dc, + wxSize size = m_art->GetTabSize(dc, + wnd, page.caption, + page.bitmap, page.active, close_button ? wxAUI_BUTTON_STATE_NORMAL : @@ -756,7 +1579,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) } } - if (total_width > m_rect.GetWidth() - 20 || m_tab_offset != 0) + if (total_width > m_rect.GetWidth() || m_tab_offset != 0) { // show left/right buttons for (i = 0; i < button_count; ++i) @@ -806,7 +1629,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) // draw background - m_art->DrawBackground(&dc, m_rect); + m_art->DrawBackground(dc, wnd, m_rect); // draw buttons int left_buttons_width = 0; @@ -829,7 +1652,8 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) button_rect.SetY(1); button_rect.SetWidth(offset); - m_art->DrawButton(&dc, + m_art->DrawButton(dc, + wnd, button_rect, button.id, button.cur_state, @@ -858,7 +1682,8 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) wxRect button_rect(offset, 1, 1000, m_rect.height); - m_art->DrawButton(&dc, + m_art->DrawButton(dc, + wnd, button_rect, button.id, button.cur_state, @@ -872,14 +1697,16 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) offset = left_buttons_width; - // set a clipping region to the tabs don't draw over the buttons - dc.SetClippingRegion(left_buttons_width, 0, - m_rect.GetWidth() - right_buttons_width - left_buttons_width - 2, - m_rect.GetHeight()); - - + 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; @@ -889,9 +1716,10 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) m_tab_close_buttons.Add(tempbtn); } + + // buttons before the tab offset must be set to hidden for (i = 0; i < m_tab_offset; ++i) { - // buttons before the tab offset must be set to hidden m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN; } @@ -900,11 +1728,11 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) 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 = m_tab_offset; i < page_count; ++i) @@ -931,25 +1759,40 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) } 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, - tab_button.cur_state, - &page.rect, - &tab_button.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_tab_offset && active < m_pages.GetCount()) { @@ -966,17 +1809,18 @@ void wxAuiTabContainer::Render(wxDC* raw_dc) } rect.x = active_offset; - m_art->DrawTab(&dc, - rect, - page.caption, - page.active, - tab_button.cur_state, - &page.rect, - &tab_button.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); } - dc.DestroyClippingRegion(); raw_dc->Blit(m_rect.x, m_rect.y, m_rect.GetWidth(), m_rect.GetHeight(), @@ -1030,7 +1874,9 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y, for (i = 0; i < button_count; ++i) { wxAuiTabContainerButton& button = m_buttons.Item(i); - if (button.rect.Contains(x,y)) + if (button.rect.Contains(x,y) && + !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN | + wxAUI_BUTTON_STATE_DISABLED))) { if (hit) *hit = &button; @@ -1042,7 +1888,9 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y, for (i = 0; i < button_count; ++i) { wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i); - if (button.rect.Contains(x,y)) + if (button.rect.Contains(x,y) && + !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN | + wxAUI_BUTTON_STATE_DISABLED))) { if (hit) *hit = &button; @@ -1128,6 +1976,7 @@ wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent, m_click_pt = wxDefaultPosition; m_is_dragging = false; m_hover_button = NULL; + m_pressed_button = NULL; } wxAuiTabCtrl::~wxAuiTabCtrl() @@ -1141,7 +1990,7 @@ void wxAuiTabCtrl::OnPaint(wxPaintEvent&) dc.SetFont(GetFont()); if (GetPageCount() > 0) - Render(&dc); + Render(&dc, this); } void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt)) @@ -1161,30 +2010,38 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt) m_click_pt = wxDefaultPosition; m_is_dragging = false; 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 = 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(); @@ -1199,19 +2056,31 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&) 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(); - if (!(m_hover_button->cur_state & wxAUI_BUTTON_STATE_DISABLED)) + if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED)) { wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId); - evt.SetInt(m_hover_button->id); + evt.SetInt(m_pressed_button->id); evt.SetEventObject(this); GetEventHandler()->ProcessEvent(evt); } + + m_pressed_button = NULL; } m_click_pt = wxDefaultPosition; @@ -1318,6 +2187,28 @@ void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event) 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 { @@ -1370,10 +2261,9 @@ public: 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(); @@ -1383,7 +2273,8 @@ public: 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(wxAuiMDIChildFrame))) { @@ -1487,8 +2378,7 @@ void wxAuiNotebook::InitNotebook(long style) m_selected_font = *wxNORMAL_FONT; m_selected_font.SetWeight(wxBOLD); - // choose a default for the tab height - m_tab_ctrl_height = m_tabs.GetArtProvider()->GetBestTabCtrlSize(this); + SetArtProvider(new wxAuiDefaultTabArt); m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0)); m_dummy_wnd->SetSize(200, 200); @@ -1510,13 +2400,77 @@ wxAuiNotebook::~wxAuiNotebook() 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(); + } + } } -wxAuiTabArt* wxAuiNotebook::GetArtProvider() +int wxAuiNotebook::CalculateTabCtrlHeight() +{ + // find out new best tab height + wxAuiTabArt* art = m_tabs.GetArtProvider(); + + return art->GetBestTabCtrlSize(this, m_tabs.GetPages()); +} + + +wxAuiTabArt* wxAuiNotebook::GetArtProvider() const { return m_tabs.GetArtProvider(); } +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, @@ -1550,6 +2504,7 @@ bool wxAuiNotebook::InsertPage(size_t page_idx, else active_tabctrl->InsertPage(page, info, page_idx); + SetTabCtrlHeight(CalculateTabCtrlHeight()); DoSizing(); active_tabctrl->DoShowHide(); @@ -1570,6 +2525,33 @@ bool wxAuiNotebook::InsertPage(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 @@ -1610,18 +2592,6 @@ bool wxAuiNotebook::DeletePage(size_t page_idx) // remove the tab from the onscreen tab ctrl ctrl->RemovePage(wnd); - // 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(); - } RemoveEmptyTabFrames(); @@ -1635,53 +2605,67 @@ bool wxAuiNotebook::DeletePage(size_t page_idx) 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 wxAuiNotebook::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 wxAuiNotebook::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 wxAuiNotebook::GetSelection() const { @@ -1701,12 +2685,14 @@ size_t wxAuiNotebook::SetSelection(size_t new_page) 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)) @@ -1717,8 +2703,6 @@ size_t wxAuiNotebook::SetSelection(size_t new_page) DoSizing(); ctrl->DoShowHide(); - int old_curpage = m_curpage; - m_curpage = new_page; // set fonts @@ -1815,6 +2799,7 @@ wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl() wxDefaultSize, wxNO_BORDER); tabframe->m_tabs->SetFlags(m_flags); + tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone()); m_mgr.AddPane(tabframe, wxAuiPaneInfo().Center().CaptionVisible(false)); @@ -1886,12 +2871,23 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt) wxPoint zero(0,0); wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject(); - wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt); + if (dest_tabs == src_tabs) { + 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; @@ -1924,6 +2920,67 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt) return; } + + // 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 = dest_tabs->GetRect(); @@ -1944,88 +3001,186 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& 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); - int insert_idx = -1; - if (tab_frame) + // check for an external move + if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE) { - dest_tabs = tab_frame->m_tabs; - - if (dest_tabs == src_tabs) - return; + wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt); - - wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt); - wxWindow* target = NULL; - dest_tabs->TabHitTest(pt.x, pt.y, &target); - if (target) + while (tab_ctrl) { - insert_idx = dest_tabs->GetIdxFromWindow(target); + if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl))) + break; + tab_ctrl = tab_ctrl->GetParent(); } - } - 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->SetFlags(m_flags); + + 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)); - m_mgr.AddPane(new_tabs, - wxAuiPaneInfo().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 - 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(); - } + // 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* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt) { // if we've just removed the last tab from the source @@ -2142,6 +3297,17 @@ void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt) { 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)); + e.SetOldSelection(evt.GetSelection()); + e.SetEventObject(this); + GetEventHandler()->ProcessEvent(e); + if (!e.IsAllowed()) + return; + + if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame))) { close_wnd->Close();