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, 630 insertions, 0 deletions

diff --git a/xbmc/settings/windows/GUIWindowSettingsScreenCalibration.cpp b/xbmc/settings/windows/GUIWindowSettingsScreenCalibration.cpp
new file mode 100644
index 0000000..7e67de6
--- /dev/null
+++ b/xbmc/settings/windows/GUIWindowSettingsScreenCalibration.cpp
@@ -0,0 +1,630 @@
+/*
+ *  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 "GUIWindowSettingsScreenCalibration.h"
+
+#include "ServiceBroker.h"
+#include "application/ApplicationComponents.h"
+#include "application/ApplicationPlayer.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIMoverControl.h"
+#include "guilib/GUIResizeControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+#include "settings/DisplaySettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "settings/SubtitlesSettings.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+#include "windowing/WinSystem.h"
+
+#include <string>
+#include <utility>
+
+using namespace KODI;
+
+namespace
+{
+constexpr int CONTROL_LABEL_RES = 2;
+constexpr int CONTROL_LABEL_DESCRIPTION = 3;
+constexpr int CONTROL_LABEL_VALUE = 4;
+constexpr int CONTROL_TOP_LEFT = 8;
+constexpr int CONTROL_BOTTOM_RIGHT = 9;
+constexpr int CONTROL_SUBTITLES = 10;
+constexpr int CONTROL_PIXEL_RATIO = 11;
+constexpr int CONTROL_RESET = 12;
+constexpr int CONTROL_VIDEO = 20;
+
+constexpr int DEFAULT_GUI_HEIGHT = 1080;
+constexpr int DEFAULT_GUI_WIDTH = 1920;
+
+// Fixed transparent space of the subtitle bar (on top + below) for touch screen
+// must match with the space of the skin bar image
+constexpr int CONTROL_SUBTITLES_SPACE = 80;
+} // unnamed namespace
+
+CGUIWindowSettingsScreenCalibration::CGUIWindowSettingsScreenCalibration(void)
+  : CGUIWindow(WINDOW_SCREEN_CALIBRATION, "SettingsScreenCalibration.xml")
+{
+  m_iCurRes = 0;
+  m_iControl = 0;
+  m_fPixelRatioBoxHeight = 0.0f;
+  m_needsScaling = false; // we handle all the scaling
+}
+
+CGUIWindowSettingsScreenCalibration::~CGUIWindowSettingsScreenCalibration(void) = default;
+
+
+void CGUIWindowSettingsScreenCalibration::ResetCalibration()
+{
+  // We ask to reset the calibration
+  // Reset will be applied to: windowed mode or per fullscreen resolution
+  CGUIDialogYesNo* pDialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
+  pDialog->SetHeading(CVariant{20325});
+  std::string strText = StringUtils::Format(
+      g_localizeStrings.Get(20326),
+      CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo(m_Res[m_iCurRes]).strMode);
+  pDialog->SetText(CVariant{std::move(strText)});
+  pDialog->SetChoice(0, CVariant{222});
+  pDialog->SetChoice(1, CVariant{186});
+  pDialog->Open();
+  if (pDialog->IsConfirmed())
+  {
+    CServiceBroker::GetWinSystem()->GetGfxContext().ResetScreenParameters(m_Res[m_iCurRes]);
+    ResetControls();
+    // Send GUI_MSG_WINDOW_RESIZE to rescale font size/aspect for label controls
+    CServiceBroker::GetGUI()->GetWindowManager().SendMessage(
+        GUI_MSG_NOTIFY_ALL, WINDOW_SCREEN_CALIBRATION, 0, GUI_MSG_WINDOW_RESIZE);
+  }
+}
+
+bool CGUIWindowSettingsScreenCalibration::OnAction(const CAction& action)
+{
+  switch (action.GetID())
+  {
+    case ACTION_CALIBRATE_SWAP_ARROWS:
+    {
+      NextControl();
+      return true;
+    }
+    break;
+
+    case ACTION_CALIBRATE_RESET:
+    {
+      ResetCalibration();
+      return true;
+    }
+    break;
+
+    case ACTION_CHANGE_RESOLUTION:
+      // choose the next resolution in our list
+      {
+        m_iCurRes = (m_iCurRes + 1) % m_Res.size();
+        CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(m_Res[m_iCurRes], false);
+        ResetControls();
+        // Send GUI_MSG_WINDOW_RESIZE to rescale font size/aspect for label controls
+        CServiceBroker::GetGUI()->GetWindowManager().SendMessage(
+            GUI_MSG_NOTIFY_ALL, WINDOW_SCREEN_CALIBRATION, 0, GUI_MSG_WINDOW_RESIZE);
+        return true;
+      }
+      break;
+
+    // ignore all gesture meta actions
+    case ACTION_GESTURE_BEGIN:
+    case ACTION_GESTURE_END:
+    case ACTION_GESTURE_ABORT:
+    case ACTION_GESTURE_NOTIFY:
+    case ACTION_GESTURE_PAN:
+    case ACTION_GESTURE_ROTATE:
+    case ACTION_GESTURE_ZOOM:
+      return true;
+
+    case ACTION_MOUSE_LEFT_CLICK:
+    case ACTION_TOUCH_TAP:
+      if (GetFocusedControlID() == CONTROL_RESET)
+      {
+        ResetCalibration();
+        return true;
+      }
+      break;
+  }
+
+  // if we see a mouse move event without dx and dy (amount2 and amount3) these
+  // are the focus actions which are generated on touch events and those should
+  // be eaten/ignored here. Else we will switch to the screencalibration controls
+  // which are at that x/y value on each touch/tap/swipe which makes the whole window
+  // unusable for touch screens
+  if (action.GetID() == ACTION_MOUSE_MOVE && action.GetAmount(2) == 0 && action.GetAmount(3) == 0)
+    return true;
+
+  return CGUIWindow::OnAction(action); // base class to handle basic movement etc.
+}
+
+void CGUIWindowSettingsScreenCalibration::AllocResources(bool forceLoad)
+{
+  CGUIWindow::AllocResources(forceLoad);
+}
+
+void CGUIWindowSettingsScreenCalibration::FreeResources(bool forceUnload)
+{
+  CGUIWindow::FreeResources(forceUnload);
+}
+
+
+bool CGUIWindowSettingsScreenCalibration::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      CDisplaySettings::GetInstance().UpdateCalibrations();
+      CServiceBroker::GetSettingsComponent()->GetSettings()->Save();
+      CServiceBroker::GetWinSystem()->GetGfxContext().SetCalibrating(false);
+      // reset our screen resolution to what it was initially
+      CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(
+          CDisplaySettings::GetInstance().GetCurrentResolution(), false);
+      CServiceBroker::GetGUI()->GetWindowManager().SendMessage(
+          GUI_MSG_NOTIFY_ALL, WINDOW_SCREEN_CALIBRATION, 0, GUI_MSG_WINDOW_RESIZE);
+    }
+    break;
+
+    case GUI_MSG_WINDOW_INIT:
+    {
+      CGUIWindow::OnMessage(message);
+      CServiceBroker::GetWinSystem()->GetGfxContext().SetCalibrating(true);
+
+      // Get the default XML size values of controls,
+      // we will use these values to scale controls when the resolution change
+      for (int id = CONTROL_TOP_LEFT; id <= CONTROL_RESET; id++)
+      {
+        CGUIControl* control = GetControl(id);
+        if (control)
+        {
+          m_controlsSize.emplace(id, std::make_pair(control->GetHeight(), control->GetWidth()));
+        }
+      }
+
+      // Get the allowable resolutions that we can calibrate...
+      m_Res.clear();
+
+      auto& components = CServiceBroker::GetAppComponents();
+      const auto appPlayer = components.GetComponent<CApplicationPlayer>();
+      bool isPlayingVideo{appPlayer->IsPlayingVideo()};
+      if (isPlayingVideo)
+      { // don't allow resolution switching if we are playing a video
+
+        appPlayer->TriggerUpdateResolution();
+
+        m_iCurRes = 0;
+        m_Res.push_back(CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution());
+        SET_CONTROL_VISIBLE(CONTROL_VIDEO);
+      }
+      else
+      {
+        SET_CONTROL_HIDDEN(CONTROL_VIDEO);
+        CServiceBroker::GetWinSystem()->GetGfxContext().GetAllowedResolutions(m_Res);
+        // find our starting resolution
+        m_iCurRes = FindCurrentResolution();
+      }
+
+      // Setup the first control
+      m_iControl = CONTROL_TOP_LEFT;
+
+      m_isSubtitleBarEnabled =
+          !(CServiceBroker::GetSettingsComponent()->GetSubtitlesSettings()->GetAlignment() !=
+                SUBTITLES::Align::MANUAL &&
+            isPlayingVideo);
+
+      ResetControls();
+      return true;
+    }
+    break;
+    case GUI_MSG_CLICKED:
+    {
+      // On click event select the next control
+      NextControl();
+    }
+    break;
+    case GUI_MSG_NOTIFY_ALL:
+    {
+      if (message.GetParam1() == GUI_MSG_WINDOW_RESIZE &&
+          message.GetSenderId() != WINDOW_SCREEN_CALIBRATION && IsActive())
+      {
+        m_Res.clear();
+        CServiceBroker::GetWinSystem()->GetGfxContext().GetAllowedResolutions(m_Res);
+        m_iCurRes = FindCurrentResolution();
+        ResetControls();
+      }
+    }
+    break;
+    // send before touch for requesting gesture features - we don't want this
+    // it would result in unfocus in the onmessage below ...
+    case GUI_MSG_GESTURE_NOTIFY:
+    // send after touch for unfocussing - we don't want this in this window!
+    case GUI_MSG_UNFOCUS_ALL:
+      return true;
+      break;
+  }
+  return CGUIWindow::OnMessage(message);
+}
+
+unsigned int CGUIWindowSettingsScreenCalibration::FindCurrentResolution()
+{
+  RESOLUTION curRes = CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution();
+  for (size_t i = 0; i < m_Res.size(); i++)
+  {
+    // If it's a CUSTOM (monitor) resolution, then CServiceBroker::GetWinSystem()->GetGfxContext().GetAllowedResolutions()
+    // returns just one entry with CUSTOM in it. Update that entry to point to the current
+    // CUSTOM resolution.
+    if (curRes >= RES_CUSTOM)
+    {
+      if (m_Res[i] == RES_CUSTOM)
+      {
+        m_Res[i] = curRes;
+        return i;
+      }
+    }
+    else if (m_Res[i] == CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution())
+      return i;
+  }
+  CLog::Log(LOGERROR, "CALIBRATION: Reported current resolution: {}",
+            CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution());
+  CLog::Log(LOGERROR,
+            "CALIBRATION: Could not determine current resolution, falling back to default");
+  return 0;
+}
+
+void CGUIWindowSettingsScreenCalibration::NextControl()
+{ // set the old control invisible and not focused, and choose the next control
+  CGUIControl* pControl = GetControl(m_iControl);
+  if (pControl)
+  {
+    pControl->SetVisible(false);
+    pControl->SetFocus(false);
+  }
+  // If the current control is the reset button
+  // ask to reset the calibration settings
+  if (m_iControl == CONTROL_RESET)
+  {
+    ResetCalibration();
+  }
+  // switch to the next control
+  m_iControl++;
+  if (m_iControl > CONTROL_RESET)
+    m_iControl = CONTROL_TOP_LEFT;
+  // enable the new control
+  EnableControl(m_iControl);
+}
+
+void CGUIWindowSettingsScreenCalibration::EnableControl(int iControl)
+{
+  SET_CONTROL_VISIBLE(CONTROL_TOP_LEFT);
+  SET_CONTROL_VISIBLE(CONTROL_BOTTOM_RIGHT);
+  SET_CONTROL_VISIBLE(CONTROL_SUBTITLES);
+  SET_CONTROL_VISIBLE(CONTROL_PIXEL_RATIO);
+  SET_CONTROL_VISIBLE(CONTROL_RESET);
+  SET_CONTROL_FOCUS(iControl, 0);
+}
+
+void CGUIWindowSettingsScreenCalibration::ResetControls()
+{
+  // disable the video control, so that our other controls take mouse clicks etc.
+  CONTROL_DISABLE(CONTROL_VIDEO);
+  // disable the UI calibration for our controls
+  // and set their limits
+  // also, set them to invisible if they don't have focus
+  CGUIMoverControl* pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_TOP_LEFT));
+  RESOLUTION_INFO info =
+      CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo(m_Res[m_iCurRes]);
+
+  m_subtitleVerticalMargin = static_cast<int>(
+      static_cast<float>(info.iHeight) / 100 *
+      CServiceBroker::GetSettingsComponent()->GetSubtitlesSettings()->GetVerticalMarginPerc());
+
+  if (pControl)
+  {
+    pControl->SetLimits(-info.iWidth / 4, -info.iHeight / 4, info.iWidth / 4, info.iHeight / 4);
+    auto& size = m_controlsSize[CONTROL_TOP_LEFT];
+    pControl->SetHeight(size.first / DEFAULT_GUI_HEIGHT * info.iHeight);
+    pControl->SetWidth(size.second / DEFAULT_GUI_WIDTH * info.iWidth);
+    pControl->SetPosition(static_cast<float>(info.Overscan.left),
+                          static_cast<float>(info.Overscan.top));
+    pControl->SetLocation(info.Overscan.left, info.Overscan.top, false);
+  }
+  pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_BOTTOM_RIGHT));
+  if (pControl)
+  {
+    pControl->SetLimits(info.iWidth * 3 / 4, info.iHeight * 3 / 4, info.iWidth * 5 / 4,
+                        info.iHeight * 5 / 4);
+    auto& size = m_controlsSize[CONTROL_BOTTOM_RIGHT];
+    pControl->SetHeight(size.first / DEFAULT_GUI_HEIGHT * info.iHeight);
+    pControl->SetWidth(size.second / DEFAULT_GUI_WIDTH * info.iWidth);
+    pControl->SetPosition(static_cast<float>(info.Overscan.right) - pControl->GetWidth(),
+                          static_cast<float>(info.Overscan.bottom) - pControl->GetHeight());
+    pControl->SetLocation(info.Overscan.right, info.Overscan.bottom, false);
+  }
+  // Subtitles and OSD controls can only move up and down
+  pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_SUBTITLES));
+  if (pControl)
+  {
+    auto& size = m_controlsSize[CONTROL_SUBTITLES];
+    float scaledHeight = size.first / DEFAULT_GUI_HEIGHT * info.iHeight;
+    float scaledSpace =
+        static_cast<float>(CONTROL_SUBTITLES_SPACE) / DEFAULT_GUI_HEIGHT * info.iHeight;
+    m_subtitlesHalfSpace = static_cast<int>(scaledSpace / 2);
+    int barHeight = static_cast<int>(scaledHeight - scaledSpace);
+    pControl->SetLimits(0, m_subtitlesHalfSpace + barHeight + info.Overscan.top, 0,
+                        info.Overscan.bottom + m_subtitlesHalfSpace);
+    pControl->SetHeight(scaledHeight);
+    pControl->SetWidth(size.second / DEFAULT_GUI_WIDTH * info.iWidth);
+    // If the vertical margin has been changed from the previous calibration,
+    // the text bar could appear offscreen, then force move to visible area
+    if (info.iSubtitles - m_subtitleVerticalMargin > info.iHeight)
+      info.iSubtitles = info.Overscan.bottom;
+    // We want the text to be at the base of the bar,
+    // then we shift the position to include the vertical margin
+    pControl->SetPosition((info.iWidth - pControl->GetWidth()) * 0.5f,
+                          info.iSubtitles - pControl->GetHeight() + m_subtitlesHalfSpace -
+                              m_subtitleVerticalMargin);
+    pControl->SetLocation(0, info.iSubtitles + m_subtitlesHalfSpace - m_subtitleVerticalMargin,
+                          false);
+    pControl->SetEnabled(m_isSubtitleBarEnabled);
+  }
+  // The pixel ratio control
+  CGUIResizeControl* pResize = dynamic_cast<CGUIResizeControl*>(GetControl(CONTROL_PIXEL_RATIO));
+  if (pResize)
+  {
+    pResize->SetLimits(info.iWidth * 0.25f, info.iHeight * 0.5f, info.iWidth * 0.75f,
+                       info.iHeight * 0.5f);
+    pResize->SetHeight(info.iHeight * 0.5f);
+    pResize->SetWidth(pResize->GetHeight() / info.fPixelRatio);
+    pResize->SetPosition((info.iWidth - pResize->GetWidth()) / 2,
+                         (info.iHeight - pResize->GetHeight()) / 2);
+  }
+  // The calibration reset
+  pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_RESET));
+  if (pControl)
+  {
+    auto& size = m_controlsSize[CONTROL_RESET];
+    pControl->SetHeight(size.first / DEFAULT_GUI_HEIGHT * info.iHeight);
+    pControl->SetWidth(size.second / DEFAULT_GUI_WIDTH * info.iWidth);
+    float posX = 0;
+    float posY = info.iHeight - pControl->GetHeight();
+    pControl->SetLimits(posX, posY, posX, posY);
+    pControl->SetPosition(posX, posY);
+    pControl->SetLocation(posX, posY, false);
+  }
+  // Enable the default control
+  EnableControl(m_iControl);
+}
+
+bool CGUIWindowSettingsScreenCalibration::UpdateFromControl(int iControl)
+{
+  RESOLUTION_INFO info =
+      CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo(m_Res[m_iCurRes]);
+  RESOLUTION_INFO infoPrev = info;
+  std::string labelDescription;
+  std::string labelValue;
+
+  if (iControl == CONTROL_PIXEL_RATIO)
+  {
+    CGUIControl* pControl = GetControl(CONTROL_PIXEL_RATIO);
+    if (pControl)
+    {
+      float fWidth = pControl->GetWidth();
+      float fHeight = pControl->GetHeight();
+      info.fPixelRatio = fHeight / fWidth;
+      // recenter our control...
+      pControl->SetPosition((static_cast<float>(info.iWidth) - pControl->GetWidth()) / 2,
+                            (static_cast<float>(info.iHeight) - pControl->GetHeight()) / 2);
+      labelDescription = StringUtils::Format("[B]{}[/B][CR]{}", g_localizeStrings.Get(272),
+                                             g_localizeStrings.Get(273));
+      labelValue = StringUtils::Format("{:5.3f}", info.fPixelRatio);
+      labelValue = StringUtils::Format(g_localizeStrings.Get(20327), labelValue);
+    }
+  }
+  else
+  {
+    CGUIMoverControl* pControl = dynamic_cast<CGUIMoverControl*>(GetControl(iControl));
+    if (pControl)
+    {
+      switch (iControl)
+      {
+        case CONTROL_TOP_LEFT:
+        {
+          info.Overscan.left = pControl->GetXLocation();
+          info.Overscan.top = pControl->GetYLocation();
+          labelDescription = StringUtils::Format("[B]{}[/B][CR]{}", g_localizeStrings.Get(274),
+                                                 g_localizeStrings.Get(276));
+          labelValue =
+              StringUtils::Format("{}, {}", pControl->GetXLocation(), pControl->GetYLocation());
+          labelValue = StringUtils::Format(g_localizeStrings.Get(20327), labelValue);
+          // Update reset control position
+          CGUIMoverControl* pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_RESET));
+          if (pControl)
+          {
+            float posX = info.Overscan.left;
+            float posY = info.Overscan.bottom - pControl->GetHeight();
+            pControl->SetLimits(posX, posY, posX, posY);
+            pControl->SetPosition(posX, posY);
+            pControl->SetLocation(posX, posY, false);
+          }
+        }
+        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();
+          labelDescription = StringUtils::Format("[B]{}[/B][CR]{}", g_localizeStrings.Get(275),
+                                                 g_localizeStrings.Get(276));
+          labelValue = StringUtils::Format("{}, {}", iXOff1, iYOff1);
+          labelValue = StringUtils::Format(g_localizeStrings.Get(20327), labelValue);
+          // Update reset control position
+          pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_RESET));
+          if (pControl)
+          {
+            float posX = info.Overscan.left;
+            float posY = info.Overscan.bottom - pControl->GetHeight();
+            pControl->SetLimits(posX, posY, posX, posY);
+            pControl->SetPosition(posX, posY);
+            pControl->SetLocation(posX, posY, false);
+          }
+        }
+        break;
+
+        case CONTROL_SUBTITLES:
+        {
+          if (m_isSubtitleBarEnabled)
+          {
+            info.iSubtitles =
+                pControl->GetYLocation() - m_subtitlesHalfSpace + m_subtitleVerticalMargin;
+
+            labelDescription = StringUtils::Format("[B]{}[/B][CR]{}", g_localizeStrings.Get(277),
+                                                   g_localizeStrings.Get(278));
+            labelValue = StringUtils::Format(g_localizeStrings.Get(39184), info.iSubtitles,
+                                             info.iSubtitles - m_subtitleVerticalMargin);
+          }
+          else
+          {
+            labelDescription = StringUtils::Format("[B]{}[/B][CR]{}", g_localizeStrings.Get(277),
+                                                   g_localizeStrings.Get(39189));
+          }
+        }
+        break;
+
+        case CONTROL_RESET:
+        {
+          labelDescription = g_localizeStrings.Get(20325);
+        }
+        break;
+      }
+    }
+  }
+
+  SET_CONTROL_LABEL(CONTROL_LABEL_DESCRIPTION, labelDescription);
+  SET_CONTROL_LABEL(CONTROL_LABEL_VALUE, labelValue);
+
+  // Set resolution info text
+  std::string resInfo;
+  if (CServiceBroker::GetWinSystem()->IsFullScreen())
+  {
+    resInfo =
+        StringUtils::Format("{} {}x{}@{:.2f} - {}", g_localizeStrings.Get(13287), info.iScreenWidth,
+                            info.iScreenHeight, info.fRefreshRate, g_localizeStrings.Get(244));
+  }
+  else
+  {
+    resInfo = StringUtils::Format("{} {}x{} - {}", g_localizeStrings.Get(13287), info.iScreenWidth,
+                                  info.iScreenHeight, g_localizeStrings.Get(242));
+  }
+  SET_CONTROL_LABEL(CONTROL_LABEL_RES, resInfo);
+
+  // Detect overscan changes
+  bool isOverscanChanged = info.Overscan != infoPrev.Overscan;
+
+  // Adjust subtitle bar position due to overscan changes
+  if (isOverscanChanged)
+  {
+    CGUIMoverControl* pControl = dynamic_cast<CGUIMoverControl*>(GetControl(CONTROL_SUBTITLES));
+    if (pControl)
+    {
+      // Keep the subtitle bar within the overscan boundary
+      if (info.Overscan.bottom + m_subtitleVerticalMargin < info.iSubtitles)
+      {
+        info.iSubtitles = info.Overscan.bottom + m_subtitleVerticalMargin;
+
+        // We want the text to be at the base of the bar,
+        // then we shift the position to include the vertical margin
+        pControl->SetPosition((info.iWidth - pControl->GetWidth()) * 0.5f,
+                              info.iSubtitles - pControl->GetHeight() + m_subtitlesHalfSpace -
+                                  m_subtitleVerticalMargin);
+        pControl->SetLocation(0, info.iSubtitles + m_subtitlesHalfSpace - m_subtitleVerticalMargin,
+                              false);
+      }
+
+      // Recalculate limits based on overscan values
+      const auto& size = m_controlsSize[CONTROL_SUBTITLES];
+      const float scaledHeight = size.first / DEFAULT_GUI_HEIGHT * info.iHeight;
+      const float scaledSpace =
+          static_cast<float>(CONTROL_SUBTITLES_SPACE) / DEFAULT_GUI_HEIGHT * info.iHeight;
+
+      m_subtitlesHalfSpace = static_cast<int>(scaledSpace / 2);
+      const int barHeight = static_cast<int>(scaledHeight - scaledSpace);
+
+      pControl->SetLimits(0, m_subtitlesHalfSpace + barHeight + info.Overscan.top, 0,
+                          info.Overscan.bottom + m_subtitlesHalfSpace);
+    }
+  }
+
+  CServiceBroker::GetWinSystem()->GetGfxContext().SetResInfo(m_Res[m_iCurRes], info);
+
+  return isOverscanChanged;
+}
+
+void CGUIWindowSettingsScreenCalibration::FrameMove()
+{
+  m_iControl = GetFocusedControlID();
+  if (m_iControl >= 0)
+  {
+    if (UpdateFromControl(m_iControl))
+    {
+      // Send GUI_MSG_WINDOW_RESIZE to rescale font size/aspect for label controls
+      CServiceBroker::GetGUI()->GetWindowManager().SendMessage(
+          GUI_MSG_NOTIFY_ALL, WINDOW_SCREEN_CALIBRATION, 0, GUI_MSG_WINDOW_RESIZE);
+    }
+  }
+  else
+  {
+    SET_CONTROL_LABEL(CONTROL_LABEL_DESCRIPTION, "");
+    SET_CONTROL_LABEL(CONTROL_LABEL_VALUE, "");
+    SET_CONTROL_LABEL(CONTROL_LABEL_RES, "");
+  }
+  CGUIWindow::FrameMove();
+}
+
+void CGUIWindowSettingsScreenCalibration::DoProcess(unsigned int currentTime,
+                                                    CDirtyRegionList& dirtyregions)
+{
+  MarkDirtyRegion();
+
+  for (int i = CONTROL_TOP_LEFT; i <= CONTROL_RESET; i++)
+    SET_CONTROL_HIDDEN(i);
+  m_needsScaling = true;
+  CGUIWindow::DoProcess(currentTime, dirtyregions);
+  m_needsScaling = false;
+
+  CServiceBroker::GetWinSystem()->GetGfxContext().SetRenderingResolution(m_Res[m_iCurRes], false);
+  CServiceBroker::GetWinSystem()->GetGfxContext().AddGUITransform();
+
+  // process the movers etc.
+  for (int i = CONTROL_TOP_LEFT; i <= CONTROL_RESET; i++)
+  {
+    SET_CONTROL_VISIBLE(i);
+    CGUIControl* control = GetControl(i);
+    if (control)
+      control->DoProcess(currentTime, dirtyregions);
+  }
+  CServiceBroker::GetWinSystem()->GetGfxContext().RemoveTransform();
+}
+
+void CGUIWindowSettingsScreenCalibration::DoRender()
+{
+  // we set that we need scaling here to render so that anything else on screen scales correctly
+  m_needsScaling = true;
+  CGUIWindow::DoRender();
+  m_needsScaling = false;
+}