Use the new restore geometry code

2025-07-09 03:04:10 -04:00 · 2022-10-19 12:38:29 +05:30 · 2022-10-19 12:38:29 +05:30 · de88d2fd39
commit de88d2fd39
parent 0d8c25f89e
40 changed files with 174 additions and 311 deletions
--- a/src/calibre/customize/init.py
+++ b/src/calibre/customize/init.py
@ -146,19 +146,9 @@ class Plugin:  # {{{
        from calibre.gui2 import gprefs

        prefname = 'plugin config dialog:'+self.type + ':' + self.name
-        geom = gprefs.get(prefname, None)
-
        config_dialog = QDialog(parent)
        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        v = QVBoxLayout(config_dialog)
-
-        def size_dialog():
-            if geom is None:
-                config_dialog.resize(config_dialog.sizeHint())
-            else:
-                from qt.core import QApplication
-                QApplication.instance().safe_restore_geometry(config_dialog, geom)
-
        button_box.accepted.connect(config_dialog.accept)
        button_box.rejected.connect(config_dialog.reject)
        config_dialog.setWindowTitle(_('Customize') + ' ' + self.name)
@ -176,7 +166,7 @@ class Plugin:  # {{{
        if config_widget is not None:
            v.addWidget(config_widget)
            v.addWidget(button_box)
-            size_dialog()
+            config_dialog.restore_geometry(gprefs, prefname)
            config_dialog.exec()

            if config_dialog.result() == QDialog.DialogCode.Accepted:
@ -201,16 +191,14 @@ class Plugin:  # {{{
            sc = QLineEdit(sc, config_dialog)
            v.addWidget(sc)
            v.addWidget(button_box)
-            size_dialog()
+            config_dialog.restore_geometry(gprefs, prefname)
            config_dialog.exec()

            if config_dialog.result() == QDialog.DialogCode.Accepted:
                sc = str(sc.text()).strip()
                customize_plugin(self, sc)

-        geom = bytearray(config_dialog.saveGeometry())
-        gprefs[prefname] = geom
-
+        config_dialog.save_geometry(gprefs, prefname)
        return config_dialog.result()

    def load_resources(self, names):
--- a/src/calibre/gui2/convert/bulk.py
+++ b/src/calibre/gui2/convert/bulk.py
@ -4,7 +4,7 @@ __docformat__ = 'restructuredtext en'

 import shutil

-from qt.core import QModelIndex, QDialog, QApplication, QDialogButtonBox
+from qt.core import QModelIndex, QDialog, QDialogButtonBox

 from calibre.gui2.convert.single import Config, GroupModel, gprefs
 from calibre.gui2.convert.look_and_feel import LookAndFeelWidget
@ -61,11 +61,7 @@ class BulkConfig(Config):
                'settings.'))
            o.setChecked(False)

-        geom = gprefs.get('convert_bulk_dialog_geom', None)
-        if geom:
-            QApplication.instance().safe_restore_geometry(self, geom)
-        else:
-            self.resize(self.sizeHint())
+        self.restore_geometry(gprefs, 'convert_bulk_dialog_geom')

    def setup_pipeline(self, *args):
        oidx = self.groups.currentIndex().row()
@ -140,6 +136,5 @@ class BulkConfig(Config):

    def done(self, r):
        if self.isVisible():
-            gprefs['convert_bulk_dialog_geom'] = \
-                bytearray(self.saveGeometry())
+            self.save_geometry(gprefs, 'convert_bulk_dialog_geom')
        return QDialog.done(self, r)
--- a/src/calibre/gui2/convert/regex_builder.py
+++ b/src/calibre/gui2/convert/regex_builder.py
@ -4,7 +4,7 @@
 import os
 from contextlib import suppress
 from qt.core import (
-    QApplication, QBrush, QByteArray, QDialog, QDialogButtonBox, Qt, QTextCursor,
+    QApplication, QBrush, QDialog, QDialogButtonBox, Qt, QTextCursor,
    QTextEdit, pyqtSignal
 )

@ -49,14 +49,11 @@ class RegexBuilder(QDialog, Ui_RegexBuilder):
        self.test.setDefault(True)

        self.match_locs = []
-        geom = gprefs.get('regex_builder_geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
+        self.restore_geometry(gprefs, 'regex_builder_geometry')
        self.finished.connect(self.save_state)

    def save_state(self, result):
-        geom = bytearray(self.saveGeometry())
-        gprefs['regex_builder_geometry'] = geom
+        self.save_geometry(gprefs, 'regex_builder_geometry')

    def regex_valid(self):
        regex = str(self.regex.text())
--- a/src/calibre/gui2/convert/single.py
+++ b/src/calibre/gui2/convert/single.py
@ -8,7 +8,7 @@ from qt.core import (
    QAbstractListModel, QCheckBox, QComboBox, QDialog,
    QDialogButtonBox, QFont, QFrame, QGridLayout, QHBoxLayout, QIcon, QLabel,
    QListView, QModelIndex, QScrollArea, QSize, QSizePolicy, QSpacerItem,
-    Qt, QTextEdit, QWidget, QApplication
+    Qt, QTextEdit, QWidget
 )

 from calibre.customize.conversion import OptionRecommendation
@ -88,11 +88,7 @@ class Config(QDialog):
        rb.setIcon(QIcon.ic('clear_left.png'))
        rb.clicked.connect(self.restore_defaults)
        self.groups.setMouseTracking(True)
-        geom = gprefs.get('convert_single_dialog_geom', None)
-        if geom:
-            QApplication.instance().safe_restore_geometry(self, geom)
-        else:
-            self.resize(self.sizeHint())
+        self.restore_geometry(gprefs, 'convert_single_dialog_geom')

    def current_group_changed(self, cur, prev):
        self.show_pane(cur)
@ -303,8 +299,7 @@ class Config(QDialog):

    def done(self, r):
        if self.isVisible():
-            gprefs['convert_single_dialog_geom'] = \
-                bytearray(self.saveGeometry())
+            self.save_geometry(gprefs, 'convert_single_dialog_geom')
        return QDialog.done(self, r)

    def break_cycles(self):
--- a/src/calibre/gui2/cover_flow.py
+++ b/src/calibre/gui2/cover_flow.py
@ -257,11 +257,7 @@ class CBDialog(QDialog):
        self.setWindowTitle(_('Browse by covers'))
        self.layout().addWidget(cover_flow)

-        geom = gprefs.get('cover_browser_dialog_geometry', None)
-        if not geom or not QApplication.instance().safe_restore_geometry(self, geom):
-            sz = self.screen().availableSize()
-            h, w = sz.height()-60, int(sz.width()/1.5)
-            self.resize(w, h)
+        self.restore_geometry(gprefs, 'cover_browser_dialog_geometry')
        self.action_fs_toggle = a = QAction(self)
        self.addAction(a)
        a.setShortcuts([QKeySequence(QKeySequence.StandardKey.FullScreen)])
@ -291,10 +287,15 @@ class CBDialog(QDialog):
            menuless_qaction.shortcuts()))
        a.triggered.connect(iactions['Send To Device'].menuless_qaction.trigger)

+    def sizeHint(self):
+        sz = self.screen().availableSize()
+        sz.setHeight(sz.height()-60)
+        sz.setWidth(int(sz.width()/1.5))
+        return sz
+
    def closeEvent(self, *args):
        if not self.isFullScreen():
-            geom = bytearray(self.saveGeometry())
-            gprefs['cover_browser_dialog_geometry'] = geom
+            self.save_geometry(gprefs, 'cover_browser_dialog_geometry')
        self.closed.emit()

    def show_normal(self):
