Après avoir appris à créer un projet Zero-Touch, nous pouvons approfondir les spécificités de la création d’un nœud en parcourant l’exemple ZeroTouchEssentials sur Dynamo Github.

De nombreux nœuds standard de Dynamo sont essentiellement des nœuds Zero-Touch, comme la plupart des nœuds Math, Color et DateTime ci-dessus.

Pour commencer, téléchargez le projet ZeroTouchEssentials à partir de l’emplacement suivant : https://github.com/DynamoDS/ZeroTouchEssentials

Dans Visual Studio, ouvrez le fichier solution ZeroTouchEssentials.sln et générez la solution.

Le fichier ZeroTouchEssentials.cs contient toutes les méthodes que vous allez importer dans Dynamo.

Ouvrez Dynamo et importez le ZeroTouchEssentials.dll pour obtenir les nœuds que vous allez référencer dans les exemples suivants.

Les exemples de code sont tirés de ZeroTouchEssentials.cs et correspondent généralement à ce dernier. La documentation XML a été supprimée pour préserver la concision, et chaque exemple de code créera le nœud figurant dans l’image ci-dessus.

Valeur d’entrée par défaut

Dynamo prend en charge la définition de valeurs par défaut pour les ports d’entrée d’un nœud. Ces valeurs par défaut seront fournies au nœud si les ports ne sont pas connectés. Les valeurs par défaut sont exprimées à l’aide du mécanisme C# qui spécifie les arguments facultatifs dans le Guide de programmation C#. Les valeurs par défaut sont spécifiées de la manière suivante :

• Définissez les paramètres de la méthode à une valeur par défaut : inputNumber = 2.0

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // Set the method parameter to a default value
        public static double MultiplyByTwo(double inputNumber = 2.0) 
        {
            return inputNumber * 2.0;
        }
    }
}

1. La valeur par défaut s’affiche lorsque vous passez le curseur sur le port d’entrée du nœud.

Renvoyer plusieurs valeurs

Le renvoi de plusieurs valeurs est un peu plus complexe que la création de plusieurs entrées et devra être renvoyé à l’aide d’un dictionnaire. Les entrées du dictionnaire deviennent des ports sur le côté sortie du nœud. Les ports de retour multiples peuvent être créés de la manière suivante :

• ajoutez using System.Collections.Generic; pour utiliser Dictionary<> ;

• ajoutez using Autodesk.DesignScript.Runtime; pour utiliser l’attribut MultiReturn. Cela fait référence à « DynamoServices.dll » du package DynamoServices NuGet ;

• ajoutez l’attribut [MultiReturn(new[] { "string1", "string2", ... more strings here })] à la méthode. Les chaînes font référence aux clés du dictionnaire et deviendront les noms des ports de sortie ;

• renvoyez un Dictionary<> de la fonction dont les clés correspondent aux noms des paramètres dans l’attribut : return new Dictionary<string, object>.

using System.Collections.Generic;
using Autodesk.DesignScript.Runtime;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        [MultiReturn(new[] { "add", "mult" })]
        public static Dictionary<string, object> ReturnMultiExample(double a, double b)
        {
            return new Dictionary<string, object>

                { "add", (a + b) },
                { "mult", (a * b) }
            };
        }
    }
}

Référez-vous à cet exemple de code dans ZeroTouchEssentials.cs

Un nœud qui renvoie plusieurs sorties.

1. Notez que deux ports de sortie sont désormais nommés en fonction des chaînes que nous avons saisies pour les clés du dictionnaire.

Documentation, info-bulles et recherche

Il est recommandé d’ajouter de la documentation aux nœuds Dynamo pour décrire la fonction du nœud, les entrées, les sorties, les balises de recherche, etc. Cela se fait par le biais de balises de documentation XML. Pour créer de la documentation XML, procédez de la manière suivante :

• tout texte de commentaire précédé de trois barres obliques est considéré comme de la documentation ;

  • par exemple : /// Documentation text and XML goes here

• après les trois barres obliques, créez des balises XML au-dessus des méthodes que Dynamo lira lors de l’importation du fichier .dll ;

  • par exemple : /// <summary>...</summary>

• activez la documentation XML dans Visual Studio en sélectionnant Project > Project Properties > Build et en cochant la case XML documentation file.

1. Visual Studio générera un fichier XML à l’emplacement spécifié.

Les types de balises sont les suivants :

• /// <summary>...</summary> est la documentation principale de votre nœud et apparaît sous forme d’infobulle au-dessus de votre nœud dans la barre latérale de recherche gauche ;

• /// <param name="inputName">...</param> créera une documentation pour des paramètres d’entrée spécifiques ;

• /// <returns>...</returns> créera une documentation pour un paramètre de sortie ;

• /// <returns name = "outputName">...</returns> créera une documentation pour plusieurs paramètres de sortie ;

• /// <search>...</search> fera correspondre votre nœud à des résultats de recherche basés sur une liste séparée par des virgules. Par exemple, si nous créons un nœud qui subdivise un maillage, nous pouvons ajouter des balises telles que « maillage », « subdivision » et « catmull-clark ».

L’exemple suivant présente un nœud avec des descriptions d’entrée et de sortie, ainsi qu’un résumé qui s’affichera dans la bibliothèque.

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        /// <summary>
        /// This method demonstrates how to use a native geometry object from Dynamo
        /// in a custom method
        /// </summary>
        /// <param name="curve">Input Curve. This can be of any type deriving from Curve, such as NurbsCurve, Arc, Circle, etc</param>
        /// <returns>The twice the length of the Curve </returns>
        /// <search>example,curve</search>
        public static double DoubleLength(Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

Reportez-vous à cet exemple de code dans ZeroTouchEssentials.cs.

Notez que le code de cet exemple de nœud contient :

1. un résumé du nœud ;

2. une description d’entrée ;

3. une description de sortie.

Objets

Dynamo ne possède pas de mot-clé new, les objets doivent donc être construits à l’aide de méthodes de construction statiques. Les objets sont construits de la façon suivante :

• rendez le constructeur interne internal ZeroTouchEssentials() à moins de devoir le faire autrement ;

• construisez l’objet avec une méthode statique telle que public static ZeroTouchEssentials ByTwoDoubles(a, b).

Remarque : Dynamo utilise le préfixe « By » pour indiquer qu’une méthode statique est un constructeur, et bien que cela soit optionnel, l’utilisation de « By » aidera votre bibliothèque à mieux s’adapter au style existant de Dynamo.

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        private double _a;
        private double _b;

        // Make the constructor internal
        internal ZeroTouchEssentials(double a, double b)
        {
            _a = a;
            _b = b;
        }

        // The static method that Dynamo will convert into a Create node
        public static ZeroTouchEssentials ByTwoDoubles(double a, double b)
        {
            return new ZeroTouchEssentials(a, b);
        }
    }
}

Reportez-vous à cet exemple de code dans ZeroTouchEssentials.cs.

Une fois que le .dll ZeroTouchEssentials a été importé, un nœud ZeroTouchEssentials sera présent dans la bibliothèque. Cet objet peut être créé en utilisant le nœud ByTwoDoubles.

Utiliser des types de géométrie Dynamo

Les bibliothèques Dynamo peuvent utiliser les types de géométrie Dynamo en entrée et créer de nouvelles géométries en sortie. Les types de géométrie sont créés de la manière suivante :

• Référencez « ProtoGeometry.dll » dans le projet en incluant using Autodesk.DesignScript.Geometry; au début de votre fichier C# et en ajoutant le package NuGet ZeroTouchLibrary au projet.

• Important : gérez les ressources de géométrie qui ne sont pas renvoyées par vos fonctions. Reportez-vous à la section Instructions using/dispose ci-dessous.

