def __init__(self, root_main_window, parent=None):
        super(ContainerManager, self).__init__(parent)
        self._root_main_window = root_main_window
        self._container_descriptor = PluginDescriptor('__DockWidgetContainer')
        self._container_descriptor.set_action_attributes(
            self.tr('Container'), self.tr('Container for other dock widgets'),
            'folder-new', 'theme')

        self._containers = {}
    def discover(self, discovery_data):
        discovered_plugins = self._unfold(self._plugin_provider.discover(discovery_data))
        plugin_descriptors = []
        for plugin in discovered_plugins.values():
            plugin_descriptor = PluginDescriptor(plugin['plugin_id'], plugin['attributes'])

            action_attributes = plugin['action']
            plugin_descriptor.set_action_attributes(action_attributes['label'], action_attributes.get('statustip', None), action_attributes.get('icon', None), action_attributes.get('icontype', None))

            groups = plugin.get('groups', {})
            for group in groups.values():
                plugin_descriptor.add_group_attributes(group['label'], group['statustip'], group['icon'], group['icontype'])

            plugin_descriptors.append(plugin_descriptor)
        return plugin_descriptors
    def discover(self):
        discovered_plugins = self._unfold(self._plugin_provider.discover())
        plugin_descriptors = []
        for plugin in discovered_plugins.values():
            plugin_descriptor = PluginDescriptor(plugin['plugin_id'],
                                                 plugin['attributes'])

            action_attributes = plugin['action']
            plugin_descriptor.set_action_attributes(
                action_attributes['label'],
                action_attributes.get('statustip', None),
                action_attributes.get('icon', None),
                action_attributes.get('icontype', None))

            groups = plugin.get('groups', {})
            for group in groups.values():
                plugin_descriptor.add_group_attributes(group['label'],
                                                       group['statustip'],
                                                       group['icon'],
                                                       group['icontype'])

            plugin_descriptors.append(plugin_descriptor)
        return plugin_descriptors
    def _parse_plugin_xml(self, package_name, plugin_xml):
        plugin_descriptors = []
        if not os.path.isfile(plugin_xml):
            qCritical('RosPluginProvider._parse_plugin_xml() plugin file "%s" in package "%s" '
                      'not found' % (plugin_xml, package_name))
            return plugin_descriptors

        try:
            root = ElementTree.parse(plugin_xml)
        except Exception:
            qCritical('RosPluginProvider._parse_plugin_xml() could not parse "%s" in package "%s"'
                      % (plugin_xml, package_name))
            return plugin_descriptors
        for library_el in root.getiterator('library'):
            library_path = library_el.attrib['path']

            for class_el in library_el.getiterator('class'):
                # collect common attributes
                attributes = {
                    'package_name': package_name,
                    'plugin_path': os.path.dirname(plugin_xml),
                    'library_path': library_path,
                }
                # add class attributes
                for key, value in class_el.items():
                    attributes['class_' + key] = value

                # skip classes with non-matching _base_class_type
                class_base_class_type = attributes.get('class_base_class_type', None)
                if class_base_class_type != self._base_class_type:
                    continue

                # generate unique identifier
                plugin_id = package_name
                if 'class_name' in attributes:
                    plugin_id = plugin_id + '/' + attributes['class_name']
                attributes['plugin_id'] = plugin_id

                # separate module name and class name
                module_name, class_from_class_type = attributes['class_type'].rsplit('.', 1)
                attributes['module_name'] = module_name
                attributes['class_from_class_type'] = class_from_class_type

                # we can not check if the plugin is available without loading it
                attributes['not_available'] = ''

                plugin_descriptor = PluginDescriptor(plugin_id, attributes)

                # set action attributes (plugin providers might have none)
                action_attributes, groups = self._parse_plugin(class_el)
                if len(action_attributes) > 0:
                    plugin_descriptor.set_action_attributes(
                        action_attributes['label'],
                        action_attributes.get('statustip', None),
                        action_attributes.get('icon', None),
                        action_attributes.get('icontype', None),
                    )
                # add group attributes
                for group in groups:
                    plugin_descriptor.add_group_attributes(
                        group['label'],
                        group.get('statustip', None),
                        group.get('icon', None),
                        group.get('icontype', None),
                    )

                # add plugin_descriptor to list
                plugin_descriptors.append(plugin_descriptor)

        return plugin_descriptors
    def _parse_plugin_xml(self, package_name, plugin_xml):
        plugin_descriptors = []

        if not os.path.isfile(plugin_xml):
            qCritical('RosPluginProvider._parse_plugin_xml() plugin file "%s" in package "%s" not found' % (plugin_xml, package_name))
            return plugin_descriptors

        try:
            root = ElementTree.parse(plugin_xml)
        except Exception:
            qCritical('RosPluginProvider._parse_plugin_xml() could not parse "%s" in package "%s"' % (plugin_xml, package_name))
            return plugin_descriptors
        for library_el in root.getiterator('library'):
            library_path = library_el.attrib['path']

            for class_el in library_el.getiterator('class'):
                # collect common attributes
                attributes = {
                    'package_name': package_name,
                    'plugin_path': os.path.dirname(plugin_xml),
                    'library_path': library_path,
                }

                # add class attributes
                for key, value in class_el.items():
                    attributes['class_' + key] = value

                # skip classes with non-matching _base_class_type
                class_base_class_type = attributes.get('class_base_class_type', None)
                if class_base_class_type != self._base_class_type:
                    continue

                # generate unique identifier
                plugin_id = package_name
                if 'class_name' in attributes:
                    plugin_id = plugin_id + '/' + attributes['class_name']
                attributes['plugin_id'] = plugin_id

                # separate module name and class name
                module_name, class_from_class_type = attributes['class_type'].rsplit('.', 1)
                attributes['module_name'] = module_name
                attributes['class_from_class_type'] = class_from_class_type

                # we can not check if the plugin is available without loading it
                attributes['not_available'] = ''

                plugin_descriptor = PluginDescriptor(plugin_id, attributes)

                # set action attributes (plugin providers might have none)
                action_attributes, groups = self._parse_plugin(class_el)
                if len(action_attributes) > 0:
                    plugin_descriptor.set_action_attributes(
                        action_attributes['label'],
                        action_attributes.get('statustip', None),
                        action_attributes.get('icon', None),
                        action_attributes.get('icontype', None),
                    )
                # add group attributes
                for group in groups:
                    plugin_descriptor.add_group_attributes(
                        group['label'],
                        group.get('statustip', None),
                        group.get('icon', None),
                        group.get('icontype', None),
                    )

                # add plugin_descriptor to list
                plugin_descriptors.append(plugin_descriptor)

        return plugin_descriptors
