[AXE] Un projet prometteur !

Voilà ce que j'ai pour l'instant, en deux versions: boutons blancs ou noirs

Et bien sûr voilà les codes (en mode TokenIDE), pour ceux que ça intéresse
Ne regardez que la routine Wdws et la data, le bout de code entre les deux est inintéressant
Notez aussi que la largeur des boutons s'adapte au texte qu'il y a à l'intérieur mais pas la taille des fenêtres.

Boutons blancs: 955 octets pour le barda complet

Code:


.AA
L1+712->^^oPtrz
L1+710->^^oPtrz0
L1+708->^^oPtrz1
L1+706->^^oPtrz2
L1+704->^^oPtrz3
L1+702->^^oBtn0

[]->GDB1
Data(6,6,82,49)
Data(2).nombre de boutons
Data(3).nombre de lignes de texte
"Première ligne de texte"[00]
"Deuxième ligne de texte"[00]
"Troisième ligne de texte"[00]
"Btn1"[00]
"Bouton2"[00]

Fix 5
GDB1sub(Wdws)
DispGraph
Pause 200
Repeat getKey(0)
End
Return

Lbl Wdws
->Ptrz
Rect({}->Ptrz0+1,{Ptrz+1}->Ptrz1,{Ptrz+2}->Ptrz2-2,{Ptrz+3}->Ptrz3)
Rect(Ptrz0,Ptrz1+1,Ptrz2,Ptrz3-2)
RectI(Ptrz0+1,Ptrz1+9,Ptrz2-2,Ptrz3-10)
Pt-Off(Ptrz0+Ptrz2-8,Ptrz1,[FE837D556D557D83])
For(r1,0,{Ptrz+5}-1)
 Text(Ptrz0+2,r1*6+Ptrz1+9->Btn0,stdDev(Ptrz+6,r1))
End
Btn0+8->Btn0
{Ptrz+4}
While -1->r1+1
 Text(Ptrz0+8,r1*10+Btn0->r2,stdDev(Ptrz+6,{Ptrz+5}+r1))
 RectI(Ptrz0+4->r3,r2,{|E86D7}+3-r3->r4,7)
 RectI(r3++,r2--,r4-2,9)
 r1
End


Boutons noirs: 1021 octets pour le barda complet

Code:


.AA
L1+712->^^oPtrz
L1+710->^^oPtrz0
L1+708->^^oPtrz1
L1+706->^^oPtrz2
L1+704->^^oPtrz3
L1+702->^^oBtn0

[]->GDB1
Data(6,6,82,49)
Data(2).nombre de boutons
Data(3).nombre de lignes de texte
"Première ligne de texte"[00]
"Deuxième ligne de texte"[00]
"Troisième ligne de texte"[00]
"Btn1"[00]
"Bouton2"[00]

Fix 5
GDB1sub(Wdws)
DispGraph
Pause 200
Repeat getKey(0)
End
Return

Lbl Wdws
->Ptrz
Rect({}->Ptrz0+1,{Ptrz+1}->Ptrz1,{Ptrz+2}->Ptrz2-2,{Ptrz+3}->Ptrz3)
Rect(Ptrz0,Ptrz1+1,Ptrz2,Ptrz3-2)
RectI(Ptrz0+1,Ptrz1+9,Ptrz2-2,Ptrz3-10)
Pt-Off(Ptrz0+Ptrz2-8,Ptrz1,[FE837D556D557D83])
For(r1,0,{Ptrz+5}-1)
 Text(Ptrz0+2,r1*6+Ptrz1+9->Btn0,stdDev(Ptrz+6,r1))
End
Btn0+8->Btn0
{Ptrz+4}
While -1->r1+1
 Text(Ptrz0+8,r1*8+Btn0->r2,stdDev(Ptrz+6,{Ptrz+5}+r1))
 RectI(Ptrz0+4->r3,r2++,{|E86D7}+3-r3->r4,5)
 RectI(r3++,r2--,r4-2->r4,7)
 RectI(r3,r2++,r4,5)
 r1
End


UPDATE
J'ai viré une des deux routines rectangles, ce qui me fait économiser 55 octets
avec screenshot [Vous devez être inscrit et connecté pour voir cette image]
et code:

Code:


.AA
L1+712->^^oPtrz
L1+710->^^oPtrz0
L1+708->^^oPtrz1
L1+706->^^oPtrz2
L1+704->^^oPtrz3
L1+702->^^oBtn0

[]->GDB1
Data(6,6,82,49)
Data(2).nombre de boutons
Data(3).nombre de lignes de texte
"Première ligne de texte"[00]
"Deuxième ligne de texte"[00]
"Troisième ligne de texte"[00]
"Btn1"[00]
"Bouton2"[00]

