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)
{
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);
}
// 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_scroller.GetValue());
else
g_graphicsContext.SetOrigin(m_posX + pos - m_scroller.GetValue(), m_posY);
control->DoProcess(currentTime, dirtyregions);
if (control->IsVisible())
pos += Size(control) + m_itemGap;
g_graphicsContext.RestoreOrigin();
}
CGUIControl::Process(currentTime, dirtyregions);
}
void CGUIListGroup::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
CServiceBroker::GetWinSystem()->GetGfxContext().SetOrigin(m_posX, m_posY);
CRect rect;
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
control->UpdateVisibility(m_item);
unsigned int oldDirty = dirtyregions.size();
control->DoProcess(currentTime, dirtyregions);
if (control->IsVisible() || (oldDirty != dirtyregions.size())) // visible or dirty (was visible?)
rect.Union(control->GetRenderRegion());
}
CServiceBroker::GetWinSystem()->GetGfxContext().RestoreOrigin();
CGUIControl::Process(currentTime, dirtyregions);
m_renderRegion = rect;
m_item = NULL;
}
void CGUIControlGroupList::UnfocusFromPoint(const CPoint &point)
{
float pos = 0;
CPoint controlCoords(point);
m_transform.InverseTransformPosition(controlCoords.x, controlCoords.y);
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *child = *it;
if (child->IsVisible())
{
if (pos + Size(child) > m_offset && pos < m_offset + Size())
{ // we're on screen
CPoint offset = (m_orientation == VERTICAL) ? CPoint(m_posX, m_posY + pos - m_offset) : CPoint(m_posX + pos - m_offset, m_posY);
child->UnfocusFromPoint(controlCoords - offset);
}
pos += Size(child) + m_itemGap;
}
}
CGUIControl::UnfocusFromPoint(point);
}
void CGUIControlGroup::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
CPoint pos(GetPosition());
g_graphicsContext.SetOrigin(pos.x, pos.y);
CRect rect;
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
control->UpdateVisibility();
unsigned int oldDirty = dirtyregions.size();
control->DoProcess(currentTime, dirtyregions);
if (control->IsVisible() || (oldDirty != dirtyregions.size())) // visible or dirty (was visible?)
rect.Union(control->GetRenderRegion());
}
g_graphicsContext.RestoreOrigin();
CGUIControl::Process(currentTime, dirtyregions);
m_renderRegion = rect;
}
void CGUIListGroup::EnlargeHeight(float difference)
{
// Alters the width of the controls that have an ID of 1
for (iControls it = m_children.begin(); it != m_children.end(); it++)
{
CGUIControl *child = *it;
if (child->GetID() >= 1 && child->GetID() <= 14)
{
if (child->GetID() == 1) // label
{
child->SetHeight(child->GetHeight() + difference);
child->SetVisible(child->GetHeight() > 10); ///
}
else
{
child->SetHeight(child->GetHeight() + difference);
}
}
}
SetInvalid();
}
void CGUIViewControl::UpdateViewVisibility()
{
// first reset our infomanager cache, as it's likely that the vis conditions
// used for views (i.e. based on contenttype) may have changed
CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager();
infoMgr.ResetCache();
infoMgr.GetInfoProviders().GetGUIControlsInfoProvider().ResetContainerMovingCache();
m_visibleViews.clear();
for (unsigned int i = 0; i < m_allViews.size(); i++)
{
CGUIControl *view = m_allViews[i];
if (view->HasVisibleCondition())
{
view->UpdateVisibility(nullptr);
if (view->IsVisibleFromSkin())
m_visibleViews.push_back(view);
}
else
m_visibleViews.push_back(view);
}
}
bool CGUIControlGroup::SendControlMessage(CGUIMessage &message)
{
// see if a child matches, and send to the child control if so
for (iControls it = m_children.begin();it != m_children.end(); ++it)
{
CGUIControl* control = *it;
if (control->HasVisibleID(message.GetControlId()))
{
if (control->OnMessage(message))
return true;
}
}
// Unhandled - send to all matching invisible controls as well
bool handled(false);
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl* control = *it;
if (control->HasID(message.GetControlId()))
{
if (control->OnMessage(message))
handled = true;
}
}
return handled;
}
void CGUIControllerWindow::DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
/*
* Apply the faded focus texture to the current controller when unfocused
*/
CGUIControl* control = nullptr; // The controller button
bool bAlphaFaded = false; // True if the controller button has been focused and faded this frame
if (m_controllerList && m_controllerList->GetFocusedController() >= 0)
{
control = GetFirstFocusableControl(CONTROL_CONTROLLER_BUTTONS_START + m_controllerList->GetFocusedController());
if (control && !control->HasFocus())
{
if (control->GetControlType() == CGUIControl::GUICONTROL_BUTTON)
{
control->SetFocus(true);
static_cast<CGUIButtonControl*>(control)->SetAlpha(0x80);
bAlphaFaded = true;
}
}
}
CGUIDialog::DoProcess(currentTime, dirtyregions);
if (control && bAlphaFaded)
{
control->SetFocus(false);
if (control->GetControlType() == CGUIControl::GUICONTROL_BUTTON)
static_cast<CGUIButtonControl*>(control)->SetAlpha(0xFF);
}
}
// returns true if the control group with id groupID has controlID as
// its focused control
bool CGUIWindow::ControlGroupHasFocus(int groupID, int controlID)
{
// 1. Run through and get control with groupID (assume unique)
// 2. Get it's selected item.
CGUIControl *group = GetFirstFocusableControl(groupID);
if (!group) group = (CGUIControl *)GetControl(groupID);
if (group && group->IsGroup())
{
if (controlID == 0)
{ // just want to know if the group is focused
return group->HasFocus();
}
else
{
CGUIMessage message(GUI_MSG_ITEM_SELECTED, GetID(), group->GetID());
group->OnMessage(message);
return (controlID == (int) message.GetParam1());
}
}
return false;
}
// OnMouseAction - called by OnAction()
EVENT_RESULT CGUIWindow::OnMouseAction(const CAction &action)
{
g_graphicsContext.SetScalingResolution(m_coordsRes, m_needsScaling);
CPoint mousePoint(action.GetAmount(0), action.GetAmount(1));
g_graphicsContext.InvertFinalCoords(mousePoint.x, mousePoint.y);
// create the mouse event
CMouseEvent event(action.GetID(), action.GetHoldTime(), action.GetAmount(2), action.GetAmount(3));
if (m_exclusiveMouseControl)
{
CGUIControl *child = (CGUIControl *)GetControl(m_exclusiveMouseControl);
if (child)
{
CPoint renderPos = child->GetRenderPosition() - CPoint(child->GetXPosition(), child->GetYPosition());
return child->OnMouseEvent(mousePoint - renderPos, event);
}
}
UnfocusFromPoint(mousePoint);
return SendMouseEvent(mousePoint, event);
}
bool CGUIPVRChannelGroupsSelector::Initialize(CGUIWindow* parent, bool bRadio)
{
CGUIControl* control = parent->GetControl(CONTROL_LSTCHANNELGROUPS);
if (control && control->IsContainer())
{
m_control = control;
m_channelGroups = CServiceBroker::GetPVRManager().ChannelGroups()->Get(bRadio)->GetMembers(true);
CFileItemList channelGroupItems;
for (const auto& group : m_channelGroups)
{
CFileItemPtr item(new CFileItem(group->GetPath(), true));
item->m_strTitle = group->GroupName();
item->SetLabel(group->GroupName());
channelGroupItems.Add(item);
}
CGUIMessage msg(GUI_MSG_LABEL_BIND, m_control->GetID(), CONTROL_LSTCHANNELGROUPS, 0, 0, &channelGroupItems);
m_control->OnMessage(msg);
return true;
}
return false;
}
CGUIControl* CGUIAddonWindow::GetAddonControl(int controlId, CGUIControl::GUICONTROLTYPES type, const std::string& typeName)
{
CGUIControl* pGUIControl = dynamic_cast<CGUIControl*>(GetControl(controlId));
if (!pGUIControl)
{
CLog::Log(LOGERROR, "CGUIAddonGUI_Window::%s: %s - Requested GUI control Id '%i' for '%s' not present!",
__FUNCTION__,
m_addon->Name().c_str(),
controlId, typeName.c_str());
return nullptr;
}
else if (pGUIControl->GetControlType() != type)
{
CLog::Log(LOGERROR, "CGUIAddonGUI_Window::%s: %s - Requested GUI control Id '%i' not the type '%s'!",
__FUNCTION__,
m_addon->Name().c_str(),
controlId, typeName.c_str());
return nullptr;
}
return pGUIControl;
}
bool CGUIDialogKeyboardGeneric::OnAction(const CAction &action)
{
bool handled(true);
if (action.GetID() == ACTION_BACKSPACE)
{
Backspace();
}
else if (action.GetID() == ACTION_ENTER)
{
OnOK();
}
else if (action.GetID() == ACTION_CURSOR_LEFT)
{
MoveCursor( -1);
}
else if (action.GetID() == ACTION_CURSOR_RIGHT)
{
MoveCursor(1);
}
else if (action.GetID() == ACTION_SHIFT)
{
OnShift();
}
else if (action.GetID() == ACTION_SYMBOLS)
{
OnSymbols();
}
else if (action.GetID() >= KEY_ASCII)
{ // send action to the edit control
CGUIControl *edit = GetControl(CTL_EDIT);
if (edit)
edit->OnAction(action);
}
else // unhandled by us - let's see if the baseclass wants it
handled = CGUIDialog::OnAction(action);
return handled;
}
void CGUIListItemLayout::LoadControl(TiXmlElement *child, CGUIControlGroup *group)
{
if (!group) return;
CRect rect(group->GetXPosition(), group->GetYPosition(), group->GetXPosition() + group->GetWidth(), group->GetYPosition() + group->GetHeight());
CGUIControlFactory factory;
CGUIControl *control = factory.Create(0, rect, child, true); // true indicating we're inside a list for the
// different label control + defaults.
if (control)
{
group->AddControl(control);
if (control->IsGroup())
{
TiXmlElement *grandChild = child->FirstChildElement("control");
while (grandChild)
{
LoadControl(grandChild, (CGUIControlGroup *)control);
grandChild = grandChild->NextSiblingElement("control");
}
}
}
}
void CGUIWindowSettingsScreenCalibration::DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
MarkDirtyRegion();
for (int i = CONTROL_TOP_LEFT; i <= CONTROL_PIXEL_RATIO; i++)
SET_CONTROL_HIDDEN(i);
m_needsScaling = true;
CGUIWindow::DoProcess(currentTime, dirtyregions);
m_needsScaling = false;
g_graphicsContext.SetRenderingResolution(m_Res[m_iCurRes], false);
g_graphicsContext.ResetWindowTransform();
// process the movers etc.
for (int i = CONTROL_TOP_LEFT; i <= CONTROL_PIXEL_RATIO; i++)
{
SET_CONTROL_VISIBLE(i);
CGUIControl *control = (CGUIControl *)GetControl(i);
if (control)
control->DoProcess(currentTime, dirtyregions);
}
}
EVENT_RESULT CGUIDialogMusicOverlay::OnMouseEvent(const CPoint &point, const CMouseEvent &event)
{
CGUIControl *pControl = GetControl(CONTROL_LOGO_PIC);
if (pControl && pControl->HitTest(point))
{
// send highlight message
CInputManager::Get().SetMouseState(MOUSE_STATE_FOCUS);
if (event.m_id == ACTION_MOUSE_LEFT_CLICK)
{ // send mouse message
CGUIMessage message(GUI_MSG_FULLSCREEN, CONTROL_LOGO_PIC, GetID());
g_windowManager.SendMessage(message);
}
if (event.m_id == ACTION_MOUSE_RIGHT_CLICK)
{ // toggle the playlist window
if (g_windowManager.GetActiveWindow() == WINDOW_MUSIC_PLAYLIST)
g_windowManager.PreviousWindow();
else
g_windowManager.ActivateWindow(WINDOW_MUSIC_PLAYLIST);
}
return EVENT_RESULT_HANDLED;
}
return EVENT_RESULT_UNHANDLED;
}
void CGUIWindowSettingsScreenCalibration::Render()
{
// g_graphicsContext.Get3DDevice()->Clear(0, NULL, D3DCLEAR_TARGET, 0, 0, 0);
m_iControl = GetFocusedControlID();
if (m_iControl >= 0)
{
UpdateFromControl(m_iControl);
}
else
{
SET_CONTROL_LABEL(CONTROL_LABEL_ROW1, "");
SET_CONTROL_LABEL(CONTROL_LABEL_ROW2, "");
}
SET_CONTROL_HIDDEN(CONTROL_TOP_LEFT);
SET_CONTROL_HIDDEN(CONTROL_BOTTOM_RIGHT);
SET_CONTROL_HIDDEN(CONTROL_SUBTITLES);
SET_CONTROL_HIDDEN(CONTROL_PIXEL_RATIO);
m_needsScaling = true;
CGUIWindow::Render();
g_graphicsContext.SetRenderingResolution(m_coordsRes, 0, 0, false);
SET_CONTROL_VISIBLE(CONTROL_TOP_LEFT);
SET_CONTROL_VISIBLE(CONTROL_BOTTOM_RIGHT);
SET_CONTROL_VISIBLE(CONTROL_SUBTITLES);
SET_CONTROL_VISIBLE(CONTROL_PIXEL_RATIO);
// render the movers etc.
for (int i = CONTROL_TOP_LEFT; i <= CONTROL_PIXEL_RATIO; i++)
{
CGUIControl *control = (CGUIControl *)GetControl(i);
if (control)
control->Render();
}
}
void CGUIViewControl::SelectVisibleView(int iViewIndex, CGUIControl *previousView, bool focusToVisibleView)
{
m_currentView = iViewIndex;
CGUIControl *pNewView = m_visibleViews[m_currentView];
// make only current control visible...
for (ciViews view = m_allViews.begin(); view != m_allViews.end(); view++)
(*view)->SetVisible(false);
pNewView->SetVisible(true);
if (focusToVisibleView)
{
// if requested -> set focus to the new view
CGUIMessage msg(GUI_MSG_SETFOCUS, m_parentWindow, pNewView->GetID(), 0);
g_windowManager.SendMessage(msg);
}
if (pNewView == previousView)
return; // no need to actually update anything (other than visibility above)
// CLog::Log(LOGDEBUG,"SetCurrentView: Oldview: %i, Newview :%i", m_currentView, viewMode);
int item = -1;
if (previousView)
{ // have an old view - let's clear it out and hide it.
item = GetSelectedItem(previousView);
CGUIMessage msg(GUI_MSG_LABEL_RESET, m_parentWindow, previousView->GetID());
previousView->OnMessage(msg);
}
// Update it with the contents
UpdateContents(pNewView, item, false);
// Update our view control
UpdateViewAsControl(((CGUIBaseContainer *)pNewView)->GetLabel());
}
void CGUIDialog::OnWindowLoaded()
{
CGUIWindow::OnWindowLoaded();
// Clip labels to extents
if (m_children.size())
{
CGUIControl* pBase = m_children[0];
for (iControls p = m_children.begin() + 1; p != m_children.end(); ++p)
{
if ((*p)->GetControlType() == CGUIControl::GUICONTROL_LABEL)
{
CGUILabelControl* pLabel = (CGUILabelControl*)(*p);
if (!pLabel->GetWidth())
{
float spacing = (pLabel->GetXPosition() - pBase->GetXPosition()) * 2;
pLabel->SetWidth(pBase->GetWidth() - spacing);
}
}
}
}
}
void CGUIDialogContextMenu::DoModal(int iWindowID /*= WINDOW_INVALID */, const CStdString ¶m)
{
// update the navigation of the first and last buttons
CGUIControl *pControl = (CGUIControl *)GetControl(BUTTON_TEMPLATE + 1);
if (pControl)
pControl->SetNavigation(BUTTON_TEMPLATE + m_iNumButtons, pControl->GetControlIdDown(), pControl->GetControlIdLeft(), pControl->GetControlIdRight());
pControl = (CGUIControl *)GetControl(BUTTON_TEMPLATE + m_iNumButtons);
if (pControl)
pControl->SetNavigation(pControl->GetControlIdUp(), BUTTON_TEMPLATE + 1, pControl->GetControlIdLeft(), pControl->GetControlIdRight());
// update our default control
if (m_defaultControl <= BUTTON_TEMPLATE || m_defaultControl > (BUTTON_TEMPLATE + m_iNumButtons))
m_defaultControl = BUTTON_TEMPLATE + 1;
// check the default control has focus...
while (m_defaultControl <= (BUTTON_TEMPLATE + m_iNumButtons) && !(GetControl(m_defaultControl)->CanFocus()))
m_defaultControl++;
CGUIDialog::DoModal();
}
void CGUIControlGroup::Render()
{
g_graphicsContext.SetOrigin(m_posX, m_posY);
CGUIControl *focusedControl = NULL;
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
control->UpdateVisibility();
if (m_renderFocusedLast && control->HasFocus())
focusedControl = control;
else
control->DoRender(m_renderTime);
}
if (focusedControl)
focusedControl->DoRender(m_renderTime);
CGUIControl::Render();
g_graphicsContext.RestoreOrigin();
}
void CGUIWindow::LoadControl(TiXmlElement* pControl, CGUIControlGroup *pGroup)
{
// get control type
CGUIControlFactory factory;
CRect rect(0, 0, (float)m_coordsRes.iWidth, (float)m_coordsRes.iHeight);
if (pGroup)
{
rect.x1 = pGroup->GetXPosition();
rect.y1 = pGroup->GetYPosition();
rect.x2 = rect.x1 + pGroup->GetWidth();
rect.y2 = rect.y1 + pGroup->GetHeight();
}
CGUIControl* pGUIControl = factory.Create(GetID(), rect, pControl);
if (pGUIControl)
{
float maxX = pGUIControl->GetXPosition() + pGUIControl->GetWidth();
if (maxX > m_width)
{
m_width = maxX;
}
float maxY = pGUIControl->GetYPosition() + pGUIControl->GetHeight();
if (maxY > m_height)
{
m_height = maxY;
}
// if we are in a group, add to the group, else add to our window
if (pGroup)
pGroup->AddControl(pGUIControl);
else
AddControl(pGUIControl);
// if the new control is a group, then add it's controls
if (pGUIControl->IsGroup())
{
TiXmlElement *pSubControl = pControl->FirstChildElement("control");
while (pSubControl)
{
LoadControl(pSubControl, (CGUIControlGroup *)pGUIControl);
pSubControl = pSubControl->NextSiblingElement("control");
}
}
}
}
void CGUIControlGroup::Render()
{
CPoint pos(GetPosition());
g_graphicsContext.SetOrigin(pos.x, pos.y);
CGUIControl *focusedControl = NULL;
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
GUIPROFILER_VISIBILITY_BEGIN(control);
control->UpdateVisibility();
GUIPROFILER_VISIBILITY_END(control);
if (m_renderFocusedLast && control->HasFocus())
focusedControl = control;
else
control->DoRender(m_renderTime);
}
if (focusedControl)
focusedControl->DoRender(m_renderTime);
CGUIControl::Render();
g_graphicsContext.RestoreOrigin();
}
void CGUIControlGroupList::Render()
{
// we run through the controls, rendering as we go
bool render(g_graphicsContext.SetClipRegion(m_posX, m_posY, m_width, m_height));
float pos = GetAlignOffset();
float focusedPos = 0;
CGUIControl *focusedControl = NULL;
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_renderFocusedLast && control->HasFocus())
{
focusedControl = control;
focusedPos = pos;
}
else
{
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->DoRender();
}
if (control->IsVisible())
pos += Size(control) + m_itemGap;
g_graphicsContext.RestoreOrigin();
}
if (focusedControl)
{
if (m_orientation == VERTICAL)
g_graphicsContext.SetOrigin(m_posX, m_posY + focusedPos - m_scroller.GetValue());
else
g_graphicsContext.SetOrigin(m_posX + focusedPos - m_scroller.GetValue(), m_posY);
focusedControl->DoRender();
}
if (render) g_graphicsContext.RestoreClipRegion();
CGUIControl::Render();
}
void CGUIWindow::LoadControl(TiXmlElement* pControl, CGUIControlGroup *pGroup, const CRect &rect)
{
// get control type
CGUIControlFactory factory;
CGUIControl* pGUIControl = factory.Create(GetID(), rect, pControl);
if (pGUIControl)
{
float maxX = pGUIControl->GetXPosition() + pGUIControl->GetWidth();
if (maxX > m_width)
{
m_width = maxX;
}
float maxY = pGUIControl->GetYPosition() + pGUIControl->GetHeight();
if (maxY > m_height)
{
m_height = maxY;
}
// if we are in a group, add to the group, else add to our window
if (pGroup)
pGroup->AddControl(pGUIControl);
else
AddControl(pGUIControl);
// if the new control is a group, then add it's controls
if (pGUIControl->IsGroup())
{
CGUIControlGroup *grp = (CGUIControlGroup *)pGUIControl;
TiXmlElement *pSubControl = pControl->FirstChildElement("control");
CRect grpRect(grp->GetXPosition(), grp->GetYPosition(),
grp->GetXPosition() + grp->GetWidth(), grp->GetYPosition() + grp->GetHeight());
while (pSubControl)
{
LoadControl(pSubControl, grp, grpRect);
pSubControl = pSubControl->NextSiblingElement("control");
}
}
}
}
void CGUIDialogContextMenu::SetupButtons()
{
if (!m_buttons.size())
return;
// disable the template button control
CGUIButtonControl *pButtonTemplate = (CGUIButtonControl *)GetFirstFocusableControl(BUTTON_TEMPLATE);
if (!pButtonTemplate) pButtonTemplate = (CGUIButtonControl *)GetControl(BUTTON_TEMPLATE);
if (!pButtonTemplate)
return;
pButtonTemplate->SetVisible(false);
CGUIControlGroupList* pGroupList = NULL;
{
const CGUIControl* pControl = GetControl(GROUP_LIST);
if (pControl && pControl->GetControlType() == GUICONTROL_GROUPLIST)
pGroupList = (CGUIControlGroupList*)pControl;
}
// add our buttons
for (unsigned int i = 0; i < m_buttons.size(); i++)
{
CGUIButtonControl *pButton = new CGUIButtonControl(*pButtonTemplate);
if (pButton)
{ // set the button's ID and position
int id = BUTTON_START + i;
pButton->SetID(id);
pButton->SetVisible(true);
pButton->SetLabel(m_buttons[i].second);
if (pGroupList)
{
pButton->SetPosition(pButtonTemplate->GetXPosition(), pButtonTemplate->GetYPosition());
pGroupList->AddControl(pButton);
}
#if PRE_SKIN_VERSION_11_COMPATIBILITY
else
{
pButton->SetPosition(pButtonTemplate->GetXPosition(), i*(pButtonTemplate->GetHeight() + SPACE_BETWEEN_BUTTONS));
pButton->SetNavigation(id - 1, id + 1, id, id);
AddControl(pButton);
}
#endif
}
}
CGUIControl *pControl = NULL;
#if PRE_SKIN_VERSION_11_COMPATIBILITY
if (!pGroupList)
{
// if we don't have grouplist update the navigation of the first and last buttons
pControl = (CGUIControl *)GetControl(BUTTON_START);
if (pControl)
pControl->SetNavigation(BUTTON_END, pControl->GetControlIdDown(), pControl->GetControlIdLeft(), pControl->GetControlIdRight());
pControl = (CGUIControl *)GetControl(BUTTON_END);
if (pControl)
pControl->SetNavigation(pControl->GetControlIdUp(), BUTTON_START, pControl->GetControlIdLeft(), pControl->GetControlIdRight());
}
#endif
// fix up background images placement and size
pControl = (CGUIControl *)GetControl(BACKGROUND_IMAGE);
if (pControl)
{
// first set size of background image
if (pGroupList)
{
if (pGroupList->GetOrientation() == VERTICAL)
{
// keep gap between bottom edges of grouplist and background image
pControl->SetHeight(pControl->GetHeight() - pGroupList->Size() + pGroupList->GetHeight());
}
else
{
// keep gap between right edges of grouplist and background image
pControl->SetWidth(pControl->GetWidth() - pGroupList->Size() + pGroupList->GetWidth());
}
}
#if PRE_SKIN_VERSION_11_COMPATIBILITY
else
pControl->SetHeight(m_buttons.size() * (pButtonTemplate->GetHeight() + SPACE_BETWEEN_BUTTONS));
if (pGroupList && pGroupList->GetOrientation() == HORIZONTAL)
{
// if there is grouplist control with horizontal orientation - adjust width of top and bottom background
CGUIControl* pControl2 = (CGUIControl *)GetControl(BACKGROUND_TOP);
if (pControl2)
pControl2->SetWidth(pControl->GetWidth());
pControl2 = (CGUIControl *)GetControl(BACKGROUND_BOTTOM);
if (pControl2)
pControl2->SetWidth(pControl->GetWidth());
}
else
{
// adjust position of bottom background
CGUIControl* pControl2 = (CGUIControl *)GetControl(BACKGROUND_BOTTOM);
if (pControl2)
pControl2->SetPosition(pControl2->GetXPosition(), pControl->GetYPosition() + pControl->GetHeight());
}
#endif
}
// update our default control
if (m_defaultControl < BUTTON_START || m_defaultControl > BUTTON_END)
m_defaultControl = BUTTON_START;
while (m_defaultControl <= BUTTON_END && !(GetControl(m_defaultControl)->CanFocus()))
m_defaultControl++;
}
void CGUIWindowSettingsScreenCalibration::UpdateFromControl(int iControl)
{
std::string strStatus;
RESOLUTION_INFO info = g_graphicsContext.GetResInfo(m_Res[m_iCurRes]);
if (iControl == CONTROL_PIXEL_RATIO)
{
CGUIControl *pControl = GetControl(CONTROL_PIXEL_RATIO);
if (pControl)
{
float fWidth = (float)pControl->GetWidth();
float fHeight = (float)pControl->GetHeight();
info.fPixelRatio = fHeight / fWidth;
// recenter our control...
pControl->SetPosition((info.iWidth - pControl->GetWidth()) / 2,
(info.iHeight - pControl->GetHeight()) / 2);
strStatus = StringUtils::Format("%s (%5.3f)", g_localizeStrings.Get(275).c_str(), info.fPixelRatio);
SET_CONTROL_LABEL(CONTROL_LABEL_ROW2, 278);
}
}
else
{
const CGUIMoverControl *pControl = dynamic_cast<const CGUIMoverControl*>(GetControl(iControl));
if (pControl)
{
switch (iControl)
{
case CONTROL_TOP_LEFT:
{
info.Overscan.left = pControl->GetXLocation();
info.Overscan.top = pControl->GetYLocation();
strStatus = StringUtils::Format("%s (%i,%i)", g_localizeStrings.Get(272).c_str(), pControl->GetXLocation(), pControl->GetYLocation());
SET_CONTROL_LABEL(CONTROL_LABEL_ROW2, 276);
}
break;
case CONTROL_BOTTOM_RIGHT:
{
info.Overscan.right = pControl->GetXLocation();
info.Overscan.bottom = pControl->GetYLocation();
int iXOff1 = info.iWidth - pControl->GetXLocation();
int iYOff1 = info.iHeight - pControl->GetYLocation();
strStatus = StringUtils::Format("%s (%i,%i)", g_localizeStrings.Get(273).c_str(), iXOff1, iYOff1);
SET_CONTROL_LABEL(CONTROL_LABEL_ROW2, 276);
}
break;
case CONTROL_SUBTITLES:
{
info.iSubtitles = pControl->GetYLocation();
strStatus = StringUtils::Format("%s (%i)", g_localizeStrings.Get(274).c_str(), pControl->GetYLocation());
SET_CONTROL_LABEL(CONTROL_LABEL_ROW2, 277);
}
break;
}
}
}
g_graphicsContext.SetResInfo(m_Res[m_iCurRes], info);
// set the label control correctly
std::string strText;
if (g_Windowing.IsFullScreen())
strText = StringUtils::Format("%ix%i@%.2f - %s | %s",
info.iScreenWidth,
info.iScreenHeight,
info.fRefreshRate,
g_localizeStrings.Get(244).c_str(),
strStatus.c_str());
else
strText = StringUtils::Format("%ix%i - %s | %s",
info.iScreenWidth,
info.iScreenHeight,
g_localizeStrings.Get(242).c_str(),
strStatus.c_str());
SET_CONTROL_LABEL(CONTROL_LABEL_ROW1, strText);
}
bool CGUIWindow::OnMessage(CGUIMessage& message)
{
switch ( message.GetMessage() )
{
case GUI_MSG_WINDOW_INIT:
{
CLog::Log(LOGDEBUG, "------ Window Init (%s) ------", GetProperty("xmlfile").c_str());
if (m_dynamicResourceAlloc || !m_bAllocated) AllocResources();
OnInitWindow();
return true;
}
break;
case GUI_MSG_WINDOW_DEINIT:
{
CLog::Log(LOGDEBUG, "------ Window Deinit (%s) ------", GetProperty("xmlfile").c_str());
OnDeinitWindow(message.GetParam1());
// now free the window
if (m_dynamicResourceAlloc) FreeResources();
return true;
}
break;
case GUI_MSG_CLICKED:
{
// a specific control was clicked
CLICK_EVENT clickEvent = m_mapClickEvents[ message.GetSenderId() ];
// determine if there are any handlers for this event
if (clickEvent.HasAHandler())
{
// fire the message to all handlers
clickEvent.Fire(message);
}
break;
}
case GUI_MSG_SELCHANGED:
{
// a selection within a specific control has changed
SELECTED_EVENT selectedEvent = m_mapSelectedEvents[ message.GetSenderId() ];
// determine if there are any handlers for this event
if (selectedEvent.HasAHandler())
{
// fire the message to all handlers
selectedEvent.Fire(message);
}
break;
}
case GUI_MSG_FOCUSED:
{ // a control has been focused
if (HasID(message.GetSenderId()))
{
m_focusedControl = message.GetControlId();
return true;
}
break;
}
case GUI_MSG_LOSTFOCUS:
{
// nothing to do at the window level when we lose focus
return true;
}
case GUI_MSG_MOVE:
{
if (HasID(message.GetSenderId()))
return OnMove(message.GetControlId(), message.GetParam1());
break;
}
case GUI_MSG_SETFOCUS:
{
// CLog::Log(LOGDEBUG,"set focus to control:%i window:%i (%i)\n", message.GetControlId(),message.GetSenderId(), GetID());
if ( message.GetControlId() )
{
// first unfocus the current control
CGUIControl *control = GetFocusedControl();
if (control)
{
CGUIMessage msgLostFocus(GUI_MSG_LOSTFOCUS, GetID(), control->GetID(), message.GetControlId());
control->OnMessage(msgLostFocus);
}
// get the control to focus
CGUIControl* pFocusedControl = GetFirstFocusableControl(message.GetControlId());
if (!pFocusedControl) pFocusedControl = (CGUIControl *)GetControl(message.GetControlId());
// and focus it
if (pFocusedControl)
return pFocusedControl->OnMessage(message);
}
return true;
}
break;
case GUI_MSG_EXCLUSIVE_MOUSE:
{
m_exclusiveMouseControl = message.GetSenderId();
return true;
}
break;
case GUI_MSG_GESTURE_NOTIFY:
{
CAction action(ACTION_GESTURE_NOTIFY, 0, (float)message.GetParam1(), (float)message.GetParam2(), 0, 0);
EVENT_RESULT result = OnMouseAction(action);
message.SetParam1(result);
return result != EVENT_RESULT_UNHANDLED;
}
case GUI_MSG_ADD_CONTROL:
{
if (message.GetPointer())
{
CGUIControl *control = (CGUIControl *)message.GetPointer();
control->AllocResources();
AddControl(control);
}
return true;
}
case GUI_MSG_REMOVE_CONTROL:
{
if (message.GetPointer())
{
CGUIControl *control = (CGUIControl *)message.GetPointer();
RemoveControl(control);
control->FreeResources(true);
delete control;
}
return true;
}
case GUI_MSG_NOTIFY_ALL:
{
// only process those notifications that come from this window, or those intended for every window
if (HasID(message.GetSenderId()) || !message.GetSenderId())
{
if (message.GetParam1() == GUI_MSG_PAGE_CHANGE ||
message.GetParam1() == GUI_MSG_REFRESH_THUMBS ||
message.GetParam1() == GUI_MSG_REFRESH_LIST ||
message.GetParam1() == GUI_MSG_WINDOW_RESIZE)
{ // alter the message accordingly, and send to all controls
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIControl *control = *it;
CGUIMessage msg(message.GetParam1(), message.GetControlId(), control->GetID(), message.GetParam2());
control->OnMessage(msg);
}
}
}
}
break;
}
return SendControlMessage(message);
}
bool CGUIControlGroup::OnMessage(CGUIMessage& message)
{
switch (message.GetMessage() )
{
case GUI_MSG_ITEM_SELECT:
{
if (message.GetControlId() == GetID())
{
m_focusedControl = message.GetParam1();
return true;
}
break;
}
case GUI_MSG_ITEM_SELECTED:
{
if (message.GetControlId() == GetID())
{
message.SetParam1(m_focusedControl);
return true;
}
break;
}
case GUI_MSG_FOCUSED:
{ // a control has been focused
m_focusedControl = message.GetControlId();
SetFocus(true);
// tell our parent thatwe have focus
if (m_parentControl)
m_parentControl->OnMessage(message);
return true;
}
case GUI_MSG_SETFOCUS:
{
// first try our last focused control...
if (!m_defaultAlways && m_focusedControl)
{
CGUIControl *control = GetFirstFocusableControl(m_focusedControl);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
}
// ok, no previously focused control, try the default control first
if (m_defaultControl)
{
CGUIControl *control = GetFirstFocusableControl(m_defaultControl);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
}
// no success with the default control, so just find one to focus
CGUIControl *control = GetFirstFocusableControl(0);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
// unsuccessful
return false;
break;
}
case GUI_MSG_LOSTFOCUS:
{
// set all subcontrols unfocused
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
(*it)->SetFocus(false);
if (!HasID(message.GetParam1()))
{ // we don't have the new id, so unfocus
SetFocus(false);
if (m_parentControl)
m_parentControl->OnMessage(message);
}
return true;
}
break;
case GUI_MSG_PAGE_CHANGE:
case GUI_MSG_REFRESH_THUMBS:
case GUI_MSG_REFRESH_LIST:
case GUI_MSG_WINDOW_RESIZE:
{ // send to all child controls (make sure the target is the control id)
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIMessage msg(message.GetMessage(), message.GetSenderId(), (*it)->GetID(), message.GetParam1());
(*it)->OnMessage(msg);
}
return true;
}
break;
}
bool handled(false);
//not intented for any specific control, send to all childs and our base handler.
if (message.GetControlId() == 0)
{
for (iControls it = m_children.begin();it != m_children.end(); ++it)
{
CGUIControl* control = *it;
handled |= control->OnMessage(message);
}
return CGUIControl::OnMessage(message) || handled;
}
// if it's intended for us, then so be it
if (message.GetControlId() == GetID())
return CGUIControl::OnMessage(message);
return SendControlMessage(message);
}
void CGUIControlGroupList::AddControl(CGUIControl *control, int position /*= -1*/)
{
// NOTE: We override control navigation here, but we don't override the <onleft> etc. builtins
// if specified.
if (position < 0 || position > (int)m_children.size()) // add at the end
position = (int)m_children.size();
if (control)
{ // set the navigation of items so that they form a list
CGUIAction beforeAction = GetAction((m_orientation == VERTICAL) ? ACTION_MOVE_UP : ACTION_MOVE_LEFT);
CGUIAction afterAction = GetAction((m_orientation == VERTICAL) ? ACTION_MOVE_DOWN : ACTION_MOVE_RIGHT);
if (m_children.size())
{
// we're inserting at the given position, so grab the items above and below and alter
// their navigation accordingly
CGUIControl *before = NULL;
CGUIControl *after = NULL;
if (position == 0)
{ // inserting at the beginning
after = m_children[0];
if (!afterAction.HasActionsMeetingCondition() || afterAction.GetNavigation() == GetID()) // we're wrapping around bottom->top, so we have to update the last item
before = m_children[m_children.size() - 1];
if (!beforeAction.HasActionsMeetingCondition() || beforeAction.GetNavigation() == GetID()) // we're wrapping around top->bottom
beforeAction = CGUIAction(m_children[m_children.size() - 1]->GetID());
afterAction = CGUIAction(after->GetID());
}
else if (position == (int)m_children.size())
{ // inserting at the end
before = m_children[m_children.size() - 1];
if (!beforeAction.HasActionsMeetingCondition() || beforeAction.GetNavigation() == GetID()) // we're wrapping around top->bottom, so we have to update the first item
after = m_children[0];
if (!afterAction.HasActionsMeetingCondition() || afterAction.GetNavigation() == GetID()) // we're wrapping around bottom->top
afterAction = CGUIAction(m_children[0]->GetID());
beforeAction = CGUIAction(before->GetID());
}
else
{ // inserting somewhere in the middle
before = m_children[position - 1];
after = m_children[position];
beforeAction = CGUIAction(before->GetID());
afterAction = CGUIAction(after->GetID());
}
if (m_orientation == VERTICAL)
{
if (before) // update the DOWN action to point to us
before->SetAction(ACTION_MOVE_DOWN, CGUIAction(control->GetID()));
if (after) // update the UP action to point to us
after->SetAction(ACTION_MOVE_UP, CGUIAction(control->GetID()));
}
else
{
if (before) // update the RIGHT action to point to us
before->SetAction(ACTION_MOVE_RIGHT, CGUIAction(control->GetID()));
if (after) // update the LEFT action to point to us
after->SetAction(ACTION_MOVE_LEFT, CGUIAction(control->GetID()));
}
}
// now the control's nav
// set navigation path on orientation axis
// and try to apply other nav actions from grouplist
// don't override them if child have already defined actions
if (m_orientation == VERTICAL)
{
control->SetAction(ACTION_MOVE_UP, beforeAction);
control->SetAction(ACTION_MOVE_DOWN, afterAction);
control->SetAction(ACTION_MOVE_LEFT, GetAction(ACTION_MOVE_LEFT), false);
control->SetAction(ACTION_MOVE_RIGHT, GetAction(ACTION_MOVE_RIGHT), false);
}
else
{
control->SetAction(ACTION_MOVE_LEFT, beforeAction);
control->SetAction(ACTION_MOVE_RIGHT, afterAction);
control->SetAction(ACTION_MOVE_UP, GetAction(ACTION_MOVE_UP), false);
control->SetAction(ACTION_MOVE_DOWN, GetAction(ACTION_MOVE_DOWN), false);
}
control->SetAction(ACTION_NAV_BACK, GetAction(ACTION_NAV_BACK), false);
if (!m_useControlPositions)
control->SetPosition(0,0);
CGUIControlGroup::AddControl(control, position);
m_totalSize = GetTotalSize();
}
}