---

Avant-propos

• Python - Apprendre ou réviser : Tri d'une liste d'objets selon un attribut.
• Apprendre ou réviser QGraphicsItem.zValue(), QGraphicsItem.setZValue(), QGraphicsView.setDragMode.
• Refactoring : Emploi fréquent, dans la classe UiNode, de l'attribut self.o_node.o_scene. Pour simplifier :
  • Créer dans UiNode.__init__() l'attribut self.o_scene = self.o_node.o_scene
  • Dans tout le code de la classe UiNode, remplacer chaque occurrence de self.o_node.o_scene par self.o_scene.
  • Vérifier que tout continue de fonctionner.

---

• Lors du dernier tuto, la case à cocher On / Off a été ajoutée aux nodes mais n'a pas été mémorisée. Réparons cet oubli.
  La méthode CtrlNode.set_checked() devient :

      def set_checked(self, val):
          self.b_chk = val
          self.b_on = self.b_chk  # Provisoire.
  
          """ Enregistrement. """
          self.od_pkl.write([self.s_id, 'b_chk'], val)
          self.o_scene.o_pkl.backup()
  

  
  Oui mais ... self.b_chk et self.b_on doivent être correctement affectés. Dans CtrlNode.__init__(), ces paramètres deviennent :

          self.b_chk = self.od_pkl.read([self.s_id, 'b_chk'], True)
          self.b_on = self.b_chk  # Provisoire.
  

  
  Oui mais ... Au lancement, la case doit être correctement cochée. Dans UiNode.init_ui(), la section On / Off devient :

          """ On / Off """
          QGraphicsProxyWidget(self).setWidget(self.on_off)
          self.on_off.move(width-10, -4)
          self.on_off.setChecked(self.o_node.b_chk)
  

   

• Vérifier.
  • Ajoutez ce code de mise au point (MAP), provisoire, pour aider à la compréhension du .pkl.
    CtrlScene.setup(), tout à la fin :

            """ MAP ***** MAP ***** MAP ***** MAP ***** MAP ***** MAP ***** """
            self.o_pkl.od_pkl.print()
            """ MAP ***** MAP ***** MAP ***** MAP ***** MAP ***** MAP ***** """
    

---

La déconnexion du timer des fonctions retardées ne se faisait pas systématiquement, provoquant des répétitions inutiles de code.
La méthode utils.py > DateTime.delay() devient :

    def delay(self, client_function, delay=20, *args, **kwargs):
        """ Asynchrone (ne prend pas la main).
        :param client_function: Cette fonction sera exécutée après un délai.
        :param delay: Délai en ms (20ms par défaut).
        :param args: Optionnel. Arguments dans l'appel de la fonction (tuple ou liste).
        :param kwargs: Optionnel. Arguments dans l'appel de la fonction (dictionnaire).
        :return: NA
        """
        key = client_function.__name__
        if key in self.d_tempo:
            try:
                self.d_tempo[key].disconnect()
            except TypeError:
                pass
        else:
            self.d_tempo[key] = QTimer()
            self.d_tempo[key].setSingleShot(True)

        self.d_tempo[key].timeout.connect(lambda: client_function(*args, **kwargs))

        self.d_tempo[key].start(delay)

 

---

Description

1. Ajout de 2 autres nodes dans le code provisoire de CtrlScene.
2. Z-index : lorsque des nodes se chevauchent, passage au 1er plan du node cliqué.
3. Multi-sélection de nodes, pouvant être déplacée à la souris : mémorisation de chaque position dans le pkl.
4. Affichage des paramètres généraux d'un node dans le dockable.
5. Paramètres d'une multi-sélection.
6. Édition, mémorisation et affichage du titre du node.
7. Paramètres spécifiques dans le dockable.

---

• Modifier la méthode provisoire dans CtrlScene pour ajouter 2 nodes.
  CtrlScene.provisoire() :

      def provisoire(self):
          """ Provisoire. Ajout de 3 nodes pour la mise au point. A supprimer après le coding du drag & drop. """
          from nodes.generateurs.signaux import Node
          Node(self, 'Node1')
          from nodes.afficheurs.plot import Node
          Node(self, 'Node2')
          from nodes.indicateurs.macd import Node
          Node(self, 'Node3')
  

  plot.py et macd.py doivent posséder la classe Node (voir signaux.py).

• Modifiez les tailles et les couleurs à votre convenance.
• Vérifiez que les positions ont été correctement mémorisées.

---

