Aide du produit avec base de connaissance de la Communauté
2013
Inventor
HomeInventorFrançais2013HelpAutodesk InventoriLogicFonctions

Évaluation de la Communauté

Cette page a-t-elle été utile ?

Mot clé Balises0

Cette page ne contient aucune balise

Statistiques de la page

1578 vues,  1 modification(s),  381717 caractère(s) Page modifiée à 19:00, 5 Avr 2012 par contentconnector
Comment ajouter vos connaissances

Fonctions

    Procédures | Références

    Qu'est-ce qu'une fonction ?

    Une fonction est une instruction effectuée dans un programme. Cette instruction peut inclure des arguments ou requérir certaines entrées pour s'exécuter correctement.

    Les fonctions sont généralement classées dans un ordre donné afin d'obtenir le résultat souhaité. Par exemple, une fonction récupère une partie des informations provenant de la base de données et la fonction suivante effectue une opération sur les données. En général, dans un programme, chaque fonction est indépendante du reste du code.

    Anatomie d'une fonction

    iLogic offre de nombreuses fonctions à utiliser dans les règles. Les fonctions sont regroupées dans des catégories.

    La procédure suivante est un exemple de la manière dont une fonction peut apparaître dans une règle : 

    returnValue = Category.FunctionName(argument1, argument2, ...)

    Un argument peut être une chaîne de texte, une valeur booléenne Vrai/Faux ou un chiffre.

    Une valeur de chaîne de texte est spécifiée entre guillemets. "ComponentName:1" et "Hole2" sont des exemples de chaînes de texte. Avec l'exemple précédent, si les arguments sont des chaînes de texte, la fonction s'affiche sous la forme : 

    returnValue = Category.FunctionName(“ComponentName:1”,“Hole2”)

    Un paramètre de texte iLogic peut être utilisé comme argument pour une fonction qui attend une chaîne de texte. Un paramètre numérique Inventor peut être utilisé comme argument pour une fonction qui attend un chiffre.

    Une valeur renvoyée peut être une chaîne de texte, une valeur booléenne Vrai/Faux ou un chiffre. Il s'agit souvent d'un élément à lire ou à récupérer à partir du modèle. Vous pouvez tester la valeur renvoyée, ou l'affecter à un paramètre ou à une variable locale dans la règle.

    Certaines fonctions n'ont pas de valeur renvoyée. Dans VB.NET, ce type de fonction est appelée Sub. Elle sert souvent à changer le modèle. Par exemple : 

    Category.FunctionName(argument1, argument2, ...)

    Un autre type de fonction peut être utilisée pour écrire ou attribuer une valeur à un élément dans le modèle Inventor. Dans VB.NET, ce type de fonction est appelée Property. Par exemple : 

    Category.FunctionName(argument1, argument2, ...) = value

    Dans cet exemple, la fonction écrit la valeur pour le modèle.

    Comment utiliser des fonctions dans iLogic ?

    iLogic fournit des fonctions permettant de modifier le modèle Inventor ou de lire certaines données du modèle et de vous les renvoyer. Ces fonctions sont disponibles sou la forme d'extraits de code dans la boîte de dialogue Modifier la règle. Vous devez placer ces fonctions dans des règles (petits programmes en Visual Basic) que vous définissez dans le modèle. Lorsqu'une règle s'exécute, les fonctions au sein de cette règle sont exécutées.

    Procédures

    Fonctions

    Ajouter une fonction à une règle

    1. Sélectionnez la règle dans le navigateur iLogic, soit dans l'onglet Règles, soit dans l'onglet Règles externes.
    2. Cliquez avec le bouton droit de la souris et sélectionnez Modifier la règle.
    3. Dans la zone de texte de la règle de la boîte de dialogue Modifier la règle, positionnez le curseur à l'emplacement où vous voulez insérer la fonction. La plupart des fonctions commencent sur une nouvelle ligne.
    4. Recherchez la fonction dans la zone Extraits de code.
    5. Cliquez deux fois avec la souris pour ajouter la fonction.
    6. Si la fonction inclut des arguments ou requiert des entrées, modifiez le code inséré en conséquence.
    RemarquePour ajouter une fonction manuellement, tapez-la à l'emplacement de votre choix. Vous pouvez également copier une fonction existante dans la règle, puis modifier la copie.

    Modifier une fonction

    Vous pouvez modifier une fonction dans une règle à l'aide des techniques standard d'édition de texte. Utilisez la barre d'outils située au-dessus de la zone de texte de la règle ou le menu contextuel pour obtenir de l'aide pour réaliser certaines opérations.

    Si vous ajoutez une fonction, il est parfois plus rapide et plus efficace de modifier une copie de la fonction qui existe dans la règle. Utilisez la fonction copier/coller pour créer une copie d'une fonction existante qui peut être modifiée.

    Références

    Fonctions Parameter

    Pour accéder aux fonctions Parameter, développez le noeud Paramètres sous l'onglet Système dans la zone Extraits de code.

    Parameter

    Paramètre ("parameterName")

    Cette fonction modifie directement les valeurs du paramètre.

    Dans un ensemble, vous pouvez accéder aux paramètres des composants masqués. Cependant, si un composant est masqué, vous ne pouvez pas accéder à son paramètre directement avec une instruction d'affectation telle que : 

    PartA.ipt.d12 = 6.3

    Au lieu de cela, vous pouvez utiliser : 

    Parameter("PartA:1", "d12") = 6.3

    Notez qu'un nom du composant est spécifié au lieu d'un nom de fichier. Bien que vous donniez à la fonction un numéro de composant spécifique, la modification du paramètre affecte toutes les occurrences du composant. Le nom du composant est simplement un moyen pour la fonction d'identifier le fichier.

    Renommer le composant manuellement afin de conserver son nom si le composant est remplacé.

    Vous pouvez également utiliser la fonction MakePath correspondant au nom du composant : 

    Parameter(MakePath("SubAssem1:1", "Part1:1"), "d12") = 6.3

    Vous pouvez lire la valeur actuelle d'un paramètre à l'aide de la syntaxe de l'une des instructions suivantes :

    param_val = Parameter("d0")

    param_val = Parameter("PartA:1", "d0")

    Comme illustré dans les exemples suivants, le paramètre peut être dans le document actif. Vous pouvez utiliser le nom des paramètres accessibles à partir de la règle.

    Dans un composant qui n'est pas masqué, vous pouvez spécifier le nom de fichier à la place du nom de composant : vous pouvez utiliser cette méthode pour modifier un paramètre d'une pièce de base qui n'apparaît pas en tant que composant dans un ensemble : 

    Parameter("PartA.ipt", "d12") = 6.3

    Si un paramètre est introuvable, la fonction Parameter génère un message d'erreur. Vous pouvez supprimer le message d'erreur de l'une des manières suivantes : 

    Parameter.Quiet = True

    Utilisez cette technique si vous savez que le paramètre est manquant et que vous êtes préparé pour cette condition.

    Accéder aux paramètres de pièces de base

    Vous pouvez accéder aux paramètres dans une pièce de base à partir d'une pièce ou d'un ensemble dérivé. Vous pouvez également y accéder à partir d'un ensemble qui contient une pièce dérivée de la pièce de base.

    Il est parfois utile de transférer les paramètres de la pièce de base à partir de règles dans l'ensemble. Cette technique est appelée modélisation verticale. Lorsque vous modifiez un paramètre de base, les paramètres liés de toutes les pièces dérivées sont également modifiés.

    La pièce et ses paramètres ne sont pas toujours visibles dans l'arborescence du modèle de la boîte de dialogue Modifier la règle. Vous pouvez y accéder à l'aide de la fonction Paramètre. Par exemple, pour modifier un paramètre d'une pièce de base, utilisez : 

    Parameter("BaseShaft.ipt”, ”Diameter") = 0.125 in

    En général, vous n'avez pas à lire de valeurs de paramètres à partir de la pièce de base. Les paramètres sont déjà liés dans la pièce ou l'ensemble dans lesquels vous travaillez.

    Fonctions Parameter avancées

    Utilisez la fonction Parameter.Param pour obtenir l'accès direct à un paramètre Inventor. L'objet renvoyé est le paramètre de type de l'API Autodesk Inventor : 

    param = Parameter.Param("parameterName")
If (param IsNot Nothing) Then
param.Expression = "5.0 in"
param.Tolerance.SetToDeviation(0.002 * 2.54, -0.004 * 2.54)
param.Comment = "Equation and Tolerance set by a rule"
End If

    Vous pouvez également utiliser une seule ligne :

    Parameter.Param("foo").Comment = "Commentaire défini par une règle"

    Vous pouvez accéder à d'autres propriétés d'un paramètre Autodesk Inventor de l'une des manières suivantes : 

    param = Parameter.Param("parameterName")param = Parameter.Param("componentName", "parameterName")

    Ces fonctions produisent un objet de la classe Inventor.Parameter. Voir l'aide à la programmation d'Inventor pour plus d'informations sur cette classe.

    Fonctions MultiValue

    Utilisez des fonctions MultiValue pour accéder à la liste de valeurs stockées avec un paramètre multivaleur et modifier ces valeurs. Voici quelques exemples de leur utilisation :

    MultiValue.SetList(“d0”, 0.5, 0.75, 1.0, 1.25)

    Définit la liste des valeurs disponibles pour le paramètre d0.

    MultiValue.SetList(“d0”, “3/8”, “d1 * 2”, “d1 * 3”)

    Définit des équations au lieu de valeurs. Vous pouvez combiner des équations et des valeurs dans la liste.

    MultiValue.SetList(“filename.ipt.str0”, “Value1”, “Value2”)

    Définit une liste de valeurs pour un paramètre de texte dans une pièce.

    MultiValue.SetList(“Part1:1”, “d0”, 0.5, 0.75, 1.0, 1.25)

    Définit la liste de valeurs d'un paramètre dans un composant.

    values = MultiValue.List(“d0”)

    Extrait la liste de valeurs active, où la variable values est un objet de type VB.NET ArrayList.

    MultiValue.SetValueOptions(True, DefaultIndex := 0, NumericCompare := “=”)

    Force le paramètre à une valeur figurant dans sa liste multivaleur. Si vous modifiez la liste multivaleur par la suite, cette fonction définit également la valeur actuelle du paramètre sur l'une des valeurs de la liste. Cette fonction ne modifie pas la valeur si celle-ci est introuvable dans la nouvelle liste.

    • DefaultIndex := 0

      Si la valeur actuelle du paramètre n'est pas dans la liste, le paramètre est défini sur la première valeur (index 0) dans la liste.

    • NumericCompare := "="

      Effectue une vérification d'égalité. Vous pouvez également utiliser "<=" ou ">=".

    MultiValue.SetValueOptions(False)

    Lorsque vous modifiez la liste multivaleur du paramètre, la valeur réelle du paramètre ne change pas. Ce comportement est le comportement par défaut de MultiValue.

    MultiValue.List(“MyStringParam”) = iProperties.Materials

    Définit un paramètre de texte sur une liste de valeurs équivalente à la liste de matières disponible dans la norme active.

    MultiValue.List(“d0”) = New Double() {0.5, 0.75, 1.0, 1.25}

    Utilise une autre méthode de définition de la liste de valeurs.

    Des exemples qui utilisent des valeurs de Microsoft® Excel, reportez-vous à la section décrivant l'instruction GoExcel.CellValues.

    MultiValue.UpdateAfterChange = True

    Cette instruction met immédiatement à jour le modèle Inventor comme lorsque vous définissez le paramètre Parameter.UpdateAfterChange sur True.

    MultiValue.Quiet = True

    Masque le message d'erreur qui s'affiche lorsqu'un paramètre est introuvable. Utilisez cette fonction si vous savez que le paramètre est manquant et que vous êtes préparé pour cette condition. Par exemple, il est possible que le paramètre n'existe pas dans chaque pièce à laquelle s'applique la règle.

    foundVal = MultiValue.FindValue(aList, "<=", 4.0)

    Recherche la valeur dans une liste qui se rapproche le plus de la condition. aList peut être un ArrayList ou Array. L'argument pour la comparaison peut être "<=", "=" ou ">=".

    L'exemple suivant recherche la valeur inférieure ou égale à 4.0. Si plusieurs valeurs existent, la valeur la plus proche de 4.0 est renvoyée. S'il n'existe pas de valeur correspondante, cet exemple renvoie la constante VB "Nothing". 

    foundVal = MultiValue.FindValue(MultiValue.List("d0"), "<=", 4.0)

    Vous pouvez tester pour cette condition.

    Fonctions Feature

    iLogic fournit des fonctions permettant de définir ou de lire l'état de masquage des fonctions, les couleurs et les désignations de filetage.

    Utilisez la fonction Feature pour vos filetages ou pour définir ou lire les propriétés des fonctions de filetage ou de perçage taraudé. Ces propriétés apparaissent également dans la boîte de dialogue de modification d'une fonction de filetage ou de perçage taraudé.

    Pour accéder aux fonctions Feature, développez le noeud Fonctions sous l'onglet Système de la zone Extraits de code.

    Feature.IsActive (avec le nom de la fonction)

    Définit ou lit l'état de masquage pour une fonction de pièce ou d'ensemble. Utilisez cette fonction pour masquer ou afficher les fonctions d'une pièce ou d'un ensemble Inventor. Lorsque vous changez l'état d'une fonction, vous modifiez également les fonctions dépendantes. Cela vous évite d'avoir à spécifier les fonctions dépendantes dans la règle.

    RemarqueSi vous modifiez manuellement l'état d'activation d'une fonction, aucune règle ne référence cette modification et ne peut être lancée automatiquement. Dans une pièce, vous pouvez définir ces règles de manière à ce qu'elles soient automatiquement déclenchées en les ajoutant à la liste des règles déclenchées par la modification de l'état de masquage de fonction. Cet événement est accessible par la commande Evénements déclencheurs.

    Si vous modifiez le nom d'un objet après avoir écrit une règle qui contient cette fonction, modifiez la règle. Remplacez l'ancien nom par le nouveau nom. Modifiez les noms de fonctions (si nécessaire) avant de créer des règles.

    Les noms de fonctions doivent toujours être placés entre guillemets.

    Syntaxe

    Feature.IsActive("nom de la fonction")

    Exemple

    if bracket_width >= 3 then
Feature.IsActive("flange_hole_pattern") = true
Feature.IsActive("base_hole_pattern") = true
else
Feature.IsActive("flange_hole_pattern") = false
end if

    Feature.IsActive (avec le composant et le nom de la fonction)

    Cette variation de la fonction Feature.IsActive définit ou lit l'état de masquage des fonctions dans une pièce ou un sous-ensemble en spécifiant le composant et le nom de la fonction. Utilisez la syntaxe suivante pour contrôler l'état d'activation des fonctions de pièces à partir d'une règle au niveau de l'ensemble.

    Syntaxe

    Feature.IsActive("nom du composant", "nom de la fonction")

    Exemples

    Pour définir l'état de masquage : 

    Feature.IsActive("PartA:1", "Hole:1") = false

    Pour lire l'état de masquage : 

    MyBooleanParameter = Feature.IsActive("PartA:1","Hole:1")

    Feature.Color

    Définit ou lit la couleur d'une fonction de pièce en spécifiant le nom de la fonction. Cette fonction n'est pas compatible avec les fonctions d'ensemble.

    La valeur de la couleur est une chaîne de texte. Le texte doit être placé entre guillemets. Il doit également posséder la même casse et l'orthographe exacte des couleurs disponibles dans la norme active du document Autodesk Inventor en cours.

    Syntaxe

    Feature.Color("nom de la fonction")

    Exemples

    Pour définir la couleur : 

    Feature.Color("Hole:1") = "Green"
Feature.Color("Hole:2") = "Aluminum (Cast)
"Feature.Color("Hole:3") = "As Material"

    Pour lire la couleur : 

    MyStringParameter = Feature.Color("Chamfer:1")

    Définit ou lit la couleur des fonctions d'un sous-ensemble ou d'une pièce en spécifiant le nom du composant et le nom de la fonction : 

    Feature.Color("componentName", "featurename")

    Feature.ThreadDesignation

    Définit ou lit la désignation du filetage d'une fonction de filetage dans un fichier pièce ou ensemble. La désignation du filetage est une chaîne de texte. Elle doit être spécifiée avec la chaîne exacte qui apparaît dans le champ Désignation de la boîte de dialogue de modification de la fonction filetée.

    Pour un filetage conique, indiquez la valeur qui est affichée dans le champ Taille de la boîte de dialogue Filetage. Cette valeur est généralement une version réduite de la désignation du filetage.

    Syntaxe

    Feature.ThreadDesignation("nom de la fonction") = "<valeur de désignation>"

    Si vous le souhaitez, utilisez la syntaxe suivante pour afficher la désignation du filetage au format requis pour sa définition :

    threadDes = Feature.ThreadDesignation("Filetage1")

    Lorsque vous définissez la désignation du filetage pour un perçage avec une règle, la taille du perçage s'ajuste automatiquement.

    Pour une tige filetée, vous pouvez utiliser une règle pour modifier le diamètre de tige et la désignation du filetage en même temps. Le diamètre de tige doit être compatible avec la désignation du filetage.

    Exemple

    If rod_type = "small" Then
