Massive changes to how we handle screen and geometry restoration

This fixes a lot of issues with geometry restoration and also makes sure
we restore the correct screen we last had the windows opened on.

src/ui/KonvergoWindow.cpp

@@ -46,7 +46,7 @@ KonvergoWindow::KonvergoWindow(QWindow* parent) : QQuickWindow(parent), m_debugL
 #endif
 
   loadGeometry();
-  m_lastScale = CalculateScale(size());
+  notifyScale(size());
 
   connect(SettingsComponent::Get().getSection(SETTINGS_SECTION_MAIN), &SettingsSection::valuesUpdated,
           this, &KonvergoWindow::updateMainSectionSettings);
@@ -57,9 +57,6 @@ KonvergoWindow::KonvergoWindow(QWindow* parent) : QQuickWindow(parent), m_debugL
   connect(this, &KonvergoWindow::enableVideoWindowSignal,
           this, &KonvergoWindow::enableVideoWindow, Qt::QueuedConnection);
 
-//  connect(QGuiApplication::desktop(), &QDesktopWidget::screenCountChanged,
-//              this, &KonvergoWindow::onScreenCountChanged);
-
   connect(&PlayerComponent::Get(), &PlayerComponent::windowVisible,
           this, &KonvergoWindow::playerWindowVisible);
 
@@ -69,21 +66,20 @@ KonvergoWindow::KonvergoWindow(QWindow* parent) : QQuickWindow(parent), m_debugL
   // this is using old syntax because ... reasons. QQuickCloseEvent is not public class
   connect(this, SIGNAL(closing(QQuickCloseEvent*)), this, SLOT(closingWindow()));
 
-  connect(qApp, &QCoreApplication::aboutToQuit, this, &KonvergoWindow::saveGeometry);
+  connect(qApp, &QCoreApplication::aboutToQuit, this, &KonvergoWindow::closingWindow);
 
-  if (!SystemComponent::Get().isOpenELEC())
-  {
-    // this is such a hack. But I could not get it to enter into fullscreen
-    // mode if I didn't trigger this after a while.
-    //
-    QTimer::singleShot(500, [=]() {
-        updateFullscreenState();
-    });
-  }
-  else
-  {
-    setWindowState(Qt::WindowFullScreen);
-  }
+#ifdef KONVERGO_OPENELEC
+  setVisibility(QWindow::FullScreen);
+#elif !defined(Q_OS_MAC)
+  updateFullscreenState(false);
+#else
+  // this is such a hack. But I could not get it to enter into fullscreen
+  // mode if I didn't trigger this after a while.
+  //
+  QTimer::singleShot(500, [=]() {
+    updateFullscreenState(false);
+  });
+#endif
 
   emit enableVideoWindowSignal();
 }
@@ -91,7 +87,7 @@ KonvergoWindow::KonvergoWindow(QWindow* parent) : QQuickWindow(parent), m_debugL
 /////////////////////////////////////////////////////////////////////////////////////////
 void KonvergoWindow::closingWindow()
 {
-  if (SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "fullscreen").toBool() == false)
+  if (!SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "fullscreen").toBool())
     saveGeometry();
 
   qApp->quit();
@@ -103,53 +99,94 @@ KonvergoWindow::~KonvergoWindow()
   DisplayComponent::Get().setApplicationWindow(0);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool KonvergoWindow::fitsInScreens(const QRect& rc)
