home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / serpentine / gaw.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  12.5 KB  |  355 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """
  5. GConf Widget Persistency is a module for maintaining persistency between your
  6. existing widgets and the GConf keys. Not only it forces the schema you've
  7. defined for the key but also preserves the widget state, for example making it
  8. insensitive when the GConf key is insensitive.
  9.  
  10. It also implements a representation of a gconf key (GConfValue) that handles
  11. the repetitive hassles of a maintaining its integrity. 
  12. """
  13. import gconf
  14. import gobject
  15.  
  16. class Spec(object):
  17.     
  18.     def __init__(self, name, gconf_type, py_type, default):
  19.         self._Spec__gconf_type = gconf_type
  20.         self._Spec__py_type = py_type
  21.         self._Spec__default = default
  22.         self._Spec__name = name
  23.  
  24.     gconf_type = property((lambda self: self._Spec__gconf_type))
  25.     py_type = property((lambda self: self._Spec__py_type))
  26.     default = property((lambda self: self._Spec__default))
  27.     name = property((lambda self: self._Spec__name))
  28.  
  29. Spec.STRING = Spec('string', gconf.VALUE_STRING, str, '')
  30. Spec.FLOAT = Spec('float', gconf.VALUE_FLOAT, float, 0.0)
  31. Spec.INT = Spec('int', gconf.VALUE_INT, int, 0)
  32. Spec.BOOL = Spec('bool', gconf.VALUE_BOOL, bool, True)
  33.  
  34. def data_file_chooser(button, key, use_directory = False, use_uri = True, default = None, client = None):
  35.     """
  36.     Returns a gaw.Data.
  37.     
  38.     use_directory - boolean variable setting if it's we're using files or directories.
  39.     use_uri - boolean variable setting if we're using URI's or normal filenames.
  40.     
  41.     Associates a gaw.Data to a gtk.FileChooserButton. 
  42.     """
  43.     if not use_directory and not use_uri:
  44.         getter = button.get_filename
  45.         setter = button.set_filename
  46.     elif not use_directory and use_uri:
  47.         getter = button.get_uri
  48.         setter = button.set_uri
  49.     elif use_directory and not use_uri:
  50.         getter = button.get_current_folder
  51.         setter = button.set_current_folder
  52.     elif use_directory and use_uri:
  53.         getter = button.get_current_folder_uri
  54.         setter = button.set_current_folder_uri
  55.     
  56.     return Data(button, getter, setter, 'selection-changed', GConfValue(key, Spec.STRING, default = default, client = client))
  57.  
  58.  
  59. def data_entry(entry, key, data_spec = Spec.STRING, default = None, client = None):
  60.     return Data(entry, entry.get_text, entry.set_text, 'changed', GConfValue(key, data_spec, default, client))
  61.  
  62.  
  63. def data_spin_button(spinbutton, key, use_int = True, default = None, client = None):
  64.     if use_int:
  65.         return Data(spinbutton, spinbutton.get_value_as_int, spinbutton.set_value, 'value-changed', GConfValue(key, Spec.INT, default, client))
  66.     else:
  67.         return Data(spinbutton, spinbutton.get_value, spinbutton.set_value, 'value-changed', GConfValue(key, Spec.FLOAT, default, client))
  68.  
  69.  
  70. def data_toggle_button(toggle, key, default = None, client = None):
  71.     return Data(toggle, toggle.get_active, toggle.set_active, 'toggled', GConfValue(key, Spec.BOOL, default, client))
  72.  
  73.  
  74. class GConfValue(object):
  75.     '''
  76.     The GConfValue represents the GConf key\'s data. You define a certain schema
  77.     (or type of data) and GConfValue keeps track of its integrity. It adds the
  78.     possibility to define a default value to be used when the key is inexistent
  79.     or contains an invalid data type. You can also define callbacks that notify
  80.     you when the key is altered.
  81.     
  82.     Taken from http://s1x.homelinux.net/documents/gaw_intro :
  83.         import gaw, gconf, gtk
  84.         gconf.client_get_default ().add_dir ("/apps/gaw", gconf.CLIENT_PRELOAD_NONE)
  85.  
  86.         key_str = gaw.GConfValue (
  87.           key = "/apps/gaw/key_str",
  88.           data_spec = gaw.Spec.STRING
  89.         )
  90.  
  91.         def on_changed (*args):
  92.           global key_str
  93.           print key_str.key, "=", key_str.data
  94.           gtk.main_quit ()
  95.           
  96.         tmp.set_callback (on_changed)
  97.         tmp.data = "Hello world"
  98.  
  99.         gtk.main ()
  100.     '''
  101.     
  102.     def __init__(self, key, data_spec, default = None, client = None):
  103.         if not client:
  104.             client = gconf.client_get_default()
  105.         
  106.         self.client = client
  107.         self.key = key
  108.         self.data_spec = data_spec
  109.         self._GConfValue__notify_id = None
  110.         if default is not None:
  111.             self.default = default
  112.         
  113.  
  114.     __setter = property((lambda self: getattr(self.client, 'set_' + self.data_spec.name)))
  115.     
  116.     def __get_data(self):
  117.         val = self.client.get(self.key)
  118.         if val is None:
  119.             return self.get_default()
  120.         
  121.         return getattr(val, 'get_' + self.data_spec.name)()
  122.  
  123.     data = property(fget = __get_data, fset = (lambda self, value: self._GConfValue__setter(self.key, value)))
  124.     
  125.     def set_callback(self, on_changed):
  126.         if self._GConfValue__notify_id is not None:
  127.             self.client_notify_remove(self._GConfValue__notify_id)
  128.             self._GConfValue__notify_id = None
  129.         
  130.         if on_changed is not None:
  131.             self._GConfValue__notify_id = self.client.notify_add(self.key, on_changed)
  132.         
  133.  
  134.     
  135.     def __del__(self):
  136.         self.set_callback(None)
  137.  
  138.     
  139.     def reset_default(self):
  140.         self.data = self.data_spec.default
  141.  
  142.     
  143.     def get_default(self):
  144.         return getattr(self, 'default', self.data_spec.default)
  145.  
  146.  
  147.  
  148. class RadioButtonData:
  149.     """A radio_group is a dictionary that associates a gconf boolean key
  150.     with a radio button.
  151.     data = RadioButtonData (
  152.         {
  153.             'cheese': cheese_btn,
  154.             'ham': ham_btn,
  155.             'fish': fish_btn
  156.         },
  157.     )
  158.     data.selected_by_default = 'ham'
  159.     
  160.     selected_value = data.data
  161.     data.data = 'fish'
  162.     """
  163.     selected_by_default = None
  164.     
  165.     def __init__(self, widgets, key, client = None):
  166.         self.widgets = widgets
  167.         self.keys = { }
  168.         self.gconf_value = GConfValue(key, Spec.STRING, client)
  169.         self.gconf_value.set_callback(self._RadioButtonData__on_gconf_changed)
  170.         notify_widget = False
  171.         for key, widget in widgets.iteritems():
  172.             if not notify_widget:
  173.                 widget.connect('toggled', self._RadioButtonData__on_widget_changed)
  174.                 notify_widget = True
  175.             
  176.             widget.connect('destroy', self._RadioButtonData__on_destroy)
  177.             self.keys[widget] = key
  178.         
  179.         self.sync_widget()
  180.  
  181.     
  182.     def __on_destroy(self, widget):
  183.         key = self.keys[widget]
  184.         del self.widgets[key]
  185.         self.keys[widget] = None
  186.  
  187.     
  188.     def _get_active(self):
  189.         for radio in self.keys:
  190.             if radio is not None and radio.get_active():
  191.                 return radio
  192.                 continue
  193.         
  194.  
  195.     
  196.     def __on_widget_changed(self, radio_button):
  197.         self.sync_gconf()
  198.  
  199.     
  200.     def __on_gconf_changed(self, client, conn_id, entry, user_data):
  201.         data_spec = self.gconf_value.data_spec
  202.         for widget in self.keys:
  203.             widget.set_sensitive(client.key_is_writable(self.gconf_value.key))
  204.         
  205.         if entry.value is None or entry.value.type != data_spec.gconf_type:
  206.             self.sync_gconf()
  207.         else:
  208.             self.sync_widget()
  209.  
  210.     
  211.     def sync_widget(self):
  212.         key = self.gconf_value.data
  213.         if key in self.widgets:
  214.             self.widgets[key].set_active(True)
  215.         elif self.selected_by_default is not None:
  216.             self.data = self.selected_by_default
  217.         
  218.         active = self._get_active()
  219.         if active is not None:
  220.             active.set_active(False)
  221.         
  222.         self.sync_gconf()
  223.  
  224.     
  225.     def sync_gconf(self):
  226.         active = self._get_active()
  227.         if active is not None:
  228.             self.gconf_value.data = self.keys[active]
  229.         else:
  230.             self.gconf_value.reset_default()
  231.  
  232.     
  233.     def __set_data(self, value):
  234.         self.sync_gconf()
  235.         self.gconf_value = value
  236.  
  237.     
  238.     def __get_data(self):
  239.         self.sync_gconf()
  240.         return self.gconf_value.data
  241.  
  242.     data = property(__get_data, __set_data)
  243.  
  244.  
  245. class Data(object):
  246.     """
  247.     This utility class acts as a synchronizer between a widget and gconf entry.
  248.     This data is considered to have problematic backends, since widgets can be
  249.     destroyed and gconf can have integrity problems (for example permissions or
  250.     schema change).
  251.     
  252.     To use the gaw.Data object you just need to specify it's associated type
  253.     (the schema) and optionally a default value.
  254.     
  255.     Here's a simple example on how to use it (taken from http://s1x.homelinux.net/documents/gaw_intro): 
  256.     
  257.             
  258.     """
  259.     
  260.     def __init__(self, widget, widget_getter, widget_setter, changed_signal, gconf_value):
  261.         self._Data__widget = widget
  262.         self._Data__widget_setter = widget_setter
  263.         self._Data__widget_getter = widget_getter
  264.         self._Data__gconf_value = gconf_value
  265.         gconf_value.set_callback(self._Data__on_gconf_changed)
  266.         widget.connect(changed_signal, self._Data__on_widget_changed)
  267.         widget.connect('destroy', self._Data__on_destroy)
  268.         if self.widget is not None:
  269.             self.sync_widget()
  270.         
  271.  
  272.     gconf_value = property((lambda self: self._Data__gconf_value))
  273.     widget = property((lambda self: self._Data__widget))
  274.     
  275.     def __get_data(self):
  276.         
  277.         try:
  278.             return self.gconf_value.data
  279.         except gobject.GError:
  280.             if self.widget is not None:
  281.                 val = self._Data__widget_getter()
  282.             else:
  283.                 return self.gconf_value.get_default()
  284.         except:
  285.             self.widget is not None
  286.  
  287.  
  288.     
  289.     def __set_data(self, data):
  290.         
  291.         try:
  292.             self.gconf_value.data = data
  293.         except gobject.GError:
  294.             pass
  295.  
  296.  
  297.     data = property(__get_data, __set_data, None, 'The data contained in this component.')
  298.     
  299.     def __on_destroy(self, widget):
  300.         self._Data__widget = None
  301.  
  302.     
  303.     def __on_widget_changed(self, *args):
  304.         if self.widget is None:
  305.             return None
  306.         
  307.         self.sync_gconf()
  308.  
  309.     
  310.     def __on_gconf_changed(self, client, conn_id, entry, user_data = None):
  311.         if self.widget is None:
  312.             return None
  313.         
  314.         data_spec = self.gconf_value.data_spec
  315.         self.widget.set_sensitive(client.key_is_writable(self.gconf_value.key))
  316.         if entry.value and entry.value.type == data_spec.gconf_type:
  317.             converter = getattr(entry.value, 'get_' + data_spec.name)
  318.             self._Data__widget_setter(converter())
  319.         else:
  320.             self._Data__widget_setter(self.gconf_value.get_default())
  321.         self.sync_gconf()
  322.  
  323.     
  324.     def sync_widget(self):
  325.         '''
  326.         Synchronizes the widget in favour of the gconf key. You must check if
  327.         there is a valid widget before calling this method.
  328.         '''
  329.         
  330.         try:
  331.             val = self.gconf_value.data
  332.             if val:
  333.                 self._Data__widget_setter(val)
  334.         except gobject.GError:
  335.             self._Data__widget_setter(self.gconf_value.get_default())
  336.  
  337.         self.sync_gconf()
  338.  
  339.     
  340.     def sync_gconf(self):
  341.         '''
  342.         Synchronizes the gconf key in favour of the widget. You must check if
  343.         there is a valid widget before calling this method.
  344.         '''
  345.         val = self._Data__widget_getter()
  346.         
  347.         try:
  348.             self.gconf_value.data = val
  349.             self._Data__widget_setter(self.gconf_value.data)
  350.         except gobject.GError:
  351.             pass
  352.  
  353.  
  354.  
  355.