Forum Sketchup Artlantis Archicad
Vous souhaitez réagir à ce message ? Créez un compte en quelques clics ou connectez-vous pour continuer.
Galerie


[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 Empty
Ton bloc notes
Derniers sujets
» [ BLENDER ] Modificateur sur plusieurs maillages
par JDD Aujourd'hui à 17:18

» [ WIP ]Mon petit labo...by ogi
par ogi Aujourd'hui à 16:42

» [ MATOS INFORM. ] bonnes nouvelles pour les aficionados de Mac
par ogi Aujourd'hui à 16:20

» [ PRESENTATION ]
par freroil Aujourd'hui à 16:14

» [ TWINMOTION ] Plantage à la synchronisation direct link ARCHICAD/TWINMOTION
par tenrev Aujourd'hui à 14:55

» [AUTRES LOGICIELS] Vectary
par Pilou Aujourd'hui à 0:07

» [ ARCHICAD ] Configurer la projection des surfaces sur un maillage ?
par Farkas Hier à 20:31

» [ ENSCAPE ] Manette XBox
par simjoubert Hier à 14:26

» [ ARCHICAD ] Cotation ouvertures dans mur courbe!?
par Coulou Hier à 13:53

» [ PRESENTATION ] Fanou Peb
par FanouPeb Ven 22 Oct 2021 - 18:19

» [ ENSCAPE ] Accès calques BIM dans le fichier exécutable ou cloud ?
par tenrev Ven 22 Oct 2021 - 16:51

» [ TECHNOLOGIE DU BATIMENT ] Passion architecture
par VertiKal Ven 22 Oct 2021 - 14:59

» [ SKETCHUP plugins ] sj_AddDCFunctions
par tenrev Ven 22 Oct 2021 - 13:20

» [ ARCHICAD-OBJETS GDL ] Bibliothèque de migration archicad 9
par freroil Ven 22 Oct 2021 - 9:11

» [ SKETCHUP composants dynamiques ] OnClick Copie composant
par simjoubert Jeu 21 Oct 2021 - 21:00

» [ SKETCHUP plugins ] Skatter 2 - un exemple d'utilisation
par tenrev Mer 20 Oct 2021 - 11:05

» [ AUTRES LOGICIELS ] Aperçu de Houdini version 19 - sortie prochaine
par Yanosh HRDY Mer 20 Oct 2021 - 9:25

» [ AUTRES LOGICIELS ] davinci resolve
par tenrev Mar 19 Oct 2021 - 12:01

» [ ARCHICAD ] TUTO - Créer un fichier modèle ArchiCad
par Coulou Mar 19 Oct 2021 - 9:25

» [ AUTRES LOGICIELS ] SOUNDLY Une Mine d'Or d'Effets Sonores pour vos animations
par tenrev Lun 18 Oct 2021 - 14:18

» [ BLENDER ] Animation d'une boule de feu
par tenrev Sam 16 Oct 2021 - 15:43

» [ SKETCHUP généralité ] Profils et Contre-Profil Menuiserie
par Pilou Sam 16 Oct 2021 - 11:09

» [ TWINMOTION ] Les 5 jours d'inspiration 2021!
par Pilou Ven 15 Oct 2021 - 19:50

» [ UNREAL ENGINE ] de twinmotion vers unreal engine - vidéo webinar en anglais
par tenrev Ven 15 Oct 2021 - 17:14

» [ SKETCHUP généralité ] SketchUp pour iPad
par REGIS Jeu 14 Oct 2021 - 22:21

» [ AUTRES LOGICIELS ] Nomad Sculpt
par Pilou Mer 13 Oct 2021 - 23:51

» [ SKETCHUP composants dynamiques ] composant dynamique avec proxy 2d pour choix des coloris
par Rascal Mer 13 Oct 2021 - 21:47

» [ AUTRES LOGICIELS ] Verve sous le sapin de Noël!
par Pilou Mer 13 Oct 2021 - 17:04

» [ SKETCHUP généralité ] 3D WAREHOUSE Importer, Télécharger, Exporter avec 2017
par tenrev Mer 13 Oct 2021 - 15:23

» [ SKETCHUP ruby ] Peux-ton réaliser des enregistrement de macro dans SketchUp ?
par JDD Mer 13 Oct 2021 - 14:25

» [ SKETCHUP plugins ] Skatter 2 disponible
par Rascal Mar 12 Oct 2021 - 18:44

» [ OBJETS ET BILLBOARDS ] Création de personnage
par tenrev Mar 12 Oct 2021 - 16:41

» [ SKETCHUP généralité ] Profil Builder
par Rascal Lun 11 Oct 2021 - 19:16

» [ TWINMOTION ] Retour d'expérience sur le challenge n°7
par AK40Cess Lun 11 Oct 2021 - 9:38

» [ ARCHICAD ] Réalisation de chevronnière
par lena29 Ven 8 Oct 2021 - 23:51

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

Voir le sujet précédent Voir le sujet suivant Aller en bas

c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Ven 20 Nov 2009 - 22:55

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

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

  2. Panneau de la console Ruby

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

  3. Saisie de la première variable

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

  4. Résultat de la saisie

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

  5. Saisie de la deuxième variable

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

  6. Résultat de la saisie

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

  7. Définition de la variable model

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

  8. Ajout de la commande

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

    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

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

  10. Modification de la variable pt1
    [Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 Tuto1020

  11. Envoie de la commande


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

  12. Resultat

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

    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
    [Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 Tuto1023



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 Arrow TutoApi100.rb

Gif animé Téléchargeable :

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

Lien des Api utilisées :

Arrow 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
Arrow Entities.add_line méthode qui permet d'ajouter des lignes. c'est la méthode add_line de la Classe Entities


Dernière édition par c.plassais le Ven 29 Jan 2010 - 11:16, édité 11 fois
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Lun 23 Nov 2009 - 20:35

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

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

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)

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

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

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

Christophe

-------------------------------------------------------------------------------------------------------------------------
Mon Blog : Plugins Sketchup ChrisP
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Mer 25 Nov 2009 - 10:53

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

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

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

Arrow TutoApi102.rb

Méthodes utilisées:

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

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

Structures de contrôle:

Arrow IF ELSE, embranchement conditionnel

Prochain Tuto => Menu contextuel

Christophe

-------------------------------------------------------------------------------------------------------------------------
Mon Blog : Plugins Sketchup ChrisP
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Dim 29 Nov 2009 - 19:38

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

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

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

Commande utilisée:

Commande Arrow add_context_menu_handler de la classe UI

Le plugin de test Arrow TutoApi103.rb


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

Christophe

-------------------------------------------------------------------------------------------------------------------------
Mon Blog : Plugins Sketchup ChrisP
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Mar 1 Déc 2009 - 21:43

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

[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 2009-114
[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 2009-115
[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 2009-116
[Tutos] RUBY Initiation les n° 1-2-3-4-5-6-7-8-9 2009-117


Commande utilisée : Arrow 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

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



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

-------------------------------------------------------------------------------------------------------------------------
Mon Blog : Plugins Sketchup ChrisP
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Mar 8 Déc 2009 - 22:18

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

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

Téléchargement du plugin test Arrow 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

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

Téléchargement du plugin test Arrow TutoApi1061.rb


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


Dernière édition par c.plassais le Mar 8 Déc 2009 - 22:29, édité 5 fois (Raison : Modification)
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Lun 4 Jan 2010 - 11:10

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 Arrow start_operation Arrow 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

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

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

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

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

Christophe
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Mar 12 Jan 2010 - 15:42

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 Arrow 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 Arrow TutoApi1065.rb

  2. Ajouter à un groupe


    Méthode à utiliser Arrow 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 Arrow 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 Arrow 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
c.plassais
c.plassais
modérateur
modérateur
Masculin Date d'inscription : 19/07/2009
Nombre de messages : 2058
Points : 2479
Age : 59
Localisation : Chambéry
Emploi : Responsable Gestion Atelier
http://bande.village.free.fr/

Messagec.plassais Ven 29 Jan 2010 - 11:18

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 Arrow
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 Arrow

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) Arrow


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 Arrow

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 Arrow Recap01.rb

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

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

Christophe

Voir le sujet précédent Voir le sujet suivant Revenir en haut

Créer un compte ou se connecter pour répondre

Vous devez être membre pour répondre.

S'enregistrer

Rejoignez notre communauté ! C'est facile !


S'enregistrer

Connexion

Vous êtes déjà membre ? Aucun soucis, cliquez ici pour vous connecter.


Connexion

 
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum