---

Avant-propos

La création de nodes par drag & drop nécessite un réaménagement du code.

• Ajout du paramètre pos à CtrlNode.__init__(), pour placer le centre du nouveau node à la position du drop.
• Ajout des attributs width et height à CtrlNode, pour simplifier le code et les calculs.
• Les conséquences sont les suivantes :
  • Les classes-enfants dérivées de CtrlNode provoquent des erreurs.
  • La méthode CtrlScene.provisoire() provoque des erreurs.
  • Les clés width et height n'ont plus lieu d'exister dans CtrlNode.d_display(), on les supprime.
  • Le calcul des variables width et height dans UiNode.init_ui() est faux.
  • Même problème dans UiNode.boundingRect().

CtrlNode.__init__() (Ajout du paramètre pos et des 2 attributs width et height) :

    def __init__(self, o_scene, s_id, pos):
        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 = pos              # pos = (x, y)
        self.width = 96             # Valeur par défaut.
        self.height = 60            # Valeur par défaut.
        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.

---

CtrlNode.setup() (Prise en compte du nouveau node dropé) :

    def setup(self, child_file):
        """ Code appelant : classe dérivée, on connait donc ses attributs, notamment width et height. """
        """ Paramètres. """
        self.o_params = Parameters(self)

        """ pos_default est utilisée lors de la création du node par drag & drop.
            Le centre du nouveau node apparaît exactement à la position du curseur de la souris. """
        pos_default = self.pos[0] - self.width // 2, self.pos[1] - self.height // 2
        b_drop = self.pos != (0, 0)     # Nouveau node (node dropé).
        self.pos = self.od_pkl.read([self.s_id, 'position'], pos_default)
        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.
        if b_drop:
            """ Cas d'un nouveau node (dropé). On mémorise son path et sa position. """
            path = 'nodes' + child_file.split('nodes')[1].replace('/', '.').replace('\\', '.')[:-3]
            self.od_pkl.write([self.s_id, 'path'], path)
            self.o_gr_node.save_pos()   # Important ! à la fin (contient o_pkl.backup()).

---

CtrlNode.d_display() (Les clés width et height, devenues inutiles, ont été supprimées.):

    @property
    def d_display(self):
        """ Attributs par défaut pouvant être surchargés dans les classes dérivées. """
        return {
            'geometry': {'h_title': 24, 'round': 6},
            'col_pen': {'select': '#ffa637', 'hover': '#888', 'on': "#000", 'off': '#aaaa00'},  # ordre = priorité.
            'col_brush': {'on': "#8888bbcc", 'off': '#cccccccc'},
            'thick_pen': {'hover': 4., 'leave': 2.}
        }

---

Classe-fille dérivée → signaux.py > Node.__init__() (Ajout du paramètre pos et surcharge des 2 attributs width et height):

    def __init__(self, o_scene, s_id, pos):
        super().__init__(o_scene, s_id, pos)
        self.width = 120        # Option provisoire.
        self.height = 100       # Option provisoire.
        self.setup()

Classe-fille dérivée → signaux.py > Node.setup() (Ajout du paramètre "chemin du fichier" child_file) :

    def setup(self, child_file=__file__):
        # Code spécifique ...
        super().setup(child_file)

Faire de même pour les autres classes dérivées (plot, macd, etc). width et height sont facultatifs.

Vérifier les éventuelles surcharges @property d_display() : retirer les clés width et height devenues inutiles, les remplacer par des attributs dans __init__().

---

CtrlScene.provisoire() (Les positions (x, y) ont été ajoutées dans les arguments d'appel) :

    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', (-10, -10))     # La position du centre du node (-10, -10) a été ajoutée.
        from nodes.afficheurs.plot import Node
        Node(self, 'Node2', (10, 10))       # Remarque : La position mémorisée n'est pas celle-ci ...
        from nodes.indicateurs.macd import Node
        Node(self, 'Node3', (30, 30))       # ... mais celle du coin haut-gauche.

---

UiNode.init_ui() (Remplacement des anciens width et height par self.o_node.width et self.o_node.height) :

    def init_ui(self):
        """ Paramètres. """
        h_title, n_round = self.o_node.d_display['geometry']['h_title'], self.o_node.d_display['geometry']['round']

        """ Position. """
        self.setPos(*self.o_node.pos)

        """ Titre. """
        geometry = (0, 0, self.o_node.width, h_title, n_round, n_round)
        self.path_title.setFillRule(Qt.WindingFill)
        self.path_title.addRoundedRect(*geometry)
        self.path_title.addRect(0, h_title - n_round, self.o_node.width, n_round)
        # |_ Enlève les arrondis du bas du titre, pour éviter un effet disgracieux (Commenter cette ligne pour le voir)
        self.title_item.setFont(QFont('Arial', 9))  # Police et taille
        self.title_item.setPos(10, 1)
        self.set_title()

        """ Dessin du node : rectangle aux coins arrondis. """
        self.path_outline.addRoundedRect(0, 0, self.o_node.width, self.o_node.height, n_round, n_round)

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

        """ Flags. """
        self.setFlag(QGraphicsItem.ItemIsMovable)       # Peut être déplacé.
        self.setFlag(QGraphicsItem.ItemIsSelectable)    # Peut être sélectionné.
        self.setAcceptHoverEvents(True)                 # Accepte le survol.
        self.setToolTip(f"{self.o_node.get_param('Titre du node', 'Le titre')}\n{self.o_node.pos}")

        """ Événements. """
        self.on_off.stateChanged.connect(self.o_node.set_checked)

---

UiNode.boundingRect() (Remplacement des anciens width et height par self.o_node.width et self.o_node.height) :

    def boundingRect(self):
        return QRectF(0, 0, self.o_node.width, self.o_node.height).normalized()

---

Vérifier :

• Revoir toutes les classes-filles dérivées de CtrlNode : macd.py, plot.py, signaux.py, etc.
  • @property d_display : Vérifier que les clés width et height ont bien été retirées.
• Lancer l'application : il ne doit y avoir aucune erreur.

---

Description

1. Suppression du code provisoire.
2. Création du node par compilation dynamique.
3. Préparation du drag.
4. Lancement du drag.
5. Réception du drop et création du node.
6. Suppression de nodes.

---

• La méthode CtrlScene.provisoire() nous a permis d'amorcer la création des nodes au démarrage du programme.
• Elle va être supprimée au profit de l'algorithme suivant :
  • Parcours du super-dictionnaire od_pkl pour rechercher les nodes.
  • Pour chacun d'entre-eux, récupérer sa clé et son path sur disque dur.
  • Utiliser ces 2 données (clé et path) pour instancier le node par compilation dynamique.
• Oui mais ... en examinant od_pkl, on remarque que le path n'existe pas. Exemple de path : nodes.generateurs.signaux
• Le path n'existant pas, l'instanciation est impossible. Nous allons donc demander à la méthode provisoire de l'ajouter.
• Après cet ajout et vérification, nous pourrons enfin :
  • Remplacer l'appel self.provisoire() par self.show_nodes(), à la fin du setup().
  • Supprimer la méthode provisoire.
  • Créer la méthode show_nodes() chargée d'exécuter l'algorithme.
     

• Pour repartir à blanc, supprimez tous les fichiers params.pkl des sous-dossiers de /backups/
• Vérifiez (avec self.o_pkl.od_pkl.print()) - Le contenu minimum de od_pkl doit être :

Node1: ----------------------------------------------------- <class 'dict'>
    path: nodes.generateurs.signaux ------------------------ <class 'str'>
    position: (-70.0, -60.0) ------------------------------- <class 'tuple'>
Node2: ----------------------------------------------------- <class 'dict'>
    path: nodes.afficheurs.plot ---------------------------- <class 'str'>
    position: (-50.0, -30.0) ------------------------------- <class 'tuple'>
Node3: ----------------------------------------------------- <class 'dict'>
    path: nodes.indicateurs.macd --------------------------- <class 'str'>
    position: (-18.0, 0.0) --------------------------------- <class 'tuple'>

 

• Supprimez la méthode CtrlScene.provisoire().
• Dans CtrlScene.setup(), remplacez l'appel self.provisoire() par self.show_nodes().
• Créez la méthode CtrlScene.show_nodes() :

      def show_nodes(self):
          """ Parcours des grappes (depth = 0) du dictionnaire pkl du graphe de cette scène.
              Recherche de celles correspondant à un node :
                  |_ La clé (s_id) doit être 'Node12' par exemple, la valeur (d_node) doit être un dictionnaire.
                  |_ Le dictionnaire 'd_node' doit contenir la clé 'path'
          """
          for s_id, d_node in self.o_pkl.od_pkl.items():
              """ On s'assure qu'il s'agit bien d'un node et que les données sont conformes. """
              if s_id[:4] == 'Node' and s_id[4:].isnumeric() and isinstance(d_node, dict) and 'path' in d_node:
                  path = d_node['path']
                  self.compile_node(s_id, path)
  

Oui mais ... pour chaque node, la méthode show_nodes() délègue la compilation dynamique à la méthode compile_node(), qui nexiste pas !

---

• Création de la méthode CtrlScene.compile_node() :

    def compile_node(self, s_id, path, pos=(0, 0)):
        """
        :param s_id: Clé à la racine du super-dictionnaire od_pkl. Exemple : 'Node7'
        :param path: Chemin sur disque dur au format des imports. Exemple : 'nodes.indicateurs.macd'
        :param pos: tuple. (0, 0) lors du setup (lecture du pkl), (pos_x, pos_y) si appel suite au drag & drop.
        :return: Objet o_node si réussite, None si échec.
        """
        d_context = {'o_scene': self, 's_id': s_id, 'pos': pos}  # Définit 'o_scene', 's_id' et 'pos' dans le contexte.
        code = f"from {path} import Node; o_node=Node(o_scene, s_id, pos=pos)"        # Ajoute o_node dans le contexte.
        # à coder
        return o_node

• Lancez les TDD (à la fin du tuto) pour coder ces méthodes.

Bon coding !

---

• Dans le tuto Peuplement des nodes, nous avions codé la méthode dock_nodes.py > GroupNodes.populate_tab() qui permet l'affichage d'icones dans le dockable des nodes, représentatives des nodes disponibles.
• Nous allons utiliser l'objet item, créé dans cette méthode, pour initier le drag, en lui ajoutant 2 données :
  • L'icone, car on désire l'afficher sous la souris lors du drag.
  • Le path du fichier, nécessaire pour la compilation dynamique au moment du drop.

La méthode GroupNodes.populate_tab() modifiée devient :

    def populate_tab(self, ld_datas):
        """
        Affichage des icones et de leur libellé à partir de la liste 'self.ld_datas'.
        :param ld_datas: Liste de dictionnaires : un par node, contenant le nom de l'icone et de son libellé.
        :return: NA
        """
        for d_datas in ld_datas:
            """ Chaque item contient des informations : icône, libellé, flags, datas """
            name = d_datas['name']
            icon = self.path_name + d_datas['icon']
            item = QListWidgetItem(name, self)
            icon = QPixmap(icon)
            item.setIcon(QIcon(icon))

            """ Ajout d'informations, pour le drag. """
            item.setData(Qt.UserRole, icon)                     # Affichage de l'icone sous la souris pendant le drag.
            item.setData(Qt.UserRole + 1, d_datas['path'])      # Nécéssaire pour la compilation, lancée par le drop.

Inutile de préciser qu'il faut importer Qt 😁 !

• Oui mais ... il y a une erreur : le dictionnaire d_datas (dernière ligne), ne contient pas la clé path.
• Il faut donc remonter au code de ld_datas, c'est à dire get_datas(), pour ajouter cette info.
  GroupNodes.get_datas() :

      def get_datas(self):
          """ 1 - Liste de tous les fichiers .py du sous-dossier => py_files
              2 - Seuls les fichiers qui possèdent un dictionnaire 'd_datas' sont candidats.
              3 - Création d'une liste de ces dictionnaires => ld_datas
          :return: Liste de dictionnaires de datas 'ld_datas'
          """
          ld_datas = list()       # ld_ = Liste de dictionnaires.
          if not os.path.isdir(self.path_name):
              return list()           # Si le dossier n'existe pas => onglet vide.
          l_files = next(os.walk(self.path_name))[2]
          py_files = [py_file[:-3] for py_file in l_files if os.path.splitext(py_file)[-1].lower() == '.py']
          for py_file in py_files:
              code = f"from nodes.{self.dir_name}.{py_file} import d_datas"
              try:
                  """ Compilation dynamique. """
                  eval(compile(code, '<string>', 'exec'), globals(), globals())
                  d_datas['path'] = f'nodes.{self.dir_name}.{py_file}'
                  ld_datas.append(d_datas)      # Si souligné rouge -> Mark all unresolved attributes ...
              except (Exception,):
                  continue
          return ld_datas
  

  Notez la ligne ajoutée : d_datas['path'] = f'nodes.{self.dir_name}.{py_file}'

• Tester : pas d'erreurs.

---

1. Le lancement du drag est capturé par un événement qui appelle la méthode des QWidgets nommée startDrag().
2. On surcharge cette méthode.
3. On récupère dans ce code les infos précédemment ajoutées (icon et path)
4. On utilise un QDataStream() comme moyen pour transporter ces données (sérialisées).
5. Le nom de ce "transporteur" est arbitraire. Choisissons "my_robot". Il est nécessaire pour le reconnaître à l'arrivée (au drop).
6. On charge l'icone pour l'afficher : drag.setPixmap(icon)
7. On lance le drag : drag.exec_(Qt.MoveAction)
    

GroupNodes.startDrag() :

    def startDrag(self, *args, **kwargs):
        """ Appelée automatiquement dès qu'un drag est amorcé dans la dock-nodes.
        - Les infos ajoutées dans populate_tab() seront récupérés par le destinaire du drop.
        """
        mime_data = QMimeData()     # Enregistre les données au format voulu (ici : 'my_robot')
        item = self.currentItem()
        item_data = QByteArray()

        """ Datas """
        icon = item.data(Qt.UserRole)
        path = item.data(Qt.UserRole + 1)

        data_stream = QDataStream(item_data, QIODevice.WriteOnly)     # Sérialisation.
        data_stream << icon               # Sérialisation de l'image.
        data_stream.writeQString(path)
        mime_data.setData('my_robot', item_data)

        drag = QDrag(self)          # Prend en charge le transport des données {mime_data}.
        drag.setMimeData(mime_data)
        drag.setHotSpot(QPoint(icon.width() // 2, icon.height() // 2))  # Curseur centré sur l'icone.
        drag.setPixmap(icon)
        drag.exec_(Qt.MoveAction)

        super().startDrag(*args, **kwargs)

On ne dit plus qu'il faut importer les classes soulignées ... on ne le dit plus 😉 !

Vérifier : Lancer un drag ⇒ L'icone apparaît sous la souris.

---

• Le drag se déplace de l'expéditeur (source = dockable des nodes) vers le destinataire (cible = vue).
• L'entrée dans la cible est un événement qui appelle la méthode dragMoveEvent().
• Nous allons la surcharger.
• La cible est la vue. Par conséquent, ajout de la méthode UiView.dragMoveEvent() :

      def dragMoveEvent(self, ev):
          ev.acceptProposedAction()
  

  Acceptation du drag.

• Le drop sur la cible est un événement qui appelle la méthode dropEvent().
• Nous allons la surcharger.
  Ajout de la méthode UiView.dropEvent() :

      def dropEvent(self, ev):
          md = ev.mimeData()
          if not md.hasFormat('my_robot'):
              return
  
          event_data = md.data('my_robot')
          data_stream = QDataStream(event_data, QIODevice.ReadOnly)
          data_stream >> QPixmap()
          path = data_stream.readQString()
  
          mouse_pos = ev.pos()
          scene_pos = self.mapToScene(mouse_pos)  # Conversion entre repères scène et vue.
          pos_new_node = scene_pos.x(), scene_pos.y()
  
          self.o_scene.new_node(path, pos_new_node)
  

   

• En dernière ligne, la création du node est déléguée à la scène. La méthode new_node() n'existe pas.

• Créons la. CtrlScene.newNode() :

      def new_node(self, path, pos_node):
          """ Recherche du s_id, compile, sélectionne puis affiche les paramètres. """
          s_id = self.get_new_sid()                          # Recherche du premier s_id disponible.
          o_node = self.compile_node(s_id, path, pos_node)    # Compilation dynamique.
          if o_node is not None:
              for item in self.o_gr_scene.items():
                  item.setSelected(False)                     # Désélection de tous les items de la scène.
              o_node.o_gr_node.setSelected(True)              # Sélection du nouveau node.
              self.show_params()                              # Affichage des paramètres par défaut.
  

   

• Cette méthode appelle la compilation dynamique que nous avons déjà codé.
  Oui mais ... elle a besoin de lui transmettre l'identifiant du node s_id, fourni par la méthode get_new_sid() qui nexiste pas.
  Créons la. CtrlScene.get_new_sid() :

      def get_new_sid(self):
          """ La liste des nodes, fournie par get_gr_nodes(), doit être triée. """
          l_gr_nodes = self.get_gr_nodes()
          new_id = len(l_gr_nodes)
          for k, o_gr_node in enumerate(l_gr_nodes):
              node_id = int(o_gr_node.s_id[4:])
              if k < node_id:
                  new_id = k
                  break
          return f'Node{new_id}'
  

   

• Oui mais ... cette méthode utilise la liste des nodes existants, triée sur l'indice de leur s_id.

• Or la méthode CtrlScene.get_gr_nodes() fournit cette liste, mais non triée.
• Par conséquent, nous allons la modifier afin d'obtenir une liste triée. En fait seule sa dernière ligne est modifiée.
  
  CtrlScene.get_gr_nodes() :

      def get_gr_nodes(self):
          """ Renvoie la liste de tous les o_gr_nodes contenus dans la scène, triée sur l'indice du s_id.
              Important : le tri est effectué sur l'indice du s_id (int) et non sur le s_id (str).
              Exemple : alphabétiquement, 'Node2' vient après 'Node14', numériquement, il vient avant. """
          l_items = self.o_gr_scene.items()
          l_gr_nodes = list()
          for o_gr_node in l_items:
              if o_gr_node.__class__.__name__ == 'UiNode':
                  l_gr_nodes.append(o_gr_node)
          # à coder ... -> Retourne la liste 'l_gr_nodes', triée.
  

Bon coding !

• Tester : Cela ne fonctionne que sur les modules de nodes que nous avons codé, à savoir : signaux.py, plot.py et macd.py.
• Coder les autres modules de nodes.
• Tester : Tout doit fonctionner.

---

• Nous choisissons de supprimer les éléments sélectionnés, par l'appui sur la touche Suppr du clavier.
• L'événement provoqué par une touche du clavier appelle les méthodes keyPressEvent() puis keyReleaseEvent().
  Nous allons surcharger la méthode UiView.keyReleaseEvent() :

      def keyReleaseEvent(self, ev):
          super().keyReleaseEvent(ev)
          key = ev.key()
          if key == Qt.Key_Delete:
              self.o_scene.delete_items()
  

   

• Oui mais ... nous voyons que l'action est déléguée à la méthode delete_items() de la scène, qui n'existe pas. Créons la.
  CtrlScene.delete_items() :

      def delete_items(self):
          """ Les items sont les nodes, les liens et autres widgets de la scène. """
          selected = self.o_gr_scene.selectedItems()
          l_gr_nodes = list()
          for sel in selected:
              if sel.__class__.__name__ == 'UiNode':
                  l_gr_nodes.append(sel)
  
          nb_nodes = len(l_gr_nodes)
          if nb_nodes == 0:
              return
          elif nb_nodes == 1:
              msg = "Vous êtes sur le point de supprimer un node.\nAcceptez-vous ?"
          else:
              msg = f"Vous êtes sur le point de supprimer {nb_nodes} nodes.\nAcceptez-vous ?"
          if ut.msg_yesno('Confirmation', msg, self):
              for o_gr_node in l_gr_nodes:
                  self.remove_node(o_gr_node)
              self.o_pkl.backup()
              self.show_params()
  

   

• Oui mais ... la boite de dialogue msg_yesno n'existe pas.

• Or, nous serons amenés à utiliser des boîtes de dialogue tout au long de  ce cours.
  A la fin de la classe Utils, ajouter ces 3 méthodes.
  utils.py > Utils :

      # **********************************************************
      # Messages Messages Messages Messages Messages Messages    *
      # **********************************************************
      @staticmethod
      def msg_info(title, msg, parent=None, sound=True, typed='info'):
          """
          Si parent == None => Affichage au milieu de l'écran.
              |_ Si parent est l'objet-widget appelant => Affichage au centre de sa fenêtre.
          """
          if sound:
              winsound.MessageBeep()  # winsound.MB_ICONASTERISK)
          if typed == 'info':
              QMessageBox.information(parent, title, msg)
          elif typed == 'error':
              QMessageBox.critical(parent, title, msg)
          elif typed == 'yesno':
              response = QMessageBox.question(parent, title, msg, QMessageBox.Yes, QMessageBox.No)
              return response == QMessageBox.Yes  # True si oui.
  
      def msg_error(self, title, msg, parent=None, sound=True):
          self.msg_info(title, msg, parent, sound, 'error')
  
      def msg_yesno(self, title, msg, parent=None, sound=True):
          return self.msg_info(title, msg, parent, sound, 'yesno')
  

   

• Mais aussi ... pour chacun des noeuds sélectionnés, la méthode remove_node() est appelée. Cette méthode n'existe pas.

• Créons-la. CtrlScene.remove_node() :

      def remove_node(self, o_gr_node):
          self.o_pkl.od_pkl.delete(o_gr_node.s_id)
          self.o_gr_scene.removeItem(o_gr_node)
  

• Vérifier.

---

Vérification

---

Snippets

• Compilation dynamique d'un node

---

Bonjour les codeurs !

---