Forum Graph100

génial ! ça c'est bien foutu !

bon bah je vais me mettre au getch alors ! (il marche au moin celui là ?)

en fai le mieu C de créer ta propre fonction ki joue le role de scanf...pa le choix lol!

Ah oui c'est toujours difficile d'apprendre ça au début Mais on est tous passé par là

Bonjour,

Désolé d'en remettre une couche sur le scanf() mais étant débutant dans la programmation de graph100 j'ai deja passé un peu de temps et eu un peu de mal a creer un executable qui m'affiche qqc sur l'ecran de la calto et je voulais savoir si qqun avait créé une fonction scanf() utilisable parce que malgré la lecture de plusieurs tuto je ne vois pas vraiment comment gérer ca.
Merci d'avance et bravo pour ce forum ca aide bien quand on débute!

n'y t'il pas ENTER.COM ki donne accès a certaines touches ? j'aimerais bien avoir le code source de ce programme pour remapper certaines touche...

ca m'arrangerais d'avoir accès à iostream completement kan meme ^^

Je viens de lire l'aide de db-lib mais (d'apres ce que j'ai suivi) le getkey ne fait que renvoyer le code de la touche comme la fonction basic or ce que je recherche (c'est pour une gestion de texte donc aucun besoin de vitesse) c'est une fonction scanf (avec affichage du texte saisi) mais utilisable parce que d'apres ce que j'ai testé les lettres du pavé numérique ne sont pas accessibles et le exe ne fonctionne pas non plus.
Voila, est ce que vous savez si ca existe ou est ce que vous avez d'autres conseil (l'utilisation de db-lib me parait assez obscure).
Merci.

:!: Pour les pressés, voir en bas :!:

j'avais créer une suite de fonction pour un explorateur afin de traiter l'ensemble des caracteres utiles..
La démarche, déjà, c'est de créer les choses suivantes:

#define MODE_NUM 0
#define MODE_ALPHA 1
#define MODE_alpha 2
// Eventuellement un autre mode?
char getchar2(int mode);

// Remplacer les ? par des valeurs non utilisées dans les caracteres courants (voir une table ascii)
#define GETCHAR_DELETE ?
#define GETCHAR_INSERT ?
#define GETCHAR_SHIFT ?
#define GETCHAR_ALPHA ?
#define GETCHAR_ESC ?
#define GETCHAR_ENTER ?
// Eventuellement d'autres, pour les F1-F6 par exemple?

Ta fonction getchar2, ce qu'elle doit faire:
>Elle doit absolument attendre la pression d'une touche!
>Elle doit convertir le code de pression de cette touche en char, le moyen le plus facile à mon gout étant une table de correspondance
>Elle doit prendre en compte le mode passé en parametre (exemple, si on appuie sur la touche [7, M]: MODE_ALPHA te donne 'M', MODE_NUM te donne '7', MODE_alpha te donne 'm', etc)

Comment faire alors?
Getkey de DB-LIB renvoie une valeur correspondant à une certaine touche pressée. Faut aller donc jeter un oeil pour connaitre à quoi correspond telle valeur. Ensuite, le moyen le plus rapide et surement le plus économique en mémoire, est de créer une table correspondante à 2 dimensions qui renvoie un char:

// Combien de mode a t on? 
#define NOMBRE_DE_MODE 3
// Valeur maximale renvoyée par Getkey (dans son utilisation courante!)
#define GETKEY_MAX 106
char getchar2_table[NOMBRE_DE_MODE][GETKEY_MAX]=
{
  // La on remplit avec les char correspondants!
  // Mode Numérique
  {
    // ...
  },
  // Mode Alphanumérique, Majuscule
  {
    // ...
  },
  // Mode Alphanumérique, Minuscule
  {
    // ...
  },
  // Eventuellement un autre mode? 
};

Ainsi, le code source de ton getchar2 devient:

char getchar2(int mode)
{
  // Eventuellement un ti contrôle d'erreur au cas ou?
  return getchar2_table[mode][Getkey(WAIT_KEY) - 1];
}

(ptit postage au cas ou)

Bon maintenant, qu'est ce qu'il te faut, une fonction du genre scanf?
Si j'me souviens bien, scanf et sscanf font exactement la meme chose, à l'exception que scanf prend de l'entrée standard (qui déconne un poil sur G100) et sscanf... d'une chaine de caractere!!
Attention toutefois, sscanf prends pas mal de ressources (on pourrait la refaire en simplifiée, notemment sans nos cheres floating point)!!

Mais admettons qu'on utilise sscanf.
Le but, c'est d'avoir une chaine de caractere non?
Mais nous, on ne peut avoir, avec getchar2, que 1 seul caractere... Et bin puisqu'une chaine de caractere c'est une mise bout-à-bout de caractere, c'est c'qu'on va devoir faire pour la construire ^^

Notre fonction sera alors:

char *getstring(int *mode);

le parametre mode, c'est pour indiquer le mode dans lequel on sera par défaut (ça le fait toujours, si l'utilisateur retrouve son mode ) (note: fucking smiley qui m'a ramenné tout en haut <_<') La variable pointée par mode sera modifiée au cas ou et utilisée dans tout les cas.

