def hide_splash_if_necessary():
qt = has_qt()
# HACK, otherwise splashscreen stays in front of windows
if qt:
try:
get_vistrails_application().splashScreen.hide()
except:
pass
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 PyQt4 import QtCore
from gui.application import get_vistrails_application
get_vistrails_application().save_configuration()
def remove_own_dom_element(self):
"""remove_own_dom_element() -> None
Opens the startup DOM, looks for the element that belongs to the package.
If it is there and there's a configuration, moves it to disabledpackages
node. This is done as part of package disable.
"""
startup = get_vistrails_application().vistrailsStartup
dom = startup.startup_dom()
doc = dom.documentElement
def find_it():
packages = enter_named_element(doc, 'packages')
for package_node in named_elements(packages, 'package'):
if str(package_node.attributes['name'].value) == self.codepath:
return package_node
package_node = find_it()
oldpackage_element = self.find_disabledpackage_element(doc)
assert oldpackage_element is None
packages = enter_named_element(doc, 'packages')
disabledpackages = enter_named_element(doc, 'disabledpackages')
try:
packages.removeChild(package_node)
disabledpackages.appendChild(package_node)
except xml.dom.NotFoundErr:
pass
startup.write_startup_dom(dom)
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_own_dom_element(self):
"""remove_own_dom_element() -> None
Opens the startup DOM, looks for the element that belongs to the package.
If it is there and there's a configuration, moves it to disabledpackages
node. This is done as part of package disable.
"""
startup = get_vistrails_application().vistrailsStartup
dom = startup.startup_dom()
doc = dom.documentElement
def find_it():
packages = enter_named_element(doc, 'packages')
for package_node in named_elements(packages, 'package'):
if str(package_node.attributes['name'].value) == self.codepath:
return package_node
package_node = find_it()
oldpackage_element = self.find_disabledpackage_element(doc)
assert oldpackage_element is None
packages = enter_named_element(doc, 'packages')
disabledpackages = enter_named_element(doc, 'disabledpackages')
try:
packages.removeChild(package_node)
disabledpackages.appendChild(package_node)
except xml.dom.NotFoundErr:
pass
startup.write_startup_dom(dom)
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 add_package(self, codepath, add_to_package_list=True):
"""Adds a new package to the manager. This does not initialize it.
To do so, call initialize_packages()"""
package = self._registry.create_package(codepath)
if add_to_package_list:
self.add_to_package_list(codepath, package)
app = get_vistrails_application()
app.send_notification("package_added", codepath)
return package
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 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 create_startup_package_node(self):
(dom, element) = self.find_own_dom_element()
doc = dom.documentElement
disabledpackages = enter_named_element(doc, 'disabledpackages')
packages = enter_named_element(doc, 'packages')
oldpackage = self.find_disabledpackage_element(doc)
if oldpackage is not None:
# Must remove element from oldpackages,
# _and_ the element that was just created in find_own_dom_element()
disabledpackages.removeChild(oldpackage)
packages.removeChild(element)
packages.appendChild(oldpackage)
configuration = enter_named_element(oldpackage, 'configuration')
if configuration:
self.configuration.set_from_dom_node(configuration)
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
dom.unlink()
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 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 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 create_startup_package_node(self):
(dom, element) = self.find_own_dom_element()
doc = dom.documentElement
disabledpackages = enter_named_element(doc, 'disabledpackages')
packages = enter_named_element(doc, 'packages')
oldpackage = self.find_disabledpackage_element(doc)
if oldpackage is not None:
# Must remove element from oldpackages,
# _and_ the element that was just created in find_own_dom_element()
disabledpackages.removeChild(oldpackage)
packages.removeChild(element)
packages.appendChild(oldpackage)
configuration = enter_named_element(oldpackage, 'configuration')
if configuration:
if self.configuration: self.configuration.set_from_dom_node(configuration)
else: debug.warning("Error, missing configuration in package")
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
dom.unlink()
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_package(self, codepath):
"""remove_package(name): Removes a package from the system."""
pkg = self._package_list[codepath]
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_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 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 if element is not there.
"""
dom = get_vistrails_application().vistrailsStartup.startup_dom()
doc = dom.documentElement
packages = enter_named_element(doc, 'packages')
for package_node in named_elements(packages, 'package'):
if str(package_node.attributes['name'].value) == self.codepath:
return (dom, package_node)
# didn't find anything, create a new node
package_node = dom.createElement("package")
package_node.setAttribute('name', self.codepath)
packages.appendChild(package_node)
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
return (dom, package_node)
def reset_configuration(self):
"""Reset_configuration() -> Resets 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 reset_configuration(self):
"""Reset_configuration() -> Resets 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 remove_package(self, codepath):
"""remove_package(name): Removes a package from the system."""
pkg = self._package_list[codepath]
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_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 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 if element is not there.
"""
dom = get_vistrails_application().vistrailsStartup.startup_dom()
doc = dom.documentElement
packages = enter_named_element(doc, 'packages')
for package_node in named_elements(packages, 'package'):
if str(package_node.attributes['name'].value) == self.codepath:
return (dom, package_node)
# didn't find anything, create a new node
package_node = dom.createElement("package")
package_node.setAttribute('name', self.codepath)
packages.appendChild(package_node)
get_vistrails_application().vistrailsStartup.write_startup_dom(dom)
return (dom, package_node)
def reload_package_disable(self, package_codepath):
# for all reverse dependencies, disable them
prefix_dictionary = {}
pkg = self.get_package_by_codepath(package_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", package_codepath,
reverse_deps, prefix_dictionary)
def reload_package_disable(self, package_codepath):
# for all reverse dependencies, disable them
prefix_dictionary = {}
pkg = self.get_package_by_codepath(package_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", package_codepath,
reverse_deps, prefix_dictionary)
class PackageManager(object):
# # add_package_menu_signal is emitted with a tuple containing the package
# # identifier, package name and the menu item
# add_package_menu_signal = QtCore.SIGNAL("add_package_menu")
# # remove_package_menu_signal is emitted with the package identifier
# remove_package_menu_signal = QtCore.SIGNAL("remove_package_menu")
# # package_error_message_signal is emitted with the package identifier,
# # package name and the error message
# package_error_message_signal = QtCore.SIGNAL("package_error_message_signal")
# # reloading_package_signal is emitted when a package reload has disabled
# # the packages, but has not yet enabled them
# reloading_package_signal = QtCore.SIGNAL("reloading_package_signal")
class DependencyCycle(Exception):
def __init__(self, p1, p2):
self._package_1 = p1
self._package_2 = p2
def __str__(self):
return ("Packages '%s' and '%s' have cyclic dependencies" %
(self._package_1, self._package_2))
class MissingPackage(Exception):
def __init__(self, n):
self._package_name = n
def __str__(self):
return "Package '%s' is missing." % self._package_name
class PackageInternalError(Exception):
def __init__(self, n, d):
self._package_name = n
self._description = d
def __str__(self):
return "Package '%s' has a bug: %s" % (self._package_name,
self._description)
def import_packages_module(self):
"""Imports the packages module using path trickery to find it
in the right place.
"""
if self._packages is not None:
return self._packages
# Imports standard packages directory
conf = self._configuration
old_sys_path = copy.copy(sys.path)
if conf.check('packageDirectory'):
sys.path.insert(0, conf.packageDirectory)
try:
import packages
except ImportError:
debug.critical('ImportError: "packages" sys.path: %s' % sys.path)
raise
finally:
sys.path = old_sys_path
self._packages = packages
return packages
def import_user_packages_module(self):
"""Imports the packages module using path trickery to find it
in the right place.
"""
if self._userpackages is not None:
return self._userpackages
# Imports user packages directory
conf = self._configuration
old_sys_path = copy.copy(sys.path)
if conf.check('userPackageDirectory'):
sys.path.insert(
0, os.path.join(conf.userPackageDirectory, os.path.pardir))
try:
import userpackages
except ImportError:
debug.critical('ImportError: "userpackages" sys.path: %s' %
sys.path)
raise
finally:
sys.path = old_sys_path
self._userpackages = userpackages
return userpackages
def __init__(self, configuration):
"""__init__(configuration: ConfigurationObject) -> PackageManager
configuration is the persistent configuration object of the application.
"""
global _package_manager
if _package_manager:
m = "Package manager can only be constructed once."
raise VistrailsInternalError(m)
_package_manager = self
self._configuration = configuration
self._package_list = {}
self._package_versions = {}
self._dependency_graph = core.data_structures.graph.Graph()
self._registry = None
self._userpackages = None
self._packages = None
self._abstraction_pkg = None
def init_registry(self, registry_filename=None):
if registry_filename is not None:
self._registry = core.db.io.open_registry(registry_filename)
self._registry.set_global()
else:
self._registry = ModuleRegistry()
self._registry.set_global()
def setup_basic_package():
# setup basic package
basic_package = self.add_package('basic_modules')
self._registry._default_package = basic_package
prefix_dictionary = {'basic_modules': 'core.modules.'}
self.initialize_packages(prefix_dictionary)
setup_basic_package()
self._abstraction_pkg = self.add_package('abstraction', False)
# FIXME need to get this info from the package, but cannot
# do this since controller isn't imported yet
self._abstraction_pkg.identifier = 'local.abstractions'
self._abstraction_pkg.name = 'My SubWorkflows'
self._abstraction_pkg.version = '1.6'
self._registry.add_package(self._abstraction_pkg)
def finalize_packages(self):
"""Finalizes all installed packages. Call this only prior to
exiting VisTrails."""
for package in self._package_list.itervalues():
package.finalize()
self._package_list = {}
self._package_versions = {}
global _package_manager
_package_manager = None
def add_package(self, codepath, add_to_package_list=True):
"""Adds a new package to the manager. This does not initialize it.
To do so, call initialize_packages()"""
package = self._registry.create_package(codepath)
if add_to_package_list:
self.add_to_package_list(codepath, package)
return package
def add_to_package_list(self, codepath, package):
self._package_list[codepath] = package
def initialize_abstraction_pkg(self, prefix_dictionary):
if self._abstraction_pkg is None:
raise Exception("Subworkflows packages is None")
self.add_to_package_list(self._abstraction_pkg.codepath,
self._abstraction_pkg)
self.late_enable_package(self._abstraction_pkg.codepath,
prefix_dictionary, False)
def remove_package(self, codepath):
"""remove_package(name): Removes a package from the system."""
pkg = self._package_list[codepath]
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_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 has_package(self, identifier, version=None):
"""has_package(identifer: string) -> Boolean.
Returns true if given package identifier is present."""
if identifier in self._package_versions:
return (version is None
or version in self._package_versions[identifier])
return False
def look_at_available_package(self, codepath):
"""look_at_available_package(codepath: string) -> Package
Returns a Package object for an uninstalled package. This does
NOT install a package.
"""
return self._registry.create_package(codepath, False)
def get_package(self, identifier, version=None):
package_versions = self._package_versions[identifier]
if version is not None:
return package_versions[version]
max_version = '0'
max_pkg = None
for version, pkg in package_versions.iteritems():
if versions_increasing(max_version, version):
max_version = version
max_pkg = pkg
return max_pkg
def get_package_by_codepath(self, codepath):
"""get_package_by_codepath(codepath: string) -> Package.
Returns a package with given codepath if it is enabled,
otherwise throws exception
"""
if codepath not in self._package_list:
raise self.MissingPackage(codepath)
else:
return self._package_list[codepath]
def get_package_by_identifier(self, identifier):
"""get_package_by_identifier(identifier: string) -> Package.
Returns a package with given identifier if it is enabled,
otherwise throws exception
"""
if identifier not in self._registry.packages:
raise self.MissingPackage(identifier)
return self._registry.packages[identifier]
def get_package_configuration(self, codepath):
"""get_package_configuration(codepath: string) ->
ConfigurationObject or None
Returns the configuration object for the package, if existing,
or None. Throws MissingPackage if package doesn't exist.
"""
pkg = self.get_package_by_codepath(codepath)
if not hasattr(pkg.module, 'configuration'):
return None
else:
c = pkg.module.configuration
if not isinstance(c, ConfigurationObject):
d = "'configuration' attribute should be a ConfigurationObject"
raise self.PackageInternalError(codepath, d)
return c
def check_dependencies(self, package, deps):
# want to check that necessary version also exists, if specified
missing_deps = []
for dep in deps:
min_version = None
max_version = None
if type(dep) == tuple:
identifier = dep[0]
if len(dep) > 1:
min_version = dep[1]
if len(dep) > 2:
max_version = dep[2]
else:
identifier = dep
if identifier not in self._package_versions:
missing_deps.append((identifier, None, None))
else:
if min_version is None and max_version is None:
continue
found_version = False
for version, pkg in \
self._package_versions[identifier].iteritems():
if ((min_version is None
or versions_increasing(min_version, version)) and
(max_version is None
or versions_increasing(version, max_version))):
found_version = True
if not found_version:
missing_deps.append((identifier, min_version, max_version))
if len(missing_deps) > 0:
raise Package.MissingDependency(package, missing_deps)
return True
def add_dependencies(self, package):
"""add_dependencies(package) -> None. Register all
dependencies a package contains by calling the appropriate
callback.
Does not add multiple dependencies - if a dependency is already there,
add_dependencies ignores it.
"""
deps = package.dependencies()
# FIXME don't hardcode this
from core.modules.basic_modules import identifier as basic_pkg
if package.identifier != basic_pkg:
deps.append(basic_pkg)
self.check_dependencies(package, deps)
for dep in deps:
if type(dep) == tuple:
dep_name = dep[0]
else:
dep_name = dep
if not self._dependency_graph.has_edge(package.identifier,
dep_name):
self._dependency_graph.add_edge(package.identifier, dep_name)
def late_enable_package(self,
package_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 package_codepath in self._package_list:
msg = 'duplicate package identifier: %s' % package_codepath
raise VistrailsInternalError(msg)
self.add_package(package_codepath)
pkg = self.get_package_by_codepath(package_codepath)
try:
pkg.load(prefix_dictionary.get(pkg.codepath, None))
except Exception, e:
# invert self.add_package
del self._package_list[package_codepath]
raise
self._dependency_graph.add_vertex(pkg.identifier)
if pkg.identifier not in self._package_versions:
self._package_versions[pkg.identifier] = {}
self._package_versions[pkg.identifier][pkg.version] = pkg
try:
self.add_dependencies(pkg)
#check_requirements is now called in pkg.initialize()
#pkg.check_requirements()
self._registry.initialize_package(pkg)
self._registry.signals.emit_new_package(pkg.identifier, True)
app = get_vistrails_application()
app.send_notification("package_added", package_codepath)
self.add_menu_items(pkg)
except Exception, e:
del self._package_versions[pkg.identifier][pkg.version]
if len(self._package_versions[pkg.identifier]) == 0:
del self._package_versions[pkg.identifier]
self._dependency_graph.delete_vertex(pkg.identifier)
# invert self.add_package
del self._package_list[package_codepath]
# if we adding the package to the registry, make sure we
# remove it if initialization fails
try:
self._registry.remove_package(pkg)
except MissingPackage:
pass
raise e
"requirement: %s" % (pkg.codepath, e.requirement),
str(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, str(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:
pkg.remove_py_deps(existing_paths)
existing_paths.update(pkg.get_py_deps())
self.add_menu_items(pkg)
app = get_vistrails_application()
app.send_notification("package_added", pkg.codepath)
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)
# self.emit(self.add_package_menu_signal,
# pkg.identifier,
# pkg.name,
def __init__(self, parent, status_bar):
QtGui.QWidget.__init__(self, parent)
self._status_bar = status_bar
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.setMargin(2)
left_layout.setSpacing(2)
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.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
self.erase_cache = False
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)
def set_key(self, key, passwd):
get_vistrails_application().keyChain.set_key(key,passwd)
self._registry.initialize_package(pkg)
except Package.InitializationFailed, e:
debug.critical("Initialization of package <codepath %s> "
"failed and will be disabled" % \
pkg.codepath, str(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)
# pkg.remove_own_dom_element()
# failed.append(package)
else:
pkg.remove_py_deps(existing_paths)
existing_paths.update(pkg.get_py_deps())
self.add_menu_items(pkg)
app = get_vistrails_application()
app.send_notification("package_added", pkg.codepath)
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)
# self.emit(self.add_package_menu_signal,
# pkg.identifier,
def get_key(self, key):
return get_vistrails_application().keyChain.get_key(key)
def __init__(self, parent, status_bar):
QtGui.QWidget.__init__(self, parent)
self._status_bar = status_bar
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.setMargin(2)
left_layout.setSpacing(2)
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.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
self.erase_cache = False