[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9

Tuto n°1 Dessiner des lignes avec la console Ruby

Je pars du préambule ou vous avez un peu épluché les tutos.
Juste un petit rappel les variables sont des casiers dans lequel vous rangez des données, et vous les manipulez à volonté
On verra le long du déroulé qu'il existe différentes sortes de variables (string, interger, instance, globale....)
Nous allons dans cette première partie utiliser des variables locales n'étant reconnues uniquement par la méthode en cours
Ruby est un interpréteur qui travaille sur des objets que l'on utilise dans des méthodes (fonctions) ou peut regrouper ses méthodes dans des classes
Dans un variable, on peut également stocké un objet, une méthode, une classe. (permet de gagner en lisibilité, en temps de saisie).

1. Lancement de la console Ruby
   
   
   
   
2. Panneau de la console Ruby
   
   
   
   
3. Saisie de la première variable
   
   
   
   
4. Résultat de la saisie
   
   
   
   
5. Saisie de la deuxième variable
   
   
   
   
6. Résultat de la saisie
   
   
   
   
7. Définition de la variable model
   
   
   
   
8. Ajout de la commande
   
   
   
   Si d'aventures on supprimait la notion de variable, voila comment on devrait ecrire la ligne de commande à chaque fois que la veux dessiner une ligne
   

   Code:

   Sketchup.active_model.entities.add_line [0, 0, 0],[50, 50, 50]

   
   
9. Envoie de la commande et résultat
   
   
   
   
10. Modification de la variable pt1
    
    
    
11. Envoie de la commande
    
    
    
    
    
12. Resultat
    
    
    
    Notez que nous n'avons pas modifié le pt2 il reste donc (50,50,50)
    
    
13. Renouvellement de l'opération pour dessiner une troisième ligne
    
    
    

Alors évidement, ca n'est pas très pratique de tracer des ligne de cette manière, d'autant qu'il existe une commande native de Sketchup qui le fait très bien!!! Nous allons voir comment simplifier la tache et passer à la rédaction d'un script

Si l'on fait l'inventaire des lignes envoyé à la console :

Code:

pt1 = [0,0,0]
pt2 = [50,50,50]
model = Sketchup.active_model
model.entities.add_line(pt1, pt2)
pt1 = [0,100,0]
model.entities.add_line(pt1, pt2)
pt1 = [100,0,0]
model.entities.add_line(pt1, pt2)

Eh Bien voila votre premier script est redigé, vous copiez ces lignes dans un editeur de texte et vous le sauvegardez avec l'extention "rb"
Par exemple TutoApi100.rb et vous le placez comme d'habitude dans le répertoire plugins de Google et vous relancez Sketchup. Pour ceux qui ont installé Ruby Toolbar il suffit de cliquer sur load et de charger le plugin que vous avez créé (TutoApi100.rb par ex), le résultat est immédiat.

On voit tout de suite les limites de notre premier script, il s'éxécute systématiquement au démarrage de Sketchup et il n'y a pas moyen de modifier les paramètres des lignes dessinées. Nous allons donc voir par la suite comment exécuter un script à la demande et comment saisir les paramètres
(c'est la ou allez mieux appréhender l'intérêt des variables).

Lien pour ceux qui veulent télécharger directement le plugin TutoApi100.rb

Gif animé Téléchargeable :



Lien des Api utilisées :

Sketchup.active_model surtout utilisé pour la compabilité avec Mac qui peut gèrer plusieurs modèles en même temps. En l'occurence on signale avec cette méthode de travailler sur le modèle ciblé (actif).
C'est donc la méthode active_model de la classe Sketchup
Entities.add_line méthode qui permet d'ajouter des lignes. c'est la méthode add_line de la Classe Entities

Nous allons reprendre l'idée du tuto précédent mais la, en renseignant les variables dans une boîte de dialogue ''inputbox ''



Première ligne de code : On renseigne la variable prompts

Code:

prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]

On définit un variable prompts qui va contenir les éléments de requete de notre inputbox, ce sont des éléments texte mis entre '' ''
Ici notre inputbox va comporter 6 lignes

Deuxième ligne on renseigne la variable values

Code:

values = [0, 0, 0, 0, 50, 0]

Ici on affecte par défaut des valeurs aux variables

Troisième ligne on exécute l'inputbox et le résultat est affecté à la variable results

Code:

results = UI.inputbox prompts, values, "Ma premiere InputBox"

On exécute la méthode inputbox de la classe UI avec les variables définies préalablement prompts et values et pour finir on lui affecte un nom qui appaitra à l'affichage
Les éléments saisies sont affectés sequentiellement à la variable results

Quatrième ligne : c'est ligne qui assure un contrôle

Code:

return if not results

Si la variable results n'est pas conforme reotur à inputbox