--- a/src/calibre/gui2/covers.py
+++ b/src/calibre/gui2/covers.py
@ -6,7 +6,7 @@ from collections import OrderedDict
 from contextlib import suppress
 from copy import deepcopy
 from qt.core import (
-    QApplication, QCheckBox, QColor, QColorDialog, QDialog, QDialogButtonBox,
+    QCheckBox, QColor, QColorDialog, QDialog, QDialogButtonBox,
    QFormLayout, QFrame, QGridLayout, QHBoxLayout, QIcon, QInputDialog, QLabel,
    QLineEdit, QListWidget, QListWidgetItem, QMenu, QPixmap, QPushButton, QSize,
    QSizePolicy, QSpinBox, Qt, QTabWidget, QTimer, QToolButton, QVBoxLayout, QWidget,
@ -554,9 +554,7 @@ class CoverSettingsDialog(QDialog):
            ' the list of checked styles/colors.'))

        self.resize(self.sizeHint())
-        geom = gprefs.get('cover_settings_dialog_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'cover_settings_dialog_geom')
        self.prefs_for_rendering = None

    def restore_defaults(self):
@ -592,7 +590,7 @@ class CoverSettingsDialog(QDialog):

    def _save_settings(self):
        gprefs.set('cover_generation_save_settings_for_future', self.save_settings.isChecked())
-        gprefs.set('cover_settings_dialog_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'cover_settings_dialog_geom')
        self.settings.save_state()

    def accept(self):
--- a/src/calibre/gui2/dialogs/authors_edit.py
+++ b/src/calibre/gui2/dialogs/authors_edit.py
@ -155,20 +155,15 @@ class AuthorsEdit(QDialog):

        l.setColumnStretch(0, 10)
        self.resize(self.sizeHint() + QSize(150, 100))
-        geom = gprefs.get('authors-edit-geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'authors-edit-geometry')
        self.author.setFocus(Qt.FocusReason.OtherFocusReason)

-    def save_geometry(self):
-        gprefs.set('authors-edit-geometry', bytearray(self.saveGeometry()))
-
    def accept(self):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'authors-edit-geometry')
        return QDialog.accept(self)

    def reject(self):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'authors-edit-geometry')
        return QDialog.reject(self)

    @property
--- a/src/calibre/gui2/dialogs/book_info.py
+++ b/src/calibre/gui2/dialogs/book_info.py
@ -198,17 +198,11 @@ class BookInfo(QDialog):
        self.previous_button.setToolTip(_('Previous [%s]')%
                str(self.ps.key().toString(QKeySequence.SequenceFormat.NativeText)))

-        geom = self.screen().availableSize()
-        screen_height = geom.height() - 100
-        screen_width = geom.width() - 100
-        self.resize(max(int(screen_width/2), 700), screen_height)
-        saved_layout = gprefs.get('book_info_dialog_layout', None)
-        if saved_layout is not None:
-            try:
-                QApplication.instance().safe_restore_geometry(self, saved_layout[0])
-                self.splitter.restoreState(saved_layout[1])
-            except Exception:
-                pass
+        self.restore_geometry(gprefs, 'book_info_dialog_geometry')
+        try:
+            self.splitter.restoreState(gprefs.get('book_info_dialog_splitter_state'))
+        except Exception:
+            pass
        ema = get_gui().iactions['Edit Metadata'].menuless_qaction
        a = self.ema = QAction('edit metadata', self)
        a.setShortcut(ema.shortcut())
@ -220,6 +214,15 @@ class BookInfo(QDialog):
        a.triggered.connect(self.view_book)
        self.addAction(a)

+    def sizeHint(self):
+        try:
+            geom = self.screen().availableSize()
+            screen_height = geom.height() - 100
+            screen_width = geom.width() - 100
+            return QSize(max(int(screen_width/2), 700), screen_height)
+        except Exception:
+            return QSize(800, 600)
+
    def view_book(self):
        if self.current_row is not None:
            book_id = self.view.model().id(self.current_row)
@ -243,8 +246,8 @@ class BookInfo(QDialog):
        self.link_delegate(link)

    def done(self, r):
-        saved_layout = (bytearray(self.saveGeometry()), bytearray(self.splitter.saveState()))
-        gprefs.set('book_info_dialog_layout', saved_layout)
+        self.save_geometry(gprefs, 'book_info_dialog_geometry')
+        gprefs['book_info_dialog_splitter_state'] = bytearray(self.splitter.saveState())
        ret = QDialog.done(self, r)
        self.view.model().new_bookdisplay_data.disconnect(self.slave)
        self.view = self.link_delegate = self.gui = None
--- a/src/calibre/gui2/dialogs/catalog.py
+++ b/src/calibre/gui2/dialogs/catalog.py
@ -10,7 +10,7 @@ import os
 import sys
 import weakref
 from qt.core import (
-    QApplication, QDialog, QDialogButtonBox, QScrollArea, QSize
+    QDialog, QDialogButtonBox, QScrollArea, QSize
 )

 from calibre.customize import PluginInstallationType
@ -132,11 +132,7 @@ class Catalog(QDialog, Ui_Dialog):
        self.buttonBox.button(QDialogButtonBox.StandardButton.Help).clicked.connect(self.help)
        self.show_plugin_tab(None)

-        geom = dynamic.get('catalog_window_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, bytes(geom))
-        else:
-            self.resize(self.sizeHint())
+        self.restore_geometry(dynamic, 'catalog_window_geom')
        g = self.screen().availableSize()
        self.setMaximumWidth(g.width() - 50)
        self.setMaximumHeight(g.height() - 50)
@ -202,7 +198,7 @@ class Catalog(QDialog, Ui_Dialog):
        dynamic.set('catalog_last_used_title', self.catalog_title)
        self.catalog_sync = bool(self.sync.isChecked())
        dynamic.set('catalog_sync_to_device', self.catalog_sync)
-        dynamic.set('catalog_window_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(dynamic, 'catalog_window_geom')
        dynamic.set('catalog_add_to_library', self.add_to_library.isChecked())

    def apply(self, *args):
@ -239,5 +235,5 @@ class Catalog(QDialog, Ui_Dialog):
                    show=True)

    def reject(self):
-        dynamic.set('catalog_window_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(dynamic, 'catalog_window_geom')
        QDialog.reject(self)
--- a/src/calibre/gui2/dialogs/comments_dialog.py
+++ b/src/calibre/gui2/dialogs/comments_dialog.py
@ -6,8 +6,8 @@ __docformat__ = 'restructuredtext en'
 __license__   = 'GPL v3'

 from qt.core import (
-    QApplication, QDialog, QDialogButtonBox, QPlainTextEdit, QSize, Qt,
-    QVBoxLayout, QLabel, QHBoxLayout, pyqtSignal
+    QDialog, QDialogButtonBox, QHBoxLayout, QLabel, QPlainTextEdit, QSize, Qt,
+    QVBoxLayout, pyqtSignal,
 )

 from calibre.gui2 import Application, gprefs
@ -40,29 +40,21 @@ class CommentsDialog(QDialog):

        if column_name:
            self.setWindowTitle(_('Edit "{0}"').format(column_name))
-
-        geom = gprefs.get('comments_dialog_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
-        else:
-            self.resize(self.sizeHint())
+        self.restore_geometry(gprefs, 'comments_dialog_geom')

    def sizeHint(self):
        return QSize(650, 600)

-    def save_geometry(self):
-        gprefs.set('comments_dialog_geom', bytearray(self.saveGeometry()))
-
    def accept(self):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'comments_dialog_geom')
        QDialog.accept(self)

    def reject(self):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'comments_dialog_geom')
        QDialog.reject(self)

    def closeEvent(self, ev):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'comments_dialog_geom')
        return QDialog.closeEvent(self, ev)


--- a/src/calibre/gui2/dialogs/duplicates.py
+++ b/src/calibre/gui2/dialogs/duplicates.py
@ -59,9 +59,7 @@ class DuplicatesQuestion(QDialog):
        cb.clicked.connect(self.copy_to_clipboard)

        self.resize(self.sizeHint())
-        geom = gprefs.get('duplicates-question-dialog-geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'duplicates-question-dialog-geometry')
        self.exec()

    def copy_to_clipboard(self):
@ -87,7 +85,7 @@ class DuplicatesQuestion(QDialog):
        QDialog.accept(self)

    def save_geometry(self):
-        gprefs.set('duplicates-question-dialog-geometry', bytearray(self.saveGeometry()))
+        super().save_geometry(gprefs, 'duplicates-question-dialog-geometry')

    def process_duplicates(self, db, duplicates):
        ta = _('%(title)s by %(author)s [%(formats)s]')
--- a/src/calibre/gui2/dialogs/edit_authors_dialog.py
+++ b/src/calibre/gui2/dialogs/edit_authors_dialog.py
@ -10,7 +10,7 @@ from contextlib import contextmanager

 from qt.core import (Qt, QDialog, QTableWidgetItem, QAbstractItemView, QIcon,
                  QDialogButtonBox, QFrame, QLabel, QTimer, QMenu, QApplication,
-                  QByteArray, QItemDelegate, QAction)
+                  QItemDelegate, QAction)

 from calibre.ebooks.metadata import author_to_author_sort, string_to_authors
 from calibre.gui2 import error_dialog, gprefs
@ -78,9 +78,7 @@ class EditAuthorsDialog(QDialog, Ui_EditAuthorsDialog):
        try:
            self.table_column_widths = \
                        gprefs.get('manage_authors_table_widths', None)
-            geom = gprefs.get('manage_authors_dialog_geometry', None)
-            if geom:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
+            self.restore_geometry(gprefs, 'manage_authors_dialog_geometry')
        except Exception:
            pass

@ -275,7 +273,7 @@ class EditAuthorsDialog(QDialog, Ui_EditAuthorsDialog):
        for c in range(0, self.table.columnCount()):
            self.table_column_widths.append(self.table.columnWidth(c))
        gprefs['manage_authors_table_widths'] = self.table_column_widths
-        gprefs['manage_authors_dialog_geometry'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'manage_authors_dialog_geometry')

    def table_column_resized(self, col, old, new):
        self.table_column_widths = []
--- a/src/calibre/gui2/dialogs/enum_values_edit.py
+++ b/src/calibre/gui2/dialogs/enum_values_edit.py
@ -2,7 +2,7 @@
 # License: GPLv3 Copyright: 2020, Charles Haley

 from qt.core import (QDialog, QColor, QDialogButtonBox, QHeaderView,
-                      QApplication, QGridLayout, QTableWidget,
+                      QGridLayout, QTableWidget,
                      QTableWidgetItem, QVBoxLayout, QToolButton, QIcon,
                      QAbstractItemView, QComboBox)

@ -77,9 +77,7 @@ class EnumValuesEdit(QDialog):
        self.ins_button.clicked.connect(self.ins_button_clicked)
        self.move_down_button.clicked.connect(self.move_down_clicked)
        self.move_up_button.clicked.connect(self.move_up_clicked)
-        geom = gprefs.get('enum-values-edit-geometry')
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'enum-values-edit-geometry')

    def sizeHint(self):
        sz = QDialog.sizeHint(self)