• Ajouter du code à la méthode-événement UiNode.mouseReleaseEvent(), pour donner au node un Z-Index supérieur à tous les autres.
  UiNode.mouseReleaseEvent() :

      def mouseReleaseEvent(self, ev):
          super().mouseReleaseEvent(ev)
          """ Demande à la scène d'enregistrer tous les nodes, en cas de multiselection déplacée à la souris.
          - La fonction broadcastée par la scène (à chaque node) est save_pos(), ci-dessus. """
          self.save_pos()
  
          """ Passe au 1er plan. """
          z_max = self.o_scene.get_z_max()
          self.setZValue(z_max + 1)
  

  Oui mais ... la méthode CtrlScene.get_z_max() n'existe pas. Créons-la :

      def get_z_max(self):
          """
          - Code appelant : un node, sur 'mouseReleaseEvent()'.
          - Réaffecte tous les Zindex à partir de 0, retourne le plus grand.
          """
          z_max = -1
          # A coder ...
          return z_max
  

  Il vous appartient de coder cette méthode (voir les prérequis).

---

• La multi-sélection peut être effectuée en cliquant sur chaque node, tout en gardant la touche Ctrl appuyée.

   Plusieurs clics avec la touche Ctrl appuyée.

• On désire aussi faire une multi-sélection par lasso à la souris.

   Cliqué-glissé (lasso) à la souris.

• A vous de coder (voir prérequis). 2 choses : Vous devez trouver le code (une seule ligne) et où le placer.
• Si l'on déplace la sélection, tous les nodes font bloc et se déplacent.
• Oui mais ... il y a un double-bug !
  1. Au relâchement du bouton de la souris (fin du déplacement), seul le node cliqué bénéficie du magnétisme.
  2. Au relancement du programme, on s'aperçoit que seul ce node a eu sa position mémorisée.
• A vous de coder (Indice : il faut demander la propagation au contrôleur-scène CtrlScene).

---

• Lorsqu'on clique n'importe où dans le graphe, la méthode CtrlScene.show_params() doit être appelée.
  La multi-sélection par drag n'est connue qu'au relâchement du bouton gauche de la souris.
  UiView.mouseReleaseEvent() devient :

    def mouseReleaseEvent(self, ev):
        if ev.button() in [Qt.RightButton, Qt.MiddleButton]:
            """ Molette ou bouton droit relâché. """
            self.right_button_released(ev)
        elif ev.button() in [Qt.LeftButton]:
            """ Affichage des paramètres retardé pour laisser le temps à l'UI de s'actualiser. """
            self.dt.delay(self.o_scene.show_params)
        super().mouseReleaseEvent(ev)

 

• La méthode CtrlScene.show_params() doit être complétée pour traiter le cas d'un seul node et celui de la multi-sélection.
  CtrlScene.show_params() :

      def show_params(self):
          """
          Si aucun élément du graphe n'est sélectionné, affiche les paramètres de la vue.
          Si un élémént est sélectionné, affiche les paramètres de cet élément.
          Si plusieurs éléménts sont sélectionnés, affiche une image 'multi-sélection'.
          :return: NA
          """
          l_selected = self.o_gr_scene.selectedItems()
          nb_selected = len(l_selected)
  
          if nb_selected == 0:
              self.o_params.show_params()
          elif nb_selected == 1:
              if l_selected[0].__class__.__name__ == 'UiNode':   # o_gr_node
                  o_node = l_selected[0].o_node
                  o_node.o_params.show_params()
          else:   # > 1
              self.o_params.show_params(b_multi=True)
  

   

• Oui mais ... Si le clic a lieu sur un node, bug ! => CtrlNode n'a pas d'objet o_params -> On l'ajoute.
  - Déclaration. Code de CtrlNode.__init__(), complet :

      def __init__(self, o_scene, s_id):
          self.o_scene = o_scene
          self.s_id = s_id             # Clé d'entrée dans le super-dictionnaire pkl.
          self.od_pkl = self.o_scene.o_pkl.od_pkl
          self.o_gr_node = None
          self.o_params = None
          self.pos = self.od_pkl.read([self.s_id, 'position'], (0, 0))
          self.main_key = f"Paramètres du node '{self.s_id}'"
          self.b_chk = self.od_pkl.read([self.s_id, 'b_chk'], True)
          self.b_on = self.b_chk  # Provisoire.
  

  
  - Instanciation. Code de CtrlNode.setup(), complet :

      def setup(self):
          """ Paramètres. """
          self.o_params = Parameters(self)
  
          """ Code appelant = classe dérivée. """
          self.o_gr_node = UiNode(self)       # Gestion de l'UI (Interface utilisateur) : dessin couleurs, ...
          self.o_scene.o_gr_scene.addItem(self.o_gr_node)     # Incorporation dans la scène.
  

  Ne pas oublier d'importer Parameters !

 

• Oui mais ... o_params a besoin des paramètres par défaut, fournis par CtrlNode.get_default(), qui n'existe pas -> on l'ajoute.
  CtrlNode.get_default() :

      def get_default(self):
          return {
              self.main_key: {
                  'Titre du node': 'Choisir un titre',
              }
          }
  

   

