def show_advanced_config(self): # Get the pipeline info for the cell vistraildata = VistrailManager(self._cell._controller) pipeline = vistraildata.get_pipeline(self._cell.cellInfo) self._cell._set_overlay(pipeline.recipe.plot.configWidget) self._cell._overlay.setup(self._cell, pipeline.recipe.plot)
def _color_version_nodes(node, action, tag, description): pipelineInfo = None if action is not None and VistrailManager.initialized: vistraildata = VistrailManager() # Warning: the first scene might get created before the # VistrailManager gets the 'controller_changed' signal, thus # VistrailManager() might be None if vistraildata is not None: pipelineInfo = vistraildata.get_pipeline(action.id) if tag == 'dat-vars': # Variable root brush = QtGui.QBrush(QtGui.QColor(0, 0, 0)) return dict( VERSION_USER_BRUSH=brush, VERSION_OTHER_BRUSH=brush, VERSION_LABEL_COLOR=QtGui.QColor(255, 255, 255), VERSION_SHAPE='rectangle') elif tag is not None and tag.startswith('dat-var-'): # Variables return dict( VERSION_USER_BRUSH=QtGui.QBrush(QtGui.QColor(27, 27, 75)), VERSION_OTHER_BRUSH=QtGui.QBrush(QtGui.QColor(72, 50, 25)), VERSION_LABEL_COLOR=QtGui.QColor(255, 255, 255), VERSION_SHAPE='rectangle') elif pipelineInfo is not None: return dict( VERSION_USER_BRUSH=QtGui.QBrush(QtGui.QColor(171, 169, 214)), VERSION_OTHER_BRUSH=QtGui.QBrush(QtGui.QColor(219, 198, 179))) else: return dict()
def openFile(self): builderWindow = get_vistrails_application().builderWindow with VistrailManager.defer_controller_change(): view = builderWindow.open_vistrail_default() if view is not None: VistrailManager.set_controller( view.get_controller(), register=True)
def resetClicked(self): mngr = VistrailManager(self.cell._controller) pipeline = mngr.get_pipeline(self.cell.cellInfo) if pipeline.version != self.cell._controller.current_version: self.cell._controller.change_selected_version(pipeline.version) currentTabIndex = self.tabWidget.currentIndex() self.setup(self.cell, self.plot) self.tabWidget.setCurrentIndex(currentTabIndex)
def applyClicked(self): self.okClicked() # Bring this overlay back up self.cell._set_overlay(DefaultPlotConfigOverlay) mngr = VistrailManager(self.cell._controller) pipeline = mngr.get_pipeline(self.cell.cellInfo) self.cell._overlay.setup(self.cell, pipeline.recipe.plot)
def populate(self, provenance, row=0): if row == 0: self.root = provenance try: node = self.nodes[provenance] except KeyError: pass else: if node.row <= row: node.row = row + 1 return node.item item = None links = set() if isinstance(provenance, data_provenance.Operation): item = OperationProvenanceItem(provenance['name'], provenance) for arg in provenance['args'].itervalues(): self.populate(arg, row + 1) links.add(arg) elif isinstance(provenance, data_provenance.Variable): varname = self._controller.vistrail.get_tag(provenance['version']) vistraildata = VistrailManager(self._controller) prev = vistraildata.variable_provenance(provenance['version']) if prev is None: # We are missing data! Someone tampered with the vistrail? if varname is not None and varname[:8] == 'dat-var': varname = varname[:8] else: varname = translate(ProvenanceSceneLayout)( '(deleted)') warnings.warn( "A variable (version %r) referenced from provenance " "is missing!" % provenance['version']) item = VariableProvenanceItem(varname, provenance) elif varname is not None and varname[:8] == 'dat-var-': self.populate(prev, row + 1) varname = varname[8:] item = VariableProvenanceItem(varname, provenance) links.add(prev) else: # If that variable has been deleted, we just skip it, like an # intermediate result self.populate(prev, row) elif isinstance(provenance, data_provenance.Loader): item = LoaderProvenanceItem(provenance['name'], provenance) elif isinstance(provenance, data_provenance.Constant): item = ConstantProvenanceItem(provenance['constant'], provenance) else: raise TypeError("populate() got %r" % (provenance,)) if item is not None: self.nodes[provenance] = self.TmpNode(item, row, links)
def _controller_changed_deferred(self, controller, new): vistraildata = VistrailManager(controller) if vistraildata is None: # Non-DAT controller here: create a sheet for it, so that we don't # interfere with DAT sh_window = spreadsheetController.findSpreadsheetWindow( create=False) if sh_window is not None: tab_controller = sh_window.tabController if self._vt_sheet is None: self._vt_sheet = StandardWidgetSheetTab( tab_controller, 2, 3) tab_controller.addTabWidget( self._vt_sheet, "VisTrails Sheet") VistrailManager.set_sheet_immortal(self._vt_sheet, True) tab_controller.setCurrentWidget(self._vt_sheet) return # Get the spreadsheets for this project spreadsheet_tabs = vistraildata.spreadsheet_tabs if new: # Execute the pipelines for cellInfo, pipeline in vistraildata.all_cells: tab = cellInfo.tab error = vistrails_interface.try_execute( controller, pipeline) if error is not None: from dat.gui.cellcontainer import DATCellContainer tab.setCellWidget( cellInfo.row, cellInfo.column, DATCellContainer( cellInfo=CellInformation( tab, cellInfo.row, cellInfo.column), error=error)) # Make one of these tabs current sh_window = spreadsheetController.findSpreadsheetWindow( create=False) if sh_window is not None: tab = sh_window.tabController.currentWidget() if tab not in spreadsheet_tabs.values(): tab_controller = sh_window.tabController tab = next(spreadsheet_tabs.itervalues()) tabidx = tab_controller.indexOf(tab) tab_controller.setCurrentIndex(tabidx)
def okClicked(self): mngr = VistrailManager(self.cell._controller) pipeline = mngr.get_pipeline(self.cell.cellInfo) if pipeline.version != self.cell._controller.current_version: new_pipeline = PipelineInformation( self.cell._controller.current_version, pipeline.recipe, pipeline.conn_map, pipeline.port_map) mngr.created_pipeline(self.cell.cellInfo, new_pipeline) self.cell.update_pipeline(True) else: self.cell._set_overlay(None)
def _get_custom_version_panels(controller, version): _ = translate("recipe_version_panel") if not VistrailManager.initialized: return [] vistraildata = VistrailManager(controller) if vistraildata is None: return [] pipelineInfo = vistraildata.get_pipeline(version) if pipelineInfo is None: return [] monospace = QtGui.QFont('Monospace') monospace.setStyleHint(QtGui.QFont.TypeWriter) recipe = pipelineInfo.recipe recipe_widget = QtGui.QGroupBox(_("DAT recipe")) recipe_widget.setSizePolicy( recipe_widget.sizePolicy().horizontalPolicy(), QtGui.QSizePolicy.Fixed) layout = QtGui.QVBoxLayout() line = QtGui.QHBoxLayout() line.addWidget(QtGui.QLabel(_("Plot:"))) plot_label = QtGui.QLabel("%s" % recipe.plot.name) plot_label.setFont(monospace) line.addWidget(plot_label) layout.addLayout(line) layout.addWidget(QtGui.QLabel(_("Variables:"))) variable_list = QtGui.QTextEdit() color = variable_list.textColor() variable_list.setEnabled(False) variable_list.setTextColor(color) variable_list.setFont(monospace) variable_list.setLineWrapMode(QtGui.QTextEdit.NoWrap) variable_list.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) text = [] for p_values in recipe.parameters.itervalues(): for value in p_values: if value.type == RecipeParameterValue.VARIABLE: text.append(value.variable.name) text = '\n'.join(text) variable_list.setPlainText(text) variable_list.setFixedHeight( variable_list.document().size().height()) layout.addWidget(variable_list) recipe_widget.setLayout(layout) return [(-1, recipe_widget)]
def setup(self, cell, plot): self.cell = cell self.plot = plot # Get pipeline of the cell mngr = VistrailManager(cell._controller) pipelineInfo = mngr.get_pipeline(cell.cellInfo) # Clear old tabs self.tabWidget.clear() # Get all of the plot modules in the pipeline plot_modules = get_plot_modules( pipelineInfo, cell._controller.current_pipeline) registry = get_module_registry() getter = registry.get_configuration_widget for module in plot_modules: widgetType = None widget = None # Try to get custom config widget for the module try: widgetType = \ getter(module.package, module.name, module.namespace) except ModuleRegistryException: pass if widgetType: # Use custom widget widget = widgetType(module, cell._controller) self.connect(widget, QtCore.SIGNAL("doneConfigure"), self.configureDone) self.connect(widget, QtCore.SIGNAL("stateChanged"), self.stateChanged) else: # Use PortsList widget, only if module has ports widget = DATPortsList(self) widget.update_module(module) if len(widget.port_spec_items) > 0: widget.set_controller(cell._controller) else: widget = None # Add widget in new tab if widget: self.tabWidget.addTab(widget, module.name)
def test_variable(self): controller = self.vt_controller() loader = Test_generation._loaders.get('MyVariableLoader') self.assertIsNotNone(loader) varname = 'mytest' variable = loader.load() self.assertIsNotNone(variable) VistrailManager(controller).new_variable(varname, variable) tag = controller.vistrail.get_tag_str('dat-var-%s' % varname) controller.change_selected_version(tag.action_id) pipeline = controller.current_pipeline self.assertEqual(len(pipeline.module_list), 4) # Float(17.63), Float(24.37), PythonCalc('+'), OutputPort output_port = vistrails_interface.find_modules_by_type( pipeline, [OutputPort]) self.assertEqual(len(output_port), 1) output_port, = output_port self.assertEqual(vistrails_interface.get_function(output_port, 'name'), 'value') self.assertEqual(vistrails_interface.get_function(output_port, 'spec'), 'org.vistrails.vistrails.basic:Float')
def __init__(self, cellcontainer, **kwargs): Overlay.__init__(self, cellcontainer, **kwargs) self.setStyleSheet(stylesheet) # Type-checking, so we can show which parameters are suitable to # receive the drop mimeData = kwargs.get('mimeData') if not mimeData or not mimeData.hasFormat(MIMETYPE_DAT_VARIABLE): self._compatible_ports = None else: varname = str(mimeData.data(MIMETYPE_DAT_VARIABLE)) variable = (VistrailManager( self._cell._controller).get_variable(varname)) self._compatible_ports = [] for port in self._cell._plot.ports: if issubclass(variable.type.module, port.type.module): self._compatible_ports.append(COMPATIBLE) else: if get_typecast_operations(variable.type, port.type): self._compatible_ports.append(TYPECASTABLE) else: self._compatible_ports.append(INCOMPATIBLE) self._cell._parameter_hovered = None self.setupUi(kwargs.get('overlayed', True))
def __new__(cls, *args, **kwargs): # Special case: if we are not on a DAT sheet, use VisTrails's container # class if VistrailManager() is None: return QCellContainer(*args, **kwargs) else: return super(DATCellContainer, cls).__new__(cls, *args, **kwargs)
def perform_operation(expression, controller=None): """Perform a variable operation from the given string. """ # First, parse the expressions target, expr_tree = parse_expression(expression) # Find the actual operations & variables controller, root_version, output_module_id = ( Variable._get_variables_root(controller)) vistraildata = VistrailManager(controller) if vistraildata.get_variable(target) is not None: raise InvalidOperation("Target variable %r already exists" % target) op_tree = resolve_symbols(vistraildata, expr_tree) # Build the new variable variable = op_tree.execute(controller) vistraildata.new_variable(target, variable)
def perform_operation(expression, controller=None): """Perform a variable operation from the given string. """ # First, parse the expressions target, expr_tree = parse_expression(expression) # Find the actual operations & variables controller, root_version, output_module_id = ( Variable._get_variables_root(controller)) vistraildata = VistrailManager(controller) if vistraildata.get_variable(target) is not None: raise InvalidOperation("Target variable %r already exists" % target) op_tree = resolve_symbols(vistraildata, expr_tree) # Build the new variable variable = op_tree.execute(controller) vistraildata.new_variable(target, variable)
def dragEnterEvent(self, event): mimeData = event.mimeData() if (mimeData.hasFormat(MIMETYPE_DAT_VARIABLE) and self._input_line.has_markers() and VistrailManager().get_variable( str(mimeData.data(MIMETYPE_DAT_VARIABLE))) is not None): event.accept() else: event.ignore()
def _controller_changed_deferred(self, controller, new): vistraildata = VistrailManager(controller) if vistraildata is None: # Non-DAT controller here: create a sheet for it, so that we don't # interfere with DAT sh_window = spreadsheetController.findSpreadsheetWindow( create=False) if sh_window is not None: tab_controller = sh_window.tabController if self._vt_sheet is None: self._vt_sheet = StandardWidgetSheetTab( tab_controller, 2, 3) tab_controller.addTabWidget(self._vt_sheet, "VisTrails Sheet") VistrailManager.set_sheet_immortal(self._vt_sheet, True) tab_controller.setCurrentWidget(self._vt_sheet) return # Get the spreadsheets for this project spreadsheet_tabs = vistraildata.spreadsheet_tabs if new: # Execute the pipelines for cellInfo, pipeline in vistraildata.all_cells: tab = cellInfo.tab error = vistrails_interface.try_execute(controller, pipeline) if error is not None: from dat.gui.cellcontainer import DATCellContainer tab.setCellWidget( cellInfo.row, cellInfo.column, DATCellContainer(cellInfo=CellInformation( tab, cellInfo.row, cellInfo.column), error=error)) # Make one of these tabs current sh_window = spreadsheetController.findSpreadsheetWindow(create=False) if sh_window is not None: tab = sh_window.tabController.currentWidget() if tab not in spreadsheet_tabs.values(): tab_controller = sh_window.tabController tab = next(spreadsheet_tabs.itervalues()) tabidx = tab_controller.indexOf(tab) tab_controller.setCurrentIndex(tabidx)
def dropEvent(self, event): mimeData = event.mimeData() if mimeData.hasFormat(MIMETYPE_DAT_VARIABLE): if self._plot is not None and self._parameter_hovered is not None: event.accept() port_name = self._plot.ports[self._parameter_hovered].name varname = str(mimeData.data(MIMETYPE_DAT_VARIABLE)) # Here we keep the old values around, and we revert if # update_pipeline() returns False old_values = self._parameters.get(port_name) if old_values is not None: old_values = list(old_values) # Try to update values = self._parameters.setdefault(port_name, []) if values and values[0].type == RecipeParameterValue.CONSTANT: # The overlay shouldn't allow this warnings.warn("a variable was dropped on a port where a " "constant is set") event.ignore() return variable = (VistrailManager( self._controller).get_variable(varname)) param = RecipeParameterValue(variable=variable) if self._insert_pos < len(values): values[self._insert_pos] = param else: values.append(param) if not self.update_pipeline(): # This is wrong somehow (ex: typecasting failed) # Revert to previous values if old_values is None: del self._parameters[port_name] else: self._parameters[port_name] = old_values else: event.ignore() elif mimeData.hasFormat(MIMETYPE_DAT_PLOT): event.accept() plotname = str(mimeData.data(MIMETYPE_DAT_PLOT)) plotname = plotname.split(',') if len(plotname) == 2: self._plot = GlobalManager.get_plot(*plotname) self._parameters = dict() self._parameter_hovered = None self.update_pipeline() else: event.ignore() self._set_overlay(None)
def dropEvent(self, event): mimeData = event.mimeData() if (mimeData.hasFormat(MIMETYPE_DAT_VARIABLE) and self._input_line.has_markers()): varname = str(mimeData.data(MIMETYPE_DAT_VARIABLE)) variable = VistrailManager().get_variable(varname) if variable is not None: self._input_line.replace_first_marker(varname) event.accept() self._input_line.setFocus(QtCore.Qt.MouseFocusReason) self._input_line.focus_first_marker() return event.ignore()
def test_pipeline_creation(self): import dat.tests.pkg_test_plots.init as pkg_test_plots controller = self.vt_controller() vistraildata = VistrailManager(controller) loader = Test_generation._loaders.get('StrMaker') loader.v = 'Hello' vistraildata.new_variable('var1', loader.load()) loader.v = 'world' vistraildata.new_variable('var2', loader.load()) cellInfo = FakeObj( row=0, column=0, tab=FakeObj(tabWidget=FakeObj(tabText=lambda w: 'Sheet 1'))) recipe = DATRecipe( pkg_test_plots.concat_plot, { 'param1': (RecipeParameterValue( variable=vistraildata.get_variable('var1')), ), 'param2': (RecipeParameterValue( variable=vistraildata.get_variable('var2')), ), 'param3': (RecipeParameterValue(constant="!"), ), }) pipelineInfo = vistrails_interface.create_pipeline( controller, recipe, cellInfo.row, cellInfo.column, None) # This plot has no cell module so this is fine controller.change_selected_version(pipelineInfo.version) result = CallRecorder() pkg_test_plots.Recorder.callback = result interpreter = get_default_interpreter() interpreter.execute(controller.current_pipeline, view=DummyView(), locator=controller.locator, current_version=pipelineInfo.version) call = (['Hello, world!'], dict()) self.assertEqual(result.calls, [call])
def dragEnterEvent(self, event): mimeData = event.mimeData() if mimeData.hasFormat(MIMETYPE_DAT_VARIABLE): if VistrailManager(self._controller).get_variable( str(mimeData.data(MIMETYPE_DAT_VARIABLE))) is None: # I can't think of another case for this than someone dragging # a variable from another instance of DAT event.ignore() return # If this doesn't fail, we would still use the variable with # the same name from this instance, not import the variable # from the other instance if self._plot is None: # We should ignore the drop here. That would make sense, and # display the correct mouse pointer # We can't though, because Qt would stop sending drag and drop # events # We still refuse the QDropEvent when the drop happens self._set_overlay(VariableDropEmptyCell, mimeData=mimeData) else: self._set_overlay(VariableDroppingOverlay, mimeData=mimeData) elif mimeData.hasFormat(MIMETYPE_DAT_PLOT): try: plot = str(mimeData.data(MIMETYPE_DAT_PLOT)) plot = plot.split(',') if len(plot) != 2: raise KeyError plot = GlobalManager.get_plot(*plot) except KeyError: # I can't think of another case for this than someone dragging # a plot from another instance of DAT event.ignore() return # If the plot is available, this operation should work as # expected else: self._set_overlay(PlotDroppingOverlay, mimeData=mimeData) else: event.ignore() return event.accept()
def apply_operation(controller, op, args): """Apply an operation to build a new variable. Either load the subworkflow or wrap the parameter variables correctly and call the callback function. """ if op.callback is not None: # FIXME : controller is ignored here... assert controller == VistrailManager().controller result = vistrails_interface.call_operation_callback( op, op.callback, args) if result is None: raise InvalidOperation("Package error: operation callback " "returned None") else: # op.subworkflow is not None: result = vistrails_interface.apply_operation_subworkflow( controller, op, op.subworkflow, args) if result.provenance is None: result.provenance = data_provenance.Operation(operation=op, arg_list=args) return result
def _sheet_changed(self, tab): vistraildata = VistrailManager.from_spreadsheet_tab(tab) if vistraildata is not None: self.builderWindow.ensureController(vistraildata.controller)
def __init__(self, parent, variables=VAR_HIDE): """Setups the widget. If variables is not VAR_HIDE, a list of the variables will be displayed on the right. You can override variable_filter to choose which variables are to be displayed. If VAR_SELECT is used, variable_selected(variable) will be called when the selection changes. """ _ = translate(OperationWizard) QtGui.QDialog.__init__(self, parent, QtCore.Qt.Dialog) self._vistraildata = VistrailManager() self._selected_varname = None self._has_error = False var_right_layout = QtGui.QHBoxLayout() vlayout = QtGui.QVBoxLayout() self._validator = VariableNameValidator(VistrailManager()) varname_layout = QtGui.QHBoxLayout() varname_layout.addWidget(QtGui.QLabel(_("Variable name:"))) self._varname_edit = AdvancedLineEdit( DEFAULT_VARIABLE_NAME, default=DEFAULT_VARIABLE_NAME, validate=self._validator, flags=(AdvancedLineEdit.COLOR_VALIDITY | AdvancedLineEdit.COLOR_DEFAULTVALUE | AdvancedLineEdit.FOLLOW_DEFAULT_UPDATE)) varname_layout.addWidget(self._varname_edit) vlayout.addStretch() vlayout.addLayout(varname_layout) # Create this wizard's specific layout app_layout = self.create_ui() assert app_layout is not None vlayout.insertLayout(0, app_layout) var_right_layout.addLayout(vlayout) # Optionally, put a list of variables on the right if variables != self.VAR_HIDE: self._variable_list = DraggableListWidget( mimetype=MIMETYPE_DAT_VARIABLE) self._variable_list.setSizePolicy( QtGui.QSizePolicy.Minimum, self._variable_list.sizePolicy().horizontalPolicy()) for varname in self._vistraildata.variables: if not self.variable_filter( self._vistraildata.get_variable(varname)): continue pos = bisect( self._variable_list.count(), lambda i: str(self._variable_list.item(i).text()), varname) self._variable_list.insertItem(pos, varname) var_right_layout.addWidget(self._variable_list) if variables == self.VAR_SELECT: self._variable_list.setDragEnabled(False) self._variable_list.setSelectionMode( QtGui.QAbstractItemView.SingleSelection) self.connect( self._variable_list, QtCore.SIGNAL('itemSelectionChanged()'), self._selection_changed) main_layout = QtGui.QVBoxLayout() main_layout.addLayout(var_right_layout) self._error_label = QtGui.QLabel() font = self._error_label.font() font.setBold(True) self._error_label.setFont(font) self._error_label.setStyleSheet('color: red;') main_layout.addWidget(self._error_label) buttons = QtGui.QDialogButtonBox( QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal) self.connect(buttons, QtCore.SIGNAL('accepted()'), self._accept) self.connect(buttons, QtCore.SIGNAL('rejected()'), self, QtCore.SLOT('reject()')) main_layout.addWidget(buttons) self.setLayout(main_layout)
class OperationWizard(QtGui.QDialog): """Base class of the operation wizards. This class offers the basic behavior and functionalities needed by an operation wizard. It can be subclassed in VisTrails packages to add wizards to operations. A wizard is a dialog that is opened by clicking on the relevant icon to the right of an operation name. It then shows a graphical UI intended to do a variable operation graphically. When the user accepts, the wizard returns the new variable or operation string to DAT. """ VAR_HIDE = 0 VAR_SELECT = 1 VAR_DRAG = 2 def __init__(self, parent, variables=VAR_HIDE): """Setups the widget. If variables is not VAR_HIDE, a list of the variables will be displayed on the right. You can override variable_filter to choose which variables are to be displayed. If VAR_SELECT is used, variable_selected(variable) will be called when the selection changes. """ _ = translate(OperationWizard) QtGui.QDialog.__init__(self, parent, QtCore.Qt.Dialog) self._vistraildata = VistrailManager() self._selected_varname = None self._has_error = False var_right_layout = QtGui.QHBoxLayout() vlayout = QtGui.QVBoxLayout() self._validator = VariableNameValidator(VistrailManager()) varname_layout = QtGui.QHBoxLayout() varname_layout.addWidget(QtGui.QLabel(_("Variable name:"))) self._varname_edit = AdvancedLineEdit( DEFAULT_VARIABLE_NAME, default=DEFAULT_VARIABLE_NAME, validate=self._validator, flags=(AdvancedLineEdit.COLOR_VALIDITY | AdvancedLineEdit.COLOR_DEFAULTVALUE | AdvancedLineEdit.FOLLOW_DEFAULT_UPDATE)) varname_layout.addWidget(self._varname_edit) vlayout.addStretch() vlayout.addLayout(varname_layout) # Create this wizard's specific layout app_layout = self.create_ui() assert app_layout is not None vlayout.insertLayout(0, app_layout) var_right_layout.addLayout(vlayout) # Optionally, put a list of variables on the right if variables != self.VAR_HIDE: self._variable_list = DraggableListWidget( mimetype=MIMETYPE_DAT_VARIABLE) self._variable_list.setSizePolicy( QtGui.QSizePolicy.Minimum, self._variable_list.sizePolicy().horizontalPolicy()) for varname in self._vistraildata.variables: if not self.variable_filter( self._vistraildata.get_variable(varname)): continue pos = bisect( self._variable_list.count(), lambda i: str(self._variable_list.item(i).text()), varname) self._variable_list.insertItem(pos, varname) var_right_layout.addWidget(self._variable_list) if variables == self.VAR_SELECT: self._variable_list.setDragEnabled(False) self._variable_list.setSelectionMode( QtGui.QAbstractItemView.SingleSelection) self.connect( self._variable_list, QtCore.SIGNAL('itemSelectionChanged()'), self._selection_changed) main_layout = QtGui.QVBoxLayout() main_layout.addLayout(var_right_layout) self._error_label = QtGui.QLabel() font = self._error_label.font() font.setBold(True) self._error_label.setFont(font) self._error_label.setStyleSheet('color: red;') main_layout.addWidget(self._error_label) buttons = QtGui.QDialogButtonBox( QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal) self.connect(buttons, QtCore.SIGNAL('accepted()'), self._accept) self.connect(buttons, QtCore.SIGNAL('rejected()'), self, QtCore.SLOT('reject()')) main_layout.addWidget(buttons) self.setLayout(main_layout) def _selection_changed(self): items = self._variable_list.selectedItems() if len(items) == 1: item = items[0] sel = str(item.text()) if sel != self._selected_varname: self._selected_varname = sel self.variable_selected(self._vistraildata.get_variable(sel)) def _accept(self): if self._has_error: return if not self._varname_edit.isValid(): self._varname_edit.setFocus(QtCore.Qt.OtherFocusReason) return varname = str(self._varname_edit.text()) result = self.make_operation(varname) if isinstance(result, Variable): # Operation was performed by make_operation() self._vistraildata.new_variable(varname, result) self.command = None self.accept() elif result is False: # Don't dismiss the dialog pass elif isinstance(result, basestring): # make_operation() gave us an expression to execute if '=' in result: self.command = result else: self.command = '%s = %s' % (varname, result) self.accept() elif (isinstance(result, tuple) and len(result) == 2 and isinstance(result[0], basestring) and isinstance(result[1], dict)): subworkflow, args = result # TODO : Use args from dictionary + 'variable' # self.get_variable_argument() to make the result raise NotImplementedError("Building the operation result from a " "subworkflow is not yet implemented") else: raise TypeError("make_operation returned an unexpected type") def get_variable_argument(self): variable_info = self._vistraildata.get_variable(self._selected_varname) variable = Variable.from_workflow(variable_info, record_materialized=False) return ArgumentWrapper(variable) def set_error(self, err): if err is None: self._error_label.hide() self._has_error = False else: if isinstance(err, BaseException): err = "%s: %s" % (err.__class__.__name__, err.message) self._error_label.setText(err) self._error_label.show() self._has_error = True def variable_filter(self, variable): return True def variable_selected(self, varname): pass def make_operation(self, target_var_name): raise NotImplementedError
def _sheet_changed(self, tab): vistraildata = VistrailManager.from_spreadsheet_tab(tab) if vistraildata is not None: self.builderWindow.ensureController(vistraildata.controller)
def __init__(self, controller, parent=None): QtGui.QDialog.__init__(self, parent, QtCore.Qt.Dialog) self._vistraildata = VistrailManager(controller) self._validator = VariableNameValidator(self._vistraildata) _ = translate(LoadVariableDialog) self.setWindowTitle(_("Load variable")) self._tabs = [] main_layout = QtGui.QVBoxLayout() self._tab_widget = QtGui.QTabWidget() self.connect(self._tab_widget, QtCore.SIGNAL('currentChanged(int)'), self.update_varname) main_layout.addWidget(self._tab_widget) varname_layout = QtGui.QHBoxLayout() varname_layout.addWidget(QtGui.QLabel(_("Variable name:"))) self._varname_edit = AdvancedLineEdit( DEFAULT_VARIABLE_NAME, default=DEFAULT_VARIABLE_NAME, validate=self._validator, flags=(AdvancedLineEdit.COLOR_VALIDITY | AdvancedLineEdit.COLOR_DEFAULTVALUE | AdvancedLineEdit.FOLLOW_DEFAULT_UPDATE)) varname_layout.addWidget(self._varname_edit) main_layout.addLayout(varname_layout) buttons_layout = QtGui.QHBoxLayout() load_cont_button = QtGui.QPushButton(_("Load and close")) self.connect(load_cont_button, QtCore.SIGNAL('clicked()'), self.loadclose_clicked) buttons_layout.addWidget(load_cont_button) load_button = QtGui.QPushButton(_("Load")) self.connect(load_button, QtCore.SIGNAL('clicked()'), self.load_clicked) buttons_layout.addWidget(load_button) cancel_button = QtGui.QPushButton(_("Cancel")) self.connect(cancel_button, QtCore.SIGNAL('clicked()'), self.cancel) buttons_layout.addWidget(cancel_button) main_layout.addLayout(buttons_layout) self.setLayout(main_layout) self._file_loader = FileLoaderPanel() self._file_loader.default_variable_name_observer = ( self.default_variable_name_changed) self._add_tab(self._file_loader, _("File")) app = get_vistrails_application() app.register_notification('dat_new_loader', self.loader_added) app.register_notification('dat_removed_loader', self.loader_removed) for loader in GlobalManager.variable_loaders: self.loader_added(loader) idx = self._tab_widget.currentIndex() if idx >= 0: loader = self._tabs[idx] self._varname_edit.setDefault(loader.get_default_variable_name()) else: self._varname_edit.setDefault(DEFAULT_VARIABLE_NAME) self._varname_edit.reset()
def __init__(self, args, optionsDict={}): QtGui.QApplication.__init__(self, args) NotificationDispatcher.__init__(self) # There are lots of issues with how the notifications are used # Although create_notification() exists, it doesn't seem to be used in # every case before register_notification() is called warnings.simplefilter('ignore', NotificationDispatcher.UsageWarning) VistrailsApplicationInterface.__init__(self) self.builderWindow = None self._vt_sheet = None set_vistrails_application(self) vistrails.gui.theme.initializeCurrentTheme() VistrailsApplicationInterface.init(self, options_dict=optionsDict, args=args) from vistrails.gui.vistrails_window import QVistrailsWindow self.builderWindow = QVistrailsWindow(ui_hooks=vt_hooks.hooks) self.builderWindow.closeEvent = lambda e: None self.startup.set_package_to_enabled('spreadsheet') self.package_manager.initialize_packages() self.builderWindow.link_registry() # Create a first controller view = self.builderWindow.create_first_vistrail() controller = view.get_controller() assert controller is not None # Set our own spreadsheet cell container class from dat.gui.cellcontainer import DATCellContainer spreadsheetController.setCellContainerClass(DATCellContainer) # Discover the plots and variable loaders from packages and register to # notifications for packages loaded/unloaded in the future GlobalManager.init() # Register the VistrailManager with the 'controller_changed' # notification VistrailManager.init() VistrailManager.set_controller( controller, register=True) # Create the main window mw = MainWindow() mw.setVisible(True) # Create the spreadsheet for the first project self._controller_changed(controller, new=True) # Create a spreadsheet and execute the visualizations when a new # controller is selected self.register_notification( 'dat_controller_changed', self._controller_changed) # Change the current controller when another sheet is selected self.register_notification( 'spreadsheet_sheet_changed', self._sheet_changed)
def __init__(self): QtGui.QMainWindow.__init__(self) self.setWindowTitle("DAT") _ = dat.gui.translate(MainWindow) menubar = self.menuBar() fileMenu = menubar.addMenu(_("&File")) newAction = fileMenu.addAction(_("&New...")) newAction.setShortcut('Ctrl+N') self.connect(newAction, QtCore.SIGNAL('triggered()'), self.newFile) openAction = fileMenu.addAction(_("&Open...")) openAction.setShortcut('Ctrl+O') self.connect(openAction, QtCore.SIGNAL('triggered()'), self.openFile) saveAction = fileMenu.addAction(_("&Save")) saveAction.setShortcut('Ctrl+S') self.connect(saveAction, QtCore.SIGNAL('triggered()'), self.saveFile) saveAsAction = fileMenu.addAction(_("Save &as...")) saveAsAction.setShortcut('Ctrl+Shift+S') self.connect(saveAsAction, QtCore.SIGNAL('triggered()'), self.saveAsFile) fileMenu.addSeparator() quitAction = fileMenu.addAction(_("&Quit")) quitAction.setShortcut('Ctrl+Q') self.connect(quitAction, QtCore.SIGNAL('triggered()'), self.quitApplication) viewMenu = menubar.addMenu(_("&View")) showBuilderAction = viewMenu.addAction(_("Show &builder window")) self.connect(showBuilderAction, QtCore.SIGNAL('triggered()'), get_vistrails_application().showBuilderWindow) # Spreadsheet hooks ss_hooks = dict( window_menu_main=False, window_menu_view=False, window_menu_window=False, window_quit_action=False, global_kbd_shortcuts=False, window_create_first_sheet=False, tab_create_sheet=True, tab_create_sheet_action=VistrailManager.hook_create_tab, tab_open_sheet=False, tab_save_sheet=False, tab_rename_sheet=True, tab_begin_rename_action=VistrailManager.hook_rename_tab_begin, tab_end_rename_action=VistrailManager.hook_rename_tab_end, tab_close_sheet=True, tab_close_sheet_action=VistrailManager.hook_close_tab, tab_delete_cell=False, ) # Embed the spreadsheet window as the central widget spreadsheetController.set_hooks(ss_hooks) self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow( show=False) self.setCentralWidget(self.spreadsheetWindow) self.spreadsheetWindow.setVisible(True) # Create the panels # DockWidgetClosable is not permitted self._variables = VariablePanel(VistrailManager()) self._plots = PlotPanel() self._operations = OperationPanel() self._data_provenance = DataProvenancePanel() self.connect(self._variables, QtCore.SIGNAL('variableSelected(PyQt_PyObject)'), self._data_provenance.showVariable) def dock_panel(title, widget, pos): dock = QtGui.QDockWidget(title) dock.setFeatures(QtGui.QDockWidget.DockWidgetMovable | QtGui.QDockWidget.DockWidgetFloatable) dock.setWidget(widget) self.addDockWidget(pos, dock) return dock dock_panel(_("Plots"), self._plots, QtCore.Qt.RightDockWidgetArea) self._variables_dock = dock_panel(_("Variables"), self._variables, QtCore.Qt.LeftDockWidgetArea) dock_panel(_("Calculator"), self._operations, QtCore.Qt.LeftDockWidgetArea) prov_dock = dock_panel(_("Data Provenance"), self._data_provenance, QtCore.Qt.LeftDockWidgetArea) self.tabifyDockWidget(self._variables_dock, prov_dock) self._variables_dock.raise_() get_vistrails_application().register_notification( 'dat_controller_changed', self._controller_changed)
def vt_controller(): app = get_vistrails_application() view = app.builderWindow.new_vistrail() controller = view.get_controller() VistrailManager.set_controller(controller, register=True) return controller