Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1078 insertions, 0 deletions

diff --git a/xbmc/guilib/GUISpinControl.cpp b/xbmc/guilib/GUISpinControl.cpp
new file mode 100644
index 0000000..f0a0f39
--- /dev/null
+++ b/xbmc/guilib/GUISpinControl.cpp
@@ -0,0 +1,1078 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUISpinControl.h"
+
+#include "GUIMessage.h"
+#include "input/Key.h"
+#include "utils/StringUtils.h"
+
+#include <stdio.h>
+
+#define SPIN_BUTTON_DOWN 1
+#define SPIN_BUTTON_UP   2
+
+namespace
+{
+// Additional space between text and spin buttons
+constexpr float TEXT_SPACE = 5.0f;
+} // unnamed namespace
+
+CGUISpinControl::CGUISpinControl(int parentID,
+                                 int controlID,
+                                 float posX,
+                                 float posY,
+                                 float width,
+                                 float height,
+                                 const CTextureInfo& textureUp,
+                                 const CTextureInfo& textureDown,
+                                 const CTextureInfo& textureUpFocus,
+                                 const CTextureInfo& textureDownFocus,
+                                 const CTextureInfo& textureUpDisabled,
+                                 const CTextureInfo& textureDownDisabled,
+                                 const CLabelInfo& labelInfo,
+                                 int iType)
+  : CGUIControl(parentID, controlID, posX, posY, width, height),
+    m_imgspinUp(CGUITexture::CreateTexture(posX, posY, width, height, textureUp)),
+    m_imgspinDown(CGUITexture::CreateTexture(posX, posY, width, height, textureDown)),
+    m_imgspinUpFocus(CGUITexture::CreateTexture(posX, posY, width, height, textureUpFocus)),
+    m_imgspinDownFocus(CGUITexture::CreateTexture(posX, posY, width, height, textureDownFocus)),
+    m_imgspinUpDisabled(CGUITexture::CreateTexture(posX, posY, width, height, textureUpDisabled)),
+    m_imgspinDownDisabled(
+        CGUITexture::CreateTexture(posX, posY, width, height, textureDownDisabled)),
+    m_label(posX, posY, width, height, labelInfo)
+{
+  m_bReverse = false;
+  m_iStart = 0;
+  m_iEnd = 100;
+  m_fStart = 0.0f;
+  m_fEnd = 1.0f;
+  m_fInterval = 0.1f;
+  m_iValue = 0;
+  m_fValue = 0.0;
+  m_iType = iType;
+  m_iSelect = SPIN_BUTTON_DOWN;
+  m_bShowRange = false;
+  m_iTypedPos = 0;
+  strcpy(m_szTyped, "");
+  ControlType = GUICONTROL_SPIN;
+  m_currentItem = 0;
+  m_numItems = 10;
+  m_itemsPerPage = 10;
+  m_showOnePage = true;
+}
+
+CGUISpinControl::CGUISpinControl(const CGUISpinControl& control)
+  : CGUIControl(control),
+    m_iStart(control.m_iStart),
+    m_iEnd(control.m_iEnd),
+    m_fStart(control.m_fStart),
+    m_fEnd(control.m_fEnd),
+    m_iValue(control.m_iValue),
+    m_fValue(control.m_fValue),
+    m_iType(control.m_iType),
+    m_iSelect(control.m_iSelect),
+    m_bReverse(control.m_bReverse),
+    m_fInterval(control.m_fInterval),
+    m_vecLabels(control.m_vecLabels),
+    m_vecValues(control.m_vecValues),
+    m_vecStrValues(control.m_vecStrValues),
+    m_imgspinUp(control.m_imgspinUp->Clone()),
+    m_imgspinDown(control.m_imgspinDown->Clone()),
+    m_imgspinUpFocus(control.m_imgspinUpFocus->Clone()),
+    m_imgspinDownFocus(control.m_imgspinDownFocus->Clone()),
+    m_imgspinUpDisabled(control.m_imgspinUpDisabled->Clone()),
+    m_imgspinDownDisabled(control.m_imgspinDownDisabled->Clone()),
+    m_label(control.m_label),
+    m_bShowRange(control.m_bShowRange),
+    m_iTypedPos(control.m_iTypedPos),
+    m_currentItem(control.m_currentItem),
+    m_itemsPerPage(control.m_itemsPerPage),
+    m_numItems(control.m_numItems),
+    m_showOnePage(control.m_showOnePage)
+{
+  std::strcpy(m_szTyped, control.m_szTyped);
+}
+
+bool CGUISpinControl::OnAction(const CAction &action)
+{
+  switch (action.GetID())
+  {
+  case REMOTE_0:
+  case REMOTE_1:
+  case REMOTE_2:
+  case REMOTE_3:
+  case REMOTE_4:
+  case REMOTE_5:
+  case REMOTE_6:
+  case REMOTE_7:
+  case REMOTE_8:
+  case REMOTE_9:
+    {
+      if (strlen(m_szTyped) >= 3)
+      {
+        m_iTypedPos = 0;
+        strcpy(m_szTyped, "");
+      }
+      int iNumber = action.GetID() - REMOTE_0;
+
+      m_szTyped[m_iTypedPos] = iNumber + '0';
+      m_iTypedPos++;
+      m_szTyped[m_iTypedPos] = 0;
+      int iValue;
+      sscanf(m_szTyped, "%i", &iValue);
+      switch (m_iType)
+      {
+      case SPIN_CONTROL_TYPE_INT:
+        {
+          if (iValue < m_iStart || iValue > m_iEnd)
+          {
+            m_iTypedPos = 0;
+            m_szTyped[m_iTypedPos] = iNumber + '0';
+            m_iTypedPos++;
+            m_szTyped[m_iTypedPos] = 0;
+            sscanf(m_szTyped, "%i", &iValue);
+            if (iValue < m_iStart || iValue > m_iEnd)
+            {
+              m_iTypedPos = 0;
+              strcpy(m_szTyped, "");
+              return true;
+            }
+          }
+          m_iValue = iValue;
+          CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+          SendWindowMessage(msg);
+        }
+        break;
+
+      case SPIN_CONTROL_TYPE_TEXT:
+        {
+          if (iValue < 0 || iValue >= (int)m_vecLabels.size())
+          {
+            m_iTypedPos = 0;
+            m_szTyped[m_iTypedPos] = iNumber + '0';
+            m_iTypedPos++;
+            m_szTyped[m_iTypedPos] = 0;
+            sscanf(m_szTyped, "%i", &iValue);
+            if (iValue < 0 || iValue >= (int)m_vecLabels.size())
+            {
+              m_iTypedPos = 0;
+              strcpy(m_szTyped, "");
+              return true;
+            }
+          }
+          m_iValue = iValue;
+          CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+          SendWindowMessage(msg);
+        }
+        break;
+
+      }
+      return true;
+    }
+    break;
+  case ACTION_PAGE_UP:
+    if (!m_bReverse)
+      PageDown();
+    else
+      PageUp();
+    return true;
+    break;
+  case ACTION_PAGE_DOWN:
+    if (!m_bReverse)
+      PageUp();
+    else
+      PageDown();
+    return true;
+    break;
+  case ACTION_SELECT_ITEM:
+    if (m_iSelect == SPIN_BUTTON_UP)
+    {
+      MoveUp();
+      return true;
+    }
+    if (m_iSelect == SPIN_BUTTON_DOWN)
+    {
+      MoveDown();
+      return true;
+    }
+    break;
+  }
+/*  static float m_fSmoothScrollOffset = 0.0f;
+  if (action.GetID() == ACTION_SCROLL_UP)
+  {
+    m_fSmoothScrollOffset += action.GetAmount() * action.GetAmount();
+    bool handled = false;
+    while (m_fSmoothScrollOffset > 0.4)
+    {
+      handled = true;
+      m_fSmoothScrollOffset -= 0.4f;
+      MoveDown();
+    }
+    return handled;
+  }*/
+  return CGUIControl::OnAction(action);
+}
+
+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 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::Clear()
+{
+  m_vecLabels.clear();
+  m_vecValues.clear();
+  m_vecStrValues.clear();
+  SetValue(0);
+}
+
+bool CGUISpinControl::OnMessage(CGUIMessage& message)
+{
+  if (CGUIControl::OnMessage(message) )
+    return true;
+  if (message.GetControlId() == GetID() )
+  {
+    switch (message.GetMessage())
+    {
+    case GUI_MSG_ITEM_SELECT:
+      if (SPIN_CONTROL_TYPE_PAGE == m_iType)
+      {
+        m_currentItem = message.GetParam1();
+        return true;
+      }
+      SetValue( message.GetParam1());
+      if (message.GetParam2() == SPIN_BUTTON_DOWN || message.GetParam2() == SPIN_BUTTON_UP)
+        m_iSelect = message.GetParam2();
+      return true;
+      break;
+
+    case GUI_MSG_LABEL_RESET:
+      if (SPIN_CONTROL_TYPE_PAGE == m_iType)
+      {
+        m_itemsPerPage = message.GetParam1();
+        m_numItems = message.GetParam2();
+        return true;
+      }
+      {
+        Clear();
+        return true;
+      }
+      break;
+
+    case GUI_MSG_SHOWRANGE:
+      if (message.GetParam1() )
+        m_bShowRange = true;
+      else
+        m_bShowRange = false;
+      break;
+
+    case GUI_MSG_SET_LABELS:
+      if (message.GetPointer())
+      {
+        auto labels =
+            static_cast<const std::vector<std::pair<std::string, int>>*>(message.GetPointer());
+        Clear();
+        for (const auto& i : *labels)
+          AddLabel(i.first, i.second);
+        SetValue( message.GetParam1());
+      }
+      break;
+
+    case GUI_MSG_LABEL_ADD:
+      {
+        AddLabel(message.GetLabel(), message.GetParam1());
+        return true;
+      }
+      break;
+
+    case GUI_MSG_ITEM_SELECTED:
+      {
+        message.SetParam1( GetValue() );
+        message.SetParam2(m_iSelect);
+
+        if (m_iType == SPIN_CONTROL_TYPE_TEXT)
+        {
+          if ( m_iValue >= 0 && m_iValue < (int)m_vecLabels.size() )
+            message.SetLabel( m_vecLabels[m_iValue]);
+        }
+        return true;
+      }
+
+    case GUI_MSG_PAGE_UP:
+      if (CanMoveUp())
+        MoveUp();
+      return true;
+
+    case GUI_MSG_PAGE_DOWN:
+      if (CanMoveDown())
+        MoveDown();
+      return true;
+
+    case GUI_MSG_MOVE_OFFSET:
+      {
+        int count = message.GetParam1();
+        while (count < 0)
+        {
+          MoveUp();
+          count++;
+        }
+        while (count > 0)
+        {
+          MoveDown();
+          count--;
+        }
+        return true;
+      }
+
+    }
+  }
+  return false;
+}
+
+void CGUISpinControl::AllocResources()
+{
+  CGUIControl::AllocResources();
+  m_imgspinUp->AllocResources();
+  m_imgspinUpFocus->AllocResources();
+  m_imgspinDown->AllocResources();
+  m_imgspinDownFocus->AllocResources();
+  m_imgspinUpDisabled->AllocResources();
+  m_imgspinDownDisabled->AllocResources();
+
+  m_imgspinDownFocus->SetPosition(m_posX, m_posY);
+  m_imgspinDown->SetPosition(m_posX, m_posY);
+  m_imgspinDownDisabled->SetPosition(m_posX, m_posY);
+  m_imgspinUp->SetPosition(m_posX + m_imgspinDown->GetWidth(), m_posY);
+  m_imgspinUpFocus->SetPosition(m_posX + m_imgspinDownFocus->GetWidth(), m_posY);
+  m_imgspinUpDisabled->SetPosition(m_posX + m_imgspinDownDisabled->GetWidth(), m_posY);
+}
+
+void CGUISpinControl::FreeResources(bool immediately)
+{
+  CGUIControl::FreeResources(immediately);
+  m_imgspinUp->FreeResources(immediately);
+  m_imgspinUpFocus->FreeResources(immediately);
+  m_imgspinDown->FreeResources(immediately);
+  m_imgspinDownFocus->FreeResources(immediately);
+  m_imgspinUpDisabled->FreeResources(immediately);
+  m_imgspinDownDisabled->FreeResources(immediately);
+  m_iTypedPos = 0;
+  strcpy(m_szTyped, "");
+}
+
+void CGUISpinControl::DynamicResourceAlloc(bool bOnOff)
+{
+  CGUIControl::DynamicResourceAlloc(bOnOff);
+  m_imgspinUp->DynamicResourceAlloc(bOnOff);
+  m_imgspinUpFocus->DynamicResourceAlloc(bOnOff);
+  m_imgspinDown->DynamicResourceAlloc(bOnOff);
+  m_imgspinDownFocus->DynamicResourceAlloc(bOnOff);
+  m_imgspinUpDisabled->DynamicResourceAlloc(bOnOff);
+  m_imgspinDownDisabled->DynamicResourceAlloc(bOnOff);
+}
+
+void CGUISpinControl::SetInvalid()
+{
+  CGUIControl::SetInvalid();
+  m_label.SetInvalid();
+  m_imgspinUp->SetInvalid();
+  m_imgspinUpFocus->SetInvalid();
+  m_imgspinDown->SetInvalid();
+  m_imgspinDownFocus->SetInvalid();
+  m_imgspinUpDisabled->SetInvalid();
+  m_imgspinDownDisabled->SetInvalid();
+}
+
+void CGUISpinControl::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
+{
+  bool changed = false;
+
+  if (!HasFocus())
+  {
+    m_iTypedPos = 0;
+    strcpy(m_szTyped, "");
+  }
+
+  std::string text;
+
+  if (m_iType == SPIN_CONTROL_TYPE_INT)
+  {
+    if (m_bShowRange)
+    {
+      text = StringUtils::Format("{}/{}", m_iValue, m_iEnd);
+    }
+    else
+    {
+      text = std::to_string(m_iValue);
+    }
+  }
+  else if (m_iType == SPIN_CONTROL_TYPE_PAGE)
+  {
+    // work out number of pages and current page
+    int numPages = (m_numItems + m_itemsPerPage - 1) / m_itemsPerPage;
+    int currentPage = m_currentItem / m_itemsPerPage + 1;
+    if (m_currentItem >= m_numItems - m_itemsPerPage)
+      currentPage = numPages;
+    text = StringUtils::Format("{}/{}", currentPage, numPages);
+  }
+  else if (m_iType == SPIN_CONTROL_TYPE_FLOAT)
+  {
+    if (m_bShowRange)
+    {
+      text = StringUtils::Format("{:02.2f}/{:02.2f}", m_fValue, m_fEnd);
+    }
+    else
+    {
+      text = StringUtils::Format("{:02.2f}", m_fValue);
+    }
+  }
+  else
+  {
+    if (m_iValue >= 0 && m_iValue < (int)m_vecLabels.size() )
+    {
+      if (m_bShowRange)
+      {
+        text = StringUtils::Format("({}/{}) {}", m_iValue + 1, (int)m_vecLabels.size(),
+                                   m_vecLabels[m_iValue]);
+      }
+      else
+      {
+        text = m_vecLabels[m_iValue];
+      }
+    }
+    else
+      text = StringUtils::Format("?{}?", m_iValue);
+  }
+
+  changed |= m_label.SetText(text);
+
+  float textWidth = m_label.GetTextWidth() + 2 * m_label.GetLabelInfo().offsetX;
+  // Position the arrows
+  bool arrowsOnRight(0 != (m_label.GetLabelInfo().align & (XBFONT_RIGHT | XBFONT_CENTER_X)));
+  if (!arrowsOnRight)
+  {
+    changed |= m_imgspinDownFocus->SetPosition(m_posX + textWidth + TEXT_SPACE, m_posY);
+    changed |= m_imgspinDown->SetPosition(m_posX + textWidth + TEXT_SPACE, m_posY);
+    changed |= m_imgspinDownDisabled->SetPosition(m_posX + textWidth + TEXT_SPACE, m_posY);
+    changed |= m_imgspinUpFocus->SetPosition(
+        m_posX + textWidth + TEXT_SPACE + m_imgspinDown->GetWidth(), m_posY);
+    changed |= m_imgspinUp->SetPosition(m_posX + textWidth + TEXT_SPACE + m_imgspinDown->GetWidth(),
+                                        m_posY);
+    changed |= m_imgspinUpDisabled->SetPosition(
+        m_posX + textWidth + TEXT_SPACE + m_imgspinDownDisabled->GetWidth(), m_posY);
+  }
+
+  changed |= m_imgspinDownFocus->Process(currentTime);
+  changed |= m_imgspinDown->Process(currentTime);
+  changed |= m_imgspinUp->Process(currentTime);
+  changed |= m_imgspinUpFocus->Process(currentTime);
+  changed |= m_imgspinUpDisabled->Process(currentTime);
+  changed |= m_imgspinDownDisabled->Process(currentTime);
+  changed |= m_label.Process(currentTime);
+
+  if (changed)
+    MarkDirtyRegion();
+
+  CGUIControl::Process(currentTime, dirtyregions);
+}
+
+void CGUISpinControl::Render()
+{
+  if (m_label.GetLabelInfo().font)
+  {
+    float textWidth = m_label.GetTextWidth() + 2 * m_label.GetLabelInfo().offsetX;
+    // Position the arrows
+    bool arrowsOnRight(0 != (m_label.GetLabelInfo().align & (XBFONT_RIGHT | XBFONT_CENTER_X)));
+
+    if (arrowsOnRight)
+      RenderText(m_posX - TEXT_SPACE - textWidth, m_posY, textWidth, m_height);
+    else
+      RenderText(m_posX + m_imgspinDown->GetWidth() + m_imgspinUp->GetWidth() + TEXT_SPACE, m_posY,
+                 textWidth, m_height);
+
+    // set our hit rectangle for MouseOver events
+    m_hitRect = m_label.GetRenderRect();
+  }
+
+  if (HasFocus())
+  {
+    if (m_iSelect == SPIN_BUTTON_UP)
+      m_imgspinUpFocus->Render();
+    else
+      m_imgspinUp->Render();
+
+    if (m_iSelect == SPIN_BUTTON_DOWN)
+      m_imgspinDownFocus->Render();
+    else
+      m_imgspinDown->Render();
+  }
+  else if (!HasFocus() && !IsDisabled())
+  {
+    m_imgspinUp->Render();
+    m_imgspinDown->Render();
+  }
+  else
+  {
+    m_imgspinUpDisabled->Render();
+    m_imgspinDownDisabled->Render();
+  }
+
+  CGUIControl::Render();
+}
+
+void CGUISpinControl::RenderText(float posX, float posY, float width, float height)
+{
+  m_label.SetMaxRect(posX, posY, width, height);
+  m_label.SetColor(GetTextColor());
+  m_label.Render();
+}
+
+CGUILabel::COLOR CGUISpinControl::GetTextColor() const
+{
+  if (IsDisabled())
+    return CGUILabel::COLOR_DISABLED;
+  else if (HasFocus())
+    return CGUILabel::COLOR_FOCUSED;
+  return CGUILabel::COLOR_TEXT;
+}
+
+void CGUISpinControl::SetRange(int iStart, int iEnd)
+{
+  m_iStart = iStart;
+  m_iEnd = iEnd;
+}
+
+void CGUISpinControl::SetFloatRange(float fStart, float fEnd)
+{
+  m_fStart = fStart;
+  m_fEnd = fEnd;
+}
+
+void CGUISpinControl::SetValueFromLabel(const std::string &label)
+{
+  if (m_iType == SPIN_CONTROL_TYPE_TEXT)
+  {
+    m_iValue = 0;
+    for (unsigned int i = 0; i < m_vecLabels.size(); i++)
+      if (label == m_vecLabels[i])
+        m_iValue = i;
+  }
+  else
+    m_iValue = atoi(label.c_str());
+
+  MarkDirtyRegion();
+  SetInvalid();
+}
+
+void CGUISpinControl::SetValue(int iValue)
+{
+  if (m_iType == SPIN_CONTROL_TYPE_TEXT)
+  {
+    m_iValue = 0;
+    for (unsigned int i = 0; i < m_vecValues.size(); i++)
+      if (iValue == m_vecValues[i])
+        m_iValue = i;
+  }
+  else
+    m_iValue = iValue;
+
+  MarkDirtyRegion();
+  SetInvalid();
+}
+
+void CGUISpinControl::SetFloatValue(float fValue)
+{
+  m_fValue = fValue;
+}
+
+void CGUISpinControl::SetStringValue(const std::string& strValue)
+{
+  if (m_iType == SPIN_CONTROL_TYPE_TEXT)
+  {
+    m_iValue = 0;
+    for (unsigned int i = 0; i < m_vecStrValues.size(); i++)
+      if (strValue == m_vecStrValues[i])
+        m_iValue = i;
+  }
+
+  SetInvalid();
+}
+
+int CGUISpinControl::GetValue() const
+{
+  if (m_iType == SPIN_CONTROL_TYPE_TEXT)
+  {
+    if (m_iValue >= 0 && m_iValue < (int)m_vecValues.size())
+      return m_vecValues[m_iValue];
+  }
+  return m_iValue;
+}
+
+float CGUISpinControl::GetFloatValue() const
+{
+  return m_fValue;
+}
+
+std::string CGUISpinControl::GetStringValue() const
+{
+  if (m_iType == SPIN_CONTROL_TYPE_TEXT && m_iValue >= 0 && m_iValue < (int)m_vecLabels.size())
+  {
+    if (m_iValue < (int)m_vecStrValues.size())
+      return m_vecStrValues[m_iValue];
+
+    return m_vecLabels[m_iValue];
+  }
+  return "";
+}
+
+void CGUISpinControl::AddLabel(const std::string& strLabel, int iValue)
+{
+  m_vecLabels.push_back(strLabel);
+  m_vecValues.push_back(iValue);
+}
+
+void CGUISpinControl::AddLabel(const std::string& strLabel, const std::string& strValue)
+{
+  m_vecLabels.push_back(strLabel);
+  m_vecStrValues.push_back(strValue);
+}
+
+const std::string CGUISpinControl::GetLabel() const
+{
+  if (m_iValue >= 0 && m_iValue < (int)m_vecLabels.size())
+  {
+    return m_vecLabels[m_iValue];
+  }
+  return "";
+}
+
+void CGUISpinControl::SetPosition(float posX, float posY)
+{
+  CGUIControl::SetPosition(posX, posY);
+
+  m_imgspinDownFocus->SetPosition(posX, posY);
+  m_imgspinDown->SetPosition(posX, posY);
+  m_imgspinDownDisabled->SetPosition(posX, posY);
+
+  m_imgspinUp->SetPosition(m_posX + m_imgspinDown->GetWidth(), m_posY);
+  m_imgspinUpFocus->SetPosition(m_posX + m_imgspinDownFocus->GetWidth(), m_posY);
+  m_imgspinUpDisabled->SetPosition(m_posX + m_imgspinDownDisabled->GetWidth(), m_posY);
+}
+
+float CGUISpinControl::GetWidth() const
+{
+  return m_imgspinDown->GetWidth() * 2;
+}
+
+bool CGUISpinControl::CanMoveUp(bool bTestReverse)
+{
+  // test for reverse...
+  if (bTestReverse && m_bReverse) return CanMoveDown(false);
+
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_PAGE:
+    return m_currentItem > 0;
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue - 1 >= m_iStart)
+        return true;
+      return false;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    {
+      if (m_fValue - m_fInterval >= m_fStart)
+        return true;
+      return false;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue - 1 >= 0)
+        return true;
+      return false;
+    }
+    break;
+  }
+  return false;
+}
+
+bool CGUISpinControl::CanMoveDown(bool bTestReverse)
+{
+  // test for reverse...
+  if (bTestReverse && m_bReverse) return CanMoveUp(false);
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_PAGE:
+    return m_currentItem < m_numItems;
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue + 1 <= m_iEnd)
+        return true;
+      return false;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    {
+      if (m_fValue + m_fInterval <= m_fEnd)
+        return true;
+      return false;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue + 1 < (int)m_vecLabels.size())
+        return true;
+      return false;
+    }
+    break;
+  }
+  return false;
+}
+
+void CGUISpinControl::PageUp()
+{
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue - 10 >= m_iStart)
+        m_iValue -= 10;
+      else
+        m_iValue = m_iStart;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+  case SPIN_CONTROL_TYPE_PAGE:
+    ChangePage(-10);
+    break;
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue - 10 >= 0)
+        m_iValue -= 10;
+      else
+        m_iValue = 0;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+  }
+
+}
+
+void CGUISpinControl::PageDown()
+{
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue + 10 <= m_iEnd)
+        m_iValue += 10;
+      else
+        m_iValue = m_iEnd;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+  case SPIN_CONTROL_TYPE_PAGE:
+    ChangePage(10);
+    break;
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue + 10 < (int)m_vecLabels.size() )
+        m_iValue += 10;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+    }
+    break;
+  }
+}
+
+void CGUISpinControl::MoveUp(bool bTestReverse)
+{
+  if (bTestReverse && m_bReverse)
+  { // actually should move down.
+    MoveDown(false);
+    return ;
+  }
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue - 1 >= m_iStart)
+        m_iValue--;
+      else if (m_iValue == m_iStart)
+        m_iValue = m_iEnd;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_PAGE:
+    ChangePage(-1);
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    {
+      if (m_fValue - m_fInterval >= m_fStart)
+        m_fValue -= m_fInterval;
+      else
+        m_fValue = m_fEnd;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue - 1 >= 0)
+        m_iValue--;
+      else if (m_iValue == 0)
+        m_iValue = (int)m_vecLabels.size() - 1;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+  }
+}
+
+void CGUISpinControl::MoveDown(bool bTestReverse)
+{
+  if (bTestReverse && m_bReverse)
+  { // actually should move up.
+    MoveUp(false);
+    return ;
+  }
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_INT:
+    {
+      if (m_iValue + 1 <= m_iEnd)
+        m_iValue++;
+      else if (m_iValue == m_iEnd)
+        m_iValue = m_iStart;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_PAGE:
+    ChangePage(1);
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    {
+      if (m_fValue + m_fInterval <= m_fEnd)
+        m_fValue += m_fInterval;
+      else
+        m_fValue = m_fStart;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    {
+      if (m_iValue + 1 < (int)m_vecLabels.size() )
+        m_iValue++;
+      else if (m_iValue == (int)m_vecLabels.size() - 1)
+        m_iValue = 0;
+      CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID());
+      SendWindowMessage(msg);
+      return ;
+    }
+    break;
+  }
+}
+void CGUISpinControl::SetReverse(bool bReverse)
+{
+  m_bReverse = bReverse;
+}
+
+void CGUISpinControl::SetFloatInterval(float fInterval)
+{
+  m_fInterval = fInterval;
+}
+
+void CGUISpinControl::SetShowRange(bool bOnoff)
+{
+  m_bShowRange = bOnoff;
+}
+
+int CGUISpinControl::GetMinimum() const
+{
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_PAGE:
+    return 0;
+  case SPIN_CONTROL_TYPE_INT:
+    return m_iStart;
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    return 1;
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    return (int)(m_fStart*10.0f);
+    break;
+  }
+  return 0;
+}
+
+int CGUISpinControl::GetMaximum() const
+{
+  switch (m_iType)
+  {
+  case SPIN_CONTROL_TYPE_PAGE:
+    return m_numItems;
+  case SPIN_CONTROL_TYPE_INT:
+    return m_iEnd;
+    break;
+
+  case SPIN_CONTROL_TYPE_TEXT:
+    return (int)m_vecLabels.size();
+    break;
+
+  case SPIN_CONTROL_TYPE_FLOAT:
+    return (int)(m_fEnd*10.0f);
+    break;
+  }
+  return 100;
+}
+
+bool CGUISpinControl::HitTest(const CPoint &point) const
+{
+  if (m_imgspinUpFocus->HitTest(point) || m_imgspinDownFocus->HitTest(point))
+    return true;
+  return CGUIControl::HitTest(point);
+}
+
+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);
+}
+
+EVENT_RESULT CGUISpinControl::OnMouseEvent(const CPoint &point, const CMouseEvent &event)
+{
+  if (event.m_id == ACTION_MOUSE_LEFT_CLICK)
+  {
+    if (m_imgspinUpFocus->HitTest(point))
+      MoveUp();
+    else if (m_imgspinDownFocus->HitTest(point))
+      MoveDown();
+    return EVENT_RESULT_HANDLED;
+  }
+  else if (event.m_id == ACTION_MOUSE_WHEEL_UP)
+  {
+    if (m_imgspinUpFocus->HitTest(point) || m_imgspinDownFocus->HitTest(point))
+    {
+      MoveUp();
+      return EVENT_RESULT_HANDLED;
+    }
+  }
+  else if (event.m_id == ACTION_MOUSE_WHEEL_DOWN)
+  {
+    if (m_imgspinUpFocus->HitTest(point) || m_imgspinDownFocus->HitTest(point))
+    {
+      MoveDown();
+      return EVENT_RESULT_HANDLED;
+    }
+  }
+  return EVENT_RESULT_UNHANDLED;
+}
+
+std::string CGUISpinControl::GetDescription() const
+{
+  return StringUtils::Format("{}/{}", 1 + GetValue(), GetMaximum());
+}
+
+bool CGUISpinControl::IsFocusedOnUp() const
+{
+  return (m_iSelect == SPIN_BUTTON_UP);
+}
+
+void CGUISpinControl::ChangePage(int amount)
+{
+  m_currentItem += amount * m_itemsPerPage;
+  if (m_currentItem > m_numItems - m_itemsPerPage)
+    m_currentItem = m_numItems - m_itemsPerPage;
+  if (m_currentItem < 0)
+    m_currentItem = 0;
+  CGUIMessage message(GUI_MSG_NOTIFY_ALL, GetParentID(), GetID(), GUI_MSG_PAGE_CHANGE, m_currentItem);
+  SendWindowMessage(message);
+}
+
+bool CGUISpinControl::UpdateColors(const CGUIListItem* item)
+{
+  bool changed = CGUIControl::UpdateColors(nullptr);
+  changed |= m_label.UpdateColors();
+  changed |= m_imgspinDownFocus->SetDiffuseColor(m_diffuseColor);
+  changed |= m_imgspinDown->SetDiffuseColor(m_diffuseColor);
+  changed |= m_imgspinUp->SetDiffuseColor(m_diffuseColor);
+  changed |= m_imgspinUpFocus->SetDiffuseColor(m_diffuseColor);
+  changed |= m_imgspinUpDisabled->SetDiffuseColor(m_diffuseColor);
+  changed |= m_imgspinDownDisabled->SetDiffuseColor(m_diffuseColor);
+
+  return changed;
+}
+
+bool CGUISpinControl::IsVisible() const
+{
+  // page controls can be optionally disabled if the number of pages is 1
+  if (m_iType == SPIN_CONTROL_TYPE_PAGE && m_numItems <= m_itemsPerPage && !m_showOnePage)
+    return false;
+  return CGUIControl::IsVisible();
+}