1
Bonjour (bonsoir plutot) a tous!
Alors voila: est il possible de copier le contenu de l ecran standart dans le graph buffer? Ou sinon,comment peut on ecrire en grands caracteres sur le graph buffer?
Si vous avez une reponse,je vous remercie d avance! smile
2
L'écran principal (home) ou graphique ?

Pour ce qui est d'écrire en grands caractères directement dans le graph buffer (sans affichage à l'écran donc), il faut utiliser les flags textWrite et fracdrawlfont comme indiqué ici : http://wikiti.brandonw.net/index.php?title=83Plus:BCALLs:4561

Ça donne donc un truc du style (à compiler pour ion) :

	.nolist
#include "ion.inc"
#define	fontflags	50	; généralement non défini dans ion.inc
#define	fracdrawlfont	2	; idem
	.list
#ifdef TI83P
	.org progstart-2
	.db $BB,$6D
#else
	.org progstart
#endif
	ret
	jr nc,start
	.db "Large Font",0
start:
	set textwrite,(IY+sgrflags)	; écrire dans le gbuf
	set fracdrawlfont,(IY+fontflags)	; avec les grands caractères
	ld hl,0
	ld (pencol),hl
	ld hl,text
	bcall _vputs
	call ionFastCopy
	bcall _getkey
	res fracdrawlfont,(IY+fontflags)	; on le désactive car ion ne le fait pas en quittant (pas comme avec textwrite)
	ret

text:
	.db "Hello world",0

	.end

Y'a sûrement moyen de récupérer l'écran graphique, j'vais voir ça smile

edit : Bon déjà tous les shells nettoient les deux écrans à leur lancement donc à moins de faire sans c'est mort je pense... Autrement y'a quelques rom calls sans doute utilisables (_pdspgrph...)
3
C'est obligé de mettre ion pour que ça marche? Parce que j'ai essayé le code suivant, et c'est pas bon:
.NOLIST
#include "ti83asm.inc"
#include "tokens.inc"

.LIST
call _clrlcdfull
call _grbufclr
set textwrite,(IY+sgrflags)
set fracdrawlfont,(IY+fontflags)
ld hl,0
ld (currow),hl
ld hl,TEXTE1
call _puts
res textwrite,(IY+sgrflags)
res fracdrawlfont,(IY+fontflags)
ld hl,1
ld (currow),hl
ld hl,TEXTE2
call _puts
call _getkey
call _grbufcpy_v
ret


TEXTE1: .db "A",0
TEXTE2: .db "B",0 end

Merci d'avance smile
4
Ah c'est pour TI 83 ? Les flags fracdrawlfont et bufferOnly n'existent pas sur ces modèles (82 STATS...)... D'ailleurs lorsqu'en TI-Basic on fait Text(-1,1,1,"test"), ça n'écrit pas en grands caractères comme sur 83+.

Du coup je ne sais pas si c'est faisable facilement... J'vais voir si je trouve quelque chose...

Autrement tu peux faire sans Ion (lancer avec "Send(9" sur 82 STATS/83 ou "Asm(" pour 83+), mais dans ce cas là il faut "unsquisher" le binaire généré par le compilateur (je recommande spasm + Bin2var2 pour Windows ou Bin8x pour Linux).

Par habitude j'utilise toujours ion.inc même s'il lui manque pas mal d'adresses, parce que ça permet de compiler directement pour 83 et 83+, et de toute façons je suis pas sûr que ti83asm.inc soit plus complet... Pour le télécharger : http://www.mirari.fr/ExZw?a=open

