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