Cinquième ligne réattribution de la variable results

Code:

x1, y1, z1, x2, y2, z2 = results

On ventile les éléments de la variable results dans des variables pour les traiter en aval

A partir de maintenant on va réexploiter les lignes du plugin précédent, les coordonnées vont être remplacées par les variables

Code:


pt1 = [x1,y1,z1]
pt2 = [x2,y2,z2]
model = Sketchup.active_model
model.entities.add_line(pt1, pt2)

Notre code complet

Code:


# Le diese permet de rentrer des lignes de commentaires sans affecter le déroulement du plugin
prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]
values = [0, 0, 0, 0, 50, 0]
results = UI.inputbox prompts, values, "Ma premiere InputBox"
return if not results   
x1, y1, z1, x2, y2, z2 = results
pt1 = [x1,y1,z1]
pt2 = [x2,y2,z2]
model = Sketchup.active_model
model.entities.add_line(pt1, pt2)

Voilà notre plugin s'améliore un peu, cependant il ne s'exécute qu'une seule fois et au démarrrage

Pour ceux qui veulent téécharger directement le plugin TutoApi101.rb

Commandes utilisées

UI.inputbox Méthode inputbox de la classe UI, permet de créer une boite de dialogue

Christophe

Nous allons reprendre l'exemple du tuto précédent et lui ajouter une boîte de Dialogue UI.messagebox....MB_YESNO
Pour cela nous allons introduire une notion très importante la définition d'une méthode def...end

Nous allons donc définir des petit modules (méthodes), qui ne seront exécutées qu'a la demande en l'appelant par le nom qui lui a été donné

L'ancien plugin va être transformé en méthode et appelé par la boîte de dialogue si on répond oui

Ancien code :

Code:


prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]
values = [0, 0, 0, 0, 50, 0]
results = UI.inputbox prompts, values, "Ma premiere InputBox"
return if not results   
x1, y1, z1, x2, y2, z2 = results
pt1 = [x1,y1,z1]
pt2 = [x2,y2,z2]
model = Sketchup.active_model
model.entities.add_line(pt1, pt2)

Nous allons donc déclarer la méthode et lui donner le nom de "mon_inputbox"

Code:

def mon_inputbox

Et déclarer la fin de la méthode par :

Code:

end

Code complet de la mèthode :

Code:


# Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]
      values = [0, 0, 0, 50, 50, 0]
      results = UI.inputbox prompts, values, "Ma premiere InputBox"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      # Costruction de la ligne
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)
   end

Si vous en restez là au niveau de l'écriture du plugin, rien ne passera, la méthode est bien déclarée, mais est en attente

Création de la boîte de dialogue qui va lancer la méthode mon_inputbox

Code:

result = UI.messagebox "Voulez vous dessiner une ligne ?", MB_YESNO

Lancement de la méthode UI.messagebox comportant le texte "Voulez vous dessiner une ligne ?" de type oui ou non MB_YESNO, dont le résultat sera affecté à la variable result

Par défaut la valeur de result lorsque le retour est oui c'est 6

Code:

if result == 6 # valeur de retour pour Oui

Nous testons ici si result est ègale à 6 si c'est le cas on passe à la suite sinon on saute à la ligne else ou end si else n'existe pas (c'est une notion importante cela veut dire que l'on peut excuter deux méthodes différentes en fonction du retour ou éventuellement ne rien faire si le retour n'est pas oui.
Le == n'est pas une erreur de frappe, mais permet de faire le distingo avec le =, le == signifie que l'on pose la question "est ce que la valeur est égale", le = assigne généralement une valeur

Code:

status = mon_inputbox

Lancement de la méthode mon_inputbox, il y a toujours une notion de variable puisque nous pourrions attribuer une valeur plutôt qu'une méthode, par status = "Vous avez cliquer sur oui Merci" et ensuite lancer une commande du style UI.messagebox status

Si toutefois vous cliquez sur NON :

Code:

else UI.beep

Si la réponse n'est pas OUI exécution de la commande UI.beep (vous l'avez deviné il vous envoie un beep)

Code:

end

Fin de la commande

Code complet :

Code:


# Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]
      values = [0, 0, 0, 50, 50, 0]
      results = UI.inputbox prompts, values, "Ma premiere InputBox"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      # Costruction de la ligne
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)
   end

   result = UI.messagebox "Voulez vous dessiner une ligne ?", MB_YESNO
   if result == 6 # valeur de retour pour Oui
   status = mon_inputbox
   # status = "Vous avez cliquer sur oui Merci"
   # UI.messagebox status
   else UI.beep
   end

Si vous voulez télécharger directement le plugin de test :

TutoApi102.rb

Méthodes utilisées:

