def _property_to_xml(self, owner, prop, ptype):
doc = self._doc
node = doc.createElement('property')
node.setAttribute('name', prop.name)
type_name = gobject.type_name(prop)
to_text = property._to_text[type_name]
if ptype == 'normal':
value = owner.get_property(prop.name)
elif ptype == 'child':
parent = owner.get_parent()
value = parent.child_get_property(owner, prop.name)
else:
raise TypeError
if gobject.type_name(prop.value_type) == 'GtkActionGroup':
print '***', value
#print '%s: %s' % (prop.name, type_name)
text = doc.createTextNode(to_text(value))
node.appendChild(text)
if (prop.flags & gobject.PARAM_CONSTRUCT_ONLY):
node.setAttribute('construct-only', 'True')
return node
def _property_to_xml(self, owner, prop, ptype):
doc = self._doc
node = doc.createElement('property')
node.setAttribute('name', prop.name)
type_name = gobject.type_name(prop)
to_text = property._to_text[type_name]
if ptype == 'normal':
value = owner.get_property(prop.name)
elif ptype == 'child':
parent = owner.get_parent()
value = parent.child_get_property(owner, prop.name)
else:
raise TypeError
if gobject.type_name(prop.value_type) == 'GtkActionGroup':
print '***', value
#print '%s: %s' % (prop.name, type_name)
text = doc.createTextNode(to_text(value))
node.appendChild(text)
if (prop.flags & gobject.PARAM_CONSTRUCT_ONLY):
node.setAttribute('construct-only', 'True')
return node
def _getproperties(self, gtype, obj_id, properties, child=False):
if child:
get_pspec = get_child_pspec_from_name
else:
get_pspec = get_pspec_from_name
propdict = self._properties
if not propdict.has_key(obj_id):
props = propdict[obj_id] = {}
else:
props = propdict[obj_id]
construct = {}
normal = []
for prop in properties:
propname = prop.name.replace('_', '-')
#full = '%s::%s' % (gobject.type_name(gtype), propname)
props[prop.name] = prop.data
if hasattr(self, 'prop_set_%s' % prop.name):
normal.append((prop.name, prop.data))
continue
pspec = get_pspec(gtype, propname)
if not pspec:
print ('Unknown property: %s:%s (id %s)' %
(gobject.type_name(gtype),
prop.name,
obj_id))
continue
try:
value = self._valuefromstring(obj_id, pspec, prop.data)
except ValueError:
print ("Convertion failed for %s:%s (id %s), "
"expected %s but found %r" %
(gobject.type_name(gtype),
prop.name,
obj_id,
gobject.type_name(pspec.value_type),
prop.data))
continue
# Could not
if value is None:
continue
if pspec.flags & gobject.PARAM_CONSTRUCT_ONLY != 0:
construct[pspec.name] = value
else:
normal.append((pspec.name, value))
if child:
assert not construct
return normal
return construct, normal
def add(self, menuitem, child, properties, type):
if isinstance(child, gtk.Menu):
menuitem.set_submenu(child)
else:
print 'FIXME: Adding a %s to a %s' % (gobject.type_name(child),
gobject.type_name(self.object_type))
# GtkWarning: Attempting to add a widget with type GtkImage to a
# GtkImageMenuItem, but as a GtkBin subclass a GtkImageMenuItem
# can only contain one widget at a time; it already contains a
# widget of type GtkAccelLabel'
#menuitem.add(child)
self._set_child_properties(menuitem, child, properties)
def _write_widget(self, widget, indent=0, props=None, extra=None):
extra = extra or []
line_props = []
name = self._items.get(hash(widget), '')
if name:
line_props.append(name)
line_props.extend(self._get_packing_properties(widget))
spaces = (' ' * (indent * 2))
if not props:
props = []
if not widget.get_visible():
props.append('hidden')
if not widget.get_sensitive():
props.append('insensitive')
if (widget.get_sensitive() and
widget.get_visible() and
not widget.get_can_focus() and
self._is_interactive_widget(widget)):
props.append('unfocusable')
fmt = "%s %s is not focusable"
self.failures.append(fmt % (gobject.type_name(widget),
self._items.get(hash(widget),
'???')))
if IValidatableProxyWidget.providedBy(widget):
if (not widget.is_valid() and
widget.get_sensitive() and
widget.get_visible()):
if widget.mandatory:
props.append('mandatory')
else:
props.append('invalid')
if props:
prop_lines = ' ' + ', '.join(props)
else:
prop_lines = ''
self.output += "%s%s(%s):%s\n" % (
spaces,
gobject.type_name(widget),
', '.join(line_props),
prop_lines)
spaces = (' ' * ((indent + 1) * 2))
for line in extra:
self.output += spaces + line + '\n'
def get_bounds(self, item):
if gobject.type_name(item)=="GnomeCanvasPixbuf":
x1=item.get_property("x")
y1=item.get_property("y")
x2=item.get_property("x")+item.get_property("width")
y2=item.get_property("y")+item.get_property("height")
return (min(x1,x2),min(y1,y2),max(x1,x2),max(y1,y2))
def make_property_widget(unused_element, prop, value=None):
""" Creates a Widget for the given element property """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if value == None:
value = prop.default_value
if type_name == "gchararray":
widget = TextWidget(default=prop.default_value)
elif type_name in ["guint64", "gint64", "guint", "gint", "gfloat", "gulong", "gdouble"]:
maximum, minimum = None, None
if hasattr(prop, "minimum"):
minimum = prop.minimum
if hasattr(prop, "maximum"):
maximum = prop.maximum
widget = NumericWidget(default=prop.default_value, upper=maximum, lower=minimum)
elif type_name == "gboolean":
widget = ToggleWidget(default=prop.default_value)
elif type_name == "GEnum":
idx = 0
choices = []
for key, val in prop.enum_class.__enum_values__.iteritems():
choices.append([val.value_name, int(val)])
widget = ChoiceWidget(choices, default=prop.default_value)
elif type_name == "GstFraction":
widget = FractionWidget(None, presets=["0:1"], default=prop.default_value)
else:
widget = DefaultWidget(type_name)
if value is not None and type_name != "GFlags":
widget.setWidgetValue(value)
return widget
def load(self):
parent_name = None
if self.child:
parent_name = gobject.type_name(self.object.get_parent())
# use the gtk value if this is an internal child
if self.gadget.internal_name or self.gadget.maintain_gtk_properties:
self._initial = self.gadget.adaptor.get_default_prop_value(
self, parent_name)
# we have to initialize _value from the gtk widget
if self.custom:
self._value = self._initial
else:
if self.child:
parent = self.object.get_parent()
self._value = parent.child_get_property(self.object,
self.name)
else:
# FIXME: This is broken, but needed for
# GtkRadioButton::group,
# see tests.test_glade.GladeTest.test_radiobutton
try:
self._value = self.object.get_property(self.name)
except TypeError:
self._value = None
else:
if self.custom or self.has_custom_default:
self._initial = self.default
self.set(self.default)
else:
self._initial = self.gadget.adaptor.get_default_prop_value(
self, parent_name)
def get_column_type_names(self):
"""
@returns: a list of type names
"""
model = self._model
return [gobject.type_name(model.get_column_type(i))
for i in range(model.get_n_columns() - 1)]
def load(self, context, column):
# column is a gtk.TreeViewColumn and we transform it into a
# GazpachoTreeViewColumn
gazpacho_column = GazpachoTreeViewColumn()
gazpacho_column.copy(column)
# copy the renderers also
func = renderer_expert.get_type_based_on_renderer
renderers = column.get_cell_renderers()
cells = [(func(gobject.type_name(r)), r) for r in renderers]
self.create_layout(gazpacho_column, cells)
# now we replace the pure column with the gazpacho column
# the old column is not useful anymore so we can set a custom widget
# just to get its parent. see GTK+ bug #342471
column.set_widget(gtk.Label())
tree_view = get_column_parent(column)
# when pasting a column from the clipboard, it is not attached to a
# tree view yet
if tree_view:
tree_view.remove_column(column)
tree_view.append_column(gazpacho_column)
gazpacho_column.update_widget()
project = context.get_project()
return Gadget.load(gazpacho_column, project)
def dump_widget(widget, lvl=0):
print '%s %s (%s)' % (' ' * lvl,
gobject.type_name(widget),
widget.get_name())
if isinstance(widget, gtk.Container):
for child in widget.get_children():
dump_widget(child, lvl+1)
def get_default_handler(klass, name):
properties = gobject.list_properties(klass)
for property in properties:
if property.name == name:
property_type = gobject.type_name(property)
break
return _default_handlers[property_type]
def get_default_handler(klass, name):
properties = gobject.list_properties(klass)
for property in properties:
if property.name == name:
property_type = gobject.type_name(property)
break
return _default_handlers[property_type]
def get_bounds(self, item):
if gobject.type_name(item) == "GooCanvasImage":
x1 = item.get_property("x")
y1 = item.get_property("y")
x2 = item.get_property("x")+item.get_property("width")
y2 = item.get_property("y")+item.get_property("height")
return (min(x1,x2),min(y1,y2),max(x1,x2),max(y1,y2))
return(None)
def get_by_type(self, obj, default=_Nothing):
"Return widget_adaptor for a given gobject type gtype"
if hasattr(obj, '__gtype__'):
gtype = obj.__gtype__
else:
gtype = obj
type_name = gobject.type_name(gtype)
return self.get_by_name(type_name, default)
def get_by_name_closest(self, type_name):
"""Return widget_adaptor for type_name or closest ancestor"""
gtype = gobject.type_from_name(type_name)
while True:
adapter = self._widget_adaptors.get(gobject.type_name(gtype))
if adapter is not None:
return adapter
gtype = gobject.type_parent(gtype)
def _filter_properties(self, properties):
res = []
for prop in properties:
type_name = gobject.type_name(prop)
if property._to_text.has_key(type_name):
if (prop.flags & gobject.PARAM_READABLE) and \
(prop.flags & gobject.PARAM_WRITABLE):
res.append(prop)
return res
def get_adapter(self, gobj, type_name=None, build=None):
# Name is optional, for performance reasons we want
# to send it as often as we can, normally it's already
# known at the callsite.
if type_name == None:
type_name = gobject.type_name(gobj)
orig_name = type_name
while True:
adapter = self._adapters.get(type_name)
if adapter:
# Store a reference for the adapter, to make the
# next lookup faster
self._adapters[orig_name] = adapter
return adapter(build)
gobj = gobject.type_parent(gobj)
type_name = gobject.type_name(gobj)
def _filter_properties(self, properties):
res = []
for prop in properties:
type_name = gobject.type_name(prop)
if property._to_text.has_key(type_name):
if (prop.flags & gobject.PARAM_READABLE) and \
(prop.flags & gobject.PARAM_WRITABLE):
res.append(prop)
return res
def _child_set(self, value):
try:
parent = self.object.get_parent()
parent.child_set_property(self.object,
self.name,
value)
except TypeError, e:
raise TypeError("Failed to set property %s:%s to %s: `%s'" % (
gobject.type_name(self.owner_type), self.name, value, e))
def _write_widget(self, widget, indent=0, props=None, extra=None):
extra = extra or []
line_props = []
name = self._items.get(hash(widget), '')
if name:
line_props.append(name)
line_props.extend(self._get_packing_properties(widget))
spaces = (' ' * (indent * 2))
if not props:
props = []
if not widget.get_visible():
props.append('hidden')
if not widget.get_sensitive():
props.append('insensitive')
if (widget.get_sensitive() and widget.get_visible()
and not widget.get_can_focus()
and self._is_interactive_widget(widget)):
props.append('unfocusable')
fmt = "%s %s is not focusable"
self.failures.append(fmt % (gobject.type_name(widget),
self._items.get(hash(widget), '???')))
if IValidatableProxyWidget.providedBy(widget):
if (not widget.is_valid() and widget.get_sensitive()
and widget.get_visible()):
if widget.mandatory:
props.append('mandatory')
else:
props.append('invalid')
if props:
prop_lines = ' ' + ', '.join(props)
else:
prop_lines = ''
self.output += "%s%s(%s):%s\n" % (spaces, gobject.type_name(widget),
', '.join(line_props), prop_lines)
spaces = (' ' * ((indent + 1) * 2))
for line in extra:
self.output += spaces + line + '\n'
def _child_get(self):
try:
parent = self.object.get_parent()
return parent.child_get_property(self.object, self.name)
except TypeError, e:
raise TypeError(
"Failed to get child property from %r for %s "
"(%s:%s): `%s'" % (parent, self.object,
gobject.type_name(self.owner_type),
self.name, e))
def _create_prop(self, prop_name, child=False):
# Get the property type
type_name = gobject.type_name(self.widget)
if child:
parent = self.widget.get_parent()
else:
parent = None
prop_type = prop_registry.get_prop_type(type_name, prop_name, parent)
# Instantiate the property from the property type
return prop_type(self)
def __init__(self):
fw.Widget.__init__(self)
model = gtk.ListStore(str, str)
for i in gobject.list_properties(self._widget):
model.append([
i.name,
gobject.type_name(i) + ': ' + gobject.type_name(i.value_type)
])
cell = gtk.CellRendererText()
cell2 = gtk.CellRendererText()
column = gtk.TreeViewColumn('Name')
column2 = gtk.TreeViewColumn('Type')
column.pack_start(cell, True)
column2.pack_start(cell2, True)
column.add_attribute(cell, 'text', 0)
column2.add_attribute(cell2, 'text', 1)
listview = self._widgets['treeView']
listview.set_model(model)
listview.append_column(column)
listview.append_column(column2)
def is_interface(self, full_class_name):
class_name, class_type, class_pak = \
self.describe_full_class_name( full_class_name )
try:
type_name = gobject.type_name( class_type )
type_info = gobject.type_from_name( type_name )
except:
return False
return type_info.is_interface()
def register_adapter(self, adapter):
adict = adapter.__dict__
# Do not register abstract adapters
if adict.has_key('object_type'):
object_type = adict.get('object_type')
if type(object_type) != tuple:
object_type = object_type,
for klass in object_type:
self._add_adapter(gobject.type_name(klass), adapter)
elif adict.has_key('object_name'):
self._add_adapter(adict.get('object_name'), adapter)
def _parse_property_bool(self, pspec, prop):
if prop.kind != TYPE_BOOLEAN:
raise Exception("Invalid boolean property value: %r" % (
prop.value, ))
value = prop.value
if value == 'true':
return True
elif value == 'false':
return False
else:
raise Exception("Unknown value %r for property %r with type %s" % (
value, pspec.name, GObject.type_name(pspec.value_type)))
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 _saveEffectProperties(self, track_object, effect_element):
effect_properties = Element("gst-element-properties")
effect = track_object.getElement()
properties = gobject.list_properties(effect)
for prop in properties:
if prop.flags & gobject.PARAM_READABLE:
type_name = str(gobject.type_name(prop.value_type.fundamental))
#FIXME we just take the int equivalent to the GEnum, how should it be handled?
if type_name == "GEnum":
value = str(effect.get_property(prop.name).__int__())
else:
value = str(effect.get_property(prop.name))
effect_properties.attrib[prop.name] = '(' + type_name + ')' + value
effect_element.append(effect_properties)
def _get_type_from_prop_name(self, type_name, prop_name):
"""Get the type for type_name::prop_name. If we don't have a PropType
for this type_name, check in its parent types"""
assert type(type_name) == str
while True:
full_name = type_name + '::' + prop_name
if full_name in self._types.keys():
return self._types[full_name]
if type_name == 'GObject':
break
type_name = gobject.type_name(gobject.type_parent(type_name))
def make_property_widget(unused_element, prop, value=None):
""" Creates a Widget for the given element property """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if value == None:
value = prop.default_value
if (type_name == 'gchararray'):
widget = gtk.Entry()
widget.set_text(str(value))
elif (type_name in ['guint64', 'gint64', 'guint', 'gint', 'gfloat', 'gulong']):
widget = gtk.SpinButton()
if type_name == 'gint':
widget.set_range(-(2**31), 2**31 - 1)
elif type_name == 'guint':
widget.set_range(0, 2**32 - 1)
elif type_name == 'gint64':
widget.set_range(-(2**63), 2**63 - 1)
elif type_name in ['gulong', 'guint64']:
widget.set_range(0, 2**64 - 1)
elif type_name == 'gfloat':
widget.set_range(0.0, 2**64 - 1)
widget.set_digits(5)
widget.set_value(float(value))
elif (type_name == 'gboolean'):
widget = gtk.CheckButton()
if value:
widget.set_active(True)
elif (type_name == 'GEnum'):
model = gtk.ListStore(gobject.TYPE_STRING, prop.value_type)
widget = gtk.ComboBox(model)
cell = gtk.CellRendererText()
widget.pack_start(cell, True)
widget.add_attribute(cell, 'text', 0)
idx = 0
for key, val in prop.enum_class.__enum_values__.iteritems():
gst.log("adding %s / %s" % (val.value_name, val))
model.append([val.value_name, val])
if val == value:
selected = idx
idx = idx + 1
widget.set_active(selected)
else:
widget = gtk.Label(type_name)
widget.set_alignment(1.0, 0.5)
if not prop.flags & gobject.PARAM_WRITABLE:
widget.set_sensitive(False)
return widget
def get_writable_properties(self, widget, child):
"""
Lists all the writable properties, eg, the ones we'd like
to have saved in a persistent format, eg glade files
@param widget: a gtk.Widget
@param child: True to list child properties, False to omit them
"""
if child:
parent_type = gobject.type_name(widget.get_parent())
property_types = self._child_storage.list(parent_type, self)
else:
type_name = gobject.type_name(widget)
property_types = self._normal_storage.list(type_name, self)
properties = []
# write the properties
for prop_type in property_types:
# don't save the name property since it is saved in the id
# attribute of the tag
if prop_type.name == 'name':
continue
# Do not save non-editable gobject properties, eg
# GtkWindow::screen
# hack?
if (prop_type.base_type == gobject.GObject.__gtype__ and
not prop_type.editable):
continue
if not prop_type.persistent:
continue
properties.append(prop_type)
return properties
def _saveEffectProperties(self, track_object, effect_element):
effect_properties = Element("gst-element-properties")
effect = track_object.getElement()
properties = gobject.list_properties(effect)
for prop in properties:
if prop.flags & gobject.PARAM_READABLE:
type_name = str(gobject.type_name(prop.value_type.fundamental))
#FIXME we just take the int equivalent to the GEnum, how should it be handled?
if type_name == "GEnum":
value = str(effect.get_property(prop.name).__int__())
else:
value = str(effect.get_property(prop.name))
effect_properties.attrib[
prop.name] = '(' + type_name + ')' + value
effect_element.append(effect_properties)
def parse_one(self, toplevel, gobj):
if not isinstance(gobj, gobject.GObject):
raise TypeError
gtype = gobj
while True:
name = gobject.type_name(gtype)
func = getattr(self, name, None)
if func:
if func(toplevel, gobj):
break
if gtype == gobject.GObject.__gtype__:
break
gtype = gobject.type_parent(gtype)
def parse_one(self, toplevel, gobj):
if not isinstance(gobj, gobject.GObject):
raise TypeError
gtype = gobj
while True:
name = gobject.type_name(gtype)
func = getattr(self, name, None)
if func:
if func(toplevel, gobj):
break
if gtype == gobject.GObject.__gtype__:
break
gtype = gobject.type_parent(gtype)
def get_widget_propvalue(prop, widget):
""" returns the value of the given propertywidget """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if (type_name == 'gchararray'):
return widget.get_text()
if (type_name in ['guint64', 'gint64', 'gint', 'gulong']):
return widget.get_value_as_int()
if (type_name in ['gfloat']):
return widget.get_value()
if (type_name in ['gboolean']):
return widget.get_active()
if type_name in ['GEnum']:
return widget.get_model()[widget.get_active()][1]
return None
def _list_custom(self, type_name):
"""
List custom properties for type_name, check the type and
all the parent types
"""
retval = []
while True:
for prop_name in self._custom.get(type_name, []):
full_name = type_name + '::' + prop_name
retval.append(self._types[full_name])
if type_name == 'GObject':
break
type_name = gobject.type_name(gobject.type_parent(type_name))
return retval
def list(self, type_name, parent=None):
"""
List all the properties for type_name
If parent is specified, child properties will also be included.
This method will create the prop_types if they're not already created.
@param type_name: name of type
@type type_name: string
@param parent: parent type of object
@type parent: GType
"""
property_types = self._normal_storage.list(type_name, self)
if parent:
parent_type = gobject.type_name(parent)
property_types.extend(self._child_storage.list(parent_type, self))
return property_types
def get_widget_propvalue(prop, widget):
""" returns the value of the given propertywidget """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if (type_name == 'gchararray'):
return widget.get_text()
if (type_name in ['guint64', 'gint64', 'gint', 'gulong']):
return widget.get_value_as_int()
if (type_name in ['gfloat']):
return widget.get_value()
if (type_name in ['gboolean']):
return widget.get_active()
if type_name in ['GEnum']:
# we don't want to have typed enums wondering around,
# we therefore convert it to it's numerical equivalent
return int(widget.get_model()[widget.get_active()][1])
return None
def register_widgets():
for gobj, editor, data_type in [
(ProxyEntry, EntryDataType, DataType),
(ProxyDateEntry, None, DateOnlyDataType),
(ProxyButton, ButtonDataType, DataType),
(ProxyColorButton, ButtonDataType, DataType),
(ProxyCheckButton, None, BoolOnlyDataType),
(ProxyLabel, LabelDataType, DataType),
(ProxyComboBox, ComboBoxDataType, DataType),
(ProxyComboBoxEntry, ComboBoxEntryDataType, DataType),
(ProxyComboEntry, ComboEntryDataType, DataType),
(ProxySpinButton, SpinBtnDataType, DataType),
(ProxyHScale, HScaleDataType, DataType),
(ProxyVScale, VScaleDataType, DataType),
(ProxyRadioButton, None, BoolOnlyDataType),
(ProxyTextView, TextViewDataType, DataType)
]:
# Property overrides, used in the editor
type_name = gobject.type_name(gobj)
data_name = type_name + '::data-type'
if editor:
prop_registry.override_simple(data_name,
data_type,
custom_editor=editor)
else:
prop_registry.override_simple(data_name, data_type)
prop_registry.override_simple(type_name + '::model-attribute',
ModelProperty)
if issubclass(gobj, ProxyRadioButton):
prop_registry.override_simple(type_name + '::data-value',
DataValueProperty)
# Register custom adapters, since gobject.new is broken in 2.6
# Used by loader, eg in gazpacho and in applications
# ComboBox is registered above
if gobj == ProxyComboBox:
continue
adapter_name = 'Kiwi%sAdapter' % gobj.__name__
klass = type(adapter_name, (PythonWidgetAdapter, ),
dict(object_type=gobj, __name__=adapter_name))
adapter_registry.register_adapter(klass)
def make_property_widget(unused_element, prop, value=None):
""" Creates a Widget for the given element property """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if value == None:
value = prop.default_value
if (type_name == 'gchararray'):
widget = dynamic.TextWidget()
elif (type_name in [
'guint64', 'gint64', 'guint', 'gint', 'gfloat', 'gulong', 'gdouble'
]):
maximum, minimum = None, None
if hasattr(prop, "minimum"):
minimum = prop.minimum
if hasattr(prop, "maximum"):
maximum = prop.maximum
widget = dynamic.NumericWidget(default=prop.default_value,
upper=maximum,
lower=minimum)
elif (type_name == 'gboolean'):
widget = dynamic.ToggleWidget(default=prop.default_value)
elif (type_name == 'GEnum'):
idx = 0
choices = []
for key, val in prop.enum_class.__enum_values__.iteritems():
choices.append([val.value_name, int(val)])
widget = dynamic.ChoiceWidget(choices, default=prop.default_value)
elif type_name == 'GstFraction':
widget = dynamic.FractionWidget(None,
presets=["0:1"],
default=prop.default_value)
else:
widget = dynamic.DefaultWidget(type_name)
if value is not None and type_name != 'GFlags':
widget.setWidgetValue(value)
return widget
def _widget_data(widget):
return widget.get_name(), gobject.type_name(widget), widget
def testGType(self):
entry = KiwiEntry()
self.assertEqual(gobject.type_name(entry), 'KiwiEntry')
entry = ProxyEntry()
self.assertEqual(gobject.type_name(entry), 'ProxyEntry')
def import_patch (filepath, userid):
"""
Load a file into a patch object
filepath -- Path to directory (if multiple files, larger
patch files take precedence for information import)
userid -- ID of the user importing the file
Returns -- patch ID
"""
# Find the patch file
patchFileName = find_patch (filepath)
if not patchFileName:
raise InstDB.ImportError, "Valid patch file not found in files"
file = ipatch.ipatch_file_identify_open (patchFileName, 'r')
# Convert file to IpatchBase derived object
patch = ipatch.ipatch_convert_object_to_type (file, ipatch.Base)
if type (patch) == ipatch.SF2:
patch_type = "sf2"
inst_type = ipatch.SF2Preset
sample_type = ipatch.SF2Sample
proplist = obj_propnames[ipatch.SF2]
extmatch = "sf2"
elif type (patch) == ipatch.DLS2:
patch_type = "dls"
extmatch = "dls[12]?"
inst_type = ipatch.DLS2Inst
sample_type = ipatch.DLS2Sample
proplist = obj_propnames[ipatch.DLS2]
elif type (patch) == ipatch.Gig:
patch_type = "GIG"
extmatch = "gig"
inst_type = ipatch.GigInst
sample_type = ipatch.GigSample
proplist = obj_propnames[ipatch.DLS2]
else:
raise InstDB.ImportError, "Unhandled file type '%s'" \
% gobject.type_name (type (patch))
# Get properties for the patch object
props = get_props (patch, proplist)
# Insert the patch item into the Items table
InstDB.Cur.execute ("INSERT INTO Items (ItemType) VALUES ('Patch')")
patchid = InstDB.DB.insert_id ()
# Get the name and remove from props list
if props.has_key ("Name"):
name = props["Name"]
del props["Name"]
else: name = "<Untitled>"
# Look for author string
author = ""
for authorProp in ("Artist", "Author"):
if props.has_key (authorProp):
if props[authorProp].strip ():
author = props[authorProp].strip ()
del props[authorProp]
# Strip file extension
fname = os.path.basename (patchFileName)
match = re.search ("(?i).*(\.%s)$" % extmatch, fname)
if match and match.start (1) != 0:
fname = fname[:match.start (1)]
# Insert patch info into PatchInfo database
InstDB.Cur.execute ("INSERT INTO PatchInfo"
" (PatchId,UserId,PatchAuthor,FileName,PatchType,"
"PatchName,UserImported,DateImported)"
" VALUES (%s, %s, %s, %s, %s, %s, %s, NULL)",
(patchid, userid, author, fname, patch_type,
name, userid))
# Save all properties
save_props (patchid, props)
# Save info for all instruments
for inst in patch.get_children (inst_type):
props = get_props (inst, obj_propnames[inst_type])
InstDB.Cur.execute ("INSERT INTO Items (ItemType) VALUES ('Inst')")
instid = InstDB.DB.insert_id ()
# Get the name and remove from props list
if props.has_key ("Name"):
name = props["Name"]
del props["Name"]
else: name = ""
InstDB.Cur.execute ("INSERT INTO InstInfo"
" (InstId, PatchId, Bank, Program, InstName)"
" VALUES (%s, %s, %s, %s, %s)",
(instid, patchid, props.get ("Bank", 0),
props.get ("Program", 0), name))
# Remove the already used properties
for key in ("Bank", "Program"):
if props.has_key (key): del props[key]
# Save rest of the instrument properties
save_props (instid, props)
# Save info for all samples
for sample in patch.get_children (sample_type):
rate = sample.get_property ("sample-rate")
samdata = sample.get_property ("sample-data") # Get sample data object
# Get first sample store
store = samdata.get_children (ipatch.SampleStore)
if store: store = store[0]
if not store: continue
channels = store.get_property ("channels")
width = store.get_property ("width")
if width == ipatch.SAMPLE_8BIT: width = "8bit"
elif width == ipatch.SAMPLE_16BIT: width = "16bit"
elif width in (ipatch.SAMPLE_24BIT, ipatch.SAMPLE_REAL24BIT):
width = "24bit"
elif width == ipatch.SAMPLE_32BIT: width = "32bit"
elif width == ipatch.SAMPLE_FLOAT: width = "float"
elif width == ipatch.SAMPLE_DOUBLE: width = "double"
else:
raise RuntimeWarning, "Unhandled sample bit depth enum %d" % width
continue
# Sample size in bytes is frame size * number of frames
size = store.get_frame_size () * samdata.get_property ("sample-size")
props = get_props (sample, obj_propnames[sample_type])
# Get the name and remove from props list
if props.has_key ("Name"):
name = props["Name"]
del props["Name"]
else: name = "<Untitled>"
InstDB.Cur.execute ("INSERT INTO Items (ItemType) VALUES ('Sample')")
sampleid = InstDB.DB.insert_id ()
InstDB.Cur.execute ("INSERT INTO SampleInfo (SampleId,PatchId,Format,"
" SampleSize,Channels,RootNote,SampleRate,SampleName)"
" VALUES (%s, %s, %s, %s, %s, %s, %s, %s)",
(sampleid, patchid, width, size, channels,
props.get ("RootNote", 60), rate, name))
# Remove the already used properties
if props.has_key ("RootNote"): del props["RootNote"]
# Save rest of the sample properties
save_props (sampleid, props)
# Move extract directory to activate/<PatchId>-files
os.rename (filepath, InstDB.ActivatePath + os.sep + str (patchid) + "-files")
# Update PatchInfo State to "Imported"
InstDB.Cur.execute ("UPDATE PatchInfo SET State='Imported'"
" WHERE PatchId=%s", patchid)
return patchid
def make_property_widget(unused_element, prop, value=None):
""" Creates a Widget for the given element property """
# FIXME : implement the case for flags
type_name = gobject.type_name(prop.value_type.fundamental)
if value == None:
value = prop.default_value
if (type_name == 'gchararray'):
widget = gtk.Entry()
widget.set_text(str(value))
elif (type_name in [
'guint64', 'gint64', 'guint', 'gint', 'gfloat', 'gdouble', 'gulong'
]):
widget = gtk.SpinButton()
if type_name == 'gint':
minimum, maximum = (-(2**31), 2**31 - 1)
widget.set_increments(1.0, 10.0)
elif type_name == 'guint':
minimum, maximum = (0, 2**32 - 1)
widget.set_increments(1.0, 10.0)
elif type_name == 'gint64':
minimum, maximum = (-(2**63), 2**63 - 1)
widget.set_increments(1.0, 10.0)
elif type_name in ['gulong', 'guint64']:
minimum, maximum = (0, 2**64 - 1)
widget.set_increments(1.0, 10.0)
elif type_name == 'gfloat' or type_name == 'gdouble':
minimum, maximum = (float("-Infinity"), float("Infinity"))
widget.set_increments(0.00001, 0.01)
widget.set_digits(5)
if hasattr(prop, "minimum"):
minimum = prop.minimum
if hasattr(prop, "maximum"):
maximum = prop.maximum
widget.set_range(minimum, maximum)
widget.props.climb_rate = 0.01 * abs(
min(maximum, 1000) - max(minimum, -1000))
widget.set_value(float(value))
elif (type_name == 'gboolean'):
widget = gtk.CheckButton()
if value:
widget.set_active(True)
elif (type_name == 'GEnum'):
model = gtk.ListStore(gobject.TYPE_STRING, prop.value_type)
widget = gtk.ComboBox(model)
cell = gtk.CellRendererText()
widget.pack_start(cell, True)
widget.add_attribute(cell, 'text', 0)
idx = 0
for key, val in prop.enum_class.__enum_values__.iteritems():
log.log("gstwidget", "adding %s / %s", val.value_name, val)
model.append([val.value_name, val])
if val == value or key == value:
selected = idx
idx = idx + 1
widget.set_active(selected)
else:
widget = gtk.Label(type_name)
widget.set_alignment(1.0, 0.5)
if not prop.flags & gobject.PARAM_WRITABLE:
widget.set_sensitive(False)
return widget
def type_name(self):
return (gobject.type_name(self.item))
