contrôle d'objet, à partir d'un code classique

Invité

Je vous soumets un programme, celui-ci est une très grosse simplification de celui que je fais actuellement.
Je me trouve confronté à un problème. Il est facile depuis un bouton, ou tout objet de controler une forme ou un autre objet.
Mais comment faire pour pouvoir contrôler une forme qui puisse être appelé plusieurs fois depuis des lignes de code. (qui n'est pas un objet événementiel)
Je n'y arrive pas. Celle-ci est transparente, c'est à dire elle s'affiche, mais le programme continu, et ici j'ai mis un bouton , mais il ne sert à rien.
Toutes les boucles que j'ai pu mettre pour arrêter la fenêtre et pouvoir me servir du clic sur le bouton me bloque.

Certes ce programme vous parait dément, mais c'est une simplification d'un programme qui lui est bien plus complexe et a son intérêt.
Mais il ne sert à rien de le montrer. Ce qui est important dans le raisonnement, est de pouvoir contrôler un événement depuis un codage de programme ordinaire, comme on le faisaitauparavant, sans événement(s), d'avoir la possibilité de controler des objets, ici c'est juste un bouton, mais un bouton, un picture ou autre est un événement.

Si quelqu'un a une idée. Je pensais que cela était facile en Panoramic, aujourd'hui, je me demande si c'est seulement possible.

Aurais-je perdu mes capacités?

J'ai fais plusieurs modifications, j'ai gardé celle-là pour la diffusion. A vous de voir, et si vous y arrivez, vous aurez la preuve, que je ne suis pas aussi fort que vous le dites parfois.

Code:: dim a%,b%

label branche , sortie , fin , code ,rebranche

button 1:top 1,200:caption 1,"essai":on_click 1,branche
memo 2:top 2,0 :left 2,0:height 2,185:print_target_is 2

' form pour comprendre le branchement avec un bouton
form 10 :left 10,300:hide 10
button 11:parent 11,10
left 11,10:top 11,50:caption 11,"clic":on_click 11,sortie

END
' ==============================================================================
' =================clic depuis un bouton========================================
rebranche:
if mouse_left_down(11)=1 :' un essai parmi tant d'autre, et à d'autre endroit
repeat:until mouse_left_up(11)=1
else
repeat:until mouse_left_down(11)=1
end_if
branche:
show 10:print "branche"
goto code
return
' =================clic sans la fenêtre=========================================
' ==============================================================================
sortie:
hide 10
return
' ==============================================================================
' ==============================================================================
code:
gosub rebranche:print "code1"
gosub rebranche:print "code2"
return
' ==============================================================================
' =================TERMINATE====================================================
fin:
terminate

Il s'agit de FORM 10 et BUTTON 11
Ici je clique sur "essai" une forme s'affiche, cela fonctionne comme prévu, et me branche sur code, qui serait une partie d'un programme, et c'est à partir de là que je bloque.
Merci aux courageux, qui veulent se penser sur le problème. Je ne sais pas si Jack vois une erreur de ma part, ou une commande qui n'existe pas.
@+
Je file pour l'instant, je dois partir, je suivrais vos commentaires ensuite. Merci

Personnelement je ne vois pas d'erreur, c'est pourquoi j'ai détourné le probleme avec des faux-form. il y a bien la possiblité avec EXECUTE WAIT, je ne vois que çà.

Voir https://panoramic.1fr1.net/vos-sources-vos-utilitaires-a-partager-f2/programmation-par-objet-avec-des-faux_forms-t456.htm?sid=720b07224929369aaccc24fd75af0a58

Invité

Merci Jean-Claude. J'ai pas essayé les faux forms,, j'avais plusieurs programmes en cour de route, sans compter le reste, et je ne pouvais pas me disperser de trop, j'avais trop de codage en tête pour vouloir en rajouté. Mais j'y jetterai un coup d'oeil.
Donc il y a bien un problème de ce côté là. J'ai essayé plein de truc, j'ai pas encore renoncé
Sur GFA Basic, puisque je reprends une procédure qui était fait avec ce langage, la méthode d'attente était:
REPEAT
UNTIL MOUSEK =0.
Mais ça ne marche pas ici, on dirait que pendant une boucle de ce genre, le basic est totalement déconnecté des touches de la souris.Dans les 2 sens, soit c'est cliqué, et j'attends le relâchement, ou dans le sens contraire avec le code:

Code:: if mouse_left_down(11)=1 :' un essai parmi tant d'autre, et à d'autre endroit
repeat:until mouse_left_up(11)=1
else
repeat:until mouse_left_down(11)=1
end_if

suivant il n'y aurait finalement pas un bug?
Peut-être aussi j'ai pas tout à fait bien interprété le codage, il y a peut-être aussi un mauvais raisonnement de ma part. Je ne suis pas encore tout à fait convaincu d'avoir ici tout bien compris.
Je vois que tu parles de execute_wait, j'y pensais tout à l'heure, mais quelque chose me dis que c'est pas gagné.

Invité

J'ai peut-être trouvé une solution. Maintenant vais-je pouvoir l'adapter dans mon programme.

Code:: dim a$ ,a%
label sortie , fin , code ,rebranche
left 0,600:height 0,450
button 1:top 1,200:caption 1,"essai":width 1,90: on_click 1,code
memo 2:top 2,0 :left 2,0:WIDTH 2,250:height 2,185:print_target_is 2
button 3:top 3,250:caption 3,"essai END direct":width 3,90
on_click 3 ,rebranche

' form pour comprendre le branchement avec un bouton
form 10 :left 10,900:hide 10 :width 10,100 :top 10,100
button 11:parent 11,10
left 11,10:top 11,50:caption 11,"clic": on_click 11,rebranche
END
' FIN DES OBJETS FIN DES OBJETS FIN DES OBJETS
' ==============================================================================
code:
a$= "code1":gosub rebranche: print "ici considérons que l'on fait du codage" :wait 1000
a$= "code2":gosub rebranche: for a%=1 to 5:print a% :next a% :wait 1000
a$= "code3":gosub rebranche: print "dernier appel" :wait 1000
return :' wait 1000 représente en quelque sorte l'éxécution d'un prog intermédiaire
' ==============================================================================
rebranche:
show 10
if clicked(11)=1 then print a$ :goto sortie
end :' Il faut mettre un END pour que cela devienne un évennement
' J'aimerai bien avoir l'avis de Jack sur ce qu'il pense de la méthode
' savoir si il trouve cela bon, ou alors tiré par les cheveux (j'ai pas d'avis
' je ne sais que penser)
' ===========================================
sortie:
hide 10
return
' ==============================================================================
' =================TERMINATE====================================================
fin:
terminate

Je viens de rajouter un bouton pour contrôler que le branchement depuis un objet ne perturbe rien. Je ne l'ai pas inactivé pendant le suivi du programme depuis code, pour ne pas alourdir, mais évidemment, il faut attendre que les 3 accès depuis code soit finis pour cliquer dessus. Si on appuie sur bouton 3 en 1er ou lorsque les 3 appels sont fait, ça fonctionne.

Au label rebranche, tu dis qu'il faut un end, et pourquoi pas un return. J'ai essayé, le comportement est différent. Mais comme je ne vois pas bien ce que tu essais de faire....

A+

Invité

J'ai repris l'ensemble pour avoir un bouton d'attente.
Lorsqu'on fait des lignes de codes, en dehors des événements, on a au moins 2 choses:
pouvoir montrer une forme avec des objets, ne serais se qu'un mémo pour montrer des résultat, et parfois, arrêter temporairement l'exécution d'un code, pour lire des résultats. Donc j'ai repris le script pour avoir une forme supplémentaire qui arête l'exécution etc continue, ensuite. On aurait pu aussi se servir de message, l'avantage de la forme est que le dimensionnement et la position est contrôlable. J'arrête là les essais. J'ai obtenu ce que je recherché. Je ne trouvais pas de solution, si j'avais poussé un peu plus, peut-être que ce poste aurait été inutile, à moins que le résultat eu intéressé quelqu'un

Code:: dim a$ ,a%
label sortie , fin , code ,boite,attente
left 0,600:height 0,450
button 1:top 1,200:caption 1,"essai":width 1,90: on_click 1,code
memo 2:top 2,0 :left 2,0:WIDTH 2,250:height 2,185:print_target_is 2
button 3:top 3,250:caption 3,"essai END direct":width 3,90: on_click 3 ,boite
' ----------------
' forme d'attente
form 20 :hide 20:top 20,300:left 20,800:width 20,100:height 20,90:color 20,132,190,33:border_small 20
button 21:parent 21,20:top 21,25:left 21,10:width 21,80:caption 21,"continue"
alpha 22:parent 22,20:top 22,0:left 22,10:font_size 22,12:font_bold 22:caption 22,"attente"
' --------------------------------------------------
' form pour comprendre le branchement avec un bouton
form 10 :left 10,900:hide 10 :width 10,100 :top 10,100
button 11:parent 11,10
left 11,10:top 11,50:caption 11,"clic": on_click 11,boite
END
' FIN DES OBJETS FIN DES OBJETS FIN DES OBJETS
' ==============================================================================
code:
inactive 1:inactive 3
a$= "code1":gosub boite: print "ici considérons que l'on fait du codage" :wait 1000
a$= "code2":gosub boite: for a%=1 to 5:print a% :next a% :gosub attente
a$= "code3":gosub boite: print "dernier appel" :gosub attente
print "il n'est plus dans attente" :active 1:active 3
' wait 1000 représente en quelque sorte l'éxécution d'un prog intermédiaire
return
' ==============================================================================
boite:
show 10
if clicked(11)=1 then print a$ :goto sortie :' pour avoir un "return"
end :' Il faut mettre un END pour que cela devienne un évennement

' ==============================================================================
' ==================fenêtre d'attente===========================================
attente:
show 20
repeat:until clicked(21)=1 :' curieusement là ça marche
hide 20
return
' ==============================================================================
sortie:
hide 10:hide 20
return
' ==============================================================================
' =================TERMINATE====================================================
fin:
terminate

Invité

Je viens de voir ton message.
Désolé, ça ne marche pas dans ton cas.
IL N'Y A PAS D'ARRÊT dans le codage, l'exécution d'un gosub à la forme, ne s'arrête pas pour attendre que tu clics sur un choix (ici il n'y à qu'un bouton pour simplifier), mais continue. donc c'est pas logique. On doit répondre au 1er appel, ensuite au 2ème, puis au 3ème pour suivre le programme.
En modifiant le end par return ici depuis la dernière version, j'ai la forme, et aussitôt la forme d'attente. Ce n'ai pas valable.
@+

En fait, je ne vois toujours pas ce que tu recherches avec ce code, c'est pourquoi je réponds à coté.

Invité

Je ne sais pas comment te l'expliquer. Jusqu'à présent on fait de la programmation objet avec panoramic, et franchement, ça marche très bien. On a une forme avec des objets, on clique dessus, et on continu le travail. Dans ce cas Panoramic est formidable. Maintenant, j'en ai déjà parlé, j'ai perdu un programme de plus de 20000 lignes, qui était un programme de recherche, pour des idées personnels. Ce programme appelait dans les lignes de code plus de 300 fois (il me semble que c'était proche de 350) une boite qui était modifiée pour répondre à chaque besoin.
(et là il n'y avait pas d'objets sur les anciens basics pas de boutons ) cette boite faisait plein de choses - être un menu - être un choix - donnez un message -remplir des listes multiples - etc... Ce programme je voudrais le refaire, sauf que là, il ne sagit plus de programmation objet, un objet appel un autre objet, mais les objets lorsqu'il faut les voir, sont appelés par le programme (si tu veux le code), et là, il y a difficulté. A tel point que ce que je présente plus haut, et qui marche, je n'ai pas encore réussi à le faire marché sur le programme qui était la base de celui présenté ici.
J'essaye comme il y a 20 ans de refaire une boite similaire, passe partout qui est appelé, chaque fois que nécessaire, depuis le programme lui-même.
Il me parait difficile de t'en dire plus: créer une forme avec des objets multiples avec réponses, mais dont l'appel de la forme ne se fait pas par un clic mais par la programmation.

Rassures-toi, c'est normal que tu répondes à côté. Moi je sais ce que je veux, mais comme l'idée est complexe pour moi à expliquer.
Une chose que j'ai apprise:

Citation :: lorsqu'il y a une erreur, c'est toujours celui qui donne commande, ou qui explique qui a tord

(j'en ai eu une démonstration dans un stage
Je réédite:
Dans le programme plus haut: il y a un bouton qui t'emmènes sur des lignes de codes dont le label est code:
C'est ce code qui décide d'appeler la boite.
un 1er appel gosub boite ==> la boite s'affiche =>> tu y réponds
un 2ème appel gosub boite ==> la boite s'affiche et idem ...

La difficulté était qu'on ne pouvait pas répondre, les boites s'affichaient et se refermaient à la suite sans que tu puisses y répondre., et on arrivait au return. Tu l'as vu.

Admin Nombre de messages : 2394 Date d'inscription : 28/05/2007

J'avoue que j'ai du mal à comprendre ce que tu veux faire.
Tu peux utiliser les objets sans passer par les événements.
Par exemple, tu peux tester si un bouton a été cliqué par CLICKED(N), sans avoir fait aucune ligne ON_CLICK N,Label

Code:: dim i%
label boucle
button 1
boucle:
if clicked(1)=1
i%=i%+1
caption 1,str$(i%)
end_if
if i%=10 then terminate
wait 100
goto boucle

Citation:
Il me parait difficile de t'en dire plus: créer une forme avec des objets multiples avec réponses, mais dont l'appel de la forme ne se fait pas par un clic mais par la programmation

Oui là je comprends bien. Les solutions que j'ai trouvés jusqu'à ce jour c'est les "faux-form" qui sont appelés à partir d'un MAIN_MENU. Ou faire un programme par FORM. Les FORMs s'appellent entre eux par EXECUTE ou EXECUTE WAIT.

J'ai déja créer Un FORM en cours du programme. (je veut dire après le premier END), mais cela fonctionne que si l'on ne retourne pas sur d'autres FORMs dèja définie.
Ce que je crois avoir compris de PANORAMIC, c'est que pour que tout se déroule bien il faut que tout les objets (y compris FORM) soit déclarés avant le premier END.
Toi tu voudrais que le programme puisse créer, lui même, un FORM pendant son déroulement (si j'ai bien interprété ta pensée). Là çà me parait difficile, mais à vrai dire je n'ai jamais essayé.

Voilà un challenge.

A+

Jack est passé juste devant moi, mais j'envoie tout de même.

Le programme de Jack crée un seul boutton qui peut avoir 10 fonctions. c'est intérressant pour économiser les objets.

Invité

on_click à pour fonction de renvoyer à un sous programme.
on_clicked par contre peut-être testé dans la suite des codes.
Ce que je veux est de faire du codage classique,comme on le faisait avant, dans les lignes de codes au fur et à mesure, et lorsque cela est nécessaire, faire appel à une boite d'objet depuis les lignes. On répond à cet objet, le programme reprend son cours, et chaque fois que cela est nécessaire, le programme ressort l'objet demandé. Ce n'est pas un clic qui commande, qui fait son effet, et de clic en clic en avance dans le programme. Le ou les objets sont temporaire, et c'est le programme qui selon les réponses qui sont données, va vers tel ou tel endroit du programme. C'est ce qu'on faisait avant. J'ai fait une boite d'essai qui fonctionne très avec des clics, et je pensais que celle-ci était terminé, mais lorsque j'ai voulu faire appel à partir du programme, là ça ne marche plus. Je pourrais mettre le code, mais ce n'est valable que pour du clic.
Si vous voulez voir ce que cela fait, je mettrais le code sans problème, mais je n'aime pas tellement mettre une chose, dont l'objectif n'est pas atteint. Je ne suis pas sur que ce type de programme puisse vous intéresser.
Je rajoute que le fait de vouloir faire de la vielle programmation, ne veux pas dire qu'il n'y a pas d'objet. Il y a les deux.

Citation :: et lorsque cela est nécessaire, faire appel à une boite d'objet depuis les lignes

Cela impose que les objets de la boite soient déclarés dans le programme principale (car je suppose que ta boite d'objets se trouverait dans un code différent du programme principale). Comme je l'ai dit précédement, si les objets ne sont pas déclarés avant le premier END, çà va poser problème. La solution dans ton cas passerait obligatoirement par un code Sans END, donc avec une boucle. Franchement cela me parait difficile, mais....

Invité

Jean-Claude, j'ai déjà fait des programmes avec des objets qui sont déclarés après le END. ça ne pose pas de problème particulier, je voulais même en publier un il y a 2/3 mois, où c'était presque de la programmation avec des sortes de briques, des objets qui servaient à faire des actions, comme tourner une page, enregistrer, dans la liste on prenait un objet, qui avait un rôle, ainsi de suite, et tout ces objets n'étaient pas déclarés avant le END, mais se programmait à ce moment là. Malheureusement une mauvaise manoeuvre, un moment d'étourdit, et le programme a été recouvert par un autre avec les problèmes que tu connais de l'éditeur. Passons.
Mais bien des choses sont possible avec Panoramic, il faut seulement que ce soit des clics qui engendrent des suites.
La programmation primitive est plus difficile ici, parce que ce n'est pas la philosophie, le fonctionnement normal. L'exemple du dessus montre que c'est possible, mais pas simple. Preuve en est pour moi, la programmation de ma boite est à refaire, je ne peux l'adapter, suivant ce que j'ai résolu au dessus.
@+

Je rajoute ceci: en fait le END, ne sert uniquement à attendre un clic un événement pour démarrer, le programme est près. Tu as une forme avec les objets, tu clics sur un objet, et tu as une action, et ça continu. Le programme principal s'arrête au END, et ne fait plus rien. Tu démarres par un clic. Tu comprends? T'en qu'il n'y a pas de END, Panoramic exécute des ordres. Et là il est en attente.

Il semble que tu as raison, je viens de jetter un coup d'oeil au dernier code de Klaus, et en fait il a fait comme tu dis. soit:

Code:: DIM :' les variables
LABEL :' les labels

GOSUB x
GOSUB y
END
' =========================
FORM :' création des forms et objet

Je n'est pas encore essayé son programme. C'est juste pour dire que sa manière de structurer un programme va dans le sens de ce que tu cherches.
Tu me diras que çà revient au même car les Gosub sont avant END. C'est juste une façon différente de coder.

A+

Invité

Sur la création d'objet, là sur que j'ai raison.
essayes le programme suivant:

Code:: label br,bs,fin

width 0,500:height 0,800
button 1:top 1,10:width 1,150:caption 1,"nouveau mémo" :on_click 1,br

end
br:
memo 2:top 2,50
item_add 2,"le mémo viens d'être créé"
caption 1,"nouveau picture":on_click 1,bs
return
bs:
picture 3:top 3,10:left 3,200:color 3,255,0,0
item_add 2,"si vous cliquez maintenant le programme s'arrète"
caption 1,"fermeture"
on_click 1,fin
return
fin:
terminate

Il y a le 1er qui commande, depuis lequel on créé un mémo, puis un picture
comme tu peux le constater: le programme créé un bouton, et s'arrête au END, maintenant tu es en mode événementiel.
Lorsque tu le décides, le programme par l'appuie d'un clic, continu. Le END sert à ça, à moins que Jack interprète autrement, mais là je ne sais pas quoi.
Je ne connais pas le code de Klaus, vu que ne n'ai pas Excel, mais faire un gosub avant de END, cela ne sort du contexte de mettre les objets avant le END. Tu mets le code ailleurs, mais cela se fait avant que le programme, en suivant sa liste atteigne le END. Maintenant ce qui a été fait dans le gosub, je ne le sais pas
A+

Là, je suis convaincu. Ton petit code est très simple et très explicatif. Ce qui est à remarquer c'est que boutton (unique) change de fonction au fur et à mesure du déroulement du programme. Et effectivement, tu crées des objet en cours de programme.
Ce n'est pas, je suppose, que c'est ce tu recherchais au départ. Mais ce code est instructif.

Merci et à +

Invité

En lisant ta réponse, et après un peu de réflexion, il m'ai venu une idée. Mon programme je vais y arriver à le faire, mais je pense qu'il manque une instruction à Panoramic, qui résoudrai mon problème, et aiderai la conception d'un programme tel que je voudrais le faire. Je ne pense pas qu'on puisse dire que cela est pour mon propre besoin. Tout le monde à un moment ou un autre peut avoir la nécessité d'avoir un programme comme fil conducteur, et non d'attendre une fenêtre, répondre à un question, cliquer sur un bouton, pour faire autre chose. ça c'est du bureau. Il faudrait une instruction du type: PUSH_CLIC N. Je ne fait pas d'anglais, mais l'idée est de simuler un clic sur un objet, de cette façon, on reste dans un événement, on provoque un clic par programme sur un objet, et le tour est joué. Je ne pense pas que cette instruction soit difficile à programmer, et même plus simple que de tester un clic sur une sourie, il suffit juste de prendre le numéro d'objet et le rendre opérationnel. Si Jack voit ceci, qu'en pense t-il?
A+

Invité

Je crois que je viens de dire une connerie, il n'y a pas de file d'attente. Si il y a évènement, on quitte le fil du programme, et on ne se rebranche pas à la suite de cette instruction, il faudrait que ce soit une sorte de gosub, pour revenir à la suite du programme.
Ne parlons plus.
Je réédite pour aller sur le fond de la réflexion. Si cela se faisait, il faudrait que les objets cliqués sur la forme, ne soit plus directionnels (j'entends par là, qu'avec on_click, on ne puisse pas se rebrancher ailleurs), sinon, je crois qu'il y a une pile, avec l'adresse de retour du gosub, et si on est dans des boucles, il faut encore tout déboucler jusqu'au return, comme on le fait avec exit_for ou autre. Dans la faisabilité de ce genre d'instruction, il faudrait avoir soit une forme spéciale, où on ne peut prendre que des infos, ou des clics pour faire un choix, soit une instruction qui force la forme à bloquer la fuite des contrôles (si je puis m'exprimer ainsi, en ce sens que on_clic soit non actif).
Il serait intéressant d'avoir l'opinion des informaticiens de ce forum. Moi avec mon CAP de couvreur, je ne suis pas grand chose. Quoi qu'il en soit, je pense que l'idée originel est foireuse.
A+

Je ne vois que CLICKED(n)=1 qui click le boutton par programmation. Et après il faut gérer le retour au programme principale. Bon courage.

Invité

C'est ce que j'utilise. Mais parfois cette programmation n'est pas facile, lorsqu'il y a plein d'objet, dont les numéros ne se suivent toujours pas, et d'autre chose qui sont difficilement explicable sans un long paragraphe. C'est pour cela qu'il aurait été bien d'avoir une instruction de plus. Si je m'en sort, et je crois que ça progresse bien, tu verras que c'est toujours évident. De plus il serait bien qu'il y ait une instruction Do ... Loop. Trafiquer un repeat Until c'est pas clair
A+

Invité

Je viens de terminer le programme, et tout fonctionne comme je le souhaitais.
Je prends le temps d'écrire un scénario pour en expliquer le fonctionnement, et je mettrais le programme dans - les sources - ...

Plus têtu que toi çà n'existe pas.

Invité

Pour quoi, tu ne voulais pas.
A+

Bien sur que si, mais tu force mon admiration. Quand tu veus quelque chose, tu vas au bout, envers et contre tout. Maintenant j'arrête de te distraire, car j'ai hate de voir le résultat.

» Défi pour les frimas à venir = dessiner des carrés
» Contrôle validité de date
» controle du son
» Clé de contrôle du numéro SS
» memomisation a partir d'un xls