UI.messagebox MB_YESNO, Méthode messagebox de la classe UI, de type MB_YESNO

UI.beep, Méthode beep de la classe UI

Structures de contrôle:

IF ELSE, embranchement conditionnel

Prochain Tuto => Menu contextuel

Christophe

Création d'un menu contextuel

Nous allons voir comment exécuter le plugin vu précedemment par un clic droit sur un élément du modèle

Cette première ligne permet de contrôler si le menu de "TutoApi104.rb" n'a pas été déjà chargé, sinon vous allez avoir une répétition du même menu :

Code:

if( not file_loaded?("TutoApi104.rb") )

Ligne de commande add_context_menu_handler de la classe UI = "ajouter un menu contextuel",
Le do associé a end, signifie que la commande va s'appliquer pour toutes les valeurs que va prendre context_menu
C'est une boucle :

Code:

 UI.add_context_menu_handler do |context_menu|

Ajoute un ligne de séparation :

Code:

context_menu.add_separator

Ajoute un élément "Mon premier menu contextuel" au menu contextuel, en cas d'activation il lance la méthode mon_inputbox:

Code:

context_menu.add_item("Mon premier menu contextuel") { mon_inputbox }


Fin de la boucle do

Code:

end

Indique que le menu a été va de paire avec la ligne 1

Code:

file_loaded("TutoApi104.rb")

Code complet :

Code:

if( not file_loaded?("TutoApi104.rb") )
   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Mon premier menu contextuel") { mon_inputbox }
   end
   file_loaded("TutoApi104.rb")
   end

Code associé au plugin du tuto précédent :

Code:

# Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Point 1 axe x", "Point 1 Axe y", "Point 1 z", "Point 2 Axe x", "Point 2 Axe y", "Point 2 Axe z"]
      values = [0, 0, 0, 50, 50, 50]
      results = UI.inputbox prompts, values, "Ma premiere InputBox"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      # Costruction de la ligne
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)
   end

   if( not file_loaded?("TutoApi104.rb") )
   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Mon premier menu contextuel") { mon_inputbox }
   end
   file_loaded("TutoApi104.rb")
   end

Commande utilisée:

Commande add_context_menu_handler de la classe UI

Le plugin de test TutoApi103.rb


Prochain Tuto nous verrons comment ajouter un sous-menu aux menus de Sketchup

Christophe

Toujours sur la base de reprise du tuto précédent :

Ligne de commande pour ajouter un élément "Dessiner une ligne" au menu "Draw" de Sketchup, que votre version soit anglaise ou française
il faut indiquer le nom du menu en Anglais : Draw, Tools, Plugins , Help

Code:


UI.menu("Draw").add_item("Dessiner une ligne"){ mon_inputbox }

Ajouter un élément au menu "Tools"

Code:


UI.menu("Tools").add_item("Dessiner une ligne"){ mon_inputbox }

Ajouter un élément au menu "Plugins" :

Code:


UI.menu("Plugins").add_item("Dessiner une ligne"){ mon_inputbox }

Code complet :

Code:


   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Axe x2", "Axe y2", "Axe z2"]
      values = [0, 0, 0, 0, 50, 0]
      results = UI.inputbox prompts, values, "Ma premiere InputBox"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      # Construction de la ligne
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)
   end
   
   if( not file_loaded?("TutoApi104.rb") )
   UI.menu("Draw").add_item("Dessiner une ligne"){ mon_inputbox }
   UI.menu("Tools").add_item("Dessiner une ligne"){ mon_inputbox }
   UI.menu("Plugins").add_item("Dessiner une ligne"){ mon_inputbox }
      UI.add_context_menu_handler do |context_menu|
      context_menu.add_separator
      context_menu.add_item("Mon premier menu contextuel") { mon_inputbox }
      end
   file_loaded("TutoApi104.rb")
   end

Commande utilisée : UI.menu....add_item



Comme ce tuto est un peu court, on peut faire un petit récapitulatif des éléments vu précedemment:

Créer un plugin "dessiner une ligne' avec saisie des paramètres, accessible pour un menu contextuel,
et un des trois menus vu ici, mais dont le choix au départ se fera par une inputbox:

Code:

   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Axe x2", "Axe y2", "Axe z2"]
      values = [0, 0, 0, 0, 50, 0]
      results = UI.inputbox prompts, values, "Ma premiere InputBox"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      # Construction de la ligne
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)
   end
   
   prompts = ["Ou voulez vous inserez votre menu ? "]
   defaults = ["Tools"]
   list = [ "Plugins|Draw|Tools" ]
   results = UI.inputbox prompts, defaults, list, "Choix du Menu"
   results = results.to_s
   UI.menu( results ).add_item("Dessiner une ligne"){ mon_inputbox }
   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Mon premier menu contextuel") { mon_inputbox }
   end

