示例#1
0
    def connect(cls, controller_widget, control_name, control_instance):
        """ Connect a 'File' controller trait and a 'FileControlWidget'
        controller widget control.

        Parameters
        ----------
        cls: FileControlWidget (mandatory)
            a StrControlWidget control
        controller_widget: ControllerWidget (mandatory)
            a controller widget that contains the controller we want to update
        control_name: str (mandatory)
            the name of the controller widget control we want to synchronize
            with the controller
        control_instance: QWidget (mandatory)
            the instance of the controller widget control we want to
            synchronize with the controller
        """
        # Check if the control is connected
        if not control_instance.connected:

            # Update one element of the controller.
            # Hook: function that will be called to update a specific
            # controller trait when a 'userModification' qt signal is emited
            widget_hook = partial(cls.update_controller,
                                  weak_proxy(controller_widget), control_name,
                                  weak_proxy(control_instance), False)

            # When a qt 'userModification' signal is emited, update the
            # 'control_name' controller trait value
            control_instance.path.userModification.connect(widget_hook)

            widget_hook2 = partial(cls.update_controller,
                                   weak_proxy(controller_widget), control_name,
                                   weak_proxy(control_instance), True)

            control_instance.path.editingFinished.connect(widget_hook2)

            # Update the control.
            # Hook: function that will be called to update the control value
            # when the 'control_name' controller trait is modified.
            controller_hook = SomaPartial(cls.update_controller_widget,
                                          weak_proxy(controller_widget),
                                          control_name,
                                          weak_proxy(control_instance))

            # When the 'control_name' controller trait value is modified,
            # update the corresponding control
            controller_widget.controller.on_trait_change(controller_hook,
                                                         name=control_name,
                                                         dispatch='ui')

            # Store the trait - control connection we just build
            control_instance._controller_connections = (widget_hook,
                                                        widget_hook2,
                                                        controller_hook)
            logger.debug("Add 'File' connection: {0}.".format(
                control_instance._controller_connections))

            # Update the control connection status
            control_instance.connected = True
示例#2
0
    def connect(cls, controller_widget, control_name, control_instance):
        """ Connect an 'Enum' controller trait and an 'EnumControlWidget'
        controller widget control.

        Parameters
        ----------
        cls: EnumControlWidget (mandatory)
            an EnumControlWidget control
        controller_widget: ControllerWidget (mandatory)
            a controller widget that contains the controller we want to update
        control_name: str (mandatory)
            the name of the controller widget control we want to synchronize
            with the controller
        control_instance: QComboBox (mandatory)
            the instance of the controller widget control we want to
            synchronize with the controller
        """
        # Update one element of the controller widget.
        # Hook: function that will be called to update the specific widget
        # when a trait event is detected.
        controller_hook = SomaPartial(cls.update_controller_widget,
                                      weak_proxy(controller_widget),
                                      control_name,
                                      weak_proxy(control_instance))

        # When the 'control_name' controller trait value is modified, update
        # the corresponding control
        controller_widget.controller.on_trait_change(controller_hook,
                                                     name=control_name,
                                                     dispatch='ui')

        # Store the trait - control connection we just build
        control_instance._controller_connections = (controller_hook, )
        logger.debug("Add 'Compound' connection: {0} / {1}".format(
            control_name, control_instance))
示例#3
0
 def __setstate__(self, state):
     """ Restore the callbacks that have been removed by __getstate__.
     """
     state['_callbacks'] = dict((i, SomaPartial(self._value_callback, *i))
                                for i in state['_callbacks'])
     super(Node, self).__setstate__(state)
     for callback_key, value_callback in six.iteritems(self._callbacks):
         self.set_callback_on_plug(callback_key[0], value_callback)
示例#4
0
    def connect(self, source_plug_name, dest_node, dest_plug_name):
        """ Connect linked plugs of two nodes

        Parameters
        ----------
        source_plug_name: str (mandatory)
            the source plug name
        dest_node: Node (mandatory)
            the destination node
        dest_plug_name: str (mandatory)
            the destination plug name
        """
        # add a callback to spread the source plug value
        value_callback = SomaPartial(self.__class__._value_callback,
                                     weak_proxy(self), source_plug_name,
                                     weak_proxy(dest_node), dest_plug_name)
        self._callbacks[(source_plug_name, dest_node,
                         dest_plug_name)] = value_callback
        self.set_callback_on_plug(source_plug_name, value_callback)