Feature.ThreadDesignation("Thread1") = "3/8-16 UNC"
rod_diameter = 0.375
ElseIf rod_type = "large" Then
Feature.ThreadDesignation("Thread1") = "1/2-13 UNC"
rod_diameter = 0.500
End If

    Vous pouvez également définir ou lire la désignation du filetage d'une fonction de filetage dans un fichier pièce ou ensemble à partir d'une règle au niveau de l'ensemble. Spécifiez le composant ou le nom de fichier et le nom de la fonction filetée : 

    Feature.ThreadDesignation("PartA.ipt", "featurename") = "1/2-13UNC"
    Feature.ThreadDesignation("PartA:1", "featurename") = "1/2-13UNC"

    Feature.SetThread

    Effectue des modifications importantes à un perçage ou une fonction filetée. Définit le type, la désignation et la classe. Utilisez cette fonction pour basculer entre les filetages en pouces et les filetages métriques. Vous ne pouvez pas passer d'une droite à un filetage conique et inversement.

    RemarquePour un filetage conique, remplacer une chaîne vide ("") pour la classe de filetage. Vous pouvez également utiliser la taille au lieu de la désignation.

    Syntaxe

    Feature.SetThread("nom de la fonction", "type de filetage", "désignation du filetage", "classe de filetage")

    Sinon, utilisez la syntaxe suivante pour apporter des modifications importantes à un perçage ou filetage dans un composant :

    Feature.SetThread("nom du composant", "nom de la fonction", "type de filetage", "désignation du filetage", "classe de filetage")

    Feature.ThreadType

    Extrait le type de filetage d'un perçage ou d'une fonction filetée. Exemples : "Taraudages de vis unifiée ANSI", "Profil en M métrique ANSI", etc. Pour modifier le type, utilisez SetThread et définissez la désignation et la classe en même temps.

    Syntaxe

    currentType = Feature.ThreadType("nom de la fonction")

    Vous pouvez également utiliser cette syntaxe pour obtenir le type de filetage d'un perçage ou d'une fonction filetée dans un composant :

    currentType = Feature.ThreadType("nom du composant", "nom de la fonction")

    Feature.ThreadClass

    Définit la classe du filetage d'un perçage ou d'une fonction filetée. Plus le chiffre est élevé, plus le filetage est précis.

    Syntaxe

    Feature.ThreadClass("nom de la fonction") = "3B"

    Utilisez la syntaxe suivante pour obtenir la classe du filetage d'un perçage ou d'une fonction filetée :

    currentClass = Feature.ThreadClass("nom de la fonction")

    Utilisez la syntaxe suivante pour définir la classe du filetage d'un perçage ou d'une fonction filetée dans un composant :

    Feature.ThreadClass("nom du composant", "nom de la fonction") = "3B"

    RemarqueNe s'applique pas à un filetage conique.

    Extrait la classe du filetage d'un perçage ou d'une fonction filetée dans un composant.

    currentClass = Feature.ThreadClass("nom du composant", "nom de la fonction")

    Fonctions Component

    iLogic fournit des fonctions de règles pour la définition ou la lecture des couleurs et des états de masquage de composant ainsi qu'une fonction pour remplacer un composant par un autre. Ces fonctions sont utiles pour contrôler les différentes configurations des pièces ou des ensembles.

    Vous pouvez créer un modèle (pièce ou ensemble) qui inclut les composants nécessaires pour représenter toutes les configurations correctes et possibles d'un produit. Cette méthode est appelée "super modélisation". Lorsque les composants d'un ensemble ou d'une pièce sont trop complexes ou nombreux et que la super modélisation devient impossible, utilisez la fonction Component.Replace.

    Pour accéder aux fonctions Component, développez le noeud Composants sous l'onglet Système de la zone Extraits de code.

    Attribution d'un nom de composant

    Personnalisez tous les noms de composants avant de référencer les noms dans une règle. Lorsque vous modifiez le nom du composant affecté par défaut par Autodesk Inventor, vous vous assurez qu'il ne change pas lorsque le fichier .ipt ou .iam référencé est modifié.

    Vous pouvez renommer le composant avec son nom d'origine et conserver sa stabilité. Pour modifier le composant, apportez une modification mineure au nom, puis rétablissez l'original.

    Pour un composant du Centre de contenu, un changement de nom est requis pour la fonction Component.IsActive ainsi que pour la fonction Component.Replace.

    Component.IsActive

    Définit ou lit l'état de masquage et la structure de nomenclature d'un composant d'ensemble. Utilisez cette fonction pour inclure ou exclure un composant dans une configuration d'ensemble.

    La fonction s'applique à un seul composant ou à des réseaux de composants. Pour les réseaux, utilisez le nom du réseau. Le réseau doit être au même niveau d'ensemble que la règle, et non dans un sous-ensemble.

    Ne masquez pas les sous-composants. Il est donc préférable d'effectuer le masquage à partir d'une règle située au sein du composant.

    Par exemple, un ensemble nommé TopAssembly contient un sous-ensemble SubAssembly:1 qui, lui-même, contient une pièce SamplePart:1.

    Utilisez une règle de SubAssembly pour masquer SamplePart:1. Cette règle peut disposer d'un paramètre qui contrôle l'état de masquage, et vous pouvez manipuler le paramètre par une règle dans TopAssembly.

    Lorsque vous utilisez iLogic pour masquer un composant, la structure de nomenclature du composant est définie sur Référence. Cette action évite que ce composant s'affiche dans la nomenclature. Il apparaît dans la vue des données de modèle, mais pas dans la vue Structuré ou Pièces uniquement. Si le composant est visible, iLogic renvoie le composant à son état avant le masquage (de type Normal, Indivisible et Acheté ou Fantôme).

    Avant d'utiliser une règle iLogic pour modifier l'état de masquage d'un composant d'ensemble, créez et activez un niveau de détail personnalisé.

    Syntaxe

    Component.IsActive("ComponentName")

    Exemples

    Vous pouvez utiliser la valeur 1 au lieu de true et 0au lieu de false.

    Pour définir l'état de masquage et la structure de la nomenclature : 

    Component.IsActive("PartA:1") = false