Sans grands caractères ça te donnerais un truc du style (textwrite n'affecte pas _puts) :

	.nolist
#define	TI83

#include	"ion.inc"

	.list
	.org $9327	; ne surtout pas oublier l'adresse de départ si on veux que ça marche

start:
	bcall _clrlcdfull	; c'est toujours préférable d'utiliser bcall que call pour les rom calls mais si c'est pas indispensable (pour la compatibilité 83+)
	bcall _grbufclr
	set textwrite,(IY+sgrflags)
	ld hl,0
	ld (pencol),hl
	ld hl,TEXTE1
	bcall _vputs
	ld hl,$0600	; si on met 1 ça écrit par dessus A
	ld (pencol),hl
	ld hl,TEXTE2
	bcall _vputs
	bcall _copygbuf
	bcall _getkey	; c'est mieux de faire la pause après avoir affiché :)
	res textwrite,(IY+sgrflags)
	ret

TEXTE1:
	.db "A",0

TEXTE2:
	.db "B",0

	.end


Pour compiler il faut avoir spasm + bin2var2 ou bin8x dans le même dossier puis créer un fichier texte dont on changera ensuite l’extension en ".bat", avec dedans :

spasm -T -A TEST.z80 TEST.bin
bin2var2 TEST.bin TEST.83p
del TEST.bin >nul
pause


(Le fichier source a alors pour nom TEST.z80)

Je sais pas si c'est assez clair donc n'hésite pas à poser des questions ! smile
5
Merci pour ta réponse wink

En fait, je ne savais pas à quoi sert ion roll , mais j'utilise TASM et OBJ83 pour compiler mes fichiers (on m'avait conseillé comme toi SPASM, mais le fichier que j’obtenais étais inutilisable, je n'ai jamais compris pourquoi.)

Pour le texte en grands caractères, je pensais à la rom call puts, et non vputs (en fait, ce que je veux faire, c'est l'équivalent de la fonction Menu( en ti basic. Au début j'avais pensé à inverser la selection en jouant sur le flag textinverse, mais on m'a fait remarqué que c'est plus simple avec un sprite. Mais... comme on utilise le graph buffer pour ceux ci, dès que je le met à l'écran, tout s'efface sad . C'est pour quoi je veux écrire en grands caractères sur le graph buffer, où à défaut, copier le contenu de l'écran dans le graph buffer, comme ça, le menu ne disparaitra pas lorsque je change la sélection (Heu... je ne sais pas si c'est très clair)

Au pire, je peux toujours écrire en petit, mais ça ne fera pas super, ou revenir sur le textinverse

Merci d'avance si vous avez une autre alternative!

PS: J'ai mis l'adresse de départ dans mon include (flegme zzz )
6
Ah ok tout s'explique smile

Ce que tu veux faire et parfaitement possible, je pensais juste que tu voulais pouvoir écrire en grands caractères n'importe où sur l'écran (au pixel près), or là ça n'a pas d'importance.

Je viens de tomber sur un rom call non référencé par ti83asm.inc, SaveOScreen, qui semble copier l'écran dans le gbuf comme tu veux le faire. Du coup là je termine de modifier l'"ultimate ti83.inc" de BrandonW (qui référence entre autre cet rom call + pas mal d'autres trucs) pour que spasm accepte de le manger et je te fais une archive avec tout ça dedans...

Autrement je ne vois pas pourquoi ce serait plus simple de faire ton menu avec un sprite qu'en inversant la sélection... Surtout qu'il va te falloir ajouter une routine de sprite en plus.
7
Merci beaucoup wink

En fait, c est pas vraiment que c est plus simple, mais plutot que c est plus rapide et que ca prends moins de place (le sprite est rectangulaire,donc si je me debrouille bien, j aurais pas a le mettre en entier (a partir de la deuxieme ligne jusqu a l avant derniere, c est la meme chose (c est aussi l avantage du sprite, j ai pu mettre des bords "arondis"))

En tous cas, encore merci pour ton aide smile
8
De rien, ça fait plaisir de voir un peu de mouvement ici, d'ailleurs n'hésite pas à poster ton code de menu si tu as besoin de conseils/optimisations...

Voilà : http://www.mirari.fr/XxiF

Donc j'ai pas mal nettoyé le fameux "ultimate ti83.inc" (quelques noms de rom calls/adresses + beaucoup d'indentation sick) et ça compile donc nickel happy

Le truc c'est que y'a presque aucune rom call de la TI 83 décrite dans le wikiti donc pour s'y retrouver... Bref j'utilise dans l'exemple suivant _saveoscreen (il existe aussi _savescreen mais je vois pas trop comment l'utiliser), qui copie l'écran à l'adresse savesscreen ($8265) et non pas dans le graph buffer (= plotsscreen = $8E29). On peut par contre restaurer directement l'écran avec _retscreen.

Ça donne donc :

	.nolist
#define	TI83

#include	"ti83.inc"

	.list
	.org $9327

start:
	bcall _clrlcdfull
	bcall _grbufclr
	bcall _homeup
	set textInverse, (IY + textFlags)
	ld hl,menu_str
	bcall _puts
	res textInverse, (IY + textFlags)
	bcall _newline
	ld hl,menu_opt1_str
	bcall _puts
	bcall _newline
	ld hl,menu_opt2_str
	bcall _puts
	bcall _newline
	ld hl,menu_opt3_str
	bcall _puts
	bcall _saveoscreen
	bcall _clrlcdfull
	ld hl,savesscreen	;\
	ld de,gbuf		; Ici on copie les données de savesscreen vers gbuf
	ld bc,768		;  /      
	ldir			; /
	bcall _copygbuf
	bcall _getkey
	ret

menu_str:
	.db $f1,$f1,$f1,"Super Menu",$f1,$f1,$f1,0

menu_opt1_str:
	.db "1",$e4,"Nouveau",0

menu_opt2_str:
	.db "2",$e4,"Charger",0

menu_opt3_str:
	.db "3",$e4,"Quitter",0

	.end

Pour la commande "ldir" si jamais t'as besoin d'en savoir plus : http://www.mworld.fr/html/projects/calc/ti-82/tutoriel/progasm/guide/lesson18.html

Autrement dans l'archive, pour compiler il suffit de cliquer sur "compiler.bat" smile
9
J'ai fait une routine de menu rapide juste pour te montrer que c'est pas forcément plus lent et gros de faire qu'avec du texte plutôt qu'avec des sprites (enfin après tu fais comme tu veux smile) :

chcm

Code source + binaire : http://www.mirari.fr/dJ5d

	.nolist
#define	TI83

#include	"ti83.inc"

	.list
	.org $9327

start:
	bcall _runIndicOff
	ld hl,menu_str
	ld (menu_title),hl
	ld a,3
	ld (menu_nb_options),a
	ld hl,menu_opt1_str
	ld (menu_option1),hl
	ld hl,new_game
	ld (menu_option1_goto),hl
	ld hl,menu_opt2_str
	ld (menu_option2),hl
	ld hl,load_game
	ld (menu_option2_goto),hl
	ld hl,menu_opt3_str
	ld (menu_option3),hl
	ld hl,exit
	ld (menu_option3_goto),hl
	jr menu

new_game:
	bcall _clrlcdfull
	ld hl,menu_opt1_str
	bjump _puts

load_game:
	bcall _clrlcdfull
	ld hl,menu_opt2_str
	bjump _puts

exit:
	bcall _clrlcdfull
	ld hl,menu_opt3_str
	bjump _puts

menu_str:
	.db $f1,$f1,$f1,"Super Menu",$f1,$f1,$f1,0

menu_opt1_str:
	.db "    Nouveau     ",0

menu_opt2_str:
	.db "    Charger     ",0

menu_opt3_str:
	.db "    Quitter     ",0

;------------Routine------------

menu:
	bcall _clrlcdfull
	xor a
	ld (menu_cur_pos),a

menu2:
	bcall _homeup
	set textInverse,(IY+textFlags)
menu_title = $+1
	ld hl,0
	bcall _puts
	res textInverse,(IY+textFlags)
	bcall _homeup
	bcall _newline
	bcall _newline
menu_nb_options = $+1
	ld b,0
	ld hl,menu_option1

menu_loop:
	push bc
	ld a,(curcol)
	or a
	bcallnz _newline
	ld a,(menu_nb_options)
	sub b
	ld b,a
menu_cur_pos = $+1
	ld a,0
	cp b
	call z,menu_inverse_cur
	call nz,menu_reset_cur
	push hl
	bcall _ldHLind
	bcall _puts
	pop hl
	inc hl
	inc hl
	inc hl
	inc hl
	pop bc
	djnz menu_loop

menu_getkey_loop:
	ld a,$fe
	out (1),a
	in a,(1)
	bit 0,a
	jr z,menu_inc_cur
	bit 3,a
	jr z,menu_dec_cur

	ld a,$bf
	out (1),a
	in a,(1)
	bit 5,a
	jr z,menu_valid
	jr menu_getkey_loop

menu_inc_cur:
	ld a,(menu_nb_options)
	dec a
	ld b,a
	ld hl,menu_cur_pos
	ld a,(hl)
	cp b
	jr z,menu_getkey_loop
	inc (hl)
	bcall _lcd_busy
	jr menu2

menu_dec_cur:
	ld hl,menu_cur_pos
	ld a,(hl)
	or a
	jr z,menu_getkey_loop
	dec (hl)
	bcall _lcd_busy
	jr menu2

menu_valid:
	res textInverse,(IY+textFlags)
	ld hl,menu_option1+2
	ld d,0
	ld e,4
	ld a,(menu_cur_pos)
	inc a
	ld b,a

menu_valid_loop:
	add hl,de
	djnz menu_valid_loop
	or a
	sbc hl,de
	bcall _ldHLind
	jp (hl)

menu_inverse_cur:
	set textInverse,(IY+textFlags)
	ret

menu_reset_cur:
	res textInverse,(IY+textFlags)
	ret

menu_option1:\	.dw 0\menu_option1_goto:\	.dw 0
menu_option2:\	.dw 0\menu_option2_goto:\	.dw 0
menu_option3:\	.dw 0\menu_option3_goto:\	.dw 0
menu_option4:\	.dw 0\menu_option4_goto:\	.dw 0
menu_option5:\	.dw 0\menu_option5_goto:\	.dw 0
menu_option6:\	.dw 0\menu_option6_goto:\	.dw 0

	.end

C'est pas forcément très compliqué, en fait la routine prend en "paramètres" les textes du titre et des options ainsi que les adresses des labels liés à celles-ci et se charge de tout gérer (déplacements, getkey en direct input...).

Autrement la routine _ldHLind est absolument à connaitre pour comprendre le code, et pour le reste n'hésite pas à poser des questions si c'est pas assez explicite.
Pour sauvegarder l'écran, tu peux utiliser comme base la routine d'ion:
fastCopy:
 di
 ld a,$80
 out ($10),a
 ld hl,gbuf-12-(-(12*64)+1)
 ld a,$20
 ld c,a
 inc hl
 dec hl
fastCopyAgain:
 ld b,64
 inc c
 ld de,-(12*64)+1
 out ($10),a
 add hl,de
 ld de,10
fastCopyLoop:
 add hl,de
 inc hl
 inc hl
 inc de
 ld a,(hl) ;!!!!!!!!!!!!!!!!!
 out ($11),a ;!!!!!!!!!!!!!!!!!!
 dec de
 djnz fastCopyLoop
 ld a,c
 cp $2B+1
 jr nz,fastCopyAgain
 ret

...mais en lieu de "ld a,(hl) / out ($11),a" je crois qu'il suffit de changer l'ordre: "in a,($11) / ld (hl),a" (lire l'octet qui est affiché sur l'écran et mettre cette valeur dans (hl)). Ça on pourra le sauvegarder ou tu voudras et d'ailleurs il sera sûrement plus rapide que le bcall (et n'occupe guère d'espace).

Mais, pourquoi veux-tu faire ça ?

Si tu veux afficher du texte grand pour le 83/82 Stats, je crois qu'il te faudra écrire ta propre routine de texte (et dessiner tes propres sprites pour les lettres). En utilisant les routines de sprites d'ion ou n'importe quelle autre, il ne serait pas très difficile de faire et serait de la bonne practice wink

EDIT: Et pour ajouter au programme de deeph, tu pourrais faire qu'on continue à afficher du texte jusqu'à ce qu'on lira un certain octet, comme $FF par exemple. Le boucle serait quelque chose comme ci:

 ld hl,menu_start
 xor a   ;a = notre counter, nombre d'options
loop:
;il faut ajouter le code pour gérer le counter quelque part
 bcall _PutS
;... verifier si le prochain octet = $FF
 ld b,(hl)  ;valeur du prochain octet
 inc b  ;$FF + $01 = .. 0!
 jr nz,loop ;si z n'est pas armé, nous avons plus à afficher
;..

menu_start:
	.db "    Nouveau     ",0 
	.db "    Charger     ",0 
	.db "    Quitter     ",0
Merci beaucoup pour votre aide! smile