Télécharger le plugin test TutoApi104.rb
Télécharger le plugin test TutoApi105.rb

Nous allons maintenant aborder la notion de boucle

Le plugin exécute une commande tant que la valeur n'est pas atteinte.
Cette valeur évoluant dans cet exemple par incrémentation
Nous allons réutiliser l'exemple de la ligne pour dessiner une série de ligne

Création de la boîte de dialogue avec les paramètres suivant

Définition:

• du point de base de la ligne (axe x1, axe y1 et axe z1) qui sera commun à l'ensemble des lignes
  
• de la longueur (qui n'est en réalité qu'un point)
  
• nombre d'itération va déterminer le nombre de lignes dessinées
  
• valeur d'incrément qui va être l'écartement entre nos lignes
  

Code:


   # Définition d'une méthode
   def mon_inputbox
      model = Sketchup.active_model
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Eventail"
      return if not results   
      axex1, axey1, axez1, longz, nbiter, incre = results

Construction de la boucle :

Definition de la variable boucle
Definition des variables de second point de la ligne axex2, axey2 et axez2

While début de la boucle et va s'effectuer tant que la variable boucle n'as pas atteint la variable nbiter
pt1 = point n°1 de la ligne défini par les variables de la boîte de dialogue
pt2 point n° 2, on voit dans le code que la variation de ce point 2 va se faire sur l'axe x
Commande pour dessiner la ligne model.entities.add_line(pt1, pt2)
On incrémente la valeur x du point n°2 de la valeur de l'incrément pour la prochaîne ligne
On incremente la variable boucle de 1
End fin de la première itération et on remonte a while tester si le nombre d'itération est atteint

Code:

      # Construction de l'ensemble de lignes
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
            while (boucle < nbiter)
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            model.entities.add_line(pt1, pt2)
            axex2 = axex2 + incre
            boucle = boucle + 1
            end

Code complet avec menu contextuel :

Code:


   # Définition d'une méthode
   def mon_inputbox
      model = Sketchup.active_model
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Eventail"
      return if not results   
      axex1, axey1, axez1, longz, nbiter, incre = results
      # Construction de l'ensemble de lignes
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
            while (boucle < nbiter)
            pt1 = [axex1,axey1,axez1]
                        pt2 = [axex2,axey2,axez2]
            model.entities.add_line(pt1, pt2)
            axex2 = axex2 + incre
            boucle = boucle + 1
            end
   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Eventail") { mon_inputbox }
   end

Téléchargement du plugin test TutoApi1060.rb

Exemple avec une deuxième boucle:

Code:

   # Définition d'une méthode
   def mon_inputbox
      model = Sketchup.active_model
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Eventail"
      return if not results   
      axex1, axey1, axez1, longz, nbiter, incre = results
      # Construction de l'ensemble de lignes
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
         model = Sketchup.active_model                   
            while (boucle < nbiter)                     # Boucle 1
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            model.entities.add_line(pt1, pt2)
            axex2 = axex2 + incre
            boucle = boucle + 1
            end
               axez2 = axez2 + incre                  #  Boucle 2 elle est séquentielle à la premiere (elle s'exécute après la premiere)
               while ( not longz < axez1)
               pt1 = [axex1,axey1,axez1]
               axez2 = axez2 - incre
               pt2 = [axex2,axey2,axez2]
               model.entities.add_line(pt1, pt2)
               longz = longz - incre
               end         
            
   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Eventail") { mon_inputbox }
   end

Téléchargement du plugin test TutoApi1061.rb


Avec un peu d'imagination, vous pouvez déjà faire un certain nombre d'essais démonstratifs

Comme vous l'avez surement constaté, lors de nos tests précedents, il est un peu pénible du supprimer nos lignes, ligne par ligne
nous allons donc voir dans ce tuto comment créer simplement une fonction Undo - Redo

Méthodes à utiliser start_operation commit_operation

Il suffit au début de votre code d'inserer la fonction start_operation en lui donnant un nom et Sketchup débutera l'enregistrement de l'opération

Code:

model.start_operation "Créer des parallèles"

et la fin de votre code ajouter la fonction commit_operation, qui signifiera la fin de l'enregistrement de l'opération

Code:

model.commit_operation

Il suffit ensuite pour annuler l'opération de faire "Ctrl+Z" ou menu "Edition" => annuler "le_nom _de_votre_opération"
Vous pouvez également rétablir l'opération annulée (fonction Redo) par "Ctrl+Y" ou menu "Edition" => rétablir "le_nom _de_votre_opération"

Code complet :

Code:


# cp
   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Parallèles"
      return if not results   
      axex1, axey1, axez1, longz, nbiter, incre = results
      # Construction de l'ensemble de lignes parallèles
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
         model = Sketchup.active_model
         model.start_operation "Créer des parallèles"
            while (boucle < nbiter)
            axex1 = axex2
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            model.entities.add_line(pt1, pt2)
            axex2 = axex2 + incre
            boucle = boucle + 1
            end
      model.commit_operation
                     
   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Parallèles") { mon_inputbox }
   end


Vous noterez aussi que j'ai légèrement changer le script pour créer des parallèles, uniquement en jouant avec les boucles et les incréments





Si vous voulez télécharger le plugin de test TutoApi1064.rb

Prochain tuto "Comment ajouter les objets créés à la selection courante"

Christophe

Nous allons voir dans ce tuto comment ajouter les lignes crées à la sélection, pour pouvoir travailler dessus directement après l'exécution
du script

1. Ajouter à la selection
   
   Nous allons utiliser pour cela la méthode selection.add
   
   Nous allons ajouter cette ligne de code :
   
   

   Code:

   
model.selection.add ma_Ligne


   
   Il faut placer cette ligne dans la boucle après la création de la ligne , en effet il faut ajouter à la selection la nouvelle ligne à chaque fois
   Etant stocké dans la variable ma_Ligne chaque nouvelle création de ligne écrase l'ancienne!!
   Si vous la placer en dehors de la boucle après le end, seule la dernière ligne sera mémorisée
   
   Code complet :
   
   

   Code:

   
# cp
   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Parallèles"
      return if not results   
      axex1, axey1, axez1, longz, nbiter, incre = results

      # Construction de l'ensemble de lignes parallèles
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
         model = Sketchup.active_model
         model.start_operation "Créer des parallèles"
            while (boucle < nbiter)
            axex1 = axex2
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            ma_Ligne = model.entities.add_line(pt1, pt2)
                       model.selection.add ma_Ligne
            axex2 = axex2 + incre
            boucle = boucle + 1
            end

         model.commit_operation               
   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Parallèles") { mon_inputbox }
   end


   
   Si vous voulez telecharger le modele du script TutoApi1065.rb
   
   
2. Ajouter à un groupe
   
   
   Méthode à utiliser group.entities
   

   Code:

   
ma_Selection = model.selection
mon_Groupe = model.active_entities.add_group ma_Selection


   
   Dans la première ligne on affecte la sélection à la variable ma_Selection et dans la deuxième on ajoute la variable ma_Selection (entités selectionnées) à la variable mon_Groupe
   
   Le code complet :
   
   

   Code:

   
# cp
   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Parallèles"
      return if not results
      axex1, axey1, axez1, longz, nbiter, incre = results

      # Construction de l'ensemble de lignes parallèles
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
         model = Sketchup.active_model
         model.start_operation "Créer des parallèles"
            while (boucle < nbiter)
            axex1 = axex2
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            ma_Ligne = model.entities.add_line(pt1, pt2)
                       model.selection.add ma_Ligne
            axex2 = axex2 + incre
            boucle = boucle + 1
            end
            
            ma_Selection = model.selection
            mon_Groupe = model.active_entities.add_group ma_Selection
         model.commit_operation
   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Parallèles") { mon_inputbox }
   end


   
   Si vous voulez telecharger le modele du script TutoApi1066.rb
   
   
3. Sélectionner le groupe
   

On reprend les méthodes du 1 et 2, il suffit de rajouter cette ligne de code

Code:


model.selection.add mon_Groupe


et de l'inserer après la création du groupe

Code complet :

Code:


# cp
   # Définition d'une méthode
   def mon_inputbox
      # Création de la boite de dialogue
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
      values = [0, 0, 0, 50, 20, 5]
      results = UI.inputbox prompts, values, "Parallèles"
      return if not results
      axex1, axey1, axez1, longz, nbiter, incre = results

      # Construction de l'ensemble de lignes parallèles
         boucle=0
         axex2 = axex1
         axey2 = axey1
         axez2 = longz
         model = Sketchup.active_model
         model.start_operation "Créer des parallèles"
            while (boucle < nbiter)
            axex1 = axex2
            pt1 = [axex1,axey1,axez1]
            pt2 = [axex2,axey2,axez2]
            ma_Ligne = model.entities.add_line(pt1, pt2)
                model.selection.add ma_Ligne
            axex2 = axex2 + incre
            boucle = boucle + 1
            end
            
            ma_Selection = model.selection
            mon_Groupe = model.active_entities.add_group ma_Selection
            model.selection.add mon_Groupe
         model.commit_operation

   end

   UI.add_context_menu_handler do |context_menu|
   context_menu.add_separator
   context_menu.add_item("Parallèles") { mon_inputbox }
   end


Si vous voulez telecharger le modele du script TutoApi1067.rb