示例#5
0
    def connect(cls, controller_widget, control_name, control_instance):
        """ Connect a 'List' controller trait and a 'DictControlWidget'
        controller widget control.

        Parameters
        ----------
        cls: StrControlWidget (mandatory)
            a StrControlWidget control
        controller_widget: ControllerWidget (mandatory)
            a controller widget that contains the controller we want to update
        control_name: str (mandatory)
            the name of the controller widget control we want to synchronize
            with the controller
        control_instance: QFrame (mandatory)
            the instance of the controller widget control we want to
            synchronize with the controller
        """
        # Check if the control is connected
        if not control_instance.connected:

            # Update the dict item when one of his associated controller trait
            # changed.
            # Hook: function that will be called to update the controller
            # associated with a dict widget when a dict widget inner controller
            # trait is modified.
            dict_controller_hook = SomaPartial(
                cls.update_controller, weak_proxy(controller_widget),
                control_name, weak_proxy(control_instance))

            # Go through all dict widget inner controller user traits
            for trait_name in control_instance.controller.user_traits():

                # And add the callback on each user trait
                control_instance.controller.on_trait_change(
                    dict_controller_hook, trait_name)
                logger.debug("Item '{0}' of a 'DictControlWidget', add "
                             "a callback on inner controller trait "
                             "'{0}'.".format(control_name, trait_name))

            # Update the dict controller widget.
            # Hook: function that will be called to update the specific widget
            # when a trait event is detected on the dict controller.
            controller_hook = SomaPartial(
                cls.update_controller_widget, weak_proxy(controller_widget),
                control_name, weak_proxy(control_instance))

            # When the 'control_name' controller trait value is modified,
            # update the corresponding control
            controller_widget.controller.on_trait_change(
                controller_hook, control_name, dispatch='ui')

            # Update the dict connection status
            control_instance._controller_connections = (
                dict_controller_hook, controller_hook)
            logger.debug("Add 'Dict' connection: {0}.".format(
                control_instance._controller_connections))

            # Connect also all dict items
            inner_controls = control_instance.controller_widget._controls
            for (inner_control_name,
                 inner_control_groups) in six.iteritems(inner_controls):
                for group, inner_control \
                        in six.iteritems(inner_control_groups):

                    # Unpack the control item
                    inner_control_instance = inner_control[2]
                    inner_control_class = inner_control[1]

                    # Call the inner control connect method
                    inner_control_class.connect(
                        control_instance.controller_widget, inner_control_name,
                        inner_control_instance)

            # Update the dict control connection status
            control_instance.connected = True
示例#6
0
    def connect(cls, controller_widget, control_name, control_instance):
        """ Connect a 'List' controller trait and an
        'OffscreenListControlWidget' controller widget control.

        Parameters
        ----------
        cls: StrControlWidget (mandatory)
            a StrControlWidget control
        controller_widget: ControllerWidget (mandatory)
            a controller widget that contains the controller we want to update
        control_name: str (mandatory)
            the name of the controller widget control we want to synchronize
            with the controller
        control_instance: QFrame (mandatory)
            the instance of the controller widget control we want to
            synchronize with the controller
        """
        # Check if the control is connected
        if not control_instance.connected:

            # Update the list item when one of his associated controller trait
            # changed.
            # Hook: function that will be called to update the controller
            # associated with a list widget when a list widget inner controller
            # trait is modified.
            list_controller_hook = SomaPartial(cls.update_controller,
                                               weak_proxy(controller_widget),
                                               control_name,
                                               weak_proxy(control_instance))

            # Go through all list widget inner controller user traits
            for trait_name in control_instance.controller.user_traits():

                # And add the callback on each user trait
                control_instance.controller.on_trait_change(
                    list_controller_hook, trait_name, dispatch='ui')
                logger.debug("Item '{0}' of a 'ListControlWidget', add "
                             "a callback on inner controller trait "
                             "'{0}'.".format(control_name, trait_name))

            # Update the list controller widget.
            # Hook: function that will be called to update the specific widget
            # when a trait event is detected on the list controller.
            controller_hook = SomaPartial(cls.update_controller_widget,
                                          weak_proxy(controller_widget),
                                          control_name,
                                          weak_proxy(control_instance))

            # When the 'control_name' controller trait value is modified,
            # update the corresponding control
            controller_widget.controller.on_trait_change(controller_hook,
                                                         control_name,
                                                         dispatch='ui')

            # Update the list connection status
            control_instance._controller_connections = (list_controller_hook,
                                                        controller_hook)
            logger.debug("Add 'List' connection: {0}.".format(
                control_instance._controller_connections))

            # Update the list control connection status
            control_instance.connected = True