def _create_new_object(type_name, pnode):
att = {}
obj = None
print 'new:', type_name
isAction = gobject.type_is_a(type_name, 'GtkAction')
isActionGroup = gobject.type_is_a(type_name, 'GtkActionGroup')
isMenuItem = gobject.type_is_a(type_name, 'GtkMenuItem')
isToolItem = gobject.type_is_a(type_name, 'GtkToolItem')
if isAction or isActionGroup:
att = _conly_properties(pnode, type_name)
elif isMenuItem or isToolItem:
_id = node = pnode.parentNode.getAttribute('action')
if not _id == '':
dic = _top_node(pnode).loader.dic
act = dic[int(_id)]
if isMenuItem:
obj = act.create_menu_item()
elif isToolItem:
obj = act.create_tool_item()
obj.set_data('shakya:action', act)
if not obj:
obj = gobject.new(type_name, **att)
if gobject.type_is_a(obj, gtk.Widget):
obj.hide()
return obj
def _object_to_xml(self, obj, parent_node=None):
doc = self._doc
# create the object node
node = doc.createElement('object')
node.setAttribute('class', gobject.type_name(obj))
node.setAttribute('id', '%d'%id(obj))
if isinstance(obj, gtk.MenuItem) or isinstance(obj, gtk.ToolItem):
act = obj.get_data('shakya:action')
if act:
node.setAttribute('action', '%d' % id(act))
# write the object properties
prop_node = doc.createElement('properties')
self._write_properties(prop_node, obj)
node.appendChild(prop_node)
# write the widget child-properties
if gobject.type_is_a(obj, 'GtkWidget'):
parent = obj.get_parent()
if parent and gobject.type_is_a(parent, 'GtkContainer'):
childprop_node = doc.createElement('child-properties')
self._write_child_properties(childprop_node, obj)
node.appendChild(childprop_node)
# write container widget children
if isinstance(obj, gtk.Container):
act = None
if isinstance(obj, gtk.MenuItem) or isinstance(obj, gtk.ToolItem):
act = obj.get_data('shakya:action')
if not act:
children_node = doc.createElement('children')
for child in self._filter_children(obj.get_children()):
child_node = self._object_to_xml(child, children_node)
node.appendChild(children_node)
# write menuitem submenus
if isinstance(obj, gtk.MenuItem):
submenu_node = doc.createElement('submenu')
submenu = obj.get_submenu()
if submenu:
menu_node = self._object_to_xml(submenu, submenu_node)
node.appendChild(submenu_node)
# link child node with parent
if parent_node:
parent_node.appendChild(node)
return node
def _object_to_xml(self, obj, parent_node=None):
doc = self._doc
# create the object node
node = doc.createElement('object')
node.setAttribute('class', gobject.type_name(obj))
node.setAttribute('id', '%d' % id(obj))
if isinstance(obj, gtk.MenuItem) or isinstance(obj, gtk.ToolItem):
act = obj.get_data('shakya:action')
if act:
node.setAttribute('action', '%d' % id(act))
# write the object properties
prop_node = doc.createElement('properties')
self._write_properties(prop_node, obj)
node.appendChild(prop_node)
# write the widget child-properties
if gobject.type_is_a(obj, 'GtkWidget'):
parent = obj.get_parent()
if parent and gobject.type_is_a(parent, 'GtkContainer'):
childprop_node = doc.createElement('child-properties')
self._write_child_properties(childprop_node, obj)
node.appendChild(childprop_node)
# write container widget children
if isinstance(obj, gtk.Container):
act = None
if isinstance(obj, gtk.MenuItem) or isinstance(obj, gtk.ToolItem):
act = obj.get_data('shakya:action')
if not act:
children_node = doc.createElement('children')
for child in self._filter_children(obj.get_children()):
child_node = self._object_to_xml(child, children_node)
node.appendChild(children_node)
# write menuitem submenus
if isinstance(obj, gtk.MenuItem):
submenu_node = doc.createElement('submenu')
submenu = obj.get_submenu()
if submenu:
menu_node = self._object_to_xml(submenu, submenu_node)
node.appendChild(submenu_node)
# link child node with parent
if parent_node:
parent_node.appendChild(node)
return node
def _get_base_type(self, value_type):
if gobject.type_is_a(value_type, gobject.TYPE_OBJECT):
base_type = gobject.TYPE_OBJECT
elif gobject.type_is_a(value_type, gobject.TYPE_ENUM):
base_type = gobject.TYPE_ENUM
elif gobject.type_is_a(value_type, gobject.TYPE_FLAGS):
base_type = gobject.TYPE_FLAGS
elif gobject.type_is_a(value_type, gobject.TYPE_BOXED):
base_type = gobject.TYPE_BOXED
else:
base_type = value_type
base = self._bases.get(base_type)
if not base:
raise PropertyError("Can't find base type for %r" % base_type)
return base
def _update_paste_action(self, selection, clipboard_item):
"""
Update the paste action.
@param selection: the selected widgets
@type selection: list
@param clipboard_item: the selected item on the clipboard
@type clipboard_item: L{gazpacho.clipboard.ClipboardItem}
"""
sensitive = False
if clipboard_item:
# We can always paste a toplevel
if clipboard_item.is_toplevel:
sensitive = True
# columns can be pasted in tree views
elif (len(selection) == 1
and isinstance(selection[0], gtk.TreeView)
and gobject.type_is_a(clipboard_item.type,
gtk.TreeViewColumn)):
sensitive = True
# otherwise we need a placeholder
elif (len(selection) == 1
and isinstance(selection[0], Placeholder)):
sensitive = True
bar_manager.set_action_prop('Paste', sensitive=sensitive)
def get_type(self, x):
for t in ("GParamFloat", "GParamDouble"):
if gobject.type_is_a(x, gobject.type_from_name(t)):
return "float"
for t in ("GParamInt", "GParamInt64", "GParamUInt", "GParamUInt64", "GParamLong", "GParamULong"):
if gobject.type_is_a(x, gobject.type_from_name(t)):
return "integer"
for t in ("GParamString", "GParamChar", "GParamUChar"):
if gobject.type_is_a(x, gobject.type_from_name(t)):
return "string"
if gobject.type_is_a(x, gobject.type_from_name("GParamEnum")):
return "enum"
if gobject.type_is_a(x, gobject.type_from_name("GParamBoolean")):
return "boolean"
return "unknown"
def do_get_accounts(self, list, types):
store = False
transport = False
if types == tinymail.ACCOUNT_STORE_STORE_ACCOUNTS:
store = True
elif types == tinymail.ACCOUNT_STORE_TRANSPORT_ACCOUNTS:
transport = True
else:
store = True
transport = True
for account in self.__accounts:
if gobject.type_is_a(account.__gtype__,
tinymail.StoreAccount) and store:
list.append(account)
elif gobject.type_is_a(account._gtype__,
tinymail.TransportAccount) and transport:
list.append(account)
def _add_type(self, prop_name, prop_type, pspec=None):
if pspec:
if gobject.type_is_a(pspec.value_type, gobject.TYPE_ENUM):
prop_type.enum_class = pspec.enum_class
elif gobject.type_is_a(pspec.value_type, gobject.TYPE_FLAGS):
prop_type.flags_class = pspec.flags_class
prop_type.label = pspec.nick
prop_type.type = pspec.value_type
else:
if not prop_type.label:
prop_type.label = prop_name.capitalize()
if prop_name in self._types:
msg = "There is already a property called %s registered"
raise TypeError(msg % prop_name)
self._types[prop_name] = prop_type
def _setup_widget(self, widget_name, widget):
if not IProxyWidget.providedBy(widget):
raise ProxyError("The widget %s (%r), in view %s is not "
"a kiwi widget and cannot be added to a proxy"
% (widget_name, widget,
self._view.__class__.__name__))
data_type = _get_widget_data_type(widget)
if data_type is None:
raise ProxyError("The kiwi widget %s (%r) in view %s should "
"have a data type set" % (
widget_name, widget, self._view.__class__.__name__))
attribute = widget.get_property('model-attribute')
if not attribute:
attribute = widget_name
widget.set_property('model-attribute', widget_name)
# Do a isinstance here instead of in the callback,
# as an optimization, it'll never change in runtime anyway
connection_id = widget.connect(
'content-changed',
self._on_widget__content_changed,
attribute,
IValidatableProxyWidget.providedBy(widget))
widget.set_data('content-changed-id', connection_id)
if IValidatableProxyWidget.providedBy(widget):
connection_id = widget.connect(
'notify::visible',
self._on_widget__notify)
widget.set_data('notify-visible-id', connection_id)
connection_id = widget.connect(
'notify::sensitive',
self._on_widget__notify)
widget.set_data('notify-sensitive-id', connection_id)
connection_id = widget.connect(
'validation-changed',
self._on_widget__validation_changed,
attribute)
widget.set_data('validation-changed-id', connection_id)
model_attributes = self._model_attributes
# save this widget in our map
if (attribute in model_attributes and
# RadioButtons are allowed several times
not gobject.type_is_a(widget, 'GtkRadioButton')):
old_widget = model_attributes[attribute]
raise KeyError("The widget %s (%r) in view %s is already in "
"the proxy, defined by widget %s (%r)" % (
widget_name, widget, self._view.__class__.__name__,
old_widget.name, old_widget))
model_attributes[attribute] = widget
self._reset_widget(attribute, widget)
def _setup_widget(self, widget_name, widget):
if not IProxyWidget.providedBy(widget):
raise ProxyError("The widget %s (%r), in view %s is not "
"a kiwi widget and cannot be added to a proxy"
% (widget_name, widget,
self._view.__class__.__name__))
data_type = _get_widget_data_type(widget)
if data_type is None:
raise ProxyError("The kiwi widget %s (%r) in view %s should "
"have a data type set" % (
widget_name, widget, self._view.__class__.__name__))
attribute = widget.get_property('model-attribute')
if not attribute:
attribute = widget_name
widget.set_property('model-attribute', widget_name)
# Do a isinstance here instead of in the callback,
# as an optimization, it'll never change in runtime anyway
connection_id = widget.connect(
'content-changed',
self._on_widget__content_changed,
attribute,
IValidatableProxyWidget.providedBy(widget))
widget.set_data('content-changed-id', connection_id)
if IValidatableProxyWidget.providedBy(widget):
connection_id = widget.connect(
'notify::visible',
self._on_widget__notify)
widget.set_data('notify-visible-id', connection_id)
connection_id = widget.connect(
'notify::sensitive',
self._on_widget__notify)
widget.set_data('notify-sensitive-id', connection_id)
connection_id = widget.connect(
'validation-changed',
self._on_widget__validation_changed,
attribute)
widget.set_data('validation-changed-id', connection_id)
model_attributes = self._model_attributes
# save this widget in our map
if (attribute in model_attributes and
# RadioButtons are allowed several times
not gobject.type_is_a(widget, 'GtkRadioButton')):
old_widget = model_attributes[attribute]
raise KeyError("The widget %s (%r) in view %s is already in "
"the proxy, defined by widget %s (%r)" % (
widget_name, widget, self._view.__class__.__name__,
old_widget.name, old_widget))
model_attributes[attribute] = widget
self._reset_widget(attribute, widget)
def load_ui(filename):
print 'Loading: %s...' % filename
loader = UILoader()
obj = loader.load(filename)
print obj
if gobject.type_is_a(obj, 'GtkWindow'):
w, h = obj.get_default_size()
obj.resize(w, h)
return obj
def _create_editor_property(self, property_class):
if property_class.editor != PropertyCustomEditor:
return EditorPropertySpecial(property_class, self._app)
# Special case GObject subclasses
if gobject.type_is_a(property_class.type, gobject.GObject):
return EditorPropertyObject(property_class, self._app)
if property_map.has_key(property_class.base_type):
return property_map[property_class.base_type](property_class,
self._app)
def get_pixbuf(name, fail_gracefully=0, width=0, height=0):
if not name:
assert fail_gracefully
return None
if width > 0 and height > 0:
key = "%s %d %d" % (name, width, height)
else:
key = name
# If this isn't a string, maybe it is a GdkPixbuf. If so, just
# pass it through. Otherwise something is very wrong, so we
# assert.
# FIXME: How do I check this type w/o the "try"?
if type(name) != type(""):
try:
if gobject.type_is_a(name.__gtype__,
gtk.gdk.Pixbuf.__gtype__):
return name
except:
print "Unknown type passed to get_pixbuf"
assert 0
if pixbuf_cache.has_key(key):
return pixbuf_cache[key]
pixbuf = None
if width > 0 and height > 0:
original = get_pixbuf(name)
pixbuf = original.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
else:
for dir in pixbuf_path:
filename = os.path.join(dir, name + ".png")
if os.path.isfile(filename):
pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
if not pixbuf:
print "Couldn't load pixbuf from '%s'" % filename
assert 0
if pixbuf:
pixbuf_cache[key] = pixbuf
return pixbuf
if not fail_gracefully:
print "Couldn't find pixbuf '%s'" % name
assert 0
return None
def get_enum(p):
vals = []
if not gobject.type_is_a(p.value_type, gobject.TYPE_ENUM):
raise errors.ComponentSetupError(p.name + ': unexpected property type.')
else:
for item in p.enum_class.__enum_values__.items():
vals.append({
'value': item[0],
'name': item[1].value_name,
'nick': item[1].value_nick
})
return vals
def get_pixbuf(name, fail_gracefully=0, width=0, height=0):
if not name:
assert fail_gracefully
return None
if width > 0 and height > 0:
key = "%s %d %d" % (name, width, height)
else:
key = name
# If this isn't a string, maybe it is a GdkPixbuf. If so, just
# pass it through. Otherwise something is very wrong, so we
# assert.
# FIXME: How do I check this type w/o the "try"?
if type(name) != type(""):
try:
if gobject.type_is_a(name.__gtype__, gtk.gdk.Pixbuf.__gtype__):
return name
except:
print "Unknown type passed to get_pixbuf"
assert 0
if pixbuf_cache.has_key(key):
return pixbuf_cache[key]
pixbuf = None
if width > 0 and height > 0:
original = get_pixbuf(name)
pixbuf = original.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
else:
for dir in pixbuf_path:
filename = os.path.join(dir, name + ".png")
if os.path.isfile(filename):
pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
if not pixbuf:
print "Couldn't load pixbuf from '%s'" % filename
assert 0
if pixbuf:
pixbuf_cache[key] = pixbuf
return pixbuf
if not fail_gracefully:
print "Couldn't find pixbuf '%s'" % name
assert 0
return None
def valuefromstringsimpletypes(gtype, string):
if gtype in (gobject.TYPE_CHAR, gobject.TYPE_UCHAR):
value = string[0]
elif gtype == gobject.TYPE_BOOLEAN:
value = str2bool(string)
elif gtype in (gobject.TYPE_INT, gobject.TYPE_UINT):
value = int(string)
elif gtype in (gobject.TYPE_LONG, gobject.TYPE_ULONG):
value = long(string)
elif gtype in (gobject.TYPE_FLOAT, gobject.TYPE_DOUBLE):
value = float(string)
elif gtype == gobject.TYPE_STRING:
value = string
elif gobject.type_is_a(gtype, gobject.TYPE_PYOBJECT):
value = string
elif gobject.type_is_a(gtype, gobject.GBoxed):
print 'TODO: boxed'
value = None
else:
raise TypeError("type %r is unknown" % gtype)
return value
def testConstruct(self):
objs = [("kiwi+ui+widgets+list+List", "w1"),
("kiwi+ui+widgets+combobox+ComboBox", "w3"),
("kiwi+ui+widgets+combobox+ComboBoxEntry", "w5")
]
if HAVE_2_8:
objs.extend([("ObjectList", "w2"),
("ProxyComboBox", "w4"),
("ProxyComboBoxEntry", "w6")
])
s = ''
for obj, name in objs:
s += '<widget class="%s" id="%s"/>\n' % (obj, name)
ob = disabledeprecationcall(ObjectBuilder, buffer=glade(s))
for obj, name in objs:
widget = ob.get_widget(name)
self.failUnless(isinstance(widget, gtk.Widget))
gtype = gobject.type_from_name(obj)
self.failUnless(gobject.type_is_a(gtype, gtk.Widget))
self.failUnless(gobject.type_is_a(gtype, widget))
def _build_object(node, parent=None):
pnode = _get_first_child(node, 'properties')
cpnode = _get_first_child(node, 'child-properties')
cnode = _get_first_child(node, 'children')
#print pnode, cpnode, cnode
_id = int(node.getAttribute('id'))
type_name = str(node.getAttribute('class'))
obj = _create_new_object(type_name, pnode); print obj
_add_child(parent, obj)
# store a reference on the dictionary
dic = _top_node(node).loader.dic
dic[_id] = obj
# setup the properties
for prop in _properties(pnode):
_set_property(obj, prop)
# setup the child-properties
if parent and gobject.type_is_a(parent, 'GtkContainer'):
for prop in _properties(cpnode):
_set_child_property(parent, obj, prop)
# recursively create children
if gobject.type_is_a(obj, 'GtkContainer'):
for child in _children(cnode):
_build_object(child, obj)
# create submenus
if gobject.type_is_a(obj, 'GtkMenuItem'):
submenu = _get_first_child(node, 'submenu')
#print '*** menuitem', submenu
if submenu:
child = _get_first_child(submenu, 'object')
if child:
_build_object(child, obj)
return obj
def get_builder_toplevel(self, builder):
"""Get the toplevel widget from a gtk.Builder file.
The main view implementation first searches for the widget named as
self.toplevel_name (which defaults to "main". If this is missing, or not
a gtk.Window, the first toplevel window found in the gtk.Builder is
used.
"""
toplevel = builder.get_object(self.toplevel_name)
if not gobject.type_is_a(toplevel, gtk.Window):
toplevel = None
if toplevel is None:
toplevel = get_first_builder_window(builder)
return toplevel
def fetch(obj):
"""
Fetch properties info of an object. This is used in the Property Browser
to get all the editable properties of that object.
"""
result = []
properties = list(gobject.list_properties(obj))
for klass, infos in _infos.iteritems():
if gobject.type_is_a(obj, klass):
for info in infos:
info.property = _get_property(info.name, properties)
result.append(info)
return result
def fetch(obj):
"""
Fetch properties info of an object. This is used in the Property Browser
to get all the editable properties of that object.
"""
result = []
properties = list(gobject.list_properties(obj))
for klass, infos in _infos.iteritems():
if gobject.type_is_a(obj, klass):
for info in infos:
info.property = _get_property(info.name, properties)
result.append(info)
return result
def _apply_delayed_properties(self):
for inst, prop in self._delayed_properties:
if '.' in prop.name:
parts = prop.name.split('.')
start = parts[0]
for part in parts[:-1]:
inst = getattr(inst.props, part)
prop_name = parts[-1]
else:
prop_name = prop.name
pspec = getattr(inst.__class__.props, prop_name)
if GObject.type_is_a(pspec.value_type, GObject.TYPE_OBJECT):
value = self._objects[prop.value]
else:
value = self._parse_property(pspec, prop)
inst.set_property(prop_name, value)
def load(self, widget):
self._start_load(widget)
current = self.property.get()
self.model.clear()
for pwidget in self.project.get_widgets():
if isinstance(pwidget, gtk.Window):
continue
if not gobject.type_is_a(pwidget, self.property_type):
continue
iter = self.model.append((pwidget.name, pwidget))
if pwidget == current:
self.input.set_active_iter(iter)
self._finish_load()
def ListDeviceProbe(element, probe_name):
element_name = element.get_factory().get_property("name")
dev_info_list = []
if hasattr(element.props, "device"):
default_device = element.__class__.props.device.default_value
if gobject.type_is_a(element, gst.interfaces.PropertyProbe):
element.probe_property_name("device")
devices = element.probe_get_values_name("device")
if (default_device != None) and (default_device not in devices):
dev_info_list.append((default_device, ""))
if probe_name and hasattr(element.props, "device-name"):
for dev in devices:
element.set_property("device", dev)
# certain elements like pulsesrc won't load the device-name until STATE_PLAYING
state_change_type = element.set_state(gst.STATE_PLAYING)
if state_change_type == gst.STATE_CHANGE_ASYNC:
new_state = None
while new_state != gst.STATE_PLAYING and new_state != gst.STATE_READY:
gtk.main_iteration()
state_change_type, new_state, pending = element.get_state(
0)
time.sleep(0.01)
name = element.get_property("device-name")
element.set_state(gst.STATE_NULL)
dev_info_list.append((dev, name))
else:
for dev in devices:
dev_info_list.append((dev, ""))
else:
dev_info_list.append((default_device, ""))
else:
Globals.debug("Cannot list devices: property probe not supported on",
element_name)
# Sort the devices by device ID (ensures that monitor devices are after canonical devices)
dev_info_list.sort()
return dev_info_list
def _valuefromstring(self, obj_id, pspec, string):
# This is almost a 1:1 copy of glade_xml_set_value_from_string from
# libglade.
prop_type = pspec.value_type
if (prop_type in (gobject.TYPE_INT, gobject.TYPE_UINT)
and gobject.type_name(pspec) == 'GParamUnichar'):
value = unicode(string and string[0] or "")
return value
try:
value = valuefromstringsimpletypes(prop_type, string)
except TypeError:
pass # it's ok if we fail so far, we'll try other types
else:
return value
if gobject.type_is_a(prop_type, gobject.TYPE_ENUM):
value = enumfromstring(string, pspec)
elif gobject.type_is_a(prop_type, gobject.TYPE_FLAGS):
value = flagsfromstring(string, pspec)
elif gobject.type_is_a(prop_type, gobject.GObject):
if gobject.type_is_a(prop_type, gtk.Adjustment):
value = gtk.Adjustment(0, 0, 100, 1, 10, 10)
(value.value, value.lower, value.upper,
value.step_increment, value.page_increment,
value.page_size) = map(float, string.split(' '))
elif gobject.type_is_a(prop_type, gdk.Pixbuf):
filename = self._build.find_resource(string)
value = None
if filename:
# XXX: Handle GError exceptions.
value = gdk.pixbuf_new_from_file(filename);
elif (gobject.type_is_a(gobject.GObject, prop_type) or
gobject.type_is_a(prop_type, gobject.GObject)):
value = self._build.get_widget(string)
if value is None:
self._build.add_delayed_property(obj_id, pspec, string)
else:
value = None
else:
raise AssertionError("type %r is unknown" % prop_type)
return value
def ListDeviceProbe(element, probe_name):
element_name = element.get_factory().get_property("name")
dev_info_list = []
if hasattr(element.props, "device"):
default_device = element.__class__.props.device.default_value
if gobject.type_is_a(element, gst.interfaces.PropertyProbe):
element.probe_property_name("device")
devices = element.probe_get_values_name("device")
if (default_device != None) and (default_device not in devices):
dev_info_list.append((default_device, ""))
if probe_name and hasattr(element.props, "device-name"):
for dev in devices:
element.set_property("device", dev)
# certain elements like pulsesrc won't load the device-name until STATE_PLAYING
state_change_type = element.set_state(gst.STATE_PLAYING)
if state_change_type == gst.STATE_CHANGE_ASYNC:
new_state = None
while new_state != gst.STATE_PLAYING and new_state != gst.STATE_READY:
gtk.main_iteration()
state_change_type, new_state, pending = element.get_state(0)
time.sleep(0.01)
name = element.get_property("device-name")
element.set_state(gst.STATE_NULL)
dev_info_list.append((dev, name))
else:
for dev in devices:
dev_info_list.append((dev, ""))
else:
dev_info_list.append((default_device, ""))
else:
Globals.debug("Cannot list devices: property probe not supported on", element_name)
# Sort the devices by device ID (ensures that monitor devices are after canonical devices)
dev_info_list.sort()
return dev_info_list
def __init__(self, gadget):
self._initial = None
cls = type(self)
assert cls.name != None
assert cls.owner_name != None
assert cls.owner_type != gobject.TYPE_INVALID
self.gadget = gadget
self._project = gadget.project
gobj = gadget.widget
# Assert that the owner is of correct type
if self.child:
test_object = gobj.get_parent()
else:
test_object = gobj
if not gobject.type_is_a(test_object, self.owner_type):
raise TypeError("Expected an object of type %s, got %r" % (
gobject.type_name(self.owner_type), test_object))
self.load()
def load_gadget_from_widget(widget, project):
""" This function creates a gadget from a widget.
It recursively creates any children of the original widget.
This method is mainly used when loading a .glade file with
gazpacho.loader
Also makes sure the name of the widget is unique in the project
parameter and if not, change it for a valid one.
@return: a new gadget
@rtype: Gadget
"""
# widget may not have a name if it is an intermediate internal children
# For example, the label of a button does not have a name
if widget.name is None:
# this is not an important widget but maybe its children are
if isinstance(widget, gtk.Container):
for child in get_all_children(widget):
load_gadget_from_widget(child, project)
return
type_name = gobject.type_name(widget)
adaptor = widget_registry.get_by_name(type_name)
if adaptor is None:
print 'Warning: could not get the class from widget: %s' % widget
return
gadget = adaptor.load(project.context, widget)
if not isinstance(gadget, Gadget):
raise TypeError("WidgetAdaptor.load should always return a Gadget"
" not %s" % gadget)
if not gobject.type_is_a(gadget.widget, adaptor.type):
raise TypeError("%s is not of the type %s"
% (gadget.widget, adaptor.type))
return gadget
def add_action_widget(self, child, response_id):
if not gobject.type_is_a(child, gtk.Widget):
print 'Not a Widget' #FIXME:
return
print '#TODO: add response data'
print child
if type(child) is gtk.Button:
signal_id = gobject.signal_lookup('clicked', type(child))
else:
signal_id = gobject.signal_lookup('activate', type(child))
if signal_id:
print 'TODO: check if this is correct.'
signal = gobject.signal_name(signal_id)
child.connect(signal, MessageArea.__action_widget_activated, self) #FIXME:
else:
print "Only 'activatable' widgets can be packed into the action area of a MessageArea"
if response_id != gtk.RESPONSE_HELP:
self.action_area.pack_start(child, False, False, 0)
else:
self.action_area.pack_end(child, False, False, 0)
def gproperty(name,
ptype,
default=None,
nick='',
blurb='',
flags=gobject.PARAM_READWRITE,
**kwargs):
"""
Add a GObject property to the current object.
@param name: name of property
@type name: string
@param ptype: type of property
@type ptype: type
@param default: default value
@param nick: short description
@param blurb: long description
@param flags: parameter flags, a combination of:
- PARAM_READABLE
- PARAM_READWRITE
- PARAM_WRITABLE
- PARAM_CONSTRUCT
- PARAM_CONSTRUCT_ONLY
- PARAM_LAX_VALIDATION
Optional, only for int, float, long types:
@note: minimum: minimum allowed value
@note: maximum: maximum allowed value
"""
# General type checking
if default is None:
default = _DEFAULT_VALUES.get(ptype)
elif not isinstance(default, ptype):
raise TypeError("default must be of type %s, not %r" %
(ptype, default))
if not isinstance(nick, str):
raise TypeError('nick for property %s must be a string, not %r' %
(name, nick))
nick = nick or name
if not isinstance(blurb, str):
raise TypeError('blurb for property %s must be a string, not %r' %
(name, blurb))
# Specific type checking
if ptype == int or ptype == float or ptype == long:
default = (kwargs.get('minimum', ptype(0)),
kwargs.get('maximum', _MAX_VALUES[ptype]), default)
elif ptype == bool:
if (default is not True and default is not False):
raise TypeError("default must be True or False, not %r" %
(default))
default = default,
elif gobject.type_is_a(ptype, gobject.GEnum):
if default is None:
raise TypeError("enum properties needs a default value")
elif not isinstance(default, ptype):
raise TypeError("enum value %s must be an instance of %r" %
(default, ptype))
default = default,
elif ptype == str:
default = default,
elif ptype == object:
if default is not None:
raise TypeError("object types does not have default values")
default = ()
else:
raise NotImplementedError("type %r" % ptype)
if flags < 0 or flags > 32:
raise TypeError("invalid flag value: %r" % (flags, ))
frame = sys._getframe(1)
try:
locals = frame.f_locals
dict = locals.setdefault('__gproperties__', {})
finally:
del frame
dict[name] = (ptype, nick, blurb) + default + (flags, )
def append_widget_to_model(self, widget, parent_iter, model):
iter = model.append(parent_iter, _widget_data(widget))
if gobject.type_is_a(widget, 'GtkContainer'):
for child in widget.get_children():
self.append_widget_to_model(child, iter, model)
def gproperty(name, ptype, default=None, nick="", blurb="", flags=gobject.PARAM_READWRITE, **kwargs):
"""Add a GObject property to the current object.
:param name: name of property
:param ptype: type of property
:param default: default value
:param nick: short description
:param blurb: long description
:param flags: parameter flags, a combination of:
- PARAM_READABLE
- PARAM_READWRITE
- PARAM_WRITABLE
- PARAM_CONSTRUCT
- PARAM_CONSTRUCT_ONLY
- PARAM_LAX_VALIDATION
Optional, only for int, float, long types:
:param minimum: minimum allowed value
:param: maximum: maximum allowed value
"""
# General type checking
if default is None:
default = _DEFAULT_VALUES.get(ptype)
elif not isinstance(default, ptype):
raise TypeError("default must be of type %s, not %r" % (ptype, default))
if not isinstance(nick, str):
raise TypeError("nick for property %s must be a string, not %r" % (name, nick))
nick = nick or name
if not isinstance(blurb, str):
raise TypeError("blurb for property %s must be a string, not %r" % (name, blurb))
# Specific type checking
if ptype == int or ptype == float or ptype == long:
default = (kwargs.get("minimum", ptype(0)), kwargs.get("maximum", _MAX_VALUES[ptype]), default)
elif ptype == bool:
if default is not True and default is not False:
raise TypeError("default must be True or False, not %r" % (default))
default = (default,)
elif gobject.type_is_a(ptype, gobject.GEnum):
if default is None:
raise TypeError("enum properties needs a default value")
elif not isinstance(default, ptype):
raise TypeError("enum value %s must be an instance of %r" % (default, ptype))
default = (default,)
elif ptype == str:
default = (default,)
elif ptype == object:
if default is not None:
raise TypeError("object types does not have default values")
default = ()
else:
raise NotImplementedError("type %r" % ptype)
if flags < 0 or flags > 32:
raise TypeError("invalid flag value: %r" % (flags,))
frame = sys._getframe(1)
try:
locals = frame.f_locals
dict = locals.setdefault("__gproperties__", {})
finally:
del frame
dict[name] = (ptype, nick, blurb) + default + (flags,)
def find_cancel_btn(btn, _self):
if btn and gobject.type_is_a(
btn, gtk.Button) and btn.get_label() == gtk.STOCK_CANCEL:
_self.cancel_btn = btn
def test_ui_main_delegate_bad_toplevel():
d = _Delegate6()
assert gobject.type_is_a(d._toplevel, gtk.Window)
def _get_pspec_args(self):
if gobject.type_is_a(self.type, gobject.GEnum):
return (self.type, self.nick, self.blurb, self.default, self.flags)
else:
return parent_get_pspec_args(self)
def _get_pspec_args(self):
if gobject.type_is_a(self.type, gobject.GEnum):
return (self.type, self.nick, self.blurb, self.default, self.flags)
else:
return parent_get_pspec_args(self)
def append_widget_to_model(self, widget, parent_iter, model):
iter = model.append(parent_iter, _widget_data(widget))
if gobject.type_is_a(widget, 'GtkContainer'):
for child in widget.get_children():
self.append_widget_to_model(child, iter, model)
def find_hbox(w, _self):
if w and gobject.type_is_a(w, gtk.HBox):
w.forall(find_cancel_btn, _self)
def __init__(self, element=None):
gtk.Window.__init__(self)
if element:
title = element.props.name + " - Parameters"
self.set_title(title)
self.element = element
self.set_position(gtk.WIN_POS_MOUSE)
self.set_default_size(380, 500)
self.connect("delete-event", self.onDelete)
self.vbox = gtk.VBox()
self.vbox.set_border_width(15)
self.scrollwin = gtk.ScrolledWindow()
self.scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scrollwin.add_with_viewport(self.vbox)
self.add(self.scrollwin)
#TODO: make this prettier
self.vbox.pack_start(gtk.Label('Set Element Parameters'), expand=False,
padding=10)
proplist = gobject.list_properties(self.element)
self.table = gtk.Table(len(proplist), 2)
self.table.props.row_spacing = 5
self.table.props.column_spacing = 5
self.vbox.pack_start(self.table, expand=False, padding=10)
count = 0
for property in proplist:
label = gtk.Label(property.name)
label.set_alignment(1,0.5)
self.table.attach(label, 0, 1, count, count+1)
#non readable params
if not(property.flags & gobject.PARAM_READABLE):
rlabel = gtk.Label("-parameter not readable-")
self.table.attach(plabel, 1, 2, count, count+1)
# just display non-writable param values
elif not(property.flags & gobject.PARAM_WRITABLE):
wvalue = self.element.get_property(property.name)
if wvalue:
wlabel = gtk.Label(wvalue)
self.table.attach(wlabel, 1, 2, count, count+1)
#TODO: tooltips using property.blurb
elif hasattr(property, "minimum") and hasattr(property, "maximum"):
#guess that it's numeric - we can use an HScale
value = self.element.get_property(property.name)
adj = gtk.Adjustment(value, property.minimum, property.maximum)
adj.connect("value_changed", self.onValueChanged, property)
hscale = gtk.HScale(adj)
hscale.set_value_pos(gtk.POS_RIGHT)
#check for ints and change digits
if not((property.value_type == gobject.TYPE_FLOAT) or
(property.value_type == gobject.TYPE_DOUBLE)):
hscale.set_digits(0)
self.table.attach(hscale, 1, 2, count, count+1)
#TODO: add numeric entry box
elif gobject.type_is_a(property.value_type, gobject.TYPE_BOOLEAN):
#booleans get a toggle button
#TODO: change this to a tick box or pixmap button
tstate = self.element.get_property(property.name)
if tstate:
button = gtk.ToggleButton("On")
else:
button = gtk.ToggleButton("Off")
button.set_active(tstate)
button.set_size_request(40,30)
button.connect("toggled", self.onToggled, property)
self.table.attach(button, 1, 2, count, count+1)
elif hasattr(property, "enum_class"):
#for enumerated types, use a combobox
choices = _getChoices(property)
enum = self.element.get_property(property.name)
combo = gtk.ComboBox(choices)
cell = gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, 'text', 0)
combo.set_active(enum)
combo.connect("changed", self.onComboBoxChanged, property)
self.table.attach(combo, 1, 2, count, count+1)
elif gobject.type_is_a(property.value_type, gobject.TYPE_STRING):
#strings get a gtk.Entry widget
entry = gtk.Entry()
text = self.element.get_property(property.name)
# ignore empty strings
if text:
entry.set_text(text)
entry.connect("changed", self.onEntryChanged, property)
self.table.attach(entry, 1, 2, count, count+1)
count += 1
