void wxRibbonPanel::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
// At least on MSW, changing the size of a window will cause GetSize() to
// report the new size, but a size event may not be handled immediately.
// If this minimised check was performed in the OnSize handler, then
// GetSize() could return a size much larger than the minimised size while
// IsMinimised() returns true. This would then affect layout, as the panel
// will refuse to grow any larger while in limbo between minimised and non.
bool minimised = (m_flags & wxRIBBON_PANEL_NO_AUTO_MINIMISE) == 0 &&
IsMinimised(wxSize(width, height)); // check if would be at this size
if(minimised != m_minimised)
{
m_minimised = minimised;
// Note that for sizers, this routine disallows the use of mixed shown
// and hidden controls
// TODO ? use some list of user set invisible children to restore status.
for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
node;
node = node->GetNext())
{
node->GetData()->Show(!minimised);
}
Refresh();
}
wxRibbonControl::DoSetSize(x, y, width, height, sizeFlags);
}
bool wxRibbonPanel::Layout()
{
if(IsMinimised())
{
// Children are all invisible when minimised
return true;
}
// Get wxRibbonPanel client size
wxPoint position;
wxClientDC dc(this);
wxSize size = m_art->GetPanelClientSize(dc, this, GetSize(), &position);
// If there is a sizer, use it
if(GetSizer())
{
GetSizer()->SetDimension(position, size); // SetSize and Layout()
}
else if(GetChildren().GetCount() == 1)
{
// Common case of no sizer and single child taking up the entire panel
wxWindow* child = GetChildren().Item(0)->GetData();
child->SetSize(position.x, position.y, size.GetWidth(), size.GetHeight());
}
if(HasExtButton())
m_ext_button_rect = m_art->GetPanelExtButtonArea(dc, this, GetSize());
return true;
}
static bool ShouldRunVariableFrame()
{
if (!gConfigGeneral.uncap_fps) return false;
if (gGameSpeed > 4) return false;
if (gOpenRCT2Headless) return false;
if (IsMinimised()) return false;
return true;
}
void CAppWnd::Restore()
{
// Not already restored?
if (!IsVisible() || IsMinimised())
{
Show(SW_SHOWNORMAL);
::SetForegroundWindow(m_hWnd);
}
}
bool wxRibbonPanel::ShowExpanded()
{
if(!IsMinimised())
{
return false;
}
if(m_expanded_dummy != NULL || m_expanded_panel != NULL)
{
return false;
}
wxSize size = GetBestSize();
wxPoint pos = GetExpandedPosition(wxRect(GetScreenPosition(), GetSize()),
size, m_preferred_expand_direction).GetTopLeft();
// Need a top-level frame to contain the expanded panel
wxFrame *container = new wxFrame(NULL, wxID_ANY, GetLabel(),
pos, size, wxFRAME_NO_TASKBAR | wxBORDER_NONE);
m_expanded_panel = new wxRibbonPanel(container, wxID_ANY,
GetLabel(), m_minimised_icon, wxPoint(0, 0), size, m_flags);
m_expanded_panel->SetArtProvider(m_art);
m_expanded_panel->m_expanded_dummy = this;
// Move all children to the new panel.
// Conceptually it might be simpler to reparent this entire panel to the
// container and create a new panel to sit in its place while expanded.
// This approach has a problem though - when the panel is reinserted into
// its original parent, it'll be at a different position in the child list
// and thus assume a new position.
// NB: Children iterators not used as behaviour is not well defined
// when iterating over a container which is being emptied
while(!GetChildren().IsEmpty())
{
wxWindow *child = GetChildren().GetFirst()->GetData();
child->Reparent(m_expanded_panel);
child->Show();
}
// Move sizer to new panel
if(GetSizer())
{
wxSizer* sizer = GetSizer();
SetSizer(NULL, false);
m_expanded_panel->SetSizer(sizer);
}
m_expanded_panel->Realize();
Refresh();
container->Show();
m_expanded_panel->SetFocus();
return true;
}
void wxRibbonPanel::OnMouseClick(wxMouseEvent& WXUNUSED(evt))
{
if(IsMinimised())
{
if(m_expanded_panel != NULL)
{
HideExpanded();
}
else
{
ShowExpanded();
}
}
}
void wxRibbonPanel::OnPaint(wxPaintEvent& WXUNUSED(evt))
{
wxAutoBufferedPaintDC dc(this);
if(m_art != NULL)
{
if(IsMinimised())
{
m_art->DrawMinimisedPanel(dc, this, GetSize(), m_minimised_icon_resized);
}
else
{
m_art->DrawPanelBackground(dc, this, GetSize());
}
}
}
void wxRibbonPanel::OnMouseClick(wxMouseEvent& WXUNUSED(evt))
{
if(IsMinimised())
{
if(m_expanded_panel != NULL)
{
HideExpanded();
}
else
{
ShowExpanded();
}
}
else if(IsExtButtonHovered())
{
wxRibbonPanelEvent notification(wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED, GetId());
notification.SetEventObject(this);
notification.SetPanel(this);
ProcessEvent(notification);
}
}
bool wxRibbonPanel::Layout()
{
if(IsMinimised())
{
// Children are all invisible when minimised
return true;
}
// TODO: Delegate to a sizer
// Common case of no sizer and single child taking up the entire panel
if(GetChildren().GetCount() == 1)
{
wxWindow* child = GetChildren().Item(0)->GetData();
wxPoint position;
wxClientDC dc(this);
wxSize size = m_art->GetPanelClientSize(dc, this, GetSize(), &position);
child->SetSize(position.x, position.y, size.GetWidth(), size.GetHeight());
}
return true;
}
void CAppWnd::OnUserMsg(uint /*nMsg*/, WPARAM /*wParam*/, LPARAM lParam)
{
// ASSERT(nMsg == WM_USER_TRAY_NOTIFY);
// ASSERT(wParam == TRAY_ICON_ID);
// Icon double-clicked with left button?
if (lParam == WM_LBUTTONDBLCLK)
{
Restore();
}
// Icon clicked with right button?
else if ( (lParam == WM_RBUTTONUP) || (lParam == WM_CONTEXTMENU) )
{
// Required to allow menu to be dismissed.
::SetForegroundWindow(m_hWnd);
CPopupMenu oMenu(IDR_TRAYMENU);
// Disable relevant commands.
oMenu.EnableCmd(ID_TRAY_RESTORE, (IsMinimised() || !IsVisible()));
// Show context menu.
uint nCmdID = oMenu.TrackMenu(*this, CCursor::CurrentPos());
if (nCmdID != 0)
{
// Handle command.
switch (nCmdID)
{
case ID_TRAY_RESTORE: Restore(); break;
case ID_TRAY_EXIT: Close(); break;
default: ASSERT_FALSE(); break;
}
}
// Required to allow menu to be dismissed.
PostMessage(WM_NULL);
}
}
bool wxRibbonPanel::ShowExpanded()
{
if(!IsMinimised())
{
return false;
}
if(m_expanded_dummy != NULL || m_expanded_panel != NULL)
{
return false;
}
wxSize size = GetBestSize();
// Special case for flexible panel layout, where GetBestSize doesn't work
if (GetFlags() & wxRIBBON_PANEL_FLEXIBLE)
{
size = GetBestSizeForParentSize(wxSize(400, 1000));
}
wxPoint pos = GetExpandedPosition(wxRect(GetScreenPosition(), GetSize()),
size, m_preferred_expand_direction).GetTopLeft();
// Need a top-level frame to contain the expanded panel
wxFrame *container = new wxFrame(NULL, wxID_ANY, GetLabel(),
pos, size, wxFRAME_NO_TASKBAR | wxBORDER_NONE);
m_expanded_panel = new wxRibbonPanel(container, wxID_ANY,
GetLabel(), m_minimised_icon, wxPoint(0, 0), size, (m_flags /* & ~wxRIBBON_PANEL_FLEXIBLE */));
m_expanded_panel->SetArtProvider(m_art);
m_expanded_panel->m_expanded_dummy = this;
// Move all children to the new panel.
// Conceptually it might be simpler to reparent this entire panel to the
// container and create a new panel to sit in its place while expanded.
// This approach has a problem though - when the panel is reinserted into
// its original parent, it'll be at a different position in the child list
// and thus assume a new position.
// NB: Children iterators not used as behaviour is not well defined
// when iterating over a container which is being emptied
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
while(!GetChildren().IsEmpty())
{
wxWindow *child = GetChildren().GetFirst()->GetData();
child->Reparent(m_expanded_panel);
child->Show();
}
// Move sizer to new panel
if(GetSizer())
{
wxSizer* sizer = GetSizer();
SetSizer(NULL, false);
m_expanded_panel->SetSizer(sizer);
}
m_expanded_panel->Realize();
Refresh();
container->SetMinClientSize(size);
container->Show();
m_expanded_panel->SetFocus();
return true;
}
wxSize wxRibbonPanel::DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const
{
if(m_expanded_panel != NULL)
{
// Next size depends upon children, who are currently in the
// expanded panel
return m_expanded_panel->DoGetNextLargerSize(direction, relative_to);
}
if(IsMinimised(relative_to))
{
wxSize current = relative_to;
wxSize min_size = GetMinNotMinimisedSize();
switch(direction)
{
case wxHORIZONTAL:
if(min_size.x > current.x && min_size.y == current.y)
return min_size;
break;
case wxVERTICAL:
if(min_size.x == current.x && min_size.y > current.y)
return min_size;
break;
case wxBOTH:
if(min_size.x > current.x && min_size.y > current.y)
return min_size;
break;
default:
break;
}
}
if(m_art != NULL)
{
wxClientDC dc((wxRibbonPanel*) this);
wxSize child_relative = m_art->GetPanelClientSize(dc, this, relative_to, NULL);
wxSize larger(-1, -1);
if(GetSizer())
{
// We could just let the sizer expand in flow direction but see comment
// in IsSizingContinuous()
larger = GetPanelSizerBestSize();
// and adjust for page in non flow direction
if(m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL)
{
if(larger.x != child_relative.x)
larger.x = child_relative.x;
}
else if(larger.y != child_relative.y)
{
larger.y = child_relative.y;
}
}
else if(GetChildren().GetCount() == 1)
{
// Simple (and common) case of single ribbon child
wxWindow* child = GetChildren().Item(0)->GetData();
wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl);
if(ribbon_child != NULL)
{
larger = ribbon_child->GetNextLargerSize(direction, child_relative);
}
}
if(larger.IsFullySpecified()) // Use fallback if !(sizer/child = 1)
{
if(larger == child_relative)
{
return relative_to;
}
else
{
return m_art->GetPanelSize(dc, this, larger, NULL);
}
}
}
// Fallback: Increase by 25% (equal to a prior or subsequent 20% decrease)
// Note that due to rounding errors, this increase may not exactly equal a
// matching decrease - an ideal solution would not have these errors, but
// avoiding them is non-trivial unless an increase is by 100% rather than
// a fractional amount. This would then be non-ideal as the resizes happen
// at very large intervals.
wxSize current(relative_to);
if(direction & wxHORIZONTAL)
{
current.x = (current.x * 5 + 3) / 4;
}
if(direction & wxVERTICAL)
{
current.y = (current.y * 5 + 3) / 4;
}
return current;
}
wxSize wxRibbonPanel::DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const
{
if(m_expanded_panel != NULL)
{
// Next size depends upon children, who are currently in the
// expanded panel
return m_expanded_panel->DoGetNextLargerSize(direction, relative_to);
}
if(IsMinimised(relative_to))
{
wxSize current = relative_to;
wxSize min_size = GetMinNotMinimisedSize();
switch(direction)
{
case wxHORIZONTAL:
if(min_size.x > current.x && min_size.y == current.y)
return min_size;
break;
case wxVERTICAL:
if(min_size.x == current.x && min_size.y > current.y)
return min_size;
break;
case wxBOTH:
if(min_size.x > current.x && min_size.y > current.y)
return min_size;
break;
default:
break;
}
}
// TODO: Check for, and delegate to, a sizer
// Simple (and common) case of single ribbon child
if(GetChildren().GetCount() == 1)
{
wxWindow* child = GetChildren().Item(0)->GetData();
wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl);
if(ribbon_child != NULL)
{
wxClientDC dc((wxRibbonPanel*) this);
wxSize child_relative = m_art->GetPanelClientSize(dc, this, relative_to, NULL);
wxSize larger = ribbon_child->GetNextLargerSize(direction, child_relative);
if(larger == child_relative)
{
return relative_to;
}
else
{
wxClientDC dc((wxRibbonPanel*) this);
return m_art->GetPanelSize(dc, this, larger, NULL);
}
}
}
// Fallback: Increase by 25% (equal to a prior or subsequent 20% decrease)
// Note that due to rounding errors, this increase may not exactly equal a
// matching decrease - an ideal solution would not have these errors, but
// avoiding them is non-trivial unless an increase is by 100% rather than
// a fractional amount. This would then be non-ideal as the resizes happen
// at very large intervals.
wxSize current(relative_to);
if(direction & wxHORIZONTAL)
{
current.x = (current.x * 5 + 3) / 4;
}
if(direction & wxVERTICAL)
{
current.y = (current.y * 5 + 3) / 4;
}
return current;
}