Remarque : les objets de géométrie Dynamo sont utilisés comme tout autre objet transmis aux fonctions.

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // "Autodesk.DesignScript.Geometry.Curve" is specifying the type of geometry input, 
        // just as you would specify a double, string, or integer 
        public static double DoubleLength(Autodesk.DesignScript.Geometry.Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

Reportez-vous à cet exemple de code dans ZeroTouchEssentials.cs.

Un nœud qui obtient la longueur d’une courbe et la double.

1. Ce nœud accepte un type de géométrie Courbe comme entrée.

Instructions using/dispose

Les ressources de géométrie qui ne sont pas renvoyées par les fonctions devront être gérées manuellement à moins que vous n’utilisiez Dynamo version 2.5 ou ultérieure. Dans Dynamo 2.5 et versions ultérieures, les ressources de géométrie sont gérées en interne par le système. Toutefois, vous devrez peut-être supprimer la géométrie manuellement si vous avez un cas d’utilisation complexe ou si vous devez réduire la mémoire à un moment précis. Le moteur Dynamo traitera toutes les ressources de géométrie qui sont renvoyées par des fonctions. Les ressources de géométrie qui ne sont pas renvoyées peuvent être traitées manuellement de l’une des manières suivantes :

• Avec une instruction using :

  Copy

  using (Point p1 = Point.ByCoordinates(0, 0, 0))
  {
    using (Point p2 = Point.ByCoordinates(10, 10, 0))
    {
        return Line.ByStartPointEndPoint(p1, p2);
    }
  }

  L’instruction using est décrite ici.

  Reportez-vous à la rubrique Améliorations apportées à la stabilité de la géométrie Dynamo pour en savoir plus sur les nouvelles fonctions de stabilité introduites dans Dynamo 2.5.

• Avec les appels dispose manuels :

  Copy

  Point p1 = Point.ByCoordinates(0, 0, 0);
  Point p2 = Point.ByCoordinates(10, 10, 0);
  Line l = Line.ByStartPointEndPoint(p1, p2);
  p1.Dispose();
  p2.Dispose();
  return l;

Migrations

Lors de la publication d’une nouvelle version d’une bibliothèque, les noms des nœuds peuvent changer. Les changements de nom peuvent être spécifiés dans un fichier migrations afin que les graphiques générés sur des versions antérieures d’une bibliothèque continuent à fonctionner correctement lorsqu’une mise à jour est effectuée. Les migrations sont implémentées de la manière suivante :

• créez un fichier .xml dans le même dossier que le .dll au format suivant : « BaseDLLName ».Migrations.xml ;

• dans le .xml, créez un seul élément <migrations>...</migrations> ;

• dans l’élément migrations, créez <priorNameHint>...</priorNameHint> éléments pour chaque changement de nom ;

• pour chaque changement de nom, fournissez un élément <oldName>...</oldName> et <newName>...</newName>.

1. Cliquez avec le bouton droit de la souris et sélectionnez Add > New Item

2. Choisissez XML File

3. Pour ce projet, nous nommerons le fichier migrations ZeroTouchEssentials.Migrations.xml

Cet exemple de code indique à Dynamo que tout nœud nommé GetClosestPoint est désormais nommé ClosestPointTo.

<?xml version="1.0"?>
<migrations>
  <priorNameHint>
    <oldName>Autodesk.DesignScript.Geometry.Geometry.GetClosestPoint</oldName>
    <newName>Autodesk.DesignScript.Geometry.Geometry.ClosestPointTo</newName>
  </priorNameHint>
</migrations>

Reportez-vous à cet exemple de code dans ProtoGeometry.Migrations.xml.

Génériques

Zero-Touch ne prend pas en charge l’utilisation de génériques pour l’instant. Ils peuvent être utilisés, mais pas dans le code importé directement lorsque le type n’est pas défini. Les méthodes, propriétés ou classes génériques qui ne possèdent pas le type défini ne peuvent pas être exposées.

Dans l’exemple ci-dessous, un nœud Zero-Touch de type T ne sera pas importé. Si le reste de la bibliothèque est importé dans Dynamo, il y aura des exceptions de type manquant.

public class SomeGenericClass<T>
{
    public SomeGenericClass()
    {
        Console.WriteLine(typeof(T).ToString());
    }  
}

L’utilisation d’un type générique avec le type défini dans cet exemple est importée dans Dynamo.

public class SomeWrapper
{
    public object wrapped;
    public SomeWrapper(SomeGenericClass<double> someConstrainedType)
    {
        Console.WriteLine(this.wrapped.GetType().ToString());
    }
}

Quel que soit le niveau d’expérience, la plateforme Dynamo est conçue pour que tous les utilisateurs soient des contributeurs. Il existe plusieurs options de développement qui ciblent des capacités et des niveaux de compétence différents, chacune avec ses forces et ses faiblesses selon l’objectif. Nous présentons ci-dessous les différentes options et comment les choisir.

Trois environnements de développement : Visual Studio, Python Editor et Code Block DesignScript

Quelles sont les options proposées ?

Les options de développement de Dynamo sont principalement réparties en deux catégories : pour Dynamo et dans Dynamo. Les deux catégories peuvent être considérées comme : « dans » Dynamo implique un contenu créé à l’aide de l’environnement de développement intégré (IDE) de Dynamo pour être utilisé dans Dynamo, et « pour » Dynamo implique l’utilisation d’outils externes pour créer du contenu qui sera importé dans Dynamo pour être utilisé. Bien que ce guide soit axé sur le développement pour Dynamo, les ressources pour tous les processus sont décrites ci-dessous.

Pour Dynamo

Ces nœuds permettent le plus haut degré de personnalisation. De nombreux packages sont créés avec cette méthode, et elle est nécessaire pour contribuer à la source de Dynamo. Le processus de génération sera abordé dans ce guide.

• Nœuds Zero-Touch

• Nœuds dérivés de NodeModel

• Extensions

Visual Studio est utilisé comme environnement de développement pour les nœuds Zero Touch et NodeModel dans les explications ci-dessous.

L’interface Visual Studio avec un projet que nous allons développer

Dans Dynamo

• Les blocs de code exposent DesignScript dans l’environnement de programmation visuel, ce qui permet des flux de travail de nœud et de script de texte flexibles. Une fonction dans un bloc de code peut être appelée par n’importe quel élément de l’espace de travail.

• Les nœuds personnalisés sont des conteneurs destinés à des ensembles de nœuds ou même à des graphiques entiers. Ils sont un moyen efficace de collecter les routines fréquemment utilisées et de les partager avec la communauté.

• Les nœuds Python sont une interface de script dans l’espace de travail de programmation visuelle, similaire aux blocs de code. Les bibliothèques Autodesk.DesignScript utilisent une notation par points similaire à DesignScript.

Le développement dans l’espace de travail de Dynamo est un outil puissant qui permet d’obtenir un retour immédiat.

Développement dans l’espace de travail Dynamo avec le nœud Python

Quels sont les avantages/inconvénients de chacun ?

Les options de développement de Dynamo ont été conçues pour répondre à la complexité d’un besoin de personnalisation. Que ce soit pour écrire un script récursif en Python ou pour générer une interface utilisateur de nœud entièrement personnalisée, il existe des options d’implémentation de code qui n’impliquent que ce qui est nécessaire pour être opérationnel.

Blocs de code, nœud Python et nœuds personnalisés dans Dynamo

Ces options sont simples pour écrire du code dans l’environnement de programmation visuelle Dynamo. L’espace de programmation visuelle Dynamo permet d’accéder à Python, DesignScript et de contenir plusieurs nœuds dans un nœud personnalisé.

Avec ces méthodes, vous pouvez :

• commencer à écrire des scripts Python ou DesignScript avec peu ou pas de configuration ;

• importer des bibliothèques Python dans Dynamo ;

• partager des blocs de code, des nœuds Python et des nœuds personnalisés avec la communauté Dynamo dans un package.

Nœuds Zero-Touch

Zero Touch fait référence à une méthode pointer-cliquer simple permettant d’importer des bibliothèques C#. Dynamo lit les méthodes publiques d’un fichier .dll et les convertit en nœuds Dynamo. Vous pouvez utiliser le Zero-Touch pour développer vos propres nœuds et packages personnalisés.

Avec cette méthode, vous pouvez :

• écrire des méthodes C# et les utiliser facilement comme nœuds dans Dynamo ;

• partager une bibliothèque C# en tant que nœuds avec la communauté Dynamo dans un package.

Nœuds dérivés de NodeModel

Ces nœuds permettent d’approfondir la structure de Dynamo. Ils sont basés sur la classe NodeModel et écrits en C#. Bien que cette méthode soit la plus souple et la plus puissante, la plupart des aspects du nœud doivent être définis de manière explicite et les fonctions doivent se trouver dans un ensemble séparé.

Avec cette méthode, vous pouvez :

• créer une interface utilisateur de nœuds entièrement personnalisable avec des curseurs, des images, des couleurs, etc. (p. ex. un nœud ColorRange) ;

• accéder et agir sur la zone de dessin Dynamo ;

• personnaliser la combinaison ;

• charger dans Dynamo comme un package.

Présentation du contrôle des versions de Dynamo et des modifications apportées à l’API (1.x → 2.x)

Comme Dynamo est régulièrement mis à jour, des modifications peuvent être apportées à une partie de l’API utilisée par un package. Il est important de suivre ces modifications pour s’assurer que les packages existants continuent à fonctionner correctement.

Autorisation de distribuer des binaires dans un package

Faites attention aux fichiers .dll inclus dans un package qui sont téléchargés dans le gestionnaire de package. Si l’auteur du package n’a pas créé le fichier .dll, il doit disposer des droits nécessaires pour le partager.

Si un package comprend des binaires, les utilisateurs doivent être avertis lors du téléchargement que celui-ci en contient.

Introduction

Cette section contient des informations sur les problèmes que vous pouvez rencontrer lors de la migration de vos graphiques, modules et bibliothèques vers Dynamo 3.x.

Dynamo 3.0 est une version majeure et certaines API ont été modifiées ou supprimées. Le changement le plus important qui est susceptible de vous affecter en tant que développeur ou utilisateur de Dynamo 3.x est le passage à .NET8.

Dotnet/.NET est le runtime qui alimente le langage C# dans lequel Dynamo est écrit. Nous avons mis à jour cette version de runtime vers une version plus récente, ainsi que le reste de l'écosystème Autodesk.

Pour en savoir plus, consultez .

Compatibilité des modules

Utilisation des modules Dynamo 2.x dans Dynamo 3.x

Comme Dynamo 3.x s'exécute désormais sur le runtime .NET8, les modules qui ont été créés pour Dynamo 2.x (à l'aide de .NET48) sont susceptibles de ne pas fonctionner dans Dynamo 3.x. Lorsque vous tentez de télécharger un module dans Dynamo 3.x qui a été publié à partir d'une version de Dynamo antérieure à la version 3.0, vous recevez un avertissement vous indiquant que le module provient d'une version antérieure de Dynamo.

