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_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 _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 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))