void CGUIBaseContainer::UpdateScrollOffset(unsigned int currentTime)
{
if (m_scroller.Update(currentTime))
MarkDirtyRegion();
else if (m_lastScrollStartTimer.IsRunning() && m_lastScrollStartTimer.GetElapsedMilliseconds() >= SCROLLING_GAP)
{
m_scrollTimer.Stop();
m_lastScrollStartTimer.Stop();
}
}
void CGUIControl::SetWidth(float width)
{
if (m_width != width)
{
MarkDirtyRegion();
m_width = width;
m_hitRect.x2 = m_hitRect.x1 + width;
SetInvalid();
}
}
void CGUIControl::SetHeight(float height)
{
if (m_height != height)
{
MarkDirtyRegion();
m_height = height;
m_hitRect.y2 = m_hitRect.y1 + height;
SetInvalid();
}
}
void CGUIControl::ResetAnimation(ANIMATION_TYPE type)
{
MarkDirtyRegion();
for (unsigned int i = 0; i < m_animations.size(); i++)
{
if (m_animations[i].GetType() == type)
m_animations[i].ResetAnimation();
}
}
bool CGUIDialogTeletext::OnAction(const CAction& action)
{
if (m_TextDecoder.HandleAction(action))
{
MarkDirtyRegion();
return true;
}
return CGUIDialog::OnAction(action);
}
void CGUIWindowFullScreen::Process(unsigned int currentTime, CDirtyRegionList &dirtyregion)
{
if (g_renderManager.IsGuiLayer())
MarkDirtyRegion();
CGUIWindow::Process(currentTime, dirtyregion);
// TODO: This isn't quite optimal - ideally we'd only be dirtying up the actual video render rect
// which is probably the job of the renderer as it can more easily track resizing etc.
m_renderRegion.SetRect(0, 0, (float)g_graphicsContext.GetWidth(), (float)g_graphicsContext.GetHeight());
}
void CGUIControlGroupList::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (m_scroller.Update(currentTime))
MarkDirtyRegion();
// first we update visibility of all our items, to ensure our size and
// alignment computations are correct.
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
GUIPROFILER_VISIBILITY_BEGIN(control);
control->UpdateVisibility();
GUIPROFILER_VISIBILITY_END(control);
}
ValidateOffset();
if (m_pageControl && m_lastScrollerValue != m_scroller.GetValue())
{
CGUIMessage message(GUI_MSG_LABEL_RESET, GetParentID(), m_pageControl, (int)Size(), (int)m_totalSize);
SendWindowMessage(message);
CGUIMessage message2(GUI_MSG_ITEM_SELECT, GetParentID(), m_pageControl, (int)m_scroller.GetValue());
SendWindowMessage(message2);
m_lastScrollerValue = m_scroller.GetValue();
}
// we run through the controls, rendering as we go
int index = 0;
float pos = GetAlignOffset();
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
// note we render all controls, even if they're offscreen, as then they'll be updated
// with respect to animations
CGUIControl *control = *it;
if (m_orientation == VERTICAL)
g_graphicsContext.SetOrigin(m_posX, m_posY + pos - m_scroller.GetValue());
else
g_graphicsContext.SetOrigin(m_posX + pos - m_scroller.GetValue(), m_posY);
control->DoProcess(currentTime, dirtyregions);
if (control->IsVisible())
{
if (IsControlOnScreen(pos, control))
{
if (control->HasFocus())
m_focusedPosition = index;
index++;
}
pos += Size(control) + m_itemGap;
}
g_graphicsContext.RestoreOrigin();
}
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIWindowPointer::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool active = g_Mouse.IsActive();
if (active != m_active)
{
MarkDirtyRegion();
m_active = active;
}
SetPosition((float)g_Mouse.GetX(), (float)g_Mouse.GetY());
SetPointer(g_Mouse.GetState());
return CGUIWindow::Process(currentTime, dirtyregions);
}
bool CGUIWindowDebugInfo::OnMessage(CGUIMessage &message)
{
if (message.GetMessage() == GUI_MSG_WINDOW_DEINIT)
{
delete m_layout;
m_layout = nullptr;
}
else if (message.GetMessage() == GUI_MSG_REFRESH_TIMER)
MarkDirtyRegion();
return CGUIDialog::OnMessage(message);
}
bool CGUIFixedListContainer::SelectItemFromPoint(const CPoint &point)
{
if (!m_focusedLayout || !m_layout)
return false;
MarkDirtyRegion();
const float mouse_scroll_speed = 0.25f;
const float mouse_max_amount = 1.5f;
float sizeOfItem = m_layout->Size(m_orientation);
int minCursor, maxCursor;
GetCursorRange(minCursor, maxCursor);
// see if the point is either side of our focus range
float start = (minCursor + 0.2f) * sizeOfItem;
float end = (maxCursor - 0.2f) * sizeOfItem + m_focusedLayout->Size(m_orientation);
float pos = (m_orientation == VERTICAL) ? point.y : point.x;
if (pos < start && GetOffset() > -minCursor)
{ // scroll backward
if (!InsideLayout(m_layout, point))
return false;
float amount = std::min((start - pos) / sizeOfItem, mouse_max_amount);
m_analogScrollCount += amount * amount * mouse_scroll_speed;
if (m_analogScrollCount > 1)
{
ScrollToOffset(GetOffset() - 1);
m_analogScrollCount = 0;
}
return true;
}
else if (pos > end && GetOffset() + maxCursor < (int)m_items.size() - 1)
{
if (!InsideLayout(m_layout, point))
return false;
// scroll forward
float amount = std::min((pos - end) / sizeOfItem, mouse_max_amount);
m_analogScrollCount += amount * amount * mouse_scroll_speed;
if (m_analogScrollCount > 1)
{
ScrollToOffset(GetOffset() + 1);
m_analogScrollCount = 0;
}
return true;
}
else
{ // select the appropriate item
int cursor = GetCursorFromPoint(point);
if (cursor < 0)
return false;
// calling SelectItem() here will focus the item and scroll, which isn't really what we're after
SetCursor(cursor);
return true;
}
}
void CGUIBaseContainer::UpdateLayout(bool updateAllItems)
{
if (updateAllItems)
{ // free memory of items
for (iItems it = m_items.begin(); it != m_items.end(); ++it)
(*it)->FreeMemory();
}
// and recalculate the layout
CalculateLayout();
SetPageControlRange();
MarkDirtyRegion();
}
void CGUIControl::UpdateVisibility(const CGUIListItem *item)
{
if (m_visibleCondition)
{
bool bWasVisible = m_visibleFromSkinCondition;
m_visibleFromSkinCondition = m_visibleCondition->Get(item);
if (!bWasVisible && m_visibleFromSkinCondition)
{ // automatic change of visibility - queue the in effect
// CLog::Log(LOGDEBUG, "Visibility changed to visible for control id %i", m_controlID);
QueueAnimation(ANIM_TYPE_VISIBLE);
}
else if (bWasVisible && !m_visibleFromSkinCondition)
{ // automatic change of visibility - do the out effect
// CLog::Log(LOGDEBUG, "Visibility changed to hidden for control id %i", m_controlID);
QueueAnimation(ANIM_TYPE_HIDDEN);
}
}
// check for conditional animations
for (unsigned int i = 0; i < m_animations.size(); i++)
{
CAnimation &anim = m_animations[i];
if (anim.GetType() == ANIM_TYPE_CONDITIONAL)
anim.UpdateCondition(item);
}
// and check for conditional enabling - note this overrides SetEnabled() from the code currently
// this may need to be reviewed at a later date
bool enabled = m_enabled;
if (m_enableCondition)
m_enabled = m_enableCondition->Get(item);
if (m_enabled != enabled)
MarkDirtyRegion();
m_allowHiddenFocus.Update(item);
if (UpdateColors())
MarkDirtyRegion();
// and finally, update our control information (if not pushed)
if (!m_pushedUpdates)
UpdateInfo(item);
}
void CGUIControlGroupList::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (m_scrollSpeed != 0)
{
MarkDirtyRegion();
m_offset += m_scrollSpeed * (currentTime - m_scrollLastTime);
if ((m_scrollSpeed < 0 && m_offset < m_scrollOffset) ||
(m_scrollSpeed > 0 && m_offset > m_scrollOffset))
{
m_offset = m_scrollOffset;
m_scrollSpeed = 0;
}
}
m_scrollLastTime = currentTime;
// first we update visibility of all our items, to ensure our size and
// alignment computations are correct.
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
GUIPROFILER_VISIBILITY_BEGIN(control);
control->UpdateVisibility();
GUIPROFILER_VISIBILITY_END(control);
}
ValidateOffset();
if (m_pageControl)
{
CGUIMessage message(GUI_MSG_LABEL_RESET, GetParentID(), m_pageControl, (int)m_height, (int)m_totalSize);
SendWindowMessage(message);
CGUIMessage message2(GUI_MSG_ITEM_SELECT, GetParentID(), m_pageControl, (int)m_offset);
SendWindowMessage(message2);
}
// we run through the controls, rendering as we go
float pos = GetAlignOffset();
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
// note we render all controls, even if they're offscreen, as then they'll be updated
// with respect to animations
CGUIControl *control = *it;
if (m_orientation == VERTICAL)
g_graphicsContext.SetOrigin(m_posX, m_posY + pos - m_offset);
else
g_graphicsContext.SetOrigin(m_posX + pos - m_offset, m_posY);
control->DoProcess(currentTime, dirtyregions);
if (control->IsVisible())
pos += Size(control) + m_itemGap;
g_graphicsContext.RestoreOrigin();
}
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIControl::SetPosition(float posX, float posY)
{
if ((m_posX != posX) || (m_posY != posY))
{
MarkDirtyRegion();
m_hitRect += CPoint(posX - m_posX, posY - m_posY);
m_posX = posX;
m_posY = posY;
SetInvalid();
}
}
void CGUIWindowFullScreen::ToggleOSD()
{
CGUIDialogVideoOSD *pOSD = (CGUIDialogVideoOSD *)g_windowManager.GetWindow(WINDOW_DIALOG_VIDEO_OSD);
if (pOSD)
{
if (pOSD->IsDialogRunning())
pOSD->Close();
else
pOSD->DoModal();
}
MarkDirtyRegion();
}
void CGUICheckMarkControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool changed = false;
changed |= m_imgCheckMark.Process(currentTime);
changed |= m_imgCheckMarkNoFocus.Process(currentTime);
changed |= m_label.Process(currentTime);
if (changed)
MarkDirtyRegion();
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIWindowPointer::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool active = CInputManager::Get().IsMouseActive();
if (active != m_active)
{
MarkDirtyRegion();
m_active = active;
}
MousePosition pos = CInputManager::Get().GetMousePosition();
SetPosition((float)pos.x, (float)pos.y);
SetPointer(CInputManager::Get().GetMouseState());
return CGUIWindow::Process(currentTime, dirtyregions);
}
bool CGUISpinControl::OnMouseOver(const CPoint &point)
{
int select = m_iSelect;
if (m_imgspinDownFocus.HitTest(point))
m_iSelect = SPIN_BUTTON_DOWN;
else
m_iSelect = SPIN_BUTTON_UP;
if (select != m_iSelect)
MarkDirtyRegion();
return CGUIControl::OnMouseOver(point);
}
void CGUISpinControl::OnRight()
{
if (m_iSelect == SPIN_BUTTON_DOWN)
{
// select the up button
m_iSelect = SPIN_BUTTON_UP;
MarkDirtyRegion();
}
else
{ // base class
CGUIControl::OnRight();
}
}
void CGUISpinControl::OnLeft()
{
if (m_iSelect == SPIN_BUTTON_UP)
{
// select the down button
m_iSelect = SPIN_BUTTON_DOWN;
MarkDirtyRegion();
}
else
{ // base class
CGUIControl::OnLeft();
}
}
void CGUIToggleButtonControl::ProcessToggle(unsigned int currentTime)
{
bool changed = false;
changed |= m_label.SetMaxRect(m_posX, m_posY, GetWidth(), m_height);
changed |= m_label.SetText(GetDescription());
changed |= m_label.SetColor(GetTextColor());
changed |= m_label.SetScrolling(HasFocus());
changed |= m_label.Process(currentTime);
if (changed)
MarkDirtyRegion();
}
void CGUIMoverControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (m_bInvalidated)
{
m_imgFocus.SetWidth(m_width);
m_imgFocus.SetHeight(m_height);
m_imgNoFocus.SetWidth(m_width);
m_imgNoFocus.SetHeight(m_height);
}
if (HasFocus())
{
unsigned int alphaCounter = m_frameCounter + 2;
unsigned int alphaChannel;
if ((alphaCounter % 128) >= 64)
alphaChannel = alphaCounter % 64;
else
alphaChannel = 63 - (alphaCounter % 64);
alphaChannel += 192;
if (SetAlpha( (unsigned char)alphaChannel ))
MarkDirtyRegion();
m_imgFocus.SetVisible(true);
m_imgNoFocus.SetVisible(false);
m_frameCounter++;
}
else
{
if (SetAlpha(0xff))
MarkDirtyRegion();
m_imgFocus.SetVisible(false);
m_imgNoFocus.SetVisible(true);
}
m_imgFocus.Process(currentTime);
m_imgNoFocus.Process(currentTime);
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIBorderedImage::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (!m_borderImage.GetFileName().IsEmpty() && m_texture.ReadyToRender())
{
CRect rect = CRect(m_texture.GetXPosition(), m_texture.GetYPosition(), m_texture.GetXPosition() + m_texture.GetWidth(), m_texture.GetYPosition() + m_texture.GetHeight());
rect.Intersect(m_texture.GetRenderRect());
m_borderImage.SetPosition(rect.x1 - m_borderSize.x1, rect.y1 - m_borderSize.y1);
m_borderImage.SetWidth(rect.Width() + m_borderSize.x1 + m_borderSize.x2);
m_borderImage.SetHeight(rect.Height() + m_borderSize.y1 + m_borderSize.y2);
m_borderImage.SetDiffuseColor(m_diffuseColor);
if (m_borderImage.Process(currentTime))
MarkDirtyRegion();
}
CGUIImage::Process(currentTime, dirtyregions);
}
void CGUISettingsSliderControl::ProcessText()
{
bool changed = false;
changed |= m_label.SetMaxRect(m_buttonControl.GetXPosition(), m_posY, m_posX - m_buttonControl.GetXPosition(), m_height);
changed |= m_label.SetText(CGUISliderControl::GetDescription());
if (IsDisabled())
changed |= m_label.SetColor(CGUILabel::COLOR_DISABLED);
else if (HasFocus())
changed |= m_label.SetColor(CGUILabel::COLOR_FOCUSED);
else
changed |= m_label.SetColor(CGUILabel::COLOR_TEXT);
if (changed)
MarkDirtyRegion();
}
void CGUIProgressControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool changed = false;
if (!IsDisabled())
changed |= UpdateLayout();
changed |= m_guiBackground.Process(currentTime);
changed |= m_guiMid.Process(currentTime);
changed |= m_guiLeft.Process(currentTime);
changed |= m_guiRight.Process(currentTime);
changed |= m_guiOverlay.Process(currentTime);
if (changed)
MarkDirtyRegion();
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIScrollBar::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool changed = false;
if (m_bInvalidated)
changed |= UpdateBarSize();
changed |= m_guiBackground.Process(currentTime);
changed |= m_guiBarNoFocus.Process(currentTime);
changed |= m_guiBarFocus.Process(currentTime);
changed |= m_guiNibNoFocus.Process(currentTime);
changed |= m_guiNibFocus.Process(currentTime);
if (changed)
MarkDirtyRegion();
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUISliderControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
bool dirty = false;
dirty |= m_guiBackground.SetPosition( m_posX, m_posY );
int infoCode = m_iInfoCode;
if (m_action && (!m_dragging || m_action->fireOnDrag))
infoCode = m_action->infoCode;
if (infoCode)
{
int val;
if (g_infoManager.GetInt(val, infoCode))
SetIntValue(val);
}
float fScaleY = m_height == 0 ? 1.0f : m_height / m_guiBackground.GetTextureHeight();
dirty |= m_guiBackground.SetHeight(m_height);
dirty |= m_guiBackground.SetWidth(m_width);
dirty |= m_guiBackground.Process(currentTime);
// we render the nib centered at the appropriate percentage, except where the nib
// would overflow the background image
CGUITexture &nib = (m_bHasFocus && !IsDisabled()) ? m_guiMidFocus : m_guiMid;
dirty |= nib.SetHeight(nib.GetTextureHeight() * fScaleY);
dirty |= nib.SetWidth(nib.GetHeight() * 2);
CAspectRatio ratio(CAspectRatio::AR_KEEP); ratio.align = ASPECT_ALIGN_LEFT | ASPECT_ALIGNY_CENTER;
dirty |= nib.SetAspectRatio(ratio);
CRect rect = nib.GetRenderRect();
float offset = GetProportion() * m_width - rect.Width() / 2;
if (offset > m_width - rect.Width())
offset = m_width - rect.Width();
if (offset < 0)
offset = 0;
dirty |= nib.SetPosition(m_guiBackground.GetXPosition() + offset, m_guiBackground.GetYPosition() );
dirty |= nib.Process(currentTime);
if (dirty)
MarkDirtyRegion();
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIButtonControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
ProcessText(currentTime);
if (m_bInvalidated)
{
m_imgFocus.SetWidth(GetWidth());
m_imgFocus.SetHeight(m_height);
m_imgNoFocus.SetWidth(GetWidth());
m_imgNoFocus.SetHeight(m_height);
}
if (HasFocus())
{
unsigned int alphaChannel = m_alpha;
if (m_pulseOnSelect)
{
unsigned int alphaCounter = m_focusCounter + 2;
if ((alphaCounter % 128) >= 64)
alphaChannel = alphaCounter % 64;
else
alphaChannel = 63 - (alphaCounter % 64);
alphaChannel += 192;
alphaChannel = (unsigned int)((float)m_alpha * (float)alphaChannel / 255.0f);
}
if (m_imgFocus.SetAlpha((unsigned char)alphaChannel))
MarkDirtyRegion();
m_imgFocus.SetVisible(true);
m_imgNoFocus.SetVisible(false);
m_focusCounter++;
}
else
{
m_imgFocus.SetVisible(false);
m_imgNoFocus.SetVisible(true);
}
m_imgFocus.Process(currentTime);
m_imgNoFocus.Process(currentTime);
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIButtonControl::ProcessText(unsigned int currentTime)
{
CRect labelRenderRect = m_label.GetRenderRect();
CRect label2RenderRect = m_label2.GetRenderRect();
float renderWidth = GetWidth();
bool changed = m_label.SetMaxRect(m_posX, m_posY, renderWidth, m_height);
changed |= m_label.SetText(m_info.GetLabel(m_parentID));
changed |= m_label.SetScrolling(HasFocus());
changed |= m_label2.SetMaxRect(m_posX, m_posY, renderWidth, m_height);
changed |= m_label2.SetText(m_info2.GetLabel(m_parentID));
// text changed - images need resizing
if (m_minWidth && (m_label.GetRenderRect() != labelRenderRect))
SetInvalid();
// auto-width - adjust hitrect
if (m_minWidth && m_width != renderWidth)
{
CRect rect(m_posX, m_posY, renderWidth, m_height);
SetHitRect(rect, m_hitColor);
}
// render the second label if it exists
if (!m_info2.GetLabel(m_parentID).empty())
{
changed |= m_label2.SetAlign(XBFONT_RIGHT | (m_label.GetLabelInfo().align & XBFONT_CENTER_Y) | XBFONT_TRUNCATED);
changed |= m_label2.SetScrolling(HasFocus());
// If overlapping was corrected - compare render rects to determine
// if they changed since last frame.
if (CGUILabel::CheckAndCorrectOverlap(m_label, m_label2))
changed |= (m_label.GetRenderRect() != labelRenderRect ||
m_label2.GetRenderRect() != label2RenderRect);
changed |= m_label2.SetColor(GetTextColor());
changed |= m_label2.Process(currentTime);
}
changed |= m_label.SetColor(GetTextColor());
changed |= m_label.Process(currentTime);
if (changed)
MarkDirtyRegion();
}
void CGUIRadioButtonControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (m_toggleSelect)
{
// ask our infoManager whether we are selected or not...
bool selected = g_infoManager.GetBoolValue(m_toggleSelect);
if (selected != m_bSelected)
{
MarkDirtyRegion();
m_bSelected = selected;
}
}
m_imgRadioOn.Process(currentTime);
m_imgRadioOff.Process(currentTime);
CGUIButtonControl::Process(currentTime, dirtyregions);
}