Example #6
0
    def _parse_plugin_xml(self, plugin_name, xml_file_name):
        plugin_descriptors = []
        plugin_path = os.path.dirname(os.path.abspath(xml_file_name))

        try:
            root = ElementTree.parse(xml_file_name)
        except Exception:
            qCritical(
                'RosPluginProvider._parse_plugin_xml() could not parse "%s" of plugin "%s"'
                % (xml_file_name, plugin_name))
            return plugin_descriptors
        for library_el in root.getiterator('library'):
            library_path = library_el.attrib['path']

            for class_el in library_el.getiterator('class'):
                # collect common attributes
                attributes = {
                    'plugin_name': plugin_name,
                    'plugin_path': plugin_path,
                    'library_path': library_path,
                }

                # add class attributes
                for key, value in class_el.items():
                    attributes['class_' + key] = value

                # skip classes with non-matching _base_class_type
                class_base_class_type = attributes.get('class_base_class_type',
                                                       None)
                if class_base_class_type != self._base_class_type:
                    continue

                # generate unique identifier
                plugin_id = plugin_name
                if 'class_name' in attributes:
                    plugin_id = plugin_id + '/' + attributes['class_name']
                attributes['plugin_id'] = plugin_id

                # base path to look for module
                module_base_path = plugin_path
                if library_path != '':
                    module_base_path = os.path.join(module_base_path,
                                                    library_path)
                attributes['module_base_path'] = module_base_path

                # separate module name and class name
                module_name, class_from_class_type = os.path.split(
                    attributes['class_type'].replace('.', os.sep))
                attributes['module_name'] = module_name.replace(os.sep, '.')
                attributes['class_from_class_type'] = class_from_class_type

                # check if plugin is available
                module_abs_path = os.path.join(module_base_path,
                                               module_name) + '.py'
                attributes[
                    'not_available'] = plugin_name if not os.path.exists(
                        module_abs_path) else ''

                plugin_descriptor = PluginDescriptor(plugin_id, attributes)

                # set action attributes (plugin providers might have none)
                action_attributes, groups = self._parse_plugin(class_el)
                if len(action_attributes) > 0:
                    plugin_descriptor.set_action_attributes(
                        action_attributes['label'],
                        action_attributes.get('statustip', None),
                        action_attributes.get('icon', None),
                        action_attributes.get('icontype', None),
                    )
                # add group attributes
                for group in groups:
                    plugin_descriptor.add_group_attributes(
                        group['label'],
                        group.get('statustip', None),
                        group.get('icon', None),
                        group.get('icontype', None),
                    )

                # add plugin_descriptor to list
                plugin_descriptors.append(plugin_descriptor)

        return plugin_descriptors
class ContainerManager(QObject):
    """Manager of `DockWidgetContainer`s enabling reparenting to stored parent."""
    def __init__(self, root_main_window, parent=None):
        super(ContainerManager, self).__init__(parent)
        self._root_main_window = root_main_window
        self._container_descriptor = PluginDescriptor('__DockWidgetContainer')
        self._container_descriptor.set_action_attributes(
            self.tr('Container'), self.tr('Container for other dock widgets'),
            'folder-new', 'theme')

        self._containers = {}

    def get_root_main_window(self):
        return self._root_main_window

    def get_container_descriptor(self):
        return self._container_descriptor

    def add_to_plugin_menu(self, plugin_menu):
        plugin_menu.add_plugin_prefix(self._container_descriptor)

    def add_container(self, container):
        self._containers[container.serial_number()] = container

    def remove_container(self, container):
        del self._containers[container.serial_number()]

    def get_container(self, serial_number):
        if serial_number in self._containers:
            return self._containers[serial_number]
        return None

    def get_containers(self):
        return self._containers.values()

    def move_container_children_to_parent(self, container):
        floating = container.isFloating()
        for child in container.main_window.children():
            if isinstance(child, DockWidget):
                area = container.main_window.dockWidgetArea(child)
                container.parent().addDockWidget(area, child)
                if floating:
                    child.setFloating(floating)

    def get_container_of_dock_widget(self, dock_widget):
        for container in self._containers.values():
            for child in container.main_window.children():
                if child == dock_widget:
                    return container
        return None

    def restore_state_of_containers(self):
        for container in self._containers.values():
            container.restore_state()

    def event(self, e):
        if e.type() == ReparentEvent.reparent_event_type:
            qDebug('ContainerManager.event() reparent event: new parent=%s' %
                   e.new_parent.objectName())
            floating = e.dock_widget.isFloating()
            pos = e.dock_widget.pos()
            e.new_parent.addDockWidget(Qt.BottomDockWidgetArea, e.dock_widget)
            if floating:
                e.dock_widget.setFloating(floating)
                e.dock_widget.move(pos)
            e.accept()
            return True
        return super(ContainerManager, self).event(e)