def insert_row(self, path, data=None, undolist=[]): ul = UndoList().describe("Insert row") if data is None: self.table.insert_n_rows(path[0], 1) else: self.table.insert_rows(path[0], data) ul.append( UndoInfo(self.delete_rows, [path]) ) self.row_inserted(path, self.get_iter(path)) undolist.append(UndoInfo(self.delete_rows, [path]))
def delete_rows(self, pathlist, undolist=[]): ul = UndoList().describe("Delete rows") deleted = 0 for path in pathlist: real_row = path[0]-deleted real_path = (real_row,) old_data = self.table.delete_n_rows(real_row, 1) ul.append( UndoInfo(self.insert_row, real_path, data=old_data) ) self.row_deleted(real_path) deleted += 1 undolist.append(ul)
def apply_changes(self): ul = UndoList().describe("Edit Plot Properties") for tab in self.tabs: ui = UndoList() tab.check_out(undolist=ui) ul.append(ui.simplify()) ul = ul.simplify(preserve_list=True) if len(ul) > 0: uwrap.emit_last(self.plot, "plot-changed", undolist=ul) else: ul = NullUndo() self.app.project.journal.add_undo(ul)
def set_region(self, row, col, array, coerce=True, undolist=[]): undo_data = self.get_region(row, col, len(array), len(array.dtype.fields[-1])) ul = UndoList() ul.append(UndoInfo(self.set_region, row, col, undo_data)) try: names = array.dtype.fields[-1] i = 0 for name in self.names[col:col+len(array)]: if coerce is True: z = self.get_column_type(col+i)(array[names[i]]) else: z = array[names[i]] self._array[name][row:row+len(array)] = z i += 1 except Exception, msg: print "set_region failed: %s. undoing." % msg ul.execute()
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 zoom_to_region(self, layer, region, undolist=[]): old_region = (layer.xaxis.start, layer.yaxis.start, layer.xaxis.end, layer.yaxis.end) x0 = min( region[0], region[2] ) x1 = max( region[0], region[2] ) y0 = min( region[1], region[3] ) y1 = max( region[1], region[3] ) # Do not zoom if x0 == x1 or if y0 == y1, because # otherwise matplotlib will mess up. Of course, if x0 and # x1 are None (or y0 and y1), i.e. if autoscale is turned on, # then it is ok to zoom. if ((x0 is not None) and (x0 == x1)) or \ ((y0 is not None) and (y0 == y1)): undolist.append(NullUndo()) return def set_axis(axis, start, end): if axis.start is not None and axis.end is not None: swap_axes = axis.start > axis.end else: swap_axes = False if swap_axes is True: _start, _end = end, start else: _start, _end = start, end print "-------" axis.set(start=_start, end=_end) print "-------" self.backend.block_redraw() set_axis(layer.xaxis, x0, x1) set_axis(layer.yaxis, y0, y1) self.backend.unblock_redraw() ul = UndoList("Zoom Region") ul.append(UndoInfo(self.zoom_to_region, layer, old_region)) undolist.append(ul)
def zoom_to_region(self, layer, region, undolist=[]): ul = UndoList() x0 = min( region[0], region[2] ) x1 = max( region[0], region[2] ) y0 = min( region[1], region[3] ) y1 = max( region[1], region[3] ) # Do not zoom if x0 == x1 or if y0 == y1, because # otherwise matplotlib will mess up. Of course, if x0 and # x1 are None (or y0 and y1), i.e. if autoscale is turned on, # then it is ok to zoom. if ((x0 is not None) and (x0 == x1)) or \ ((y0 is not None) and (y0 == y1)): ul.append( NullUndo() ) return def set_axis(key, start, end): axis = layer.request_axis(key, undolist=ul) if axis.start is not None and axis.end is not None: swap_axes = axis.start > axis.end else: swap_axes = False if swap_axes is True: _start, _end = end, start else: _start, _end = start, end uwrap.set(axis, start=_start, end=_end, undolist=ul) set_axis('x', x0, x1) set_axis('y', y0, y1) uwrap.emit_last( self.plot, "plot-changed", undolist=ul ) undolist.append(ul)
def apply_changes(self): """ Apply all changes in all tabs. The method calls 'check_in' of every tab in the dialog's notebook. The created undolists are unified into a single undolist, which is appended to the project's journal. """ ul = UndoList().describe("Edit Plot Properties") for tab in self.tabdict.itervalues(): ui = UndoList() tab.check_out(undolist=ui) ul.append(ui.simplify()) ul = ul.simplify(preserve_list=True) if len(ul) > 0: uwrap.emit_last(self.plot, "changed", undolist=ul) else: ul = NullUndo() globals.app.project.journal.add_undo(ul)