Cela ne signifie pas que le module ne fonctionnera pas. Il s'agit simplement d'un avertissement indiquant que des problèmes de compatibilité peuvent survenir. En général, il est conseillé de vérifier si une version plus récente a été spécialement conçue pour Dynamo 3.x.

Vous pouvez également remarquer ce type d'avertissement dans vos fichiers journaux Dynamo au moment du chargement du module. Si tout fonctionne correctement, vous pouvez l'ignorer.

Utilisation des modules Dynamo 3.x dans Dynamo 2.x

Il est très peu probable qu'un module créé pour Dynamo 3.x (à l'aide de .Net8) fonctionne sur Dynamo 2.x. Un avertissement s'affiche également lors du téléchargement de modules créés pour des versions plus récentes de Dynamo lorsque vous utilisez une version antérieure.

Introduction :

Dynamo 2.0 est une version majeure et certaines API ont été modifiées ou supprimées. L’un des changements les plus importants qui affectera les auteurs de nœuds et de packages est le passage au format de fichier JSON.

Dans la plupart des cas, les auteurs de nœuds Zero-Touch n’auront que peu ou pas de travail à faire pour que leurs packages fonctionnent dans la version 2.0.

Les nœuds d’interface utilisateur et les nœuds qui dérivent directement de NodeModel nécessiteront plus de travail pour fonctionner dans la version 2.x.

Les auteurs d’extensions peuvent également avoir des changements potentiels à faire selon la quantité d’API de Dynamo Core qu’ils utilisent dans leurs extensions.

Règles générales relatives aux packages :

• n’intégrez pas les fichiers .dll de Dynamo ou de Dynamo Revit dans votre package. Ces fichiers .dll seront déjà chargés par Dynamo. Si vous intégrez une version différente de celle que l’utilisateur a chargée (p. ex. vous distribuez sur Dynamo Core 1.3 mais l’utilisateur exécute votre package sur Dynamo 2.0), des bogues d’exécution inattendus se produiront. Cela inclut les fichiers .dll tels que DynamoCore.dll, DynamoServices.dll, DSCodeNodes.dll, ProtoGeometry.dll ;

• évitez d’intégrer et de distribuer des newtonsoft.json.net avec votre package si vous pouvez l’éviter. Ce fichier .dll sera également chargé par Dynamo 2.x. Le même problème que ci-dessus peut se produire ;

• évitez d’intégrer et de distribuer des CEFSharp avec votre package si vous pouvez l’éviter. Ce fichier .dll sera également chargé par Dynamo 2.x. Le même problème que ci-dessus peut se produire ;

• de manière générale, évitez de partager des dépendances avec Dynamo ou Revit si vous avez besoin de contrôler la version de cette dépendance.

Problèmes courants :

1) Lors de l’ouverture d’un graphique, certains nœuds ont plusieurs ports portant le même nom, mais le graphique semble correct lors de l’enregistrement. Ce problème peut avoir plusieurs causes.

La cause principale est que le nœud a été créé à l’aide d’un constructeur qui a recréé les ports. Au lieu de cela, il aurait fallu utiliser un constructeur capable de charger les ports. Ces constructeurs sont généralement marqués [JsonConstructor]. Voir les exemples ci-dessous

Cela peut se produire pour les raisons suivantes :

• il n’y avait tout simplement pas de [JsonConstructor] correspondant, ou il n’a pas été transmis par les fichiers Inports et Outports du fichier JSON .dyn ;

• deux versions de JSON.net ont été chargées simultanément dans le même processus, ce qui a entraîné une erreur au niveau de l’exécution .net, de sorte que l’attribut [JsonConstructor] n’a pas pu être utilisé correctement pour marquer le constructeur ;

• une version de DynamoServices.dll différente de la version actuelle de Dynamo a été incluse dans le package et provoque l’échec de l’exécution .net à identifier l’attribut [MultiReturn], de sorte que les nœuds Zero-Touch marqués avec divers attributs ne pourront pas être appliqués. Il se peut qu’un nœud renvoie une seule sortie de dictionnaire au lieu de plusieurs ports.

2) Des nœuds sont complètement absents lors du chargement du graphique avec des erreurs dans la console.

• Cela peut se produire si votre désérialisation a échoué pour une raison quelconque. Il est recommandé de ne sérialiser que les propriétés dont vous avez besoin. Nous pouvons utiliser [JsonIgnore] sur les propriétés complexes que vous n’avez pas besoin de charger ou d’enregistrer pour les ignorer. Il s’agit de propriétés telles que function pointer, delegate, action, ou event etc. Elles ne doivent pas être sérialisées car elles échoueront généralement à la désérialisation et provoqueront une erreur d’exécution.

Mise à niveau détaillée :

Nœuds personnalisés 1.3 - > 2.0

Problèmes connus :

• les commentaires seront transformés en commentaires de bloc au lieu de commentaires de ligne ;

• les noms de type abrégés seront remplacés par des noms complets. Par exemple, si vous n’avez pas spécifié de type lorsque vous chargez à nouveau le nœud personnalisé, var[]..[] s’affiche, car il s’agit du type par défaut.

Nœuds Zero-Touch 1.3 -> 2.0

• Dans Dynamo 2.0, les types Liste et Dictionnaire ont été divisés et la syntaxe pour créer des listes et des dictionnaires a été modifiée. Les listes sont initialisées à l’aide de [] tandis que les dictionnaires utilisent {}. Si vous utilisiez auparavant l’attribut DefaultArgument pour marquer les paramètres de vos nœuds Zero-Touch et utilisiez la syntaxe de liste par défaut pour une liste spécifique telle que someFunc([DefaultArgument("{0,1,2}")]), ceci ne sera plus valable et vous devrez modifier l’extrait de code DesignScript pour utiliser la nouvelle syntaxe d’initialisation pour les listes.

• Comme indiqué ci-dessus, ne distribuez pas de fichiers .dll Dynamo avec vos packages. (DynamoCore, DynamoServices, etc.).

Nœuds de modèle de nœud 1.3 -> 2.0

Les nœuds de modèle de nœud nécessitent le plus de travail pour passer à Dynamo 2.x. De manière générale, vous devez implémenter des constructeurs qui seront utilisés uniquement pour charger vos nœuds à partir de json, en plus des constructeurs nodeModel standard utilisés pour instancier de nouvelles instances de vos types de nœud. Pour les différencier, vous devez marquer les constructeurs de chargement à l’aide de l’attribut [JsonConstructor] de newtonsoft.Json.net.

Constructeurs JSON

La modification la plus courante requise pour mettre à jour les nœuds dérivés de la classe de base NodeModel (ou d’autres classes de base Dynamo Core, par exemple DSDropDownBase) est la nécessité d’ajouter un constructeur JSON à votre classe.

Votre constructeur original sans paramètre gérera toujours l’initialisation d’un nouveau nœud créé au sein de Dynamo (via la bibliothèque par exemple). Le constructeur JSON est requis pour initialiser un nœud désérialisé (chargé) à partir d’un fichier .dyn ou .dyf enregistré.

Le constructeur JSON diffère du constructeur de base, car il possède des paramètres PortModel pour les inPorts et les outPorts, fournis par la logique de chargement JSON. L’appel pour enregistrer les ports pour le nœud n’est pas requis ici, car les données existent dans le fichier .dyn. Voici un exemple de constructeur JSON :

