def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QMainWindow.__init__(self, parent, f)
BaseView.__init__(self)
self.set_title("Mashup")
self.controller = None
self.mshpController = None
self.createActions()
#Setting up a toolbar
self.createToolBar()
self.tab_to_stack_idx = {}
self.button_to_tab_idx = Bidict()
widget = QtGui.QWidget(self)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.tabBar = QtGui.QTabBar(self)
self.tabBar.setDocumentMode(True)
self.tabBar.setTabsClosable(False)
self.tabBar.setExpanding(False)
self.tabBar.currentChanged.connect(self.switchTab)
self.stack = QtGui.QStackedWidget(self)
layout.addWidget(self.tabBar)
layout.addWidget(self.stack)
widget.setLayout(layout)
self.setCentralWidget(widget)
self.createAliasPanelTab()
widget.setVisible(True)
#self.createPipelineTab()
self.setWindowTitle("Mashup Builder")
self.vtversion = -1
self.manager = MashupsManager.getInstance()
def add_to_persistent_pipeline(self, pipeline):
"""add_to_persistent_pipeline(pipeline):
(module_id_map, connection_id_map, modules_added)
Adds a pipeline to the persistent pipeline of the cached interpreter
and adds current logging object to each existing module.
Returns four things: two dictionaries describing the mapping
of ids from the passed pipeline to the persistent one (the
first one has the module id mapping, the second one has the
connection id mapping), a set of all module ids added to the
persistent pipeline, and a set of all connection ids added to
the persistent pipeline."""
module_id_map = Bidict()
connection_id_map = Bidict()
modules_added = set()
connections_added = set()
pipeline.refresh_signatures()
# we must traverse vertices in topological sort order
verts = pipeline.graph.vertices_topological_sort()
for new_module_id in verts:
new_sig = pipeline.subpipeline_signature(new_module_id)
if not self._persistent_pipeline.has_subpipeline_signature(new_sig):
# Must add module to persistent pipeline
persistent_module = copy.copy(pipeline.modules[new_module_id])
persistent_id = self._persistent_pipeline.fresh_module_id()
persistent_module.id = persistent_id
self._persistent_pipeline.add_module(persistent_module)
self._persistent_pipeline.modules[persistent_id]._signature = \
base64.b16encode(new_sig).lower()
module_id_map[new_module_id] = persistent_id
modules_added.add(new_module_id)
else:
i = self._persistent_pipeline \
.subpipeline_id_from_signature(new_sig)
module_id_map[new_module_id] = i
for connection in pipeline.connections.itervalues():
new_sig = pipeline.connection_signature(connection.id)
if not self._persistent_pipeline.has_connection_signature(new_sig):
# Must add connection to persistent pipeline
persistent_connection = copy.copy(connection)
persistent_id = self._persistent_pipeline.fresh_connection_id()
persistent_connection.id = persistent_id
persistent_connection.sourceId = module_id_map[
connection.sourceId]
persistent_connection.destinationId = module_id_map[
connection.destinationId]
self._persistent_pipeline.add_connection(persistent_connection)
connection_id_map[connection.id] = persistent_id
connections_added.add(connection.id)
else:
i = self._persistent_pipeline \
.connection_id_from_signature(new_sig)
connection_id_map[connection.id] = i
# update persistent signatures
self._persistent_pipeline.compute_signatures()
return (module_id_map, connection_id_map,
modules_added, connections_added)
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QMainWindow.__init__(self, parent, f)
BaseView.__init__(self)
self.set_title("Mashup")
self.controller = None
self.mshpController = None
self.createActions()
#Setting up a toolbar
self.createToolBar()
self.tab_to_stack_idx = {}
self.button_to_tab_idx = Bidict()
widget = QtGui.QWidget(self)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.tabBar = QtGui.QTabBar(self)
self.tabBar.setDocumentMode(True)
self.tabBar.setTabsClosable(False)
self.tabBar.setExpanding(False)
self.tabBar.currentChanged.connect(self.switchTab)
self.stack = QtGui.QStackedWidget(self)
layout.addWidget(self.tabBar)
layout.addWidget(self.stack)
widget.setLayout(layout)
self.setCentralWidget(widget)
self.createAliasPanelTab()
widget.setVisible(True)
#self.createPipelineTab()
self.setWindowTitle("Mashup Builder")
self.vtversion = -1
self.manager = MashupsManager.getInstance()
def clear(self):
"""clear(self) -> None. Removes all references, prepares for
deletion."""
for connector_list in self.inputPorts.itervalues():
for connector in connector_list:
connector.clear()
self.inputPorts = {}
self.outputPorts = {}
self.logging = _dummy_logging
self.is_method = Bidict()
self._latest_method_order = 0
def __init__(self, controller, panel, parent=None):
""" QAliasList(parent: QWidget) -> QAliasTable
"""
QtGui.QTreeWidget.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.setRootIsDecorated(False)
self.panel = panel
self.aliases = Bidict()
self.alias_widgets = {}
self.current_item = None
self.controller = controller
self.header().setStretchLastSection(True)
self.setHeaderLabels(
QtCore.QStringList() << "Position" << "Name" << "Type")
self.itemSelectionChanged.connect(self.setPreviousSelected)
self.connect(
self,
QtCore.SIGNAL(
"currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)"),
self.currentAliasChanged)
self.previousSelected = -1
def build_widget(self):
layout = QtGui.QVBoxLayout()
layout.setMargin(4)
layout.setSpacing(2)
self.searchBox = QSearchBox(True, False, self)
layout.addWidget(self.searchBox)
radio_layout = QtGui.QHBoxLayout()
radio_layout.setSpacing(5)
radio_layout.setAlignment(QtCore.Qt.AlignLeft)
radio_layout.addWidget(QtGui.QLabel("Search:"))
searchAll = QtGui.QRadioButton("Open Vistrails")
searchCurrent = QtGui.QRadioButton("Current Vistrail")
searchWorkflow = QtGui.QRadioButton("Current Workflow")
self.level_group = QtGui.QButtonGroup()
self.level_group.addButton(searchAll)
self.level_group.addButton(searchCurrent)
self.level_group.addButton(searchWorkflow)
self.level_map = \
Bidict([(QueryController.LEVEL_ALL, searchAll),
(QueryController.LEVEL_VISTRAIL, searchCurrent),
(QueryController.LEVEL_WORKFLOW, searchWorkflow)])
radio_layout.addWidget(searchAll)
radio_layout.addWidget(searchCurrent)
radio_layout.addWidget(searchWorkflow)
searchCurrent.setChecked(True)
self.editButton = QtGui.QPushButton("Edit")
self.editButton.setEnabled(False)
self.backButton = QtGui.QPushButton("Back to Search")
self.backButton.setEnabled(False)
radio_layout.addStretch(1)
radio_layout.addWidget(self.editButton, 0, QtCore.Qt.AlignRight)
radio_layout.addWidget(self.backButton, 0, QtCore.Qt.AlignRight)
layout.addLayout(radio_layout)
self.setLayout(layout)
self.connect(self.searchBox, QtCore.SIGNAL('resetSearch()'),
self.resetSearch)
self.connect(self.searchBox, QtCore.SIGNAL('executeSearch(QString)'),
self.executeSearch)
self.connect(self.searchBox, QtCore.SIGNAL('refineMode(bool)'),
self.refineMode)
self.connect(self.backButton, QtCore.SIGNAL('clicked()'),
self.backToSearch)
self.connect(self.editButton, QtCore.SIGNAL('clicked()'),
self.doEdit)
self.connect(self.level_group,
QtCore.SIGNAL('buttonClicked(QAbstractButton*)'),
self.levelChanged)
def __init__(self):
self.inputPorts = {}
self.outputPorts = {}
self.upToDate = False
self.setResult("self", self) # every object can return itself
self.logging = _dummy_logging
# isMethod stores whether a certain input port is a method.
# If so, isMethod maps the port to the order in which it is
# stored. This is so that modules that need to know about the
# method order can work correctly
self.is_method = Bidict()
self._latest_method_order = 0
# Pipeline info that a module should know about This is useful
# for a spreadsheet cell to know where it is from. It will be
# also used for talking back and forth between the spreadsheet
# and the builder besides Parameter Exploration.
self.moduleInfo = {
'locator': None,
'vistrailName': 'Unknown',
'version': -1,
'pipeline': None,
'moduleId': -1,
'reason': 'Pipeline Execution',
'actions': []
}
self.is_breakpoint = False
# is_fold_operator stores wether the module is a part of a fold
self.is_fold_operator = False
# is_fold_module stores whether the module is a fold module
self.is_fold_module = False
# computed stores wether the module was computed
# used for the logging stuff
self.computed = False
self.suspended = False
self.signature = None
def __init__(self, controller, panel, parent=None):
""" QAliasList(parent: QWidget) -> QAliasTable
"""
QtGui.QTreeWidget.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.setRootIsDecorated(False)
self.panel = panel
self.aliases = Bidict()
self.alias_widgets = {}
self.current_item = None
self.controller = controller
self.header().setStretchLastSection(True)
self.setHeaderLabels(QtCore.QStringList() << "Position" << "Name" << "Type")
self.itemSelectionChanged.connect(self.setPreviousSelected)
self.connect(self,
QtCore.SIGNAL("currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)"),
self.currentAliasChanged)
self.previousSelected = -1
class QMashupView(QtGui.QMainWindow, BaseView):
#signals
#mashupChanged = pyqtSignal()
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QMainWindow.__init__(self, parent, f)
BaseView.__init__(self)
self.set_title("Mashup")
self.controller = None
self.mshpController = None
self.createActions()
#Setting up a toolbar
self.createToolBar()
self.tab_to_stack_idx = {}
self.button_to_tab_idx = Bidict()
widget = QtGui.QWidget(self)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.tabBar = QtGui.QTabBar(self)
self.tabBar.setDocumentMode(True)
self.tabBar.setTabsClosable(False)
self.tabBar.setExpanding(False)
self.tabBar.currentChanged.connect(self.switchTab)
self.stack = QtGui.QStackedWidget(self)
layout.addWidget(self.tabBar)
layout.addWidget(self.stack)
widget.setLayout(layout)
self.setCentralWidget(widget)
self.createAliasPanelTab()
widget.setVisible(True)
#self.createPipelineTab()
self.setWindowTitle("Mashup Builder")
self.vtversion = -1
self.manager = MashupsManager.getInstance()
def set_default_layout(self):
from gui.mashups.mashups_inspector import QMashupsInspector
from gui.mashups.alias_parameter_view import QAliasParameterView
self.set_palette_layout({
QtCore.Qt.LeftDockWidgetArea:
QMashupsInspector,
QtCore.Qt.RightDockWidgetArea:
QAliasParameterView,
})
def set_action_links(self):
self.action_links = \
{
}
def set_action_defaults(self):
self.action_defaults['execute'] = [('setEnabled', False, False)]
def set_controller(self, controller):
"""set_controller(controller:VistrailController) -> None
This will set vistrail controller"""
if controller == self.controller:
return
# if self.controller is not None:
# self.disconnect(self.controller,
# QtCore.SIGNAL('versionWasChanged'),
# self.versionChanged)
self.controller = controller
# if self.controller:
# self.connect(self.controller,
# QtCore.SIGNAL('versionWasChanged'),
# self.versionChanged)
#print " *** mashup view set vtController: ", controller
def versionChanged(self, version):
window = self.window()
self.vtversion = version
if self.vtversion > -1:
window.qactions['mashup'].setEnabled(True)
else:
window.qactions['mashup'].setEnabled(False)
#print " *** mashup view versionChanged ", self.vtversion
def controllerChanged(self, controller):
from gui.vistrails_window import _app
self.set_controller(controller)
self.versionChanged(self.controller.current_version)
if _app.get_current_tab() == self:
self.updateView()
def updateView(self):
from gui.vistrails_window import _app
if self.vtversion > 0:
if self.mshpController is not None:
self.mshpController.versionChanged.disconnect(
self.mshpVersionChanged)
self.mshpController.stateChanged.disconnect(
self.mshpStateChanged)
if self.mshpController.vtController is not None:
self.disconnect(self.mshpController.vtController,
QtCore.SIGNAL('vistrailChanged()'),
self.mshpControllerVistrailChanged)
self.controller.flush_delayed_actions()
self.vtversion = self.controller.current_version
self.mshpController = self.manager.createMashupController(
self.controller, self.vtversion)
#self.pipelineTab.set_controller(self.mshpController.vtController)
#self.pipelineTab.set_to_current()
self.mshpController.vtController.change_selected_version(
self.vtversion)
self.connect(self.mshpController.vtController,
QtCore.SIGNAL('vistrailChanged()'),
self.mshpControllerVistrailChanged)
self.mshpController.versionChanged.connect(self.mshpVersionChanged)
self.mshpController.stateChanged.connect(self.mshpStateChanged)
self.aliasPanel.updateController(self.mshpController)
self.clearPreviewTabs()
_app.notify('mshpcontroller_changed', self.mshpController)
def createActions(self):
self.saveAction = QtGui.QAction("Tag",
self,
triggered=self.saveTriggered)
self.saveAction.setToolTip("Tag current mashup")
self.saveAction.setEnabled(False)
self.previewAction = QtGui.QAction("Preview",
self,
triggered=self.previewTriggered,
checkable=False)
self.previewAction.setToolTip("Preview current mashup")
def createToolBar(self):
self.toolbar = QtGui.QToolBar(self)
self.toolbar.addAction(self.previewAction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.saveAction)
self.addToolBar(self.toolbar)
def createAliasPanelTab(self):
self.aliasPanel = QAliasListPanel(parent=self)
idx = self.stack.addWidget(self.aliasPanel)
self.aliasPanel.set_index(idx)
tab_idx = self.tabBar.addTab("Aliases")
self.aliasPanel.set_tab_idx(tab_idx)
self.tab_to_stack_idx[tab_idx] = idx
def createPreviewTab(self, version):
previewTab = QMashupViewTab(self.mshpController, version)
# self.refreshButton = QtGui.QPushButton("Refresh", self)
# self.refreshButton.setFlat(True)
# self.refreshButton.setEnabled(False)
# self.refreshButton.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
# QtGui.QSizePolicy.Fixed))
previewApp = self.manager.createMashupApp(
self.controller, self.mshpController.mshptrail, version)
previewApp.appWasClosed.connect(self.previewTabWasClosed)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(5)
#layout.addWidget(self.refreshButton, QtCore.Qt.AlignLeft)
layout.addWidget(previewApp)
previewTab.setLayout(layout)
idx = self.stack.addWidget(previewTab)
previewTab.set_index(idx)
tab_idx = self.tabBar.addTab(
"Preview: %s" % self.mshpController.getMashupName(version))
previewTab.set_tab_idx(tab_idx)
self.tab_to_stack_idx[tab_idx] = idx
closeButton = QMashupViewCloseButton(self.tabBar)
closeSide = self.tabBar.style().styleHint(
QtGui.QStyle.SH_TabBar_CloseButtonPosition, None, self.tabBar)
closeButton.clicked.connect(self.closePreviewTab)
self.tabBar.setTabButton(tab_idx, closeSide, closeButton)
self.button_to_tab_idx[closeButton] = tab_idx
self.tabBar.setCurrentIndex(tab_idx)
@pyqtSlot()
def closePreviewTab(self):
closeButton = self.sender()
tab_idx = self.button_to_tab_idx[closeButton]
self.tabBar.removeTab(tab_idx)
stack_idx = self.tab_to_stack_idx[tab_idx]
if stack_idx >= 0:
self.stack.removeWidget(self.stack.widget(stack_idx))
del self.button_to_tab_idx[closeButton]
self.updateIndexes(tab_idx, stack_idx)
def previewTabWasClosed(self, previewApp):
previewTab = previewApp.parent()
tab_idx = previewTab.get_tab_idx()
stack_idx = self.tab_to_stack_idx[tab_idx]
if previewTab == self.stack.widget(stack_idx):
#this means the quit button was pressed
closeButton = self.button_to_tab_idx.inverse[tab_idx]
self.tabBar.removeTab(tab_idx)
self.stack.removeWidget(self.stack.widget(stack_idx))
del self.button_to_tab_idx[closeButton]
self.updateIndexes(tab_idx, stack_idx)
def updateIndexes(self, rm_tab_idx, rm_stack_idx):
for (b, tab_idx) in self.button_to_tab_idx.iteritems():
if tab_idx > rm_tab_idx:
self.button_to_tab_idx[b] -= 1
for idx in range(self.stack.count()):
if idx >= rm_stack_idx:
view = self.stack.widget(idx)
view.set_index(idx)
view.set_tab_idx(view.tab_idx - 1)
def clearPreviewTabs(self):
tab_idx = self.tabBar.count() - 1
while self.tabBar.count() > 1:
idx = self.tab_to_stack_idx[tab_idx]
if type(self.stack.widget(idx)) == QMashupViewTab:
self.tabBar.removeTab(tab_idx)
if idx >= 0:
self.stack.removeWidget(self.stack.widget(idx))
tab_idx -= 1
@pyqtSlot(int)
def switchTab(self, index):
try:
self.stack.setCurrentIndex(self.tab_to_stack_idx[index])
except KeyError:
pass
def previewTriggered(self):
self.createPreviewTab(self.mshpController.currentVersion)
def saveTriggered(self):
(pid, pname) = self.mshpController.findFirstTaggedParent(
self.mshpController.currentVersion)
if pid >= 1:
res = show_question(
"VisTrails::Mashups",
"""You've decided to keep a modified version of '%s'.
Would you like to update it (this will move the tag to the current version)?
Click on No to create a new tag.""" % pname,
[CANCEL_BUTTON, YES_BUTTON, NO_BUTTON], 0)
if res == YES_BUTTON:
#move tag
self.mshpController.moveTag(pid,
self.mshpController.currentVersion,
pname)
elif res == NO_BUTTON:
# show createNewtag dialog
tag_exists = True
ok = True
while ok and tag_exists:
(text,
ok) = QtGui.QInputDialog.getText(self,
"VisTrails::Mashups",
"Enter a new tag:",
text="")
if ok and not text.isEmpty():
tag = str(text)
if self.mshpController.updateCurrentTag(tag):
tag_exists = False
def mshpControllerVistrailChanged(self):
#print "*** vistrailChanged mashup view ", self.mshpController.vtController.current_version
pipeline = self.mshpController.vtController.current_pipeline
self.mshpController.updateAliasesFromPipeline(pipeline)
def mshpVersionChanged(self, versionId):
from gui.vistrails_window import _app
#print "*** mshpVersionChanged ", versionId
self.aliasPanel.updateVersion(versionId)
if not self.mshpController.versionHasTag(versionId):
self.saveAction.setEnabled(True)
else:
self.saveAction.setEnabled(False)
_app.notify('mshpversion_changed', versionId)
def mshpStateChanged(self):
for idx in range(self.stack.count()):
view = self.stack.widget(idx)
if type(view) == QMashupViewTab:
tab_idx = view.tab_idx
self.tabBar.setTabText(
tab_idx, "Preview: %s" %
self.mshpController.getMashupName(view.version))
def aliasChanged(self, param):
#print "mashupView aliasChanged", param
self.mshpController.updateAliasFromParam(param)
class QAliasList(QtGui.QTreeWidget):
"""
QAliasList just inherits from QListView to have a customized
list and items
"""
#signals
aliasUpdated = pyqtSignal(Alias)
aliasRemoved = pyqtSignal(str)
highlightModule = pyqtSignal(int)
def __init__(self, controller, panel, parent=None):
""" QAliasList(parent: QWidget) -> QAliasTable
"""
QtGui.QTreeWidget.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.setRootIsDecorated(False)
self.panel = panel
self.aliases = Bidict()
self.alias_widgets = {}
self.current_item = None
self.controller = controller
self.header().setStretchLastSection(True)
self.setHeaderLabels(QtCore.QStringList() << "Position" << "Name" << "Type")
self.itemSelectionChanged.connect(self.setPreviousSelected)
self.connect(self,
QtCore.SIGNAL("currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)"),
self.currentAliasChanged)
self.previousSelected = -1
@pyqtSlot()
def setPreviousSelected(self):
if len(self.selectedItems()) == 1:
item = self.selectedItems()[0]
self.previousSelected = self.indexOfTopLevelItem(item)
else:
self.previousSelected = -1
def processCellChanges(self, row, col):
""" processCellChanges(row: int, col: int) -> None
Event handler for capturing when the contents in a cell changes
"""
item = self.item(row, col)
if col == 0:
old_alias = item.alias.alias
new_alias = str(item.text())
if new_alias in self.aliases.keys():
QtGui.QMessageBox.warning(self,
"VisMashup",
"""Label name %s already exists.
Please type a different name. """ %
new_alias)
item.setText(old_alias)
return
elif new_alias == '':
del self.aliases[old_alias]
wdgt = self.cellWidget(row, 1)
del self.alias_widgets[wdgt]
item.alias.alias = ''
self.removeRow(row)
wdgt.deleteLater()
self.updateRowNumbers()
else:
self.aliases[new_alias] = self.aliases[old_alias]
del self.aliases[old_alias]
item.alias.alias = new_alias
elif col == 1:
wdgt = self.cellWidget(row,col)
if wdgt is not None:
item.alias.value = wdgt.contents()
self.aliasUpdated.emit(item.alias)
def currentAliasChanged(self, current, previous):
if current:
if ((previous is not None and current.alias != previous.alias) or
previous is None):
self.highlightModule.emit(current.alias.component.vtmid)
else:
self.highlightModule.emit(-1)
def _getOtherParameterInfo(self, pipeline, id, ptype):
parameter = pipeline.db_get_object(ptype,id)
return (parameter.type, parameter.strValue, 1, parameter.pos)
def createAliasItem(self, alias):
""" createAliasRow( alias: core.mashup.Alias) -> AliasItem
Creates a row in the list
"""
alias.pos = self.topLevelItemCount()
labels = QtCore.QStringList() << str(alias.component.pos) << str(alias.name) << \
str(alias.component.type)
item = QAliasListItem(self, alias, labels)
item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable )
return alias
def populateFromMashup(self, mashupController):
#print "populateFromMashup ", self , self.previousSelected
if self.controller != mashupController:
self.controller = mashupController
self.itemSelectionChanged.disconnect(self.setPreviousSelected)
self.aliases = {}
self.alias_cache = {}
self.alias_widgets = {}
self.clear()
mashup = self.controller.currentMashup
if len(mashup.alias_list) > 0:
for alias in mashup.alias_list:
alias = self.createAliasItem(copy.copy(alias))
self.aliases[alias.name] = alias
if (self.previousSelected > -1 and
self.previousSelected < self.topLevelItemCount()):
item = self.topLevelItem(self.previousSelected)
self.setItemSelected(item, True)
self.itemSelectionChanged.connect(self.setPreviousSelected)
def updatePosNumbers(self):
new_order = []
for idx in range(self.topLevelItemCount()):
item = self.topLevelItem(idx)
new_order.append(item.alias.component.pos)
item.setText(0,str(idx))
return new_order
def moveItemToNewPos(self, old, new):
"""moveItemToNewPos(old:int, new:int) -> None
Move item from pos old to pos new
"""
self.itemSelectionChanged.disconnect(self.panel.updateInspector)
item = self.takeTopLevelItem(old)
self.insertTopLevelItem(new,item)
self.clearSelection()
new_order = self.updatePosNumbers()
self.setItemSelected(item, True)
self.itemSelectionChanged.connect(self.panel.updateInspector)
self.controller.reorderAliases(new_order)
def keyPressEvent(self, event):
""" keyPressEvent(event: QKeyEvent) -> None
Capture 'Del', 'Backspace' for deleting aliases
"""
if (event.key() in [QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Delete]):
self.removeCurrentAlias()
@pyqtSlot(bool)
def removeCurrentAlias(self, checked=False):
item = self.currentItem()
name = item.alias.name
res = show_question("Mashups",
"Are you sure do you want to remove '%s' from the mashup?"%name,
[YES_BUTTON, NO_BUTTON], NO_BUTTON)
if res == YES_BUTTON:
old_alias = item.alias.name
del self.aliases[old_alias]
pos = self.indexOfTopLevelItem(item)
self.takeTopLevelItem(pos)
self.updatePosNumbers()
if pos < self.topLevelItemCount() -1:
new_item = self.topLevelItem(pos)
else:
new_item = self.topLevelItem(pos-1)
self.setCurrentItem(new_item)
self.aliasRemoved.emit(name)
class QQueryView(QtGui.QWidget, BaseView):
VISUAL_SEARCH_VIEW = 0
GLOBAL_RESULT_VIEW = 1
VERSION_RESULT_VIEW = 2
WORKFLOW_RESULT_VIEW = 3
RESULT_LEVEL_MAP = \
Bidict([(QueryController.LEVEL_ALL, GLOBAL_RESULT_VIEW),
(QueryController.LEVEL_VISTRAIL, VERSION_RESULT_VIEW),
(QueryController.LEVEL_WORKFLOW, WORKFLOW_RESULT_VIEW)])
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
BaseView.__init__(self)
self.build_widget()
self.set_title("Search")
def set_controller(self, controller=None):
if self.controller:
self.disconnect(self.controller,
QtCore.SIGNAL('stateChanged'),
self.update_controller)
self.controller = controller
if controller:
self.connect(self.controller,
QtCore.SIGNAL('stateChanged'),
self.update_controller)
self.vt_controller.vistrail_view = self.version_result_view
self.vt_controller.current_pipeline_view = \
self.workflow_result_view.scene()
# self.vt_controller.vistrail_view.set_controller(self.vt_controller)
self.vt_controller.set_vistrail(controller.vistrail, None,
set_log_on_vt=False)
self.vt_controller.change_selected_version(controller.current_version)
self.version_result_view.set_controller(self.vt_controller)
self.workflow_result_view.set_controller(self.vt_controller)
self.query_controller.set_vistrail_controller(controller)
def update_controller(self):
self.vt_controller.set_vistrail(self.controller.vistrail, None,
set_log_on_vt=False)
self.vt_controller.change_selected_version(
self.controller.current_version)
def build_widget(self):
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.query_controller = QueryController(self)
self.vt_controller = VistrailController(auto_save=False)
self.p_controller = VistrailController(Vistrail(), auto_save=False)
self.connect(self.p_controller,
QtCore.SIGNAL('vistrailChanged()'),
self.vistrailChanged)
self.query_box = QQueryBox()
self.query_box.set_controller(self.query_controller)
layout.addWidget(self.query_box)
self.stacked_widget = QtGui.QStackedWidget()
self.pipeline_view = QQueryPipelineView()
self.p_controller.current_pipeline_view = self.pipeline_view.scene()
self.pipeline_view.set_controller(self.p_controller)
self.pipeline_view.set_query_controller(self.query_controller)
QQueryView.VISUAL_SEARCH_VIEW = \
self.stacked_widget.addWidget(self.pipeline_view)
self.global_result_view = QQueryResultGlobalView()
QQueryView.GLOBAL_RESULT_VIEW = \
self.stacked_widget.addWidget(self.global_result_view)
self.version_result_view = QQueryResultVersionView()
self.connect(self.version_result_view.scene(),
QtCore.SIGNAL('versionSelected(int,bool,bool,bool,bool)'),
self.result_version_selected)
# self.version_result_view.set_controller(self.vt_controller)
QQueryView.VERSION_RESULT_VIEW = \
self.stacked_widget.addWidget(self.version_result_view)
self.workflow_result_view = QQueryResultWorkflowView()
# self.workflow_result_view.set_controller(self.vt_controller)
QQueryView.WORKFLOW_RESULT_VIEW = \
self.stacked_widget.addWidget(self.workflow_result_view)
self.stacked_widget.setCurrentWidget(self.pipeline_view)
layout.addWidget(self.stacked_widget)
self.setLayout(layout)
self.current_display = QQueryView.VISUAL_SEARCH_VIEW
self.current_result_view = QQueryView.VERSION_RESULT_VIEW
def set_default_layout(self):
from gui.module_palette import QModulePalette
from gui.module_info import QModuleInfo
self.set_palette_layout(
{QtCore.Qt.LeftDockWidgetArea: QModulePalette,
QtCore.Qt.RightDockWidgetArea: QModuleInfo,
})
def set_action_links(self):
self.action_links = \
{ 'execute': ('query_pipeline_changed', self.set_execute_action) }
# also add other notification here...
from gui.vistrails_window import _app
_app.register_notification('query_pipeline_changed',
self.set_reset_button)
def set_reset_button(self, pipeline):
self.query_box.setManualResetEnabled(self.pipeline_non_empty(pipeline))
def set_result_level(self, level):
view_idx = QQueryView.RESULT_LEVEL_MAP[level]
if self.current_display != QQueryView.VISUAL_SEARCH_VIEW:
self.set_display_view(view_idx)
self.current_result_view = view_idx
self.query_controller.update_results()
def set_to_search_mode(self):
self.set_display_view(QQueryView.VISUAL_SEARCH_VIEW)
self.query_box.backButton.setEnabled(False)
self.query_box.editButton.setEnabled(False)
self.set_reset_button(self.p_controller.current_pipeline)
from gui.vistrails_window import _app
_app.notify('query_pipeline_changed',
self.p_controller.current_pipeline)
def set_to_result_mode(self):
self.set_display_view(self.current_result_view)
self.query_box.backButton.setEnabled(True)
if self.query_controller.level >= QueryController.LEVEL_VISTRAIL:
self.query_box.editButton.setEnabled(True)
self.query_box.setManualResetEnabled(True)
from gui.vistrails_window import _app
_app.notify('query_pipeline_changed',
self.p_controller.current_pipeline)
def set_display_view(self, view_type):
self.current_display = view_type
self.stacked_widget.setCurrentIndex(view_type)
def get_current_view(self):
return self.stacked_widget.currentWidget()
def set_action_defaults(self):
self.action_defaults = \
{
'execute': [('setEnabled', True, self.set_execute_action),
('setIcon', False, CurrentTheme.VISUAL_QUERY_ICON),
('setToolTip', False, 'Execute a visual query')],
'publishWeb': [('setEnabled', False, False)],
'publishPaper': [('setEnabled', False, False)],
}
def set_execute_action(self, pipeline=None):
if not self.vt_controller:
return False
if pipeline is None:
pipeline = self.p_controller.current_pipeline
if self.current_display == QQueryView.VISUAL_SEARCH_VIEW:
return self.pipeline_non_empty(pipeline)
return False
def pipeline_non_empty(self, pipeline):
return pipeline is not None and len(pipeline.modules) > 0
def vistrailChanged(self):
from gui.vistrails_window import _app
self.p_controller.current_pipeline.ensure_connection_specs()
_app.notify('query_pipeline_changed', self.p_controller.current_pipeline)
def query_changed(self, query=None):
if query is None:
self.query_controller.reset_search()
# FIXME add support for changing the query to something specific
def version_changed(self, version_id):
self.vt_controller.change_selected_version(version_id)
def result_version_selected(self, version_id, by_click, do_validate=True,
from_root=False, double_click=False):
if by_click:
self.query_controller.search.setCurrentVistrail(
self.vt_controller.vistrail)
self.vt_controller.change_selected_version(version_id, by_click,
do_validate, from_root)
if double_click:
self.query_controller.set_level(QueryController.LEVEL_WORKFLOW)
self.query_controller.show_workflow_matches()
def get_vertex_map(g):
return Bidict([(v, k) for (k, v) in enumerate(g.iter_vertices())])
def get_edge_map(g):
itor = enumerate(imap(lambda x: x[2], g.iter_all_edges()))
return Bidict([(v, k) for (k, v) in itor])
class PortSpec(DBPortSpec):
port_type_map = Bidict([('input', 'destination'), ('output', 'source'),
('invalid', 'invalid')])
end_point_map = Bidict([('source', PortEndPoint.Source),
('destination', PortEndPoint.Destination),
('invalid', PortEndPoint.Invalid)])
##########################################################################
# Constructors and copy
def __init__(self, *args, **kwargs):
signature = None
if 'signature' in kwargs:
signature = kwargs['signature']
del kwargs['signature']
if 'optional' not in kwargs:
kwargs['optional'] = 0 # False
elif type(kwargs['optional']) != type(0):
if type(kwargs['optional']) == type(True):
if kwargs['optional']:
kwargs['optional'] = 1
else:
kwargs['optional'] = 0
else:
raise VistrailsInternalError("Cannot parse 'optional' kw "
"-- must be an int or bool")
if 'sort_key' not in kwargs:
kwargs['sort_key'] = -1
if 'id' not in kwargs:
kwargs['id'] = -1
if 'tooltip' in kwargs:
self._tooltip = kwargs['tooltip']
del kwargs['tooltip']
else:
self._tooltip = None
DBPortSpec.__init__(self, *args, **kwargs)
self._entries = None
self._descriptors = None
self._short_sigstring = None
self._labels = None
self._defaults = None
if signature is not None:
self.create_entries(signature)
if not self.sigstring and self._entries is not None:
# create sigstring from entries
self.create_sigstring_and_descriptors()
# DAKOOP: removed this---we will check in module_registry and pipeline
# validation, this way, we can let errors go all the way up
# elif self._entries is None and self.sigstring:
# # create entries from sigstring
# self.create_entries_and_descriptors()
# else:
# raise VistrailsInternalError("Need to specify signature or "
# "sigstring to create PortSpec")
if self._entries is not None and self._tooltip is None:
self.create_tooltip()
self.is_valid = True
def __copy__(self):
return PortSpec.do_copy(self)
def do_copy(self, new_ids=False, id_scope=None, id_remap=None):
cp = DBPortSpec.do_copy(self, new_ids, id_scope, id_remap)
cp._entries = copy.copy(self._entries)
cp._descriptors = copy.copy(self._descriptors)
cp._short_sigstring = self._short_sigstring
cp._labels = self._labels
cp._defaults = self._defaults
cp._tooltip = self._tooltip
cp.is_valid = self.is_valid
cp.__class__ = PortSpec
if cp._entries is not None:
cp.create_tooltip()
return cp
@staticmethod
def convert(_port_spec):
from core.modules.module_registry import module_registry_loaded, \
ModuleRegistryException
if _port_spec.__class__ == PortSpec:
return
_port_spec.__class__ = PortSpec
_port_spec._entries = None
_port_spec._descriptors = None
_port_spec._short_sigstring = None
_port_spec._labels = None
_port_spec._defaults = None
_port_spec._tooltip = None
_port_spec.is_valid = True
# FIXME probably can just let validation take care of this...
if module_registry_loaded():
try:
_port_spec.create_entries_and_descriptors()
_port_spec.create_tooltip()
except ModuleRegistryException, e:
_port_spec._descriptors = None
_port_spec._entries = None
# raise e
else:
class QMashupView(QtGui.QMainWindow, BaseView):
#signals
#mashupChanged = pyqtSignal()
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QMainWindow.__init__(self, parent, f)
BaseView.__init__(self)
self.set_title("Mashup")
self.controller = None
self.mshpController = None
self.createActions()
#Setting up a toolbar
self.createToolBar()
self.tab_to_stack_idx = {}
self.button_to_tab_idx = Bidict()
widget = QtGui.QWidget(self)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.tabBar = QtGui.QTabBar(self)
self.tabBar.setDocumentMode(True)
self.tabBar.setTabsClosable(False)
self.tabBar.setExpanding(False)
self.tabBar.currentChanged.connect(self.switchTab)
self.stack = QtGui.QStackedWidget(self)
layout.addWidget(self.tabBar)
layout.addWidget(self.stack)
widget.setLayout(layout)
self.setCentralWidget(widget)
self.createAliasPanelTab()
widget.setVisible(True)
#self.createPipelineTab()
self.setWindowTitle("Mashup Builder")
self.vtversion = -1
self.manager = MashupsManager.getInstance()
def set_default_layout(self):
from gui.mashups.mashups_inspector import QMashupsInspector
from gui.mashups.alias_parameter_view import QAliasParameterView
self.set_palette_layout(
{QtCore.Qt.LeftDockWidgetArea: QMashupsInspector,
QtCore.Qt.RightDockWidgetArea: QAliasParameterView,
})
def set_action_links(self):
self.action_links = \
{
}
def set_action_defaults(self):
self.action_defaults['execute'] = [('setEnabled', False, False)]
def set_controller(self, controller):
"""set_controller(controller:VistrailController) -> None
This will set vistrail controller"""
if controller == self.controller:
return
# if self.controller is not None:
# self.disconnect(self.controller,
# QtCore.SIGNAL('versionWasChanged'),
# self.versionChanged)
self.controller = controller
# if self.controller:
# self.connect(self.controller,
# QtCore.SIGNAL('versionWasChanged'),
# self.versionChanged)
#print " *** mashup view set vtController: ", controller
def versionChanged(self, version):
window = self.window()
self.vtversion = version
if self.vtversion > -1:
window.qactions['mashup'].setEnabled(True)
else:
window.qactions['mashup'].setEnabled(False)
#print " *** mashup view versionChanged ", self.vtversion
def controllerChanged(self, controller):
from gui.vistrails_window import _app
self.set_controller(controller)
self.versionChanged(self.controller.current_version)
if _app.get_current_tab() == self:
self.updateView()
def updateView(self):
from gui.vistrails_window import _app
if self.vtversion > 0:
if self.mshpController is not None:
self.mshpController.versionChanged.disconnect(self.mshpVersionChanged)
self.mshpController.stateChanged.disconnect(self.mshpStateChanged)
if self.mshpController.vtController is not None:
self.disconnect(self.mshpController.vtController,
QtCore.SIGNAL('vistrailChanged()'),
self.mshpControllerVistrailChanged)
self.controller.flush_delayed_actions()
self.vtversion = self.controller.current_version
self.mshpController = self.manager.createMashupController(self.controller,
self.vtversion)
#self.pipelineTab.set_controller(self.mshpController.vtController)
#self.pipelineTab.set_to_current()
self.mshpController.vtController.change_selected_version(self.vtversion)
self.connect(self.mshpController.vtController,
QtCore.SIGNAL('vistrailChanged()'),
self.mshpControllerVistrailChanged)
self.mshpController.versionChanged.connect(self.mshpVersionChanged)
self.mshpController.stateChanged.connect(self.mshpStateChanged)
self.aliasPanel.updateController(self.mshpController)
self.clearPreviewTabs()
_app.notify('mshpcontroller_changed', self.mshpController)
def createActions(self):
self.saveAction = QtGui.QAction("Tag", self,
triggered=self.saveTriggered)
self.saveAction.setToolTip("Tag current mashup")
self.saveAction.setEnabled(False)
self.previewAction = QtGui.QAction("Preview", self,
triggered=self.previewTriggered,
checkable=False)
self.previewAction.setToolTip("Preview current mashup")
def createToolBar(self):
self.toolbar = QtGui.QToolBar(self)
self.toolbar.addAction(self.previewAction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.saveAction)
self.addToolBar(self.toolbar)
def createAliasPanelTab(self):
self.aliasPanel = QAliasListPanel(parent=self)
idx = self.stack.addWidget(self.aliasPanel)
self.aliasPanel.set_index(idx)
tab_idx = self.tabBar.addTab("Aliases")
self.aliasPanel.set_tab_idx(tab_idx)
self.tab_to_stack_idx[tab_idx] = idx
def createPreviewTab(self, version):
previewTab = QMashupViewTab(self.mshpController, version)
# self.refreshButton = QtGui.QPushButton("Refresh", self)
# self.refreshButton.setFlat(True)
# self.refreshButton.setEnabled(False)
# self.refreshButton.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
# QtGui.QSizePolicy.Fixed))
previewApp = self.manager.createMashupApp(self.controller,
self.mshpController.mshptrail,
version)
previewApp.appWasClosed.connect(self.previewTabWasClosed)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(5)
#layout.addWidget(self.refreshButton, QtCore.Qt.AlignLeft)
layout.addWidget(previewApp)
previewTab.setLayout(layout)
idx = self.stack.addWidget(previewTab)
previewTab.set_index(idx)
tab_idx = self.tabBar.addTab("Preview: %s"%self.mshpController.getMashupName(version))
previewTab.set_tab_idx(tab_idx)
self.tab_to_stack_idx[tab_idx] = idx
closeButton = QMashupViewCloseButton(self.tabBar)
closeSide = self.tabBar.style().styleHint(
QtGui.QStyle.SH_TabBar_CloseButtonPosition,
None, self.tabBar)
closeButton.clicked.connect(self.closePreviewTab)
self.tabBar.setTabButton(tab_idx, closeSide, closeButton)
self.button_to_tab_idx[closeButton] = tab_idx
self.tabBar.setCurrentIndex(tab_idx)
@pyqtSlot()
def closePreviewTab(self):
closeButton = self.sender()
tab_idx = self.button_to_tab_idx[closeButton]
self.tabBar.removeTab(tab_idx)
stack_idx = self.tab_to_stack_idx[tab_idx]
if stack_idx >= 0:
self.stack.removeWidget(self.stack.widget(stack_idx))
del self.button_to_tab_idx[closeButton]
self.updateIndexes(tab_idx, stack_idx)
def previewTabWasClosed(self, previewApp):
previewTab = previewApp.parent()
tab_idx = previewTab.get_tab_idx()
stack_idx = self.tab_to_stack_idx[tab_idx]
if previewTab == self.stack.widget(stack_idx):
#this means the quit button was pressed
closeButton = self.button_to_tab_idx.inverse[tab_idx]
self.tabBar.removeTab(tab_idx)
self.stack.removeWidget(self.stack.widget(stack_idx))
del self.button_to_tab_idx[closeButton]
self.updateIndexes(tab_idx, stack_idx)
def updateIndexes(self, rm_tab_idx, rm_stack_idx):
for (b,tab_idx) in self.button_to_tab_idx.iteritems():
if tab_idx > rm_tab_idx:
self.button_to_tab_idx[b] -= 1
for idx in range(self.stack.count()):
if idx >= rm_stack_idx:
view = self.stack.widget(idx)
view.set_index(idx)
view.set_tab_idx(view.tab_idx-1)
def clearPreviewTabs(self):
tab_idx = self.tabBar.count()-1
while self.tabBar.count() > 1:
idx = self.tab_to_stack_idx[tab_idx]
if type(self.stack.widget(idx)) == QMashupViewTab:
self.tabBar.removeTab(tab_idx)
if idx >= 0:
self.stack.removeWidget(self.stack.widget(idx))
tab_idx -= 1
@pyqtSlot(int)
def switchTab(self, index):
try:
self.stack.setCurrentIndex(self.tab_to_stack_idx[index])
except KeyError:
pass
def previewTriggered(self):
self.createPreviewTab(self.mshpController.currentVersion)
def saveTriggered(self):
(pid, pname) = self.mshpController.findFirstTaggedParent(self.mshpController.currentVersion)
if pid >= 1:
res = show_question("VisTrails::Mashups",
"""You've decided to keep a modified version of '%s'.
Would you like to update it (this will move the tag to the current version)?
Click on No to create a new tag.""" %pname,
[CANCEL_BUTTON, YES_BUTTON, NO_BUTTON], 0)
if res == YES_BUTTON:
#move tag
self.mshpController.moveTag(pid,
self.mshpController.currentVersion,
pname)
elif res == NO_BUTTON:
# show createNewtag dialog
tag_exists = True
ok = True
while ok and tag_exists:
(text, ok) = QtGui.QInputDialog.getText(self, "VisTrails::Mashups",
"Enter a new tag:",
text="")
if ok and not text.isEmpty():
tag = str(text)
if self.mshpController.updateCurrentTag(tag):
tag_exists = False
def mshpControllerVistrailChanged(self):
#print "*** vistrailChanged mashup view ", self.mshpController.vtController.current_version
pipeline = self.mshpController.vtController.current_pipeline
self.mshpController.updateAliasesFromPipeline(pipeline)
def mshpVersionChanged(self, versionId):
from gui.vistrails_window import _app
#print "*** mshpVersionChanged ", versionId
self.aliasPanel.updateVersion(versionId)
if not self.mshpController.versionHasTag(versionId):
self.saveAction.setEnabled(True)
else:
self.saveAction.setEnabled(False)
_app.notify('mshpversion_changed', versionId)
def mshpStateChanged(self):
for idx in range(self.stack.count()):
view = self.stack.widget(idx)
if type(view) == QMashupViewTab:
tab_idx = view.tab_idx
self.tabBar.setTabText(tab_idx,
"Preview: %s"%self.mshpController.getMashupName(view.version))
def aliasChanged(self, param):
#print "mashupView aliasChanged", param
self.mshpController.updateAliasFromParam(param)
class QAliasList(QtGui.QTreeWidget):
"""
QAliasList just inherits from QListView to have a customized
list and items
"""
#signals
aliasUpdated = pyqtSignal(Alias)
aliasRemoved = pyqtSignal(str)
highlightModule = pyqtSignal(int)
def __init__(self, controller, panel, parent=None):
""" QAliasList(parent: QWidget) -> QAliasTable
"""
QtGui.QTreeWidget.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.setRootIsDecorated(False)
self.panel = panel
self.aliases = Bidict()
self.alias_widgets = {}
self.current_item = None
self.controller = controller
self.header().setStretchLastSection(True)
self.setHeaderLabels(
QtCore.QStringList() << "Position" << "Name" << "Type")
self.itemSelectionChanged.connect(self.setPreviousSelected)
self.connect(
self,
QtCore.SIGNAL(
"currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)"),
self.currentAliasChanged)
self.previousSelected = -1
@pyqtSlot()
def setPreviousSelected(self):
if len(self.selectedItems()) == 1:
item = self.selectedItems()[0]
self.previousSelected = self.indexOfTopLevelItem(item)
else:
self.previousSelected = -1
def processCellChanges(self, row, col):
""" processCellChanges(row: int, col: int) -> None
Event handler for capturing when the contents in a cell changes
"""
item = self.item(row, col)
if col == 0:
old_alias = item.alias.alias
new_alias = str(item.text())
if new_alias in self.aliases.keys():
QtGui.QMessageBox.warning(
self, "VisMashup", """Label name %s already exists.
Please type a different name. """ %
new_alias)
item.setText(old_alias)
return
elif new_alias == '':
del self.aliases[old_alias]
wdgt = self.cellWidget(row, 1)
del self.alias_widgets[wdgt]
item.alias.alias = ''
self.removeRow(row)
wdgt.deleteLater()
self.updateRowNumbers()
else:
self.aliases[new_alias] = self.aliases[old_alias]
del self.aliases[old_alias]
item.alias.alias = new_alias
elif col == 1:
wdgt = self.cellWidget(row, col)
if wdgt is not None:
item.alias.value = wdgt.contents()
self.aliasUpdated.emit(item.alias)
def currentAliasChanged(self, current, previous):
if current:
if ((previous is not None and current.alias != previous.alias)
or previous is None):
self.highlightModule.emit(current.alias.component.vtmid)
else:
self.highlightModule.emit(-1)
def _getOtherParameterInfo(self, pipeline, id, ptype):
parameter = pipeline.db_get_object(ptype, id)
return (parameter.type, parameter.strValue, 1, parameter.pos)
def createAliasItem(self, alias):
""" createAliasRow( alias: core.mashup.Alias) -> AliasItem
Creates a row in the list
"""
alias.pos = self.topLevelItemCount()
labels = QtCore.QStringList() << str(alias.component.pos) << str(alias.name) << \
str(alias.component.type)
item = QAliasListItem(self, alias, labels)
item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
return alias
def populateFromMashup(self, mashupController):
#print "populateFromMashup ", self , self.previousSelected
if self.controller != mashupController:
self.controller = mashupController
self.itemSelectionChanged.disconnect(self.setPreviousSelected)
self.aliases = {}
self.alias_cache = {}
self.alias_widgets = {}
self.clear()
mashup = self.controller.currentMashup
if len(mashup.alias_list) > 0:
for alias in mashup.alias_list:
alias = self.createAliasItem(copy.copy(alias))
self.aliases[alias.name] = alias
if (self.previousSelected > -1
and self.previousSelected < self.topLevelItemCount()):
item = self.topLevelItem(self.previousSelected)
self.setItemSelected(item, True)
self.itemSelectionChanged.connect(self.setPreviousSelected)
def updatePosNumbers(self):
new_order = []
for idx in range(self.topLevelItemCount()):
item = self.topLevelItem(idx)
new_order.append(item.alias.component.pos)
item.setText(0, str(idx))
return new_order
def moveItemToNewPos(self, old, new):
"""moveItemToNewPos(old:int, new:int) -> None
Move item from pos old to pos new
"""
self.itemSelectionChanged.disconnect(self.panel.updateInspector)
item = self.takeTopLevelItem(old)
self.insertTopLevelItem(new, item)
self.clearSelection()
new_order = self.updatePosNumbers()
self.setItemSelected(item, True)
self.itemSelectionChanged.connect(self.panel.updateInspector)
self.controller.reorderAliases(new_order)
def keyPressEvent(self, event):
""" keyPressEvent(event: QKeyEvent) -> None
Capture 'Del', 'Backspace' for deleting aliases
"""
if (event.key() in [QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Delete]):
self.removeCurrentAlias()
@pyqtSlot(bool)
def removeCurrentAlias(self, checked=False):
item = self.currentItem()
name = item.alias.name
res = show_question(
"Mashups",
"Are you sure do you want to remove '%s' from the mashup?" % name,
[YES_BUTTON, NO_BUTTON], NO_BUTTON)
if res == YES_BUTTON:
old_alias = item.alias.name
del self.aliases[old_alias]
pos = self.indexOfTopLevelItem(item)
self.takeTopLevelItem(pos)
self.updatePosNumbers()
if pos < self.topLevelItemCount() - 1:
new_item = self.topLevelItem(pos)
else:
new_item = self.topLevelItem(pos - 1)
self.setCurrentItem(new_item)
self.aliasRemoved.emit(name)