• Maintenant, les paramètres s'affichent correctement.
• Si l'on clique dans la vue, en dehors d'un node, les paramètres de la scène s'affichent.

---

• Si l'on fait une multi-sélection, on obtient une erreur : Parameters.show_params() reçoit le paramètre inconnu b_multi.
• En effet, ce paramètre est un flag qui conditionnera l'affichage d'une image illustrant une multi-sélection. Nous allons réécrire cette méthode.
  Parameters.show_params() :

      def show_params(self, b_multi=False):
          """
          Code appelant : CtrlScene.show_params() - Affichage dans le dockable 'Params'.
          :param b_multi: Conditionne l'affichage d'une image.
          :return: NA.
          """
          """ 1 - Nettoyage de l'arbre des paramètres dans le dockable 'params'. """
          self.clear_params()
  
          """ 2 - Multi-sélection. """
          if b_multi:
              self.multi_selection()
              return
  
          """ 3 - Liste des paramètres 'l_params' créée à partir de od_real et od_default. """
          l_params = self.dic2params()
          try:
              p = Parameter.create(name='params', type='group', children=l_params)    # GroupParameter
          except (Exception,):
              print("Parameters.show_params() :\nLa liste 'l_params' n'est pas conforme.")
              return
  
          """ 4 - Mise en place de la liste des paramètres dans un widget 'ParameterTree'. """
          pt = ParameterTree(showHeader=False)        # ParameterTree
          pt.setParameters(p, showTop=False)          # Titre 'params' masqué.
  
          """ 5 - Affichage à l'écran, en plaçant l'arbre de paramètres dans un layout propre. """
          self.layout.addWidget(pt)
  
          """ 6 - Événement : change() est appelée à chaque modification. """
          p.sigTreeStateChanged.connect(self.change)
  

   

• Oui mais ... on fait appel à la méthode multi_selection(), chargée d'afficher l'image, qui n'existe pas. Créons la.
  Parameters.multi_selection() :

      def multi_selection(self):
          """ Ajoute 2 éléments dans le dockable des paramètres :
              - L'image multi.png, récupérée dans les ressources (voir exemple de code dans fen_mere.py).
              - Le texte "Multi-sélection" en arial 20px, ou à votre convenance.
          """
          # à coder ...
  

  A vous de coder cette méthode.

---

• Sélectionner un node pour afficher ses paramètres. Modifier le titre.
• Oui mais ... cette modification provoque une erreur : la méthode refresh() n'existe pas -> on la crée.
  CtrlNode.refresh() :

      def refresh(self, l_keys):
          """ Titre du node. """
          if l_keys[-1] == 'Titre du node':
              self.o_gr_node.set_title()
  

   

• Oui mais ... cette méthode fait appel à la méthode set_title() qui n'existe pas -> On la crée.
  UiNode.set_title() :

      def set_title(self):
          title = self.o_node.get_param('Titre du node', 'Le titre')
          self.title_item.setPlainText(title)
  

   

• Oui mais ... cette méthode fait appel à la méthode get_param() qui n'existe pas -> On la crée.
  CtrlNode.get_param() :

      def get_param(self, l_keys, v_default=None):
          od_params = Dictionary(self.o_params.od_params[self.main_key])
          return od_params.read(l_keys, v_default)
  

  Ne pas oublier d'importer Dictionary.
• Oui mais ... au lancement, le titre affiché sur les nodes reste "Le titre". C'est normal, il reste à modifier le code qui écrit le titre.
  Dans UiNode.init_ui(), section Titre, remplacez la ligne self.title_item.setPlainText('Le titre') par self.set_title()

UiNode.init_ui(), section Flags, ajoutez cette ligne : 

        self.setToolTip(f"{self.o_node.get_param('Titre du node', 'Le titre')}\n{self.o_node.pos}")

 

---

• Le paramètre "Titre du node" est commun à tous les nodes.
• De plus, chaque node doit ajouter ses propres paramètres.
• Il lui suffit pour celà de surcharger la méthode-parent get_default(). À titre d'exemple, nous allons traiter signaux.py.
• signaux.py > Node.get_default() :

      def get_default(self):
          d_updated = super().get_default().copy()
          d_updated[self.main_key].update({
              'Couleurs': {
                  'Sortie': '#88bbff',
              },
              'Sinus': True,
              'Cosinus': False,
              'Carré': False,
              'Triangle': False,
              'Dent de scie m': False,
              'Dent de scie d': False,
              'Amplitude': 20,
              'Points par période': 100,
          })
          return d_updated
  

   

• Tester : Modifier des valeurs, puis relancer s'assurer qu'elles ont bien été mémorisées dans le .pkl.
• Tester également le retour aux valeurs par défaut, en cliquant sur les petits boutons de droite.

 

 

---

Vérification

---

Snippets

• Plusieurs nodes

---

Bonjour les codeurs !

---