using Newtonsoft.Json; //New dependency for Json

………

[JsonConstructor] //Attribute required to identity the Json constructor

//Minimum constructor implementation. Note that the base method invocation must also be present.

FooNode(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts) { }

Cette syntaxe :base(Inports,outPorts){} appelle le constructeur de base nodeModel et lui transmet les ports désérialisés.

Il n’est pas nécessaire de répéter dans ce constructeur toute logique spéciale qui existait dans le constructeur de la classe et qui impliquait l’initialisation de données spécifiques sérialisées dans le fichier .dyn (par exemple la définition de l’enregistrement du port, la stratégie de combinaison, etc.), car ces valeurs peuvent être lues à partir du JSON.

C’est la principale différence entre le constructeur JSON et les constructeurs non-JSON pour vos nodeModels. Les constructeurs JSON sont appelés lors du chargement à partir d’un fichier et les données chargées sont transmises. D’autres éléments de la logique utilisateur doivent cependant être dupliqués dans le constructeur JSON (par exemple, l’initialisation des gestionnaires d’événements pour le nœud ou l’association).

Propriétés publiques et sérialisation

[JsonProperty(PropertyName = "InputValue")]

public DSColor DsColor {...

Convertisseurs :

Remarque Si vous créez votre propre classe de convertisseur JSON.net, Dynamo ne dispose pas actuellement d’un mécanisme qui vous permet de l’injecter dans les méthodes de chargement et d’enregistrement. Ainsi, même si vous marquez votre classe avec l’attribut [JsonConverter], elle ne peut pas être utilisée, à la place vous pouvez appeler votre convertisseur directement dans votre setter ou getter. //À FAIRE : avoir la confirmation de cette limitation. Toute preuve est la bienvenue.

[JsonProperty("MeasurementType"), JsonConverter(typeof(StringEnumConverter))]

public ConversionMetricUnit SelectedMetricConversion{...

Ignorer les propriétés

Annuler/Rétablir

Comme indiqué ci-dessus, les méthodes SerializeCore et DeserializeCore étaient utilisées dans le passé pour enregistrer et charger des nœuds dans le fichier xml .dyn. En outre, elles étaient également utilisées pour enregistrer et charger l’état des nœuds pour annuler/rétabliret le sont toujours ! Si vous souhaitez mettre en œuvre une fonctionnalité complexe Annuler/Rétablir pour votre nœud de l’interface utilisateur nodeModel, vous devrez mettre en œuvre ces méthodes et sérialiser dans l’objet document XML fourni en tant que paramètre de ces méthodes. Il s’agit d’un cas d’utilisation rare, sauf pour les nœuds complexes de l’interface utilisateur.

API des ports d’entrée et de sortie

L’enregistrement du port dans le constructeur du nœud est un phénomène courant dans les nœuds nodeModel concernés par les modifications de l’API 2.0. Si vous avez déjà regardé des exemples dans le dépôt Dynamo ou DynamoSamples, il est possible que vous ayez utilisé les méthodes InPortData.Add() ou OutPortData.Add(). Auparavant, dans l’API Dynamo, les propriétés publiques InPortData et OutPortData étaient marquées comme étant obsolètes. Dans la version 2.0, ces propriétés ont été supprimées. Les développeurs doivent maintenant utiliser les méthodes InPorts.Add() et OutPorts.Add(). En outre, ces deux méthodes Add() ont des signatures légèrement différentes :

InPortData.Add(new PortData("Port Name", "Port Description")); //Old version valid in 1.3 but now deprecated

comparé à

InPorts.Add(new PortModel(PortType.Input, this, new PortData("Port Name", "Port Description"))); //Recommended 2.0

Exemples :

Nous allons voir comment mettre à jour un nœud d’interface utilisateur 1.3 vers Dynamo 2.x.

Pour charger et enregistrer correctement cette classe nodeModel dans la version 2.0, il suffit d’ajouter un jsonConstructor pour gérer le chargement des ports. Nous passons simplement les ports au constructeur de base et cette implémentation est vide.

Remarque : n’appelez pas RegisterPorts() ou une variante de ce paramètre dans votre JsonConstructor. Cela utilisera les attributs des paramètres d’entrée et de sortie de votre classe de nœuds pour construire de nouveaux ports ! Ce n’est pas ce que nous souhaitons, puisque nous voulons utiliser les ports chargés qui sont passés au constructeur.

Voici un constructeur plus complexe pour un nœud d’interface utilisateur :

Lorsque nous ajoutons un constructeur JSON pour charger ce nœud à partir d’un fichier, nous devons recréer une partie de cette logique, mais notez que nous n’incluons pas le code qui crée les ports, définit la combinaison ou les valeurs par défaut des propriétés que nous pouvons charger à partir du fichier.

Notez que les autres propriétés publiques qui ont été sérialisées dans le JSON comme ButtonText et WindowText ne devront pas être ajoutées en tant que paramètres explicites au constructeur. Elles sont définies automatiquement par JSON.net en utilisant les setters pour ces propriétés.

Avec un projet Visual Studio opérationnel, nous allons voir comment générer un nœud personnalisé qui crée une grille rectangulaire de cellules. Bien que nous puissions créer ce nœud avec plusieurs nœuds standard, il s’agit d’un outil utile qui peut être facilement contenu dans un nœud Zero-Touch. Contrairement aux lignes de grille, les cellules peuvent être mises à l’échelle autour de leurs points centraux, interrogées pour leurs sommets d’angle ou créées dans des faces.

Cet exemple aborde quelques-unes des caractéristiques et des concepts à prendre en compte lors de la création d’un nœud Zero-Touch. Après avoir générer le nœud personnalisé et l’avoir ajouté à Dynamo, assurez-vous de consulter la page Aller plus loin avec Zero-Touch pour obtenir plus de détails sur les valeurs d’entrée par défaut, le renvoi de valeurs multiples, la documentation, les objets, l’utilisation des types de géométrie Dynamo et les migrations.

Noeud de grille rectangulaire personnalisé

Pour commencer à générer le nœud de grille, créez un nouveau projet de bibliothèque de classes Visual Studio. Reportez-vous à la page Mise en route pour obtenir un guide détaillé de la configuration d’un projet.

1. Choisissez Class Library comme type de projet

2. Nommez le projet CustomNodes

Comme nous allons créer une géométrie, nous devons référencer le package NuGet approprié. Installez le package ZeroTouchLibrary à partir du gestionnaire de package Nuget. Ce package est nécessaire pour l’instruction using Autodesk.DesignScript.Geometry;.

1. Recherchez le package ZeroTouchLibrary.

2. Nous utiliserons ce nœud dans la version actuelle de Dynamo Studio, qui est la 1.3. Sélectionnez la version du package qui correspond à cette version.

3. Notez que nous avons également renommé le fichier de classe en Grids.cs.

Ensuite, nous devons établir un espace de noms et une classe dans lesquels la méthode RectangularGrid sera intégrée. Le nœud sera nommé dans Dynamo en fonction des noms de la méthode et de la classe. Nous n’avons pas besoin de copier ceci dans Visual Studio pour le moment.

Autodesk.DesignScript.Geometry; fait référence au fichier ProtoGeometry.dll du package et ZeroTouchLibrary System.Collections.Generic est nécessaire pour créer des listes

Nous pouvons maintenant ajouter la méthode pour dessiner les rectangles. Le fichier de classe doit ressembler à ceci et peut être copié dans Visual Studio.

Si le projet ressemble à ceci, essayez de générer le .dll.

1. Choisissez Générer > Générer une solution

Vérifiez si le dossier bin du projet contient un .dll. Si la génération est réussie, nous pouvons ajouter le .dll à Dynamo.

1. Le nœud RectangularGrids personnalisé dans la bibliothèque Dynamo

2. Le nœud personnalisé sur la zone de dessin

3. Le bouton Ajouter permet d’ajouter le .dll à Dynamo

Modifications de nœuds personnalisé

Dans l’exemple ci-dessus, nous avons créé un nœud assez simple qui définit essentiellement la méthode RectangularGrids. Cependant, nous pouvons vouloir créer des infobulles pour les ports d’entrée ou donner au nœud un résumé comme les nœuds Dynamo standard. L’ajout de ces fonctionnalités aux nœuds personnalisés les rend plus faciles à utiliser, en particulier si un utilisateur souhaite les rechercher dans la bibliothèque.

1. Une valeur d’entrée par défaut

2. Une Info-bulle pour l’entrée xCount

Le nœud RectangularGrid a besoin de certaines de ces caractéristiques de base. Dans le code ci-dessous, nous avons ajouté des descriptions des ports d’entrée et de sortie, un résumé et des valeurs d’entrée par défaut.

• Donnez aux entrées des valeurs par défaut en attribuant des valeurs aux paramètres de la méthode : RectangularGrid(int xCount = 10, int yCount = 10).

• Créez des info-bulles d’entrée et de sortie, des mots-clés de recherche et un résumé avec la documentation XML précédée de ///.

Pour ajouter des info-bulles, vous devez disposer d’un fichier XML dans le répertoire du projet. Un .xml peut être généré automatiquement par Visual Studio en activant l’option.

1. Activez ici le fichier de documentation XML et indiquez un chemin d’accès au fichier. Cela génère un fichier XML.

Et voilà ! Nous avons créé un nouveau nœud doté de plusieurs fonctions standard. Le chapitre suivant, Bases de Zero-Touch, décrit plus en détail le développement des nœuds Zero-Touch et les problèmes à prendre en compte.

Avant de se lancer dans le développement, il est important d’établir des bases solides pour un nouveau projet. Il existe plusieurs modèles de projets dans la communauté des développeurs Dynamo qui sont d’excellents points de départ, mais il est encore plus utile de savoir comment démarrer un projet à partir de zéro. La génération d’un projet à partir de zéro permet de mieux comprendre le processus de développement.

Créer un projet Visual Studio

Visual Studio est un environnement IDE puissant dans lequel vous pouvez créer un projet, ajouter des références, générer des .dlls et déboguer. Lors de la création d’un projet, Visual Studio crée également une solution, une structure pour l’organisation des projets. Plusieurs projets peuvent exister au sein d’une même solution et peuvent être créés ensemble. Pour créer un nœud ZeroTouch, nous devons démarrer un nouveau projet Visual Studio dans lequel nous écrirons une bibliothèque de classes en C# et générerons un .dll.

La fenêtre Nouveau projet dans Visual Studio

1. Commencez par ouvrir Visual Studio et créez un projet : File > New > Project.

2. Choisissez le modèle de projet Class Library.

3. Donnez un nom au projet (nous avons nommé le projet MyCustomNode).

4. Définissez le chemin d’accès au fichier de votre projet. Dans cet exemple, nous le laisserons à l’emplacement par défaut.

5. Sélectionnez Ok.

Visual Studio crée et ouvre automatiquement un fichier C#. Donnez-lui un nom approprié, configurez l’espace de travail et remplacez le code par défaut par cette méthode de multiplication.

1. Ouvrez l’explorateur de solutions et les fenêtres de sortie à partir de View.

2. Renommez le fichier Class1.cs en SampleFunctions.cs dans l’explorateur de solutions sur la droite.

3. Ajoutez le code ci-dessus pour la fonction de multiplication. Nous verrons plus tard comment Dynamo lira vos classes C#.

4. L’explorateur de solutions : il vous permet d’accéder à tous les éléments de votre projet.

5. La fenêtre de sortie : nous en aurons besoin plus tard pour voir si la génération s’est bien déroulée.

L’étape suivante consiste à générer le projet, mais avant cela, nous devons vérifier quelques paramètres. Tout d’abord, assurez-vous que Any CPU ou x64 est sélectionné comme plateforme cible et que la case Prefer 32-bit n’est pas cochée dans les propriétés du projet.

1. Ouvrez les propriétés du projet en sélectionnant Project > "ProjectName" Properties.

2. Sélectionnez la page Build.

3. Sélectionnez Any CPU ou x64 dans le menu déroulant.

4. Assurez-vous que la case Prefer 32-bit n’est pas cochée.

Nous pouvons maintenant générer le projet pour créer un .dll. Pour ce faire, sélectionnez Build Solution dans le menu Build ou utilisez le raccourci CTRL+SHIFT+B.

1. Sélectionnez Build > Build Solution.

2. Vous pouvez déterminer si votre projet a été créé correctement en cochant la fenêtre Sortie.

Si le projet a été créé correctement, un .dll nommé MyCustomNode figure dans le dossier bin du projet. Pour cet exemple, nous avons laissé le chemin d’accès au fichier du projet tel qu’il est défini par défaut par Visual Studio, à savoir c:\users\username\documents\visual studio 2015\Projects. Examinons la structure de fichiers du projet.

1. Le dossier bin contient le .dll créé à partir de Visual Studio.

2. Le fichier du projet Visual Studio.

3. Le fichier de classe.

4. La configuration de notre solution étant définie sur Debug, le .dll sera créé dans bin\Debug.

Nous pouvons maintenant ouvrir Dynamo et importer le .dll. Avec la fonction Ajouter, accédez à l’emplacement bin du projet et sélectionnez le .dll à ouvrir.

1. Cliquez sur le bouton Ajouter pour importer un fichier .dll.

2. Accédez à l’emplacement du projet. Notre projet se trouve dans le chemin d’accès par défaut de Visual Studio : C:\Users\username\Documents\Visual Studio 2015\Projects\MyCustomNode.

3. Sélectionnez le MyCustomNode.dll à importer.

4. Cliquez sur Open pour charger le .dll.

Si une catégorie est créée dans la bibliothèque appelée MyCustomNode, le fichier .dll a été importé avec succès ! Cependant, Dynamo a créé deux nœuds alors que nous n’en voulions qu’un seul. Dans la section suivante, nous allons expliquer pourquoi cela se produit et comment Dynamo lit un fichier .dll.

1. MyCustomNode dans la bibliothèque Dynamo. La catégorie Bibliothèque est déterminée par le nom .dll.

2. SampleFunctions.MultiplyByTwo dans la zone de dessin.

Lecture des classes et des méthodes par Dynamo

Lorsque Dynamo charge un fichier .dll, il expose toutes les méthodes statiques publiques sous forme de nœuds. Les constructeurs, les méthodes et les propriétés seront transformés respectivement en nœuds de création, d’action et de requête. Dans notre exemple de multiplication, la méthode MultiplyByTwo() devient un nœud d’action dans Dynamo. Ceci est dû au fait que le nœud a été nommé en fonction de sa méthode et de sa classe.

1. L’entrée est nommée inputNumber en fonction du nom du paramètre de la méthode.

2. La sortie est nommée double par défaut, car il s’agit du type de données renvoyé.

3. Le nœud est nommé SampleFunctions.MultiplyByTwo car il s’agit des noms de classe et de méthode.

Dans l’exemple ci-dessus, le nœud supplémentaire de création SampleFunctions a été créé, car nous n’avons pas fourni explicitement de constructeur et par conséquent un constructeur a été automatiquement créé. Nous pouvons éviter cela en créant un constructeur privé vide dans notre classe SampleFunctions.

1. Dynamo a importé notre méthode en tant que nœud de création

Ajouter des références de package Dynamo NuGet

Le nœud de multiplication est très simple et aucune référence à Dynamo n’est nécessaire. Si nous voulons accéder à l’une des fonctionnalités de Dynamo pour créer une géométrie par exemple, nous devrons faire référence aux packages NuGet de Dynamo.

Pour référencer ces packages dans un projet Visual Studio, téléchargez le package à partir de NuGet à l’aide des liens ci-dessus et référencez manuellement les fichiers .dll ou utilisez le gestionnaire de package NuGet dans Visual Studio. Nous pouvons d’abord voir comment les installer avec NuGet dans Visual Studio.

1. Ouvrez le gestionnaire de package NuGet en sélectionnant Tools > NuGet Package Manager > Manage NuGet Packages for Solution....

Il s’agit du gestionnaire de package NuGet. Cette fenêtre indique les packages qui ont été installés pour le projet et permet à l’utilisateur d’en rechercher d’autres. Si une nouvelle version du package DynamoServices est publiée, les packages peuvent être mis à jour à partir d’ici ou rétablis à une version antérieure.

1. Sélectionnez Parcourir et recherchez DynamoVisualProgramming pour faire apparaître les packages Dynamo.

2. Les packages Dynamo. En sélectionnant l’un d’entre eux, vous verrez sa version actuelle et une description de son contenu.

3. Sélectionnez la version du package dont vous avez besoin et cliquez sur installer. Cela permet d’installer un package pour le projet spécifique sur lequel vous travaillez. Puisque nous utilisons la dernière version stable de Dynamo (version 1.3), choisissez la version du package correspondante.

Pour ajouter manuellement un package téléchargé à partir du navigateur, ouvrez le gestionnaire des références à partir de l’explorateur de solutions et recherchez le package.

1. Cliquez avec le bouton droit de la souris sur References et sélectionnez Add Reference.

2. Sélectionnez Browse pour accéder à l’emplacement du package.

Maintenant que Visual Studio est configuré correctement et que nous avons réussi à ajouter un .dll à Dynamo, nous disposons d’une base solide pour les concepts à venir. Ce n’est que le début, alors poursuivez votre lecture pour en savoir plus sur la création d’un nœud personnalisé.

Les extensions sont un outil de développement puissant dans l’écosystème Dynamo. Elles permettent aux développeurs de créer des fonctionnalités personnalisées basées sur les interactions et la logique de Dynamo. Les extensions peuvent être divisées en deux catégories principales : les extensions et les extensions de vue. Comme son nom l’indique, le cadre d’extension de vue vous permet d’étendre l’interface utilisateur Dynamo en enregistrant des éléments de menu personnalisés. Les extensions classiques fonctionnent de manière très similaire, à l’exception de l’interface utilisateur. Par exemple, nous pourrions générer une extension qui enregistre des informations spécifiques dans la console Dynamo. Ce scénario ne nécessite pas d’interface utilisateur personnalisée et pourrait donc être réalisé à l’aide d’une extension.

Étude de cas sur les extensions

En suivant l’exemple SampleViewExtension du dépôt DynamoSamples de Github, nous allons parcourir les étapes nécessaires à la création d’une simple fenêtre sans modèle qui affiche les nœuds actifs du graphique en temps réel. Une extension de vue nécessite la création d’une interface utilisateur pour la fenêtre et l’association de valeurs à un modèle de vue.

1. La fenêtre d’extension de vue a été développée en suivant l’exemple SampleViewExtension dans le dépôt de Github.

Bien que nous allons générer l’exemple à partir de zéro, vous pouvez également télécharger et générer le dépôt DynamoSamples comme référence.

Le dépôt DynamoSamples : https://github.com/DynamoDS/DynamoSamples

Cette présentation fait référence au projet nommé SampleViewExtension qui se trouve dans DynamoSamples/src/.

Comment implémenter une extension de vue

Une extension de vue comporte trois parties essentielles :

• un assemblage contenant une classe qui implémente IViewExtension ainsi qu’une classe qui crée un modèle de vue ;

• un fichier .xml qui indique à Dynamo où il doit chercher cet assemblage lors de l’exécution, et le type d’extension ;

• un fichier .xaml qui lie les données à l’affichage graphique et détermine l’apparence de la fenêtre.

1. Créer la structure du projet

Commencez par créer un projet Class Library nommé SampleViewExtension.

1. Créez un projet en sélectionnant File > New > Project

2. Sélectionnez Class Library

3. Nommez le projet SampleViewExtension

4. Sélectionnez Ok

Dans ce projet, nous aurons besoin de deux classes. Une classe implémentera IViewExtension et une autre qui implémentera NotificationObject. IViewExtension contiendra toutes les informations sur la façon dont l’extension sera déployée, chargée, référencée et supprimée. NotificationObject fournira des notifications pour les modifications dans Dynamo et IDisposable. Lorsqu’un changement se produit, le compte sera mis à jour en conséquence.

1. Un fichier de classe nommé SampleViewExtension.cs qui implémentera IViewExtension

2. Un fichier de classe nommé SampleWindowViewMode.cs qui implémentera NotificationObject

Pour utiliser IViewExtension, nous aurons besoin du package NuGet WpfUILibrary. L’installation de ce package installera automatiquement les packages Core, Services et ZeroTouchLibrary.

1. Sélectionnez la bibliothèque WpfUILibrary

2. Sélectionnez Install pour installer tous les packages dépendants

2. Implémenter la classe IViewExtension

Dans la classe IViewExtension, nous allons déterminer les actions qui se produisent au démarrage de Dynamo, au chargement de l’extension et à l’arrêt de Dynamo. Dans le fichier de classe SampleViewExtension.cs, ajoutez le code suivant :

using System;
using System.Windows;
using System.Windows.Controls;
using Dynamo.Wpf.Extensions;

namespace SampleViewExtension
{

    public class SampleViewExtension : IViewExtension
    {
        private MenuItem sampleMenuItem;

        public void Dispose()
        {
        }

        public void Startup(ViewStartupParams p)
        {
        }

        public void Loaded(ViewLoadedParams p)
        {
            // Save a reference to your loaded parameters.
            // You'll need these later when you want to use
            // the supplied workspaces

            sampleMenuItem = new MenuItem {Header = "Show View Extension Sample Window"};
            sampleMenuItem.Click += (sender, args) =>
            {
                var viewModel = new SampleWindowViewModel(p);
                var window = new SampleWindow
                {
                    // Set the data context for the main grid in the window.
                    MainGrid = { DataContext = viewModel },

                    // Set the owner of the window to the Dynamo window.
                    Owner = p.DynamoWindow
                };

                window.Left = window.Owner.Left + 400;
                window.Top = window.Owner.Top + 200;

                // Show a modeless window.
                window.Show();
            };
            p.AddMenuItem(MenuBarType.View, sampleMenuItem);
        }

        public void Shutdown()
        {
        }

        public string UniqueId
        {
            get
            {
                return Guid.NewGuid().ToString();
            }  
        } 

        public string Name
        {
            get
            {
                return "Sample View Extension";
            }
        } 

    }
}

La classe SampleViewExtension crée un élément de menu cliquable pour ouvrir la fenêtre et le relie au modèle de vue et à la fenêtre.

• public class SampleViewExtension : IViewExtension SampleViewExtension hérite de l’interface IViewExtension et fournit tout ce dont nous avons besoin pour créer l’élément de menu.

• sampleMenuItem = new MenuItem { Header = "Show View Extension Sample Window" }; crée un élément MenuItem et l’ajoute au menu View.

1. L’élément de menu

• sampleMenuItem.Click += (sender, args) déclenche un événement qui ouvre une nouvelle fenêtre lorsque vous cliquez sur l’élément de menu

• MainGrid = { DataContext = viewModel } définit le contexte de données pour la grille principale de la fenêtre, en se référant à Main Grid dans le fichier .xaml que nous allons créer

• Owner = p.DynamoWindow définit le propriétaire de la fenêtre contextuelle sur Dynamo. Cela signifie que la nouvelle fenêtre est dépendante de Dynamo, de sorte que les actions telles que la réduction, l’agrandissement et la restauration de Dynamo entraîneront le même comportement dans la nouvelle fenêtre

• window.Show(); affiche la fenêtre dans laquelle les propriétés de fenêtre supplémentaires ont été définies

3. Implémentation du modèle de vue

Maintenant que nous avons établi certains des paramètres de base de la fenêtre, nous allons ajouter la logique de réponse aux différents événements liés à Dynamo et indiquer à l’interface utilisateur de se mettre à jour en fonction de ces événements. Copiez le code suivant dans le fichier de classe SampleWindowViewModel.cs :

using System;
using Dynamo.Core;
using Dynamo.Extensions;
using Dynamo.Graph.Nodes;

namespace SampleViewExtension
{
    public class SampleWindowViewModel : NotificationObject, IDisposable
    {
        private string activeNodeTypes;
        private ReadyParams readyParams;

        // Displays active nodes in the workspace
        public string ActiveNodeTypes
        {
            get
            {
                activeNodeTypes = getNodeTypes();
                return activeNodeTypes;
            }
        }

        // Helper function that builds string of active nodes
        public string getNodeTypes()
        {
            string output = "Active nodes:\n";

            foreach (NodeModel node in readyParams.CurrentWorkspaceModel.Nodes)
            {
                string nickName = node.Name;
                output += nickName + "\n";
            }

            return output;
        }

        public SampleWindowViewModel(ReadyParams p)
        {
            readyParams = p;
            p.CurrentWorkspaceModel.NodeAdded += CurrentWorkspaceModel_NodesChanged;
            p.CurrentWorkspaceModel.NodeRemoved += CurrentWorkspaceModel_NodesChanged;
        }

        private void CurrentWorkspaceModel_NodesChanged(NodeModel obj)
        {
            RaisePropertyChanged("ActiveNodeTypes");
        }

        public void Dispose()
        {
            readyParams.CurrentWorkspaceModel.NodeAdded -= CurrentWorkspaceModel_NodesChanged;
            readyParams.CurrentWorkspaceModel.NodeRemoved -= CurrentWorkspaceModel_NodesChanged;
        }
    }
}

Cette implémentation de la classe de modèle de vue écoute le CurrentWorkspaceModel et déclenche un événement lorsqu’un nœud est ajouté ou supprimé de l’espace de travail. Cela déclenche un changement de propriété qui signale à l’interface utilisateur ou aux éléments liés que les données ont changé et qu’elles doivent être mises à jour. Le getter ActiveNodeTypes est appelé, ce qui appelle en interne une fonction d’assistant supplémentaire getNodeTypes(). Cette fonction parcourt tous les nœuds actifs de la zone de dessin, remplit une chaîne contenant les noms de ces nœuds et renvoie cette chaîne à notre liaison dans le fichier .xaml pour qu’elle soit affichée dans notre fenêtre contextuelle.

Une fois la logique principale de l’extension définie, vous allez maintenant spécifier les détails d’apparence de la fenêtre avec un fichier .xaml. Il suffit d’une simple fenêtre qui affiche la chaîne via la liaison de propriété ActiveNodeTypes dans le TextBlock Text.

1. Cliquez avec le bouton droit de la souris sur le projet et choisissez Add > New Item...

2. Sélectionnez le modèle de contrôle utilisateur que vous allez modifier pour créer une fenêtre

3. Nommez le nouveau fichier SampleWindow.xaml

4. Sélectionnez Add

Dans le code de la fenêtre .xaml, vous devez lier SelectedNodesText à un bloc de texte. Ajoutez le code suivant à SampleWindow.xaml :

<Window x:Class="SampleViewExtension.SampleWindow"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:SampleViewExtension"
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300"
            Width="500" Height="100">
    <Grid Name="MainGrid" 
          HorizontalAlignment="Stretch"
          VerticalAlignment="Stretch">
        <TextBlock HorizontalAlignment="Stretch" Text="{Binding ActiveNodeTypes}" FontFamily="Arial" Padding="10" FontWeight="Medium" FontSize="18" Background="#2d2d2d" Foreground="White"/>
    </Grid>
</Window>

• Text="{Binding ActiveNodeTypes}" se lie à la valeur de propriété de ActiveNodeTypes dans SampleWindowViewModel.cs à la valeur de TextBlock Text dans la fenêtre.

Nous allons maintenant initialiser la fenêtre d’exemple dans le fichier de sauvegarde .xaml C# SampleWindow.xaml.cs. Ajoutez le code suivant à SampleWindow.xaml :

using System.Windows;

namespace SampleViewExtension
{
    /// <summary>
    /// Interaction logic for SampleWindow.xaml
    /// </summary>
    public partial class SampleWindow : Window
    {
        public SampleWindow()
        {
            InitializeComponent();
        }
    }
}

L’extension de vue est maintenant prête à être créée et ajoutée à Dynamo. Dynamo requiert un fichier xml pour enregistrer la sortie .dll en tant qu’extension.

1. Cliquez avec le bouton droit de la souris sur le projet et choisissez Add > New Item...

2. Sélectionner un fichier XML

3. Nommez le fichier SampleViewExtension_ViewExtensionDefinition.xml

4. Sélectionnez Add

• Le nom du fichier suit la norme Dynamo pour référencer un ensemble d’extension de la manière suivante : "extensionName"_ViewExtensionDefinition.xml

Dans le fichier xml, ajoutez le code suivant pour indiquer à Dynamo où rechercher l’assemblage d’extension :

<ViewExtensionDefinition>
  <AssemblyPath>C:\Users\username\Documents\Visual Studio 2015\Projects\SampleViewExtension\SampleViewExtension\bin\Debug\SampleViewExtension.dll</AssemblyPath>
  <TypeName>SampleViewExtension.SampleViewExtension</TypeName>
</ViewExtensionDefinition>

• Dans cet exemple, nous avons créé l’assemblage dans le dossier par défaut du projet Visual Studio. Remplacez la cible <AssemblyPath>...</AssemblyPath> par l’emplacement de l’assemblage.

La dernière étape consiste à copier le fichier SampleViewExtension_ViewExtensionDefinition.xml dans le dossier des extensions de vue de Dynamo situé dans le répertoire d’installation de Dynamo Core C:\Program Files\Dynamo\Dynamo Core\1.3\viewExtensions. Il est important de noter qu’il existe des dossiers distincts pour extensions et viewExtensions. Placer le fichier xml dans un dossier incorrect peut entraîner un échec du chargement au moment de l’exécution.

1. Le fichier .xml que nous avons copié dans le dossier des extensions de vue de Dynamo

Il s’agit d’une introduction sommaire aux extensions de vues. Pour une étude de cas plus sophistiquée, consultez le package DynaShape, un projet open source sur Github. Le package utilise une extension de vue qui permet de modifier en direct la vue du modèle Dynamo.

Un programme d’installation du package pour Dynamo Shape peut être téléchargé à partir du forum Dynamo : https://forum.dynamobim.com/t/dynashape-published/11666

Le code source peut être cloné à partir de Github : https://github.com/LongNguyenP/DynaShape

Exécuter des scripts Python dans des nœuds Zero-Touch (C#)

Si vous êtes à l’aise avec l’écriture de scripts en Python et que vous voulez plus de fonctionnalités à partir des nœuds Python standard de Dynamo, nous pouvons utiliser Zero-Touch pour créer les nôtres. Commençons par un exemple simple qui nous permet de faire passer un script python sous la forme d’une chaîne à un nœud Zero-Touch où le script est exécuté et un résultat est renvoyé. Cette étude de cas s’appuie sur les guides et les exemples de la section Mise en route. Reportez-vous à ces derniers si vous êtes novice en matière de création de nœuds Zero-Touch.

Un nœud Zero-Touch qui exécute une chaîne de script Python

Moteur Python

Ce nœud s’appuie sur une instance du moteur de script IronPython. Pour faire cela, nous devons référencer quelques assemblages supplémentaires. Suivez les étapes ci-dessous pour configurer un modèle de base dans Visual Studio :

• créez un projet de classe Visual Studio ;

• ajoutez une référence au IronPython.dll situé dans C:\Program Files (x86)\IronPython 2.7\IronPython.dll ;

• ajoutez une référence au Microsoft.Scripting.dll situé dans C:\Program Files (x86)\IronPython 2.7\Platforms\Net40\Microsoft.Scripting.dll ;

• incluez les instructions IronPython.Hosting et Microsoft.Scripting.Hosting using dans votre classe ;

• ajoutez un constructeur privé vide pour empêcher l’ajout d’un nœud supplémentaire à la bibliothèque Dynamo avec votre package ;

• créez une méthode qui prend une seule chaîne comme paramètre d’entrée ;

• dans cette méthode, nous allons instancier un nouveau moteur Python et créer une portée de script vide. Vous pouvez imaginer cette portée comme les variables globales dans une instance de l’interpréteur Python ;

• appelez ensuite Execute sur le moteur en passant la chaîne d’entrée et la portée comme paramètres ;

• enfin, récupérez et renvoyez les résultats du script en appelant GetVariable sur la portée et en transmettant le nom de la variable de votre script Python qui contient la valeur que vous essayez de renvoyer (Voir l’exemple ci-dessous pour plus de détails).

Le code suivant fournit un exemple pour l’étape mentionnée ci-dessus. La génération de la solution entraîne la création d’un nouveau .dll situé dans le dossier bin de notre projet. Ce .dll peut désormais être importé dans Dynamo en tant que composant d’un package ou en accédant à File < Import Library...

Sorties multiples

L’une des limites des nœuds Python standard est qu’ils n’ont qu’un seul port de sortie. Si nous souhaitons renvoyer plusieurs objets, nous devons construire une liste et récupérer chaque objet à l’intérieur. Si nous modifions l’exemple ci-dessus pour qu’il renvoie un dictionnaire, nous pouvons ajouter autant de ports de sortie que nous le souhaitons. Reportez-vous à la section Renvoyer plusieurs valeurs dans Aller plus loin avec Zero-Touch pour plus de détails sur les dictionnaires.

Ce nœud permet de renvoyer le volume du cuboïde et son centre de gravité.

Modifions l’exemple précédent en procédant comme suit :

• ajoutez une référence DynamoServices.dll du gestionnaire de package NuGet ;

• en plus des assemblages précédents, incluez System.Collections.Generic et Autodesk.DesignScript.Runtime ;

• modifiez le type de retour de notre méthode pour qu’elle renvoie un dictionnaire qui contiendra nos résultats ;

• chaque sortie doit être extraite individuellement de la portée (il est conseillé de configurer une boucle simple pour des ensembles de sorties plus importants).

Nous avons également ajouté une variable de sortie supplémentaire (output2) à l’exemple de script Python. N’oubliez pas que ces variables peuvent utiliser n’importe quelle convention de dénomination légale de Python. La sortie a été utilisée uniquement pour des raisons de clarté dans cet exemple.

Les nœuds basés sur NodeModel offrent beaucoup plus de flexibilité et de puissance que les nœuds Zero-Touch. Dans cet exemple, nous ferons passer le nœud de grille Zero-Touch au niveau supérieur en ajoutant un curseur intégré qui randomise la taille du rectangle.

Le curseur met à l’échelle les cellules en fonction de leur taille, de sorte que l’utilisateur n’a pas besoin de fournir un curseur avec la plage correcte.

Modèle vue-vue modèle

À un haut niveau, établir une relation modèle-vue dans Dynamo se fait en deux temps :

• Une classe NodeModel pour établir la logique de base du nœud (le « modèle »)

• Une classe INodeViewCustomization pour personnaliser la façon dont le NodeModel est affiché (la « vue »)

Les objets NodeModel ont déjà une vue-modèle associée (NodeViewModel), nous pouvons donc nous concentrer uniquement sur le modèle et la vue pour l’interface utilisateur personnalisée.

Comment implémenter NodeModel

Les nœuds NodeModel présentent plusieurs différences significatives par rapport aux nœuds Zero-Touch que nous aborderons dans cet exemple. Avant de passer à la personnalisation de l’interface utilisateur, commençons par générer la logique NodeModel.

1. Créer la structure du projet :

Un nœud NodeModel ne peut appeler que des fonctions, nous devons donc séparer le NodeModel et les fonctions dans des bibliothèques différentes. La façon standard de procéder pour les packages Dynamo est de créer des projets distincts pour chacun d’entre eux. Commencez par créer une nouvelle solution pour englober les projets.

1. Sélectionnez File > New > Project

2. Sélectionnez Other Project Types pour afficher l’option Solution

3. Sélectionnez Blank Solution

4. Nommez la solution CustomNodeModel

5. Sélectionnez Ok

Créez deux projets de bibliothèque de classes C# dans la solution : un pour les fonctions et un pour la mise en œuvre de l’interface NodeModel.

1. Cliquez avec le bouton droit de la souris sur la solution et sélectionnez Add > New Project

2. Choisissez une bibliothèque de classe

3. Nommez-le CustomNodeModel

4. Cliquez sur Ok

5. Répétez l’opération pour ajouter un autre projet nommé CustomNodeModelFunctions

Ensuite, nous devons renommer les bibliothèques de classes qui ont été créées automatiquement et en ajouter une au projet CustomNodeModel. La classe GridNodeModel implémente la classe abstraite NodeModel, GridNodeView est utilisée pour personnaliser la vue et GridFunction contient toutes les fonctions que nous devons appeler.

1. Ajoutez une autre classe en cliquant avec le bouton droit de la souris sur le projet CustomNodeModel, en sélectionnant Add > New Item... et en choisissant Class

2. Dans le projet CustomNodeModel, nous avons besoin de GridNodeModel.cs et de GridNodeView.cs

3. Dans le projet CustomNodeModelFunction, nous avons besoin d’une classe GridFunctions.cs

Avant d’ajouter du code aux classes, ajoutez les packages nécessaires pour ce projet. CustomNodeModel aura besoin de ZeroTouchLibrary et de WpfUILibrary, et CustomNodeModelFunction n’aura besoin que de ZeroTouchLibrary. La bibliothèque WpfUILibrary sera utilisée dans la personnalisation de l’interface utilisateur que nous effectuerons ultérieurement, et la bibliothèque ZeroTouchLibrary sera utilisée pour la création de géométries. Les packages peuvent être ajoutés individuellement pour les projets. Comme ces packages ont des dépendances, Core et DynamoServices seront automatiquement installés.

1. Cliquez avec le bouton droit de la souris sur un projet et choisissez Manage NuGet Packages

2. Installez uniquement les packages requis pour ce projet

Visual Studio copie les packages NuGet référencés dans le répertoire de génération. Cette valeur peut être définie sur False pour éviter que le package ne contienne des fichiers inutiles.

1. Sélectionnez les packages Dynamo NuGet

2. Définissez Copy Local sur False

2. Hériter de la classe NodeModel

Comme indiqué précédemment, l’aspect principal qui différencie un nœud NodeModel d’un nœud Zero-Touch est son implémentation de la classe NodeModel. Un nœud NodeModel a besoin de plusieurs fonctions de cette classe, et nous pouvons les obtenir en ajoutant :NodeModel après le nom de la classe.

Copiez le code suivant dans GridNodeModel.cs.

Cela diffère des nœuds Zero-Touch. Voyons ce que fait chaque partie.

• Spécifiez les attributs de nœud tels que le nom, la catégorie, les noms InPort/OutPort, les types InPort/OutPort et les descriptions.

• public class GridNodeModel : NodeModel est une classe qui hérite de la classe NodeModel de Dynamo.Graph.Nodes.

• public GridNodeModel() { RegisterAllPorts(); } est un constructeur qui enregistre les entrées et les sorties du nœud.

• BuildOutputAst() renvoie une structure ASA (Arbre de la syntaxe abstraite), qui est requise pour renvoyer des données à partir d’un nœud NodeModel.

• AstFactory.BuildFunctionCall() appelle la fonction RectangularGrid à partir de GridFunctions.cs.

• new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid) spécifie la fonction et ses paramètres.

• new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue }); mappe les entrées des nœuds aux paramètres des fonctions.

