Start flattening Qtlib into qt

- Remove app.py from qtlib (unused)
- Remove .gitignore from qtlib (unecessary)
- Move contents of preferences.py in qtlib to qt, clean up references
- Simplify language dropdown code

qt/preferences.py

@@ -4,15 +4,176 @@
 # which should be included with this package. The terms are also available at
 # http://www.gnu.org/licenses/gpl-3.0.html
 
-from PyQt5.QtWidgets import QApplication
-from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QApplication, QDockWidget
+from PyQt5.QtCore import Qt, QSettings, QRect, QObject, pyqtSignal, QStandardPaths
 from PyQt5.QtGui import QColor
 
 from hscommon import trans
-from hscommon.plat import ISLINUX
+from hscommon.plat import ISLINUX, ISWINDOWS
 from core.app import AppMode
 from core.scanner import ScanType
-from qtlib.preferences import Preferences as PreferencesBase
+from hscommon.util import tryint
+from core.util import executable_folder
+
+from os import path as op
+
+
+def get_langnames():
+    tr = trans.trget("qtlib")  # TODO migrate this to ui instead
+    return {
+        "cs": tr("Czech"),
+        "de": tr("German"),
+        "el": tr("Greek"),
+        "en": tr("English"),
+        "es": tr("Spanish"),
+        "fr": tr("French"),
+        "hy": tr("Armenian"),
+        "it": tr("Italian"),
+        "ja": tr("Japanese"),
+        "ko": tr("Korean"),
+        "ms": tr("Malay"),
+        "nl": tr("Dutch"),
+        "pl_PL": tr("Polish"),
+        "pt_BR": tr("Brazilian"),
+        "ru": tr("Russian"),
+        "tr": tr("Turkish"),
+        "uk": tr("Ukrainian"),
+        "vi": tr("Vietnamese"),
+        "zh_CN": tr("Chinese (Simplified)"),
+    }
+
+
+def _normalize_for_serialization(v):
+    # QSettings doesn't consider set/tuple as "native" typs for serialization, so if we don't
+    # change them into a list, we get a weird serialized QVariant value which isn't a very
+    # "portable" value.
+    if isinstance(v, (set, tuple)):
+        v = list(v)
+    if isinstance(v, list):
+        v = [_normalize_for_serialization(item) for item in v]
+    return v
+
+
+def _adjust_after_deserialization(v):
+    # In some cases, when reading from prefs, we end up with strings that are supposed to be
+    # bool or int. Convert these.
+    if isinstance(v, list):
+        return [_adjust_after_deserialization(sub) for sub in v]
+    if isinstance(v, str):
+        # might be bool or int, try them
+        if v == "true":
+            return True
+        elif v == "false":
+            return False
+        else:
+            return tryint(v, v)
+    return v
+
+
+def create_qsettings():
+    # Create a QSettings instance with the correct arguments.
+    config_location = op.join(executable_folder(), "settings.ini")
+    if op.isfile(config_location):
+        settings = QSettings(config_location, QSettings.IniFormat)
+        settings.setValue("Portable", True)
+    elif ISWINDOWS:
+        # On windows use an ini file in the AppDataLocation instead of registry if possible as it
+        # makes it easier for a user to clear it out when there are issues.
+        locations = QStandardPaths.standardLocations(QStandardPaths.AppDataLocation)
+        if locations:
+            settings = QSettings(op.join(locations[0], "settings.ini"), QSettings.IniFormat)
+        else:
+            settings = QSettings()
+        settings.setValue("Portable", False)
+    else:
+        settings = QSettings()
+        settings.setValue("Portable", False)
+    return settings
+
+
+class PreferencesBase(QObject):
+    prefsChanged = pyqtSignal()
+
+    def __init__(self):
+        QObject.__init__(self)
+        self.reset()
+        self._settings = create_qsettings()
+
+    def _load_values(self, settings):
+        # Implemented in subclasses
+        pass
+
+    def get_rect(self, name, default=None):
+        r = self.get_value(name, default)
+        if r is not None:
+            return QRect(*r)
+        else:
+            return None
+
+    def get_value(self, name, default=None):
+        if self._settings.contains(name):
+            result = _adjust_after_deserialization(self._settings.value(name))
+            if result is not None:
+                return result
+            else:
+                # If result is None, but still present in self._settings, it usually means a value
+                # like "@Invalid".
+                return default
+        else:
+            return default
+
+    def load(self):
+        self.reset()
+        self._load_values(self._settings)
+
+    def reset(self):
+        # Implemented in subclasses
+        pass
+
+    def _save_values(self, settings):
+        # Implemented in subclasses
+        pass
+
+    def save(self):
+        self._save_values(self._settings)
+        self._settings.sync()
+
+    def set_rect(self, name, r):
+        # About QRect conversion:
+        # I think Qt supports putting basic structures like QRect directly in QSettings, but I prefer not
+        # to rely on it and stay with generic structures.
+        if isinstance(r, QRect):
+            rect_as_list = [r.x(), r.y(), r.width(), r.height()]
+            self.set_value(name, rect_as_list)
+
+    def set_value(self, name, value):
+        self._settings.setValue(name, _normalize_for_serialization(value))
+
+    def saveGeometry(self, name, widget):
+        # We save geometry under a 7-sized int array: first item is a flag
+        # for whether the widget is maximized, second item is a flag for whether
+        # the widget is docked, third item is a Qt::DockWidgetArea enum value,
+        # and the other 4 are (x, y, w, h).
+        m = 1 if widget.isMaximized() else 0
+        d = 1 if isinstance(widget, QDockWidget) and not widget.isFloating() else 0
+        area = widget.parent.dockWidgetArea(widget) if d else 0
+        r = widget.geometry()
+        rect_as_list = [r.x(), r.y(), r.width(), r.height()]
+        self.set_value(name, [m, d, area] + rect_as_list)
+
+    def restoreGeometry(self, name, widget):
+        geometry = self.get_value(name)
+        if geometry and len(geometry) == 7:
+            m, d, area, x, y, w, h = geometry
+            if m:
+                widget.setWindowState(Qt.WindowMaximized)
+            else:
+                r = QRect(x, y, w, h)
+                widget.setGeometry(r)
+                if isinstance(widget, QDockWidget):
+                    # Inform of the previous dock state and the area used
+                    return bool(d), area
+        return False, 0
 
 
 class Preferences(PreferencesBase):