// Name: src/aui/auibook.cpp
// Purpose: wxaui: wx advanced user interface - notebook
// Author: Benjamin I. Williams
-// Modified by:
+// Modified by: Jens Lody
// Created: 2006-06-28
// Copyright: (C) Copyright 2006, Kirix Corporation, All Rights Reserved
// Licence: wxWindows Library Licence, Version 3.1
#ifndef WX_PRECOMP
#include "wx/settings.h"
- #include "wx/image.h"
+ #include "wx/dcclient.h"
+ #include "wx/dcmemory.h"
#endif
#include "wx/aui/tabmdi.h"
-#include "wx/dcbuffer.h"
-#include "wx/menu.h"
+
+#ifdef __WXMAC__
+#include "wx/osx/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)
-
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, wxAuiNotebookEvent);
+wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, wxAuiNotebookEvent);
IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
-
-
-
-
-
-// This functions are here for this proof of concept
-// and will be factored out later. See dockart.cpp
-static wxColor StepColour(const wxColor& c, int percent)
-{
- int r = c.Red(), g = c.Green(), b = c.Blue();
- return wxColour((unsigned char)wxMin((r*percent)/100,255),
- (unsigned char)wxMin((g*percent)/100,255),
- (unsigned char)wxMin((b*percent)/100,255));
-}
-
-// This functions are here for this proof of concept
-// and will be factored out later. See dockart.cpp
-static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
- const wxColour& color)
-{
- wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
- img.Replace(0,0,0,123,123,123);
- img.Replace(255,255,255,color.Red(),color.Green(),color.Blue());
- img.SetMaskColour(123,123,123);
- return wxBitmap(img);
-}
-
-static void DrawButtons(wxDC& dc,
- const wxRect& _rect,
- const wxBitmap& bmp,
- const wxColour& bkcolour,
- int button_state)
-{
- wxRect rect = _rect;
-
- if (button_state == wxAUI_BUTTON_STATE_PRESSED)
- {
- rect.x++;
- rect.y++;
- }
-
- if (button_state == wxAUI_BUTTON_STATE_HOVER ||
- button_state == wxAUI_BUTTON_STATE_PRESSED)
- {
- dc.SetBrush(wxBrush(StepColour(bkcolour, 120)));
- dc.SetPen(wxPen(StepColour(bkcolour, 70)));
-
- // draw the background behind the button
- dc.DrawRectangle(rect.x, rect.y, 15, 15);
- }
-
- // draw the button itself
- 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,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};
-
-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};
-
-
-
-
-
-
-// -- 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;
-
- wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-
- wxColour background_colour = base_colour;
- wxColour normaltab_colour = base_colour;
- wxColour selectedtab_colour = base_colour;
-
- m_bkbrush = wxBrush(background_colour);
- m_normal_bkbrush = wxBrush(normaltab_colour);
- 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));
-
- 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 = tab_ctrl_size.x;
- 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 wxAuiDefaultTabArt::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);
-
- // draw base lines
- dc.SetPen(*wxGREY_PEN);
- dc.DrawLine(0, rect.GetHeight()-4, rect.GetWidth(), rect.GetHeight()-4);
- dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
-}
-
-
-// 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,
- 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, 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;
-
- dc.SetClippingRegion(in_rect);
-
-
-
- // 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;
- }
-
-
- // -- create points that will make the tab outline --
-
- wxPoint points[6];
- points[0].x = tab_x;
- points[0].y = tab_y + tab_height - 4;
- points[1].x = tab_x;
- points[1].y = tab_y + 2;
- points[2].x = tab_x + 2;
- 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 - 4;
-
-
- // -- draw gradient background --
- if (active)
- {
- wxColour c = m_bkbrush.GetColour();
- dc.SetPen(wxPen(c));
-
- int x, y, last_y = -1;
- for (y = points[0].y; y > points[2].y; --y)
- {
- if (y < tab_y+(tab_height*3/5) && y != last_y)
- {
- last_y = y;
- c = StepColour(c, 102);
- dc.SetPen(wxPen(c));
- }
-
- for (x = points[0].x+1; x < points[5].x; ++x)
- {
- dc.DrawPoint(x,y);
- }
- }
- }
-
- // -- draw tab outline --
- dc.SetPen(*wxGREY_PEN);
- dc.SetBrush(*wxTRANSPARENT_BRUSH);
- dc.DrawPolygon(6, 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)
- {
- wxColour c = m_bkbrush.GetColour();
- dc.SetPen(wxPen(c));
- dc.DrawLine(points[0].x+1, points[0].y, points[5].x, points[5].y);
- }
-
- 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 + 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,
- (tab_y + tab_height)/2 - (texty/2));
-
-
-
-
- // 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,
- 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);
-
- wxCoord tab_width = measured_textx + 5;
- wxCoord tab_height = measured_texty + 10;
-
- if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
- tab_width += m_active_close_bmp.GetWidth() + 8;
-
-
- 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)
-{
- wxClientDC dc(wnd);
- dc.SetFont(m_measuring_font);
- int x_ext = 0;
- wxSize s = GetTabSize(dc,
- wnd,
- wxT("ABCDEFGHIj"),
- true,
- wxAUI_BUTTON_STATE_HIDDEN,
- &x_ext);
- return s.y+3;
-}
-
-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);
- wxColour normaltab_colour = base_colour;
- wxColour selectedtab_colour = *wxWHITE;
-
- m_bkbrush = wxBrush(background_colour);
- m_normal_bkbrush = wxBrush(normaltab_colour);
- 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;
-}
-
-void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
- size_t tab_count)
-{
- m_fixed_tab_width = 100;
-
- int tot_width = tab_ctrl_size.x;
- 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);
-
- // draw base line
- dc.SetPen(*wxGREY_PEN);
- dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
-}
-
-
-// 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 wxAuiSimpleTabArt::DrawTab(wxDC& dc,
- wxWindow* wnd,
- 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)
-{
- 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, 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);
- 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;
- }
-
-
- // -- 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,
- 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;
-
- 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 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())
- {
- 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());
- }
-
-
- DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
-
- *out_rect = rect;
-}
-
-
-int wxAuiSimpleTabArt::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 wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd)
-{
- wxClientDC dc(wnd);
- dc.SetFont(m_measuring_font);
- int x_ext = 0;
- wxSize s = GetTabSize(dc,
- wnd,
- wxT("ABCDEFGHIj"),
- true,
- wxAUI_BUTTON_STATE_HIDDEN,
- &x_ext);
- return s.y+3;
-}
-
-void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
-{
- m_normal_font = font;
-}
-
-void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
-{
- m_selected_font = font;
-}
-
-void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
-{
- m_measuring_font = font;
-}
-
-
+IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxBookCtrlEvent)
// -- wxAuiTabContainer class implementation --
wxAuiTabContainer::wxAuiTabContainer()
{
- m_tab_offset = 0;
+ m_tabOffset = 0;
m_flags = 0;
m_art = new wxAuiDefaultTabArt;
-
- AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
+
+ AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
{
delete m_art;
m_art = art;
-
+
if (m_art)
{
m_art->SetFlags(m_flags);
}
}
-wxAuiTabArt* 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_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_LEFT, wxLEFT);
AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
}
{
AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
}
-
+
if (flags & wxAUI_NB_CLOSE_BUTTON)
{
AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
}
-
+
if (m_art)
{
m_art->SetFlags(m_flags);
m_art->SetMeasuringFont(font);
}
+void wxAuiTabContainer::SetColour(const wxColour& colour)
+{
+ m_art->SetColour(colour);
+}
+
+void wxAuiTabContainer::SetActiveColour(const wxColour& colour)
+{
+ m_art->SetActiveColour(colour);
+}
+
void wxAuiTabContainer::SetRect(const wxRect& rect)
{
m_rect = rect;
-
+
if (m_art)
{
m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
{
m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
}
-
+
return true;
}
if (idx >= m_pages.GetCount())
m_pages.Add(page_info);
- else
+ else
m_pages.Insert(page_info, idx);
// let the art provider know how many pages we have
{
m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
}
-
+
return true;
}
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;
}
}
page.active = true;
found = true;
}
- else
+ else
{
page.active = false;
}
int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
{
- size_t i, page_count = m_pages.GetCount();
- for (i = 0; i < page_count; ++i)
+ const size_t page_count = m_pages.GetCount();
+ for ( size_t i = 0; i < page_count; ++i )
{
wxAuiNotebookPage& page = m_pages.Item(i);
if (page.window == wnd)
return i;
}
- return -1;
+ return wxNOT_FOUND;
}
wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
return m_pages[idx];
}
+const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
+{
+ wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
+
+ return m_pages[idx];
+}
+
wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
{
return m_pages;
void wxAuiTabContainer::AddButton(int id,
int location,
- const wxBitmap& normal_bitmap,
- const wxBitmap& disabled_bitmap)
+ const wxBitmap& normalBitmap,
+ const wxBitmap& disabledBitmap)
{
wxAuiTabContainerButton button;
button.id = id;
- button.bitmap = normal_bitmap;
- button.dis_bitmap = disabled_bitmap;
+ button.bitmap = normalBitmap;
+ button.disBitmap = disabledBitmap;
button.location = location;
- button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
+ button.curState = wxAUI_BUTTON_STATE_NORMAL;
m_buttons.Add(button);
}
size_t wxAuiTabContainer::GetTabOffset() const
{
- return m_tab_offset;
+ return m_tabOffset;
}
void wxAuiTabContainer::SetTabOffset(size_t offset)
{
- m_tab_offset = offset;
+ m_tabOffset = offset;
}
// provide custom drawing capabilities
void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
{
+ if (!raw_dc || !raw_dc->IsOk())
+ return;
+
wxMemoryDC dc;
+
+ // use the same layout direction as the window DC uses to ensure that the
+ // text is rendered correctly
+ dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
+
wxBitmap bmp;
size_t i;
size_t page_count = m_pages.GetCount();
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
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 ||
{
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
+ else
total_width += size.x;
-
- if (i >= m_tab_offset)
+
+ if (i >= m_tabOffset)
{
if (i+1 < page_count)
visible_width += x_extent;
- else
+ else
visible_width += size.x;
}
}
-
- if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
+
+ if (total_width > m_rect.GetWidth() || m_tabOffset != 0)
{
// show left/right buttons
for (i = 0; i < button_count; ++i)
if (button.id == wxAUI_BUTTON_LEFT ||
button.id == wxAUI_BUTTON_RIGHT)
{
- button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
+ button.curState &= ~wxAUI_BUTTON_STATE_HIDDEN;
}
}
}
- else
+ else
{
// hide left/right buttons
for (i = 0; i < button_count; ++i)
if (button.id == wxAUI_BUTTON_LEFT ||
button.id == wxAUI_BUTTON_RIGHT)
{
- button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
+ button.curState |= wxAUI_BUTTON_STATE_HIDDEN;
}
}
}
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 (m_tabOffset == 0)
+ button.curState |= wxAUI_BUTTON_STATE_DISABLED;
+ else
+ button.curState &= ~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;
+ button.curState |= wxAUI_BUTTON_STATE_DISABLED;
+ else
+ button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
}
}
// draw buttons
int left_buttons_width = 0;
int right_buttons_width = 0;
-
+
int offset = 0;
// draw the buttons on the right side
for (i = 0; i < button_count; ++i)
{
wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
-
+
if (button.location != wxRIGHT)
continue;
- if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
continue;
-
+
wxRect button_rect = m_rect;
button_rect.SetY(1);
button_rect.SetWidth(offset);
wnd,
button_rect,
button.id,
- button.cur_state,
+ button.curState,
wxRIGHT,
- wxNullBitmap,
&button.rect);
offset -= button.rect.GetWidth();
offset = 0;
-
+
// draw the buttons on the left side
for (i = 0; i < button_count; ++i)
{
wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
-
+
if (button.location != wxLEFT)
continue;
- if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
+ if (button.curState & 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,
+ button.curState,
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();
-
+ offset += m_art->GetIndentSize();
+
+
// prepare the tab-close-button array
- while (m_tab_close_buttons.GetCount() < page_count)
+ // make sure tab button entries which aren't used are marked as hidden
+ for (i = page_count; i < m_tabCloseButtons.GetCount(); ++i)
+ m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
+
+ // make sure there are enough tab button entries to accommodate all tabs
+ while (m_tabCloseButtons.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);
+ tempbtn.curState = wxAUI_BUTTON_STATE_HIDDEN;
+ m_tabCloseButtons.Add(tempbtn);
}
-
- for (i = 0; i < m_tab_offset; ++i)
+
+
+ // buttons before the tab offset must be set to hidden
+ for (i = 0; i < m_tabOffset; ++i)
{
- // buttons before the tab offset must be set to hidden
- m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
}
-
-
+
+
// draw the tabs
size_t active = 999;
rect.y = 0;
rect.height = m_rect.height;
- for (i = m_tab_offset; i < page_count; ++i)
+ for (i = m_tabOffset; i < page_count; ++i)
{
wxAuiNotebookPage& page = m_pages.Item(i);
- wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
+ wxAuiTabContainerButton& tab_button = m_tabCloseButtons.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)
+ if (tab_button.curState == wxAUI_BUTTON_STATE_HIDDEN)
{
tab_button.id = wxAUI_BUTTON_CLOSE;
- tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
+ tab_button.curState = wxAUI_BUTTON_STATE_NORMAL;
tab_button.location = wxCENTER;
}
}
- else
+ else
{
- tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+ tab_button.curState = 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,
+ wnd,
+ page,
+ rect,
+ tab_button.curState,
+ &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_tabCloseButtons.GetCount(); ++i)
+ {
+ m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
+ }
+
+
+ // draw the active tab again so it stands in the foreground
+ if (active >= m_tabOffset && active < m_pages.GetCount())
+ {
+ wxAuiNotebookPage& page = m_pages.Item(active);
+
+ wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(active);
+
+ rect.x = active_offset;
+ m_art->DrawTab(dc,
+ wnd,
+ page,
+ active_rect,
+ tab_button.curState,
+ &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);
+}
+
+// Is the tab visible?
+bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
+{
+ if (!dc || !dc->IsOk())
+ return false;
+
+ size_t i;
+ size_t page_count = m_pages.GetCount();
+ size_t button_count = m_buttons.GetCount();
+
+ // Hasn't been rendered yet; assume it's visible
+ if (m_tabCloseButtons.GetCount() < page_count)
+ return true;
+
+ // First check if both buttons are disabled - if so, there's no need to
+ // check further for visibility.
+ int arrowButtonVisibleCount = 0;
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(i);
+ if (button.id == wxAUI_BUTTON_LEFT ||
+ button.id == wxAUI_BUTTON_RIGHT)
+ {
+ if ((button.curState & wxAUI_BUTTON_STATE_HIDDEN) == 0)
+ arrowButtonVisibleCount ++;
+ }
+ }
+
+ // Tab must be visible
+ if (arrowButtonVisibleCount == 0)
+ return true;
+
+ // If tab is less than the given offset, it must be invisible by definition
+ if (tabPage < tabOffset)
+ return false;
+
+ // draw buttons
+ int left_buttons_width = 0;
+ int right_buttons_width = 0;
+
+ int offset = 0;
+
+ // calculate size of the buttons on the right side
+ offset = m_rect.x + m_rect.width;
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
+
+ if (button.location != wxRIGHT)
+ continue;
+ if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ offset -= button.rect.GetWidth();
+ right_buttons_width += button.rect.GetWidth();
+ }
+
+ offset = 0;
+
+ // calculate size of the buttons on the left side
+ for (i = 0; i < button_count; ++i)
+ {
+ wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
+
+ if (button.location != wxLEFT)
+ continue;
+ if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
+ continue;
+
+ offset += button.rect.GetWidth();
+ left_buttons_width += button.rect.GetWidth();
+ }
+
+ offset = left_buttons_width;
+
+ if (offset == 0)
+ offset += m_art->GetIndentSize();
+
+ wxRect active_rect;
+
+ wxRect rect = m_rect;
+ rect.y = 0;
+ rect.height = m_rect.height;
+
+ // See if the given page is visible at the given tab offset (effectively scroll position)
+ for (i = tabOffset; i < page_count; ++i)
+ {
+ wxAuiNotebookPage& page = m_pages.Item(i);
+ wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
+
+ rect.x = offset;
+ rect.width = m_rect.width - right_buttons_width - offset - 2;
+
+ if (rect.width <= 0)
+ return false; // haven't found the tab, and we've run out of space, so return false
+ int x_extent = 0;
+ m_art->GetTabSize(*dc,
+ wnd,
+ page.caption,
+ page.bitmap,
+ page.active,
+ tab_button.curState,
+ &x_extent);
- m_art->DrawTab(dc,
- wnd,
- rect,
- page.caption,
- page.active,
- tab_button.cur_state,
- &page.rect,
- &tab_button.rect,
- &x_extent);
+ offset += x_extent;
- if (page.active)
+ if (i == (size_t) tabPage)
{
- active = i;
- active_offset = offset;
- active_rect = rect;
+ // If not all of the tab is visible, and supposing there's space to display it all,
+ // we could do better so we return false.
+ if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
+ return false;
+ else
+ return true;
}
-
- offset += x_extent;
}
- // draw the active tab again so it stands in the foreground
- if (active >= m_tab_offset && active < m_pages.GetCount())
- {
- wxAuiNotebookPage& page = m_pages.Item(active);
-
- wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
+ // Shouldn't really get here, but if it does, assume the tab is visible to prevent
+ // further looping in calling code.
+ return true;
+}
- // 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))
+// Make the tab visible if it wasn't already
+void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
+{
+ wxClientDC dc(win);
+ if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
+ {
+ int i;
+ for (i = 0; i < (int) m_pages.GetCount(); i++)
{
- close_button = true;
+ if (IsTabVisible(tabPage, i, & dc, win))
+ {
+ SetTabOffset(i);
+ win->Refresh();
+ return;
+ }
}
-
- rect.x = active_offset;
- m_art->DrawTab(dc,
- wnd,
- active_rect,
- page.caption,
- 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);
}
-
// TabHitTest() tests if a tab was hit, passing the window pointer
// back if that condition was fulfilled. The function returns
// true if a tab was hit, otherwise false
{
if (!m_rect.Contains(x,y))
return false;
-
+
wxAuiTabContainerButton* btn = NULL;
- if (ButtonHitTest(x, y, &btn))
+ if (ButtonHitTest(x, y, &btn) && !(btn->curState & wxAUI_BUTTON_STATE_DISABLED))
{
if (m_buttons.Index(*btn) != wxNOT_FOUND)
return false;
size_t i, page_count = m_pages.GetCount();
- for (i = m_tab_offset; i < page_count; ++i)
+ for (i = m_tabOffset; i < page_count; ++i)
{
wxAuiNotebookPage& page = m_pages.Item(i);
if (page.rect.Contains(x,y))
return false;
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))
+ if (button.rect.Contains(x,y) &&
+ !(button.curState & wxAUI_BUTTON_STATE_HIDDEN ))
{
if (hit)
*hit = &button;
return true;
}
}
-
- button_count = m_tab_close_buttons.GetCount();
+
+ button_count = m_tabCloseButtons.GetCount();
for (i = 0; i < button_count; ++i)
{
- wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
- if (button.rect.Contains(x,y))
+ wxAuiTabContainerButton& button = m_tabCloseButtons.Item(i);
+ if (button.rect.Contains(x,y) &&
+ !(button.curState & (wxAUI_BUTTON_STATE_HIDDEN |
+ wxAUI_BUTTON_STATE_DISABLED)))
{
if (hit)
*hit = &button;
return true;
}
}
-
+
return false;
}
// as the Show() method on this class is "unplugged"
static void ShowWnd(wxWindow* wnd, bool show)
{
+#if wxUSE_MDI
if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
cf->DoShow(show);
}
- else
+ else
+#endif
{
wnd->Show(show);
}
for (i = 0; i < page_count; ++i)
{
wxAuiNotebookPage& page = pages.Item(i);
- ShowWnd(page.window, page.active);
+ if (!page.active)
+ ShowWnd(page.window, false);
}
}
EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
EVT_SIZE(wxAuiTabCtrl::OnSize)
EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
+ EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
+ EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
+ EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
+ EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
+ EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
EVT_MOTION(wxAuiTabCtrl::OnMotion)
EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
- EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton)
+ EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
+ EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
+ EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
+ EVT_CHAR(wxAuiTabCtrl::OnChar)
+ EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
END_EVENT_TABLE()
const wxSize& size,
long style) : wxControl(parent, id, pos, size, style)
{
- m_click_pt = wxDefaultPosition;
- m_is_dragging = false;
- m_hover_button = NULL;
+ SetName(wxT("wxAuiTabCtrl"));
+ m_clickPt = wxDefaultPosition;
+ m_isDragging = false;
+ m_hoverButton = NULL;
+ m_pressedButton = NULL;
}
wxAuiTabCtrl::~wxAuiTabCtrl()
void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
{
CaptureMouse();
- m_click_pt = wxDefaultPosition;
- m_is_dragging = false;
- m_click_tab = NULL;
+ m_clickPt = wxDefaultPosition;
+ m_isDragging = false;
+ m_clickTab = NULL;
+ m_pressedButton = 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);
+
+ // wxAuiNotebooks always want to receive this event
+ // even if the tab is already active, because they may
+ // have multiple tab controls
+ if (new_selection != GetActivePage() ||
+ GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
+ {
+ 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;
+ m_clickPt.x = evt.m_x;
+ m_clickPt.y = evt.m_y;
+ m_clickTab = wnd;
}
- if (m_hover_button)
+ if (m_hoverButton)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
+ m_pressedButton = m_hoverButton;
+ m_pressedButton->curState = wxAUI_BUTTON_STATE_PRESSED;
Refresh();
Update();
}
}
-void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
+void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+{
+ if (m_isDragging)
+ {
+ m_isDragging = false;
+
+ wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);
+ evt.SetSelection(GetIdxFromWindow(m_clickTab));
+ evt.SetOldSelection(evt.GetSelection());
+ evt.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(evt);
+ }
+}
+
+void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
{
if (GetCapture() == this)
ReleaseMouse();
- if (m_is_dragging)
+ if (m_isDragging)
{
+ m_isDragging = false;
+
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
- evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetSelection(GetIdxFromWindow(m_clickTab));
evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
+
return;
}
- if (m_hover_button)
+ if (m_pressedButton)
{
- 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) ||
+ button->curState & wxAUI_BUTTON_STATE_DISABLED)
+ return;
+
+ if (button != m_pressedButton)
+ {
+ m_pressedButton = NULL;
+ return;
+ }
+
Refresh();
Update();
- if (!(m_hover_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+ if (!(m_pressedButton->curState & wxAUI_BUTTON_STATE_DISABLED))
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
- evt.SetInt(m_hover_button->id);
+ evt.SetSelection(GetIdxFromWindow(m_clickTab));
+ evt.SetInt(m_pressedButton->id);
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
}
+
+ m_pressedButton = NULL;
}
- m_click_pt = wxDefaultPosition;
- m_is_dragging = false;
- m_click_tab = NULL;
+ m_clickPt = wxDefaultPosition;
+ m_isDragging = false;
+ m_clickTab = NULL;
+}
+
+void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
+{
+ wxWindow* wnd = NULL;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
+ return;
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
+ e.SetEventObject(this);
+ e.SetSelection(GetIdxFromWindow(wnd));
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
+{
+ wxWindow* wnd = NULL;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
+ return;
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
+ e.SetEventObject(this);
+ e.SetSelection(GetIdxFromWindow(wnd));
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
+{
+ wxWindow* wnd = NULL;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
+ return;
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
+ e.SetEventObject(this);
+ e.SetSelection(GetIdxFromWindow(wnd));
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
+{
+ wxWindow* wnd = NULL;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
+ return;
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
+ e.SetEventObject(this);
+ e.SetSelection(GetIdxFromWindow(wnd));
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
+{
+ wxWindow* wnd;
+ wxAuiTabContainerButton* button;
+ if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+ }
}
void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
// check if the mouse is hovering above a button
wxAuiTabContainerButton* button;
- if (ButtonHitTest(pos.x, pos.y, &button))
+ if (ButtonHitTest(pos.x, pos.y, &button) && !(button->curState & wxAUI_BUTTON_STATE_DISABLED))
{
- if (m_hover_button && button != m_hover_button)
+ if (m_hoverButton && button != m_hoverButton)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
- m_hover_button = NULL;
+ m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+ m_hoverButton = NULL;
Refresh();
Update();
}
-
- if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
+
+ if (button->curState != wxAUI_BUTTON_STATE_HOVER)
{
- button->cur_state = wxAUI_BUTTON_STATE_HOVER;
+ button->curState = wxAUI_BUTTON_STATE_HOVER;
Refresh();
Update();
- m_hover_button = button;
+
+ m_hoverButton = button;
return;
}
}
- else
+ else
{
- if (m_hover_button)
+ if (m_hoverButton)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
- m_hover_button = NULL;
+ m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+ m_hoverButton = NULL;
Refresh();
Update();
}
}
- if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
+ if (!evt.LeftIsDown() || m_clickPt == wxDefaultPosition)
return;
- if (m_is_dragging)
+ if (m_isDragging)
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
- evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetSelection(GetIdxFromWindow(m_clickTab));
evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
- if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
- abs(pos.y - m_click_pt.y) > drag_y_threshold)
+ if (abs(pos.x - m_clickPt.x) > drag_x_threshold ||
+ abs(pos.y - m_clickPt.y) > drag_y_threshold)
{
wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
- evt.SetSelection(GetIdxFromWindow(m_click_tab));
+ evt.SetSelection(GetIdxFromWindow(m_clickTab));
evt.SetOldSelection(evt.GetSelection());
evt.SetEventObject(this);
GetEventHandler()->ProcessEvent(evt);
- m_is_dragging = true;
+ m_isDragging = true;
}
}
void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
{
- if (m_hover_button)
+ if (m_hoverButton)
{
- m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
- m_hover_button = NULL;
+ m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
+ m_hoverButton = NULL;
Refresh();
Update();
}
void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
{
int button = event.GetInt();
-
+
if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
{
if (button == wxAUI_BUTTON_LEFT)
Update();
}
}
- else
+ else
{
SetTabOffset(GetTabOffset()+1);
Refresh();
Update();
}
}
- else if (button == wxAUI_BUTTON_WINDOWLIST)
+ 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()->ShowDropDown(this, m_pages, GetActivePage());
- int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
-
if (idx != -1)
{
wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
GetEventHandler()->ProcessEvent(e);
}
}
- else
+ else
+ {
+ event.Skip();
+ }
+}
+
+void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
+{
+ Refresh();
+}
+
+void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
+{
+ Refresh();
+}
+
+void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
+{
+ if (GetActivePage() == -1)
+ {
+ event.Skip();
+ return;
+ }
+
+ // We can't leave tab processing to the system; on Windows, tabs and keys
+ // get eaten by the system and not processed properly if we specify both
+ // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
+ // we don't key arrow key events.
+
+ int key = event.GetKeyCode();
+
+ if (key == WXK_NUMPAD_PAGEUP)
+ key = WXK_PAGEUP;
+ if (key == WXK_NUMPAD_PAGEDOWN)
+ key = WXK_PAGEDOWN;
+ if (key == WXK_NUMPAD_HOME)
+ key = WXK_HOME;
+ if (key == WXK_NUMPAD_END)
+ key = WXK_END;
+ if (key == WXK_NUMPAD_LEFT)
+ key = WXK_LEFT;
+ if (key == WXK_NUMPAD_RIGHT)
+ key = WXK_RIGHT;
+
+ if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
+ {
+ bool bCtrlDown = event.ControlDown();
+ bool bShiftDown = event.ShiftDown();
+
+ bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
+ bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
+ bool bFromTab = (key == WXK_TAB);
+
+ wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
+ if (!nb)
+ {
+ event.Skip();
+ return;
+ }
+
+ wxNavigationKeyEvent keyEvent;
+ keyEvent.SetDirection(bForward);
+ keyEvent.SetWindowChange(bWindowChange);
+ keyEvent.SetFromTab(bFromTab);
+ keyEvent.SetEventObject(nb);
+
+ if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
+ {
+ // Not processed? Do an explicit tab into the page.
+ wxWindow* win = GetWindowFromIdx(GetActivePage());
+ if (win)
+ win->SetFocus();
+ }
+ return;
+ }
+
+ if (m_pages.GetCount() < 2)
+ {
+ event.Skip();
+ return;
+ }
+
+ int newPage = -1;
+
+ int forwardKey, backwardKey;
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ {
+ forwardKey = WXK_LEFT;
+ backwardKey = WXK_RIGHT;
+ }
+ else
+ {
+ forwardKey = WXK_RIGHT;
+ backwardKey = WXK_LEFT;
+ }
+
+ if (key == forwardKey)
+ {
+ if (m_pages.GetCount() > 1)
+ {
+ if (GetActivePage() == -1)
+ newPage = 0;
+ else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
+ newPage = GetActivePage() + 1;
+ }
+ }
+ else if (key == backwardKey)
+ {
+ if (m_pages.GetCount() > 1)
+ {
+ if (GetActivePage() == -1)
+ newPage = (int) (m_pages.GetCount() - 1);
+ else if (GetActivePage() > 0)
+ newPage = GetActivePage() - 1;
+ }
+ }
+ else if (key == WXK_HOME)
+ {
+ newPage = 0;
+ }
+ else if (key == WXK_END)
{
+ newPage = (int) (m_pages.GetCount() - 1);
+ }
+ else
event.Skip();
+
+ if (newPage != -1)
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+ e.SetSelection(newPage);
+ e.SetOldSelection(newPage);
+ e.SetEventObject(this);
+ this->GetEventHandler()->ProcessEvent(e);
}
+ else
+ event.Skip();
}
// wxTabFrame is an interesting case. It's important that all child pages
{
m_tabs = NULL;
m_rect = wxRect(0,0,200,200);
- m_tab_ctrl_height = 20;
+ m_tabCtrlHeight = 20;
+ }
+
+ ~wxTabFrame()
+ {
+ wxDELETE(m_tabs);
}
void SetTabCtrlHeight(int h)
{
- m_tab_ctrl_height = h;
+ m_tabCtrlHeight = h;
}
+protected:
void DoSetSize(int x, int y,
int width, int height,
int WXUNUSED(sizeFlags = wxSIZE_AUTO))
*y = m_rect.height;
}
+public:
bool Show( bool WXUNUSED(show = true) ) { return false; }
void DoSizing()
if (!m_tabs)
return;
- m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
- m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
- m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
+ if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
+ return;
+
+ m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
+ if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
+ {
+ m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
+ m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
+ m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
+ }
+ else //TODO: if (GetFlags() & wxAUI_NB_TOP)
+ {
+ m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
+ m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
+ m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
+ }
+ // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
+ // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
+
m_tabs->Refresh();
m_tabs->Update();
for (i = 0; i < page_count; ++i)
{
+ int height = m_rect.height - m_tabCtrlHeight;
+ if ( height < 0 )
+ {
+ // avoid passing negative height to wxWindow::SetSize(), this
+ // results in assert failures/GTK+ warnings
+ height = 0;
+ }
+
wxAuiNotebookPage& page = pages.Item(i);
- page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
- m_rect.width, m_rect.height - m_tab_ctrl_height);
+ if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
+ {
+ page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
+ }
+ else //TODO: if (GetFlags() & wxAUI_NB_TOP)
+ {
+ page.window->SetSize(m_rect.x, m_rect.y + m_tabCtrlHeight,
+ m_rect.width, height);
+ }
+ // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
+ // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
+#if wxUSE_MDI
if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
wnd->ApplyMDIChildFrameRect();
}
+#endif
}
}
+protected:
void DoGetSize(int* x, int* y) const
{
if (x)
*y = m_rect.GetHeight();
}
+public:
void Update()
{
// does nothing
}
-public:
-
wxRect m_rect;
wxRect m_tab_rect;
wxAuiTabCtrl* m_tabs;
- int m_tab_ctrl_height;
+ int m_tabCtrlHeight;
};
-
+const int wxAuiBaseTabCtrlId = 5380;
// -- wxAuiNotebook class implementation --
+#define EVT_AUI_RANGE(id1, id2, event, func) \
+ wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
+
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,
+ EVT_SIZE(wxAuiNotebook::OnSize)
+ EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
wxAuiNotebook::OnTabClicked)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
wxAuiNotebook::OnTabBeginDrag)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
wxAuiNotebook::OnTabEndDrag)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG,
+ wxAuiNotebook::OnTabCancelDrag)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
wxAuiNotebook::OnTabDragMotion)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
wxAuiNotebook::OnTabButton)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
+ wxAuiNotebook::OnTabMiddleDown)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
+ wxAuiNotebook::OnTabMiddleUp)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
+ wxAuiNotebook::OnTabRightDown)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
+ wxAuiNotebook::OnTabRightUp)
+ EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
+ wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
+ wxAuiNotebook::OnTabBgDClick)
+ EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
END_EVENT_TABLE()
-wxAuiNotebook::wxAuiNotebook()
-{
- m_curpage = -1;
- m_tab_id_counter = 10000;
- m_dummy_wnd = NULL;
- m_tab_ctrl_height = 20;
-}
-
-wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
- wxWindowID id,
- const wxPoint& pos,
- const wxSize& size,
- long style) : wxControl(parent, id, pos, size, style)
+void wxAuiNotebook::Init()
{
- InitNotebook(style);
+ m_curPage = -1;
+ m_tabIdCounter = wxAuiBaseTabCtrlId;
+ m_dummyWnd = NULL;
+ m_tabCtrlHeight = 20;
+ m_requestedBmpSize = wxDefaultSize;
+ m_requestedTabCtrlHeight = -1;
}
bool wxAuiNotebook::Create(wxWindow* parent,
if (!wxControl::Create(parent, id, pos, size, style))
return false;
- InitNotebook(style);
+ InitNotebook(style);
+
+ return true;
+}
+
+// InitNotebook() contains common initialization
+// code called by all constructors
+void wxAuiNotebook::InitNotebook(long style)
+{
+ SetName(wxT("wxAuiNotebook"));
+ m_curPage = -1;
+ m_tabIdCounter = wxAuiBaseTabCtrlId;
+ m_dummyWnd = NULL;
+ m_flags = (unsigned int)style;
+ m_tabCtrlHeight = 20;
+
+ m_normalFont = *wxNORMAL_FONT;
+ m_selectedFont = *wxNORMAL_FONT;
+ m_selectedFont.SetWeight(wxBOLD);
+
+ SetArtProvider(new wxAuiDefaultTabArt);
+
+ m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
+ m_dummyWnd->SetSize(200, 200);
+ m_dummyWnd->Show(false);
+
+ m_mgr.SetManagedWindow(this);
+ m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
+ m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
+
+ m_mgr.AddPane(m_dummyWnd,
+ wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
+
+ m_mgr.Update();
+}
+
+wxAuiNotebook::~wxAuiNotebook()
+{
+ // Indicate we're deleting pages
+ SendDestroyEvent();
+
+ while ( GetPageCount() > 0 )
+ DeletePage(0);
+
+ m_mgr.UnInit();
+}
+
+void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
+{
+ m_tabs.SetArtProvider(art);
+
+ // Update the height and do nothing else if it did something but otherwise
+ // (i.e. if the new art provider uses the same height as the old one) we
+ // need to manually set the art provider for all tabs ourselves.
+ if ( !UpdateTabCtrlHeight() )
+ {
+ wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+ const size_t pane_count = all_panes.GetCount();
+ for (size_t 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;
+ tabctrl->SetArtProvider(art->Clone());
+ }
+ }
+}
+
+// SetTabCtrlHeight() is the highest-level override of the
+// tab height. A call to this function effectively enforces a
+// specified tab ctrl height, overriding all other considerations,
+// such as text or bitmap height. It overrides any call to
+// SetUniformBitmapSize(). Specifying a height of -1 reverts
+// any previous call and returns to the default behaviour
+
+void wxAuiNotebook::SetTabCtrlHeight(int height)
+{
+ m_requestedTabCtrlHeight = height;
+
+ // if window is already initialized, recalculate the tab height
+ if (m_dummyWnd)
+ {
+ UpdateTabCtrlHeight();
+ }
+}
+
+
+// SetUniformBitmapSize() ensures that all tabs will have
+// the same height, even if some tabs don't have bitmaps
+// Passing wxDefaultSize to this function will instruct
+// the control to use dynamic tab height-- so when a tab
+// with a large bitmap is added, the tab ctrl's height will
+// automatically increase to accommodate the bitmap
+
+void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
+{
+ m_requestedBmpSize = size;
- return true;
+ // if window is already initialized, recalculate the tab height
+ if (m_dummyWnd)
+ {
+ UpdateTabCtrlHeight();
+ }
}
-// InitNotebook() contains common initialization
-// code called by all constructors
-void wxAuiNotebook::InitNotebook(long style)
+// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
+// to be used internally
+bool wxAuiNotebook::UpdateTabCtrlHeight()
{
- 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);
+ // get the tab ctrl height we will use
+ int height = CalculateTabCtrlHeight();
- SetArtProvider(new wxAuiDefaultTabArt);
+ // if the tab control height needs to change, update
+ // all of our tab controls with the new height
+ if (m_tabCtrlHeight == height)
+ return false;
- m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
- m_dummy_wnd->SetSize(200, 200);
- m_dummy_wnd->Show(false);
+ wxAuiTabArt* art = m_tabs.GetArtProvider();
- m_mgr.SetManagedWindow(this);
+ m_tabCtrlHeight = height;
- m_mgr.AddPane(m_dummy_wnd,
- wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
+ 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_tabCtrlHeight);
+ tabctrl->SetArtProvider(art->Clone());
+ tab_frame->DoSizing();
+ }
- m_mgr.Update();
+ return true;
}
-wxAuiNotebook::~wxAuiNotebook()
+void wxAuiNotebook::UpdateHintWindowSize()
{
- m_mgr.UnInit();
+ wxSize size = CalculateNewSplitSize();
+
+ // the placeholder hint window should be set to this size
+ wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
+ if (info.IsOk())
+ {
+ info.MinSize(size);
+ info.BestSize(size);
+ m_dummyWnd->SetSize(size);
+ }
}
-void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
+
+// calculates the size of the new split
+wxSize wxAuiNotebook::CalculateNewSplitSize()
{
- m_tabs.SetArtProvider(art);
-
- // choose a default for the tab height
- m_tab_ctrl_height = art->GetBestTabCtrlSize(this);
-
+ // count number of tab controls
+ int tab_ctrl_count = 0;
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();
+ tab_ctrl_count++;
+ }
+
+ wxSize new_split_size;
+
+ // if there is only one tab control, the first split
+ // should happen around the middle
+ if (tab_ctrl_count < 2)
+ {
+ new_split_size = GetClientSize();
+ new_split_size.x /= 2;
+ new_split_size.y /= 2;
+ }
+ else
+ {
+ // this is in place of a more complicated calculation
+ // that needs to be implemented
+ new_split_size = wxSize(180,180);
}
-
+
+ return new_split_size;
+}
+
+int wxAuiNotebook::CalculateTabCtrlHeight()
+{
+ // if a fixed tab ctrl height is specified,
+ // just return that instead of calculating a
+ // tab height
+ if (m_requestedTabCtrlHeight != -1)
+ return m_requestedTabCtrlHeight;
+
+ // find out new best tab height
+ wxAuiTabArt* art = m_tabs.GetArtProvider();
+
+ return art->GetBestTabCtrlSize(this,
+ m_tabs.GetPages(),
+ m_requestedBmpSize);
}
-wxAuiTabArt* wxAuiNotebook::GetArtProvider()
+
+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;
+ wxTabFrame* tabframe = (wxTabFrame*)pane.window;
+ wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
tabctrl->SetFlags(m_flags);
+ tabframe->DoSizing();
tabctrl->Refresh();
tabctrl->Update();
}
bool select,
const wxBitmap& bitmap)
{
+ wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
+ if (!page)
+ return false;
+
+ page->Reparent(this);
+
wxAuiNotebookPage info;
info.window = page;
info.caption = caption;
m_tabs.InsertPage(page, info, page_idx);
+ // if that was the first page added, even if
+ // select is false, it must become the "current page"
+ // (though no select events will be fired)
+ if (!select && m_tabs.GetPageCount() == 1)
+ select = true;
+ //m_curPage = GetPageIndex(page);
+
wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
if (page_idx >= active_tabctrl->GetPageCount())
active_tabctrl->AddPage(page, info);
- else
+ else
active_tabctrl->InsertPage(page, info, page_idx);
+ UpdateTabCtrlHeight();
DoSizing();
active_tabctrl->DoShowHide();
+ // adjust selected index
+ if(m_curPage >= (int) page_idx)
+ m_curPage++;
+
if (select)
{
- int idx = m_tabs.GetIdxFromWindow(page);
- wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
-
- SetSelection(idx);
+ SetSelectionToWindow(page);
}
return true;
// DeletePage() removes a tab from the multi-notebook,
// and destroys the window as well
bool wxAuiNotebook::DeletePage(size_t page_idx)
-{
+{
+ if (page_idx >= m_tabs.GetPageCount())
+ return false;
+
wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
+ // hide the window in advance, as this will
+ // prevent flicker
+ ShowWnd(wnd, false);
+
if (!RemovePage(page_idx))
return false;
-
+#if wxUSE_MDI
// actually destroy the window now
if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
if (!wxPendingDelete.Member(wnd))
wxPendingDelete.Append(wnd);
}
- else
+ else
+#endif
{
wnd->Destroy();
}
-
+
return true;
}
// but does not destroy the window
bool wxAuiNotebook::RemovePage(size_t page_idx)
{
+ // save active window pointer
+ wxWindow* active_wnd = NULL;
+ if (m_curPage >= 0)
+ active_wnd = m_tabs.GetWindowFromIdx(m_curPage);
+
+ // save pointer of window being deleted
wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
wxWindow* new_active = NULL;
+ // make sure we found the page
+ if (!wnd)
+ return false;
+
// find out which onscreen tab ctrl owns this tab
wxAuiTabCtrl* ctrl;
int ctrl_idx;
if (!FindTab(wnd, &ctrl, &ctrl_idx))
return false;
- // find a new page and set it as active
- int new_idx = ctrl_idx+1;
- if (new_idx >= (int)ctrl->GetPageCount())
- new_idx = ctrl_idx-1;
+ bool is_curpage = (m_curPage == (int)page_idx);
+ bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
- if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
- {
- new_active = ctrl->GetWindowFromIdx(new_idx);
- }
- else
- {
- // set the active page to the first page that
- // isn't the one being deleted
- size_t i, page_count = m_tabs.GetPageCount();
- for (i = 0; i < page_count; ++i)
- {
- wxWindow* w = m_tabs.GetWindowFromIdx(i);
- if (wnd != w)
- {
- new_active = m_tabs.GetWindowFromIdx(i);
- break;
- }
- }
- }
// remove the tab from main catalog
if (!m_tabs.RemovePage(wnd))
// remove the tab from the onscreen tab ctrl
ctrl->RemovePage(wnd);
+ if (is_active_in_split)
+ {
+ int ctrl_new_page_count = (int)ctrl->GetPageCount();
+
+ if (ctrl_idx >= ctrl_new_page_count)
+ ctrl_idx = ctrl_new_page_count-1;
+
+ if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
+ {
+ // set new page as active in the tab split
+ ctrl->SetActivePage(ctrl_idx);
+
+ // if the page deleted was the current page for the
+ // entire tab control, then record the window
+ // pointer of the new active page for activation
+ if (is_curpage)
+ {
+ new_active = ctrl->GetWindowFromIdx(ctrl_idx);
+ }
+ }
+ }
+ else
+ {
+ // we are not deleting the active page, so keep it the same
+ new_active = active_wnd;
+ }
- RemoveEmptyTabFrames();
- // set new active pane
- if (new_active)
+ if (!new_active)
{
- m_curpage = -1;
- SetSelection(m_tabs.GetIdxFromWindow(new_active));
+ // we haven't yet found a new page to active,
+ // so select the next page from the main tab
+ // catalogue
+
+ if (page_idx < m_tabs.GetPageCount())
+ {
+ new_active = m_tabs.GetPage(page_idx).window;
+ }
+
+ if (!new_active && m_tabs.GetPageCount() > 0)
+ {
+ new_active = m_tabs.GetPage(0).window;
+ }
}
-
+
+
+ RemoveEmptyTabFrames();
+
+ m_curPage = wxNOT_FOUND;
+
+ // set new active pane unless we're being destroyed anyhow
+ if (new_active && !m_isBeingDeleted)
+ SetSelectionToWindow(new_active);
+
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);
+}
+
+
+
// SetPageText() changes the tab caption of the specified page
bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
{
return true;
}
-// GetSelection() returns the index of the currently active page
-int wxAuiNotebook::GetSelection() const
+// returns the page caption
+wxString wxAuiNotebook::GetPageText(size_t page_idx) const
{
- return m_curpage;
+ if (page_idx >= m_tabs.GetPageCount())
+ return wxEmptyString;
+
+ // update our own tab catalog
+ const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+ return page_info.caption;
}
-// SetSelection() sets the currently active page
-size_t wxAuiNotebook::SetSelection(size_t new_page)
+bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
{
- wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
- if (!wnd)
- return m_curpage;
+ if (page_idx >= m_tabs.GetPageCount())
+ return false;
- wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
- evt.SetSelection(new_page);
- evt.SetOldSelection(m_curpage);
- evt.SetEventObject(this);
- if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
+ // update our own tab catalog
+ wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+ page_info.bitmap = bitmap;
+
+ // tab height might have changed
+ UpdateTabCtrlHeight();
+
+ // update what's on screen
+ wxAuiTabCtrl* ctrl;
+ int ctrl_idx;
+ if (FindTab(page_info.window, &ctrl, &ctrl_idx))
{
- // program allows the page change
- evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
- (void)GetEventHandler()->ProcessEvent(evt);
+ wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
+ info.bitmap = bitmap;
+ ctrl->Refresh();
+ ctrl->Update();
+ }
+ return true;
+}
+// returns the page bitmap
+wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
+{
+ if (page_idx >= m_tabs.GetPageCount())
+ return wxBitmap();
- wxAuiTabCtrl* ctrl;
- int ctrl_idx;
- if (FindTab(wnd, &ctrl, &ctrl_idx))
- {
- m_tabs.SetActivePage(wnd);
+ // update our own tab catalog
+ const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+ return page_info.bitmap;
+}
- ctrl->SetActivePage(ctrl_idx);
- DoSizing();
- ctrl->DoShowHide();
+// GetSelection() returns the index of the currently active page
+int wxAuiNotebook::GetSelection() const
+{
+ return m_curPage;
+}
- int old_curpage = m_curpage;
- m_curpage = new_page;
+// SetSelection() sets the currently active page
+int wxAuiNotebook::SetSelection(size_t new_page)
+{
+ return DoModifySelection(new_page, true);
+}
+void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
+{
+ const int idx = m_tabs.GetIdxFromWindow(win);
+ wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
- // set fonts
- 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;
- if (tabctrl != ctrl)
- tabctrl->SetSelectedFont(m_normal_font);
- else
- tabctrl->SetSelectedFont(m_selected_font);
- tabctrl->Refresh();
- }
- wnd->SetFocus();
+ // since a tab was clicked, let the parent know that we received
+ // the focus, even if we will assign that focus immediately
+ // to the child tab in the SetSelection call below
+ // (the child focus event will also let wxAuiManager, if any,
+ // know that the notebook control has been activated)
- return old_curpage;
- }
+ wxWindow* parent = GetParent();
+ if (parent)
+ {
+ wxChildFocusEvent eventFocus(this);
+ parent->GetEventHandler()->ProcessEvent(eventFocus);
}
- return m_curpage;
+
+ SetSelection(idx);
}
// GetPageCount() returns the total number of
// called to determine which control gets new windows being added
wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
{
- if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
+ if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())
{
wxAuiTabCtrl* ctrl;
int idx;
// find the tab ctrl with the current page
- if (FindTab(m_tabs.GetPage(m_curpage).window,
+ if (FindTab(m_tabs.GetPage(m_curPage).window,
&ctrl, &idx))
{
return ctrl;
// If there is no tabframe at all, create one
wxTabFrame* tabframe = new wxTabFrame;
- tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
+ tabframe->SetTabCtrlHeight(m_tabCtrlHeight);
tabframe->m_tabs = new wxAuiTabCtrl(this,
- m_tab_id_counter++,
+ m_tabIdCounter++,
wxDefaultPosition,
wxDefaultSize,
- wxNO_BORDER);
+ wxNO_BORDER|wxWANTS_CHARS);
tabframe->m_tabs->SetFlags(m_flags);
tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
m_mgr.AddPane(tabframe,
return false;
}
-
-void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
+void wxAuiNotebook::Split(size_t page, int direction)
{
+ wxSize cli_size = GetClientSize();
+
+ // get the page's window pointer
+ wxWindow* wnd = GetPage(page);
+ if (!wnd)
+ return;
+
+ // notebooks with 1 or less pages can't be split
+ if (GetPageCount() < 2)
+ return;
+
+ // find out which tab control the page currently belongs to
+ wxAuiTabCtrl *src_tabs, *dest_tabs;
+ int src_idx = -1;
+ src_tabs = NULL;
+ if (!FindTab(wnd, &src_tabs, &src_idx))
+ return;
+ if (!src_tabs || src_idx == -1)
+ return;
+
+ // choose a split size
+ wxSize split_size;
+ if (GetPageCount() > 2)
+ {
+ split_size = CalculateNewSplitSize();
+ }
+ else
+ {
+ // because there are two panes, always split them
+ // equally
+ split_size = GetClientSize();
+ split_size.x /= 2;
+ split_size.y /= 2;
+ }
+
+
+ // create a new tab frame
+ wxTabFrame* new_tabs = new wxTabFrame;
+ new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
+ new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
+ new_tabs->m_tabs = new wxAuiTabCtrl(this,
+ m_tabIdCounter++,
+ wxDefaultPosition,
+ wxDefaultSize,
+ wxNO_BORDER|wxWANTS_CHARS);
+ new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
+ new_tabs->m_tabs->SetFlags(m_flags);
+ dest_tabs = new_tabs->m_tabs;
+
+ // create a pane info structure with the information
+ // about where the pane should be added
+ wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);
+ wxPoint mouse_pt;
+
+ if (direction == wxLEFT)
+ {
+ paneInfo.Left();
+ mouse_pt = wxPoint(0, cli_size.y/2);
+ }
+ else if (direction == wxRIGHT)
+ {
+ paneInfo.Right();
+ mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
+ }
+ else if (direction == wxTOP)
+ {
+ paneInfo.Top();
+ mouse_pt = wxPoint(cli_size.x/2, 0);
+ }
+ else if (direction == wxBOTTOM)
+ {
+ paneInfo.Bottom();
+ mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
+ }
+
+ m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);
+ m_mgr.Update();
+
+ // remove the page from the source tabs
+ wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
+ 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();
+ }
+
+
+ // add the page to the destination tabs
+ dest_tabs->InsertPage(page_info.window, page_info, 0);
+
+ if (src_tabs->GetPageCount() == 0)
+ {
+ RemoveEmptyTabFrames();
+ }
+
+ DoSizing();
+ dest_tabs->DoShowHide();
+ dest_tabs->Refresh();
+
+ // force the set selection function reset the selection
+ m_curPage = -1;
+
+ // set the active page to the one we just split off
+ SetSelectionToPage(page_info);
+
+ UpdateHintWindowSize();
}
-void wxAuiNotebook::OnSize(wxSizeEvent&)
+
+void wxAuiNotebook::OnSize(wxSizeEvent& evt)
{
+ UpdateHintWindowSize();
+
+ evt.Skip();
}
-void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
{
- wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
-
wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
wxASSERT(ctrl != NULL);
wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
wxASSERT(wnd != NULL);
- int idx = m_tabs.GetIdxFromWindow(wnd);
- wxASSERT(idx != -1);
+ SetSelectionToWindow(wnd);
+}
- SetSelection(idx);
+void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
+{
+ // notify owner that the tabbar background has been double-clicked
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
}
-void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
+void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
{
- m_last_drag_x = 0;
+ m_lastDragX = 0;
}
-void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
+void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
{
wxPoint screen_pt = ::wxGetMousePosition();
wxPoint client_pt = ScreenToClient(screen_pt);
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;
-
+
// 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))
+ (src_idx > dest_idx && m_lastDragX <= pt.x) ||
+ (src_idx < dest_idx && m_lastDragX >= pt.x))
{
- m_last_drag_x = pt.x;
+ m_lastDragX = pt.x;
return;
}
dest_tabs->SetActivePage((size_t)dest_idx);
dest_tabs->DoShowHide();
dest_tabs->Refresh();
- m_last_drag_x = pt.x;
+ m_lastDragX = pt.x;
}
-
+
return;
}
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 && !tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
+ if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
{
while (tab_ctrl)
{
break;
tab_ctrl = tab_ctrl->GetParent();
}
-
+
if (tab_ctrl)
{
wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
-
+
if (nb != this)
{
- wxRect hint_rect = tab_ctrl->GetRect();
+ 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();
ClientToScreen(&hint_rect.x, &hint_rect.y);
m_mgr.ShowHint(hint_rect);
}
- else
+ else
{
- m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
+ m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);
}
}
-void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& 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));
- }
-
+
+ wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxCHECK_RET( src_tabs, wxT("no source object?") );
+
+ 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);
if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
{
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
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);
-
+
+ // Check that it's not an impossible parent relationship
+ wxWindow* p = nb;
+ while (p && !p->IsTopLevel())
+ {
+ if (p == src_page)
+ {
+ return;
+ }
+ p = p->GetParent();
+ }
+
// get main index of the page
int main_idx = m_tabs.GetIdxFromWindow(src_page);
-
+ wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
+
+
// make a copy of the page info
- wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
-
+ wxAuiNotebookPage page_info = m_tabs.GetPage(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);
insert_idx = dest_tabs->GetIdxFromWindow(target);
}
-
+
// add the page to the new notebook
if (insert_idx == -1)
insert_idx = dest_tabs->GetPageCount();
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));
+ nb->SetSelectionToPage(page_info);
+
+ // notify owner that the tab has been dragged
+ wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
+ e2.SetSelection(evt.GetSelection());
+ e2.SetOldSelection(evt.GetSelection());
+ e2.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e2);
return;
}
// only perform a tab split if it's allowed
- if (m_flags & wxAUI_NB_TAB_SPLIT)
+ wxAuiTabCtrl* dest_tabs = NULL;
+
+ if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
{
// If the pointer is in an existing tab frame, do a tab insert
wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
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);
insert_idx = dest_tabs->GetIdxFromWindow(target);
}
}
- else
+ else
{
+ wxPoint zero(0,0);
+ wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,
+ mouse_client_pt,
+ zero);
+ if (rect.IsEmpty())
+ {
+ // there is no suitable drop location here, exit out
+ return;
+ }
+
// If there is no tabframe at all, create one
wxTabFrame* new_tabs = new wxTabFrame;
- new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
+ new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
+ new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
new_tabs->m_tabs = new wxAuiTabCtrl(this,
- m_tab_id_counter++,
+ m_tabIdCounter++,
wxDefaultPosition,
wxDefaultSize,
- wxNO_BORDER);
+ wxNO_BORDER|wxWANTS_CHARS);
new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
new_tabs->m_tabs->SetFlags(m_flags);
dest_tabs->DoShowHide();
dest_tabs->Refresh();
- SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+ // force the set selection function reset the selection
+ m_curPage = -1;
+
+ // set the active page to the one we just split off
+ SetSelectionToPage(page_info);
+
+ UpdateHintWindowSize();
}
+
+ // notify owner that the tab has been dragged
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
+ e.SetSelection(evt.GetSelection());
+ e.SetOldSelection(evt.GetSelection());
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
}
+void wxAuiNotebook::OnTabCancelDrag(wxAuiNotebookEvent& command_evt)
+{
+ wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
+
+ m_mgr.HideHint();
+
+ wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxCHECK_RET( src_tabs, wxT("no source object?") );
+
+ src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
+}
+
wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
{
// if we've just removed the last tab from the source
// window closing, refreshs are pending
if (!wxPendingDelete.Member(tab_frame->m_tabs))
wxPendingDelete.Append(tab_frame->m_tabs);
- //tab_frame->m_tabs->Destroy();
+
+ tab_frame->m_tabs = NULL;
delete tab_frame;
}
m_mgr.GetPane(first_good).Centre();
}
- m_mgr.Update();
+ if (!m_isBeingDeleted)
+ m_mgr.Update();
}
-void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
+void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
{
+ evt.Skip();
+
+ // if we're dragging a tab, don't change the current selection.
+ // This code prevents a bug that used to happen when the hint window
+ // was hidden. In the bug, the focus would return to the notebook
+ // child, which would then enter this handler and call
+ // SetSelection, which is not desired turn tab dragging.
+
+ 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* tabframe = (wxTabFrame*)pane.window;
+ if (tabframe->m_tabs->IsDragging())
+ return;
+ }
+
+
+ // change the tab selection to the child
+ // which was focused
int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
- if (idx != -1 && idx != m_curpage)
+ if (idx != -1 && idx != m_curPage)
{
SetSelection(idx);
}
}
+void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
+{
+ if ( event.IsWindowChange() ) {
+ // change pages
+ // FIXME: the problem with this is that if we have a split notebook,
+ // we selection may go all over the place.
+ AdvanceSelection(event.GetDirection());
+ }
+ else {
+ // we get this event in 3 cases
+ //
+ // a) one of our pages might have generated it because the user TABbed
+ // out from it in which case we should propagate the event upwards and
+ // our parent will take care of setting the focus to prev/next sibling
+ //
+ // or
+ //
+ // b) the parent panel wants to give the focus to us so that we
+ // forward it to our selected page. We can't deal with this in
+ // OnSetFocus() because we don't know which direction the focus came
+ // from in this case and so can't choose between setting the focus to
+ // first or last panel child
+ //
+ // or
+ //
+ // c) we ourselves (see MSWTranslateMessage) generated the event
+ //
+ wxWindow * const parent = GetParent();
+
+ // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
+ const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
+ const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
+
+ if ( isFromParent || isFromSelf )
+ {
+ // no, it doesn't come from child, case (b) or (c): forward to a
+ // page but only if direction is backwards (TAB) or from ourselves,
+ if ( GetSelection() != wxNOT_FOUND &&
+ (!event.GetDirection() || isFromSelf) )
+ {
+ // so that the page knows that the event comes from it's parent
+ // and is being propagated downwards
+ event.SetEventObject(this);
+
+ wxWindow *page = GetPage(GetSelection());
+ if ( !page->GetEventHandler()->ProcessEvent(event) )
+ {
+ page->SetFocus();
+ }
+ //else: page manages focus inside it itself
+ }
+ else // otherwise set the focus to the notebook itself
+ {
+ SetFocus();
+ }
+ }
+ else
+ {
+ // it comes from our child, case (a), pass to the parent, but only
+ // if the direction is forwards. Otherwise set the focus to the
+ // notebook itself. The notebook is always the 'first' control of a
+ // page.
+ if ( !event.GetDirection() )
+ {
+ SetFocus();
+ }
+ else if ( parent )
+ {
+ event.SetCurrentFocus(this);
+ parent->GetEventHandler()->ProcessEvent(event);
+ }
+ }
+ }
+}
-void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
+void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
{
- wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
int button_id = evt.GetInt();
if (button_id == wxAUI_BUTTON_CLOSE)
{
- int selection = tabs->GetActivePage();
+ int selection = evt.GetSelection();
+
+ if (selection == -1)
+ {
+ // if the close button is to the right, use the active
+ // page selection to determine which page to close
+ selection = tabs->GetActivePage();
+ }
if (selection != -1)
{
wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
-
// ask owner if it's ok to close the tab
wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
+ const int idx = m_tabs.GetIdxFromWindow(close_wnd);
+ e.SetSelection(idx);
e.SetOldSelection(evt.GetSelection());
e.SetEventObject(this);
GetEventHandler()->ProcessEvent(e);
return;
+#if wxUSE_MDI
if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
{
close_wnd->Close();
}
- else
+ else
+#endif
{
int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
+ wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
+
DeletePage(main_idx);
}
+
+ // notify owner that the tab has been closed
+ wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
+ e2.SetSelection(idx);
+ e2.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e2);
}
}
}
+void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
+{
+ // patch event through to owner
+ wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
+ e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
+{
+ // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
+ // click should act like a tab close action. However, first
+ // give the owner an opportunity to handle the middle up event
+ // for custom action
+
+ wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
+ e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
+ e.SetEventObject(this);
+ if (GetEventHandler()->ProcessEvent(e))
+ return;
+ if (!e.IsAllowed())
+ return;
+
+ // check if we are supposed to close on middle-up
+ if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
+ return;
+
+ // simulate the user pressing the close button on the tab
+ evt.SetInt(wxAUI_BUTTON_CLOSE);
+ OnTabButton(evt);
+}
+
+void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
+{
+ // patch event through to owner
+ wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
+ e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+}
+
+void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
+{
+ // patch event through to owner
+ wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
+ wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
+
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
+ e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
+ e.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(e);
+}
+
+// Sets the normal font
+void wxAuiNotebook::SetNormalFont(const wxFont& font)
+{
+ m_normalFont = font;
+ GetArtProvider()->SetNormalFont(font);
+}
+
+// Sets the selected tab font
+void wxAuiNotebook::SetSelectedFont(const wxFont& font)
+{
+ m_selectedFont = font;
+ GetArtProvider()->SetSelectedFont(font);
+}
+
+// Sets the measuring font
+void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
+{
+ GetArtProvider()->SetMeasuringFont(font);
+}
+
+// Sets the tab font
+bool wxAuiNotebook::SetFont(const wxFont& font)
+{
+ wxControl::SetFont(font);
+
+ wxFont normalFont(font);
+ wxFont selectedFont(normalFont);
+ selectedFont.SetWeight(wxBOLD);
+
+ SetNormalFont(normalFont);
+ SetSelectedFont(selectedFont);
+ SetMeasuringFont(selectedFont);
+
+ return true;
+}
+
+// Gets the tab control height
+int wxAuiNotebook::GetTabCtrlHeight() const
+{
+ return m_tabCtrlHeight;
+}
+
+// Gets the height of the notebook for a given page height
+int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
+{
+ UpdateTabCtrlHeight();
+
+ int tabCtrlHeight = GetTabCtrlHeight();
+ int decorHeight = 2;
+ return tabCtrlHeight + pageHeight + decorHeight;
+}
+
+// Advances the selection, generation page selection events
+void wxAuiNotebook::AdvanceSelection(bool forward)
+{
+ if (GetPageCount() <= 1)
+ return;
+
+ int currentSelection = GetSelection();
+
+ if (forward)
+ {
+ if (currentSelection == (int) (GetPageCount() - 1))
+ return;
+ else if (currentSelection == -1)
+ currentSelection = 0;
+ else
+ currentSelection ++;
+ }
+ else
+ {
+ if (currentSelection <= 0)
+ return;
+ else
+ currentSelection --;
+ }
+
+ SetSelection(currentSelection);
+}
+
+// Shows the window menu
+bool wxAuiNotebook::ShowWindowMenu()
+{
+ wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
+
+ int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
+
+ if (idx != -1)
+ {
+ wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
+ e.SetSelection(idx);
+ e.SetOldSelection(tabCtrl->GetActivePage());
+ e.SetEventObject(tabCtrl);
+ GetEventHandler()->ProcessEvent(e);
+
+ return true;
+ }
+ else
+ return false;
+}
+
+void wxAuiNotebook::Thaw()
+{
+ DoSizing();
+
+ wxControl::Thaw();
+}
+
+void wxAuiNotebook::SetPageSize (const wxSize& WXUNUSED(size))
+{
+ wxFAIL_MSG("Not implemented for wxAuiNotebook");
+}
+
+int wxAuiNotebook::HitTest (const wxPoint& WXUNUSED(pt), long* WXUNUSED(flags)) const
+{
+ wxFAIL_MSG("Not implemented for wxAuiNotebook");
+ return wxNOT_FOUND;
+}
+
+int wxAuiNotebook::GetPageImage(size_t WXUNUSED(n)) const
+{
+ wxFAIL_MSG("Not implemented for wxAuiNotebook");
+ return -1;
+}
+
+bool wxAuiNotebook::SetPageImage(size_t n, int imageId)
+{
+ return SetPageBitmap(n, GetImageList()->GetBitmap(imageId));
+}
+
+wxWindow* wxAuiNotebook::GetCurrentPage () const
+{
+ const int sel = GetSelection();
+
+ return sel == wxNOT_FOUND ? NULL : GetPage(sel);
+}
+
+int wxAuiNotebook::ChangeSelection(size_t n)
+{
+ return DoModifySelection(n, false);
+}
+
+bool wxAuiNotebook::AddPage(wxWindow *page, const wxString &text, bool select,
+ int imageId)
+{
+ if(HasImageList())
+ {
+ return AddPage(page, text, select, GetImageList()->GetBitmap(imageId));
+ }
+ else
+ {
+ return AddPage(page, text, select, wxNullBitmap);
+ }
+}
+
+bool wxAuiNotebook::DeleteAllPages()
+{
+ size_t count = GetPageCount();
+ for(size_t i = 0; i < count; i++)
+ {
+ DeletePage(0);
+ }
+ return true;
+}
+
+bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
+ const wxString &text, bool select,
+ int imageId)
+{
+ if(HasImageList())
+ {
+ return InsertPage(index, page, text, select,
+ GetImageList()->GetBitmap(imageId));
+ }
+ else
+ {
+ return InsertPage(index, page, text, select, wxNullBitmap);
+ }
+}
+
+int wxAuiNotebook::DoModifySelection(size_t n, bool events)
+{
+ wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
+ if (!wnd)
+ return m_curPage;
+
+ // don't change the page unless necessary;
+ // however, clicking again on a tab should give it the focus.
+ if ((int)n == m_curPage)
+ {
+ wxAuiTabCtrl* ctrl;
+ int ctrl_idx;
+ if (FindTab(wnd, &ctrl, &ctrl_idx))
+ {
+ if (FindFocus() != ctrl)
+ ctrl->SetFocus();
+ }
+ return m_curPage;
+ }
+
+ bool vetoed = false;
+
+ wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+
+ if(events)
+ {
+ evt.SetSelection(n);
+ evt.SetOldSelection(m_curPage);
+ evt.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(evt);
+ vetoed = !evt.IsAllowed();
+ }
+
+ if (!vetoed)
+ {
+ int old_curpage = m_curPage;
+ m_curPage = n;
+
+ // program allows the page change
+ if(events)
+ {
+ evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
+ (void)GetEventHandler()->ProcessEvent(evt);
+ }
+
+
+ wxAuiTabCtrl* ctrl;
+ int ctrl_idx;
+ if (FindTab(wnd, &ctrl, &ctrl_idx))
+ {
+ m_tabs.SetActivePage(wnd);
+
+ ctrl->SetActivePage(ctrl_idx);
+ DoSizing();
+ ctrl->DoShowHide();
+
+ ctrl->MakeTabVisible(ctrl_idx, ctrl);
+
+ // set fonts
+ 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;
+ if (tabctrl != ctrl)
+ tabctrl->SetSelectedFont(m_normalFont);
+ else
+ tabctrl->SetSelectedFont(m_selectedFont);
+ tabctrl->Refresh();
+ }
+
+ // Set the focus to the page if we're not currently focused on the tab.
+ // This is Firefox-like behaviour.
+ if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
+ wnd->SetFocus();
+
+ return old_curpage;
+ }
+ }
+
+ return m_curPage;
+}
#endif // wxUSE_AUI
projects / wxWidgets.git / blobdiff