Besoin d’aide RxMui
-
Salut,
Donc pour en revenir à ma première interventions, voici les lignes de codes où je parles de cela:
/*call child("mgroup","graces","group") Par defaut, un group est vertical */
/*De plus tu mélange la création par variable et dynamique */
mgroup.0="graces" /* mgroup (qui est vertical) contient l'objet graces */
graces.class="group" /* graces est une classe group */
Comme Arexx a besoins de stocker la structure de l’aboressance de l’application MUI avant de ma créer avec la ligne
if NewObj(« application », »app »)~=0 then exit
Pour cela, on utilise un ensemble de variables qui font référence les unes aux autres et avec des incrémentation pour « remplir » les groupes.
Application (app.)
'->Fenetre (app.SubWindow="mwin")
'->Group (mwin.Contents="mgroup")
'->Group (mgroup.0="graces")
| '->Object (graces.0)
| '->Object (graces.1)
| '->Object (graces.2)
'->Group (mgroup.1="gtypes")
'->Object (gtypes.0)
'->Object (gtypes.1)
La fonction arexx ‘call child(« mgroup », »graces », »group »)’ est ce que j’appel un appel dynamique car cela ajoute un enfant à « mgroup » en incrémentant l’indice du groupe automatiquement.
Le premier appel de ‘call child()’ fera ceci:
mgroup.0= »graces »; graces.class= »group »;
Le deuxième appel avec un autre nom de groupe:
‘call child(« mgroup », »gtypes », »group »)’
équivaud à:
mgroup.1= »gtypes »; graces.class= »group »;
L’indice est passé de 0 à 1.
D’où mon terme dynamique, l’ordre d’appel défini l’ordre dans le groupe. Cela a un avantage et un inconvénient.
Si on se contente d’utiliser les appels rxmui de base (fonctions) cela peut parraitre plus simple et lisible car on a pas a se soucier de l’incrémentation.
L’inconvénient est que cela « masque » la mécanique de l’arboressence et rendra la programmation avancée plus compliquée à manipuler, faute de l’avoir fait pour des choses simple.
Utiliser uniquement la gestion des variable comme je te l’ai montré dans les différents exemples permet un contrôle plus fin de MUI et permet de (relativement) faciliter l’identation.
Evidement, les fonctions de la section « Functions that create objects » de la page http://alfie.altervista.org/rxmui/rxmuidoc/functions.html sont crée de manière dynamique car ils sont le dernier niveau (pas d’enfant).
L’identation est une chose TRES importante car une interface utilisateur peut vite devenir une grande suite d’empilement successif.
Donc chaque création d’un objet (groupe ou autre sauf les « fonctions » cité plus haut) demande un décalage de quelques espaces (en général une tabulation de 4 caractères est asser courant). Cela permet de « voir » grace au décalage les différents « niveaux » l’arboressence.
C’est aussi pour cela qu’il est indispensable de lister sur papier les différents éléments à incorporer dans une fenetre et de dessiner celle ci et ensuite. Encadrer les différents ensemble d’objets horizontaux et verticaux pour en faire apparaitre une arboressence.
Sans avoir l’habitude, il est necessaire de refaire l’implantation pour « rationaliser » les groupes H/V.
Enfin tu « nome » les différents groupes avant de passer a l’arboressence en RxMUI.
Dernier point, attention au piège des variable arexx lorsqu’ils sont passé en arguments à une fonction. Une variable non initialisée correspond à son « nom ».
Exemple:
/* */
say hello
hello= "good bye"
say hello
Il faut donc toujours mettre les nom d’une variable entre guillement ou apostrophe pour bien faire référence à son « nom » et non à son « contenu ».
En pratique:
group.0=Button(sauver, »Sauvegarder »)
peut fonctionner mais si dans ton code il y a cela:
sauver= »fichier.txt »
group.0=Button(sauver, »Sauvegarder »)
Ne marchera pas car c’est en « théorie » un bouton nommé « fichier.txt » qui devrait être créer et non « sauver » donc je te laisse imaginer ce que cela peut provoquer comme bug à posteriori.
Je ne sais pas si tout ce blabla est très clair mais j’aurai essayé
A+
Ok ça marche,
J’ai encore pleins de questions et plus j’apprends plus j’en ai j’espère que je ne vais pas te saoulé
voila j’aimerai savoi qu’elle différence y a t-il entres ces fonctions :
– Add
– NewObj
– XNewObj
– MakeObj
j’ai du mal à comprendre la nuance pour moi et par rapport à la doc (tres limité) c’est plus ou moins la même chose
Salut,
Pour le moment ça va
Add: Ajoute un objet EXISTANT (child) à l’objet parent (un groupe ou l’application pour ajouter une fenètre en général).
res = Add(parent,child,before)
(before) n’est utilisable que pour les menus
Il faut avoir créer l’objest (child) avec NewObj(),XNewObj() ou MakeObj().
NewObj: Crée une instance de la classe (className) en utilisant le nom et les paramètre de la variable (objName)
res = NewObj(className,objName)
res=0 si reussis.
XNewObj: Crée une instance de la classe (className) avec les attribut de la variable (stem) et retourne le nom généré automatiquement.
res = NewObj(className, » »,stem)
res= » » si échoué sinon le nom de l’objet crée.
MakeObj: Crée un objet « standard »
oname = MakeObj(name,type,parms)
Name est le nom de l’objet à créer (optionnel, le nom auto-généré est alors retourne dans oname )
Type et Params sont défini dans la liste ci-dessous
http://alfie.altervista.org/rxmui/rxmuidoc/functions.html#MakeObj
oname= » » si échoué sinon le nom de l’objet crée.
Donc chaqu’un a ces spécificités.
Voilà
A+
ok j’y voi plus clair maintenant
enfin c’est bizard quand même j’ai utilisé la fonction Add() dans une fonction pour créer des boutons qui n’existe pas et ça marche quand même :
mais je bloque sur mon code pour le clique sur les boutons il n’incrémente pas le j
mafonction:
blablabla
blablabla
blablabla
…
call DoMethod(« frl », »InitChange »)
call Add(« frl »,button(« bouton »j,laBase.j.ButtonName_))
call Notify(« bouton »||j, »pressed »,0, »app », »return », »call ChoixBouton(j) »)
call DoMethod(« frl », »ExitChange »)
…
blablabla
return
en faite ce que je cherche à faire c’est créer des boutons dinamiquement par rapport à une liste de fichier qui ce trouve dans un tableau
Quel homme ce Poly. Tu devrais te reconvertir en prof de MUI.
en faite je me suis mal expliqué
j’ai une liste de fichier => de 1 à x fichiers
donc j’aimerai créer des boutons dynamiquement par rapport au nombre de fichier
en claire ça donne :
DO i=1 TO xfile
call Add(« frl »,button(« bouton »j,laBase.j.ButtonName_))
call Notify(« bouton »||j, »pressed »,0, »app », »return », »call ChoixBouton(j) »)
End
mais ça marche pas les bouton ce créer bien mais la notification ne renvoi rien dans la fonction
c’est la dernière chose qu’il manque pour finir mon projet apres ça j’attaque la localisation
J’ai trouvé en faite j’oublier de mettre les « » à mon j => « j » ça marche capitaine ça marche!!
Si mon bouton ajouté c’est :
call Add(« frl »,button(« bouton »||bt,laBase.bt.ButtonName_))
Pour le retiré c’est bien :
call remove(« bouton »||bt) ?
par ce que je bloque dessus depuis un p’tit moment déjà et ça veu pas partir!
C’est bon j’ai trouvé
mais c’est le killnotify qui me bloque maintenant
- Vous devez être connecté pour répondre à ce sujet.