@ -144,7 +142,7 @@ class EnumValuesEdit(QDialog):
        self.table.setCellWidget(row, 1, c)

    def save_geometry(self):
-        gprefs.set('enum-values-edit-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'enum-values-edit-geometry')

    def accept(self):
        disp = self.fm['display']
--- a/src/calibre/gui2/dialogs/match_books.py
+++ b/src/calibre/gui2/dialogs/match_books.py
@ -7,7 +7,7 @@ __docformat__ = 'restructuredtext en'


 from qt.core import (Qt, QDialog, QAbstractItemView, QTableWidgetItem,
-                      QByteArray, QApplication, QCursor, QTimer)
+                      QApplication, QCursor, QTimer)

 from calibre.gui2 import gprefs, error_dialog
 from calibre.gui2.dialogs.match_books_ui import Ui_MatchBooks
@ -56,9 +56,7 @@ class MatchBooks(QDialog, Ui_MatchBooks):
        try:
            self.books_table_column_widths = \
                        gprefs.get('match_books_dialog_books_table_widths', None)
-            geom = gprefs.get('match_books_dialog_geometry', None)
-            if geom:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
+            self.restore_geometry(gprefs, 'match_books_dialog_geometry')
        except:
            pass

@ -189,7 +187,7 @@ class MatchBooks(QDialog, Ui_MatchBooks):
        for c in range(0, self.books_table.columnCount()):
            self.books_table_column_widths.append(self.books_table.columnWidth(c))
        gprefs['match_books_dialog_books_table_widths'] = self.books_table_column_widths
-        gprefs['match_books_dialog_geometry'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'match_books_dialog_geometry')
        self.search_text.save_history()

    def close(self):
--- a/src/calibre/gui2/dialogs/message_box.py
+++ b/src/calibre/gui2/dialogs/message_box.py
@ -227,22 +227,22 @@ class ViewLog(QDialog):  # {{{

        self.unique_name = unique_name or 'view-log-dialog'
        self.finished.connect(self.dialog_closing)
-        self.resize(QSize(700, 500))
-        geom = gprefs.get(self.unique_name, None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, self.unique_name)

        self.setModal(False)
        self.setWindowTitle(title)
        self.setWindowIcon(QIcon.ic('debug.png'))
        self.show()

+    def sizeHint(self):
+        return QSize(700, 500)
+
    def copy_to_clipboard(self):
        txt = self.tb.toPlainText()
        QApplication.clipboard().setText(txt)

    def dialog_closing(self, result):
-        gprefs[self.unique_name] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, self.unique_name)
 # }}}


--- a/src/calibre/gui2/dialogs/metadata_bulk.py
+++ b/src/calibre/gui2/dialogs/metadata_bulk.py
@ -567,11 +567,7 @@ class MetadataBulkDialog(QDialog, Ui_MetadataBulkDialog):
            'This operation cannot be canceled or undone'))
        self.do_again = False
        self.central_widget.setCurrentIndex(tab)
-        geom = gprefs.get('bulk_metadata_window_geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, bytes(geom))
-        else:
-            self.resize(self.sizeHint())
+        self.restore_geometry(gprefs, 'bulk_metadata_window_geometry')
        ct = gprefs.get('bulk_metadata_window_tab', 0)
        self.central_widget.setCurrentIndex(ct)
        self.languages.init_langs(self.db)
@ -606,8 +602,7 @@ class MetadataBulkDialog(QDialog, Ui_MetadataBulkDialog):
        gprefs['refresh_book_list_on_bulk_edit'] = bool(self.refresh_book_list.isChecked())

    def save_state(self, *args):
-        gprefs['bulk_metadata_window_geometry'] = \
-            bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'bulk_metadata_window_geometry')
        gprefs['bulk_metadata_window_tab'] = self.central_widget.currentIndex()

    def do_apply_pubdate(self, *args):
@ -1303,7 +1298,7 @@ class MetadataBulkDialog(QDialog, Ui_MetadataBulkDialog):
        self.query_field.setCurrentIndex(0)

        if item_name in list(self.queries.keys()):
-            del(self.queries[item_name])
+            del self.queries[item_name]
            self.queries.commit()

    def s_r_save_query(self, *args):