Component.IsActive("PartB:1") = 0
Component.IsActive("PartC:1") = false
Component.IsActive("PartD:1") = 0

    Pour lire l'état de masquage et la structure de la nomenclature : 

    MyBooleanParam = Component.IsActive("ComponentName:1)
If Component.IsActive("PartE") Then
' do something
End If

    Component.iComponentIsActive

    Variation de Component.IsActive, cette fonction définit ou lit l'état de masquage d'un composant d'iPièce ou d'iEnsemble. Si vous n'avez pas modifié manuellement le nom du composant, les iPièces et les iEnsembles requièrent l'utilisation de cette syntaxe dédiée.

    Il est conseillé de modifier le nom du composant. Si vous le souhaitez, vous pouvez ensuite utiliser Component.IsActive au lieu de cette fonction.

    Syntaxe

    Component.iComponentIsActive(“iPartParentName:1”)

    iPartParentName

    Le nom de pièce de famille sans l'extension de nom de fichier .ipt.

    Component.Color

    Définit ou lit la couleur d'un composant.

    Syntaxe

    Component.Color(“iPartA:1”)

    Exemples

    Pour définir la couleur : 

    Component.Color("iPartA:1") = "Green"
Component.Color("iPartA:2") = "Aluminum (Cast)"
Component.Color("iPartA:3") = "As Material"

    Pour lire la couleur : 

    MyStringParameter = Component.Color("iPartA:1")

    Component.Visible

    Définit ou lit la visibilité d'un composant. Cette fonction ne change pas la structure de nomenclature du composant.

    Syntaxe

    Component.Visible("componentName")

    Exemples

    Pour définir la visibilité : 

    Component.Visible("Plate") = true
Component.Visible("Bearing") = false

    Pour lire la visibilité : 

    parameter = Component.Visible("Plate")
parameter = Component.Visible("Bearing")
    If Component.Visible("PartE") Then
do something
End If

    Component.SkipDocumentSave

    Indique si un fichier composant doit être enregistré dès qu'il change et ensuite si le composant doit être masqué par une règle.

    Syntaxe

    Component.SkipDocumentSave = True

    Lorsque cette option est définie sur True, le fichier composant n'est pas enregistré.

    La valeur par défaut est False (Component.SkipDocumentSave = False) ; le fichier composant est enregistré.

    Component.Replace

    Remplace une pièce ou un sous-ensemble par un(e) autre. Cette fonction peut également être utilisée pour remplacer des réseaux de composants.

    Utilisez des iContraintes dans des composants en cours de modification pour conserver les contraintes d'ensemble tel quel. Vous pouvez remplacer une pièce par une pièce, une pièce par un ensemble ou un ensemble par une pièce.

    La fonction recherche dans plusieurs répertoires (dossiers) le fichier à utiliser en remplacement :

    • Répertoire du fichier composant remplacé
    • Répertoire du fichier ensemble
    • Dossier de l'espace de travail du projet actif

    Le nom de fichier peut être un chemin relatif (par rapport à l'un de ces emplacements de recherche).

    RemarqueAvant d'utiliser cette fonction, "stabilisez" le nom du composant pour empêcher sa modification de lors du remplacement. Pour stabiliser le nom du composant, modifiez-le. Vous pouvez même stabiliser ce nom en le modifiant une fois, puis en rétablissant le nom d'origine. Si vous ne parvenez pas à stabiliser le nom, l'opération de remplacement modifie le composant pour correspondre à l'autre nom. Dans ce cas, la règle ne peut pas trouver le composant lorsqu'elle s'exécute de nouveau.

    Syntaxe

    Component.Replace(“ComponentToReplaceName”, “OtherPartfilename.ipt”, <replaceAll>)

    ComponentToReplaceName

    Nom de la pièce ou du sous-ensemble à remplacer.

    OtherPartfilename

    Pièce ou ensemble de remplacement.

    <replaceAll>

    Définissez cette valeur booléenne sur True pour remplacer toutes les occurrences de ce composant. Définissez la valeur sur False pour remplacer uniquement l'occurrence avec ce nom.

    Exemple

    If PartType = "Type A" Then
Component.Replace("Widget","PartA.ipt", True)
ElseIf PartType = "Type B" Then
Component.Replace("Widget","PartB.ipt", True)
End If

    Component.Replace (avec niveau de détail spécifié)

    Cette variation de la fonction Component.Replace remplace un composant dans un ensemble par un autre composant de niveau de détail spécifique.

    Syntaxe

    Component.Replace("SubAssem:1", "OtherAssemFilename.iam<Level of Detail>", <replaceAll>)

    Dans cette fonction, l'argument <replaceAll> est le même que celui indiqué pour la fonction Component.Replace plus générique.

    Vous pouvez également remplacer un sous-ensemble par le même sous-ensemble de niveau de détail différent.

    Component.ReplaceiPart

    Requise pour les iPièces avec des paramètres personnalisés, cette fonction est également recommandée pour les iPièces normalisées. Utilisez-la à la place de Component.Replace lorsque le composant est une iPièce. Vous pouvez utiliser iPart.ChangeRow ou iPart.FindRow après le remplacement pour changer la configuration d'iPièce spécifique.

    Pour une iPièce avec des paramètres personnalisés, répertoriez les valeurs des paramètres personnalisés après le numéro de ligne. Ces valeurs doivent s'afficher dans l'ordre dans lequel elles apparaissent dans le tableau.

    Syntaxe

    Component.ReplaceiPart("iPart1:1", "OtherPartfilename.ipt", True, rowNumber)

    Utilisez rowNumber pour remplacer le composant et choisissez une ligne d'iPièce en même temps.

    Exemples

    Pour définir les paramètres personnalisés, répétez les valeurs personnalisées dans Component.ReplaceiPart et à nouveau dans iPart.ChangeRow ou ultérieurement dans iPart.FindRow dans la règle.

    Pour ChangeRow : 

    Component.ReplaceiPart("iPart1:1", "OtherPartfilename.ipt", True, rowNumber, customParam1, customParam2)
iPart.ChangeRow("iPart1:1", rowNumber, customParam1, customParam2)

    Pour FindRow : 

    Component.ReplaceiPart("iPart1:1", "OtherPartfilename.ipt", True, rowNumber, customParam1, customParam2)
i = iPart.FindRow("iPart1:1", "Dia", ">=", 3.0, "r;|", customParam1, customParam2)

    MakePath

    Définit le chemin d'accès à un nom de composant d'un sous-ensemble. Pour spécifier le chemin d'accès, liste tous les niveaux dans l'ordre dans lequel ils apparaissent dans l'arborescence. Cette fonction est nécessaire si vous voulez spécifier un nom de composant lorsque le même nom existe déjà ailleurs dans l'ensemble.

    Syntaxe

    MakePath(“SubassemblyComponentName”,“PartComponentName”)

    Exemples

    Component.Color(MakePath("SubAssem1:1", "Part2:1")) = “Green”
Component.IsActive(MakePath("SubAssem1:1", "SubSubAssem2:1", "Part2:1")) = “Yellow”

    Fonctions iProperties

    iLogic fournit des fonctions de règles pour la définition ou l'obtention des iPropriétés de pièce, d'ensemble et de documents de dessin Inventor. Comme les règles servent à transformer ou modifier des conceptions en nouvelles configurations, conservez les iPropriétés des documents de conception à jour. Les iPropriétés doivent être mises à jour dans la nomenclature pour être correctes. Les règles peuvent également être utilisées pour lire les valeurs des iPropriétés d'un document et réagir en fonction. Par exemple, vous pouvez avoir une règle qui modifie l'épaisseur d'une pièce lorsque la propriété d'une matière change. Une règle peut entraîner des modifications si le volume de la pièce dépasse une valeur maximale ou minimale. Toute iPropriété qui peut être définie manuellement peut être définie ou lue à l'aide d'une règle.

    Pour accéder aux fonctions iProperties, développez le noeud iPropriétés sous l'onglet Système de la zone Extraits de code.

    iProperties.Value

    Syntaxe

    iProperties.Value("property tab name", "property name")

    Définit ou lit la valeur d'une propriété dans le document qui contient la règle.

    iProperties.Value("filename.ipt", "property tab name", "property name")

    Fonction utilisée dans une règle d'ensemble pour accéder aux iPropriétés d'une pièce ou d'un sous-ensemble.

    Si le nom de fichier de la pièce ou du sous-ensemble est modifié, le texte de la règle doit également être modifié.

    Il est préférable d'utiliser le nom de composant (après sa personnalisation) plutôt que le nom de fichier.

    iProperties.Value("custom component name", "property tab name", "property name")

    Définit ou lit les valeurs de propriété d'un composant. Cette fonction utilise le nom de composant au lieu du nom de fichier. Personnalisez le nom du composant (en changeant son nom par défaut) pour qu'il ne change pas si la référence de fichier est modifiée.

    Exemples

    Pour définir la valeur d'iPropriété : 

    iProperties.Value("Project", "Stock Number") = "302A"

    Pour lire la valeur d'iPropriété : 

    MyStringParam = iProperties.Value("Project", "Stock Number")

    Pour définir une valeur d'iPropriété personnalisée : 

    iProperties.Value("Custom", "Age") = 41 'number type
iProperties.Value("Custom", "Company") = "Autodesk, Inc" 'text type
iProperties.Value("Custom", "Date") = CDate("11/1/2008") ' date type
iProperties.Value("Custom", "Insured") = true 'yes or no type

    Pour lire une valeur d'iPropriété personnalisée : 

    age = iProperties.Value("Custom", "Age")
company = iProperties.Value("Custom", "Company")
thedate = CStr(iProperties.Value("Custom", "Date"))
insured = iProperties.Value("Custom", "Insured")

    Rappel

    • La plupart des propriétés sont des chaînes de texte.
    • Les propriétés dont le nom comprend date sont des dates. Dans les règles, ces propriétés peuvent être lues et définies par les variables locales du type VB.NET Date. Souvent, il n'est pas nécessaire de connaître le type de propriété car VB.NET convertit automatiquement la valeur.
    • La propriété Coût estimé (sous Projet) est un nombre.
    • La propriété Etat de la conception (sous Etat) est un cas particulier. Utilisez un nombre, bien qu'il s'affiche dans l'Editeur d'iPropriétés dans une liste de choix. L'exemple suivant utilise des variables temporaires. 
      Work_In_Progress = 1
Pending = 2
Released = 3
iProperties.Value("Status", "Design State") = Pending

    Fonctions abandonnées

    Les versions précédentes d'iLogic utilisaient les fonctions suivantes pour obtenir les iPropriétés de pièces dans un ensemble :

    iProperties.ValueInDoc("filename.ipt", "property tab name", "property name")

    Référence le nom du fichier.

    iProperties.ValueInComponent("custom component name", "property tab name", "property name")

    Référence le nom du composant.

    Bien que ces fonctions ne soient pas disponibles dans la zone Extraits de code de la boîte de dialogue Modifier la règle, elles peuvent être utilisées dans une règle. Toutefois, la fonction iProperties.Value est mieux adaptée que ces fonctions plus anciennes.

    iProperties.StylesInEnglish

    Cette fonction prend en charge l'utilisation du même document dans différentes versions de langue d'Autodesk Inventor. Le modèle est plus portable s'il utilise des noms anglais pour les matières et les couleurs dans les règles. Si vous définissez cette fonction sur VRAI, toute fonction qui renvoie des noms de matière ou de couleur renvoie alors les noms en anglais. Vous pouvez utiliser des noms dans la langue de votre installation d'Autodesk Inventor pour définir une matière ou un nom de couleur. Toutefois, il est recommandé d'utiliser des noms en anglais pour assurer la cohérence. Les fonctions suivantes renvoient des noms en anglais lorsque vous définissez la valeur iProperties.StylesInEnglish sur VRAI :

    • iProperties.Material
    • iProperties.MaterialOfComponent
    • iProperties.Materials
    • iProperties.PartColor
    • Feature.Color
    • Component.Color

    iProperties.Material

    Définit ou lit la matière dans un document.

    Lors de la définition de la matière; utilisez le nom de la matière (en respectant la casse) telle qu'il apparaît dans la liste des propriétés de matières standard active. Les valeurs de matière sont toujours des chaînes de texte, placées entre guillemets.

    Exemples

    Pour définir la matière : 

    iProperties.Material = "Gold"

    Pour lire la matière : 

    MyStringParam = iProperties.Material

    iProperties.Material(“filename.ipt”)

    Définit ou lit la matière d'une pièce dans un ensemble, en précisant le nom de fichier.

    iProperties.Material(“componentName:1”)

    Dans une règle de niveau d'ensemble, permet d'accéder à la matière d'une pièce dans l'ensemble, en spécifiant le nom du composant.

    iProperties.PartColor

    Définit ou lit la couleur d'une pièce. Les valeurs de couleur de pièce sont des chaînes de texte entre guillemets. La modification de la couleur n'a pas d'incidence sur la valeur de matière actuelle.

    Cette fonction s'applique aux pièces uniquement.

    Exemples

    Pour définir la couleur : 

    iProperties.PartColor = "Green"
iProperties.PartColor = "As Material"

    Pour lire la couleur : 

    MyStringParam = iProperties.PartColor

    iProperties.Mass

    Lit ou écrit la masse dans le fichier pièce ou ensemble contenant la règle.

    Si vous écrivez sur la masse, la masse calculée est remplacée. Pour rétablir la valeur calculée, définissez la masse sur -1.

    iProperties.Mass(“filename.ipt”)

    Lit ou écrit la masse d'une pièce ou d'un sous-ensemble dans un ensemble, en précisant le nom de fichier.

    iProperties.Mass(“component name:1”)

    Lit ou écrit la masse d'un composant dans un ensemble, en spécifiant le nom du composant. Cette fonction peut également être utilisée pour lire et écrire sur la masse d'un composant virtuel.

    Exemples

    Pour lire la masse : 

    MyMassParam = iProperties.Mass
MyMassParam = iProperties.Mass("component:1")
MyMassParam = iProperties.Mass("mypart.ipt")

    Pour définir la masse (et remplacer automatiquement la valeur calculée) : 

    iProperties.Mass = 3 kg
iProperties.Mass("virtual_component") = 233 g
iProperties.Mass("mypart.ipt") = 4.2 lb
massiProperties.Mass = -1 'set the mass back to automatic calculation

    iProperties.Volume

    Lit ou écrit le volume dans le document contenant la règle.

    iProperties.Volume(“filename.ipt”)

    Lit ou écrit le volume d'une pièce ou d'un sous-ensemble qui contient la règle, en précisant le nom de fichier.

    iProperties.Volume(“component:1”)

    Lit ou écrit le volume d'un composant dans un ensemble, en spécifiant le nom du composant. Cette fonction peut également être utilisée pour lire et écrire sur le volume d'un composant virtuel.

    Exemples

    Pour lire le volume : 

    MyVolumeParam = iProperties.Volume
MyVolumeParam = iProperties.Volume("component:1")
MyVolumeParam = iProperties.Volume("mypart.ipt")

    Pour définir le volume (et remplacer automatiquement la valeur calculée) : 

    iProperties.Volume = 12.4 in^3
iProperties.Volume("virtual_component") = 542 cm^3
iProperties.Volume("mypart.ipt") = 12.8 in^3
iProperties.Volume = -1 'set it back to automatic calculation

    iProperties.CenterOfGravity

    Lit le centre de gravité du modèle dans le document contenant la règle.

    Syntaxe

    pt = iProperties.CenterOfGravity

    pt est de type Inventor.Point, fonction décrite dans l'aide sur l'API Inventor. Vous pouvez lire les valeurs X, Y et Z du point, exprimées dans les unités du document contenant la règle : 

    cx = pt.X
cy = pt.Y
cz = pt.Z

    pt = iProperties.CenterOfGravity("component")

    Lit le centre de gravité d'un composant dans un ensemble, indiquant le nom du composant.

    iProperties.Area

    Affiche l'aire de la surface du modèle dans le document contenant la règle.

    Syntaxe

    surfaceArea = iProperties.Area

    surfaceArea = iProperties.Area(“component:1”)

    Affiche l'aire de la surface d'un composant dans un ensemble, en spécifiant le nom du composant.

    Fonction de liaisons de données Excel

    iLogic fournit des fonctions de règles pour la lecture et l'écriture dans des documents Microsoft Excel®. Pour accéder à la fonction de liaisons de données Excel, développez le noeud Liaisons de données Excel sous l'onglet Système de la zone Extraits de code.

    Deux types de fonctions de liaisons de données Excel sont disponibles :

    • Les fonctions permettant de lire les données dans des tableaux.
    • Les fonctions permettant de lire et d'écrire des données dans une cellule spécifique.

    Pour lire et écrire vers d'autres formats de fichier, ajouter un code VB.NET personnalisé à vos règles.

    Utilisez la fonction dédiée ThisBOM.Export pour exporter une nomenclature d'ensemble vers Microsoft® Excel et d'autres formats.

    Spécifier le fichier Excel

    Vous pouvez incorporer des données Microsoft® Excel ou les lier dans un document Autodesk Inventor, ou encore les conserver dans un fichier externe. Les fonctions nécessitent soit un nom de fichier soit une spécification de fichier Excel lié ou incorporé.

    Pour un nom de fichier, vous pouvez spécifier un chemin relatif ou absolu. Cependant, les chemins absolus peuvent rendre difficile l'envoi du modèle vers un autre utilisateur travaillant sur un autre ordinateur. Si aucun chemin n'est spécifié, iLogic suppose que le document Excel se trouve dans le même dossier que le document Inventor actif. Un chemin d'accès relatif est interprété comme un chemin relatif vers le dossier contenant le document Inventor.

    iLogic recherche également le fichier dans le chemin de l'espace de travail du projet. Vous pouvez utiliser un chemin relatif dans l'espace de travail du projet.

    Les extensions de nom de fichier pris en charge sont .xls, .xlsx, .xlsm et .xlsb.

    Vous pouvez également spécifier une feuille de calcul liée ou incorporée au lieu d'un nom de fichier. Utilisez la syntaxe 3rd Party:Embedding# pour obtenir des feuilles de calcul incorporées.

    Utilisez la syntaxe 3rd Party:LinkedName.xls pour obtenir des feuilles de calcul liées. Spécifiez le nom qui s'affiche dans l'arborescence du modèle Autodesk Inventor, sous Tiers.

    Si vous utilisez une table incorporée, incorporez-la à l'aide de l'option Lier dans la boîte de dialogue Paramètres. Ne modifiez pas le nom d'origine de la table incorporée, défini par Autodesk Inventor (par exemple, Incorporation de 1). GoExcel requiert le nom d'origine.

    RemarqueN'ajoutez pas d'espace après le caractère : dans la syntaxe 3rd Party:Name.

    Pour lier un fichier, cliquez sur l'onglet Gérerle groupe de fonctions Insérer Insérer objet ou utilisez l'option Lier dans la boîte de dialogue Paramètres.

    GoExcel.FindRow

    Permet de rechercher une ligne en fonction d'un ou plusieurs critères de valeur de la colonne.

    Syntaxe

    GoExcel.FindRow("filename", "sheetname", "first column title", "operator", valeur à rechercher, "second column title","operator", valeur à rechercher, "third column title",...)

    "filename"

    Indique le fichier de données.

    "sheetname"

    Feuille de calcul du document Excel contenant le tableau pour la recherche. Il peut s'agir de n'importe quelle feuille existante.

    "first column title"

    Titre de la première colonne du tableau pour la recherche. Les titres de colonne sont généralement placés dans la ligne 1, en commençant par la colonne A.

    "operator"

    Les valeurs possibles sont les suivantes :

    • <=

      Permet de rechercher une ligne avec une valeur de colonne qui soit inférieure ou égale à la valeur spécifiée.

    • >=

      Permet de rechercher une ligne avec une valeur de colonne qui soit supérieure ou égale à la valeur spécifiée.

    • =

      Permet de rechercher une ligne avec une valeur de colonne numérique ou textuelle qui soit égale à la valeur spécifiée.

    valeur à rechercher

    Valeur numérique ou textuelle qui peut être définie avec une valeur explicite, un paramètre ou une variable locale.

    "second column title"

    Titre de la deuxième colonne dans le tableau pour la recherche.

    "operator"

    <= , >= ou =

    valeur à rechercher

    "third column title"

    Rechercher une ligne basée sur plusieurs critères.

    Retours

    Numéro de ligne (un entier) qui correspond aux critères de recherche. La valeur est -1 si une telle ligne est introuvable.

    Erreurs possibles

    • Fichier introuvable
    • Nom de la feuille introuvable
    • Nom de colonne introuvable
    • La valeur d'entrée est de type incorrect (ne correspond pas au type de valeur de la colonne)

    Tableau Excel requis

    • Le tableau doit avoir une configuration horizontale (table définie par des lignes, et non par des colonnes).
    • Les titres de colonne doivent apparaître dans la première cellule de la colonne.
    • Les valeurs de résultat de la recherche peuvent être numériques ou textuelles.

    Exemples

    Ces exemples définissent la valeur de la variable de paramètre i sur le numéro de la ligne de la table. Dia est égal à 0.2 et Len est supérieur ou égal à 4.1. Le premier exemple se rapporte à une feuille de calcul externe et le second exemple à une feuille de calcul incorporée. 

    i = GoExcel.FindRow("mytable.xls", "Sheet1", "Dia", "=", 0.2, "len", ">=",4.1)
    i = GoExcel.FindRow("3rd Party:Embedding 1", "Sheet1", "Dia", "=", 0.2, "len",">=", 4.1)

    Dans ces exemples, les lignes 5, 6 et 7 correspondent à la première condition Dia=.2. Toutefois, seule la ligne 7 respecte les critères Dia=.2 et len>=4.1.

    GoExcel.CurrentRowValue

    Lit une valeur à partir de la ligne trouvée à l'aide de la fonction GoExcel.FindRow.

    Syntaxe

    GoExcel.CurrentRowValue("column name")

    "column name"

    Nom du titre de la colonne pour la valeur de la cellule tirée de la ligne actuelle.

    Retours

    Valeur de la cellule tirée de la colonne de la ligne actuelle, précédemment trouvée avec la fonction GoExcel.FindRow.

    Erreurs

    Renvoie un message d'erreur si la colonne est introuvable.

    Exemple

    i = GoExcel.FindRow("iLogic_SCHS.xls", "Sheet1", "thread_diameter", "=", Screw_Size, "screw-length", ">=",
screw_length_required)
thread_diameter = GoExcel.CurrentRowValue("thread_diameter")
screw_length =  GoExcel.CurrentRowValue("screw_length")
head_diameter = GoExcel.CurrentRowValue("head_diameter")
head_thickness = GoExcel.CurrentRowValue("head_thickness")
socket_size =  GoExcel.CurrentRowValue("socket_size")
thread_pitch =  GoExcel.CurrentRowValue("thread_pitch")

    GoExcel.CellValue

    Lit ou écrit les valeurs dans les cellules de la feuille de calcul.

    Syntaxe

    GoExcel.CellValue("filename", "sheetname", "cellnumber")

    "filename"

    Reportez-vous à la section Spécifier le fichier Excel.

    "sheetname"

    Nom de la feuille du document Excel contenant la cellule cible. Il peut s'agir de n'importe quelle feuille existante.

    "cell number"

    Adresse de la cellule pour la lecture ou l'écriture (exemple : “A7”). Vous pouvez également spécifier une plage de cellules nommée dans la feuille de calcul.

    Retours

    • Valeur de cellule
    • Aucune affectation si une erreur se produit

    Erreurs

    • Fichier introuvable
    • Nom de la feuille introuvable

    Format de tableau Excel requis

    Les valeurs de cellule peuvent être numériques ou textuelles.

    Exemples

    Pour lire dans une feuille de calcul incorporée : 

    head_rad = GoExcel.CellValue("3rd Party:Embedding 4", "Sheet1","A1")

    Pour écrire dans une feuille de calcul incorporée : 

    GoExcel.CellValue("3rd Party:Embedding 4", "Sheet1", "A1")= head_rad

    Pour lire dans une feuille de calcul externe : 

    head_rad = GoExcel.CellValue("Spreadsheet.xlsx", "Sheet1", "A5")
message =GoExcel.CellValue("Spreadsheet.xlsx", "Sheet1", "B5")

    Pour écrire dans une feuille de calcul externe : 

    GoExcel.CellValue("Spreadsheet.xls", "Sheet1", "A6") = "Hello World"
GoExcel.Save
    Remarque Requiert GoExcel.Save pour enregistrer les modifications apportées à la feuille de calcul :

    GoExcel.CurrentCellValue, GoExcel.CellValue

    Lit ou écrit dans une adresse de cellule spécifique dans une feuille de calcul créée avec la fonction GoExcel.CellValue ou GoExcel.Open. Cette fonction utilise le fichier et la feuille ouverts précédemment.

    Syntaxe

    GoExcel.CurrentCellValue("cellnumber")

    GoExcel.CellValue("cellnumber")(sans spécifier un nom de fichier et un nom de feuille)

    "cellnumber"

    Adresse de cellule ou plage nommée de la valeur de cellule tirée de la feuille de calcul actuelle dans laquelle lire ou écrire.

    Retours

    La valeur de la cellule à partir du numéro de cellule spécifié.

    Erreurs

    • Aucune affectation en cas d'erreur
    • Un message d'erreur s'affiche

    Exemples

    Pour lire une série de cellules à partir d'une feuille de calcul unique : 

    head_rad = GoExcel.CellValue("Spreadsheet.xlsx","Sheet1","A1")
head_thick = GoExcel.CellValue("B1")
pin_length = GoExcel.CellValue("C1")
shaft_rad = GoExcel.CellValue("D1")

    Pour écrire une série de cellules dans un ensemble de feuilles de calcul : 

    GoExcel.CellValue("Spreadsheet.xlsx","Sheet1","A1") = head_rad
GoExcel.CellValue("B1") = head_thick
GoExcel.CellValue("C1") = pin_length
GoExcel.CellValue("D1") = shaft_rad
GoExcel.Save

    GoExcel.NameRangeValue

    Fonctionne comme la fonction CellValue. Au lieu d'une adresse de cellule, indiquez une plage nommée définie dans le classeur Excel. Le nom doit être un nom contenu dans le classeur et la plage doit être limitée à une seule cellule. Vous pouvez accéder aux plages nommées de la feuille de calcul à l'aide de la syntaxe CellValue standard, en spécifiant le nom au lieu d'une adresse de cellule.

    Utilisez GoExcel.CellValue ou GoExcel.Open pour ouvrir le fichier Excel avant d'utiliser NamedRangeValuedans une règle.

    Syntaxe

    GoExcel.NamedRangeValue("PinLength")

    GoExcel.Open

    Ouvre la feuille de calcul Excel spécifiée et active, si nécessaire, une feuille de calcul nommée. Vous pouvez ensuite utiliser des fonctions telles que GoExcel.FindRow et GoExcel.CellValue pour extraire des informations ou modifier la feuille de calcul.

    Syntaxe

    GoExcel.Open("filename", "sheetname")

    "filename"

    Reportez-vous à la section Spécifier le fichier Excel.

    "sheetname"

    Nom de la feuille dans le document Excel à activer. Il peut s'agir de n'importe quelle feuille existante.

    Retours

    N/D

    Erreurs

    Fichier Excel introuvable.

    Exemples

    Si aucun nom de feuille n'est spécifié, "Feuille1" s'affiche par défaut. 

    GoExcel.Open("Spreadsheet.xls")

    Une feuille de calcul différente peut également être spécifiée. 

    GoExcel.Open("Spreadsheet.xls", "MyOtherSheet")

    GoExcel.Save

    Enregistre le document Excel actuel. Utilisez cette fonction si vous avez modifié des cellules avec la fonction GoExcel.CellValue ou GoExcel.CurrentCellValue.

    Retours

    N/D

    Erreurs

    N/D

    Exemple

    GoExcel.CellValue("Spreadsheet.xls", "Sheet1", "A1") = "Hello, World!"
GoExcel.CellValue("A2") = 5.42
GoExcel.Save

    GoExcel.CellValues

    Cette fonction sert à deux usages :

    • Lit les valeurs d'une plage de cellules spécifiée dans une feuille de calcul Excel, puis les affecte à une liste multivaleur.
    • Tire les valeurs d'une liste multivaleur et les écrit dans une plage de cellules spécifiée dans une feuille de calcul Excel.

    Lire à partir d'une feuille de calcul Excel

    Vous pouvez lire dans une plage de cellules orientée verticalement. La fonction lit les valeurs en commençant par la première cellule et poursuit vers le bas jusqu'à atteindre la deuxième cellule spécifiée dans la fonction : 

    Multivalue.List("parameter") =  GoExcel.CellValues("filename.xls", "Sheet1", "A1", "A10")

    Si une chaîne vide ("") remplace la deuxième d'adresse de cellule, commencez la lecture à partir de la première adresse de cellule et poursuivez vers le bas jusqu'à rencontrer une cellule vide : 

    Multivalue.List("parameter") =  GoExcel.CellValues("filename.xls", "Sheet1", "A1", "")

    Vous pouvez lire dans une plage de cellules orientée horizontalement : 

    Multivalue.List("parameter") =  GoExcel.CellValues("filename.xls", "Sheet1", "A1", "J1")

    Si la feuille de calcul a déjà été référencée dans la règle, vous pouvez également omettre le nom de fichier et le nom de la feuille : 

    Multivalue.List("parameter") =  GoExcel.CellValues("B2", "G2")

    Ecrire dans une feuille de calcul Excel

    Vous pouvez écrire des valeurs dans une plage de cellules orientée verticalement. La fonction écrit les valeurs en commençant par la première cellule et poursuit vers le bas jusqu'à atteindre la deuxième cellule spécifiée dans la fonction : 

    GoExcel.CellValues("filename.xls", "Sheet1", "A2", "A10") = Multivalue.List("parameter")

    Vous pouvez écrire des valeurs dans une plage de cellules orientée verticalement. Si une chaîne vide ("") remplace la deuxième d'adresse de cellule, iLogic utilise autant de cellules qu'il est nécessaire pour contenir tous les membres de la liste multivaleur : 

    GoExcel.CellValues("filename.xls", "Sheet1", "A2", "") = Multivalue.List("parameter")

    Vous pouvez écrire des valeurs dans une plage de cellules orientée horizontalement : 

    GoExcel.CellValues("filename.xls", "Sheet1", "A1", "J1") = Multivalue.List("parameter")

    Si la feuille de calcul a déjà été référencée dans la règle, vous pouvez également omettre le nom de fichier et le nom de la feuille : 

    GoExcel.CellValues("B2", "G2") = Multivalue.List("parameter")

    GoExcel.Close

    Ferme la feuille de calcul Excel.

    GoExcel.TitleRow

    Utilisée avant GoExcel.FindRow pour spécifier le numéro de la ligne de la feuille de calcul qui contient les noms de colonne. Le numéro de ligne par défaut est 1. Modifiez cette valeur si vous avez des lignes supplémentaires au-dessus de la ligne du nom de colonne.

    Exemple

    GoExcel.TitleRow = 2

    GoExcel.FindRowStart

    Utilisée avant la fonction GoExcel.FindRow pour spécifier le numéro de la première ligne de la feuille de calcul contenant des données. Le numéro de ligne par défaut est 2.

    Syntaxe

    GoExcel.FindRowStart = <row>

    <row>

    Ligne à laquelle les données commencent.

    Exemples

    La valeur par défaut 2 indique que les données débutent sur la ligne 2 et poursuivent sur la ligne de titre : 

    GoExcel.FindRowStart = 2

    Si vous disposez de deux lignes de titre, ajoutez l'instruction suivante à la règle avant l'instruction contenant GoExcel.FindRow : 

    GoExcel.FindRowStart = 3

    GoExcel.ChangeSourceOfLinked

    Permet d'accéder depuis des règles iLogic à l'opération de changement de source.

    Cette fonction remplace la feuille de calcul Excel contrôlant le modèle par une autre feuille de calcul. Les valeurs incluses dans la nouvelle feuille de calcul contrôlent ensuite les cotes du modèle.

    RemarqueCette fonction peut également être lancée manuellement à partir du menu contextuel des feuilles de calcul Excel liées.

    Syntaxe

    changeOK = GoExcel.ChangeSourceOfLinked(partialOldName, newName)

    partialOldName

    Partie du nom de la feuille de calcul à remplacer.

    partialOldName peut être une chaîne vide "" pour correspondre au premier fichier Excel lié. Souvent, une pièce ou un ensemble ne possède qu'un seul fichier Excel.

    newName

    Nouveau nom entier de la feuille de calcul, qui peut être un nom de fichier absolu ou relatif.

    Exemple

    If size = "small" Then
changeOK = GoExcel.ChangeSourceOfLinked("pipe"," smallpipe.xlsx")
ElseIf size = "medium" Then
changeOK = GoExcel.ChangeSourceOfLinked("pipe", "mediumpipe.xlsx")
ElseIf size = "large" Then
changeOK = GoExcel.ChangeSourceOfLinked("pipe", "largepipe.xlsx")
End If

    GoExcel.Tolerance

    Utilisée avec la fonction GoExcel.FindRow pour rechercher une valeur dans une plage plutôt qu'une valeur exacte. La tolérance par défaut est 0.0000001 et ne dépend pas des unités du document.

    Syntaxe

    GoExcel.Tolerance = <tolerance>

    Permet de définir une tolérance plus élevée pour augmenter la plage de valeurs autorisées.

    Exemple

    Vous utilisez l'instruction de recherche de la manière suivante : 

    GoExcel.Tolerance = 0.001
i = GoExcel.FindRow("Table1.xlsx", "Sheet1", "length", "=", 2.3)

    L'instruction devient équivalente à la recherche suivante sans tolérance : 

    i = GoExcel.FindRow("Table1.xlsx", "Sheet1", "length", ">=", 2.299, "length","<=", 2.301)

    GoExcel.DisplayAlerts

    Empêche l'affichage des boîtes de dialogue d'invite Excel.

    Syntaxe

    GoExcel.DisplayAlerts = True

    GoExcel.DisplayAlerts = False

    Vrai

    Autorise l'affichage des invites Microsoft® Excel (par défaut).

    Faux

    Empêche l'affichage des invites Excel.

    GoExcel.Application

    Permet d'accéder à l'objet de l'application Excel. Utilisez cette option uniquement si vous connaissez l'interface COM d'Excel. Avant d'utiliser cette fonction dans une règle, appelez une autre fonction GoExcel pour initialiser l'application.

    Syntaxe

    excelApp = GoExcel.Application

    Fonctions iPart et iAssembly

    Utilisez les fonctions d'iPièces ou d'iEnsembles pour contrôler les configurations d'iPièces et d'iEnsembles dans un ensemble. Vous pouvez utiliser une règle pour modifier la configuration actuelle d'une iPièce ou d'un iEnsemble selon les conditions et la logique que vous définissez.

    Ces fonctions utilisent des iEnsembles de la même façon que les iPièces, à l'exception des paramètres personnalisés qui ne peuvent être utilisés que pour les iPièces. Pour utiliser la fonction d'un iEnsemble, vous pouvez éventuellement remplacer iPart par iAssembly lors de la spécification de la fonction.

    Pour accéder aux fonctions iPart ou iAssembly, développez le noeud iPièces sous l'onglet Système de la zone Extraits de code.

    Des fonctions similaires sont disponibles pour les iFonctions. Reportez-vous à la rubrique fonctions iFeature pour plus d'informations.

    iPart.ChangeRow

    Modifie la ligne active dans la table d'iPièce ou d'iEnsemble.

    Syntaxe

    iPart.ChangeRow("iChangedComponentName:1", "memberName")

    “iChangedComponentName:1”

    Nom du composant tel qu'il est affiché dans le navigateur de l'ensemble Autodesk Inventor. Permet de modifier le nom du composant par défaut affecté par Inventor pour le stabiliser et l'empêcher de changer lorsqu'une autre ligne est sélectionnée dans la table.

    “memberName”

    Nom attribué à la ligne dans la colonne Membre de la table.

    Pour une iPièce avec des paramètres personnalisés, utilisez la syntaxe suivante pour afficher la liste des paramètres personnalisés après "memberName". Affiche dans le même ordre que dans la table :

    iPart.ChangeRow("iChangedComponentName:1", "memberName", customParam1,customParam2)

    Utilisez la syntaxe suivante pour spécifier un numéro de ligne au lieu d'un nom de membre. Le numéro de ligne est un nombre entier, commençant par 1 pour la première ligne (pour les iPièces normalisées uniquement) :

    iPart.ChangeRow("iChangedComponentName:1", rowNumber)

    Exemple

    Dans cet exemple, la configuration actuelle de l'iPièce est modifiée en fonction d'une instruction conditionnelle qui évalue un paramètre utilisateur Inventor Port_1_Size. La fonction requiert uniquement le nom du composant d'iPièce port_1_Flange_screw et le nom de membre de la table d'iPièce Screw-01 pour contrôler la configuration d'iPièce active : 

    If Port_1_Size = .50 Then
iPart.ChangeRow("port_1_flange_screw", "Screw-01")
ElseIf Port_1_Size = .75 Then
iPart.ChangeRow("port_1_flange_screw", "Screw-02")
ElseIf Port_1_Size = 1.00 Then
iPart.ChangeRow("port_1_flange_screw", "Screw-03")
End If

    iPart.FindRow

    Recherche dans la table d'iPièce ou d'iEnsemble, par colonne, la ligne contenant une valeur spécifique ou approximative et définit la configuration active pour la ligne trouvée.

    Syntaxe

    i=iPart.FindRow("iChangedComponentName:1", "columnName","<=",0.2,"columnName","<=", 4.1,"|",customParam1,customParam2)

    i=iPart.FindRow("iChangedComponentName:1","columnName", "<=",d1,"columnName","<=",d2)

    "i"

    Variable locale qui peut être utilisée pour vérifier si une ligne correcte est trouvée.

    "iChangedComponentName:1"

    Nom du composant tel qu'il est affiché dans le navigateur de l'ensemble Inventor. Permet de modifier le nom du composant par défaut affecté par Inventor pour le stabiliser et l'empêcher de changer lorsqu'une autre ligne est sélectionnée dans la table.

    "columnName"

    Colonne de recherche dans la table d'iPièce. Utilisez le nom d'en-tête de colonne exactement tel qu'il apparaît dans la table d'iPièce.

    Exemple

    Cet exemple recherche une table d'iPièce pour une ligne avec des valeurs de colonne supérieures ou égales aux valeurs spécifiées. iLogic change la configuration d'iPièce active pour la ligne trouvée : 

    iPart.FindRow("port_1_flange_screw", "Thread_Diameter", ">=", 0.45, "Thread_Length", ">=", 2.0)

    iPart.CurrentRowValue

    Dès qu'une ligne a été trouvée à l'aide de iPart.FindRow, cette fonction lit les valeurs de la colonne associées à cette ligne. Cette fonction lit uniquement les valeurs numériques. Utilisez iPart.CurrentRowStringValue pour lire les colonnes contenant des valeurs de texte.

    Syntaxe

    d0 = iPart.CurrentRowValue("columnName")

    Toutes les fonctions suivantes définissent la ligne en cours :

    • iPart.FindRow
    • iPart.ChangeRow
    • iPart.RowName
    • iPart.RowNumber

    iPart.FindRow or iPart.ChangeRow.

    "columnName"

    Nom de la colonne de la table d'iPièce que vous voulez.

    Exemple

    Dans cet exemple, nous allons rechercher dans la colonne Port_Size de la table d'iPièce port_1_flare_flange une valeur exacte correspondant à la valeur du paramètre Inventor Port_1_Size. Une fois la ligne trouvée, nous utilisons iPart.CurrentRowValue pour extraire les cotes des colonnes A_dim et B_dim de la table. Nous assignons ensuite les valeurs aux paramètres Inventor Port_1_screw_A_dim et Port_1_screw_B_dim : 

    i = iPart.FindRow("port_1_flare_flange", "Port_Size", "=", Port_1_Size)
Port_1_screw_A_dim = iPart.CurrentRowValue("A_dim")
Port_1_screw_B_dim = iPart.CurrentRowValue("B_dim")

    iPart.CurrentRowStringValue

    Dès qu'une ligne a été trouvée à l'aide de iPart.FindRow, utilisez cette fonction pour lire les valeurs de la colonne associées à cette ligne. Cette fonction est similaire à la fonction iPart.CurrentRowValue, à ceci près qu'elle lit les valeurs de texte uniquement. Utilisez iPart.CurrentRowValue pour lire les colonnes contenant des valeurs numériques.

    Syntaxe

    iPart.CurrentRowStringValue("PartNumber")

    Autre syntaxe pour le nom du composant

    Pour spécifier un nom de composant qui ne change pas lorsque la ligne de l'iPièce est modifiée.

    iPart.ChangeRow("iParentFileName:1", "memberName")

    iPart.FindRow("iParentFileName:1","columnName","<=",d1,"columnName","<=",d2)

    “iParentFileName:1”

    Nom du fichier parent de l'iPièce, où ":1" remplace le fichier .ipt ou.iam habituel. Modifiez la variable ":1" par le numéro du composant avec lequel vous travaillez.

    Bien que cette syntaxe soit prise en charge, elle n'est pas recommandée. Il existe une méthode plus classique qui consiste à modifier le nom du composant pour le stabiliser.

    iPart.RowName

    Extrait le nom de membre de la ligne active dans une occurrence du composant iPièce ou iEnsemble. Cette fonction est utile dans les règles déclenchées par l'événement Modifier le composant sur l'iPièce ou l'iEnsemble. Utilisez iPart.ChangeRow ou iPart.FindRow pour sélectionner une ligne automatiquement à partir d'une règle. Si vous souhaitez autoriser l'utilisateur à sélectionner une ligne manuellement, vous pouvez associer cet événement à l'aide de cette fonction pour réagir aux modifications.

    RemarqueAprès avoir utilisé cette fonction, vous pouvez utiliser iPart.CurrentRowValue ou iPart.CurrentRowStringValue pour extraire les valeurs d'autres cellules de la ligne active.

    Syntaxe

    iPart.RowName("iChangedComponentName:1")

    Exemple

    memberName = iPart.RowName("port_1_flange_screw:1")

    iPart.RowNumber

    Extrait le numéro de ligne de la ligne active dans une occurrence du composant iPièce ou iEnsemble.

    RemarqueAprès avoir utilisé cette fonction, vous pouvez utiliser iPart.CurrentRowValue ou iPart.CurrentRowStringValue pour extraire les valeurs d'autres cellules de la ligne active.

    Syntaxe

    iPart.RowNumber("iChangedComponentName:1")

    Exemple

    rowNumber = iPart.RowNumber("port_1_flange_screw:1")

    iPart.Tolerance

    Utilisée avec la fonction iPart.FindRow, cette fonction vous permet de rechercher une valeur comprise dans une plage plutôt qu'une valeur exacte. Il existe toujours une tolérance pour cette recherche. La tolérance par défaut est 0.0000001 et ne dépend pas des unités du document.

    Syntaxe

    iPart.Tolerance = <value>

    Permet de définir une tolérance plus élevée pour augmenter la plage de valeurs autorisées.

    Exemple

    Supposons que vous utilisez les instructions suivantes : 

    iPart.Tolerance = 0.001
i = iPart.FindRow("Block:1","length", "=", 2.3)

    Ces instructions sont équivalentes à la recherche suivante sans tolérance : 

    i = iPart.FindRow("Block:1", "length", ">=", 2.299, "length","<=", 2.301)

    Pour remplacer un membre d'iPièce par un membre d'une autre famille, utilisez Component.ReplaceiPart.

    Fonctions iFeature

    Utilisez les fonctions iFeature pour choisir une ligne dans une iFonction liée à une table. Chaque ligne possède un jeu de valeurs de paramètre pour contrôler l'iFonction.

    Les fonctions iFeature agissent au sein d'une pièce dans laquelle l'iFonction est placée (instanciée). Leur syntaxe est identique à celle utilisée pour les fonctions GoExcel et iPart.

    Pour accéder aux fonctions iFeature, développez le noeud iFonctions sous l'onglet Système de la zone Extraits de code.

    iFeature.ChangeRow

    Modifie la ligne active d'une iFonction liée à une table.

    Syntaxe

    iFeature.ChangeRow("iFeatureName", "rowName")

    "iFeatureName”

    Nom de l'iFonction tel qu'il est affiché dans l'arborescence du modèle.

    "rowName"

    Valeur souhaitée du paramètre clé dans la table d'iFonction.

    Si l'iFonction contient plus d'un paramètre clé, définissez tous ces paramètres dans une chaîne de texte sous la forme [Clé1=Valeur1][Clé2=Valeur2]. Par exemple : 

    [Size=A0][CutLength=0.4375000 in]

    Cet exemple représente la propriété iFeatureTableRow.MemberName, comme décrit dans la documentation sur l'API Inventor. Une autre façon de définir plusieurs valeurs de paramètre consiste à utiliser iFeature.FindRow.

    Vous pouvez également utiliser un nombre entier correspondant au numéro de ligne :

    iFeature.ChangeRow("iFeatureName", rowNumber)

    Exemple

    Dans cet exemple, la configuration actuelle de l'iFonction est modifiée en fonction d'une instruction conditionnelle qui évalue la taille, un paramètre de texte. iFeature.ChangeRow requiert uniquement le nom du composant d'iFonction RectangularPocket1 et le nom de la colonne d'identifiantsla de la table d'iFonction "Pocket-01" pour contrôler la configuration de l'iFonction active : 

    If size = "small" Then
iFeature.ChangeRow("RectangularPocket1", "Pocket-01")
ElseIf size = "medium" Then
iFeature.ChangeRow("RectangularPocket1", "Pocket-02")
ElseIf size = "large" Then
iFeature.ChangeRow("RectangularPocket1", "Pocket-03")
ElseIf size = "very large" Then
iFeature.ChangeRow("RectangularPocket1", "Pocket-04")
End If

    iFeature.FindRow

    Permet de rechercher une ligne en fonction d'un ou plusieurs critères de valeur de la colonne. S'il détecte une ligne, la ligne active de l'iFonction est remplacée par cette ligne.

    Syntaxe

    i = iFeature.FindRow("iFeatureName", "columnName", "<=", 0.2, "columnName", "<=", 4.1)

    "iFeatureName"

    Nom de l'iFonction liée à une table.

    "columnName"

    Titre de la colonne pour la recherche.

    Opérateurs

    • "=" affiche une ligne avec une valeur égale à la valeur spécifiée.
    • "> =" affiche une ligne avec une valeur supérieure ou égale à la valeur spécifiée.
    • "> =" affiche une ligne avec une valeur supérieure ou égale à la valeur spécifiée.

    Cette valeur peut être une valeur numérique ou une chaîne de texte. Elle peut être spécifiée à l'aide d'une valeur explicite, d'un paramètre ou d'une variable locale.

    Retours

    • Numéro de ligne (entier) de la ligne qui correspond aux critères de recherche.
    • -1 si la ligne n'a pas été trouvée.

    iFeature.CurrentRowValue(“columnName”)

    Lit une valeur à partir de la ligne trouvée à l'aide de la fonction iFeature.FindRow, où "columnName" est le nom du titre de la colonne. Il renvoie la valeur de la cellule tirée de la valeur de la ligne actuelle renvoyée par la fonction iFeature.FindRow. Par exemple : 

    i = iFeature.FindRow("RectangularPocket1", "pocketdepth", "=", 0.250)
pocketlength = iFeature.CurrentRowValue("pocketlength")
pocketwidth = iFeature.CurrentRowValue("pocketwidth")

    Si la colonne n'existe pas dans l'iFonction, la règle affiche un message d'erreur.

    iFeature.CurrentRowStringValue("columnName")

    Utilisez cette fonction lorsque l'entrée recherchée dans la table d'iFonction est une chaîne de texte. Par exemple : 

    Part_number = iFeature.CurrentRowStringValue("Part Number")

    iFeature.Tolerance

    Utilisée avec la fonction iFeature.FindRow, cette fonction vous permet de rechercher une valeur comprise dans une plage plutôt qu'une valeur exacte. Il existe toujours une tolérance pour cette recherche. La tolérance par défaut est 0.0000001 et ne dépend pas des unités du document.

    Syntaxe

    iFeature.Tolerance = <valeur>

    Permet de définir une tolérance plus élevée pour augmenter la plage de valeurs autorisées.

    Exemple

    iFeature.Tolerance = 0.001
i = iFeature.FindRow("insertpocket", "pocketlength", "=", 2.0)

    Cet exemple correspond à une ligne avec une valeur pocketlength égale à 2.0004.

    Fonctions de contraintes d'ensemble

    iLogic fournit des fonctions de règles contrôlant l'état de masquage des contraintes d'ensemble. Ces fonctions sont utiles lors de la définition de configurations au niveau de l'ensemble avec des règles iLogic.

    Par exemple, supposons que vous définissez d'autres positions d'un composant dans un ensemble. Vous pouvez définir tous les placages nécessaires pour contraindre le composant dans chaque emplacement. Ensuite, vous pouvez utiliser une règle pour masquer ou annuler le masquage des placages à discrétion pour déplacer le composant dans chaque configuration.

    Autodesk Inventor ne permet aucun conflit de contraintes. Créez les contraintes pour une position d'un composant, puis masquez-les manuellement avant de créer d'autres jeux de contraintes pour les différentes positions du composant. Une fois que vous avez créé toutes les contraintes nécessaires pour positionner le composant pour chaque configuration, vous pouvez créer des règles permettant de choisir entre les contraintes.

    Pour accéder aux fonctions Constraint, développez le noeud Contraintes sous l'onglet Système de la zone Extraits de code.

    Constraint.IsActive

    Définit ou lit le masquage d'une contrainte de la racine de l'ensemble.

    Définissez un nom personnalisé unique pour chaque contrainte référencée dans une règle :

    • Les règles sont plus facilement comprises.
    • L'attribution d'un nouveau nom à un placage "stabilise" le nom afin d'éviter qu'il soit modifié automatiquement, ce qui pourrait empêcher la règle de trouver la contrainte.

    Si vous modifiez manuellement le masquage d'une contrainte, les règles qui y font référence ne se lancent pas automatiquement.

    Syntaxe

    Constraint.IsActive(“Mate:1”)

    Constraint.IsActive(“SubAssem.iam”, “Mate:1”)

    Exemples

    Pour définir l'état de masquage : 

    If ConfigStyle = “A” Then
Constraint.IsActive("MateLeftSide:1") = true
Constraint.IsActive("MateRightSide:2") = false
ElseIf ConfigStyle = “B” Then
Constraint.IsActive("MateLeftSide:1") = false
Constraint.IsActive("MateRightSide:2") = true
End If

    Pour lire l'état de masquage : 

    If Constraint.IsActive("MateLeftSide:1")  Then (Do something)

    Pour définir ou lire l'état de masquage d'une contrainte dans un sous-ensemble (spécifiez le nom de fichier et le nom de la contrainte) : 

    Constraint.IsActiveInDoc("SubAssem.iam", "Mate:1")

    Pour copier et renommer tous les fichiers dans un ensemble en conservant toutes les règles intactes, utilisez Constraint.IsActiveInComponent et spécifiez un nom de sous-ensemble à la place du nom de fichier.

    Pour définir à l'aide d'un nom de sous-ensemble : 

    If ConfigStyle = “A” Then
Constraint.IsActiveInDoc("SubAssem.iam", “LeftMate”) = true
Constraint.IsActiveInDoc("SubAssem.iam", “RightMate”) = false
ElseIf ConfigStyle = “B” Then
Constraint.IsActiveInDoc("SubAssem.iam", “LeftMate”) = false
Constraint.IsActiveInDoc("SubAssem.iam", “RightMate”) = true
End If

    Pour lire à l'aide d'un nom de sous-ensemble : 

    Constraint.IsActiveInDoc("SubAssem.iam",”LeftMate”) = true then (Do something)

    Constraint.iMateDefIsActive

    Masque ou annule le masquage d'une définition iContrainte.

    Constraint.iMateDefIsActive(“iMate:1”) = False

    Masque la définition iContrainte avec le nom iMate:1 dans la règle du document en cours. Le résultat est le même que lorsque vous la masquez à partir du menu contextuel qui s'affiche dans l'interface utilisateur. Lorsqu'elle est masquée, la définition iContrainte n'est pas disponible pour le placage.

    Constraint.iMateDefIsActive(“SubAssem:1”,“iMate:1) = False

    Masque la définition iContrainte avec le nom iMate:1 dans le composant SubAssem:1.

    Constraint.iMateDefIsActive(PartA:1”,“iMate:1”) = True

    Annule le masquage de la définition iContrainte avec le nom iMate:1 dans la pièce de composant PartA:1.

    Fonctions Measure

    Utilisez les fonctions Measure pour rechercher et renvoyer des valeurs pour la distance, l'angle, l'aire, le périmètre et les cotes relatives à l'encombrement.

    Pour accéder aux fonctions Measure, développez le noeud Mesure sous l'onglet Système de la zone Extraits de code.

    Mesurer la distance et l'angle

    Vous pouvez mesurer la distance ou l'angle entre deux entités (ou trois s'il s'agit de mesurer l'angle). Vous spécifiez les entités situées aux extrémités de la mesure par leur nom. Un nom peut se rapporter aux éléments suivants :

    • Une fonction de construction (par exemple, un plan de construction, un axe de construction ou un point de construction dans un fichier pièce ou ensemble). La fonction de construction peut être une fonction de construction Inventor standard telle que Plan XY ou Axe X.
    • Une iContrainte attachée à une face, une arête ou un sommet. Utilisez cette méthode pour affecter à l'élément un nom définitif. Il n'est pas nécessaire d'utiliser l'iContrainte pour une contrainte. L'iContrainte peut être masquée.

    Les objets peuvent appartenir à la même pièce ou au même ensemble, ou se trouver dans différents composants d'un ensemble.

    Vous pouvez également mesurer la distance entre deux composants d'un ensemble en recherchant les points les plus proches sur chaque composant et en rapportant la distance qui les sépare.

    Incluez les fonctions RuleParametersOutput et InventorVb.DocumentUpdate() (dans cet ordre) avant d'introduire les fonctions Measure dans une règle. L'utilisation de ces fonctions permet à la fonction Measure d'examiner la version mise à jour du modèle Inventor.

    Measure.MinimumDistance

    Mesure la distance minimale entre deux points, plans ou axes. Cette fonction permet également de mesurer la distance entre un plan et un point, un plan et un axe ou un point et un axe.

    Syntaxe

    Measure.MinimumDistance("entityName1","entityName2")

    Exemples

    Pour mesurer la distance entre deux points : 

    distance = Measure.MinimumDistance("Work Point1", "Work Point2")

    (1) Point de construction 1 (2) Point de construction 2

    Pour mesurer la distance entre un point et un axe :

    distance = Measure.MinimumDistance("Work Point1", "Work Axis1")

    (1) Point de construction 1 (2) Axe de construction 1

    Pour mesurer la distance entre deux axes : 

    distance = Measure.MinimumDistance("Work Axis1", "Work Axis2")

    (1) Axe de construction 1 (2) Axe de construction 2

    Pour mesurer la distance entre deux plans : 

    distance = Measure.MinimumDistance(“Work Plane1”, “Work Plane2”)

    (1) Plan de construction 1 (2) Plan de construction 2

    Measure.MinimumDistance("componentName1", "entityName1", "componentName2", "entityName2")

    Mesure la distance entre les entités dans deux composants d'un ensemble. Ces objets peuvent être des points, des plans ou des axes.

    Par exemple, pour mesurer la distance entre les plans de deux composants d'un ensemble : 

    distance = Measure.MinimumDistance(“Wheel1”, “Workplane1”, “Wheel2”, Workplane2”)

    (1) Plan de construction 1 Roue 1 (2) Plan de construction 2 Roue 2

    Measure.MinimumDistance("componentName1", "componentName2")

    Mesure la distance minimale entre deux composants d'un ensemble. Examine les composants dans leur ensemble et recherche les points les plus proches n'importe où sur les composants, comme illustré dans les exemples suivants : 

    distance = Measure.MinimumDistance("partA:1", "partB:1")
distance = Measure.MinimumDistance("Wheel1", "Wheel2")

    (1) Roue 1 (2) Roue 2

    Utilisez avec précaution la fonction de mesure lorsque les axes ne sont pas parallèles .

    Supposons que votre ensemble est constitué de deux blocs. L'angle entre les faces de chaque bloc est de 60 degrés. Chaque bloc possède un perçage qui fait face à celui de l'autre bloc. Les axes de ces deux perçages sont des lignes coplanaires non parallèles qui s'entrecoupent. Ecrivez ainsi votre fonction : 

    distance = Measure.MinimumDistance("Block1","Axis1","Block2","Axis1")

    La mesure pourrait s'effectuer comme si les lignes avaient une longueur infinie, ce qui entraînerait une distance de zéro. Toutefois, lorsque la fonction Measure.MinimumDistance est utilisée, la distance est mesurée entre les points d'extrémité les plus proches sur les deux marqueurs représentant l'emplacement des axes. Par conséquent, la mesure est effectuée sur les lignes finies, et la valeur renvoyée est 1.36 pouces.

    (1) Axe 1 (2) Bloc 1 (3) Axe 2 (4) Bloc 2

    Pour obtenir un résultat différent, vous pouvez prolonger manuellement les lignes représentant les axes du perçage. La fonction Measure.MinimumDistance renvoie à présent la valeur 0 pouces, comme prévu pour les lignes qui se coupent.

    (1) Bloc 1 (2) Axe 1 (3) Axe 2 (4) Bloc 2

    Measure.Angle

    Mesure l'angle entre deux entités ou comme défini par trois points.

    angle = Measure.Angle("entityName1", "entityName2")

    Mesure l'angle entre deux entités dans une pièce ou un ensemble. Cette fonction peut mesurer l'angle entre deux axes, deux plans, ou un axe et un plan. Les entités peuvent être des fonctions de construction ou des iContraintes.

    angle = Measure.Angle("componentName1", "entityName1", "componentName2", "entityName2")

    Mesure l'angle entre deux entités de deux composants au niveau de l'ensemble. Cette fonction peut mesurer l'angle entre deux axes, deux plans, ou un axe et un plan.

    angle = Measure.Angle("point1", "point2", "point3")

    Mesure l'angle défini par trois points. Cette valeur correspond à l'angle entre deux lignes :

    • La ligne 1 s'étend de "point1" à "point2".
    • La ligne 2 s'étend de "point2" à "point3".

    Dans ce cas, "point2" est le sommet de l'angle. Par exemple : 

    angle = Measure.Angle("Work Point1", "Work Point2", "Work Point3")

    (1) Point de construction 1 (2) Point de construction 2 (sommet) (3) Point de construction 3

    angle = Measure.Angle("componentName1", "point1", "componentName2", "point2", "componentName3", "point3")

    Mesure l'angle défini par trois points. "point2" définit le sommet de l'angle. Chaque point peut être dans un composant différent.

    (1) Composant 1 Point de construction 1 (2) Composant 2 Point de construction 2 (sommet de l'angle) (3) Composant 3 Point de construction 3 (4) 74.02 degrés

    Measure.Area

    Mesure l'aire d'une esquisse. Cette fonction calcule la somme des aires des zones délimitées par les contours fermés dans une esquisse.

    Syntaxe

    Measure.Area("SketchName")

    Exemples

    Pour un seul profil fermé, la fonction calcule l'aire délimitée par le contour :

    Aire : 3.14 = po au carré

    Si l'esquisse comprend plusieurs contours fermés, la fonction calcule la somme des zones délimitées par les profils :

    Aire : 6.28 = po au carré

    Si les contours fermés se coupent, la fonction calcule la somme des aires fermées, même si ces surfaces se chevauchent :

    Aire : 6.28 = po au carré

    Si l'esquisse comprend plusieurs contours et que l'un des contours est entièrement inclus dans un autre, la fonction Measure.Area renvoie la différence entre les deux aires :

    Aire : 1.37 = po au carré

    Measure.Perimeter

    Measure.Perimeter(“SketchName”)

    Calcule la somme des périmètres des contours fermés dans une esquisse. Pour une esquisse contenant un seul contour fermé, cette fonction calcule la longueur du périmètre du contour.

    Syntaxe

    size = Measure.Perimeter("Sketch1")

    Exemples

    Pour une esquisse contenant un seul contour fermé, cette fonction calcule la longueur du périmètre du contour.

    Périmètre : 6 pouces

    Pour une esquisse contenant plusieurs contours fermés qui ne se coupent pas, la fonction calcule la somme de la longueur des périmètres de contour :

    Périmètre : 9 pouces

    Pour une esquisse contenant plusieurs contours fermés qui se coupent, la fonction calcule la somme de la longueur des périmètres de contour :

    Périmètre : 12 pouces

    Measure.Extents

    Permet de mesurer les cotes X, Y ou Z de l'encombrement d'une pièce ou d'un ensemble. Cette étendue peut être plus grande que le modèle le long de cet axe, en particulier si les formes du modèle sont incurvées.

    RemarqueCes fonctions mesurent uniquement l'encombrement des entités visibles, y compris les plans, les points de construction, les surfaces et les corps. Les entités masquées ne sont pas mesurées.

    Syntaxe

    Measure.ExtentsLength

    Mesure l'étendue X (le long de l'axe rouge) du modèle.

    Measure.ExtentsWidth

    Mesure l'étendue Y (le long de l'axe vert) du modèle.

    Measure.ExtentsHeight

    Mesure l'étendue Z (le long de l'axe bleu) du modèle.

    Fonctions relatives aux fonctions de construction

    Utilisez les fonctions relatives aux fonctions de construction pour modifier des fonctions de construction existantes.

    Pour accéder à ces fonctions, développez le noeud Fonctions de construction sous l'onglet Système de la zone Extraits de code.

    WorkPlane.FlipNormal

    Inverse sous conditions le vecteur de la normale au plan de construction. Cette action permet d'inverser le plan de construction. Si une esquisse est créée sur le plan, elle est également inversée. Cette fonction peut être utilisée pour déplacer une fonction de gauche à droite. Elle est très utile pour une extrusion de type plan médian. Cette fonction n'inverse pas la normale chaque fois que vous l'utilisez ; en revanche, elle garantit que la normale est dans la direction voulue. La fonction inverse la normale si elle n'est pas "en accord" avec l'axe que vous spécifiez.

    Syntaxe

    WorkPlane.FlipNormal("workPlaneName", "axisWanted")

    "workPlaneName"

    Nom du plan de construction à inverser.

    "axisWanted"

    Nom de l'axe d'une pièce, éventuellement précédé d'un signe négatif (-) pour indiquer la direction. Cette convention indique à la fonction la direction approximative de la normale au plan. Si le plan n'est pas parfaitement aligné sur l'axe du modèle, choisissez l'axe le plus proche de la normale au plan souhaitée. Un alignement de 60 degrés par rapport à l'axe est acceptable.

    Exemples

    WorkPlane.FlipNormal("Work Plane1", "X")
    WorkPlane.FlipNormal("Work Plane1", "-X")
    WorkPlane.FlipNormal("Work Plane1", "Y")
    WorkPlane.FlipNormal("Work Plane1", "-Y")
    WorkPlane.FlipNormal("Work Plane1", "Z")
    WorkPlane.FlipNormal("Work Plane1", "-Z")

    Sketch.Redefine

    Redéfinit l'esquisse à l'aide d'autres entrées. Cette fonction est particulièrement efficace pour les esquisses autonomes qui ne contiennent pas de géométrie projetée. Contraignez l'ensemble de la géométrie d'esquisse à l'origine ou à l'un des axes de l'esquisse à l'aide de contraintes ou des cotes de coïncidence ou de blocage.

    Cette fonction nécessite des noms comme entrées ; par conséquent, définissez l'esquisse à l'aide d'éléments nommés :

    • Fonctions de construction
    • Plans ou axes standard
    • Faces, arêtes, ou sommets associés à des iContraintes

    Syntaxe

    Sketch.Redefine(sketchName, planeName, originName, axisName, AxisIsX := True, NaturalAxisDirection := True )

    sketchName

    Nom de l'esquisse.

    planeName

    Nom de l'entité à utiliser en tant que plan d'esquisse.

    originName

    Nom de l'entité à utiliser comme point d'origine de l'esquisse.

    axisName

    Nom de l'entité à utiliser comme axe de l'esquisse (axe X ou Y).

    AxisIsX

    La valeur par défaut Vrai indique que l'axe de l'esquisse spécifié par axisName est l'axe X (horizontal). Faux indique qu'il s'agit de l'axe Y (vertical).

    NaturalAxisDirection

    La valeur par défaut Vrai indique que l'axe de l'esquisse est dans la même direction que l'entité axisName. La valeur Faux indique que l'axe de l'esquisse est dans la direction opposée.

    Fonctions MessageBox

    Utilisez des fonctions MessageBox pour créer des boîtes de message et des zones de saisie dans une règle.

    MessageBox.Show et InputBox sont des fonctions VB.NET standard. Consultez la documentation sur VB.NET pour obtenir plus d'informations.

    MessageBox.Show est une version VB.NET de la fonction MsgBox disponible dans VB6 et VBA. Vous pouvez toujours utiliser MsgBox dans les règles iLogic.

    InputListBox et InputRadioBox sont des fonctions iLogic.

    Pour accéder aux fonctions MessageBox, développez le noeud MessageBox sous l'onglet Système de la zone Extraits de code.

    Vous pouvez utiliser l'assistant de création de boîtes de dialogue disponible dans la boîte de dialogue Ajouter une règle pour vous aider à écrire du code pour une boîte de message.

    MessageBox.Show

    Agit comme fonction de base pour les fonctions MessageBox dans iLogic. Utilisez cette fonction pour afficher une boîte de message.

    Syntaxe

    MessageBox.Show("Message", "Titre")

    "Message"

    Contenu de la zone de texte de la boîte de message.

    "Titre"

    Contenu de la barre de titre de la boîte de message.

    MessageBoxButtons

    Vous pouvez spécifier les boutons inclus dans une boîte de message à l'aide du paramètre MessageBoxButtons pour spécifier les valeurs appropriées dans la fonction MessageBox.Show.

    Par exemple : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.OK)

    Cette option crée une simple boîte de message avec le bouton OK :

    Autres options : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.OKCancel)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.RetryCancel)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNo)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.AbortRetryIgnore)

    MessageBoxIcon

    Vous pouvez ajouter une icône à une boîte de message en incluant le paramètre MessageBoxIcon dans la fonction MessageBox.Show.

    Par exemple : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Error)

    Cette option ajoute une icône d'erreur à la boîte de dialogue du message :

    Autres options : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Information)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.None)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning)

    DefaultButton

    Vous pouvez spécifier le bouton de la boîte de message pour sélectionner lorsque la boîte de message s'affiche pour la première fois. Pour spécifier le bouton, incluez le paramètre MessageBoxDefaultButton dans la fonction MessageBox.Show. Choisissez parmi les trois boutons potentiels dans la boîte de message, selon la valeur MessageBoxButtons utilisée.

    Par exemple : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2)

    Cette option indique que le deuxième bouton (Non) est sélectionné par défaut :

    Autres options : 

    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1)
    MessageBox.Show("Message",'"Title", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button3)

    InputBox

    Crée une boîte de message qui invite et accepte des entrées.

    Syntaxe

    myparam = InputBox("Message", "Titre", "Entrée par défaut")

    "Message"

    Message qui s'affiche dans la boîte.

    "Titre"

    Texte qui s'affiche dans la barre de titre de la boîte.

    "Entrée par défaut"

    Texte qui s'affiche dans le champ de saisie de la boîte.

    Exemple

    InputListBox

    Affiche une boîte de message s'affiche avec une liste de valeurs disponibles. Lorsqu'une valeur est sélectionnée dans la liste, la fonction renvoie cette valeur.

    Syntaxe

    d0 = InputListBox("Message",MultiValue.List("listName"), defaultEntry, Titre := "Titre de la boîte de dialogue", ListPrompt := "List Prompt")

    "Message"

    Message qui s'affiche au-dessus du bouton OK de la boîte.

    MultiValue.List("listName")

    Nom de la liste multivaleur à utiliser.

    defaultEntry

    Valeur sélectionnée initialement dans la zone de liste.

    Titre

    Texte qui s'affiche dans la barre de titre.

    ListPrompt

    Message

    Texte qui s'affiche au-dessus de la liste dans la boîte.

    Retours

    d0

    Valeur de la liste qui a été sélectionnée.

    Exemple

    material = InputListBox("Choose Part material", MultiValue.List("material"),  _
material, Title := "Part material", ListName := "Available Standard materials")

    InputRadioBox

    Affiche une boîte de message invitant à l'une des deux options disponibles.

    Syntaxe

    booleanResult= InputRadioBox("Message", "Libellé du bouton1", "Libellé du bouton2", booleanParam, Titre :="Titre")

    "Message"

    Message qui s'affiche dans la boîte.

    "Button1 Label"

    Message qui s'affiche pour la première option.

    "Button2 Label"

    Message qui s'affiche pour la deuxième option.

    booleanParam

    Indiquez True pour sélectionner la première option ou False pour sélectionner la seconde option.

    Titre

    Texte qui s'affiche dans la barre de titre de la boîte.

    Retours

    booleanResult

    Vrai si la première option est sélectionnée, Faux si la deuxième option est sélectionnée.

    Exemple

    booleanParam= InputRadioBox("Choose an Edge Treatment option", "Chamfer", "Fillet", true, Title :="Edge
Treatment")

    Fonctions Document

    Utilisez les fonctions Document pour accéder au fichier pièce, ensemble ou dessin Inventor. Les fonctions Document vous permettent d'effectuer des tâches telles que l'obtention du nom du fichier et la mise à jour du modèle.

    Dans les fonctions Document, ThisDoc fait référence au document Autodesk Inventor dans laquelle la règle est enregistrée. Il s'agit souvent du document actif, mais il peut également s'agir d'une pièce dans un ensemble. Quel que soit l'emplacement dans lequel la règle est stockée, ThisDoc vous donne accès à ce document.

    Pour accéder aux fonctions Document, développez le noeud Document sous l'onglet Système de la zone Extraits de code.

    Path

    Renvoie le chemin d'accès au document (nom de dossier) sous la forme d'une chaîne de texte.

    Syntaxe

    ThisDoc.Path

    FileName

    Renvoie le nom de fichier du document.

    Syntaxe

    ThisDoc.FileName(False)

    L'extension de fichier n'est pas incluse lorsque False est fourni comme argument. Si vous souhaitez afficher l'extension du fichier, choisissez True comme argument de substitution.

    PathAndFileName

    Renvoie le chemin et le nom de fichier du document.

    Syntaxe

    ThisDoc.PathAndFileName(False)

    L'extension de fichier n'est pas incluse lorsque False est fourni comme argument. Pour inclure l'extension de fichier, insérez True entre les parenthèses.

    ChangeExtension

    Crée un nom de fichier en utilisant le nom de fichier du document et une nouvelle extension.

    Syntaxe

    changedName = ThisDoc.ChangeExtension(“.new”)

    WorkspacePath

    Renvoie le chemin d'accès (nom de dossier) à l'espace de travail du projet Autodesk Inventor actif. Si aucun espace de travail n'est défini, cette fonction renvoie une chaîne vide (une chaîne sans caractères, de longueur égale à 0).

    Syntaxe

    ThisDoc.WorkspacePath()

    Launch

    Ouvre un fichier basé sur le chemin d'accès et le nom de fichier (y compris l'extension) fournis. Si un fichier de données est spécifié, il s'ouvre dans son application d'origine. Si un fichier exécutable (.exe) est spécifié, il exécute le programme. Si vous ne spécifiez pas le chemin d'accès complet, iLogic recherche le fichier dans le dossier qui contient le document Inventor. Vous pouvez également spécifier un nom et un chemin relatif pour le dossier du document.

    Syntaxe

    ThisDoc.Launch(“path\file.ext”)

    Save

    Enregistre le document actif. Cette fonction ne sert pas dans une règle déclenchée par un événement de type changement de paramètre.

    Syntaxe

    ThisDoc.Save

    UpdateWhenDone

    Met à jour le document contenant la règle après l'exécution de cette dernière (et de toute autre règle qu'elle déclenche). Le résultat est le même que lorsque vous cliquez sur le bouton Mettre à jour dans l'interface utilisateur.

    Syntaxe

    iLogicVb.UpdateWhenDone = True

    RuleParametersOutput

    Si votre règle a modifié des valeurs de paramètre, cette fonction applique de nouvelles valeurs de règle pour le modèle Inventor. Si cette fonction n'est pas utilisée, les valeurs ne sont pas appliquées tant que la règle n'est pas terminée. Utilisez cette fonction si vous devez effectuer une mise à jour à l'aide de DocumentUpdate. Utilisez également cette fonction si vous utilisez la fonction iLogicVb.RunRule, de sorte que l'autre règle puisse extraire les nouvelles valeurs des paramètres.

    Syntaxe

    RuleParametersOutput()

    DocumentUpdate

    Effectue une mise à jour immédiatement dans le document actif (le document qui contient la règle) et met à jour l'affichage. Utilisez cette fonction si vous avez besoin que la géométrie soit recréée (par exemple, si vous calculez les volumes à l'aide de iProperties.Mass). Si la règle déclenche d'autres règles (en modifiant les paramètres), activer l'option Exécuter les règles dépendantes immédiatement dans la boîte de dialogue Modifier la règle. Cette option permet de s'assurer que les autres règles ont terminé avant la mise à jour.

    Syntaxe

    InventorVb.DocumentUpdate()

    DocumentUpdate(False)

    Effectue une mise à jour immédiatement dans le document actif (le document qui contient la règle) sans mettre à jour l'affichage. La fonction InventorVb.DocumentUpdate met à jour l'affichage ainsi que le modèle. Si vous ne souhaitez pas mettre à jour l'affichage, utilisez cette fonction à la place.

    Syntaxe

    InventorVb.DocumentUpdate(False)

    Mise à jour de l'affichage

    Cette fonction API Inventor met à jour l'affichage, mais pas le modèle.

    Syntaxe

    ThisApplication.ActiveView.Update()

    CheckParameters

    Vérifie les valeurs des paramètres, mais ne les change pas.

    Utilisez cette fonction dans les cas suivants :

    Supposons que vos paramètres soient liés à une pièce de base, puis liés à une feuille de calcul externe dans la pièce de base. Il est possible de modifier les valeurs de paramètres dans la feuille de calcul et l'enregistrer sans ces modifications affichant dans la pièce principale. Utilisez cette fonction dans une règle de la pièce principale avant d'utiliser GoExcel pour modifier les valeurs dans la feuille de calcul. Cette fonction permet de s'assurer que la pièce de base est chargée (dans l'arrière-plan) et que les modifications sont propagées à la pièce principale de l'ensemble.

    Syntaxe

    InventorVb.CheckParameters(“”)

    File Save As

    Enregistre le document sous un nouveau nom de fichier et, éventuellement, sous une nouvelle extension.

    Syntaxe

    ThisDoc.Document.SaveAs(NewFileNameAndExtension , True)

    True

    Définie sur True, permet d'effectuer une opération Enregistrer la copie sous et définie sur False, d'effectuer une opération Enregistrer sous.

    Fonctions RunRule

    iLogic fournit plusieurs variantes d'une fonction qui peut être utilisée pour exécuter d'autres fonctions. En règle générale, vous modifiez un paramètre dans une règle pour déclencher la règle. Cette fonction est utile pour les règles sans paramètres ou identifiées par l'option Ne pas exécuter automatiquement.

    Pour accéder à ces fonctions, développez le noeud Exécuter (autre) sous l'onglet Système de la zone Extraits de code.

    RunRule

    Exécute une autre règle en spécifiant le nom de la règle. Utilisez une fonction RunRule pour des règles de génération de rapports qui n'ont pas d'incidence sur le modèle, mais qui peuvent faire référence à plusieurs paramètres. Vous pouvez exécuter n'importe quelle règle à l'aide de cette fonction.

    Syntaxe

    iLogicVb.RunRule("nom de la règle")

    Exemple

    iLogicVb.RunRule(“Rule0”)

    RunRule dans un composant

    Exécute une autre règle stockée dans un composant inclus dans un ensemble.

    Syntaxe

    iLogicVb.RunRule("nom du composant", "nom de la règle")

    Exemple

    iLogicVb.RunRule("PartA:1", "Rule0")

    Pour connaître les autres fonctions répertoriées dans la catégorie Exécuter (autre) de la zone Extraits de code, reportez-vous aux sections Fonctions API avancées et Règles de programmation avancées.

    RunExternalRule

    Exécute une règle externe à partir d'une règle standard d'un document Autodesk Inventor.

    Syntaxe

    iLogicVb.RunExternalRule("nom du fichier de règles")

    "nom du fichier de règles"

    Spécifie le nom du fichier de règles, avec ou sans l'extension de fichier. Vous pouvez également spécifier un chemin de fichier ici, mais cela peut avoir une incidence au niveau de la portabilité du fichier. iLogic recherche le fichier de règles dans les dossiers suivants et dans l'ordre indiqué :

    • Le dossier dans lequel le document Inventor actif est enregistré (permet la copie des modèles avec les règles associées).
    • Le dossier de l'espace de travail du projet Inventor actuel.
    • La liste des dossiers définis dans la configuration iLogic (généralement pour les règles d'entreprise ou de groupe de travail).

    Les noms de fichiers de règles peuvent correspondre aux noms de chemin, en fonction de l'un de ces dossiers.

    Les règles externes exécutées à partir d'une autre règle n'ont pas à s'afficher dans le navigateur de règles. Pour les modifier, cependant, vous devez les ajouter au navigateur.

    Exemple

    iLogicVb.RunExternalRule("color_by_vendor")

    RunMacro

    Exécute une macro Inventor Visual Basic for Applications (VBA). Les macros peuvent être stockées dans le document ou dans un fichier .ivb distinct. Utilisez Alt + F11 pour ouvrir l'éditeur VBA de Microsoft et afficher les macros disponibles, puis charger ou modifier des macros. Si la macro requiert des arguments, ajoutez-les à la suite du nom de la macro.

    Vous pouvez appeler une fonction VBA, mais vous ne pouvez pas obtenir une valeur renvoyée.

    RemarqueDans un futur proche, le langage VSTA devrait remplacer le langage VBA. Il n'est pas recommandé de créer de nouvelles macros VBA. Toutefois, si vous en disposez déjà, vous pouvez utiliser RunMacro.

    Syntaxe

    InventorVb.RunMacro("nom de projet", "nom de module", "nom de macro")

    Exemples

    InventorVb.RunMacro ("DocumentProject", "Module1", "DrawCustomLines" )
InventorVb.RunMacro ("ThreadMacros", "Module1", "ThreadsInit" )
InventorVb.RunMacro ("ThreadMacros", "Module1", "AddThreads", "3/8-16 UNC")

    AddReference

    Requise si vous souhaitez utiliser le code externe .NET (voir la section Règles de programmation avancées).

    Syntaxe

    ddReference "nom de fichier.dll"

    Fonctions de nomenclature

    Les fonctions de nomenclature permettent d'exécuter des opérations sur la nomenclature d'un ensemble.

    Vous pouvez remplacer les quantités de composants indiquées dans la nomenclature. Vous pouvez également exporter des données de nomenclature vers Excel et d'autres formats.

    Pour accéder aux fonctions de nomenclature, développez le noeud Nomenclature sous l'onglet Système de la zone Extraits de code.

    Export

    Vous pouvez exporter la nomenclature dans un fichier externe.

    RemarqueCette fonction n'est applicable qu'au niveau de détail principal dans l'ensemble.

    Syntaxe

    ThisBOM.Export("BOMViewName", filename, format)

    "BOMViewName"

    Nom qui s'affiche dans un onglet de la boîte de dialogue Nomenclature d'Inventor. Cette valeur peut être Données du modèle, Structuré ou Pièces uniquement. Activez la vue que vous voulez utiliser avant d'exécuter la règle pour la première fois (cliquez avec le bouton droit de la souris sur cet onglet dans la table de nomenclature).

    Nom de fichier

    Nom du fichier d'exportation à créer (avec extension de nom de fichier). Si vous ne spécifiez pas de chemin complet, la nomenclature est exportée dans le dossier dans lequel l'ensemble est stocké. Pour une exportation vers Excel, l'extension du nom de fichier doit être .xls (.xlsx n'est pas pris en charge).

    Format

    Formats possibles :

    • kMicrosoftAccessFormat = Microsoft Access
    • kMicrosoftExcelFormat = Microsoft Excel
    • kdBASEIVFormat = dBASE IV
    • kdBASEIIIFormat = dBASE III
    • kTextFileTabDelimitedFormat = Fichier texte délimité par des tabulations
    • kTextFileCommaDelimitedFormat = Fichier texte délimité par des virgules
    • kUnicodeTextFileTabDelimitedFormat = Fichier texte Unicode délimité par des tabulations
    • kUnicodeTextFileCommaDelimitedFormat = Fichier texte Unicode délimité par des virgules

    Exemples

    ThisBOM.Export("Parts Only", "Bom353.xls",  kMicrosoftExcelFormat)