Fix 5
GDB1sub(Wdws)
DispGraph
Pause 200
Repeat getKey(0)
End
Return

Lbl Wdws
->Ptrz
RectI({}->Ptrz0+1,{Ptrz+1}->Ptrz1,{Ptrz+2}->Ptrz2-2,{Ptrz+3}->Ptrz3)
RectI(Ptrz0,Ptrz1+1,Ptrz2,Ptrz3-2)
RectI(Ptrz0+1,Ptrz1+1,Ptrz2-2,8)
Pt-Off(Ptrz0+Ptrz2-8,Ptrz1,[FE837D556D557D83])
For(r1,0,{Ptrz+5}-1)
 Text(Ptrz0+2,r1*6+Ptrz1+9->Btn0,stdDev(Ptrz+6,r1))
End
Btn0+8->Btn0
{Ptrz+4}
While -1->r1+1
 Text(Ptrz0+8,r1*8+Btn0->r2,stdDev(Ptrz+6,{Ptrz+5}+r1))
 RectI(Ptrz0+4->r3,r2++,{|E86D7}+3-r3->r4,5)
 RectI(r3++,r2--,r4-2->r4,7)
 RectI(r3,r2++,r4,5)
 r1
End



Pas mal, pas mal

Je te défie de faire une simple boîte de dialogue avec du texte, un titre et un bouton Ok, tout ça en Axe en mois d'octets que je vais le faire en ASM

matrefeytontias a écrit:Pas mal, pas mal [Vous devez être inscrit et connecté pour voir cette image]

Je te défie de faire une simple boîte de dialogue avec du texte, un titre et un bouton Ok, tout ça en Axe en mois d'octets que je vais le faire en ASM

Ah oui, le titre, j'avais oublié ça [Vous devez être inscrit et connecté pour voir cette image]

Mais c'est ça qu'il y a de beau avec ma routine: elle est modulable. J'ai juste à changer la Data pour avoir ce que tu demandes. Et ce qui prend le plus de place dans la librairie c'est les routines rectangles et Pt-Off.

D'ailleurs, sur les 3 codes que j'ai mis, le dernier ne fonctionne que sur fond blanc à cause du fait que j'utilise jamais de rectangle non inversé

___________________________________________
EDIT
[Vous devez être inscrit et connecté pour voir cette image]
La routine prend 805 octets en comptant les deux routines rectangles et la routine Pt-Off ce qui veut dire qu'une fois intégré dans un programme, elle prend sûrement moins

Et le code:

Code:


.AA
L1+712->^^oPtrz
L1+710->^^oPtrz0
L1+708->^^oPtrz1
L1+706->^^oPtrz2
L1+704->^^oPtrz3
L1+702->^^oBtn0

[]->GDB1
Data(6,6,82,54)
Data(3).nombre de boutons
Data(4).nombre de lignes de texte en comptant le titre
"The Titre (you lost)"[00]
"Matorefu !"[00]
"Voilà, la fenêtre que tu"[00]
"Voulais, en 805 octets."[00]
"OK"[00]
"Pas OK"[00]
"Abstention"[00]

Fix 5
GDB1sub(Wdws)
DispGraph
Pause 200
Repeat getKey(0)
End
Return

Lbl Wdws
->Ptrz
Rect({}->Ptrz0+1,{Ptrz+1}->Ptrz1,{Ptrz+2}->Ptrz2-2,{Ptrz+3}->Ptrz3)
Rect(Ptrz0,Ptrz1+1,Ptrz2,Ptrz3-2)
RectI(Ptrz0+1,Ptrz1+1,Ptrz2-2,Ptrz3-2)
For(r1,0,{Ptrz+5}-1)
 Text(Ptrz0+2,r1*6+(r1>0*2)+Ptrz1+1->Btn0,stdDev(Ptrz+6,r1))
End
RectI(Ptrz0+1,Ptrz1+1,Ptrz2-2,8)
Pt-Off(Ptrz0+Ptrz2-8,Ptrz1,[FE837D556D557D83])
Btn0+8->Btn0
{Ptrz+4}
While -1->r1+1
 Text(Ptrz0+8,r1*8+Btn0->r2,stdDev(Ptrz+6,{Ptrz+5}+r1))
 RectI(Ptrz0+4->r3,r2++,{|E86D7}+3-r3->r4,5)
 RectI(r3++,r2--,r4-2->r4,7)
 RectI(r3,r2++,r4,5)
 r1
End



Pas mal, vraiment pas mal, même si je pense qu'on peut optimiser

Oh, et en ASM j'en suis à 32 octets avec le texte et le titre centrés, donc je pense pas atteindre 806 octets