Vous pouvez faire un petit test, en essayant de créer autant de groupe que de lignes crées et de les regrouper dans un seul groupe

Prochain tuto : Amelioration de nos menus

Christophe

Amelioration de la gestion des menus

Comme vous l'avez constaté, lorsque pour des tests vous avez relancé plusieurs fois nos scripts, les menus s'empilent les uns derrieres les autres en surchargant la mémoire et diminuant la lisibilité de vos menus ou sous menus
Nous allons donc faire une petite compilation pas au sens (informatique du terme) de l'ensemble des scripts vus et pour cela juste un petit rappel
Nous avons abordé la notion de méthode ou routine "def.....end", sketchup au démarrrage lit l'ensemble des scripts, mais n'execute pas les "def.....end", mais par contre charge les menus puisque en dehors de la définition
Dans le même script, on peut donc empiler des méthodes qui seront appelées par leurs noms soit par un menu soit par une autre méthode, voir un autre plugin.

Scématiquement

Code:


def premiere_routine
........
end

def deuxieme_routine
appel de le troisieme_routine
......
end

def troisieme_routine
.........
end

menu
appel de la premiere_routine sur intervention de l'utilisateur
appel de la deuxieme_routine sur intervention de l'utilisateur
end


Fonction de contrôle de chargement de menu

Voilà ce qui à été écrit par Jojo2 (merci à toi)

Fonction de validation de chargement:
Non, c'est une notation arbitraire dans une variable globale (valable pour toute la session) que l'on mémorise et que l'on vérifie en cas de rechargement.
Le nom du script n'a pas plus de signification que cette notation du moment qu'elle est unique.

Par contre, Ruby gère les plugins intégrés par la commande "require".
Sketchup utilise aussi la commande require mais n'est pas totalement compatible avec Ruby (caractères nationaux entre autres).
Donc depuis la version 6, Sketchup a normalisé (fichier Sketchup.rb) la notion de "loaded_files" que l'on retrouve dans beaucoup de scripts.
Il s'avère que la meilleure présentation de cette fonction est:

Code:


# Gestion des Plugins deja charges
if not file_loaded?("NomUniquePLUGIN")
UI.menu("Plugins").add_separator
UI.menu("Plugins").add_item("Denomination du Plugin") { maFONCTION }
file_loaded("NomUniquePLUGIN")
end

Liste de tous les éléments chargés de cette manière dans le tableau: $loaded_files

En résumé, pour utiliser cette fonction il faut préalablement faire appel à "sketchup.rb"
par la ligne de code suivante en début de plugin

Code:


require 'sketchup.rb'


et enfin terminer le script par les lignes données par Jojo2.
le principe c'est de donner un nom à votre menu (ici NomUniquePlugin, qui n'est pas nécessairement le même que le plugin), lorsque sketchup le charge, il va le "noter" dans le tableau "file_loaded"
A chaque chargement du plugin, sketchup scrute le tableau et contrôle si le menu a été chargé, si cela n'est pas le cas il le charge.

Code complet en utilisant les sripts précédents

Code:



=begin
   cp
      