ThisBOM.Export("Structured", "Bom631.xls",  kTextFileTabDelimitedFormat)
ThisBOM.Export("Structured", ThisDoc.ChangeExtension(".mdb"),  kMicrosoftAccessFormat)

    OverrideQuantity

    Remplace la quantité d'un composant. Cette fonction peut être utile si vous n'affichez que quelques occurrences dans le modèle et si la nomenclature répertorie le nombre réel. Vous obtenez le même résultat si vous ouvrez la boîte de dialogue Nomenclature, puis choisissez Quantité statique au lieu de Calculer la quantité dans la colonne QTE pour un composant.

    Syntaxe

    ThisBOM.OverrideQuantity("Model Data", partNumber, quantity)

    Le premier argument indique le nom de la vue de nomenclature et doit toujours être "Model Data".

    Numéro de pièce

    La propriété de numéro de pièce du composant. Cette valeur s'affiche sous la forme d'une colonne dans la vue de nomenclature.

    Quantité

    Quantité à définir pour ce composant.

    Exemple

    ThisBOM.OverrideQuantity("Model Data", "Top Screw", 18)

    CalculateQuantity

    Définit la quantité de nomenclature sur la quantité calculée automatiquement.

    Syntaxe

    quantité = ThisBOM.CalculateQuantity("Model Data", "partNumber")

    Exemple

    quantity = ThisBOM.CalculateQuantity("Model Data", "Top Screws")

    Fonctions mathématiques

    iLogic fournit un jeu de fonctions mathématiques qui peuvent être ajoutés à des règles. Dans la boîte de dialogue Modifier la règle iLogic, utilisez l'une des méthodes suivantes pour accéder aux fonctions mathématiques :

    • Développez le noeud Math sous l'onglet Système de la zone Extraits de code.
    • Cliquez avec le bouton droit dans la zone de texte de la règle, puis sélectionnez Fonctions mathématiques.

    Fonctions mathématiques standard

    La bibliothèque de fonctions mathématiques VB.NET standard fournit la plupart des fonctions mathématiques utilisées dans iLogic :

    IsNumeric PI
    MinOfMany Sqrt
    MaxOfMany Abs
    Round Sign
    Arrondir à la décimale Int
    Arrondir à l'incrément le plus proche Bloquer
    Arrondir à l'incrément supérieur Log10
    Arrondir à l'incrément inférieur Ln
    Ceil Pow
    Floor Min
    Sin Max
    Cos CDbl
    Tan EqualWithinTolerance

    Fonctions mathématiques iLogic

    iLogic fournit des fonctions mathématiques. Les fonctions suivantes permettent d'émuler les fonctions disponibles dans les équations de paramètres Inventor standard : 

    Ceil (same as Math.Ceiling)