--- a/src/calibre/gui2/dialogs/plugin_updater.py
+++ b/src/calibre/gui2/dialogs/plugin_updater.py
@ -9,7 +9,7 @@ import datetime
 import re
 import traceback
 from qt.core import (
-    QAbstractItemView, QAbstractTableModel, QAction, QApplication, QBrush, QComboBox,
+    QAbstractItemView, QAbstractTableModel, QAction, QBrush, QComboBox,
    QDialog, QDialogButtonBox, QFont, QFrame, QHBoxLayout, QIcon, QLabel, QLineEdit,
    QModelIndex, QSize, QSortFilterProxyModel, Qt, QTableView, QUrl, QVBoxLayout
 )
@ -155,18 +155,17 @@ class SizePersistedDialog(QDialog):
    def __init__(self, parent, unique_pref_name):
        QDialog.__init__(self, parent)
        self.unique_pref_name = unique_pref_name
-        self.geom = gprefs.get(unique_pref_name, None)
        self.finished.connect(self.dialog_closing)

+    def sizeHint(self):
+        ans = super().sizeHint()
+        return ans + self.initial_extra_size
+
    def resize_dialog(self):
-        if self.geom is None:
-            self.resize(self.sizeHint()+self.initial_extra_size)
-        else:
-            QApplication.instance().safe_restore_geometry(self, self.geom)
+        self.restore_geometry(gprefs, self.unique_pref_name)

    def dialog_closing(self, result):
-        geom = bytearray(self.saveGeometry())
-        gprefs[self.unique_pref_name] = geom
+        self.save_geometry(gprefs, self.unique_pref_name)


 class PluginFilterComboBox(QComboBox):
--- a/src/calibre/gui2/dialogs/quickview.py
+++ b/src/calibre/gui2/dialogs/quickview.py
@ -11,7 +11,7 @@ from functools import partial

 from qt.core import (
    Qt, QDialog, QAbstractItemView, QTableWidgetItem, QIcon, QListWidgetItem,
-    QCoreApplication, QEvent, QObject, QApplication, pyqtSignal, QByteArray, QMenu,
+    QCoreApplication, QEvent, QObject, QApplication, pyqtSignal, QMenu,
    QShortcut, QTimer, QStyle)

 from calibre.customize.ui import find_plugin
@ -175,9 +175,7 @@ class Quickview(QDialog, Ui_Quickview):
            self.books_table_column_widths = \
                        gprefs.get('quickview_dialog_books_table_widths', None)
            if not self.is_pane:
-                geom = gprefs.get('quickview_dialog_geometry', None)
-                if geom:
-                    QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
+                self.restore_geometry(gprefs, 'quickview_dialog_geometry')
        except:
            pass

@ -824,7 +822,7 @@ class Quickview(QDialog, Ui_Quickview):
            self.books_table_column_widths.append(self.books_table.columnWidth(c))
        gprefs['quickview_dialog_books_table_widths'] = self.books_table_column_widths
        if not self.is_pane:
-            gprefs['quickview_dialog_geometry'] = bytearray(self.saveGeometry())
+            self.save_geometry(gprefs, 'quickview_dialog_geometry')

    def _close(self):
        self.save_state()
--- a/src/calibre/gui2/dialogs/scheduler.py
+++ b/src/calibre/gui2/dialogs/scheduler.py
@ -12,7 +12,7 @@ from collections import OrderedDict
 from contextlib import suppress

 from qt.core import (
-    QDialog, Qt, QTime, QObject, QMenu, QHBoxLayout, QAction, QIcon, QRecursiveMutex, QApplication,
+    QDialog, Qt, QTime, QObject, QMenu, QHBoxLayout, QAction, QIcon, QRecursiveMutex,
    QTimer, pyqtSignal, QWidget, QGridLayout, QCheckBox, QTimeEdit, QLabel,
    QLineEdit, QDoubleSpinBox, QSize, QTreeView, QSizePolicy, QToolButton,
    QFrame, QVBoxLayout, QTabWidget, QSpacerItem, QGroupBox,
@ -370,9 +370,7 @@ class SchedulerDialog(QDialog):
        b.clicked.connect(self.download_clicked)
        self.l.addWidget(bb, 3, 1, 1, 1)

-        geom = gprefs.get('scheduler_dialog_geometry')
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'scheduler_dialog_geometry')

    def sizeHint(self):
        return QSize(800, 600)
@ -425,16 +423,13 @@ class SchedulerDialog(QDialog):
    def accept(self):
        if not self.commit():
            return False
-        self.save_geometry()
+        self.save_geometry(gprefs, 'scheduler_dialog_geometry')
        return QDialog.accept(self)

    def reject(self):
-        self.save_geometry()
+        self.save_geometry(gprefs, 'scheduler_dialog_geometry')
        return QDialog.reject(self)

-    def save_geometry(self):
-        gprefs.set('scheduler_dialog_geometry', bytearray(self.saveGeometry()))
-
    def download_clicked(self, *args):
        self.commit()
        if self.commit() and self.current_urn:
--- a/src/calibre/gui2/dialogs/tag_editor.py
+++ b/src/calibre/gui2/dialogs/tag_editor.py
@ -2,8 +2,7 @@ __license__   = 'GPL v3'
 __copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'

 from qt.core import (
-    QAbstractItemView, QApplication, QDialog, QSortFilterProxyModel,
-    QStringListModel, Qt
+    QAbstractItemView, QDialog, QSortFilterProxyModel, QStringListModel, Qt,
 )

 from calibre.constants import islinux
@ -112,9 +111,7 @@ class TagEditor(QDialog, Ui_TagEditor):
            self.available_tags.activated.connect(self.apply_tags)
            self.applied_tags.activated.connect(self.unapply_tags)

