======Les interfaces 2 : les contrôleurs======

A ce stade nous savons [[instructions_composees#les_fonctions|créer une fonction]] et [[tutos:python:interface_utilisateur:start|afficher une fenêtre]] fournie de contrôleurs d'attributs, pouvant manipuler les attributs d'un objet :

<code python>
# crée un slider automatiquement lié à l'attribut donné
cmds.attrFieldSliderGrp(attribute = 'monObjet.scaleX')
# crée un slider et une color box automatiquement liés à l'attribut donné
cmds.attrColorSliderGrp(attribute = 'maLumiere.color')
# crée le meilleur controleur pour l'attribut donné et le lie automatiquement
cmds.attrControlGrp(attribute = 'monObjet.translateY')
# ...
</code>

Nous allons voir maintenant comment contrôler nos propres fonctions.

Reprenons notre fonction [[instructions_composees#exemple_concret_dans_maya|ligneColonnes()]] :
<code python>
def ligneColonnes(nombre, hauteur, espacement) :
    '''Cree x colonnes cotes à cotes, de hauteur et espacement donnes'''
    for i in(nombre) : # fais ceci "nombre" fois
        cmds.polyCube(h = hauteur) # cree un cube de hauteur donnee
        cmds.move(i*espacement,0,0) # le deplace selon l'espacement donne
</code>
Il serait utile d'avoir un slider gérant le nombre de colonnes, un autre leur hauteur et un dernier leur espacement. Vous comprenez qu'on ne peut le faire au moyen de contrôleurs d'attributs : le nombre de colonnes est variable, leur position dépend de plusieurs paramètres, etc...

=====Contrôle statique=====
Abandonnons donc ces contrôleurs d'attributs et penchons-nous sur les contrôleurs standard.

Ils contiennent tous un argument "**command**" (ou "**changeCommand**" et "**dragCommand**" pour les sliders), à l'image de ce que nous avons déjà utilisé pour faire des boutons créant des objets :
<code python>
# ce bouton lance la ligne de commande "cmds.polySphere()" quand on appuie dessus
cmds.button(label = 'Créer une sphère', command = 'cmds.polySphere()') 
</code>

Hors la commande que nous lui demandons, "**polysphere()**", est... une fonction. Et nous savons faire des fonctions. Plus besoin de se cantonner à ce qui existe déjà, nous pouvons ordonner à notre contrôle de faire ce que nous voulons. Remplaçons la fonction **polySphere** par notre fonction **ligneColonnes** :
<code python>
# ce bouton lance la fonction "ligneColonnes()" quand on appuie dessus
cmds.button(
     label = 'Créer une ligne de colonnes',
     command = 'cmds.ligneColonnes(nombre = 5, hauteur = 10, espacement = 2)')
# on a indiqué en plus les arguments que demande la fonction
</code>
Ainsi quand on appuie sur ce bouton nous appelons notre fonction, et il se crée une ligne de 5 colonnes de hauteur 10 et espacées de 2.

<note importante>Une action qui ne varie pas, qui fait une chose bien précise, par exemple "toutSupprimer", "creer10Lumieres", "polyCube", etc... peut être contrôlée simplement de cette manière, en mettant la fonction dans l'argument "**command**" d'un contrôleur.</note>

Cela fonctionne très bien, mais dans notre cas nous voulons un slider. Essayons :
<code python>
cmds.intSliderGrp(
     label = 'nombre',
     changeCommand = 'cmds.ligneColonnes(nombre = 5, hauteur = 10, espacement = 2)')
</code>
Le slider appelle bien notre fonction quand on change sa valeur, mais fait toujours la même chose : en effet les arguments sont fixes (5, 10 et 2), c'est un contrôle statique.

Dans notre cas il faudrait que lorsqu'on modifie la valeur du slider on fasse varier un des paramètres. Devenons dynamiques.

=====Contrôle dynamique=====

Une fonction **lambda** est une micro-fonction tenant en une ligne, sans nom, qui sert a faire une petite action ponctuelle. Dans notre cas cette petite merveille peut récupérer en direct la valeur du contrôleur et modifier ainsi dynamiquement une valeur que l'on veut envoyer à **ligneColonnes()**.

On utilise cette fonction de cette manière :
<code python>lambda variable : retour</code>
La fonction renvoie ce que l'on demande dans "retour".

Dans notre cas, on aimerait qu'elle renvoie notre commande...
<code python>'cmds.ligneColonnes(nombre = 5, hauteur = 10, espacement = 2)'</code>
... mais en faisant varier la valeur **5**. Pour que cela varie il faut une variable. Concaténons (lions, mettons bout à bout) notre commande (qui est une chaine de caractères) et une variable :
<code python>'cmds.ligneColonnes(nombre = ' + x + ', hauteur = 10, espacement = 2)'</code>
Nous avons indiqué la fin de la chaine de caractère par un guillemet, avons placé notre variable, puis avons indiqué que la chaine de caractère redémarrait avec un autre guillemet. Ainsi, si "x" vaut 10, la chaine de caractère deviendra :
<code python>'cmds.ligneColonnes(nombre = 10, hauteur = 10, espacement = 2)'</code>
Il reste une dernière étape : la fonction lambda préfère qu'on lui indique  quel est le type de valeur de la variable (entier, nombre à virgule, etc...), pour savoir quoi en faire. pour lui indiquer, on écrit (les plus courants) :
<code python>
int(x) # pour un entier
float(x) # pour un nombre à virgule
str(x) # pour une chaine de caractères (string)
</code>
Ici nous aurons un entier, il ne peut y avoir 2,57 colonnes. On a donc :
<code python>'cmds.ligneColonnes(nombre = ' + int(x) + ', hauteur = 10, espacement = 2)'</code>
La fonction lambda entière est ainsi :
<code python>lambda x : 'cmds.ligneColonnes(nombre = ' + int(x) + ', hauteur = 10, espacement = 2)'</code>
Et maintenant, qu'en fait-on? Et bien on la place simplement dans "**changeCommand**" de notre contrôleur :
<code python>
cmds.intSliderGrp(
     label = 'nombre',
     changeCommand = lambda x : 'cmds.ligneColonnes(nombre = ' + int(x) + ', hauteur = 10, espacement = 2)')
</code>

Et voila, notre slider contrôle dynamiquement le nombre de colonnes !

Et là on se dit: cool, c'est réglé, on n'a plus qu'à faire les autres ! Oui mais... non. Essayons :
<code python>
cmds.intSliderGrp(
     label = 'nombre',
     changeCommand = lambda x : 'cmds.ligneColonnes(nombre = ' + int(x) + ', hauteur = 10, espacement = 2)')
cmds.floatSliderGrp(
     label = 'hauteur',
     changeCommand = lambda x : 'cmds.ligneColonnes(nombre = 5, hauteur = ' + float(x) + ', espacement = 2)')
cmds.floatSliderGrp(
     label = 'espacement',
     changeCommand = lambda x : 'cmds.ligneColonnes(nombre = 5, hauteur = 10, espacement = ' + float(x) + ')')
# des float sont utilisés pour la hauteur et l'espacement
# penser à changer le type de contrôle et le type de la variable de lambda
</code>
Cela contrôle bien chaque paramètre, mais sans "sauvegarder" la modification faite sur les autres. Normal : dans mes lignes de commande les autres paramètres que celui contrôlé sont statiques.

On se retrouve donc bloqué lorsqu'il y a plusieurs arguments à faire varier((c'est en réalité possible au moyen de variables globales, mais tout à fait contre-indiqué )). Il faut alors changer de technique.

<note importante>
Une fonction dont on n'a besoin de faire varier qu'un seul paramètre, par exemple "creerLumieres(nombre)", "supprimerObjet(nom)", etc... peut être contrôlée de cette manière, c'est court et efficace.
</note>

=====Contrôle total=====
Bon, faisons un point : **.**

Voila, continuons.

Nous savons faire une fonction, nous savons l'appeler depuis nos contrôleurs, mais nous avons besoin de récupérer la valeur de nos contrôleurs. Et là, magique, on trouve une utilité au fameux **query=True** que l'on peut mettre un peu partout. Nous avons besoin de leur valeur? Demandons-leur!

Pour leur demander, il faut savoir qui appeler. Donnons donc un nom à nos contrôleurs :

<code python>
cmds.intSliderGrp(  'nombre',     label = 'nombre',     value = 5,  field = True)
cmds.floatSliderGrp('hauteur',    label = 'hauteur',    value = 10, field = True )
cmds.floatSliderGrp('espacement', label = 'espacement', value = 2,  field = True )
# ne pas confondre leur nom et leur label : le label est seulement le texte affiché devant le controleur
# j'ai rajouté la valeur par défaut et le field
</code>

Maintenant demandons-leurs quelle est leur valeur et stockons ça dans des variables :
<code python>
nombre     = cmds.intSliderGrp(  'nombre',     query = True, value = True)
hauteur    = cmds.floatSliderGrp('hauteur',    query = True, value = True)
espacement = cmds.floatSliderGrp('espacement', query = True, value = True)
</code>
Ainsi nous n'avons plus qu'à rapeller notre fonction **ligneColonnes()** avec ces nouveaux paramètres :
<code python>
ligneColonnes(nombre, hauteur, espacement)
# pas la peine de mettre nombre=nombre, etc... si l'on voit bien qui est qui
</code>
Oui, mais attends, comment je fais tout ça quand je bouge mon slider ? Avec une fonction, encore !

On met tout ça dans une fonction...
<code python>
def update() :
     '''lie la fonction ligneColonnes et ses controleurs'''
     # demande la valeur des sliders et les stocke dans des variables
     nombre     = cmds.intSliderGrp(  'nombre',     query = True, value = True)
     hauteur    = cmds.floatSliderGrp('hauteur',    query = True, value = True)
     espacement = cmds.floatSliderGrp('espacement', query = True, value = True)
     # appelle la fonction ligneColonnes avec les valeurs précédentes
     ligneColonnes(nombre, hauteur, espacement)
</code>

...et nous n'avons plus qu'à dire que lorsqu'on modifie un des contrôleurs on appelle notre fonction **update()** :
<code python>
cmds.intSliderGrp(  'nombre',     label = 'nombre',     changeCommand = "update()", value = 5,  field = True)
cmds.floatSliderGrp('hauteur',    label = 'hauteur',    changeCommand = "update()", value = 10, field = True )
cmds.floatSliderGrp('espacement', label = 'espacement', changeCommand = "update()", value = 2,  field = True )
</code>
Ainsi quand on modifie un contrôleur on n'apelle pas directement notre fonction principale mais notre fonction d'update, qui se charge de mettre à jour. Pourquoi avoir pris ce chemin détourné au lieu de mettre ça directement dans **ligneColonnes**? Imaginez, par exemple, que vous sachiez [[l3:mel_python:aleatoire|faire de l'aléatoire]]. Vous pourriez tout à fait faire une fonction "**randomUpdate()**" qui appellerais votre fonction avec des valeurs aléatoires. Cloisonner chaque action permet de rajouter des fonctionnalités facilement, sans modifier vos fonctions existantes.

En tout cas, notre fonction **ligneColonnes()** est entièrement contrôlable !

Bien entendu vous pouvez adapter tout ça avec les contrôleurs que vous voulez (boutons, boites à cocher, listes déroulantes...) et à la fonction que vous voulez (**tomate()**, **lampadaire()**, **temple()**...)

=====Le script complet=====

Le code est modifié afin de se nettoyer proprement. Voir [[nettoyage]].

<code python>
import maya.cmds as cmds
 
#fonction de nettoyage
def deleteGroup(name) :
	'''Supprime un groupe'''
	if cmds.objExists(name) :
		cmds.delete(name)
 
# fonction principale
def ligneColonnes(nombre, hauteur, espacement) :
	'''Cree x colonnes cotes à cotes, de hauteur et espacement donnes'''
	for i in range(nombre):
		cmds.polyCube(n = 'tomate_colonne', h = hauteur) # cree un cube de hauteur donnee
		cmds.move(i*espacement,0,0) # le deplace selon l'espacement donne
	cmds.group('tomate_*', name = 'tomateGroup') # on met tout dans un groupe
 
# fonction de mise a jour
def update() :
	'''lie la fonction ligneColonnes et ses controleurs'''
	# on demande la valeur des sliders et on les stocke dans des variables
	nombre     = cmds.intSliderGrp(  'nombre',     query = True, value = True)
	hauteur    = cmds.floatSliderGrp('hauteur',    query = True, value = True)
	espacement = cmds.floatSliderGrp('espacement', query = True, value = True)
	
	# on supprime l'ancien groupe
	deleteGroup('tomateGroup')
	# on appelle la fonction ligneColonnes avec les valeurs précédentes
	ligneColonnes(nombre, hauteur, espacement)
 
# suppression du groupe au lancement du script
deleteGroup('tomateGroup')
 
# execution de la fonction au lancement du script
ligneColonnes(nombre = 5, hauteur = 10, espacement = 2)
 
#affichage de la fenetre de controle
cmds.window()
cmds.columnLayout()
cmds.intSliderGrp(  'nombre',     label = 'nombre',     changeCommand = "update()", value = 5,  field = True)
cmds.floatSliderGrp('hauteur',    label = 'hauteur',    changeCommand = "update()", value = 10, field = True )
cmds.floatSliderGrp('espacement', label = 'espacement', changeCommand = "update()", value = 2,  field = True )
cmds.showWindow()
</code>

---------------
Si vous avez des questions, des remarques, des suggestions, n'hésitez pas à m'en faire part.

~~DISCUSSION~~