• AstFactory.BuildNullNode() génère un nœud nul si les ports d’entrée ne sont pas connectés. Cela permet d’éviter l’affichage d’un avertissement sur le nœud.

• RaisePropertyChanged("SliderValue") notifie l’interface utilisateur lorsque la valeur du curseur change.

• var sliderValue = AstFactory.BuildDoubleNode(SliderValue) génère un nœud dans l’ASA qui représente la valeur du curseur.

• Modifiez une entrée pour la variable sliderValue dans la variable functionCall new List<AssociativeNode> { inputAstNodes[0], sliderValue });.

3. Appeler une fonction

Le projet CustomNodeModelFunction sera créé dans un assemblage séparé de CustomNodeModel afin qu’il puisse être appelé.

Copiez le code suivant dans GridFunction.cs.

Cette classe de fonction est très similaire à l’étude de cas Zero-Touch : nœud grille, à une différence près :

• [IsVisibleInDynamoLibrary(false)] empêche Dynamo de « voir » la méthode et la classe suivantes, car la fonction est déjà appelée à partir de CustomNodeModel.

Tout comme nous avons ajouté des références pour les packages NuGet, CustomNodeModel devra faire référence à CustomNodeModelFunction pour appeler la fonction.

L’instruction using pour CustomNodeModel sera inactive jusqu’à ce que nous référencions la fonction

