def new_table(spj, element):
# Create field infos
formats = []
info_dict = {}
for eColumn in element.findall("Column"):
# name
try:
name = eColumn.attrib["name"]
except KeyError:
logger.warn("Could not get column name; using default name instead.")
name = utils.unique_names(["col"], info_dict.keys())
# format
try:
format = eColumn.attrib["format"]
except KeyError:
logger.warn("Could not get column type, using default type instead.")
format = "f4"
formats.append(format)
# create info with attributes
info = Table.Info()
for eAttribute in eColumn.findall("Attribute"):
key = eAttribute.attrib["key"]
value = eAttribute.text
if value is not None:
info.set_value(key, value)
info_dict[name] = info
# create table with given format and infos, but w/o any rows
a = numpy.zeros((0,), {"names": info_dict.keys(), "formats": formats})
tbl = Table(a, info_dict)
# node info
for eItem in element.findall("NodeInfo/Item"):
key = eItem.attrib["key"]
value = eItem.text
if value is not None:
tbl.node_info.set_value(key, value)
for eItem in element.findall("NodeInfo/MetaItem"):
key = eItem.attrib["key"]
value = eItem.text
if value is not None:
tbl.node_info.metadata[key] = value
# table key is essential
try:
key = element.attrib["key"]
except KeyError:
logger.warn("Could not get table key. Using generic key instead.")
key = pdict.unique_key(spj.datasets, "dataset")
tbl.key = key
# Right now, the Table is still empty. By setting this callback
# for the _import attribute, the dataset is loaded from the hard
# disk on the next access.
tbl._import = DatasetImporter(spj.get_filename(), tbl.key)
return tbl
def on_btn_add_clicked(self, button):
selection = self.cview.get_selection()
(model, iter) = selection.get_selected()
new_info = Table.Info()
fields = self.cview.get_columns()
new_key = utils.unique_names(['new_column'], fields)[0]
iter = model.insert_after(iter, (new_key, new_info, None))
selection.select_iter(iter)
self.cview.grab_focus()
def insert_(self, col, table, undolist=[]):
col = self.get_index(col)
# We merge in the description of the new array into the
# existing array 'self._array'. Unfortunately we must
# make sure that each new added field has a unique name.
new_names = self.names[:]
descriptor = self._array.dtype.descr[:]
infos = {}
i = 0
for name in table.names:
typecode = table.get_column_type(name)
new_name = utils.unique_names([name], new_names)[0]
new_names.insert(i+col, new_name)
descriptor.insert(i+col, (new_name, typecode))
if table._infos.has_key(name):
infos[new_name] = table._infos[name].copy()
i+=1
new_array = numpy.zeros( (self.nrows,), dtype=numpy.dtype(descriptor))
# fill new array with data
# copy data from existing dataset
for name in self.names:
new_array[name] = self._array[name]
# ..and then copy data from table object.
# Because the names might have changed, we refer
# to the columns by their index!
i = 0
for name in table.names:
new_array[new_names[col+i]] = table._array[name]
i += 1
# undo information
ul = UndoList()
self.update_infos(infos, undolist=ul)
ul.append(UndoInfo(self.remove_n_columns, col, table.ncols))
undolist.append(ul)
self._array = new_array
self.sig_emit('update-fields')
def do_edit(self, template, key=None, allow_edit=True):
"""
Edit the given template. Returns the new key of the template.
The method assures that the entered key is valid, i.e. its
length is > 0 and it is different from existing keys.
If no key is given, then a new unique key is created as
suggestion.
"""
importer = template.new_instance()
# keys = list of existing keys, needed to check for duplicates
keys = []
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter is not None:
keys.append(model.get_value(iter, self.MODEL_KEY))
iter = model.iter_next(iter)
# if no key was given, then the key is new and should
# be constructed unique.
if key is None:
key = utils.unique_names(['template'], keys)[0]
#
# create gui elements
#
dlg = gtk.Dialog("Edit Template Options",None,
gtk.DIALOG_MODAL,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
key_label = gtk.Label("Template name ")
key_entry = gtk.Entry()
key_entry.set_text(unicode(key))
key_entry.set_activates_default(True)
key_box = gtk.HBox()
key_box.pack_start(key_label,False,True)
key_box.pack_start(key_entry,True,True)
hint = gtk.Label()
factorylist = []
factory1 = widget_factory.CWidgetFactory(template)
factory1.add_keys('blurb','extensions','skip_options')
factorylist.append(factory1)
factory2 = widget_factory.CWidgetFactory(importer)
factory2.add_keys(importer.public_props)
factorylist.append(factory2)
table1 = factory1.create_table()
table2 = factory2.create_table()
dlg.vbox.pack_start(key_box, True, True)
dlg.vbox.pack_start(hint,False,True)
dlg.vbox.pack_start(gtk.HSeparator(), False, True)
dlg.vbox.pack_start(table1, True, True)
dlg.vbox.pack_start(gtk.HSeparator(), False, True)
dlg.vbox.pack_start(table2, True, True)
for factory in factorylist:
factory.check_in()
# gray out gui items if object is immutable
if allow_edit is False:
hint.set_markup(DS['template_immutable'])
for factory in factorylist:
for c in factory.clist:
c.widget.set_sensitive(False)
key_entry.set_sensitive(False)
dlg.show_all()
try:
while True:
response = dlg.run()
if response == gtk.RESPONSE_ACCEPT:
# check key
new_key = key_entry.get_text()
try:
new_key = Keyword().check(new_key)
except PropertyError:
hint.set_markup(DS['invalid_key'])
continue
# if key is equal to the suggested key, use it
if key is not None and new_key == key:
pass
elif len(new_key) == 0:
# don't allow empty keys
hint.set_markup(DS['empty_key'])
continue
elif new_key in keys:
# otherwise check if key does not yet exist
hint.set_markup(DS['existing_key'])
continue
# check out
for factory in factorylist:
factory.check_out()
# move importer data to template
values = importer.get_values(importer.public_props, default=None)
template.set_values(defaults=values)
return new_key
raise error.UserCancel
finally:
dlg.destroy()