=end

   #  Définir une Boite de dialogue pour saisir des variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------
      def ma_boite_de_saisie                               #début de la méthode et attribution d'un nom qui sera utilisé pour l'appeler)
      prompts = ["Point X", "Point Y", "Point Z", "Hauteur" ]      #Détermine d'invite et le nombre de lignes de l'inputbox
      values = [0, 0, 0, 100]                              #Valeur par défaut proposées
      results = inputbox prompts, values, "Nom de ma Boite"      #Genere l'inputbox et l'affecte à la variable resuts
      return if not results                               #controle si il y a bien saisie sinon retour
      x, y, z, h = results                               # les variables au contenu de l'inputbox
      UI.messagebox results                               # juste ici pour controler si results a bien pris les valeurs de l'inputbox, dans ce cas obligatoirement puisque déja controlé par "return if not results"
      x= "valeur de x est " + x.to_s                         # Pour démonstration modification de la variable x en texte (string) et ajout de texte
      UI.messagebox x                                    # controle du résultat de la ligne précédente x est modifié
      z= "z prend la valeur de " + y.to_s                     # création d'une variable string z qui prend la valeur de y sans le modifier et ajoute du texte
      UI.messagebox z                                    # controle du résultat de la ligne précédente z est crée en reprenant la valeur de y
      UI.messagebox y                                    # controle du résultat y n'a pas été modifié
      end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Dessiner une ligne sans variable ------------------------------------------------------------------------------------------------------------------------------------------------------------------
      def ma_premiere_ligne
      pt1 = [0,0,0]                      # coordonnées de point 1
      pt2 = [50,50,50]                  # coordonnées de point 2
      model = Sketchup.active_model         # Pour reduire la saisie et par convention on determine une variable mode = a la Classe ou Module Sketchup avec la méthode active_model (c'est surtout pour assurer la compatibilté avec Mac
      model.entities.add_line(pt1, pt2)      # qui avoir plusieurs modeles d'ouverts.
      end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Dessiner une ligne paramétrable ------------------------------------------------------------------------------------------------------------------------------------------------------------------
      def ma_ligne_paramétrable
      prompts = ["Axe x1", "Axe y1", "Axe z1", "Axe x2", "Axe y2", "Axe z2"]
      values = [0, 0, 0, 0, 50, 0]
      results = UI.inputbox prompts, values, "Saisie des parametres"
      return if not results   
      x1, y1, z1, x2, y2, z2 = results
      pt1 = [x1,y1,z1]
      pt2 = [x2,y2,z2]
      model = Sketchup.active_model
      model.entities.add_line(pt1, pt2)            # Dessine une ligne en reprenat les varaibles pt1 et pt2 issus de l'Inputbox
      end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Dessiner une ligne paramétrable ------------------------------------------------------------------------------------------------------------------------------------------------------------------
      def mon_feu_artifice
                                                               # Création de la boite de dialogue
         prompts = ["Axe x1", "Axe y1", "Axe z1", "Nb Lignes", "Long Maxi"]
         values = [0, 0, 0, 50, 50]
         results = UI.inputbox prompts, values, "Feu d'artifice"
         return if not results   
         x1, y1, z1, x2, y2 = results
                                                               # Construction de l'ensemble de lignes
            x=1                                                   # Initialisation de la variable x
            while (x != x2)                                        # contruire une bouble conditionnelle
               pt1 = [x1,y1,z1]
               g2= rand(y2)                                       # creation variable aléatoire
               d2= rand(y2)                                       # creation variable aléatoire
               f2= rand(y2)                                       # creation variable aléatoire
               pt2 = [g2,d2,f2]
               model = Sketchup.active_model
               model.entities.add_line(pt1, pt2)
            x = x+1
            end
      end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Dessiner un éventail ------------------------------------------------------------------------------------------------------------------------------------------------------------------
   
      def mon_eventail
         # Création de la boite de dialogue
         prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
         values = [0, 0, 0, 50, 20, 5]
         results = UI.inputbox prompts, values, "Eventail"
         return if not results   
         axex1, axey1, axez1, longz, nbiter, incre = results
         # Construction de l'ensemble de lignes
            boucle=0
            axex2 = axex1
            axey2 = axey1
            axez2 = longz
               while (boucle < nbiter)
               pt1 = [axex1,axey1,axez1]
                           pt2 = [axex2,axey2,axez2]
               model = Sketchup.active_model
               model.entities.add_line(pt1, pt2)
               axex2 = axex2 + incre
               boucle = boucle + 1
               end
      end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Dessiner un éventail rectangle ------------------------------------------------------------------------------------------------------------------------------------------------------------------
      def eventail_rectangle
            # Création de la boite de dialogue
            prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
            values = [0, 0, 0, 50, 20, 5]
            results = UI.inputbox prompts, values, "Eventail"
            return if not results   
            axex1, axey1, axez1, longz, nbiter, incre = results
            # Construction de l'ensemble de lignes
               boucle=0
               axex2 = axex1
               axey2 = axey1
               axez2 = longz
               model = Sketchup.active_model                   
                  while (boucle < nbiter)                     # Boucle 1
                  pt1 = [axex1,axey1,axez1]
                  pt2 = [axex2,axey2,axez2]
                  model.entities.add_line(pt1, pt2)
                  axex2 = axex2 + incre
                  boucle = boucle + 1
                  end
                     axez2 = axez2 + incre                  #  Boucle 2 elle est séquentielle à la premiere (elle s'exécute après la premiere)
                     while ( not longz < axez1)
                     pt1 = [axex1,axey1,axez1]
                     axez2 = axez2 - incre
                     pt2 = [axex2,axey2,axez2]
                     model.entities.add_line(pt1, pt2)
                     # axez2 = axez2 - incre
                     longz = longz - incre
                     end         
         end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Tracer des parallèles avec la possibilité d'annuler toute l'opération (undo)------------------------------------------------------------------------------------------------------------------------------------------------------------------
         def paralleles
         # Création de la boite de dialogue
         prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
         values = [0, 0, 0, 50, 20, 5]
         results = UI.inputbox prompts, values, "Parallèles"
         return if not results   
         axex1, axey1, axez1, longz, nbiter, incre = results
            # Construction de l'ensemble de lignes parallèles
               boucle=0
               axex2 = axex1
               axey2 = axey1
               axez2 = longz
               model = Sketchup.active_model
               model.start_operation "Créer des parallèles"      # donne un nom à l'opération et commence sa mémorisation
                  while (boucle < nbiter)
                  axex1 = axex2
                  pt1 = [axex1,axey1,axez1]
                  pt2 = [axex2,axey2,axez2]
                  model.entities.add_line(pt1, pt2)
                  axex2 = axex2 + incre
                  boucle = boucle + 1
                  end
               model.commit_operation                        # fin de mémorisation de l'opération                  
         end         
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
   #  Groupe les parralèles crées ------------------------------------------------------------------------------------------------------------------------------------------------------------------
         def select_group
               # Création de la boite de dialogue
               prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
               values = [0, 0, 0, 50, 20, 5]
               results = UI.inputbox prompts, values, "Parallèles"
               return if not results   
               axex1, axey1, axez1, longz, nbiter, incre = results
               # Construction de l'ensemble de lignes parallèles
                  boucle=0
                  axex2 = axex1
                  axey2 = axey1
                  axez2 = longz
                  model = Sketchup.active_model
                  model.start_operation "Créer des parallèles"
                     while (boucle < nbiter)
                     axex1 = axex2
                     pt1 = [axex1,axey1,axez1]
                     pt2 = [axex2,axey2,axez2]
                     ligne = model.entities.add_line(pt1, pt2)
                     model.selection.add ligne
                     axex2 = axex2 + incre
                     boucle = boucle + 1
                     end
                  ss=model.selection
                  model.active_entities.add_group ss
                  model.commit_operation               
            end
   #-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------   
      #  Sélectionne les parralèles crées ------------------------------------------------------------------------------------------------------------------------------------------------------------------
         def select
            # Création de la boite de dialogue
            prompts = ["Axe x1", "Axe y1", "Axe z1", "Longueur",  "Nb Itération", "Valeur incrément"]
            values = [0, 0, 0, 50, 20, 5]
            results = UI.inputbox prompts, values, "Parallèles"
            return if not results   
            axex1, axey1, axez1, longz, nbiter, incre = results
            # Construction de l'ensemble de lignes parallèles
               boucle=0
               axex2 = axex1
               axey2 = axey1
               axez2 = longz
               model = Sketchup.active_model
               model.start_operation "Créer des parallèles"
                  while (boucle < nbiter)
                  axex1 = axex2
                  pt1 = [axex1,axey1,axez1]
                  pt2 = [axex2,axey2,axez2]
                  ligne = model.entities.add_line(pt1, pt2)
                  model.selection.add ligne
                  axex2 = axex2 + incre
                  boucle = boucle + 1
                  end         
         end
   #    Menus-----------------------------------------------------------------------------------------------------------------------------------------------------
    if not file_loaded?("Mes_Plugins")
        menu =UI.menu("Plugins").add_submenu("Mes Plugins")
          menu.add_item("Mon Input Box"){ ma_boite_de_saisie }    # Ajoute un menu et un sous-menu au menu Plugins de GSU
          menu.add_item("Ma Premiere Ligne"){ ma_premiere_ligne }
          menu.add_item("Ma Ligne paramétrable"){ ma_ligne_paramétrable }
          menu.add_item("Feu d'artifice"){ mon_feu_artifice }
          menu.add_item("Eventail"){ mon_eventail }
          menu.add_item("Eventail rectangle"){ eventail_rectangle }
          menu.add_item("Tracer des parallèles & Undo"){ paralleles }
          menu.add_item("Parrellèles Groupées"){ select_group }
          menu.add_item("Parrellèles Sélectionnées"){ select }
       #------------------------------------------------------------------------------------------------------------------------------------------------------------
       UI.add_context_menu_handler do |context_menu|                                       # Ajout d'un menu contextuel
       context_menu.add_separator
       context_menu.add_item("Mon premier menu contextuel") { ma_boite_de_saisie }
       #---------------------------------------------------------------------------------------------------------------------------------------------------------------
    file_loaded("Mes_Plugins")
    end
end
   


Note :

1. De la ligne 43 à 63, j'avais prévu un petit tuto sur ".rand" (mais j'ai oublié), qui permet de générer des nombres aléatoires, en fixant éventuellement des limites.
   
2. Je corrige des erreurs de rédaction avant que Jojo2 ne le fasse, il est notamment très peu judicieux de donner (lignes 211 & 212) des noms qui sont des mots cléfs de sketchup select_group & select, il aurait été plus juste de prendre par ex. mon_groupe & ma_selection. A ce sujet, Jojo2 a réalisé un petit tuto "Conventions de rédaction d'un script" (un maître en la matière) qui fera l'objet d'un autre sujet

Pour ceux qui veulent télécharger le script Recap01.rb



Suite à une intervention de Fabien, le prochain tuto abordera la gestion des unités

Christophe