EDIT : valà, j'ai une fenêtre modale (donc qui bloque le prgm jusqu'à ce qu'on presse [2nd] ou [Enter]) avec un titre en blanc sur noir, un texte noir sur blanc et une largeur réglable (attention à adapter la largeur en fonction du texte et du titre, c'est pas automatique), le tout en 75 octets

Le token est normalpdf(, accessible avec [2nd] [var], renommé en Alert( pour les besoins de l'Axiom

Screen prochainement parce que là de suite je peux pas

Je suppose que l'asm permet de le faire en economisant des octets.

Personelement, mon code source pese 640 octets, et permet de creer une fenetre, et d'y ajouter du texte.
Et pour le texte, j'ai mit le système suivant.

Texte dans le programme: "CECI/EST UN/TEXTE"

affichage réel:

CECI
EST UN
TEXTE

Comme vous l'aurez compris les "/" font office de saut de ligne.
Pour l'instant la taille de la largeur de la fenetre s'adapte au titre, mais plus tard elle s'adapteras aussi a son contenu,et sa hauteur aussi.

En plus des boutons j'ai pensé au bar de progression Qu'en pensez vous ?

Et qu'est ce qu'on peu rajouter encore, plus ce sera complet, mieux ce sera, non ?

on est pas en train de faire un IDE maxence tu part sur des idee trop vaste ou trop compliquee

hayleia tu te moque de nous c'est quoi ce code ???? il est l a r g e m e n t optimisable :O

Je ne parle pas d'IDE, je parle de la ou j'en suis actuelement dans mon entrainement, qui consiste a creer un programme en axe qui contient des fonctions permetant de créer facilement une fenetre.

Biensur ce n'est pas exactement ce que vous faite, mais le but est le même.
J'ai créer un programme "ZFENETRE" en axe, qui, lorsque on l'ajoute via la ligne "prgmZFENETRE" dans un autre programme axe permet d'écrire des lignes du genre "WND( 5,10, "FENETRE 1")->A" et "AFF(A)", pour qu'une fenetre apparaisse a l'écran, avec a peu près le même skin que les votre.

Le coup du "/" je l'ai deja implementé, je présentais juste mes idées, en gros ou j'en suis dans mon entrainement quoi

sachiix69 a écrit:hayleia tu te moque de nous c'est quoi ce code ???? il est l a r g e m e n t optimisable :O

Je sais, c'est pour ça que je le poste, c'est pour que vous bossiez aussi [Vous devez être inscrit et connecté pour voir cette image]
Et puis c'est comme pour la traduction du readme, j'ai pas fait ça sérieusement, c'était pour décompresser entre deux séances de révisions, donc j'allais vraiment pas me prendre la tête à réfléchir sur l'optimisation, sinon j'aurais pas beaucoup décompressé

:P je vais y travaillez

maxence : montre nous un peu source ou screen

Désolé je peu pas encore posté de screen j'ai pas accès au PC en ce moment.

Et pour le code c'est pareil, a moins que je ne le recopie. (Le code est horible)

Je vais faire un résumé de mon code:

La fonction "WND( 1, 2, 3)", avec 1 et 2 pour les coordonnees et 3 pour le titre, renvoie un pointeur sur la fenetre créer, comme je l'ai dit on ne peu en creer qu'une seule helas.

La fonction "POS( 1, 2, 3)" avec 1 et 2 pour les coordonnees et 3 un pointeur vers une fenetre, elle change les coordonnees de la fenetre.

La fonction "ADD( 1, 2)", avec 1 et 2 des pointeurs vers des "objets" de ZFENETRE (fenetre, texte etc...), 2 devient l'"enfant" de 1, ou l'"enfant" de son enfant si il en a deja un, enfin vous m'avez compris

La fonction "TEXT( 1)", renvoie un pointeur sur la zone de texte creee.
les "/" dans le texte sont des retours a la ligne lors de l'affichage.

la fonction "AFF( 1)", avec 1 un pointeur vers un objet (fenetre en principe), l'affiche ainsi que tous ses "enfants".

C'est tout pour le moment.
Mais j'ai prevu la fonction "BTN( 1, 2, 3)" avec 1 le texte du bouton, 2 un pointeur vers le cusreur ( pour savoir si il est sur le bouton ou pas ) et 3 l'addresse d'une fonction qui sera appellée lorsque l'on cliqueras sur le bouton.

Le tout en combien d'octets pour l'instant ? [Vous devez être inscrit et connecté pour voir cette image]

Le code source non compilé prend 662 octets pour l'instant.

c'est un peu lourd :O mais pour un debutant sa va

Non compilé ça veut pas dire grand chose... surtout s'il y a des commentaires et toussa.

oui surtout que il y a des routine qui prenne 24 octets en compilé...

donc c'est enorme

Non il y a pas de commentaires, il prend 1155 en compilé, je sais c'est beacoup mais en même temps il y a pas mal de choses dedans et en plus je ne sais pas optimiser l'axe, d'ailleur je n'est pas chercher a l'optimiser.

J'ai eu des problèmes aussi avec les fonctions qui appelent d'autres fonctions, car sa modifiait les "r1", "r2" etc... Donc il en resulte un code immonde comme dit plus haut

au pire donne nous ton code on te diras comment l'optimiser un minimum

Voici donc le screen d'une simple alerte modale donc qui bloque le prgm jusqu'à l'appui sur [2nd] ou [Enter], en 75 octets compilés, et deux lignes de code Axe

Alors c'est sûr, c'est pas très beau, mais en ASM je me suis pas permis de rajouter des fioritures inutiles. Pis vu que c'est qu'une alerte, elle est juste sensée transmettre un message avant de se fermer, donc c'est pas trop grave.

Par contre, fait embêtant, un petit bug subsiste : une fois sur deux alternativement, y'a un bug d'affichage, comme vous pourrez le voir sur le screenshot. J'ai remarqué que c'était lié à l'utilisation de certains shells, donc si vous n'avez aucun shell y'aura pas ce bug.

[Vous devez être inscrit et connecté pour voir cette image]

sa c'est franchement pas mal merci beaucoup tu nous le met quand en telechargement ?

Finalement je l'ai supprimer mais je vais le refaire avec cette fois ci des fonctions qui prennent en argument une Data, comme ça on pourras faire autant de fenetre que souhaité, et ça devrait prendre legerement moins de place.

Je vous envoie le code dés que c'est finit et que j'en ai l'occasion

Ça a l'air très intéressant matref

super maxence

matref, il faut que tu fasse un gros axioms, on a le droit de mettre que 5 axioms par programme, on peut mettre je crois 34 commande au max par axiom et il y a plein de commande non utilisé en axe et par les autre axioms...

On peut mettre maximum 5 axioms de maximum 32 commandes chacun, et ne t'inquiètes pas, j'ai prévu tout plein de fonctions d'ailleurs j'ai prévu d'attaquer les boutons.
Justement, à ce stade je propose une manière de gérer une GUI :

• Je créé une variable GUIstack (qui sera un pointeur statique sur une zone RAM libre quelconque)
  
• Les commandes que je vais faire seront du type Button(...) qui dessineront le widget à l'écran et renverront leurs coordonnées, avec l'abscisse dans L et l'ordonnée dans H. Il faudra stocker ça dans GUIstack, et ça se fera du genre :

  Code:

  Button(...)→{GUIstack}r

• Quand tous les éléments de la GUI seront dessinées, on appellera une fonction Mouse(départX,départY) qui vous permettra de déplacer une souris jusqu'à l'appui sur [2nd] ou [Enter], et qui renvoie les coordonnées lors du clic, avec le même format que les widgets, abscisse → L / ordonnée → H
  
• Ensuite, avec une simple boucle For pour parcourir GUIstack, on pourra voir si la souris a cliqué dans un widget, et réagir en conséquence

Voilà, que pensez-vous de cette gestion ?

Ta gestion est bien pensée je trouve

A la limite tu pourrais faire une fonction qui verifie toute seule si un widget à été cliqué (je ne sais pas si c'est possible j'en demande probablement trop )

Pour les fenetres il seraient bien qu'elles n'est pas forcement de texte, par exemple l'utilisateur pourrais faire quelque chose du genre:

Si la touche clear est préssée, une fenetre avec un bouton "annuler" et un bouton "quitter" apparait.

Sinon je ne vois pas trop quels widget sont indispenssables, à toi de voir

J'ai déjà pensé à faire une fonction qui vérifie toute seule (en fait je l'ai proposée dans mon précédent post avant de l'effacer) mais ça sera très dur ou impossible dans le sens où le bouton doit être activé même si on ne clique pas sur le tout petit pixel d'où il est dessiné, il faut une marge qui est :

Code:

(clicX ≥ boutonX) et (clicX ≤ (boutonX + boutonW)) et (clicY ≥ boutonY) et (clicY ≤ (boutonY+boutonH))

En ASM je ne vois pas du tout comment faire ça (ceci dit ça doit être possible, mais j'y ai pas réfléchi) mais en Axe c'est facile comme tout de modifier les comparaisons comme on veut.

EDIT : oooh je viens de trouver comment utiliser les fonctions de l'Axe via un Axiom ça risque de réduire encore le poids compilé et de faire disparaître les bugs