Cette fonction renvoie un pointeur de type char. Parfait pour une chaine, mais comment le stocker? Ce qu'on pourrait faire, c'est l'allouer dynamiquement à chaque fois, mais... ça pose un soucis car faut libérer la mémoire ainsi allouée et c'est souvent ce qu'on peut oublier (comme sur G100 on en a pas des masses, on va éviter).
Donc la meilleure solution reste, je pense, un tableau de char déclaré comme ceci:

// Nombre de caracteres maximum pour la chinae
#define GETSTRING_MAXBUFFER 128
char getstring_buffer[GETSTRING_MAXBUFFER];

à déclarer en variable globale, ou statique si on la met dans la fonction, car cet espace mémoire doit absolument rester valide!!

Bon maintenant, voyons la fonction getstring...
Que doit-elle faire?
>Elle doit retourner la chaine, c'est le but. Facile, il suffit de toujours retourner getstring_buffer!
>Elle doit capter les caracteres tapés par l'utilisateur. Notre fonction getchar2 permet de le faire très facilement.
>Elle doit analyser le caractere renvoyé pour savoir ce qu'il faut faire: si c'est GETCHAR_DELETE, elle doit reculer d'un caractere SI POSSIBLE, si c'est 'm' elle doit rajouter 'm' dans la chaine SI POSSIBLE et avancer d'un caractere, si c'est GETCHAR_ENTER, elle doit terminer la chaine par un NULL et la renvoyer, si c'est GETCHAR_ESCAPE, peut etre qu'elle doit effacer la chaine, la terminer par un NULL et la renvoyer aussi? etc, c'est limité par ce qu'on veut ^^
>Eventuellement, si taper afficher quelque chose à l'écran, il faut le faire pendant l'analyse de la chaine!

Comment faire tout ceci?
>Déjà, excepté si l'on appuie sur [EXE], [ESC] ou tout autre touche, la fonction ne doit pas quitter. L'emploi d'une boucle do-while est donc justifié dans ce cas précis.
>Ensuite, on doit garder une trace du caractere renvoyé par getchar2 tout au long de son analyse, y compris pour sortir de la boucle! donc une variable de type char est la bienvenue ici.
>Le mode doit etre stocké pour pouvoir le modifier et l'utiliser, bien entendu.
>L'analyse de ce caractere dépend de ce qu'on veux en faire, mais généralement, le mieux est d'utiliser une construction de type switch-case et d'analyser les cas spéciaux: GETCHAR_ENTER, GETCHAR_DELETE, etc... Enfin, si le caractere n'est pas compris dans ces cas spéciaux(donc dans le cas default), c'est que c'est juste un caractere à rajouter!
> Rajouter les caracteres aux fur et à mesure, éventuellement reculer.. Un index parcourant notre buffer est ok pour ce genre de chose, un pointeur idéal. Il suffira d'incrémenter lorsqu'on rajoute, et de décrémenter lorsqu'on supprimer. SI POSSIBLE, hein...
>J'ai insisté sur les SI POSSIBLE parce que c'est vraiment important si on veut éviter d'écraser la mémoire! en effet, si on est au tout début de notre buffer, on ne peut pas reculer!! et si on est à la fin, on ne peut rien rajouter! attention parce que si le buffer est de 128 caracteres, la chaine ne contiendra que 127 caracteres puisque le dernier est réservé au NULL terminal.

Ce qui devrait nous donner une fonction comme ceci:

char *getstring(int *mode)
{
  char *scan;
  char character;
  
  scan= getstring_buffer;
  do
  {
    character= getchar2(*mode);
    switch(character)
    {
    case GETSTRING_ENTER:
      // On termine la chaine par un NULL
      (*scan)= NULL;
      break;
    case GETSTRING_DELETE:
      // Si on est pas au début de la chaine, alors on revient d'un cran en
      // arriere
      if (scan > getstring_buffer)
      {
        scan--;
        // Ici, on efface le caractere précédent affiché sur l'écran!
        // ...
      }
      break;
    case GETSTRING_ESCAPE:
      // On débute la chaine par un NULL pour ne rien renvoyer
      getstring_buffer[0]= NULL;
      break;
    default:
      // Dans tout les autres cas, on rajoute le caractere si possible!
      if (scan < getstring_buffer + GETSTRING_MAXBUFFER - 1)
      {
        (*scan)= character;
        scan++;
        // On affiche le caractere à l'écran!
        // ..
      }
      break;
  }
  while ((character != GETSTRING_ENTER) &&
    (character != GETSTRING_ESCAPE));
}

Voila, j'espere que je t'ai éclairé l'esprit!!

(Nota: il se peut que des erreurs NE SE SOIENT PAS glissées dans ce code aux lecteurs de ce topic de bien l'analyser et d'en comprendre le bon fonctionnement avant de le mettre en oeuvre!)

(Nota2: un modo devrait bouger ce topic en Techniques de Programmation j'pense!)

:!: Pour les pressés, voir en haut :!:

Merci pour ce post fleuve auquel j'ai a peu pres compris tout (bon ok j'ai pas encore trop regardé le code) je vais essayer de coder ca et on verra ce que ca donne....