Make applying a profile in the standalone viewer more efficient

src/calibre/gui2/viewer/web_view.py

@@ -688,22 +688,40 @@ class WebView(RestartingWebEngineView):
         self.execute_when_ready('full_screen_state_changed', in_fullscreen_mode)
 
     def set_session_data(self, key, val):
-        if key == '*' and val is None:
+        fonts_changed = paged_mode_changed = standalone_misc_settings_changed = update_vprefs = False
-            vprefs['session_data'] = {}
-            apply_font_settings(self)
-            self.paged_mode_changed.emit()
-            self.standalone_misc_settings_changed.emit()
-        elif key != '*':
         sd = vprefs['session_data']
-            changed = sd.get(key) == val
+
+        def change(key, val):
+            nonlocal fonts_changed, paged_mode_changed, standalone_misc_settings_changed, update_vprefs
+            changed = sd.get(key) != val
             if changed:
+                update_vprefs = True
+                if val is None:
+                    sd.pop(key, None)
+                else:
                     sd[key] = val
-                vprefs['session_data'] = sd
                 if key in ('standalone_font_settings', 'base_font_size'):
-                    apply_font_settings(self)
+                    fonts_changed = True
                 elif key == 'read_mode':
-                    self.paged_mode_changed.emit()
+                    paged_mode_changed = True
                 elif key == 'standalone_misc_settings':
+                    standalone_misc_settings_changed = True
+
+        if isinstance(key, dict):
+            for k, val in key.items():
+                change(k, val)
+        elif key == '*' and val is None:
+            vprefs['session_data'] = {}
+            fonts_changed = paged_mode_changed = standalone_misc_settings_changed = update_vprefs = True
+        elif key != '*':
+            change(key, val)
+        if update_vprefs:
+            vprefs['session_data'] = sd
+        if fonts_changed:
+            apply_font_settings(self)
+        if paged_mode_changed:
+            self.paged_mode_changed.emit()
+        if standalone_misc_settings_changed:
             self.standalone_misc_settings_changed.emit(val)
 
     def set_local_storage(self, key, val):

src/pyj/session.pyj

@@ -172,6 +172,10 @@ class SessionData:
             console.error('session storage has overflowed, using a temp cache instead')
         return False
 
+    def set_bulk(self, changes):
+        for key in Object.keys(changes):
+            self.set(key, changes[key])
+
     def clear(self):
         self.storage.clear()
         self.overflow_storage = {}
@@ -234,18 +238,20 @@ def get_subset_of_settings(sd, filter_func):
     return ans
 
 def apply_profile(sd, profile, filter_func):
-    sentinel = {}
+    changes = {}
     for setting_name in Object.keys(all_settings):
         metadata = all_settings[setting_name]
-        curval = sd.get(setting_name, sentinel)
+        curval = sd.get(setting_name, changes)
-        is_set = curval is not sentinel
+        is_set = curval is not changes
         if filter_func(setting_name, metadata, is_set, curval):
             newval = None
             if Object.prototype.hasOwnProperty.call(profile, setting_name):
                 newval = profile[setting_name]
                 if deep_eq(newval, metadata.default):
                     newval = None
-            sd.set(setting_name, window.structuredClone(newval))
+            changes[setting_name] = window.structuredClone(newval)
+    sd.set_bulk(changes)
+    return changes
 
 
 standalone_reader_defaults = {
@@ -286,7 +292,7 @@ def settings_for_reader_profile(sd):
 
 def apply_reader_profile(sd, profile):
     def filter_func(setting_name, metadata, is_set, curval):
-        return metadata.category is 'read_book'
+        return metadata.category is 'read_book' and not metadata.disallowed_in_profile
     apply_profile(sd, profile, filter_func)
 
 

src/pyj/viewer-main.pyj

@@ -161,11 +161,21 @@ class SessionData:
 
     def set(self, key, val):
         if val is None:
-            self.data[key] = val = session_defaults()[key]
+            self.data[key] = session_defaults()[key]
         else:
             self.data[key] = val
         to_python.set_session_data(key, val)
 
+    def set_bulk(self, changes):
+        defaults = session_defaults()
+        for key in Object.keys(changes):
+            val = changes[key]
+            if val is None:
+                self.data[key] = defaults[key]
+            else:
+                self.data[key] = val
+        to_python.set_session_data(changes, None)
+
     def clear(self):
         defaults = session_defaults()
         self.data = {k: defaults[k] for k in defaults}