def persist_configuration(self, no_update=False):
if self.load_configuration:
if not no_update:
self.persistent_configuration.update(self.configuration)
# make sure startup is updated to reflect changes
get_vistrails_application().startup.persist_pkg_configuration(
self.codepath, self.persistent_configuration)
def persist_configuration(self, no_update=False):
if self.load_configuration:
if not no_update:
self.persistent_configuration.update(self.configuration)
# make sure startup is updated to reflect changes
get_vistrails_application().startup.persist_pkg_configuration(
self.codepath, self.persistent_configuration)
def set_persistent_configuration(self):
(dom, element) = self.find_own_dom_element()
child = enter_named_element(element, 'configuration')
if child:
element.removeChild(child)
self.configuration.write_to_dom(dom, element)
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
dom.unlink()
def configuration_changed(self, item, new_value):
""" configuration_changed(item: QTreeWidgetItem *,
new_value: QString) -> None
Write the current session configuration to startup.xml.
Note: This is already happening on close to capture configuration
items that are not set in preferences. We are doing this here too, so
we guarantee the changes were saved before VisTrails crashes.
"""
from vistrails.gui.application import get_vistrails_application
get_vistrails_application().save_configuration()
def configuration_changed(self, item, new_value):
""" configuration_changed(item: QTreeWidgetItem *,
new_value: QString) -> None
Write the current session configuration to startup.xml.
Note: This is already happening on close to capture configuration
items that are not set in preferences. We are doing this here too, so
we guarantee the changes were saved before VisTrails crashes.
"""
from vistrails.gui.application import get_vistrails_application
get_vistrails_application().save_configuration()
def _move_package_node(self, dom, where, node):
doc = dom.documentElement
packages = enter_named_element(doc, 'packages')
oldpackages = enter_named_element(doc, 'disabledpackages')
if where == 'enabled':
oldpackages.removeChild(node)
packages.appendChild(node)
elif where == 'disabled':
packages.removeChild(node)
oldpackages.appendChild(node)
else:
raise ValueError
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
def initialize_packages(self, prefix_dictionary={},
report_missing_dependencies=True):
"""initialize_packages(prefix_dictionary={}): None
Initializes all installed packages. If prefix_dictionary is
not {}, then it should be a dictionary from package names to
the prefix such that prefix + package_name is a valid python
import."""
failed = []
# import the modules
app = get_vistrails_application()
for package in self._package_list.itervalues():
# print '+ initializing', package.codepath, id(package)
if package.initialized():
# print '- already initialized'
continue
try:
prefix = prefix_dictionary.get(package.codepath)
if prefix is None:
prefix = self._default_prefix_dict.get(package.codepath)
package.load(prefix)
except Package.LoadFailed, e:
debug.critical("Package %s failed to load and will be "
"disabled" % package.name, e)
# We disable the package manually to skip over things
# we know will not be necessary - the only thing needed is
# the reference in the package list
self._startup.set_package_to_disabled(package.codepath)
failed.append(package)
except MissingRequirement, e:
debug.critical("Package <codepath %s> is missing a "
"requirement: %s" % (
package.codepath, e.requirement),
e)
def initialize_packages(self,
prefix_dictionary={},
report_missing_dependencies=True):
"""Initializes all installed packages.
:param prefix_dictionary: dictionary from package names to the prefix
such that prefix + package_name is a valid python import.
:type prefix_dictionary: dict
"""
failed = []
# import the modules
app = get_vistrails_application()
for package in self._package_list.itervalues():
# print '+ initializing', package.codepath, id(package)
if package.initialized():
# print '- already initialized'
continue
try:
prefix = prefix_dictionary.get(package.codepath)
if prefix is None:
prefix = self._default_prefix_dict.get(package.codepath)
package.load(prefix)
except Package.LoadFailed, e:
debug.critical(
"Package %s failed to load and will be disabled" %
(package.name or ("<codepath %s>" % package.codepath)), e)
# We disable the package manually to skip over things
# we know will not be necessary - the only thing needed is
# the reference in the package list
self._startup.set_package_to_disabled(package.codepath)
failed.append(package)
except MissingRequirement, e:
debug.critical(
"Package <codepath %s> is missing a "
"requirement: %s" % (package.codepath, e.requirement), e)
def remove_menu_items(self, pkg):
"""remove_menu_items(pkg: Package) -> None
Send a signal with the pkg identifier. The builder window should
catch this signal and remove the package menu items"""
if pkg.menu_items():
app = get_vistrails_application()
app.send_notification("pm_remove_package_menu", pkg.identifier)
def remove_menu_items(self, pkg):
"""remove_menu_items(pkg: Package) -> None
Send a signal with the pkg identifier. The builder window should
catch this signal and remove the package menu items"""
if pkg.menu_items():
app = get_vistrails_application()
app.send_notification("pm_remove_package_menu", pkg.identifier)
def remove_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
if pkg.menu_items():
app = get_vistrails_application()
app.send_notification("pm_remove_package_menu", pkg.identifier)
def show_error_message(self, pkg, msg):
"""show_error_message(pkg: Package, msg: str) -> None
Print a message to standard error output and emit a signal to the
builder so if it is possible, a message box is also shown """
debug.critical("Package %s (%s) says: %s" % (pkg.name, pkg.identifier, msg))
app = get_vistrails_application()
app.send_notification("pm_package_error_message", pkg.identifier, pkg.name, msg)
def remove_own_dom_element(self):
"""Moves the node to the <disabledpackages> section.
"""
dom = get_vistrails_application().vistrailsStartup.startup_dom()
node, section = self._get_package_node(dom, create='disabled')
if section == 'enabled':
self._move_package_node(dom, 'disabled', node)
def add_menu_items(self, pkg):
"""add_menu_items(pkg: Package) -> None
If the package implemented the function menu_items(),
the package manager will emit a signal with the menu items to
be added to the builder window """
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier, pkg.name, items)
def connect_registry_signals(self):
app = get_vistrails_application()
app.register_notification("reg_new_module", self.newModule)
app.register_notification("reg_new_package", self.newPackage)
app.register_notification("reg_deleted_module", self.deletedModule)
app.register_notification("reg_deleted_package", self.deletedPackage)
app.register_notification("reg_show_module", self.showModule)
app.register_notification("reg_hide_module", self.hideModule)
app.register_notification("reg_module_updated", self.switchDescriptors)
def remove_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
if pkg.menu_items():
app = get_vistrails_application()
app.send_notification("pm_remove_package_menu",
pkg.identifier)
def connect_registry_signals(self):
app = get_vistrails_application()
app.register_notification("reg_new_module", self.newModule)
app.register_notification("reg_new_package", self.newPackage)
app.register_notification("reg_deleted_module", self.deletedModule)
app.register_notification("reg_deleted_package", self.deletedPackage)
app.register_notification("reg_show_module", self.showModule)
app.register_notification("reg_hide_module", self.hideModule)
app.register_notification("reg_module_updated", self.switchDescriptors)
def show_error_message(self, pkg, msg):
"""Print and emit a notification for an error message.
"""
# TODO: isn't debug enough for the UI?
debug.critical("Package %s (%s) says: %s" %
(pkg.name, pkg.identifier, msg))
app = get_vistrails_application()
app.send_notification("pm_package_error_message", pkg.identifier,
pkg.name, msg)
def execute_pipeline(controller, pipeline,
reason, locator, version,
**kwargs):
"""Execute the pipeline while showing a progress dialog.
"""
_ = translate('execute_pipeline')
totalProgress = len(pipeline.modules)
progress = QtGui.QProgressDialog(_("Executing..."),
None,
0, totalProgress)
progress.setWindowTitle(_("Pipeline Execution"))
progress.setWindowModality(QtCore.Qt.WindowModal)
progress.show()
def moduleExecuted(objId):
progress.setValue(progress.value() + 1)
QtCore.QCoreApplication.processEvents()
if 'module_executed_hook' in kwargs:
kwargs['module_executed_hook'].append(moduleExecuted)
else:
kwargs['module_executed_hook'] = [moduleExecuted]
results, changed = controller.execute_workflow_list([(
locator, # locator
version, # version
pipeline, # pipeline
DummyView(), # view
None, # custom_aliases
None, # custom_params
reason, # reason
None, # sinks
kwargs)]) # extra_info
get_vistrails_application().send_notification('execution_updated')
progress.setValue(totalProgress)
progress.hide()
progress.deleteLater()
if not results[0].errors:
return None
else:
module_id, error = next(results[0].errors.iteritems())
return str(error)
def show_error_message(self, pkg, msg):
"""Print and emit a notification for an error message.
"""
# TODO: isn't debug enough for the UI?
debug.critical("Package %s (%s) says: %s"%(pkg.name,
pkg.identifier,
msg))
app = get_vistrails_application()
app.send_notification("pm_package_error_message", pkg.identifier,
pkg.name, msg)
def add_menu_items(self, pkg):
"""add_menu_items(pkg: Package) -> None
If the package implemented the function menu_items(),
the package manager will emit a signal with the menu items to
be added to the builder window """
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier,
pkg.name, items)
def late_disable_package(self, codepath):
"""Disables a package 'late', i.e. after VisTrails initialization.
Note that all the reverse dependencies need to already be disabled.
"""
pkg = self.get_package_by_codepath(codepath)
self.remove_package(codepath)
app = get_vistrails_application()
self._startup.set_package_to_disabled(codepath)
self._startup.save_persisted_startup()
def add_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier,
pkg.name, items)
def show_error_message(self, pkg, msg):
"""show_error_message(pkg: Package, msg: str) -> None
Print a message to standard error output and emit a signal to the
builder so if it is possible, a message box is also shown """
debug.critical("Package %s (%s) says: %s" %
(pkg.name, pkg.identifier, msg))
app = get_vistrails_application()
app.send_notification("pm_package_error_message", pkg.identifier,
pkg.name, msg)
def late_disable_package(self, codepath):
"""Disables a package 'late', i.e. after VisTrails initialization.
Note that all the reverse dependencies need to already be disabled.
"""
pkg = self.get_package_by_codepath(codepath)
self.remove_package(codepath)
app = get_vistrails_application()
self._startup.set_package_to_disabled(codepath)
self._startup.save_persisted_startup()
def add_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier,
pkg.name, items)
def find_own_dom_element(self):
"""find_own_dom_element() -> (DOM, Node)
Opens the startup DOM, looks for the element that belongs to the package,
and returns DOM and node. Creates a new one in the <disabledpackages>
section if none is found.
"""
dom = get_vistrails_application().vistrailsStartup.startup_dom()
node, section = self._get_package_node(dom, create='disabled')
return (dom, node)
def test_remove_package(self):
""" Tests if the package really gets deleted, and that it gets
selected again in the available packages list.
"""
pkg = "URL"
_app = get_vistrails_application()
builder = _app.builderWindow
builder.showPreferences()
prefs = builder.preferencesDialog
packages = prefs._packages_tab
prefs._tab_widget.setCurrentWidget(packages)
QtGui.QApplication.processEvents()
# check if package is loaded
av = packages._available_packages_list
try:
item, = av.findItems(pkg, QtCore.Qt.MatchExactly)
av.setCurrentItem(item)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
packages.enable_current_package()
except ValueError:
# Already enabled
pass
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
inst = packages._enabled_packages_list
item, = inst.findItems(pkg, QtCore.Qt.MatchExactly)
inst.setCurrentItem(item)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
packages.disable_current_package()
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
# force delayed calls
packages.populate_lists()
packages.select_package_after_update_slot(pkg)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
# This does not work because the selection is delayed
av = packages._available_packages_list
items = av.selectedItems()
self.assertEqual(len(items), 1, "No available items selected!")
self.assertEqual(items[0].text(), unicode(pkg),
"Wrong available item selected: %s" % items[0].text())
# check if configuration has been written correctly
startup = _app.startup
self.assertIn(pkg, startup.disabled_packages)
self.assertNotIn(pkg, startup.enabled_packages)
def test_remove_package(self):
""" Tests if the package really gets deleted, and that it gets
selected again in the available packages list.
"""
pkg = "URL"
_app = get_vistrails_application()
builder = _app.builderWindow
builder.showPreferences()
prefs = builder.preferencesDialog
packages = prefs._packages_tab
prefs._tab_widget.setCurrentWidget(packages)
QtGui.QApplication.processEvents()
# check if package is loaded
av = packages._available_packages_list
try:
item, = av.findItems(pkg, QtCore.Qt.MatchExactly)
av.setCurrentItem(item)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
packages.enable_current_package()
except ValueError:
# Already enabled
pass
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
inst = packages._enabled_packages_list
item, = inst.findItems(pkg, QtCore.Qt.MatchExactly)
inst.setCurrentItem(item)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
packages.disable_current_package()
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
# force delayed calls
packages.populate_lists()
packages.select_package_after_update_slot(pkg)
QtGui.QApplication.processEvents()
QtGui.QApplication.processEvents()
# This does not work because the selection is delayed
av = packages._available_packages_list
items = av.selectedItems()
self.assertEqual(len(items), 1, "No available items selected!")
self.assertEqual(items[0].text(), unicode(pkg),
"Wrong available item selected: %s" % items[0].text())
# check if configuration has been written correctly
startup = _app.startup
self.assertIn(pkg, startup.disabled_packages)
self.assertNotIn(pkg, startup.enabled_packages)
def test_remove_package(self):
""" Tests if the package really gets deleted, and that it gets
selected again in the available packages list.
"""
pkg = "dialogs"
_app = get_vistrails_application()
builder = _app.builderWindow
builder.showPreferences()
prefs = builder.preferencesDialog
packages = prefs._packages_tab
prefs._tab_widget.setCurrentWidget(packages)
# check if package is loaded
av = packages._available_packages_list
for item in av.findItems(pkg, QtCore.Qt.MatchExactly):
av.setCurrentItem(item)
packages.enable_current_package()
QtCore.QCoreApplication.processEvents()
inst = packages._enabled_packages_list
for item in inst.findItems(pkg, QtCore.Qt.MatchExactly):
inst.setCurrentItem(item)
packages.disable_current_package()
QtCore.QCoreApplication.processEvents()
# force delayed calls
packages.populate_lists()
packages.select_package_after_update_slot(pkg)
QtCore.QCoreApplication.processEvents()
# This does not work because the selection is delayed
av = packages._available_packages_list
items = av.selectedItems()
self.assertEqual(len(items), 1, "No available items selected!")
self.assertEqual(items[0].text(), unicode(pkg),
"Wrong available item selected: %s" % items[0].text())
# check if configuration has been written correctly
startup = _app.vistrailsStartup
doc = startup.startup_dom().documentElement
disabledpackages = enter_named_element(doc, 'disabledpackages')
dpackage = None
for package_node in named_elements(disabledpackages, 'package'):
if str(package_node.attributes['name'].value) == pkg:
dpackage = package_node
self.assertIsNotNone(dpackage, "Removed package '%s' is not in unloaded packages list!" % pkg)
epackages = enter_named_element(doc, 'packages')
apackage = None
for package_node in named_elements(epackages, 'package'):
if str(package_node.attributes['name'].value) == pkg:
apackage = package_node
self.assertIsNone(apackage, "Removed package '%s' is still in loaded packages list!" % pkg)
def execute_pipeline(controller, pipeline, reason, locator, version, **kwargs):
"""Execute the pipeline while showing a progress dialog.
"""
_ = translate('execute_pipeline')
totalProgress = len(pipeline.modules)
progress = QtGui.QProgressDialog(_("Executing..."), None, 0, totalProgress)
progress.setWindowTitle(_("Pipeline Execution"))
progress.setWindowModality(QtCore.Qt.WindowModal)
progress.show()
def moduleExecuted(objId):
progress.setValue(progress.value() + 1)
QtCore.QCoreApplication.processEvents()
if 'module_executed_hook' in kwargs:
kwargs['module_executed_hook'].append(moduleExecuted)
else:
kwargs['module_executed_hook'] = [moduleExecuted]
results, changed = controller.execute_workflow_list([(
locator, # locator
version, # version
pipeline, # pipeline
DummyView(), # view
None, # custom_aliases
None, # custom_params
reason, # reason
None, # sinks
kwargs)]) # extra_info
get_vistrails_application().send_notification('execution_updated')
progress.setValue(totalProgress)
progress.hide()
progress.deleteLater()
if not results[0].errors:
return None
else:
module_id, error = next(results[0].errors.iteritems())
return str(error)
def reset_configuration(self):
"""Reset package configuration to original package settings.
"""
(dom, element) = self.find_own_dom_element()
doc = dom.documentElement
configuration = enter_named_element(element, 'configuration')
if configuration:
element.removeChild(configuration)
self.configuration = copy.copy(self._initial_configuration)
startup = get_vistrails_application().vistrailsStartup
startup.write_startup_dom(dom)
def _get_package_node(self, dom, create):
doc = dom.documentElement
packages = enter_named_element(doc, 'packages')
for package_node in named_elements(packages, 'package'):
if package_node.attributes['name'].value == self.codepath:
return package_node, 'enabled'
oldpackages = enter_named_element(doc, 'disabledpackages')
for package_node in named_elements(oldpackages, 'package'):
if package_node.attributes['name'].value == self.codepath:
return package_node, 'disabled'
if create is None:
return None, None
else:
package_node = dom.createElement('package')
package_node.setAttribute('name', self.codepath)
if create == 'enabled':
packages.appendChild(package_node)
elif create == 'disabled':
oldpackages.appendChild(package_node)
else:
raise ValueError
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
return package_node, create
def create_startup_package_node(self):
"""Writes the node to the <packages> section.
If it was in the <disabledpackages> section, move it, else, create it.
"""
dom = get_vistrails_application().vistrailsStartup.startup_dom()
node, section = self._get_package_node(dom, create='enabled')
if section == 'disabled':
self._move_package_node(dom, 'enabled', node)
configuration = enter_named_element(node, 'configuration')
if configuration:
self.configuration.set_from_dom_node(configuration)
dom.unlink()
def reload_package_disable(self, codepath):
# for all reverse dependencies, disable them
prefix_dictionary = {}
pkg = self.get_package_by_codepath(codepath)
reverse_deps = []
for dep_id in self.all_reverse_dependencies(pkg.identifier):
reverse_deps.append(self.get_package(dep_id))
for dep_pkg in reverse_deps:
prefix_dictionary[dep_pkg.codepath] = dep_pkg.prefix
self.late_disable_package(dep_pkg.codepath)
# Queue the re-enabling of the packages so event loop can free
# any QObjects whose deleteLater() method is invoked
app = get_vistrails_application()
app.send_notification("pm_reloading_package", codepath, reverse_deps, prefix_dictionary)
def reload_package_disable(self, codepath):
# for all reverse dependencies, disable them
prefix_dictionary = {}
pkg = self.get_package_by_codepath(codepath)
reverse_deps = []
for dep_id in self.all_reverse_dependencies(pkg.identifier):
reverse_deps.append(self.get_package(dep_id))
for dep_pkg in reverse_deps:
prefix_dictionary[dep_pkg.codepath] = dep_pkg.prefix
self.late_disable_package(dep_pkg.codepath)
# Queue the re-enabling of the packages so event loop can free
# any QObjects whose deleteLater() method is invoked
app = get_vistrails_application()
app.send_notification("pm_reloading_package", codepath, reverse_deps,
prefix_dictionary)
def remove_package(self, codepath):
"""remove_package(name): Removes a package from the system."""
pkg = self._package_list[codepath]
from vistrails.core.interpreter.cached import CachedInterpreter
CachedInterpreter.clear_package(pkg.identifier)
self._dependency_graph.delete_vertex(pkg.identifier)
del self._package_versions[pkg.identifier][pkg.version]
if len(self._package_versions[pkg.identifier]) == 0:
del self._package_versions[pkg.identifier]
self.remove_old_identifiers(pkg.identifier)
self.remove_menu_items(pkg)
pkg.finalize()
del self._package_list[codepath]
self._registry.remove_package(pkg)
app = get_vistrails_application()
app.send_notification("package_removed", codepath)
def remove_package(self, codepath):
"""remove_package(name): Removes a package from the system."""
pkg = self._package_list[codepath]
from vistrails.core.interpreter.cached import CachedInterpreter
CachedInterpreter.clear_package(pkg.identifier)
self._dependency_graph.delete_vertex(pkg.identifier)
del self._package_versions[pkg.identifier][pkg.version]
if len(self._package_versions[pkg.identifier]) == 0:
del self._package_versions[pkg.identifier]
self.remove_old_identifiers(pkg.identifier)
self.remove_menu_items(pkg)
pkg.finalize()
del self._package_list[codepath]
self._registry.remove_package(pkg)
app = get_vistrails_application()
app.send_notification("package_removed", codepath)
def late_enable_package(self, codepath, prefix_dictionary={}, needs_add=True):
"""late_enable_package enables a package 'late', that is,
after VisTrails initialization. All dependencies need to be
already enabled.
"""
if needs_add:
if codepath in self._package_list:
msg = "duplicate package identifier: %s" % codepath
raise VistrailsInternalError(msg)
self.add_package(codepath)
app = get_vistrails_application()
pkg = self.get_package_by_codepath(codepath)
try:
pkg.load(prefix_dictionary.get(pkg.codepath, None))
# pkg.create_startup_package_node()
except Exception, e:
# invert self.add_package
del self._package_list[codepath]
raise
def _get_variables_root(controller=None):
"""Create or get the version tagged 'dat-vars'
This is the base version of all DAT variables. It consists of a single
OutputPort module with name 'value'.
"""
if controller is None:
controller = get_vistrails_application().get_controller()
assert controller is not None
if controller.vistrail.has_tag_str('dat-vars'):
root_version = controller.vistrail.get_version_number('dat-vars')
else:
# Create the 'dat-vars' version
controller.change_selected_version(0)
reg = get_module_registry()
operations = []
# Add an OutputPort module
descriptor = reg.get_descriptor_by_name(
'org.vistrails.vistrails.basic', 'OutputPort')
out_mod = controller.create_module_from_descriptor(descriptor)
operations.append(('add', out_mod))
# Add a function to this module
operations.extend(
controller.update_function_ops(
out_mod,
'name',
['value']))
# Perform the operations
action = create_action(operations)
controller.add_new_action(action)
root_version = controller.perform_action(action)
# Tag as 'dat-vars'
controller.vistrail.set_tag(root_version, 'dat-vars')
controller.change_selected_version(root_version)
pipeline = controller.current_pipeline
outmod_id = pipeline.modules.keys()
assert len(outmod_id) == 1
outmod_id = outmod_id[0]
return controller, root_version, outmod_id
def startDrag(self, actions):
indexes = self.selectedIndexes()
if len(indexes) > 0:
mime_data = self.model().mimeData(indexes)
drag = QtGui.QDrag(self)
drag.setMimeData(mime_data)
item = mime_data.items[0]
app = get_vistrails_application()
pipeline_view = app.builderWindow.get_current_controller().current_pipeline_view
if hasattr(pipeline_view.scene(), 'add_tmp_module'):
module_item = \
pipeline_view.scene().add_tmp_module(item.descriptor)
pixmap = pipeline_view.paintModuleToPixmap(module_item)
drag.setPixmap(pixmap)
drag.setHotSpot(QtCore.QPoint(pixmap.width()/2,
pixmap.height()/2))
drag.exec_(actions)
pipeline_view.scene().delete_tmp_module()
def late_enable_package(self, codepath, prefix_dictionary={},
needs_add=True):
"""late_enable_package enables a package 'late', that is,
after VisTrails initialization. All dependencies need to be
already enabled.
"""
if needs_add:
if codepath in self._package_list:
msg = 'duplicate package identifier: %s' % codepath
raise VistrailsInternalError(msg)
self.add_package(codepath)
app = get_vistrails_application()
pkg = self.get_package_by_codepath(codepath)
try:
pkg.load(prefix_dictionary.get(pkg.codepath, None))
# pkg.create_startup_package_node()
except Exception, e:
# invert self.add_package
del self._package_list[codepath]
raise
def __init__(self, parent, persistent_config, temp_config):
QtGui.QWidget.__init__(self, parent)
self.persistent_config = persistent_config
self.temp_config = temp_config
scroll_area = QtGui.QScrollArea()
inner_widget = QtGui.QWidget()
self.inner_layout = QtGui.QVBoxLayout()
inner_widget.setLayout(self.inner_layout)
scroll_area.setWidget(inner_widget)
scroll_area.setWidgetResizable(True)
self.setLayout(QtGui.QVBoxLayout())
self.layout().addWidget(scroll_area, 1)
self.layout().setContentsMargins(0,0,0,0)
app = get_vistrails_application()
app.register_notification("package_added", self.update_output_modules)
app.register_notification("package_removed", self.update_output_modules)
self.mode_widgets = {}
def startDrag(self, actions):
indexes = self.selectedIndexes()
if len(indexes) > 0:
mime_data = self.model().mimeData(indexes)
drag = QtGui.QDrag(self)
drag.setMimeData(mime_data)
item = mime_data.items[0]
app = get_vistrails_application()
pipeline_view = app.builderWindow.get_current_controller(
).current_pipeline_view
if hasattr(pipeline_view.scene(), 'add_tmp_module'):
module_item = \
pipeline_view.scene().add_tmp_module(item.descriptor)
pixmap = pipeline_view.paintModuleToPixmap(module_item)
drag.setPixmap(pixmap)
drag.setHotSpot(
QtCore.QPoint(pixmap.width() / 2,
pixmap.height() / 2))
drag.exec_(actions)
pipeline_view.scene().delete_tmp_module()
def hide_splash_if_necessary():
"""Disables the splashscreen, otherwise it sits in front of windows.
"""
app = get_vistrails_application()
if hasattr(app, 'splashScreen') and app.splashScreen:
app.splashScreen.hide()
def __init__(self, parent):
QtGui.QWidget.__init__(self, parent)
base_layout = QtGui.QHBoxLayout(self)
left = QtGui.QFrame(self)
right = QtGui.QFrame(self)
base_layout.addWidget(left)
base_layout.addWidget(right, 1)
######################################################################
left_layout = QtGui.QVBoxLayout(left)
left_layout.addWidget(QtGui.QLabel("Disabled packages:", left))
self._available_packages_list = QtGui.QListWidget(left)
left_layout.addWidget(self._available_packages_list)
left_layout.addWidget(QtGui.QLabel("Enabled packages:", left))
self._enabled_packages_list = QtGui.QListWidget(left)
left_layout.addWidget(self._enabled_packages_list)
self.update_button = QtGui.QPushButton("Refresh Lists", left)
left_layout.addWidget(self.update_button, 0, QtCore.Qt.AlignLeft)
self.update_button.clicked.connect(self.populate_lists)
self.connect(self._available_packages_list,
QtCore.SIGNAL('itemSelectionChanged()'),
self.selected_available_list, QtCore.Qt.QueuedConnection)
self.connect(self._enabled_packages_list,
QtCore.SIGNAL('itemSelectionChanged()'),
self.selected_enabled_list, QtCore.Qt.QueuedConnection)
sm = QtGui.QAbstractItemView.SingleSelection
self._available_packages_list.setSelectionMode(sm)
self._enabled_packages_list.setSelectionMode(sm)
######################################################################
right_layout = QtGui.QVBoxLayout(right)
info_frame = QtGui.QFrame(right)
info_layout = QtGui.QVBoxLayout(info_frame)
grid_frame = QtGui.QFrame(info_frame)
grid_frame.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
info_layout.addWidget(grid_frame)
grid_layout = QtGui.QGridLayout(grid_frame)
l1 = QtGui.QLabel("Package Name:", grid_frame)
grid_layout.addWidget(l1, 0, 0)
l2 = QtGui.QLabel("Identifier:", grid_frame)
grid_layout.addWidget(l2, 1, 0)
l3 = QtGui.QLabel("Version:", grid_frame)
grid_layout.addWidget(l3, 2, 0)
l4 = QtGui.QLabel("Dependencies:", grid_frame)
grid_layout.addWidget(l4, 3, 0)
l5 = QtGui.QLabel("Reverse Dependencies:", grid_frame)
grid_layout.addWidget(l5, 4, 0)
l6 = QtGui.QLabel("Description:", grid_frame)
grid_layout.addWidget(l6, 5, 0)
self._name_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._name_label, 0, 1)
self._identifier_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._identifier_label, 1, 1)
self._version_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._version_label, 2, 1)
self._dependencies_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._dependencies_label, 3, 1)
self._reverse_dependencies_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._reverse_dependencies_label, 4, 1)
self._description_label = QtGui.QLabel("", grid_frame)
grid_layout.addWidget(self._description_label, 5, 1)
for lbl in [
l1, l2, l3, l4, l5, l6, self._name_label, self._version_label,
self._dependencies_label, self._identifier_label,
self._reverse_dependencies_label, self._description_label
]:
lbl.setAlignment(QtCore.Qt.AlignTop | QtCore.Qt.AlignLeft)
lbl.setWordWrap(True)
grid_layout.setRowStretch(4, 1)
grid_layout.setColumnStretch(1, 1)
right_layout.addWidget(info_frame)
self._enable_button = QtGui.QPushButton("&Enable")
self._enable_button.setEnabled(False)
self.connect(self._enable_button, QtCore.SIGNAL("clicked()"),
self.enable_current_package)
self._disable_button = QtGui.QPushButton("&Disable")
self._disable_button.setEnabled(False)
self.connect(self._disable_button, QtCore.SIGNAL("clicked()"),
self.disable_current_package)
self._configure_button = QtGui.QPushButton("&Configure...")
self._configure_button.setEnabled(False)
self.connect(self._configure_button, QtCore.SIGNAL("clicked()"),
self.configure_current_package)
self._reload_button = QtGui.QPushButton("&Reload")
self._reload_button.setEnabled(False)
self.connect(self._reload_button, QtCore.SIGNAL("clicked()"),
self.reload_current_package)
button_box = QtGui.QDialogButtonBox()
button_box.addButton(self._enable_button,
QtGui.QDialogButtonBox.ActionRole)
button_box.addButton(self._disable_button,
QtGui.QDialogButtonBox.ActionRole)
button_box.addButton(self._configure_button,
QtGui.QDialogButtonBox.ActionRole)
button_box.addButton(self._reload_button,
QtGui.QDialogButtonBox.ActionRole)
right_layout.addWidget(button_box)
self.connect(self, self.select_package_after_update_signal,
self.select_package_after_update_slot,
QtCore.Qt.QueuedConnection)
# pm = get_package_manager()
# self.connect(pm,
# pm.reloading_package_signal,
# self.reload_current_package_finisher,
# QtCore.Qt.QueuedConnection)
app = get_vistrails_application()
app.register_notification("pm_reloading_package",
self.reload_current_package_finisher)
app.register_notification("package_added", self.package_added)
app.register_notification("package_removed", self.package_removed)
self.populate_lists()
self._current_package = None
def vt_controller():
app = get_vistrails_application()
view = app.builderWindow.new_vistrail()
controller = view.get_controller()
VistrailManager.set_controller(controller, register=True)
return controller
def get_key(self, key):
return get_vistrails_application().keyChain.get_key(key)
def set_key(self, key, passwd):
get_vistrails_application().keyChain.set_key(key, passwd)
def get_key(self, key):
return get_vistrails_application().keyChain.get_key(key)
"requirement: %s" % (
pkg.codepath, e.requirement),
e)
self.late_disable_package(pkg.codepath)
except Package.InitializationFailed, e:
debug.critical("Initialization of package <codepath %s> "
"failed and will be disabled" %
pkg.codepath,
e)
# We disable the package manually to skip over things
# we know will not be necessary - the only thing needed is
# the reference in the package list
self.late_disable_package(pkg.codepath)
else:
self.add_menu_items(pkg)
app = get_vistrails_application()
app.send_notification("package_added", pkg.codepath)
self._startup.save_persisted_startup()
def add_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier,
pkg.name, items)
# self.emit(self.add_package_menu_signal,
debug.critical(
"Package <codepath %s> is missing a "
"requirement: %s" % (pkg.codepath, e.requirement),
e)
self.late_disable_package(pkg.codepath)
except Package.InitializationFailed, e:
debug.critical(
"Initialization of package <codepath %s> "
"failed and will be disabled" % pkg.codepath, e)
# We disable the package manually to skip over things
# we know will not be necessary - the only thing needed is
# the reference in the package list
self.late_disable_package(pkg.codepath)
else:
self.add_menu_items(pkg)
app = get_vistrails_application()
app.send_notification("package_added", pkg.codepath)
self._startup.save_persisted_startup()
def add_menu_items(self, pkg):
"""Emit the appropriate signal if the package has menu items.
:type pkg: Package
"""
items = pkg.menu_items()
if items:
app = get_vistrails_application()
app.send_notification("pm_add_package_menu", pkg.identifier,
pkg.name, items)
# self.emit(self.add_package_menu_signal,