-        geom = gprefs.get('tag_editor_geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'tag_editor_geometry')

    def edit_box_changed(self, which):
        gprefs['tag_editor_last_filter'] = which
@ -227,7 +224,7 @@ class TagEditor(QDialog, Ui_TagEditor):
        return QDialog.reject(self)

    def save_state(self):
-        gprefs['tag_editor_geometry'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'tag_editor_geometry')


 if __name__ == '__main__':
--- a/src/calibre/gui2/dialogs/tag_list_editor.py
+++ b/src/calibre/gui2/dialogs/tag_list_editor.py
@ -4,7 +4,7 @@

 from functools import partial

-from qt.core import (Qt, QDialog, QTableWidgetItem, QIcon, QByteArray, QSize, QAbstractItemView,
+from qt.core import (Qt, QDialog, QTableWidgetItem, QIcon, QSize, QAbstractItemView,
                      QDialogButtonBox, QItemDelegate, QApplication,
                      pyqtSignal, QAction, QFrame, QLabel, QTimer, QMenu, QColor)

@ -240,15 +240,7 @@ class TagListEditor(QDialog, Ui_TagListEditor):

        self.table.setEditTriggers(QAbstractItemView.EditTrigger.EditKeyPressed)

-        try:
-            geom = gprefs.get('tag_list_editor_dialog_geometry', None)
-            if geom is not None:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
-            else:
-                self.resize(self.sizeHint()+QSize(150, 100))
-        except:
-            pass
-
+        self.restore_geometry(gprefs, 'tag_list_editor_dialog_geometry')
        self.is_enumerated = False
        if fm:
            if fm['datatype'] == 'enumeration':
@ -261,6 +253,9 @@ class TagListEditor(QDialog, Ui_TagListEditor):
        self.table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.table.customContextMenuRequested.connect(self.show_context_menu)

+    def sizeHint(self):
+        return super().sizeHint() + QSize(150, 100)
+
    def show_context_menu(self, point):
        idx = self.table.indexAt(point)
        if idx.column() != 0:
@ -510,7 +505,7 @@ class TagListEditor(QDialog, Ui_TagListEditor):

    def save_geometry(self):
        gprefs['tag_list_editor_table_widths'] = self.table_column_widths
-        gprefs['tag_list_editor_dialog_geometry'] = bytearray(self.saveGeometry())
+        super().save_geometry(gprefs, 'tag_list_editor_dialog_geometry')

    def start_editing(self, on_row):
        items = self.table.selectedItems()
--- a/src/calibre/gui2/dialogs/template_dialog.py
+++ b/src/calibre/gui2/dialogs/template_dialog.py
@ -10,7 +10,7 @@ from functools import partial

 from qt.core import (Qt, QDialog, QDialogButtonBox, QSyntaxHighlighter, QFont,
                      QApplication, QTextCharFormat, QColor, QCursor,
-                      QIcon, QSize, QPalette, QLineEdit, QByteArray, QFontInfo,
+                      QIcon, QSize, QPalette, QLineEdit, QFontInfo,
                      QFontDatabase, QVBoxLayout, QTableWidget, QTableWidgetItem,
                      QComboBox, QAbstractItemView, QTextOption, QFontMetrics)

@ -474,12 +474,7 @@ class TemplateDialog(QDialog, Ui_TemplateDialog):
        self.textbox.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.textbox.customContextMenuRequested.connect(self.show_context_menu)
        # Now geometry
-        try:
-            geom = gprefs.get('template_editor_dialog_geometry', None)
-            if geom is not None:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
-        except Exception:
-            pass
+        self.restore_geometry(gprefs, 'template_editor_dialog_geometry')

    def setup_saved_template_editor(self, show_buttonbox, show_doc_and_name):
        self.buttonBox.setVisible(show_buttonbox)
@ -842,7 +837,7 @@ def evaluate(book, context):

    def save_geometry(self):
        gprefs['template_editor_table_widths'] = self.table_column_widths
-        gprefs['template_editor_dialog_geometry'] = bytearray(self.saveGeometry())
+        super().save_geometry(gprefs, 'template_editor_dialog_geometry')

    def keyPressEvent(self, ev):
        if ev.key() == Qt.Key.Key_Escape:
@ -964,12 +959,7 @@ class BreakReporter(QDialog):
            itm.setToolTip(_('The value of the variable'))
            self.table.setItem(i+2, 1, itm)

-        try:
-            geom = gprefs.get('template_editor_break_geometry', None)
-            if geom is not None:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
-        except Exception:
-            pass
+        self.restore_geometry(gprefs, 'template_editor_break_geometry')

    def get_field_value(self, field):
        val = self.mi.format_field('timestamp' if field == 'date' else field)[1]
@ -990,7 +980,7 @@ class BreakReporter(QDialog):
        return sorted(keys)

    def save_geometry(self):
-        gprefs['template_editor_break_geometry'] = bytearray(self.saveGeometry())
+        super().save_geometry(gprefs, 'template_editor_break_geometry')
        gprefs['template_editor_break_table_widths'] = self.table_column_widths

    def reject(self):
--- a/src/calibre/gui2/dialogs/trim_image.py
+++ b/src/calibre/gui2/dialogs/trim_image.py
@ -7,7 +7,7 @@ __copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
 import os
 import sys
 from qt.core import (
-    QApplication, QDialog, QDialogButtonBox, QHBoxLayout, QIcon, QKeySequence,
+    QDialog, QDialogButtonBox, QHBoxLayout, QIcon, QKeySequence,
    QLabel, QSize, Qt, QToolBar, QVBoxLayout
 )

@ -66,13 +66,13 @@ class TrimImage(QDialog):
        h.addStretch(10)
        h.addWidget(bb)

-        self.resize(QSize(900, 600))
-        geom = gprefs.get('image-trim-dialog-geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'image-trim-dialog-geometry')
        self.setWindowIcon(self.trim_action.icon())
        self.image_data = None

+    def sizeHint(self):
+        return QSize(900, 600)
+
    def do_trim(self):
        self.canvas.trim_image()
        self.selection_changed(False)
@ -95,7 +95,7 @@ class TrimImage(QDialog):

    def cleanup(self):
        self.canvas.break_cycles()
-        gprefs.set('image-trim-dialog-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'image-trim-dialog-geometry')

    def accept(self):
        if self.trim_action.isEnabled():
--- a/src/calibre/gui2/image_popup.py
+++ b/src/calibre/gui2/image_popup.py
@ -179,9 +179,7 @@ class ImageView(QDialog):
        h.addWidget(i), h.addStretch(), h.addWidget(bb)
        if self.fit_image.isChecked():
            self.set_to_viewport_size()
-        geom = self.prefs.get(self.geom_name)
-        if geom is not None:
-            self.restoreGeometry(geom)
+        self.restore_geometry(self.prefs, self.geom_name)
        fo.setChecked(self.isFullScreen())
        fo.toggled.connect(self.toggle_fullscreen)

@ -284,9 +282,7 @@ class ImageView(QDialog):
        self.label.setPixmap(self.current_img)
        self.label.adjustSize()
        self.resize(QSize(int(geom.width()/2.5), geom.height()-50))
-        geom = self.prefs.get(self.geom_name, None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(self.prefs, self.geom_name)
        try:
            self.current_image_name = str(self.current_url.toString(NO_URL_FORMATTING)).rpartition('/')[-1]
        except AttributeError:
@ -302,7 +298,7 @@ class ImageView(QDialog):
            self.show()

    def done(self, e):
-        self.prefs[self.geom_name] = bytearray(self.saveGeometry())
+        self.save_geometry(self.prefs, self.geom_name)
        return QDialog.done(self, e)

    def toggle_fullscreen(self):
--- a/src/calibre/gui2/jobs.py
+++ b/src/calibre/gui2/jobs.py
@ -628,9 +628,7 @@ class JobsDialog(QDialog, Ui_JobsDialog):

    def restore_state(self):
        try:
-            geom = gprefs.get('jobs_dialog_geometry', None)
-            if geom:
-                QApplication.instance().safe_restore_geometry(self, QByteArray(geom))
+            self.restore_geometry(gprefs, 'jobs_dialog_geometry')
            state = gprefs.get('jobs view column layout3', None)
            if state is not None:
                self.jobs_view.horizontalHeader().restoreState(QByteArray(state))
@ -647,8 +645,7 @@ class JobsDialog(QDialog, Ui_JobsDialog):
            with gprefs:
                state = bytearray(self.jobs_view.horizontalHeader().saveState())
                gprefs['jobs view column layout3'] = state
-                geom = bytearray(self.saveGeometry())
-                gprefs['jobs_dialog_geometry'] = geom
+                self.save_geometry(gprefs, 'jobs_dialog_geometry')
        except Exception:
            import traceback
            traceback.print_exc()
--- a/src/calibre/gui2/metadata/diff.py
+++ b/src/calibre/gui2/metadata/diff.py
@ -691,9 +691,7 @@ class CompareMany(QDialog):
        width = max(700, min(950, geom.width()-50))
        height = max(650, min(1000, geom.height()-100))
        self.resize(QSize(width, height))
-        geom = gprefs.get('diff_dialog_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'diff_dialog_geom')
        b.setFocus(Qt.FocusReason.OtherFocusReason)
        self.next_called = False

@ -709,7 +707,7 @@ class CompareMany(QDialog):
        self.action_button_action(self.ids[0])

    def accept(self):
-        gprefs.set('diff_dialog_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'diff_dialog_geom')
        self.compare_widget.save_comments_controls_state()
        super().accept()

@ -721,7 +719,7 @@ class CompareMany(QDialog):
            'All reviewed changes will be lost! Are you sure you want to Cancel?'),
            'confirm-metadata-diff-dialog-cancel'):
            return
-        gprefs.set('diff_dialog_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'diff_dialog_geom')
        self.compare_widget.save_comments_controls_state()
        super().reject()

--- a/src/calibre/gui2/metadata/single.py
+++ b/src/calibre/gui2/metadata/single.py
@ -120,16 +120,7 @@ class MetadataSingleDialogBase(QDialog):
        self.comments_edit_state_at_apply = {self.comments:None}

        self.do_layout()
-        max_size = self.screen().availableSize()
-
-        try:
-            w, h = gprefs.get('metasingle_window_size')
-            sz = QSize(w, h)
-        except Exception:
-            sz = self.sizeHint()
-        sz.setWidth(min(max_size.width(), sz.width()))
-        sz.setHeight(min(sz.height(), max_size.height()))
-        self.resize(sz)
+        self.restore_geometry(gprefs, 'metasingle_window_geometry3')
        self.restore_widget_settings()
    # }}}

@ -655,8 +646,7 @@ class MetadataSingleDialogBase(QDialog):

    def save_state(self):
        try:
-            sz = self.size()
-            gprefs['metasingle_window_size'] = sz.width(), sz.height()
+            self.save_geometry(gprefs, 'metasingle_window_geometry3')
            self.save_widget_settings()
        except:
            # Weird failure, see https://bugs.launchpad.net/bugs/995271
--- a/src/calibre/gui2/metadata/single_download.py
+++ b/src/calibre/gui2/metadata/single_download.py
@ -1057,11 +1057,8 @@ class FullFetch(QDialog):  # {{{
        self.covers_widget.chosen.connect(self.ok_clicked)
        self.stack.addWidget(self.covers_widget)

-        self.resize(850, 600)
-        geom = gprefs.get('metadata_single_gui_geom', None)
-        if geom is not None and geom:
-            QApplication.instance().safe_restore_geometry(self, geom)
-
+        if not self.restore_geometry(gprefs, 'metadata_single_gui_geom'):
+            self.resize(850, 600)
        self.finished.connect(self.cleanup)

    def view_log(self):
@ -1084,7 +1081,7 @@ class FullFetch(QDialog):  # {{{

    def accept(self):
        # Prevent the usual dialog accept mechanisms from working
-        gprefs['metadata_single_gui_geom'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'metadata_single_gui_geom')
        self.identify_widget.save_state()
        if DEBUG_DIALOG:
            if self.stack.currentIndex() == 2:
@ -1094,7 +1091,7 @@ class FullFetch(QDialog):  # {{{
                return QDialog.accept(self)

    def reject(self):
-        gprefs['metadata_single_gui_geom'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'metadata_single_gui_geom')
        self.identify_widget.cancel()
        self.covers_widget.cancel()
        return QDialog.reject(self)
@ -1106,7 +1103,7 @@ class FullFetch(QDialog):  # {{{
        self.ok_button.setEnabled(True)

    def next_clicked(self, *args):
-        gprefs['metadata_single_gui_geom'] = bytearray(self.saveGeometry())
+        self.save_geometry(gprefs, 'metadata_single_gui_geom')
        self.identify_widget.get_result()

    def ok_clicked(self, *args):
@ -1160,21 +1157,18 @@ class CoverFetch(QDialog):  # {{{
        self.log_button.setIcon(QIcon.ic('debug.png'))
        self.bb.rejected.connect(self.reject)
        self.bb.accepted.connect(self.accept)
-
-        geom = gprefs.get('single-cover-fetch-dialog-geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'single-cover-fetch-dialog-geometry')

    def cleanup(self):
        self.covers_widget.cleanup()

    def reject(self):
-        gprefs.set('single-cover-fetch-dialog-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'single-cover-fetch-dialog-geometry')
        self.covers_widget.cancel()
        return QDialog.reject(self)

    def accept(self, *args):
-        gprefs.set('single-cover-fetch-dialog-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'single-cover-fetch-dialog-geometry')
        self.cover_pixmap = self.covers_widget.cover_pixmap()
        QDialog.accept(self)

--- a/src/calibre/gui2/preferences/init.py
+++ b/src/calibre/gui2/preferences/init.py
@ -363,7 +363,6 @@ def show_config_widget(category, name, gui=None, show_restart_msg=False,
    d = ConfigDialog(parent)
    d.resize(750, 550)
    conf_name = 'config_widget_dialog_geometry_%s_%s'%(category, name)
-    geom = gprefs.get(conf_name, None)
    d.setWindowTitle(_('Configure ') + pl.gui_name)
    d.setWindowIcon(QIcon.ic('config.png'))
    bb = QDialogButtonBox(d)
@ -394,11 +393,9 @@ def show_config_widget(category, name, gui=None, show_restart_msg=False,
        mygui = True
    w.genesis(gui)
    w.initialize()
-    if geom is not None:
-        QApplication.instance().safe_restore_geometry(d, geom)
+    d.restore_geometry(gprefs, conf_name)
    d.exec()
-    geom = bytearray(d.saveGeometry())
-    gprefs[conf_name] = geom
+    d.save_geometry(gprefs, conf_name)
    rr = getattr(d, 'restart_required', False)
    if show_restart_msg and rr:
        from calibre.gui2 import warning_dialog
--- a/src/calibre/gui2/preferences/main.py
+++ b/src/calibre/gui2/preferences/main.py
@ -19,7 +19,7 @@ from qt.core import (
 from calibre.constants import __appname__, __version__, islinux
 from calibre.customize.ui import preferences_plugins
 from calibre.gui2 import (
-    available_width, gprefs, min_available_height, show_restart_warning
+    gprefs, show_restart_warning
 )
 from calibre.gui2.dialogs.message_box import Icon
 from calibre.gui2.preferences import (
@ -214,19 +214,7 @@ class Preferences(QDialog):
        self.committed = False
        self.close_after_initial = close_after_initial

-        self.resize(930, 720)
-        nh, nw = min_available_height()-25, available_width()-10
-        if nh < 0:
-            nh = 800
-        if nw < 0:
-            nw = 600
-        nh = min(self.height(), nh)
-        nw = min(self.width(), nw)
-        self.resize(nw, nh)
-
-        geom = gprefs.get('preferences dialog geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(gprefs, 'preferences dialog geometry')

        # Center
        if islinux:
@ -290,6 +278,9 @@ class Preferences(QDialog):
        else:
            self.hide_plugin()

+    def sizeHint(self):
+        return QSize(930, 720)
+
    def event(self, ev):
        if isinstance(ev, QStatusTipEvent):
            msg = re.sub(r'</?[a-z1-6]+>', ' ', ev.tip())
@ -409,7 +400,7 @@ class Preferences(QDialog):
        self.showing_widget.restore_defaults()

    def on_shutdown(self):
-        gprefs.set('preferences dialog geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'preferences dialog geometry')
        if self.committed:
            self.gui.must_restart_before_config = self.must_restart
            self.gui.tags_view.recount()
--- a/src/calibre/gui2/store/search/search.py
+++ b/src/calibre/gui2/store/search/search.py
@ -6,7 +6,7 @@ import re
 from random import shuffle

 from qt.core import (Qt, QDialog, QDialogButtonBox, QTimer, QCheckBox, QLabel,
-                      QVBoxLayout, QIcon, QWidget, QTabWidget, QGridLayout, QApplication, QStyle)
+                      QVBoxLayout, QIcon, QWidget, QTabWidget, QGridLayout, QSize, QStyle)

 from calibre.gui2 import JSONConfig, info_dialog, error_dialog
 from calibre.gui2.dialogs.choose_format import ChooseFormatDialog
@ -249,7 +249,7 @@ class SearchDialog(QDialog, Ui_Dialog):
        return query.encode('utf-8')

    def save_state(self):
-        self.config['geometry'] = bytearray(self.saveGeometry())
+        self.save_geometry(self.config, 'geometry')
        self.config['store_splitter_state'] = bytearray(self.store_splitter.saveState())
        self.config['results_view_column_width'] = [self.results_view.columnWidth(i) for i in range(self.results_view.model().columnCount())]
        self.config['sort_col'] = self.results_view.model().sort_col
@ -262,10 +262,7 @@ class SearchDialog(QDialog, Ui_Dialog):
        self.config['store_checked'] = store_check

    def restore_state(self):
-        geometry = self.config.get('geometry', None)
-        if geometry:
-            QApplication.instance().safe_restore_geometry(self, geometry)
-
+        self.restore_geometry(self.config, 'geometry')
        splitter_state = self.config.get('store_splitter_state', None)
        if splitter_state:
            self.store_splitter.restoreState(splitter_state)
@ -334,11 +331,7 @@ class SearchDialog(QDialog, Ui_Dialog):
        tab_widget.addTab(search_config_widget, _('Configure s&earch'))

        # Restore dialog state.
-        geometry = self.config.get('config_dialog_geometry', None)
-        if geometry:
-            QApplication.instance().safe_restore_geometry(d, geometry)
-        else:
-            d.resize(800, 600)
+        self.restore_geometry(self.config, 'config_dialog_geometry')
        tab_index = self.config.get('config_dialog_tab_index', 0)
        tab_index = min(tab_index, tab_widget.count() - 1)
        tab_widget.setCurrentIndex(tab_index)
@ -346,7 +339,7 @@ class SearchDialog(QDialog, Ui_Dialog):
        d.exec()

        # Save dialog state.
-        self.config['config_dialog_geometry'] = bytearray(d.saveGeometry())
+        self.save_geometry(self.config, 'config_dialog_geometry')
        self.config['config_dialog_tab_index'] = tab_widget.currentIndex()

        search_config_widget.save_settings()
@ -354,6 +347,9 @@ class SearchDialog(QDialog, Ui_Dialog):
        self.gui.load_store_plugins()
        self.setup_store_checks()

+    def sizeHint(self):
+        return QSize(800, 600)
+
    def config_changed(self):
        self.load_settings()

--- a/src/calibre/gui2/store/stores/mobileread/store_dialog.py
+++ b/src/calibre/gui2/store/stores/mobileread/store_dialog.py
@ -7,7 +7,7 @@ __copyright__ = '2011, John Schember <john@nachtimwald.com>'
 __docformat__ = 'restructuredtext en'


-from qt.core import (Qt, QDialog, QIcon, QComboBox, QApplication)
+from qt.core import Qt, QDialog, QIcon, QComboBox

 from calibre.gui2.store.stores.mobileread.adv_search_builder import AdvSearchBuilderDialog
 from calibre.gui2.store.stores.mobileread.models import BooksModel
@ -56,10 +56,7 @@ class MobileReadStoreDialog(QDialog, Ui_Dialog):
            self.search_query.setText(adv.search_string())

    def restore_state(self):
-        geometry = self.plugin.config.get('dialog_geometry', None)
-        if geometry:
-            QApplication.instance().safe_restore_geometry(self, geometry)
-
+        self.restore_geometry(self.plugin.config, 'dialog_geometry')
        results_cwidth = self.plugin.config.get('dialog_results_view_column_width')
        if results_cwidth:
            for i, x in enumerate(results_cwidth):
@ -76,7 +73,7 @@ class MobileReadStoreDialog(QDialog, Ui_Dialog):
        self.results_view.header().setSortIndicator(self.results_view.model().sort_col, self.results_view.model().sort_order)

    def save_state(self):
-        self.plugin.config['dialog_geometry'] = bytearray(self.saveGeometry())
+        self.save_geometry(self.plugin.config, 'dialog_geometry')
        self.plugin.config['dialog_results_view_column_width'] = [self.results_view.columnWidth(i) for i in range(self.results_view.model().columnCount())]
        self.plugin.config['dialog_sort_col'] = self.results_view.model().sort_col
        self.plugin.config['dialog_sort_order'] = self.results_view.model().sort_order
--- a/src/calibre/gui2/store/web_store.py
+++ b/src/calibre/gui2/store/web_store.py
@ -148,16 +148,14 @@ class Main(MainWindow):
        c.home.connect(self.go_home)
        c.profile.downloadRequested.connect(self.download_requested)
        self.setCentralWidget(c)
-        geometry = gprefs.get('store_dialog_main_window_geometry')
-        if geometry is not None:
-            QApplication.instance().safe_restore_geometry(self, geometry)
+        self.restore_geometry(gprefs, 'store_dialog_main_window_geometry')
        self.go_to(data['detail_url'] or None)

    def sizeHint(self):
        return QSize(1024, 740)

    def closeEvent(self, e):
-        gprefs.set('store_dialog_main_window_geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(gprefs, 'store_dialog_main_window_geometry')
        MainWindow.closeEvent(self, e)

    @property
--- a/src/calibre/gui2/toc/main.py
+++ b/src/calibre/gui2/toc/main.py
@ -8,7 +8,7 @@ import tempfile
 import textwrap
 from functools import partial
 from qt.core import (
-    QAbstractItemView, QApplication, QCheckBox, QCursor, QDialog, QDialogButtonBox,
+    QAbstractItemView, QCheckBox, QCursor, QDialog, QDialogButtonBox,
    QEvent, QFrame, QGridLayout, QIcon, QInputDialog, QItemSelectionModel,
    QKeySequence, QLabel, QMenu, QPushButton, QScrollArea, QSize, QSizePolicy,
    QStackedWidget, Qt, QToolButton, QTreeWidget, QTreeWidgetItem, QVBoxLayout,
@ -1052,14 +1052,13 @@ class TOCEditor(QDialog):  # {{{
        self.explode_done.connect(self.read_toc, type=Qt.ConnectionType.QueuedConnection)
        self.writing_done.connect(self.really_accept, type=Qt.ConnectionType.QueuedConnection)

-        r = self.screen().availableSize()
-        self.resize(r.width() - 100, r.height() - 100)
-        geom = self.prefs.get('toc_editor_window_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, bytes(geom))
+        self.restore_geometry(self.prefs, 'toc_editor_window_geom')
        self.stacks.currentChanged.connect(self.update_history_buttons)
        self.update_history_buttons()

+    def sizeHint(self):
+        return QSize(900, 600)
+
    def update_history_buttons(self):
        self.undo_button.setVisible(self.stacks.currentIndex() == 1)
        self.undo_button.setEnabled(bool(self.toc_view.tocw.history))
@ -1086,7 +1085,7 @@ class TOCEditor(QDialog):  # {{{
            self.bb.setEnabled(False)

    def really_accept(self, tb):
-        self.prefs['toc_editor_window_geom'] = bytearray(self.saveGeometry())
+        self.save_geometry(self.prefs, 'toc_editor_window_geom')
        if tb:
            error_dialog(self, _('Failed to write book'),
                _('Could not write %s. Click "Show details" for'
@ -1107,7 +1106,7 @@ class TOCEditor(QDialog):  # {{{
            self.stacks.setCurrentIndex(1)
        else:
            self.working = False
-            self.prefs['toc_editor_window_geom'] = bytearray(self.saveGeometry())
+            self.save_geometry(self.prefs, 'toc_editor_window_geom')
            self.write_result(1)
            super().reject()

--- a/src/calibre/gui2/tweak_book/preferences.py
+++ b/src/calibre/gui2/tweak_book/preferences.py
@ -15,7 +15,7 @@ from copy import copy, deepcopy
 from qt.core import (
    QDialog, QGridLayout, QStackedWidget, QDialogButtonBox, QListWidget,
    QListWidgetItem, QIcon, QWidget, QSize, QFormLayout, Qt, QSpinBox, QListView,
-    QCheckBox, pyqtSignal, QDoubleSpinBox, QComboBox, QLabel, QFont, QApplication,
+    QCheckBox, pyqtSignal, QDoubleSpinBox, QComboBox, QLabel, QFont,
    QFontComboBox, QPushButton, QSizePolicy, QHBoxLayout, QGroupBox, QAbstractItemView,
    QToolButton, QVBoxLayout, QSpacerItem, QTimer, QRadioButton)

@ -782,10 +782,7 @@ class Preferences(QDialog):

        l.addWidget(bb, 1, 0, 1, 2)

-        self.resize(800, 600)
-        geom = tprefs.get('preferences_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(tprefs, 'preferences_geom')

        self.keyboard_panel = ShortcutConfig(self)
        self.keyboard_panel.initialize(gui.keyboard)
@ -819,6 +816,9 @@ class Preferences(QDialog):
        cl.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        cl.setMinimumWidth(min(cl.maximumWidth(), cl.sizeHint().width()))

+    def sizeHint(self):
+        return QSize(800, 600)
+
    @property
    def dictionaries_changed(self):
        return self.editor_panel.dictionaries_changed
@ -859,14 +859,14 @@ class Preferences(QDialog):
        info_dialog(self, _('Disabled confirmations restored'), msg, show=True)

    def accept(self):
-        tprefs.set('preferences_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(tprefs, 'preferences_geom')
        for i in range(self.stacks.count()):
            w = self.stacks.widget(i)
            w.commit()
        QDialog.accept(self)

    def reject(self):
-        tprefs.set('preferences_geom', bytearray(self.saveGeometry()))
+        self.save_geometry(tprefs, 'preferences_geom')
        QDialog.reject(self)


--- a/src/calibre/gui2/tweak_book/toc.py
+++ b/src/calibre/gui2/tweak_book/toc.py
@ -53,11 +53,10 @@ class TOCEditor(QDialog):
        b.clicked.connect(self.toc_view.undo)

        self.read_toc()
+        self.restore_geometry(tprefs, 'toc_editor_window_geom')

-        self.resize(950, 630)
-        geom = tprefs.get('toc_editor_window_geom', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, bytes(geom))
+    def sizeHint(self):
+        return QSize(950, 630)

    def add_new_item(self, item, where):
        self.item_edit(item, where)
@ -73,11 +72,11 @@ class TOCEditor(QDialog):
            self.stacks.setCurrentIndex(0)
        elif self.stacks.currentIndex() == 0:
            self.write_toc()
-            tprefs['toc_editor_window_geom'] = bytearray(self.saveGeometry())
+            self.save_geometry(tprefs, 'toc_editor_window_geom')
            super().accept()

    def really_accept(self, tb):
-        tprefs['toc_editor_window_geom'] = bytearray(self.saveGeometry())
+        self.save_geometry(tprefs, 'toc_editor_window_geom')
        if tb:
            error_dialog(self, _('Failed to write book'),
                _('Could not write %s. Click "Show details" for'
@ -97,7 +96,7 @@ class TOCEditor(QDialog):
            tprefs['toc_edit_splitter_state'] = bytearray(self.item_edit.splitter.saveState())
            self.stacks.setCurrentIndex(0)
        else:
-            tprefs['toc_editor_window_geom'] = bytearray(self.saveGeometry())
+            self.save_geometry(tprefs, 'toc_editor_window_geom')
            super().reject()

    def read_toc(self):
--- a/src/calibre/gui2/tweak_book/ui.py
+++ b/src/calibre/gui2/tweak_book/ui.py
@ -884,7 +884,7 @@ class Main(MainWindow):
            e.ignore()

    def save_state(self):
-        tprefs.set('main_window_geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(tprefs, 'main_window_geometry')
        tprefs.set('main_window_state', bytearray(self.saveState(self.STATE_VERSION)))
        self.central.save_state()
        self.saved_searches.save_state()
@ -892,9 +892,7 @@ class Main(MainWindow):
        self.text_search.save_state()

    def restore_state(self):
-        geom = tprefs.get('main_window_geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(tprefs, 'main_window_geometry')
        state = tprefs.get('main_window_state', None)
        if state is not None:
            self.restoreState(state, self.STATE_VERSION)
--- a/src/calibre/gui2/ui.py
+++ b/src/calibre/gui2/ui.py
@ -1060,14 +1060,12 @@ class Main(MainWindow, MainWindowMixin, DeviceMixin, EmailMixin,  # {{{
                    det_msg=job.details, retry_func=retry_func)

    def read_settings(self):
-        geometry = config['main_window_geometry']
-        if geometry is not None:
-            QApplication.instance().safe_restore_geometry(self, geometry)
+        self.restore_geometry(gprefs, 'calibre_main_window_geometry', get_legacy_saved_geometry=lambda: config['main_window_geometry'])
        self.read_layout_settings()

    def write_settings(self):
        with gprefs:  # Only write to gprefs once
-            config.set('main_window_geometry', self.saveGeometry())
+            self.save_geometry(gprefs, 'calibre_main_window_geometry')
            dynamic.set('sort_history', self.library_view.model().sort_history)
            self.save_layout_state()
            self.stack.tb_widget.save_state()
--- a/src/calibre/gui2/viewer/ui.py
+++ b/src/calibre/gui2/viewer/ui.py
@ -755,14 +755,11 @@ class EbookViewer(MainWindow):
    def save_state(self):
        with vprefs:
            vprefs['main_window_state'] = bytearray(self.saveState(self.MAIN_WINDOW_STATE_VERSION))
-            vprefs['main_window_geometry'] = bytearray(self.saveGeometry())
+            self.save_geometry(vprefs, 'main_window_geometry')

    def restore_state(self):
        state = vprefs['main_window_state']
-        geom = vprefs['main_window_geometry']
-        if geom and get_session_pref('remember_window_geometry', default=False):
-            QApplication.instance().safe_restore_geometry(self, geom)
-        else:
+        if not get_session_pref('remember_window_geometry', default=False) or not self.restore_geometry(vprefs, 'main_window_geometry'):
            QApplication.instance().ensure_window_on_screen(self)
        if state:
            self.restoreState(state, self.MAIN_WINDOW_STATE_VERSION)
--- a/src/calibre/gui2/widgets2.py
+++ b/src/calibre/gui2/widgets2.py
@ -221,23 +221,20 @@ class Dialog(QDialog):

        self.setup_ui()

-        self.resize(self.sizeHint())
-        geom = self.prefs_for_persistence.get(name + '-geometry', None)
-        if geom is not None:
-            QApplication.instance().safe_restore_geometry(self, geom)
+        self.restore_geometry(self.prefs_for_persistence, self.name + '-geometry')
        if hasattr(self, 'splitter'):
-            state = self.prefs_for_persistence.get(name + '-splitter-state', None)
+            state = self.prefs_for_persistence.get(self.name + '-splitter-state', None)
            if state is not None:
                self.splitter.restoreState(state)

    def accept(self):
-        self.prefs_for_persistence.set(self.name + '-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(self.prefs_for_persistence, self.name + '-geometry')
        if hasattr(self, 'splitter'):
            self.prefs_for_persistence.set(self.name + '-splitter-state', bytearray(self.splitter.saveState()))
        QDialog.accept(self)

    def reject(self):
-        self.prefs_for_persistence.set(self.name + '-geometry', bytearray(self.saveGeometry()))
+        self.save_geometry(self.prefs_for_persistence, self.name + '-geometry')
        if hasattr(self, 'splitter'):
            self.prefs_for_persistence.set(self.name + '-splitter-state', bytearray(self.splitter.saveState()))
        QDialog.reject(self)