Sign0(a) = 1 if a > 0.0, = 0 otherwise
Ln (same as Math.Log)

    Certaines fonctions Autodesk Inventor diffèrent des fonctions mathématiques standard en VB.NET qui portent le même nom. Par conséquent, elles sont converties dès qu'elles doivent servir à une règle iLogic :

    • La fonction sign devient sign0 dans la règle.
    • La fonction log devient log10 dans la règle.

    Fonctions trigonométriques

    Sin(0) = 0 Cos(PI) = -1
    Sin(PI) = 0 Tan(0) = 0
    Sin(PI/2) = 1 Tan(PI/4) = 1
    Cos(0) = 1 PI = 3.1415926......
    Cos(PI/2) = 0  

    Sin(), Cos() et Tan() sont des fonctions trigonométriques standard avec des arguments exprimés en radians (pas de degrés) :

    Si vous utilisez l'option Capturer l'état actuel dans une formule trigonométrique de la boîte de dialogue Modifier la règle, la fonction n'est pas convertie en fonction VB.NET. La formule garde le format indiqué dans Inventor. Vous pouvez modifier la formule manuellement pour la convertir en formule VB.NET (avec des unités d'angle en radians).

    Convertissez des degrés en radians à l'aide de la formule suivante :

    radians = degrés *(PI/180)

    Autres fonctions mathématiques

    Fonction Objectif Exemples
    Abs() Renvoie la valeur absolue de l'argument.

    Abs(10) = 10

    Abs(-9.87) = 9.87

    Sqrt() Renvoie la racine carrée de l'argument.

    Sqrt(25) = 5

    Sqrt(100) = 10

    Sqrt(3) = 1.732051

    Sign() Renvoie un nombre indiquant le signe de l'argument.

    Si la valeur est positive, Sign(valeur) = 1

    Si la valeur est négative, Sign(valeur) = -1

    Si la valeur est nulle, Sign(valeur) = 0

    Round() Arrondit l'argument à un nombre entier ou à un certain nombre de chiffres après la virgule.

    Syntaxe : Round(argument, nombre de chiffres après la virgule (facultatif))

    Round(2.55689) = 3

    Round (2.55689, 1) = 2.6

    Round(2.55689, 3) = 2.557

    Round(PI, 4) = 3,1416

    Ceil() Arrondit l'argument à l'entier supérieur le plus proche.

    Ceil(2.56) = 3

    Ceil(Sqrt (3) = 2

    Floor() Arrondit l'argument à l'entier inférieur le plus proche.

    Floor (1.789) = 1

    Floor (PI) = 3

    Log10() Renvoie le logarithme décimal de l'argument.

    Log10(10) = 1

    Log10(100) = 2

    Log10(15) = 1.176091

    Ln() Renvoie le logarithme naturel de l'argument. (Logarithme de base e.)

    Ln(5) = 1.609438

    Ln(37) = 3.610918

    Pow(argument1, argument2) Renvoie le résultat de argument1 élevé à l'exposant argument2.

    Pow(2, 2) = 22 = 4

    Pow(2, 3) = 23 = 8

    Pow(3, 2) = 32 = 9

    Fonctions de comparaison

    Fonction Objectif Exemples
    Min(argument1, argument2) Renvoie le plus petit des deux arguments.

    Min(2, 4) = 2

    Min(9, 4) = 4

    Min(Sqrt(2), Sqrt(3)) = 1.4142.....

    Max(argument1,argument2) Renvoie le plus grand des deux arguments.

    Max(2, 4) = 4

    Max(9, 4) = 9

    Sqrt(3)) = 1.73205.....

    MinOfMany( ,,, ) Renvoie le plus petit argument de la liste.

    MinOfMany (2,4,3,6,7,8) = 2

    MinOfMany (9,4,5,67,3,5) = 3

    MinOfMany (Sqrt(2), Sqrt(3), Sin(PI/2) ) = 1

    MaxOfMany( ,,, ) Renvoie le plus grand argument de la liste.

    MaxOfMany(2,4,3,6,7,8) = 8

    MaxOfMany(9,4,5,67,3,5) = 67

    MaxOfMany(Sqrt(2), Sqrt(3), Sin(PI/ignored>/2)) = 1.73205.....

    EqualWithinTolerance(a, b, 0.001) Compare les valeurs de deux paramètres (représentés par a et b) et compare la différence obtenue par rapport à la valeur de tolérance (spécifiée ici sous la forme 0.001). Si la différence est inférieure à la tolérance, la fonction renvoie la valeur booléenne True (vrai). Si la différence est supérieure à la tolérance, la fonction renvoie la valeur booléenne False (faux).

    Si a = 10.00 et b = 10.01

    EqualWithinTolerance(a, b, 0.015) = True[Abs(a-b) est inférieur à la valeur de tolérance de 0.015 po]

    EqualWithinTolerance(a, b, 0.001) = False[Abs(a-b) est supérieur à la valeur de tolérance de 0.001]

    EqualWithinTolerance(a,b) Utilisez une tolérance par défaut de 0.0000001  

    Fonctions de chaîne

    iLogic fournit un jeu de fonctions de chaîne pour les paramètres de texte qui peuvent être inclus dans vos règles iLogic. Pour accéder aux fonctions de chaîne, développez le noeud Chaînes sous l'onglet Système de la zone Extraits de code.

    Fonctions de chaîne standard

    La plupart des fonctions de chaîne utilisées dans iLogic sont fournies en tant qu'élément de la bibliothèque de chaînes VB.NET standard. Exemples :

    Left() CStr()
    Compare Now()
    Len() DateString
    Right() TimeString
    Mid() Val(string)
    LCase() Read All Text
    UCase()  

    La documentation relative à ces fonctions est disponible sur http://msdn.microsoft.com/fr-fr/library/system.string_methods%20(VS.80).aspx

    Fonctions de chaîne iLogic

    Plusieurs fonctions de chaîne sont spécifiques à iLogic :

    Fonction Objectif Exemples
    CDblAny(chaîne) Convertit une chaîne de texte en une valeur double. Comme la fonction VB.NET CDbl standard. Il permet de convertir une chaîne de texte à l'aide d'une virgule ou d'un point comme séparateur décimal, indépendamment des paramètres de langue Windows. Il peut échouer si la chaîne de texte ne représente pas un nombre correct.

    x = CDblAny("3.14159") renvoie 3.14159

    x = CDblAny(“3.14159”) renvoie 3.14159

    RoundToFraction(valeur, fractionFactor, RoundingMethod.Round)

    Convertit une valeur numérique en chaîne de texte sous la forme d'une fraction pour représenter les mesures en pouces.

    Renvoie une fraction (par exemple, "1/2") ou un numéro et une fraction (par exemple, "3 5/8"). Arrondit la valeur à un multiple du facteur de fraction.

    fractionFactor doit être 1/2, 1/4, 1/8, 1/16, 1/32, 1/64 ou 1/128.

    RoundingMethod.Round arrondit au multiple le plus proche de fractionFactor.

    RoundToFraction(0.7502, 1/4, RoundingMethod.Round)renvoie "1/4"

    RoundToFraction(valeur, fractionFactor, RoundingMethod.RoundUp)

    Convertit une valeur numérique en chaîne de texte sous la forme d'une fraction pour représenter les mesures en pouces.

    Renvoie une fraction (par exemple, "1/2") ou un numéro et une fraction (par exemple, "3 5/8"). Arrondit la valeur à un multiple du facteur de fraction.

    fractionFactor doit être 1/2, 1/4, 1/8, 1/16, 1/32, 1/64 ou 1/128.

    RoundingMethod.RoundUp arrondit au multiple le plus proche de fractionFactor, supérieur ou égal à la valeur.

    RoundToFraction(0.7502, 1/4, RoundingMethod.RoundUp)renvoie "3/4"

    RoundToFraction(0.749, 1/4, RoundingMethod.RoundUp) renvoie "3/4"

    RoundToFraction(0.749, 1/8, RoundingMethod.RoundUp)renvoie "3/4"

    RoundToFraction(0.7, 1/8, RoundingMethod.RoundUp) renvoie "3/4"

    RoundToFraction(0.6, 1/4, RoundingMethod.RoundUp)renvoie "3/4"

    RoundToFraction(0.6, 1/8, RoundingMethod.RoundUp) renvoie "5/8"

    RoundToFraction(valeur, fractionFactor, RoundingMethod.RoundDown)

    Convertit une valeur numérique en chaîne de texte sous la forme d'une fraction pour représenter les mesures en pouces.

    Renvoie une fraction (par exemple, "1/2") ou un numéro et une fraction (par exemple, "3 5/8"). Arrondit la valeur à un multiple du facteur de fraction.

    fractionFactor doit être 1/2, 1/4, 1/8, 1/16, 1/32, 1/64 ou 1/128.

    RoundingMethod.RoundDown arrondit au multiple le plus proche de fractionFactor, inférieur ou égal à la valeur.

    RoundToFraction(0.7502, 1/4, RoundingMethod.RoundDown) renvoie "3/4"

    RoundToFraction(0.749, 1/4, RoundingMethod.RoundDown) renvoie "1/2"

    FormatAsFraction(valeur, [nbreDécimales])

    Convertit une valeur numérique en chaîne de texte sous la forme d'une fraction pour représenter les mesures en pouces.

    Renvoie une fraction (par exemple, "1/2") ou un numéro et une fraction (par exemple, "3 5/8"), uniquement si la valeur peut être exprimée sous forme d'une fraction de nombre entier avec un dénominateur de puissance (jusqu'à un maximum de 128, dans 0.0000001). Dans le cas contraire, elle renvoie un nombre décimal.

    Si les décimales sont renvoyées, l'argument nbreDécimales affecte l'arrondi de la chaîne de texte obtenue. Cet argument est facultatif et par défaut égal à 3 si aucune valeur n'est fournie.

    FormatAsFraction(0.75) renvoie "3/4"

    FormatAsFraction(2.375)renvoie"2 3/8"

    FormatAsFraction(2,4) renvoie "2.4"

    FormatAsFraction(2.00001) renvoie "2"

    RemarqueVous pouvez utiliser la fonction CDblAny pour convertir les valeurs des paramètres de texte iLogic en nombres.

    Fonctions de variables

    Pour accéder aux fonctions de variables, développez le noeud Variables sous l'onglet Système de la zone Extraits de code.

    Fonctions SharedVariable

    Les variables partagées iLogic sont partagées entre les règles et stockées dans la mémoire. Contrairement aux paramètres Inventor, elles ne sont pas associées à une pièce ou à un ensemble. Vous pouvez utiliser les variables partagées au lieu de paramètres Inventor pour transmettre des données entre les règles. Vous pouvez également les utiliser pour stocker des données qui ne peuvent pas être stockées dans des paramètres Inventor. Voici quelques exemples de leur utilisation :

    SharedVariable(“Thread1”) = “1/4-20 UNC”

    Attribue une valeur à une variable partagée appelée Thread1. Si cette variable n'existe pas, elle est créée.

    s0 = SharedVariable(“Thread1”)

    Attribue la valeur d'une variable partagée à un paramètre de texte. Le type de variable est connu parce que vous l'avez créé précédemment.

    SharedVariable(“Distance1”) = 7.2

    Attribue un numéro à une variable partagée.

    d0 = SharedVariable(“Distance1”)

    Attribue la valeur d'une variable partagée à un paramètre numérique.

    if SharedVariable.Exists(“Thread1”) then

    Vérifie si un paramètre existe déjà. Si le paramètre a été créé dans une autre règle, cette fonction renvoie une valeur vraie.

    SharedVariable.Remove(“Thread1”)

    Supprime une variable partagée. Bien que cela ne soit pas obligatoire, cette fonction est recommandée si vous savez que vous n'avez plus besoin de la variable.

    SharedVariable.RemoveAll()

    Supprime toutes les variables partagées. Utilisez cette option avec précaution dans une règle. Si des pièces et ensembles ouverts sans rapport entre eux utilisent des variables partagées, utilisez plutôt la commande Mémoire iLogic disponible.

    Fonctions de création Array

    Les fonctions de création Array sont des fonctions Visual Basic standard qui permettent de définir différents types de tableaux et de spécifier des valeurs initiales. Pour plus d'informations sur ces fonctions, reportez-vous à l'aide de Visual Basic.

    Nouvel array de type double

    Définit un nouveau tableau de type Double et définit des valeurs initiales. 

    MyDoubleValues = new double(){1.2,2.2,3.3}

    Nouvel array de type entier

    Définit un nouveau tableau de type Integer et définit des valeurs initiales. 

    MyIntegerValues = new integer(){1,2,3}

    Nouvel array de type chaîne

    Définit un nouveau tableau de type String et définit des valeurs initiales. 

    MyStringValues = new string(){string1,string2}

    Nouvel array de type objet

    Définit un nouveau tableau de type Object et définit des valeurs initiales. 

    MyObjectValues = new object(){“string”,true,1.234}

    Nouvel ArrayList

    Définit une nouvelle variable de type ArrayList et y ajoute des valeurs. 

    Dim MyArrayList As New ArrayListMyArrayList.add(“string”)MyArrayList.add(1.234)MyArrayList.add(True)

    Pour chaque boucle

    Passe en boucle par les valeurs d'une variable Array ou ArrayList. 

    for each oval in MyVariableHeremsgbox(oval)next

    Fonctions de propriétés des matières

    Pour accéder aux fonctions de propriétés de matière, développez le noeud Propriétés des matières sous l'onglet Système de la zone Extraits de code.

    Reportez-vous à l'aide de l'API Inventor pour plus d'informations sur ces fonctions.

    Fonctions SheetMetal

    Utilisez les fonctions SheetMetal pour définir et/ou lire la règle de tôlerie actuelle et FacteurX dans une pièce en tôle. Ces fonctions vous permettent de modifier la règle de tôlerie automatiquement, selon certaines conditions, telles que la matière active ou l'épaisseur de matière.

    Pour accéder aux fonctions SheetMetal, développez le noeud Tôlerie sous l'onglet Système de la zone Extraits de code.

    SheetMetal.SetActiveStyle

    Définit la règle de tôlerie active. Vous obtenez le même résultat si vous sélectionnez manuellement une règle de tôlerie dans la boîte de dialogue Paramètres par défaut de la tôle.

    Syntaxe

    SheetMetal.SetActiveStyle("styleName")

    "styleName"

    Nom de la règle de tôlerie dans la boîte de dialogue Paramètres par défaut de la tôle. Ce nom n'est pas sensible à la casse.

    Exemples

    SheetMetal.SetActiveStyle(“styleName”)

    Indique le nom d'un style dans la liste des règles de tôlerie :

    SheetMetal.SetActiveStyle(MyStyleParameter)

    Spécifie un paramètre de texte iLogic.

    SheetMetal.GetActiveStyle

    Lit la règle de tôlerie active. Vous pouvez l'affecter à un paramètre de texte iLogic à une variable locale dans une règle. Utilisez cette fonction pour agir sur un modèle ou modifier le modèle en fonction de la règle de tôlerie active.

    Exemple

    CurrentStyleParameter=SheetMetal.GetActiveStyle()

    SheetMetal.ActiveKFactor

    Lit le FacteurX actif (valeur numérique).

    Exemples

    KFactorParameter=SheetMetal.ActiveKFactor

    Fonctions d'encombrement de la mise à plat

    Utilisez ces fonctions pour obtenir la surface de la mise à plat dépliée. Vous pouvez également afficher ces valeurs en cliquant avec le bouton droit de la souris sur la mise à plat de l'arborescence du modèle de pièce en tôle et en sélectionnant Encombrement.

    SheetMetal.FlatExtentsLength

    Extrait la longueur (cote X) de l'encombrement de la mise à plat.

    SheetMetal.FlatExtentsWidth

    Extrait la largeur (cote Y) de l'encombrement de la mise à plat.

    SheetMetal.FlatExtentsArea

    Extrait l'aire (X * Y) de l'encombrement de la mise à plat.

    Fonctions de dessin

    Utilisez des fonctions de dessin pour personnaliser la manière dont les modifications apportées au modèle sont répercutées dans le dessin. Les fonctions de dessin facilitent les mises à jour du modèle et peuvent être incluses dans les règles déclenchées par l'événement Modification de la vue de dessin iLogic.

    ThisDrawing

    Permet d'accéder au dessin en cours dans une règle.

    ActiveSheet

    Permet d'accéder à la feuille active dans un dessin. Cette fonction est un alias pour ThisDrawing.ActiveSheet. La plupart des opérations de dessin sont effectuées dans la feuille active, car les autres feuilles ne sont pas forcément à jour.

    ThisDrawing.Sheet

    Permet d'accéder à une feuille dans le dessin.

    Syntaxe

    ThisDrawing.Sheet("sheetname")

    ResourceFileName

    Vous pouvez affecter une chaîne de nom de fichier à cette propriété pour spécifier le nom d'un autre dessin duquel extraire des définitions de cartouches et de cadres. Lorsque vous utilisez la fonction de feuille Cartouche ou Cadre, iLogic recherche dans ce dessin des ressources qui ne sont pas disponibles dans le dessin en cours. Utilisez un chemin relatif pour ce nom de fichier. iLogic recherche ce fichier dans le dossier contenant le dessin en cours et dans le dossier de l'espace de travail du projet. Vous pouvez spécifier des sous-dossiers par rapport à ces emplacements.

    Exemple

    ThisDrawing.ResourceFileName = “DrawingResources1.idw”

    KeepExtraResources

    Définissez cette propriété sur Faux pour conserver dans le dessin en cours des copies des ressources disponibles dans le fichier de ressources externe.

    Si vous réglez cette propriété sur Faux, une ressource est supprimée lorsqu'une autre ressource la remplace. La suppression se produit uniquement si le champ ResourceFileName n'est pas vide. Toutes les ressources dont vous avez besoin se trouvent normalement dans le fichier de ressources externe.

    Exemple

    ThisDrawing.KeepExtraResources = False

    Fonctions de feuille

    Les fonctions de feuille appliquées aux dessins agissent généralement sur la feuille active. Pour restreindre une règle de manière à ce qu'elle s'exécute sur une feuille donnée, vous pouvez ajouter du code au début d'une règle. Par exemple : 

    If (ActiveSheet.Name <> "Sheet:2") Then Return

    ChangeSize (à l'aide d'une valeur de chaîne de texte)

    Change la taille de la feuille en fonction d'une valeur de chaîne de texte indiquant la nouvelle taille.

    Syntaxe

    Sheet.ChangeSize ("value",<MoveBorderItems = True>)

    valeur

    Valeur de la nouvelle taille.

    MoveBorderItems

    Ce paramètre est facultatif. Si MoveBorderItems est défini sur Faux, les tables et les listes de pièces actuellement situées sur le cadre ou bord de la feuille ne sont pas déplacées vers le nouveau cadre.

    Exemples

    ActiveSheet.ChangeSize (“A”)
    ActiveSheet.ChangeSize (“B1”, MoveBorderItems := False)

    ChangeSize (à l'aide de valeurs personnalisées)

    Change la taille de la feuille à l'aide d'une hauteur et d'une largeur personnalisées dans l'unité du document.

    Syntaxe

    Sheet.ChangeSize (customHeight, customWidth, <MoveBorderItems = True>)

    hauteur

    Hauteur dans l'unité du document.

    largeur

    Largeur dans l'unité du document.

    MoveBorderItems

    Ce paramètre est facultatif. Si MoveBorderItems est défini sur Faux, les tables et les listes de pièces actuellement situées sur le cadre ou bord de la feuille ne sont pas déplacées vers le nouveau cadre.

    Exemples

    ActiveSheet.ChangeSize (7.2, 4)
    ActiveSheet.ChangeSize ( 7.2, 4, MoveBorderItems = False)

    Sheet.Border

    Modifiez le cadre de la feuille en spécifiant un autre nom. Ce nom doit être présent dans le dossier de ressources de dessin du dessin en cours ou dans le dessin ResourceFileName s'il est spécifié.

    Exemples

    ActiveSheet.Border = “OtherBorder”
    currentName = ActiveSheet.Border

    Sheet.TitleBlock

    Modifiez le cartouche actuel de la feuille en spécifiant un autre nom. Ce nom doit être présent dans le dossier de ressources de dessin du dessin en cours ou dans le dessin ResourceFileName s'il est spécifié.

    Exemples

    ActiveSheet.TitleBlock = “ANSI - A”
    currentName = ActiveSheet.TitleBlock

    Exemple lors de l'utilisation d'un fichier source externe - 

    ThisDrawing.ResourceFileName = “DrawingResources1.idw”
ActiveSheet.TitleBlock = “Custom - A”

    ActiveSheet.Name

    Extrait le nom de la feuille.

    ActiveSheet.Size

    Extrait la taille de la feuille sous la forme d'une chaîne de texte, par exemple : "A" ou “B0”.

    ActiveSheet.Height

    Extrait la hauteur de la feuille dans l'unité du document.

    ActiveSheet.Width

    Extrait la largeur de la feuille dans les unités du document.

    ActiveSheet.View(“viewName”)

    Permet d'accéder à une vue de la feuille.

    Fonctions View

    Les fonctions View appliquées aux dessins agissent généralement sur la feuille active (recommandé).

    View.Name

    Extrait le nom de la vue.

    View.Height

    Extrait la hauteur de la vue dans l'unité du document.

    View.Width

    Extrait la largeur de la vue dans les unités du document.

    View.Scale

    Extrait ou définit l'échelle de la vue sous la forme d'un nombre.

    View.ScaleString

    Extrait ou définit l'échelle de la vue sous la forme d'une chaîne de texte, par exemple : “1:2” ou “4.1”.

    View.SetCenter(centerX,centerY)

    Définit le point de centre de la vue (déplace la vue). Les coordonnées sont indiquées dans les unités du dessin.

    View.SetSpacingToCorner(distanceX, distanceY, corner)

    Définit la position de la vue (déplace la vue) en spécifiant la distance d'un angle à l'angle de la feuille le plus proche. La variable Coin peut être l'un des éléments suivants : 

    SheetCorner.BottomLeft
SheetCorner.BottomRight
SheetCorner.TopLeft
SheetCorner.TopRight

    Les coordonnées sont indiquées en unités de dessin. iLogic détermine l'angle le plus proche à un angle de la feuille.

    View.SpacingBetween(“otherViewName”)

    Définit la position de la vue (déplace la vue) en spécifiant l'espace entre cette vue et une autre vue. L'autre vue correspond généralement à une vue adjacente sur la feuille. L'espacement est entre les arêtes, dans la direction X ou Y. Indiquez une valeur d'espacement positive pour placer la vue vers la droite ou au-dessus de l'autre vue. Indiquez une valeur négative pour placer la vue vers la gauche ou en dessous de l'autre vue. Par exemple : 

    ActiveSheet.View("VIEW2").SpacingBetween("VIEW1") = 30 mm  '

    VUE2 se trouve à droite de VUE1. 

    ActiveSheet.View("VIEW3").SpacingBetween("VIEW1") = -40 mm  '

    VUE3 se trouve sous VUE1.

    View.Balloons

    Permet d'accéder aux repères de la vue.

    Fonctions Balloons

    Les fonctions Balloons des dessins sont liées à une vue spécifique.

    Balloons.Reattach

    Pour les vues de fichiers ensemble, cette fonction permet de rechercher dans la vue les repères non attachés et de les attacher à un composant, dans la mesure du possible. La première recherche s'effectue à l'emplacement de la pointe de la flèche. Si aucun composant n'est trouvé, le composant plus proche est utilisé. Si le repère ne peut pas être associé à ce stade, il est déplacé vers un calque masqué. Le calque masqué est un calque créé (si nécessaire) à cette fin.

    RemarqueCette fonction nécessite la définition de l'option Conserver les annotations orphelines pour le dessin (sous Outils Options Paramètres du document). Si cette option n'est pas sélectionnée, la fonction la définit automatiquement.

    Balloons.AttachToComponent(“componentName”)

    Spécifie un composant qui requiert un repère. componentName indique une occurrence de composant, telle que "Broche:1". Lorsque vous utilisez cette fonction, les repères sont uniquement rattachés aux composants que vous spécifiez. Si vous n'utilisez pas cette fonction, les repères sont rattachés à n'importe quel composant disponible (excepté ceux rejetés par la fonction DoNotAttachToComponent).

    Balloons.DoNotAttachToComponent(“componentName”)

    Spécifie un composant qui ne requiert pas un repère. componentName indique une occurrence de composant, telle que "Broche:1".

    Fonctions API de dessin avancées

    Utilisez les fonctions API de dessin avancées pour tirer parti des fonctions d'API. Notez les types d'interface suivants pour les objets utilisés dans les fonctions de dessin :

    • ThisDrawing est de type ICadDrawing.
    • Feuille est de type ICadSheet.
    • Vue est de type ICadView.

    ThisDrawing.Document

    Permet d'accéder au document de dessin sous-jacent. Renvoie un objet de type Inventor.DrawingDocument.

    ICadSheet.Sheet

    Permet d'accéder à la feuille sous-jacente. Renvoie un objet de type Inventor.Sheet.

    ICadView.View

    Permet d'accéder à l'objet de la vue sous-jacente. Renvoie un objet de type Inventor.DrawingView.

    ICadView.ModelDocument

    Permet d'accéder au document indiqué dans cette vue. Renvoie un objet de type Inventor.Document. Ne renvoie rien si le document n'est pas une vue de modèle.

    Fonctions API avancées

    ThisApplication

    Objet de l'application Inventor pour la session active d'Autodesk Inventor. A partir de cet objet, vous pouvez accéder directement à l'API Inventor. Pour obtenir de l'aide sur l'API, consultez le document d'aide à la programmation, disponible dans le menu d'aide, sous Ressources supplémentaires.

    Cet objet est également accessible par le biais de l'ancienne syntaxe :

    app = InventorVb.Application

    ThisDoc.Document

    Ouvre le document dans lequel la règle actuelle est stockée en tant qu'objet Inventor.Document. Cette fonction permet d'indiquer un point de départ pour examiner ou modifier le modèle. Cet objet est décrit dans l'aide de l'API Inventor.

    Syntaxe

    doc = ThisDoc.Document

    Cet objet est également accessible par le biais de l'ancienne syntaxe :

    doc = iLogicVb.RuleDocument

    ModelDocument

    Ouvre le document modèle (pièce ou ensemble) affiché dans un document de dessin. Si aucun document modèle n'existe, cette fonction ne renvoie rien. Si plusieurs documents modèle existent, elle renvoie le premier fichier trouvé.

    Syntaxe

    doc = ThisDoc.ModelDocument

    Automation

    Permet d'accéder à l'objet iLogicAutomation dans une règle.

    Syntaxe

    auto = iLogicVb.Automation

    UserInterfaceManager

    Requis dans une règle avant d'utiliser certaines fonctions de l'API Inventor telles que Document.SelectSet.Select. Si vous rencontrez un extrait de code VBA ou un autre code API qui ne fonctionne pas dans une règle, ajoutez cette instruction en haut de la règle.

    Syntaxe

    ThisApplication.UserInterfaceManager.UserInteractionDisabled = False

    InventorComponent

    Utilisez cette fonction pour obtenir l'accès direct à un composant. Elle renvoie un objet de type Inventor.ComponentOccurrence.

    Syntaxe

    compo = Component.InventorComponent("componentName")

    InventorFeature

    Permet d'accéder directement à un objet. Cette fonction renvoie un objet de type Inventor.PartFeature.

    Syntaxe

    feat = Feature.InventorFeature("featureName")

    InventorFeature (composant)

    Permet d'accéder directement à une fonction d'un composant ou d'un document.

    Syntaxe

    feat = Feature.InventorFeature(componentOrDocNameName, "featureName")

    Commentaires0

    Fonctionne avec MindTouch
    © Copyright 2012 Autodesk, Inc. All rights reserved.   Privacy Policy — Legal Notices & Trademarks