Viewing file:  gconf_wrapper.py (6.45 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# -*- coding: utf-8 -*-
# GConf wrapper1
# COPIED VERBATIM FROM http://www.daa.com.au/pipermail/pygtk/2002-August/003220.html
# by Johan Dahlin
import gconf
from gconf import VALUE_BOOL, VALUE_INT, VALUE_STRING, VALUE_FLOAT
from types import StringType, IntType, FloatType, BooleanType
verbose = False
class GConfError (Exception):
pass
class GConf:
def __init__ (self, appname, allowed={}):
self._domain = '/apps/%s/' % appname
self._allowed = allowed
self._gconf_client = gconf.client_get_default ()
def __getitem__ (self, attr):
return self.get_value (attr)
def __setitem__ (self, key, val):
allowed = self._allowed
if allowed.has_key (key):
if not key in allowed[key]:
good = ', '.join (allowed[key])
raise GConfError, '%s must be one of: (%s)' % (key, good)
self.set_value (key, val)
def _get_type (self, key):
KeyType = type (key)
if KeyType == StringType:
return 'string'
elif KeyType == IntType:
return 'int'
elif KeyType == FloatType:
return 'float'
elif KeyType == BooleanType:
return 'bool'
else:
raise GConfError, 'unsupported type: %s' % str (KeyType)
# Public functions
def set_allowed (self, allowed):
self._allowed = allowed
def set_domain (self, domain):
self._domain = domain
def get_domain (self):
return self._domain
def get_gconf_client (self):
return self._gconf_client
def get_value (self, key):
'''returns the value of key `key' ''' #'
if '/' in key:
raise GConfError, 'key must not contain /'
value = self._gconf_client.get (self._domain + key)
if value == None:
raise GConfError, "gconf_client returned a None!"
ValueType = value.type
if ValueType == VALUE_BOOL:
return value.get_bool ()
elif ValueType == VALUE_INT:
return value.get_int ()
elif ValueType == VALUE_STRING:
return value.get_string ()
elif ValueType == VALUE_FLOAT:
return value.get_float ()
def set_value (self, key, value):
'''sets the value of key `key' to `value' '''
value_type = self._get_type (value)
if '/' in key:
raise GConfError, 'key must not contain /'
func = getattr (self._gconf_client, 'set_' + value_type)
apply (func, (self._domain + key, value))
def get_string (self, key):
if '/' in key:
raise GConfError, 'key must not contain /'
return self._gconf_client.get_string (self._domain + key)
def set_string (self, key, value):
if type (value) != StringType:
raise GConfError, 'value must be a string'
if '/' in key:
raise GConfError, 'key must not contain /'
self._gconf_client.set_string (self._domain + key, value)
def get_bool (self, key):
if '/' in key:
raise GConfError, 'key must not contain /'
return self._gconf_client.get_bool (self._domain + key)
def set_bool (self, key, value):
if type (value) != IntType and \
(key != 0 or key != 1):
raise GConfError, 'value must be a boolean'
if '/' in key:
raise GConfError, 'key must not contain /'
self._gconf_client.set_bool (self._domain + key, value)
def get_int (self, key):
if '/' in key:
raise GConfError, 'key must not contain /'
return self._gconf_client.get_int (self._domain + key)
def set_int (self, key, value):
if type (value) != IntType:
raise GConfError, 'value must be an int'
if '/' in key:
raise GConfError, 'key must not contain /'
self._gconf_client.set_int (self._domain + key, value)
def get_float (self, key):
if '/' in key:
raise GConfError, 'key must not contain /'
return self._gconf_client.get_float (self._domain + key)
def set_float (self, key, value):
if type (value) != FloatType:
raise GConfError, 'value must be an float'
if '/' in key:
raise GConfError, 'key must not contain /'
self._gconf_client.set_float (self._domain + key, value)
class GConfWrapper:
"""Provide some general purpose convenience functions for keeping
GConf keys and GUI in sync.
"""
# These can be defined by subclasses as they see fit
initial_prefs = {}
def __init__ (self, gconf):
"""gconf is an instance of our GConf convenience class."""
self.gconf = gconf
def gconf_wrap (self, key_name, widget,
get_method=lambda w: w.get_value(),
set_method=lambda w,v: w.set_value(v),
signal='changed'):
if verbose:
print 'Wrapping ',key_name,widget,get_method,set_method,signal
try:
if verbose: print 'setting ',key_name,self.gconf[key_name]
set_method(widget,self.gconf[key_name])
except:
if self.initial_prefs.has_key(key_name):
if verbose: print 'Falling back to value from initial_prefs',self.initial_prefs[key_name]
val = self.initial_prefs[key_name]
self.gconf[key_name]=val
set_method(widget,val)
else:
if verbose: print 'Falling back to value already in widget',
val = get_method(widget)
if verbose: print val
self.gconf[key_name]= val
set_method(widget,val)
widget.connect(signal,self.gconf_set_key,key_name,get_method)
def gconf_wrap_toggle (self, key_name, action):
self.gconf_wrap(key_name,action,
get_method=lambda w: w.get_active(),
set_method=lambda w,v: w.set_active(v),
signal='toggled')
def gconf_wrap_adjustment (self, key_name, adj):
self.gconf_wrap(key_name,adj,signal='value-changed')
def gconf_set_key (self, action, key_name, get_method):
# gconf takes integers rather than booleans...
if verbose: print 'Setting ',key_name,'->',get_method(action)
self.gconf[key_name]= get_method(action)
def test():
c = GConf ('test-gconf')
c['foo'] = '1'
c['bar'] = 2
c['baz'] = 3.0
print c['foo'], c['bar'], c['baz']
if __name__ == '__main__':
test()
|