fond en gris clair - Page 1

voila je voudrais mettre un fond gris clair derriere mon tableau de mendeliev j'ai essaye qq truc avec setplane et tout ca j'y suis pas arriver voila ma syntax:
void _main(void)
{
short xx=53;
short yy=12;
short l=0;
short key=0;
char *element[]={"Hydrogene","Lithium","Sodium","Potassium","Rubidium","Cesium","Francium","Beryllium","Magnesium","Calcium"
,"Strontium","Baryum","Radium","Scandium","Yttrium","Lanthanides","Actinides","Titane"
,"Zirconium","Hafnium","lanthane","actinium","Vanadium","Niobium","Tantale","Cerium"
,"Thorium","Chrome","Molybdene","Tungstene","Praseodyme","Protactinium","Manganese"
,"Technetium","Rhenium","Neodyme","Uranium","Fer","Ruthenium","Osmium","Promethium"
,"Neptunium","Cobalt","Rhodium","Iridium","Samarium","Plutonium","Nickel","Palladium","Platine","Europium","Americium"
,"Cuivre","Argent","Or","Gadolinium","Curium","Zinc","Cadmium","Mercure","Terbium","Berkelium","Bore","Aluminium"
,"Gallium","Indium","Thallium","Dysprosium","Californium","Carbone","Silicium","Germanium","Etain","Plomb","Holmium"
,"Einsteinium","Azote","Phosphore","Arsenic","Antimoine","Bismuth","Erbium","Fermium","Oxygene","Soufre","Selenium","Tellure"
,"Polonium","Thullium","Mendelevium","Fluor","Chlore","Brome","Iode","Astate","Ytterbium","Nobelium","helium","Neon"
,"Argon","krypton","Xenon","radon","Lutetium","Lawrencium"};
char *electron[]={"1","3","11","19","37","55","87","4","12","20","38","56","88","21","39","55 à 71","89 à 103","22","40","72","57","89","23","41"
,"73","58","90","24","42","74","59","91","25","43","75","60","92","26","44","76","61","93","27","45","77","62","94","28","46"
,"78","63","95","29","47","79","64","96","30","48","80","65","97","5","13","31","49","81","66","98","6","14","32","50","82","67"
,"99","7","15","33","51","83","68","100","8","16","34","52","84","69","101","9","17","35","53","85","70","102","2","10","18","36","54"
,"86","71","103"};
static unsigned long sprite1[]={ 0xF8000000, 0x88000000, 0x88000000, 0x88000000, 0xFF800000,
0x88800000, 0x88800000, 0x88800000, 0xFF800000, 0x88800000, 0x88800000, 0x88800000, 0xFFFFFFF8,
0x88888888, 0x88888888, 0x88888888, 0xFFFFFFF8, 0x88888888, 0x88888888, 0x88888888, 0xFFFFFFF8,
0x88888888, 0x88888888, 0x88888888, 0xFFFFFFF8, 0x88880000, 0x88880000, 0x88880000, 0xFFF80000,
0x0, 0x0, 0x0};
static unsigned long sprite2[]={ 0xF8, 0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 0xFFFFFFF8, 0x88888888,
0x88888888, 0x88888888, 0xFFFFFFF8, 0x88888888, 0x88888888, 0x88888888, 0xFFFFFFF8, 0x88888888,
0x88888888, 0x88888888, 0xFFFFFFF8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
static unsigned long sprite3[]={ 0xF800, 0x8800, 0x8800, 0x8800, 0xFFFFF800, 0x88888800, 0x88888800,
0x88888800, 0xFFFFF800, 0x88888800, 0x88888800, 0x88888800, 0xFFFFF800, 0x88888800, 0x88888800,
0x88888800, 0xFFFFF800, 0x88888800, 0x88888800, 0x88888800, 0xFFFFF800, 0x88888800, 0x88888800,
0x88888800, 0xFFFFF800, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
static unsigned char curseur1[]={ 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0x0, 0x0, 0x0};

clrscr();
Sprite8(12,53,8,curseur1,LCD_MEM,SPRT_OR);
Sprite32(12,53,32,sprite1,LCD_MEM,SPRT_OR);
Sprite32(40,57,32,sprite2,LCD_MEM,SPRT_OR);
Sprite32(68,53,32,sprite3,LCD_MEM,SPRT_OR);
FontSetSys(F_4x6);
DrawStr(90, 40, element[l], A_NORMAL);
DrawStr(135, 60, electron[l], A_NORMAL);

do
{
switch(key)
{
case 344:
if(xx==53)
{
if(yy>=12)
break;
else
{
yy+=4;
l+=6;
break;
}
}
else if(xx>=75)
{
if(yy>=23)
break;
else
{
yy+=4;
l+=6;
break;
}
}
else
{
yy+=4;
l+=6;
break;
}

case 338:
if(yy<=12)
break;
else
{
yy-=4;
l-=6;
break;
}

case 340:
if(xx>=74)
{
if(yy<=22)
break;
else
{
xx+=4;
l++;
break;
}
}
else
{
xx+=4;
l++;
break;
}

case 337:
if(xx<=53)
break;
else if(xx<=58)
{
if(yy==22)
break;
else
{
xx-=4;
l--;
break;
}
}
else
{
xx-=4;
l--;
break;
}

}
clrscr();
Sprite8(yy,xx,8,curseur1,LCD_MEM,SPRT_OR);
Sprite32(12,53,32,sprite1,LCD_MEM,SPRT_OR);
Sprite32(40,57,32,sprite2,LCD_MEM,SPRT_OR);
Sprite32(68,53,32,sprite3,LCD_MEM,SPRT_OR);
FontSetSys(F_4x6);
DrawStr(90, 40, element[l], A_NORMAL);
DrawStr(135, 60, electron[l], A_NORMAL);
key=ngetchx();
}
while(key!=264);
ClrScr();
ST_showHelp("salut")

Ben déjà revois tes tableaux de pointeurs, c'est énorme ce que tu fais, 4 octets par pointeur plus toutes ces chaines, à ta place je ferais plutôt un tableau de chaine, quite à ce qu'il y en ait de plus petite ou de plus grande, on pert un peu de place mais pas autant qu'avec tous ces pointeurs je pense.

char element[][nbre_lettre_max+1]= { "Hydrogene",
                                     "Lithium  ",
                                     "Sodium   ", 
                                     ... };

Sinon essais plutôt avec un memcpy() pour ton fond.

style

memcpy(Getplane(LIGHT_PLANE), (char *)boite_tt_noire, 3840); // avec que des {0xFF, 0xFF ...} pour la def de boite_tt_noire, recopié sur le plan clair, ça donnera à l'affichage un fond gris normalement.

C'est ça ou je me gourre (ce qui est fort possible ) ??

et pkoi pas un memset ?

ah oui, j'y avais pas pensé

memset(GetPlane(LIGHT_PLANE), 0xFF, 3840);

corrigé ;-)

juste pour savoir: ca serait pas mieux (nivo place) de déclarer les electron en int plutot qu'en char ( int electron[]={1,3,11,19,37,55,...}; )?

heu, s'il fait ça, c'est parce que ce sont des chaines de caractères, qu'il affiche avec DrawStr surement, donc il doit garder le type char.
Mais à sa place j'aurais plutôt tout mis en usnigned char, et PAS en chaine !

unsigned char element[]={1,3,11, ...}; que j'afficherai avec

printf_xy(x, y, "%d", element[i]);

ok, printf_xy est pas très rapide, mais son prog n'a pas besoin de bcp de rapidité non plus, avec ma méthode il économiserait bcp de place !

OK MERCI JE V essaye

il me met :
"undefined reference to Getplane"
ca veut dire quoi

-

ouai, c'est plus du ti-basic ni du pascal...

ok pour la compilation ca a marche je v voir sur ti
sur ti ca me met pas de fond gris mais seulement qq ligne vertical
syntax:
memset(GetPlane(LIGHT_PLANE),1,3840);

Ben si ton prog ne gère pas les niveau de gris, tu es mal pour le fond gris clair ! lis le tuto de squale sur les niveau de gris (GrayOn(), GrayOff() ect ...)

et ensuite la méthode du memset() devrait marcher.

memset(GetPlane(LIGHT_PLANE), 0xFFFF, 3840);

si tu met 1 en 2ème param, ça fait 0b0000000000000001
si tu met 0xFFFF, ça fait 0b1111111111111111 => si tu veux tout en gris clair, c ce qu'il faut mettre

erf, en effet , j'avais pas pensé à ça

squale : 3840 => nbre de "char" pour le buffer, alors que toi, tu donnes 0xFFFF, qui corresponds à un "int".

memset(GetPlane(LIGHT_PLANE), 0xFF, 3840); plutôt non ?

Si je me fie à la doc de TIGCC :

memset Function (ROM Call 0x27C)

--------------------------------------------------------------------------------
mem.h, string.h

void *memset (void *buffer, short c, unsigned long num);


Sets num bytes of buffer to byte c.

memset sets the first num bytes of the array buffer to the character c. memset is faster than _memset, because it sets a memory in a 4-byte chunks as long as possible. memset returns buffer.

3840 = nombre d'octets que je mettre à 0xFF.
0xFFFF = valeur de ce à quoi je veux mettre.
cela dit, c vrai que c ambigue...
faudrait que je teste

erf, j'ai pas tout compris ta démarche là

c tordu

c doit être un short...
mais num correspond au nombre d'octets... (donc, de char)
faudrait que je teste pr voir comment ça marche

cela dit, vu que c est un short d'après le prototype, mettre 0xFFFF ne posera pas de problème, et ça sera plus prudent (on ne sait pas si memset prend l'octet de poids fort ou l'octet de poids faible ou une moyenne, ou autre chose de c !!!)

erf

La documentation le dit très bien : "Sets num bytes of buffer to byte c." => la valeur est considérée sur 8 bits.

Si le prototype est déclaré de façon que c soit considéré comme un short, c'est dans un souci d'optimisation : il est (ça peut paraître paradoxal) plus rapide d'empiler un short que d'empiler un char.

Quand tu écris memset(GetPlane(LIGHT_PLANE), 0xFF, 3840), le compilateur étend à la compilation (donc il n'y a pas de perte de vitesse à l'exécution) 0xFF sur 16 bits. Mais la fonction ne lira que les 8 premiers.

Explication :
* si c était de type char, le compilo générerait pour le passage de 0xFF : subq.l #2,a7 / move.b #$FF,1(a7)
* avec c de type short, le compilo génère pour le passage de 0xFF : move.w #$FFFF,-(a7)

arf...
OK.

(faudrait que je me documente un peu plus sur la théorie des compilateurs )

Idem
Thibaut a plus l'habitude vu qu'il a fait Azur , je lui fais confiance.

Empiler un char ou empiler un short revient exactement au même normalement. Si le prototype de memset dit short, c'est parce que c'est ce que le standard ANSI demande (en fait, il demande int, mais on met short parce qu'il y a le switch -mlong).

Non le code de passage est différent il me semble !