wxAuiFloatingFrame::wxAuiFloatingFrame(wxWindow* parent,
wxAuiManager* owner_mgr,
const wxAuiPaneInfo& pane,
wxWindowID id /*= wxID_ANY*/,
long style /*=wxRESIZE_BORDER | wxSYSTEM_MENU | wxCAPTION |
wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT |
wxCLIP_CHILDREN
*/)
: wxAuiFloatingFrameBaseClass(parent, id, wxEmptyString,
pane.floating_pos, pane.floating_size,
style |
(pane.HasCloseButton()?wxCLOSE_BOX:0) |
(pane.HasMaximizeButton()?wxMAXIMIZE_BOX:0) |
(pane.IsFixed()?0:wxRESIZE_BORDER)
)
{
m_owner_mgr = owner_mgr;
m_moving = false;
m_mgr.SetManagedWindow(this);
m_solid_drag = true;
// find out if the system supports solid window drag.
// on non-msw systems, this is assumed to be the case
#ifdef __WXMSW__
BOOL b = TRUE;
SystemParametersInfo(38 /*SPI_GETDRAGFULLWINDOWS*/, 0, &b, 0);
m_solid_drag = b ? true : false;
#endif
SetExtraStyle(wxWS_EX_PROCESS_IDLE);
}
void DockablePaneMenuManager::HackShowPane(wxAuiPaneInfo &pane_info, wxAuiManager *pAui)
{
if ( pane_info.IsOk() && pAui ) {
pane_info.MinSize(pane_info.best_size); // saved while hiding
pane_info.Show();
pAui->Update();
pane_info.MinSize(10,5); // so it can't disappear if undocked
pAui->Update();
}
}
void DockablePaneMenuManager::HackHidePane(bool commit, wxAuiPaneInfo &pane_info, wxAuiManager *pAui)
{
if ( pane_info.IsOk() && pAui ) {
int width = 0;
int height = 0;
pane_info.window->GetClientSize(&width, &height);
pane_info.BestSize(width,height); // save for later subsequent show
pane_info.Hide();
if ( commit ) {
pAui->Update();
}
}
}
void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow *WXUNUSED(window), const wxRect& _rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(m_border_pen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
wxRect rect = _rect;
int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
if (pane.IsToolbar())
{
for (i = 0; i < border_width; ++i)
{
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
dc.SetPen(m_border_pen);
dc.DrawLine(rect.x, rect.y+rect.height-1,
rect.x+rect.width, rect.y+rect.height-1);
dc.DrawLine(rect.x+rect.width-1, rect.y,
rect.x+rect.width-1, rect.y+rect.height);
rect.Deflate(1);
}
}
else
{
for (i = 0; i < border_width; ++i)
{
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
rect.Deflate(1);
}
}
}
void wxAuiDefaultDockArt::DrawCaption(wxDC& dc, wxWindow *WXUNUSED(window),
const wxString& text,
const wxRect& rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetFont(m_captionFont);
DrawCaptionBackground(dc, rect,
(pane.state & wxAuiPaneInfo::optionActive)?true:false);
int caption_offset = 0;
if ( pane.icon.IsOk() )
{
DrawIcon(dc, rect, pane);
caption_offset += pane.icon.GetWidth() + 3;
}
if (pane.state & wxAuiPaneInfo::optionActive)
dc.SetTextForeground(m_activeCaptionTextColour);
else
dc.SetTextForeground(m_inactiveCaptionTextColour);
wxCoord w,h;
dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
wxRect clip_rect = rect;
clip_rect.width -= 3; // text offset
clip_rect.width -= 2; // button padding
if (pane.HasCloseButton())
clip_rect.width -= m_buttonSize;
if (pane.HasPinButton())
clip_rect.width -= m_buttonSize;
if (pane.HasMaximizeButton())
clip_rect.width -= m_buttonSize;
wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
dc.SetClippingRegion(clip_rect);
dc.DrawText(draw_text, rect.x+3 + caption_offset, rect.y+(rect.height/2)-(h/2)-1);
dc.DestroyClippingRegion();
}
void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
const wxRect& rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(m_gripperBrush);
dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
if (!pane.HasGripperTop())
{
int y = 5;
while (1)
{
dc.SetPen(m_gripperPen1);
dc.DrawPoint(rect.x+3, rect.y+y);
dc.SetPen(m_gripperPen2);
dc.DrawPoint(rect.x+3, rect.y+y+1);
dc.DrawPoint(rect.x+4, rect.y+y);
dc.SetPen(m_gripperPen3);
dc.DrawPoint(rect.x+5, rect.y+y+1);
dc.DrawPoint(rect.x+5, rect.y+y+2);
dc.DrawPoint(rect.x+4, rect.y+y+2);
y += 4;
if (y > rect.GetHeight()-5)
break;
}
}
else
{
int x = 5;
while (1)
{
dc.SetPen(m_gripperPen1);
dc.DrawPoint(rect.x+x, rect.y+3);
dc.SetPen(m_gripperPen2);
dc.DrawPoint(rect.x+x+1, rect.y+3);
dc.DrawPoint(rect.x+x, rect.y+4);
dc.SetPen(m_gripperPen3);
dc.DrawPoint(rect.x+x+1, rect.y+5);
dc.DrawPoint(rect.x+x+2, rect.y+5);
dc.DrawPoint(rect.x+x+2, rect.y+4);
x += 4;
if (x > rect.GetWidth()-5)
break;
}
}
}
void wxAuiDefaultDockArt::DrawBorder(wxDC& dc, wxWindow* window, const wxRect& _rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(m_borderPen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
wxRect rect = _rect;
int i, border_width = GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
if (pane.IsToolbar())
{
for (i = 0; i < border_width; ++i)
{
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
dc.SetPen(m_borderPen);
dc.DrawLine(rect.x, rect.y+rect.height-1,
rect.x+rect.width, rect.y+rect.height-1);
dc.DrawLine(rect.x+rect.width-1, rect.y,
rect.x+rect.width-1, rect.y+rect.height);
rect.Deflate(1);
}
}
else
{
// notebooks draw the border themselves, so they can use native rendering (e.g. tabartgtk)
wxAuiTabArt* art = 0;
wxAuiNotebook* nb = wxDynamicCast(window, wxAuiNotebook);
if (nb)
art = nb->GetArtProvider();
if (art)
art->DrawBorder(dc, window, rect);
else
{
for (i = 0; i < border_width; ++i)
{
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
rect.Deflate(1);
}
}
}
}
void clAuiDockArt::DrawPaneButton(
wxDC& dc, wxWindow* window, int button, int button_state, const wxRect& _rect, wxAuiPaneInfo& pane)
{
int xx = _rect.GetTopLeft().x + ((_rect.GetWidth() - AUI_BUTTON_SIZE) / 2);
int yy = _rect.GetTopLeft().y + ((_rect.GetHeight() - AUI_BUTTON_SIZE) / 2);
switch(button) {
case wxAUI_BUTTON_CLOSE:
dc.DrawBitmap(m_dockCloseBmp, xx, yy);
break;
case wxAUI_BUTTON_MAXIMIZE_RESTORE:
if(pane.IsMaximized()) {
dc.DrawBitmap(m_dockMinimizeBmp, xx, yy);
} else {
dc.DrawBitmap(m_dockExpandeBmp, xx, yy);
}
break;
case wxAUI_BUTTON_PIN:
dc.DrawBitmap(m_dockMoreBmp, xx, yy);
break;
default:
wxAuiDefaultDockArt::DrawPaneButton(dc, window, button, button_state, _rect, pane);
break;
}
}
//=====================================================================================
/*virtual*/ void WinnerPanel::SetupPaneInfo( wxAuiPaneInfo& paneInfo )
{
paneInfo.MinSize( 150, -1 );
}
void
clAuiDockArt::DrawCaption(wxDC& dc, wxWindow* window, const wxString& text, const wxRect& rect, wxAuiPaneInfo& pane)
{
wxRect tmpRect(wxPoint(0, 0), rect.GetSize());
// Hackishly prevent assertions on linux
if(tmpRect.GetHeight() == 0) tmpRect.SetHeight(1);
if(tmpRect.GetWidth() == 0) tmpRect.SetWidth(1);
#ifdef __WXOSX__
tmpRect = rect;
window->PrepareDC(dc);
// Prepare the colours
wxColour bgColour, penColour, textColour;
textColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
bgColour = DrawingUtils::DarkColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 2.0);
; // Same as the notebook background colour
penColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
penColour = bgColour;
wxFont f = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
dc.SetFont(f);
dc.SetPen(penColour);
dc.SetBrush(bgColour);
dc.DrawRectangle(tmpRect);
// Fill the caption to look like OSX caption
wxColour topColour("#d3d2d3");
wxColour bottomColour("#e8e8e8");
dc.GradientFillLinear(tmpRect, topColour, bottomColour, wxNORTH);
dc.SetPen(penColour);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(tmpRect);
int caption_offset = 0;
if(pane.icon.IsOk()) {
DrawIcon(dc, tmpRect, pane);
caption_offset += pane.icon.GetWidth() + 3;
} else {
caption_offset = 3;
}
dc.SetTextForeground(textColour);
wxCoord w, h;
dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
wxRect clip_rect = tmpRect;
clip_rect.width -= 3; // text offset
clip_rect.width -= 2; // button padding
if(pane.HasCloseButton()) clip_rect.width -= m_buttonSize;
if(pane.HasPinButton()) clip_rect.width -= m_buttonSize;
if(pane.HasMaximizeButton()) clip_rect.width -= m_buttonSize;
wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
wxSize textSize = dc.GetTextExtent(draw_text);
dc.SetTextForeground(textColour);
dc.DrawText(draw_text, tmpRect.x + 3 + caption_offset, tmpRect.y + ((tmpRect.height - textSize.y) / 2));
#else
wxBitmap bmp(tmpRect.GetSize());
{
wxMemoryDC memDc;
memDc.SelectObject(bmp);
wxGCDC gdc;
wxDC* pDC = NULL;
if(!DrawingUtils::GetGCDC(memDc, gdc)) {
pDC = &memDc;
} else {
pDC = &gdc;
}
// Prepare the colours
wxColour bgColour, penColour, textColour;
textColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
bgColour = DrawingUtils::DarkColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 2.0);
; // Same as the notebook background colour
penColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
penColour = bgColour;
wxFont f = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
pDC->SetFont(f);
pDC->SetPen(penColour);
pDC->SetBrush(bgColour);
pDC->DrawRectangle(tmpRect);
pDC->SetPen(penColour);
pDC->SetBrush(*wxTRANSPARENT_BRUSH);
pDC->DrawRectangle(tmpRect);
int caption_offset = 0;
if(pane.icon.IsOk()) {
DrawIcon(gdc, tmpRect, pane);
caption_offset += pane.icon.GetWidth() + 3;
} else {
caption_offset = 3;
}
pDC->SetTextForeground(textColour);
wxCoord w, h;
pDC->GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
wxRect clip_rect = tmpRect;
clip_rect.width -= 3; // text offset
clip_rect.width -= 2; // button padding
if(pane.HasCloseButton()) clip_rect.width -= m_buttonSize;
if(pane.HasPinButton()) clip_rect.width -= m_buttonSize;
if(pane.HasMaximizeButton()) clip_rect.width -= m_buttonSize;
wxString draw_text = wxAuiChopText(gdc, text, clip_rect.width);
wxSize textSize = pDC->GetTextExtent(draw_text);
pDC->SetTextForeground(textColour);
pDC->DrawText(draw_text, tmpRect.x + 3 + caption_offset, tmpRect.y + ((tmpRect.height - textSize.y) / 2));
memDc.SelectObject(wxNullBitmap);
}
dc.DrawBitmap(bmp, rect.x, rect.y, true);
#endif
}
void wxAuiFloatingFrame::SetPaneWindow(const wxAuiPaneInfo& pane)
{
m_pane_window = pane.window;
m_pane_window->Reparent(this);
wxAuiPaneInfo contained_pane = pane;
contained_pane.Dock().Center().Show().
CaptionVisible(false).
PaneBorder(false).
Layer(0).Row(0).Position(0);
// Carry over the minimum size
wxSize pane_min_size = pane.window->GetMinSize();
// if the frame window's max size is greater than the min size
// then set the max size to the min size as well
wxSize cur_max_size = GetMaxSize();
if (cur_max_size.IsFullySpecified() &&
(cur_max_size.x < pane.min_size.x ||
cur_max_size.y < pane.min_size.y)
)
{
SetMaxSize(pane_min_size);
}
SetMinSize(pane.window->GetMinSize());
m_mgr.AddPane(m_pane_window, contained_pane);
m_mgr.Update();
if (pane.min_size.IsFullySpecified())
{
// because SetSizeHints() calls Fit() too (which sets the window
// size to its minimum allowed), we keep the size before calling
// SetSizeHints() and reset it afterwards...
wxSize tmp = GetSize();
GetSizer()->SetSizeHints(this);
SetSize(tmp);
}
SetTitle(pane.caption);
if (pane.floating_size != wxDefaultSize)
{
SetSize(pane.floating_size);
}
else
{
wxSize size = pane.best_size;
if (size == wxDefaultSize)
size = pane.min_size;
if (size == wxDefaultSize)
size = m_pane_window->GetSize();
if (m_owner_mgr && pane.HasGripper())
{
if (pane.HasGripperTop())
size.y += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
else
size.x += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
}
SetClientSize(size);
}
if (pane.IsFixed())
{
SetWindowStyleFlag(GetWindowStyleFlag() & ~wxRESIZE_BORDER);
}
}
void wxAuiFloatingFrame::SetPaneWindow(const wxAuiPaneInfo& pane)
{
m_pane_window = pane.window;
m_pane_window->Reparent(this);
wxAuiPaneInfo contained_pane = pane;
contained_pane.Dock().Center().Show().
CaptionVisible(false).
PaneBorder(false).
Layer(0).Row(0).Position(0);
// Carry over the minimum size
wxSize pane_min_size = pane.window->GetMinSize();
// if the frame window's max size is greater than the min size
// then set the max size to the min size as well
wxSize cur_max_size = GetMaxSize();
if (cur_max_size.IsFullySpecified() &&
(cur_max_size.x < pane.min_size.x ||
cur_max_size.y < pane.min_size.y)
)
{
SetMaxSize(pane_min_size);
}
SetMinSize(pane.window->GetMinSize());
m_mgr.AddPane(m_pane_window, contained_pane);
m_mgr.Update();
if (pane.min_size.IsFullySpecified())
{
// because SetSizeHints() calls Fit() too (which sets the window
// size to its minimum allowed), we keep the size before calling
// SetSizeHints() and reset it afterwards...
wxSize tmp = GetSize();
GetSizer()->SetSizeHints(this);
SetSize(tmp);
}
SetTitle(pane.caption);
// This code is slightly awkward because we need to reset wxRESIZE_BORDER
// before calling SetClientSize() below as doing it after setting the
// client size would actually change it, at least under MSW, where the
// total window size doesn't change and hence, as the borders size changes,
// the client size does change.
//
// So we must call it first but doing it generates a size event and updates
// pane.floating_size from inside it so we must also record its original
// value before doing it.
const bool hasFloatingSize = pane.floating_size != wxDefaultSize;
if (pane.IsFixed())
{
SetWindowStyleFlag(GetWindowStyleFlag() & ~wxRESIZE_BORDER);
}
if ( hasFloatingSize )
{
SetSize(pane.floating_size);
}
else
{
wxSize size = pane.best_size;
if (size == wxDefaultSize)
size = pane.min_size;
if (size == wxDefaultSize)
size = m_pane_window->GetSize();
if (m_owner_mgr && pane.HasGripper())
{
if (pane.HasGripperTop())
size.y += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
else
size.x += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
}
SetClientSize(size);
}
}
void wxAuiDefaultDockArt::DrawPaneButton(wxDC& dc, wxWindow *WXUNUSED(window),
int button,
int button_state,
const wxRect& _rect,
wxAuiPaneInfo& pane)
{
wxBitmap bmp;
switch (button)
{
default:
case wxAUI_BUTTON_CLOSE:
if (pane.state & wxAuiPaneInfo::optionActive)
bmp = m_activeCloseBitmap;
else
bmp = m_inactiveCloseBitmap;
break;
case wxAUI_BUTTON_PIN:
if (pane.state & wxAuiPaneInfo::optionActive)
bmp = m_activePinBitmap;
else
bmp = m_inactivePinBitmap;
break;
case wxAUI_BUTTON_MAXIMIZE_RESTORE:
if (pane.IsMaximized())
{
if (pane.state & wxAuiPaneInfo::optionActive)
bmp = m_activeRestoreBitmap;
else
bmp = m_inactiveRestoreBitmap;
}
else
{
if (pane.state & wxAuiPaneInfo::optionActive)
bmp = m_activeMaximizeBitmap;
else
bmp = m_inactiveMaximizeBitmap;
}
break;
}
wxRect rect = _rect;
int old_y = rect.y;
rect.y = rect.y + (rect.height/2) - (bmp.GetHeight()/2);
rect.height = old_y + rect.height - rect.y - 1;
if (button_state == wxAUI_BUTTON_STATE_PRESSED)
{
rect.x++;
rect.y++;
}
if (button_state == wxAUI_BUTTON_STATE_HOVER ||
button_state == wxAUI_BUTTON_STATE_PRESSED)
{
if (pane.state & wxAuiPaneInfo::optionActive)
{
dc.SetBrush(wxBrush(m_activeCaptionColour.ChangeLightness(120)));
dc.SetPen(wxPen(m_activeCaptionColour.ChangeLightness(70)));
}
else
{
dc.SetBrush(wxBrush(m_inactiveCaptionColour.ChangeLightness(120)));
dc.SetPen(wxPen(m_inactiveCaptionColour.ChangeLightness(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);
}
void SAuiDockArt::DrawCaption(wxDC& dc,
wxWindow *window,
const wxString& text,
const wxRect& rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetFont(m_captionFont);
dc.SetBrush(wxBrush(captionBackColour));
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
//dc.SetPen(m_borderPen);
//dc.SetBrush(wxBrush(Drawing::darkColour(captionBackColour, 2.0f)));
//dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
wxColor sepCol;
int l = rgba_t(captionBackColour.Red(), captionBackColour.Green(), captionBackColour.Blue()).greyscale().r;
if (l < 100)
sepCol = Drawing::lightColour(captionBackColour, 2.0f);
else
sepCol = Drawing::darkColour(captionBackColour, 2.0f);
//dc.SetPen(wxPen(sepCol));
//dc.DrawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width, rect.y + rect.height - 1);
dc.SetBrush(wxBrush(sepCol));
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height + 1);
int caption_offset = 0;
if (pane.icon.IsOk())
{
DrawIcon(dc, rect, pane);
caption_offset += pane.icon.GetWidth() + 3;
}
dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
wxRect clip_rect = rect;
clip_rect.width -= 3; // text offset
clip_rect.width -= 2; // button padding
if (pane.HasCloseButton())
clip_rect.width -= m_buttonSize;
if (pane.HasPinButton())
clip_rect.width -= m_buttonSize;
if (pane.HasMaximizeButton())
clip_rect.width -= m_buttonSize;
wxString draw_text = wxAuiChopText(dc, text, clip_rect.width);
wxCoord w, h;
dc.GetTextExtent(draw_text, &w, &h);
dc.SetClippingRegion(clip_rect);
#ifdef __WXMSW__
dc.DrawText(draw_text, rect.x + 5 + caption_offset, rect.y + (rect.height / 2) - (h / 2));
#else
dc.DrawText(draw_text, rect.x + 5 + caption_offset, rect.y + (rect.height / 2) - (h / 2) + 1);
#endif
//dc.SetPen(wxPen(captionAccentColour));
//dc.DrawLine(rect.x + w + 8, rect.y + (rect.height / 2) - 1, rect.x + rect.width - 16, rect.y + (rect.height / 2) - 1);
//dc.DrawLine(rect.x + w + 8, rect.y + (rect.height / 2) + 1, rect.x + rect.width - 16, rect.y + (rect.height / 2) + 1);
dc.DestroyClippingRegion();
}
void clAuiDockArt::DrawCaption(wxDC& dc, wxWindow* window, const wxString& text, const wxRect& rect, wxAuiPaneInfo& pane)
{
wxRect tmpRect(wxPoint(0, 0), rect.GetSize());
// Hackishly prevent assertions on linux
if (tmpRect.GetHeight() == 0)
tmpRect.SetHeight(1);
if (tmpRect.GetWidth() == 0)
tmpRect.SetWidth(1);
wxBitmap bmp(tmpRect.GetSize());
wxMemoryDC memDc;
memDc.SelectObject(bmp);
memDc.SetPen(*wxTRANSPARENT_PEN);
memDc.SetFont(m_captionFont);
// Prepare the colours
bool is_dark_theme = DrawingUtils::IsThemeDark();
wxColour bgColour, penColour, textColour;
if ( is_dark_theme ) {
bgColour = wxColour(EditorConfigST::Get()->GetCurrentOutputviewBgColour());
penColour = DrawingUtils::DarkColour(bgColour, 5.0);
textColour = *wxWHITE;
} else {
// Use the settings provided by a plugin
// Allow the plugins to override the border colour
wxColour originalPenColour = penColour;
clColourEvent borderColourEvent( wxEVT_GET_TAB_BORDER_COLOUR );
if ( EventNotifier::Get()->ProcessEvent( borderColourEvent ) ) {
bgColour = borderColourEvent.GetBorderColour();
penColour = DrawingUtils::DarkColour(bgColour, 3.0);
if ( DrawingUtils::IsDark(bgColour) ) {
textColour = *wxWHITE;
} else {
textColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT);
}
} else {
bgColour = DrawingUtils::DarkColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE), 2.0);
penColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
textColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT);
}
}
memDc.SetPen( penColour );
memDc.SetBrush( bgColour );
memDc.DrawRectangle( tmpRect );
wxPoint bottomLeft, bottomRight;
bottomLeft = tmpRect.GetBottomLeft();
bottomRight = tmpRect.GetBottomRight();
bottomRight.x += 1;
memDc.SetPen( bgColour );
memDc.DrawLine(bottomLeft, bottomRight);
memDc.SetPen( penColour );
bottomLeft.y--;
bottomRight.y--;
memDc.DrawLine(bottomLeft, bottomRight);
int caption_offset = 0;
if ( pane.icon.IsOk() ) {
DrawIcon(memDc, tmpRect, pane);
caption_offset += pane.icon.GetWidth() + 3;
} else {
caption_offset = 3;
}
memDc.SetTextForeground( textColour );
wxCoord w,h;
memDc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
wxRect clip_rect = tmpRect;
clip_rect.width -= 3; // text offset
clip_rect.width -= 2; // button padding
if (pane.HasCloseButton())
clip_rect.width -= m_buttonSize;
if (pane.HasPinButton())
clip_rect.width -= m_buttonSize;
if (pane.HasMaximizeButton())
clip_rect.width -= m_buttonSize;
wxString draw_text = wxAuiChopText(memDc, text, clip_rect.width);
wxSize textSize = memDc.GetTextExtent(draw_text);
memDc.DrawText(draw_text, tmpRect.x+3 + caption_offset, tmpRect.y+((tmpRect.height - textSize.y)/2));
memDc.SelectObject(wxNullBitmap);
dc.DrawBitmap( bmp, rect.x, rect.y, true );
}
