deskbar-applet r2272 - in trunk: . deskbar/core

[sebp svn gnome org]

Author: sebp
Date: Tue Jul 29 20:56:40 2008
New Revision: 2272
URL: http://svn.gnome.org/viewvc/deskbar-applet?rev=2272&view=rev

Log:
Added sanity checks when setting values and emitting signals (fixes bug #486549)
(patch partly by Goran Rakic <grakic at devbase dot net>)

Modified:
   trunk/ChangeLog
   trunk/deskbar/core/CoreImpl.py
   trunk/deskbar/core/GconfStore.py

Modified: trunk/deskbar/core/CoreImpl.py
==============================================================================
--- trunk/deskbar/core/CoreImpl.py	(original)
+++ trunk/deskbar/core/CoreImpl.py	Tue Jul 29 20:56:40 2008
@@ -68,12 +68,17 @@
         self._module_loader.connect ("module-stopped", self._module_list.module_toggled_cb)
         
     def _setup_keybinder(self):
+        self._gconf.connect("keybinding-changed", self._on_keybinding_changed)
+        
         self._keybinder = Keybinder()
-        if (self.get_keybinding() == None or gtk.accelerator_parse(self.get_keybinding()) == (0,0)):
+        keybinding = self.get_keybinding()
+        if (keybinding == None or gtk.accelerator_parse(keybinding) == (0,0)):
             # Keybinding is not set or invalid, set default keybinding
-            self.set_keybinding( self.DEFAULT_KEYBINDING )
+            keybinding = self.DEFAULT_KEYBINDING
+            self.set_keybinding(keybinding) # try to save it to Gconf
         else:
-            self.set_keybinding( self.get_keybinding() )
+            keybinding = self.get_keybinding()
+        self.bind_keybinding(keybinding) # use keybindingx
     
     def get_old_modules(self):
         """
@@ -106,8 +111,9 @@
         
         @type name: list of class names 
         """
-        self._gconf.set_enabled_modules(name)
-    
+        if not self._gconf.set_enabled_modules(name):
+            LOGGER.error("Unable to save enabled modules list to GConf")
+
     def get_keybinding(self):
         """
         Get keybinding
@@ -160,61 +166,82 @@
     
     def get_ui_name(self):
         return self._gconf.get_ui_name()
-    
+
     def set_keybinding(self, binding):
         """
-        Store keybinding and actually bind it
+        Store keybinding
+        """
+        if not self._gconf.set_keybinding(binding):
+            LOGGER.error("Unable to save keybinding setting to GConf")
+
+    def bind_keybinding(self, binding):
+        """
+        Actually bind keybinding
         """
-        self._gconf.set_keybinding(binding)
         if not self._keybinder.bind(binding):
             LOGGER.error("Keybinding is already in use")
         else:
             LOGGER.info("Successfully binded Deskbar to %s", binding)
     
     def set_min_chars(self, number):
-        self._gconf.set_min_chars(number)
+        if not self._gconf.set_min_chars(number):
+            LOGGER.error("Unable to save min chars setting to GConf")
     
     def set_type_delay(self, seconds):
-        self._gconf.set_type_delay(seconds)
+        if not self._gconf.set_type_delay(seconds):
+            LOGGER.error("Unable to save type delay setting to GConf")
     
     def set_use_selection(self, val):
-        self._gconf.set_use_selection(val)
+        if not self._gconf.set_use_selection(val):
+            LOGGER.error("Unable to save use selection setting to GConf")
 
     def set_clear_entry(self, val):
-        self._gconf.set_clear_entry(val)
+        if not self._gconf.set_clear_entry(val):
+            LOGGER.error("Unable to save clear entry setting to GConf")
     
     def set_use_http_proxy(self, val):
-        self._gconf.set_use_http_proxy(val)
+        if not self._gconf.set_use_http_proxy(val):
+            LOGGER.error("Unable to save http proxy setting to GConf")
     
     def set_proxy_host(self, host):
-        self._gconf.set_proxy_host(host)
+        if not self._gconf.set_proxy_host(host):
+            LOGGER.error("Unable to save http proxy host setting to GConf")
     
     def set_proxy_port(self, port):
-        self._gconf.set_proxy_port(port)
+        if not self._gconf.set_proxy_port(port):
+            LOGGER.error("Unable to save proxy port setting to GConf")
     
     def set_collapsed_cat(self, cat):
-        self._gconf.set_collapsed_cat(cat)
+        if not self._gconf.set_collapsed_cat(cat):
+            LOGGER.error("Unable to save collapsed cat setting to GConf")
     
     def set_window_width(self, width):
-        self._gconf.set_window_width(width)
+        if not self._gconf.set_window_width(width):
+            LOGGER.error("Unable to save window width setting to GConf")
     
     def set_window_height(self, height):
-        self._gconf.set_window_height(height)
+        if not self._gconf.set_window_height(height):
+            LOGGER.error("Unable to save window height setting to GConf")
     
     def set_window_x(self, x):      
-        self._gconf.set_window_x(x)      
+        if not self._gconf.set_window_x(x):     
+            LOGGER.error("Unable to save window x position setting to GConf")
        
     def set_window_y(self, y):      
-        self._gconf.set_window_y(y)
+        if not self._gconf.set_window_y(y):
+            LOGGER.error("Unable to save window y position setting to GConf")
     
     def set_hide_after_action(self, width):
-        self._gconf.set_hide_after_action(width)
+        if not self._gconf.set_hide_after_action(width):
+            LOGGER.error("Unable to save hide after action setting to GConf")
     
     def set_max_history_items(self, amount):
-        self._gconf.set_max_history_items(amount)
+        if not self._gconf.set_max_history_items(amount):
+            LOGGER.error("Unable to save max history items setting to GConf")
         
     def set_ui_name(self, name):
-        self._gconf.set_ui_name(name)
+        if not self._gconf.set_ui_name(name):
+            LOGGER.error("Unable to save ui name setting to GConf")
     
     def get_history(self):
         """
@@ -422,3 +449,7 @@
                 self.initialize_module(new_module, async=False)
         
         self.update_gconf()
+        
+    def _on_keybinding_changed(self, store, keybinding):
+        if gtk.accelerator_parse(keybinding) != (0,0):
+            self.bind_keybinding(keybinding)

Modified: trunk/deskbar/core/GconfStore.py
==============================================================================
--- trunk/deskbar/core/GconfStore.py	(original)
+++ trunk/deskbar/core/GconfStore.py	Tue Jul 29 20:56:40 2008
@@ -80,20 +80,40 @@
         
     def __connect_notifications(self):
         self._client.add_dir(self.GCONF_DIR, gconf.CLIENT_PRELOAD_RECURSIVE)
-        self._client.notify_add(self.GCONF_KEYBINDING, lambda x, y, z, a: self.emit("keybinding-changed", z.value.get_string()))
-        self._client.notify_add(self.GCONF_MINCHARS, lambda x, y, z, a: self.emit("min-chars-changed", z.value.get_int()))
-        self._client.notify_add(self.GCONF_TYPINGDELAY, lambda x, y, z, a: self.emit("type-delay-changed", z.value.get_int()))
-        self._client.notify_add(self.GCONF_USE_SELECTION, lambda x, y, z, a: self.emit("use-selection-changed", z.value.get_bool()))
-        self._client.notify_add(self.GCONF_CLEAR_ENTRY, lambda x, y, z, a: self.emit("clear-entry-changed", z.value.get_bool()))
-        self._client.notify_add(self.GCONF_PROXY_USE_HTTP_PROXY, lambda x, y, z, a: self.emit("use-http-proxy-changed", z.value.get_bool()))
-        self._client.notify_add(self.GCONF_PROXY_HOST_KEY, lambda x, y, z, a: self.emit("proxy-host-changed", z.value.get_string()))
-        self._client.notify_add(self.GCONF_PROXY_PORT_KEY, lambda x, y, z, a: self.emit("proxy-port-changed", z.value.get_string()))
-        self._client.notify_add(self.GCONF_ENABLED_HANDLERS, lambda x, y, z, a: self.emit("enabled-modules-changed", [i.get_string() for i in z.value.get_list()]))
-        self._client.notify_add(self.GCONF_COLLAPSED_CAT, lambda x, y, z, a: self.emit("collapsed-rows-changed", [i.get_string() for i in z.value.get_list()]))
-        self._client.notify_add(self.GCONF_HIDE_AFTER_ACTION, lambda x, y, z, a: self.emit("hide-after-action-changed", z.value.get_bool()))
-        self._client.notify_add(self.GCONF_TYPINGDELAY, lambda x, y, z, a: self.emit("max-history-items-changed", z.value.get_int()))
-        self._client.notify_add(self.GCONF_DEFAULT_BROWSER, lambda x, y, z, a: self.emit("default-browser-changed", z.value.get_string()))
-        self._client.notify_add(self.GCONF_UI_NAME, lambda x, y, z, a: self.emit("ui-name-changed", z.value.get_string()))
+        self._client.notify_add(self.GCONF_KEYBINDING, self.__emit_signal_string, "keybinding-changed")
+        self._client.notify_add(self.GCONF_MINCHARS, self.__emit_signal_int, "min-chars-changed")
+        self._client.notify_add(self.GCONF_TYPINGDELAY, self.__emit_signal_int, "type-delay-changed")
+        self._client.notify_add(self.GCONF_USE_SELECTION, self.__emit_signal_bool, "use-selection-changed")
+        self._client.notify_add(self.GCONF_CLEAR_ENTRY, self.__emit_signal_bool, "clear-entry-changed")
+        self._client.notify_add(self.GCONF_PROXY_USE_HTTP_PROXY, self.__emit_signal_bool, "use-http-proxy-changed")
+        self._client.notify_add(self.GCONF_PROXY_HOST_KEY, self.__emit_signal_string, "proxy-host-changed")
+        self._client.notify_add(self.GCONF_PROXY_PORT_KEY, self.__emit_signal_string, "proxy-port-changed")
+        self._client.notify_add(self.GCONF_ENABLED_HANDLERS, self.__emit_signal_string_list, "enabled-modules-changed")
+        self._client.notify_add(self.GCONF_COLLAPSED_CAT, self.__emit_signal_string_list, "collapsed-rows-changed")
+        self._client.notify_add(self.GCONF_HIDE_AFTER_ACTION, self.__emit_signal_bool, "hide-after-action-changed")
+        self._client.notify_add(self.GCONF_TYPINGDELAY, self.__emit_signal_int, "max-history-items-changed")
+        self._client.notify_add(self.GCONF_DEFAULT_BROWSER, self.__emit_signal_string, "default-browser-changed")
+        self._client.notify_add(self.GCONF_UI_NAME, self.__emit_signal_string, "ui-name-changed")
+        
+    def __emit_signal_string(self, client, cnxn_id, entry, data):
+        if entry.value != None:
+            self.emit(data, entry.value.get_string())
+    
+    def __emit_signal_string_list(self, client, cnxn_id, entry, data):
+        if entry.value != None:
+            vals = []
+            for i in entry.value.get_list():
+                if i != None:
+                    vals.append(i.get_string())
+            self.emit(data, vals)
+    
+    def __emit_signal_bool(self, client, cnxn_id, entry, data):
+        if entry.value != None:
+            self.emit(data, entry.value.get_bool())
+    
+    def __emit_signal_int(self, client, cnxn_id, entry, data):
+        if entry.value != None:
+            self.emit(data, entry.value.get_int())
     
     def get_client(self):
         return self._client
@@ -168,52 +188,72 @@
         return self._client.get_string(self.GCONF_UI_NAME)
 
     def set_keybinding(self, binding):
-        self._client.set_string(self.GCONF_KEYBINDING, binding)
+        return self.__set_string_if_writeable(self.GCONF_KEYBINDING, binding)
     
     def set_min_chars(self, number):
-        self._client.set_int(self.GCONF_MINCHARS, int(number))
+        return self.__set_int_if_writeable(self.GCONF_MINCHARS, int(number))
     
     def set_type_delay(self, seconds):
-        self._client.set_int(self.GCONF_TYPINGDELAY, int(seconds))
+        return self.__set_int_if_writeable(self.GCONF_TYPINGDELAY, int(seconds))
     
     def set_use_selection(self, val):
-        self._client.set_bool(self.GCONF_USE_SELECTION, val)
+        return self.__set_bool_if_writeable(self.GCONF_USE_SELECTION, val)
     
     def set_clear_entry(self, val):
-        self._client.set_bool(self.GCONF_CLEAR_ENTRY)
+        return self.__set_bool_if_writeable(self.GCONF_CLEAR_ENTRY)
     
     def set_use_http_proxy(self, val):
-        self._client.set_bool(self.GCONF_PROXY_USE_HTTP_PROXY, val)
+        return self.__set_bool_if_writeable(self.GCONF_PROXY_USE_HTTP_PROXY, val)
     
     def set_proxy_host(self, host):
-        self._client.set_string(self.GCONF_PROXY_HOST_KEY, host)
+        return self.__set_string_if_writeable(self.GCONF_PROXY_HOST_KEY, host)
     
     def set_proxy_port(self, port):
-        self._client.set_int(self.GCONF_PROXY_HOST_KEY, port)
+        return self.__set_int_if_writeable(self.GCONF_PROXY_HOST_KEY, port)
     
     def set_enabled_modules(self, handlers):
-        self._client.set_list(self.GCONF_ENABLED_HANDLERS, gconf.VALUE_STRING,  handlers)
+        return self.__set_list_if_writeable(self.GCONF_ENABLED_HANDLERS, gconf.VALUE_STRING,  handlers)
         
     def set_collapsed_cat(self, cat):
-        self._client.set_list(self.GCONF_COLLAPSED_CAT, gconf.VALUE_STRING, cat)
+        return self.__set_list_if_writeable(self.GCONF_COLLAPSED_CAT, gconf.VALUE_STRING, cat)
      
     def set_window_width(self, width):
-        self._client.set_int(self.GCONF_WINDOW_WIDTH, width)
+        return self.__set_int_if_writeable(self.GCONF_WINDOW_WIDTH, width)
     
     def set_window_height(self, height):
-        self._client.set_int(self.GCONF_WINDOW_HEIGHT, height)  
+        return self.__set_int_if_writeable(self.GCONF_WINDOW_HEIGHT, height)  
     
     def set_window_x(self, x):      
-        self._client.set_int(self.GCONF_WINDOW_X, x)      
+        return self.__set_int_if_writeable(self.GCONF_WINDOW_X, x)      
            
     def set_window_y(self, y):      
-        self._client.set_int(self.GCONF_WINDOW_Y, y)
+        return self.__set_int_if_writeable(self.GCONF_WINDOW_Y, y)
         
     def set_hide_after_action(self, val):
-        self._client.set_bool(self.GCONF_HIDE_AFTER_ACTION, val)
+        return self.__set_bool_if_writeable(self.GCONF_HIDE_AFTER_ACTION, val)
         
     def set_max_history_items(self, amount):
-        self._client.set_int(self.GCONF_MAX_HISTORY_ITEMS, int(amount))
+        return self.__set_int_if_writeable(self.GCONF_MAX_HISTORY_ITEMS, int(amount))
         
     def set_ui_name(self, name):
-        self._client.set_string(self.GCONF_UI_NAME, name)
+        return self.__set_string_if_writeable(self.GCONF_UI_NAME, name)
+
+    def __set_string_if_writeable(self, key, val):
+        if self._client.key_is_writable(key):
+            return self._client.set_string(key, val)
+        return False
+
+    def __set_int_if_writeable(self, key, val):
+        if self._client.key_is_writable(key):
+            return self._client.set_int(key, val)
+        return False
+
+    def __set_bool_if_writeable(self, key, val):
+        if self._client.key_is_writable(key):
+            return self._client.set_bool(key, val)
+        return False
+
+    def __set_list_if_writeable(self, key, value_type, val):
+        if self._client.key_is_writable(key):
+            return self._client.set_list(key, value_type, val)
+        return False