#ifndef WX_PRECOMP
#include "wx/settings.h"
#include "wx/image.h"
+ #include "wx/menu.h"
#endif
#include "wx/aui/tabmdi.h"
#include "wx/dcbuffer.h"
-#include "wx/menu.h"
#ifdef __WXMAC__
#include "wx/mac/carbon/private.h"
-// 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));
-}
+// these functions live in dockart.cpp -- they'll eventually
+// be moved to a new utility cpp file
-// 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);
-}
+wxColor wxAuiStepColour(const wxColor& c, int percent);
+
+wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
+ const wxColour& color);
+
+wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
static void DrawButtons(wxDC& dc,
const wxRect& _rect,
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)));
+ dc.SetBrush(wxBrush(wxAuiStepColour(bkcolour, 120)));
+ dc.SetPen(wxPen(wxAuiStepColour(bkcolour, 75)));
// draw the background behind the button
dc.DrawRectangle(rect.x, rect.y, 15, 15);
}
}
-// 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 --
wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
#endif
+ // the base_colour is too pale to use as our base colour,
+ // so darken it a bit --
+ if ((255-base_colour.Red()) +
+ (255-base_colour.Green()) +
+ (255-base_colour.Blue()) < 60)
+ {
+ base_colour = wxAuiStepColour(base_colour, 92);
+ }
+
m_base_colour = base_colour;
- wxColor darker2_colour = StepColour(base_colour, 70);
+ wxColor border_colour = wxAuiStepColour(base_colour, 75);
- m_border_pen = wxPen(darker2_colour);
+ m_border_pen = wxPen(border_colour);
m_base_colour_pen = wxPen(m_base_colour);
m_base_colour_brush = wxBrush(m_base_colour);
- m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
- m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+ m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+ m_disabled_close_bmp = wxAuiBitmapFromBits(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_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+ m_disabled_left_bmp = wxAuiBitmapFromBits(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_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+ m_disabled_right_bmp = wxAuiBitmapFromBits(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_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+ m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
m_flags = 0;
}
m_fixed_tab_width = 100;
int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
-
+
if (m_flags & wxAUI_NB_CLOSE_BUTTON)
tot_width -= m_active_close_bmp.GetWidth();
if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
{
// draw background
wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
- wxColor start_colour = StepColour(m_base_colour, 90);
- wxColor end_colour = StepColour(m_base_colour, 110);
- dc.GradientFillLinear(r, start_colour, end_colour, wxSOUTH);
+ wxColor top_color = wxAuiStepColour(m_base_colour, 90);
+ wxColor bottom_color = wxAuiStepColour(m_base_colour, 170);
+ dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
// draw base lines
int y = rect.GetHeight();
int w = rect.GetWidth();
dc.SetPen(m_border_pen);
- dc.DrawLine(0, y-4, w, y-4);
- dc.DrawLine(0, y-1, w, y-1);
- dc.SetPen(wxPen(start_colour));
- dc.DrawLine(0, y-3, w, y-3);
- dc.DrawLine(0, y-2, w, y-2);
+ dc.SetBrush(m_base_colour_brush);
+ dc.DrawRectangle(-1, y-4, w+2, 4);
}
void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
wxWindow* wnd,
+ const wxAuiNotebookPage& page,
const wxRect& in_rect,
- const wxString& caption_text,
- const wxBitmap& bitmap,
- bool active,
int close_button_state,
wxRect* out_tab_rect,
wxRect* out_button_rect,
wxCoord textx, texty;
// if the caption is empty, measure some temporary text
- wxString caption = caption_text;
- if (caption_text.empty())
+ wxString caption = page.caption;
+ if (caption.empty())
caption = wxT("Xj");
dc.SetFont(m_selected_font);
// figure out the size of the tab
wxSize tab_size = GetTabSize(dc,
wnd,
- caption,
- bitmap,
- active,
+ page.caption,
+ page.bitmap,
+ page.active,
close_button_state,
x_extent);
wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
- caption = caption_text;
+ caption = page.caption;
// select pen, brush and font for the tab to be drawn
- if (active)
+ if (page.active)
{
dc.SetFont(m_selected_font);
textx = selected_textx;
if (tab_x + clip_width > in_rect.x + in_rect.width)
clip_width = (in_rect.x + in_rect.width) - tab_x;
+/*
wxPoint clip_points[6];
clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
clip_points[1] = wxPoint(tab_x, tab_y+2);
clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
// FIXME: these ports don't provide wxRegion ctor from array of points
-#if !defined(__WXMGL__) && !defined(__WXDFB__)
+#if !defined(__WXDFB__) && !defined(__WXCOCOA__)
// set the clipping region for the tab --
wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
dc.SetClippingRegion(clipping_region);
-#endif // !wxMGL && !wxDFB
+#endif // !wxDFB && !wxCocoa
+*/
+ // since the above code above doesn't play well with WXDFB or WXCOCOA,
+ // we'll just use a rectangle for the clipping region for now --
+ dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
+
wxPoint border_points[6];
border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
int drawn_tab_height = border_points[0].y - border_points[1].y;
- if (active)
+ if (page.active)
{
// draw active tab
wxRect r(tab_x, tab_y, tab_width, tab_height);
dc.SetPen(m_base_colour_pen);
dc.SetBrush(m_base_colour_brush);
- dc.DrawRectangle(r.x, r.y, r.width, r.height);
+ dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
// this white helps fill out the gradient at the top of the tab
dc.SetPen(*wxWHITE_PEN);
dc.SetBrush(*wxWHITE_BRUSH);
- dc.DrawRectangle(r.x+2, r.y+2, r.width-3, r.height);
+ dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
// these two points help the rounded corners appear more antialiased
dc.SetPen(m_base_colour_pen);
- dc.DrawPoint(r.x+2, r.y+2);
- dc.DrawPoint(r.x+r.width-2, r.y+2);
+ dc.DrawPoint(r.x+2, r.y+1);
+ dc.DrawPoint(r.x+r.width-2, r.y+1);
// set rectangle down a bit for gradient drawing
r.SetHeight(r.GetHeight()/2);
r.x += 2;
r.width -= 2;
r.y += r.height;
+ r.y -= 2;
// draw gradient background
- wxColor start_color = StepColour(m_base_colour, 95);
- wxColor end_color = *wxWHITE;
- dc.GradientFillLinear(r, start_color, end_color, wxNORTH);
+ wxColor top_color = *wxWHITE;
+ wxColor bottom_color = m_base_colour;
+ dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
}
else
{
wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
- // draw base background color for inactive tabs
- dc.SetPen(m_base_colour_pen);
- dc.SetBrush(m_base_colour_brush);
- dc.DrawRectangle(r.x, r.y, r.width, r.height);
-
// start the gradent up a bit and leave the inside border inset
// by a pixel for a 3D look. Only the top half of the inactive
// tab will have a slight gradient
- r.x += 2;
- r.width -= 2;
+ r.x += 3;
+ r.y++;
+ r.width -= 4;
r.height /= 2;
+ r.height--;
- // -- draw bottom gradient fill for glossy look
+ // -- draw top gradient fill for glossy look
wxColor top_color = m_base_colour;
- wxColor bottom_color = StepColour(top_color, 106);
+ wxColor bottom_color = wxAuiStepColour(top_color, 160);
dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
+
+ r.y += r.height;
+ r.y--;
+
+ // -- draw bottom fill for glossy look
+ top_color = m_base_colour;
+ bottom_color = m_base_colour;
+ dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
}
// draw tab outline
// 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)
+ if (page.active)
{
- wxColor start_color = StepColour(m_base_colour, 93);
- dc.SetPen(wxPen(start_color));
- dc.DrawLine(border_points[0].x,
+ wxColor start_color = m_base_colour;
+ dc.SetPen(m_base_colour_pen);
+ dc.DrawLine(border_points[0].x+1,
border_points[0].y,
- border_points[5].x+1,
+ border_points[5].x,
border_points[5].y);
}
}
- if (bitmap.IsOk())
+ if (page.bitmap.IsOk())
{
int bitmap_offset = tab_x + 8;
// draw bitmap
- dc.DrawBitmap(bitmap,
+ dc.DrawBitmap(page.bitmap,
bitmap_offset,
- drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2) + 1,
+ drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
true);
- text_offset = bitmap_offset + bitmap.GetWidth();
+ text_offset = bitmap_offset + page.bitmap.GetWidth();
text_offset += 3; // bitmap padding
}
else
}
- wxString draw_text = ChopText(dc,
+ wxString draw_text = wxAuiChopText(dc,
caption,
tab_width - (text_offset-tab_x) - close_button_width);
int bitmap_id,
int button_state,
int orientation,
- const wxBitmap& bitmap_override,
wxRect* out_rect)
{
wxBitmap bmp;
wxRect rect;
- if (bitmap_override.IsOk())
+ switch (bitmap_id)
{
- 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;
- }
+ 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;
}
-int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
- const wxArrayString& items,
- int active_idx)
+int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
+ const wxAuiNotebookPageArray& pages,
+ int active_idx)
{
- wxMenu menuPopup;
+ wxMenu menuPopup;
- size_t i, count = items.GetCount();
+ size_t i, count = pages.GetCount();
for (i = 0; i < count; ++i)
{
- menuPopup.AppendCheckItem(1000+i, items.Item(i));
+ const wxAuiNotebookPage& page = pages.Item(i);
+ menuPopup.AppendCheckItem(1000+i, page.caption);
}
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
+ // find out where to put the popup menu of window items
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();
}
int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
- wxAuiNotebookPageArray& pages)
+ const wxAuiNotebookPageArray& pages,
+ const wxSize& required_bmp_size)
{
wxClientDC dc(wnd);
dc.SetFont(m_measuring_font);
+ // sometimes a standard bitmap size needs to be enforced, especially
+ // if some tabs have bitmaps and others don't. This is important because
+ // it prevents the tab control from resizing when tabs are added.
+ wxBitmap measure_bmp;
+ if (required_bmp_size.IsFullySpecified())
+ {
+ measure_bmp.Create(required_bmp_size.x,
+ required_bmp_size.y);
+ }
+
+
int max_y = 0;
size_t i, page_count = pages.GetCount();
for (i = 0; i < page_count; ++i)
{
wxAuiNotebookPage& page = pages.Item(i);
+ wxBitmap bmp;
+ if (measure_bmp.IsOk())
+ bmp = measure_bmp;
+ else
+ bmp = page.bitmap;
+
// we don't use the caption text because we don't
// want tab heights to be different in the case
// of a very short piece of text on one tab and a very
wxSize s = GetTabSize(dc,
wnd,
wxT("ABCDEFGHIj"),
- page.bitmap,
+ bmp,
true,
wxAUI_BUTTON_STATE_HIDDEN,
&x_ext);
+
max_y = wxMax(max_y, s.y);
}
wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
- wxColour background_colour = StepColour(base_colour, 95);
+ wxColour background_colour = base_colour;
wxColour normaltab_colour = base_colour;
wxColour selectedtab_colour = *wxWHITE;
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_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+ m_disabled_close_bmp = wxAuiBitmapFromBits(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_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+ m_disabled_left_bmp = wxAuiBitmapFromBits(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_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+ m_disabled_right_bmp = wxAuiBitmapFromBits(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_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+ m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
}
void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
wxWindow* wnd,
+ const wxAuiNotebookPage& page,
const wxRect& in_rect,
- const wxString& caption_text,
- const wxBitmap& bitmap,
- bool active,
int close_button_state,
wxRect* out_tab_rect,
wxRect* out_button_rect,
wxCoord textx, texty;
// if the caption is empty, measure some temporary text
- wxString caption = caption_text;
- if (caption_text.empty())
+ wxString caption = page.caption;
+ if (caption.empty())
caption = wxT("Xj");
dc.SetFont(m_selected_font);
// figure out the size of the tab
wxSize tab_size = GetTabSize(dc,
wnd,
- caption,
- bitmap,
- active,
+ page.caption,
+ page.bitmap,
+ page.active,
close_button_state,
x_extent);
wxCoord tab_x = in_rect.x;
wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
- caption = caption_text;
+ caption = page.caption;
// select pen, brush and font for the tab to be drawn
- if (active)
+ if (page.active)
{
dc.SetPen(m_selected_bkpen);
dc.SetBrush(m_selected_bkbrush);
text_offset = tab_x + tab_height;
// chop text if necessary
- wxString draw_text = ChopText(dc,
+ wxString draw_text = wxAuiChopText(dc,
caption,
tab_width - (text_offset-tab_x) - close_button_width);
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
wxBitmap bmp;
- if (active)
+ if (page.active)
bmp = m_active_close_bmp;
else
bmp = m_disabled_close_bmp;
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)
{
- 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;
- }
+ 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())
}
-int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
- const wxArrayString& items,
- int active_idx)
+int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
+ const wxAuiNotebookPageArray& pages,
+ int active_idx)
{
- wxMenu menuPopup;
+ wxMenu menuPopup;
- size_t i, count = items.GetCount();
+ size_t i, count = pages.GetCount();
for (i = 0; i < count; ++i)
{
- menuPopup.AppendCheckItem(1000+i, items.Item(i));
+ const wxAuiNotebookPage& page = pages.Item(i);
+ menuPopup.AppendCheckItem(1000+i, page.caption);
}
if (active_idx != -1)
}
int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
- wxAuiNotebookPageArray& WXUNUSED(pages))
+ const wxAuiNotebookPageArray& WXUNUSED(pages),
+ const wxSize& WXUNUSED(required_bmp_size))
{
wxClientDC dc(wnd);
dc.SetFont(m_measuring_font);
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;
button.id,
button.cur_state,
wxRIGHT,
- wxNullBitmap,
&button.rect);
offset -= button.rect.GetWidth();
button.id,
button.cur_state,
wxLEFT,
- wxNullBitmap,
&button.rect);
offset += button.rect.GetWidth();
m_art->DrawTab(dc,
wnd,
+ page,
rect,
- page.caption,
- page.bitmap,
- page.active,
tab_button.cur_state,
&page.rect,
&tab_button.rect,
rect.x = active_offset;
m_art->DrawTab(dc,
wnd,
+ page,
active_rect,
- page.caption,
- page.bitmap,
- page.active,
tab_button.cur_state,
&page.rect,
&tab_button.rect,
EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
EVT_SIZE(wxAuiTabCtrl::OnSize)
EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
+ EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDown)
EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
EVT_MOTION(wxAuiTabCtrl::OnMotion)
EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
- EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton)
+ EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
END_EVENT_TABLE()
{
int new_selection = GetIdxFromWindow(wnd);
- if (new_selection != GetActivePage())
+ // 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);
}
else if (button == wxAUI_BUTTON_WINDOWLIST)
{
- wxArrayString as;
-
- size_t i, page_count = m_pages.GetCount();
- for (i = 0; i < page_count; ++i)
- {
- wxAuiNotebookPage& page = m_pages.Item(i);
- as.Add(page.caption);
- }
-
- int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
+ int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
if (idx != -1)
{
};
-
+const int wxAuiBaseTabCtrlId = 5380;
// -- wxAuiNotebook class implementation --
BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
- //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
- //EVT_SIZE(wxAuiNotebook::OnSize)
- //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
+ EVT_SIZE(wxAuiNotebook::OnSize)
EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
wxAuiNotebook::OnTabClicked)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
wxAuiNotebook::OnTabBeginDrag)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
wxAuiNotebook::OnTabEndDrag)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
wxAuiNotebook::OnTabDragMotion)
- EVT_COMMAND_RANGE(10000, 10100,
+ EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
wxAuiNotebook::OnTabButton)
END_EVENT_TABLE()
wxAuiNotebook::wxAuiNotebook()
{
m_curpage = -1;
- m_tab_id_counter = 10000;
+ m_tab_id_counter = wxAuiBaseTabCtrlId;
m_dummy_wnd = NULL;
m_tab_ctrl_height = 20;
+ m_requested_bmp_size = wxDefaultSize;
+ m_requested_tabctrl_height = -1;
}
wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
const wxSize& size,
long style) : wxControl(parent, id, pos, size, style)
{
+ m_dummy_wnd = NULL;
+ m_requested_bmp_size = wxDefaultSize;
+ m_requested_tabctrl_height = -1;
InitNotebook(style);
}
void wxAuiNotebook::InitNotebook(long style)
{
m_curpage = -1;
- m_tab_id_counter = 10000;
+ m_tab_id_counter = wxAuiBaseTabCtrlId;
m_dummy_wnd = NULL;
- m_tab_ctrl_height = 20;
m_flags = (unsigned int)style;
+ m_tab_ctrl_height = 20;
m_normal_font = *wxNORMAL_FONT;
m_selected_font = *wxNORMAL_FONT;
m_dummy_wnd->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_dummy_wnd,
- wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
+ wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
m_mgr.Update();
}
{
m_tabs.SetArtProvider(art);
- SetTabCtrlHeight(CalculateTabCtrlHeight());
+ UpdateTabCtrlHeight();
}
+// 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 behavior
+
void wxAuiNotebook::SetTabCtrlHeight(int height)
{
+ m_requested_tabctrl_height = height;
+
+ // if window is already initialized, recalculate the tab height
+ if (m_dummy_wnd)
+ {
+ 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_requested_bmp_size = size;
+
+ // if window is already initialized, recalculate the tab height
+ if (m_dummy_wnd)
+ {
+ UpdateTabCtrlHeight();
+ }
+}
+
+// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
+// to be used interally
+void wxAuiNotebook::UpdateTabCtrlHeight()
+{
+ // get the tab ctrl height we will use
+ int height = CalculateTabCtrlHeight();
+
// if the tab control height needs to change, update
// all of our tab controls with the new height
if (m_tab_ctrl_height != height)
}
}
+void wxAuiNotebook::UpdateHintWindowSize()
+{
+ 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_dummy_wnd->SetSize(size);
+ }
+}
+
+
+// calculates the size of the new split
+wxSize wxAuiNotebook::CalculateNewSplitSize()
+{
+ // 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;
+ 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_requested_tabctrl_height != -1)
+ return m_requested_tabctrl_height;
+
// find out new best tab height
wxAuiTabArt* art = m_tabs.GetArtProvider();
- return art->GetBestTabCtrlSize(this, m_tabs.GetPages());
+ return art->GetBestTabCtrlSize(this,
+ m_tabs.GetPages(),
+ m_requested_bmp_size);
}
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)
+ m_curpage = GetPageIndex(page);
+
wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
if (page_idx >= active_tabctrl->GetPageCount())
active_tabctrl->AddPage(page, info);
else
active_tabctrl->InsertPage(page, info, page_idx);
- SetTabCtrlHeight(CalculateTabCtrlHeight());
+ UpdateTabCtrlHeight();
DoSizing();
active_tabctrl->DoShowHide();
return true;
}
+// returns the page caption
+wxString wxAuiNotebook::GetPageText(size_t page_idx) const
+{
+ 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;
+}
bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
{
page_info.bitmap = bitmap;
// tab height might have changed
- SetTabCtrlHeight(CalculateTabCtrlHeight());
+ UpdateTabCtrlHeight();
// update what's on screen
wxAuiTabCtrl* ctrl;
return true;
}
+// returns the page bitmap
+wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
+{
+ if (page_idx >= m_tabs.GetPageCount())
+ return wxBitmap();
+
+ // update our own tab catalog
+ const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+ return page_info.bitmap;
+}
// GetSelection() returns the index of the currently active page
int wxAuiNotebook::GetSelection() const
// SetSelection() sets the currently active page
size_t wxAuiNotebook::SetSelection(size_t new_page)
{
+ // don't change the page unless necessary
+ if ((int)new_page == m_curpage)
+ return m_curpage;
+
wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
if (!wnd)
return m_curpage;
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_tab_ctrl_height);
+ new_tabs->m_tabs = new wxAuiTabCtrl(this,
+ m_tab_id_counter++,
+ wxDefaultPosition,
+ wxDefaultSize,
+ wxNO_BORDER);
+ new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
+ new_tabs->m_tabs->SetFlags(m_flags);
+ dest_tabs = new_tabs->m_tabs;
+
+ // create a pane info structure with the information
+ // about where the pane should be added
+ wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
+ wxPoint mouse_pt;
+
+ if (direction == wxLEFT)
+ {
+ pane_info.Left();
+ mouse_pt = wxPoint(0, cli_size.y/2);
+ }
+ else if (direction == wxRIGHT)
+ {
+ pane_info.Right();
+ mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
+ }
+ else if (direction == wxTOP)
+ {
+ pane_info.Top();
+ mouse_pt = wxPoint(cli_size.x/2, 0);
+ }
+ else if (direction == wxBOTTOM)
+ {
+ pane_info.Bottom();
+ mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
+ }
+
+ m_mgr.AddPane(new_tabs, pane_info, 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
+ SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+
+ UpdateHintWindowSize();
}
-void wxAuiNotebook::OnSize(wxSizeEvent&)
+
+void wxAuiNotebook::OnSize(wxSizeEvent& evt)
{
+ UpdateHintWindowSize();
+
+ evt.Skip();
}
void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
return;
}
-
// If there is no tabframe at all, create one
wxTabFrame* new_tabs = new wxTabFrame;
+ new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
new_tabs->m_tabs = new wxAuiTabCtrl(this,
m_tab_id_counter++,
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
SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+
+ UpdateHintWindowSize();
}
}
projects / wxWidgets.git / blobdiff