+{
+  foreach (QScreen *screen, QGuiApplication::screens())
+  {
+    if (screen->virtualGeometry().contains(rc))
+      return true;
+  }
+  return false;
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void KonvergoWindow::saveGeometry()
 {
   QRect rc = geometry();
-  QJsonObject obj;
-  obj.insert("x", rc.x());
-  obj.insert("y", rc.y());
-  obj.insert("width", rc.width());
-  obj.insert("height", rc.height());
-  SettingsComponent::Get().setValue(SETTINGS_SECTION_STATE, "geometry", obj.toVariantMap());
+
+  // lets make sure we are not saving something craycray
+  if (rc.size().width() < windowMinSize().width() || rc.size().height() < windowMinSize().height())
+    return;
+
+  if (!fitsInScreens(rc))
+    return;
+
+  QVariantMap map = {{"x", rc.x()}, {"y", rc.y()},
+                     {"width", rc.width()}, {"height", rc.height()}};
+  SettingsComponent::Get().setValue(SETTINGS_SECTION_STATE, "geometry", map);
+  SettingsComponent::Get().setValue(SETTINGS_SECTION_STATE, "lastUsedScreen", screen()->name());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void KonvergoWindow::loadGeometry()
 {
   QRect rc = loadGeometryRect();
-  if (rc.isValid())
+  QScreen* myScreen = loadLastScreen();
+  if (!myScreen)
+    myScreen = screen();
+
+  if (SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "fullscreen").toBool())
+  {
+    QLOG_DEBUG() << "Load FullScreen geo...";
+    setGeometry(myScreen->geometry());
+    setScreen(myScreen);
+  }
+  else
+  {
     setGeometry(rc);
+    saveGeometry();
+  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 QRect KonvergoWindow::loadGeometryRect()
 {
-  QJsonObject obj = QJsonObject::fromVariantMap(SettingsComponent::Get().value(SETTINGS_SECTION_STATE, "geometry").toMap());
-  if (obj.isEmpty())
-    return QRect();
+  // if we dont have anything, default to 720p in the middle of the screen
+  QRect defaultRect = QRect((screen()->geometry().width() - webUISize().width()) / 2,
+                            (screen()->geometry().height() - webUISize().height()) / 2,
+                            webUISize().width(), webUISize().height());
 
-  QRect rc(obj["x"].toInt(), obj["y"].toInt(), obj["width"].toInt(), obj["height"].toInt());
+  QVariantMap map = SettingsComponent::Get().value(SETTINGS_SECTION_STATE, "geometry").toMap();
+  if (map.isEmpty())
+    return defaultRect;
 
-  if (rc.width() < 1280)
-    rc.setWidth(1280);
+  QRect rc(map["x"].toInt(), map["y"].toInt(), map["width"].toInt(), map["height"].toInt());
 
-  if (rc.height() < 720)
-    rc.setHeight(720);
+  QLOG_DEBUG() << "Restoring geo:" << rc;
 
-  // make sure our poisition is contained in one of the current screens
-  foreach (QScreen *screen, QGuiApplication::screens())
+  if (!rc.isValid() || rc.isEmpty())
+  {
+    QLOG_DEBUG() << "Geo bad, going for defaults";
+    return defaultRect;
+  }
+
+  QSize minsz = windowMinSize();
+
+  // Clamp to min size if we have really small values in there
+  if (rc.size().width() < minsz.width())
+    rc.setWidth(minsz.width());
+  if (rc.size().height() < minsz.height())
+    rc.setHeight(minsz.height());
+
+  // also make sure we are not putting windows outside the screen somewhere
+  if (!fitsInScreens(rc))
   {
-    if (screen->availableGeometry().contains(rc))
-      return rc;
+    QLOG_DEBUG() << "Could not fit stored geo into current screens";
+    return defaultRect;
   }
 
- // otherwise default to center of current screen
-  return QRect((screen()->geometry().width() - geometry().width()) / 2,
-               (screen()->geometry().height() - geometry().height()) / 2,
-               geometry().width(),
-               geometry().height());
+  return rc;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -192,24 +229,22 @@ void KonvergoWindow::updateMainSectionSettings(const QVariantMap& values)
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-void KonvergoWindow::updateFullscreenState()
+void KonvergoWindow::updateFullscreenState(bool saveGeo)
 {
   if (SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "fullscreen").toBool() || SystemComponent::Get().isOpenELEC())
   {
     // if we were go from windowed to fullscreen
-    // we want to stor our current windowed position
-    if (!isFullScreen())
+    // we want to store our current windowed position
+    if (!isFullScreen() && saveGeo)
       saveGeometry();
 
-      setVisibility(QWindow::FullScreen);
+    setVisibility(QWindow::FullScreen);
   }
   else
   {
     setVisibility(QWindow::Windowed);
     loadGeometry();
   }
-  
-  
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -266,7 +301,7 @@ void KonvergoWindow::RegisterClass()
 /////////////////////////////////////////////////////////////////////////////////////////
 void KonvergoWindow::onScreenCountChanged(int newCount)
 {
-  updateFullscreenState();
+  updateFullscreenState(false);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -305,7 +340,7 @@ void KonvergoWindow::notifyScale(const QSize& size)
   qreal scale = CalculateScale(size);
   if (scale != m_lastScale)
   {
-    QLOG_DEBUG() << "windowScale updated to:" << scale;
+    QLOG_DEBUG() << "windowScale updated to:" << scale << "webscale:" << CalculateWebScale(size, devicePixelRatio());
     m_lastScale = scale;
 
     emit SystemComponent::Get().scaleChanged(CalculateWebScale(size, devicePixelRatio()));
@@ -313,10 +348,10 @@ void KonvergoWindow::notifyScale(const QSize& size)
   emit webScaleChanged();
 }
 
-
 /////////////////////////////////////////////////////////////////////////////////////////
 void KonvergoWindow::resizeEvent(QResizeEvent* event)
 {
+  QLOG_DEBUG() << "resize event:" << event->size();
   notifyScale(event->size());
   QQuickWindow::resizeEvent(event);
 }
@@ -339,5 +374,26 @@ qreal KonvergoWindow::CalculateWebScale(const QSize& size, qint32 devicePixelRat
   qreal verticalScale = (qreal)size.height() / (qreal)WEBUI_SIZE.height();
 
   qreal minScale = qMin(horizontalScale, qMin(verticalScale, (qreal)(WEBUI_MAX_HEIGHT / devicePixelRatio) / (qreal)WEBUI_SIZE.height()));
-  return ROUND(qMax(1.0, minScale));
+  qreal minWinScale = 240.0 / (qreal)WEBUI_SIZE.height();
+  return ROUND(qMax(minWinScale, minScale));
 }
+
+/////////////////////////////////////////////////////////////////////////////////////////
+QScreen* KonvergoWindow::loadLastScreen()
+{
+  QString screenName = SettingsComponent::Get().value(SETTINGS_SECTION_STATE, "lastUsedScreen").toString();
+  if (screenName.isEmpty())
+    return nullptr;
+
+  for (QScreen* scr : QGuiApplication::screens())
+  {
+    if (scr->name() == screenName)
+      return scr;
+  }
+
+  QLOG_DEBUG() << "Tried to find screen:" << screenName << "but it was not present";
+
+  return nullptr;
+}
+
+

src/ui/KonvergoWindow.h

@@ -17,6 +17,7 @@
 //
 #define WEBUI_MAX_HEIGHT 1440.0
 #define WEBUI_SIZE QSize(1280, 720)
+#define WINDOWW_MIN_SIZE QSize(426, 240)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class KonvergoWindow : public QQuickWindow
@@ -31,6 +32,7 @@ class KonvergoWindow : public QQuickWindow
   Q_PROPERTY(qreal webHeightMax READ webHeightMax NOTIFY webScaleChanged)
   Q_PROPERTY(QSize webUISize READ webUISize NOTIFY webScaleChanged)
   Q_PROPERTY(qreal windowScale READ windowScale NOTIFY webScaleChanged)
+  Q_PROPERTY(QSize windowMinSize READ windowMinSize NOTIFY webScaleChanged)
 
 public:
   static void RegisterClass();
@@ -67,6 +69,7 @@ public:
   qreal webScale() { return CalculateWebScale(size(), devicePixelRatio()); }
   qreal webHeightMax() { return WEBUI_MAX_HEIGHT; }
   QSize webUISize() { return WEBUI_SIZE; }
+  QSize windowMinSize() { return WINDOWW_MIN_SIZE; }
   static qreal CalculateScale(const QSize& size);
   static qreal CalculateWebScale(const QSize& size, qint32 devicePixelRatio);
 
@@ -87,7 +90,7 @@ private slots:
   void enableVideoWindow();
   void onVisibilityChanged(QWindow::Visibility visibility);
   void updateMainSectionSettings(const QVariantMap& values);
-  void updateFullscreenState();
+  void updateFullscreenState(bool saveGeo = true);
   void onScreenCountChanged(int newCount);
   void updateDebugInfo();
   void playerWindowVisible(bool visible);
@@ -98,6 +101,9 @@ private:
   void saveGeometry();
   void loadGeometry();
   QRect loadGeometryRect();
+  bool fitsInScreens(const QRect& rc);
+  QScreen* loadLastScreen();
+
   bool m_debugLayer;
   qreal m_lastScale;
   QTimer* m_infoTimer;

src/ui/webview.qml

@@ -9,10 +9,8 @@ KonvergoWindow
   id: mainWindow
   title: "Plex Media Player"
   objectName: "mainWindow"
-  minimumHeight: 240
-  minimumWidth: 426
-  height: 720
-  width: 1280
+  minimumHeight: windowMinSize.height
+  minimumWidth: windowMinSize.width
 
   function getInitialScaleArg()
   {
@@ -24,15 +22,6 @@ KonvergoWindow
     return webHeightMax ? ((webHeightMax / Screen.devicePixelRatio) / 720) : 10;
   }
 
-  onWebScaleChanged:
-  {
-    if (web.url == "")
-    {
-      console.log("Loading web page")
-      web.url = components.settings.value("path", "startupurl") + getInitialScaleArg();
-    }
-  }
-
   MpvVideo
   {
     id: video
@@ -53,8 +42,8 @@ KonvergoWindow
     profile.httpUserAgent: components.system.getUserAgent()
     transformOrigin: Item.TopLeft
 
-    width: Math.min((parent.height * 16) / 9, parent.width)
-    height: Math.min((parent.width * 9) / 16, parent.height)
+    width: parent.width
+    height: parent.height
     
     scale:
     {
@@ -67,14 +56,6 @@ KonvergoWindow
       }
     }
 
-    zoomFactor:
-    {
-      if (mainWindow.windowScale < 1)
-        return mainWindow.windowScale
-      else
-        return 1;
-    }
-
     Component.onCompleted:
     {
       // set the transparency
@@ -82,6 +63,7 @@ KonvergoWindow
       backgroundColor : "#111111"
       forceActiveFocus()
       mainWindow.reloadWebClient.connect(reload)
+      url = components.settings.value("path", "startupurl") + getInitialScaleArg();
     }
 
     onLoadingChanged:
@@ -175,7 +157,7 @@ KonvergoWindow
         dbg += "  DevicePixel ratio: " + Screen.devicePixelRatio + "\n";
         dbg += "  Web Max Height: " + (webHeightMax / Screen.devicePixelRatio) + " / Max scale: " + mainWindow.maxWebScale() + "\n";
         dbg += "  Web scale: " + webScale + " / Window scale: " + windowScale + "\n";
-        dbg += "  Scale applied: " + web.scale + " / Zoom: " + web.zoomFactor + "\n";
+        dbg += "  Scale applied: " + web.scale + "\n";
 
         return dbg;
       }