1. Cliquez avec le bouton droit de la souris sur CustomNodeModel et sélectionnez Add > Reference

2. Choisissez Projects > Solution

3. Cochez la case CustomNodeModelFunction

4. Cliquez sur Ok

4. Personnaliser la vue

Pour créer un curseur, nous devons personnaliser l’interface utilisateur en implémentant l’interface INodeViewCustomization.

Copiez le code suivant dans GridNodeView.cs.

• public class CustomNodeModelView : INodeViewCustomization<GridNodeModel> définit les fonctions nécessaires pour personnaliser l’interface utilisateur.

Une fois la structure du projet mise en place, utilisez l’environnement de conception de Visual Studio pour générer un contrôle utilisateur et définir ses paramètres dans un fichier .xaml. Dans la boîte à outils, ajoutez un curseur à <Grid>...</Grid>.

1. Cliquez avec le bouton droit de la souris sur CustomNodeModel et sélectionnez Add > New Item

2. Sélectionnez WPF

3. Nommez le contrôle utilisateur Slider

4. Cliquez sur Add

Copiez le code suivant dans Slider.xaml

• Les paramètres du contrôle du curseur sont définis dans le fichier .xaml. Les attributs Minimum et Maximum définissent la plage numérique de ce curseur.

• Dans <Grid>...</Grid>, nous pouvons placer différents contrôles utilisateur de la boîte à outils de Visual Studio.

Lorsque nous avons créé le fichier Slider.xaml, Visual Studio a automatiquement créé un fichier C# appelé Slider.xaml.cs qui initialise le curseur. Modifiez l’espace de noms dans ce fichier.

• L’espace de noms doit être CustomNodeModel.CustomNodeModel

Le GridNodeModel.cs définit la logique de calcul du curseur.

5. Configurer en tant que package

Avant de générer le projet, la dernière étape consiste à ajouter un fichier pkg.json pour que Dynamo puisse lire le package.

1. Cliquez avec le bouton droit de la souris sur CustomNodeModel et sélectionnez Add > New Item

2. Sélectionnez Web

3. Sélectionnez JSON File

4. Nommez le fichier pkg.json

5. Cliquez sur Add

• Copiez le code suivant dans pkg.json

• "name": détermine le nom du package et de son groupe dans la bibliothèque Dynamo

• "keywords": fournit des termes de recherche pour la bibliothèque Dynamo

• "node_libraries": [] les bibliothèques associées au package

  La dernière étape consiste à générer la solution et à la publier en tant que package Dynamo. Consultez le chapitre Déploiement de package pour savoir comment créer un package local avant de publier en ligne et comment générer un package directement à partir de Visual Studio.