Deplacer d'une ligne vers le haut un buffer et limite

International Français
1

Bonjour,
imaginons que j’ai un buffer de 80x25, indice commencant de 0 a 24.

si je veux deplacer le buffer d’une ligne vers le haut.

je fais comme ceci:

for (r = 0; r < 25; r++) {

        for (uint16_t c = 0; c < 80; c++) {

            vt->screen[r][c] = vt->screen[r + 1][c];                     

        }               

    }

quand la ligne arrive a 24 j’ai r+1, ce qui donne 25, donc je suis hors gabaris du tableaux ?
comme l’indice va de 0 a 24

comment on peut pour deplacer un buffer d’une ligne vers le haut. ?

une memmove ? ce serai quoi la formule du memmove ? ou est ce que j’aurais le meme probleme de débordement d’indice?

Merci de votre aide.

2

Il faut que r compte de 0 à 23.

Maintenant, il serait peut-être plus judicieux de ne pas déplacer le contenu du buffer ce qui est coûteux en temps de traitement et de faire bouger le pointeur dans le buffer

3

merci du coup je me suis arrêter a 23, c’est deja mieux, sauf que la dernière ligne du tableau, le contenu reste donc quand ca scroll, toutes lignes scrollé affiche la dernière lignes du tableau et si je met a blanc la dernière ligne, des lignes blanche s’affichent, j’ai du oublié un truc.

en fait après le scroll, l’indice de ligne reste toujours sur la dernière, ce qui est logique, quand il y a un saut de ligne, je dois surement remplir la dernière ligne avec la ligne qui contient du texte, je pense que c’est cela.

sinon pour le déplacement avec pointeur c’est sur que c’est mieux, mais dans un premier temps je le fait sans pointeurs, il faut deja que ca fonctionne comme ceci.

4

C’est pour quel types arduino ? Si c’est pour des processeurs 32 bits (pas les uno et mega) vous pourriez utiliser un vecteur de chaînes comme stockage et un index de tête pour représenter la première ligne logique.

Le scroll consiste uniquement à réinitialiser la ligne en tête puis à avancer l’index circulaire.

Aucune donnée n’est déplacée en mémoire et l’accès logique reste constant.

Un truc comme ça (tapé ici donc à vérifier)

#include <vector>
#include <string>

class Tampon {
  size_t nbLignes;
  size_t nbCol;
  std::vector<std::string> lesLignes;
  size_t tete;

public:
  Tampon(size_t nbLignes = 24, size_t nbCol = 80)
  : nbLignes(nbLignes),
    nbCol(nbCol),
    lesLignes(nbLignes, std::string(nbCol, ' ')),
    tete(0) {}

  size_t lignes() const {
    return nbLignes;
  }

  size_t colonnes() const {
    return nbCol;
  }

  void effacerLigne(size_t lig) {
    lesLignes[indexPhys(lig)].assign(nbCol, ' ');
  }

  void definirCar(size_t lig, size_t col, char c) {
    if (lig >= nbLignes || col >= nbCol) return;
    lesLignes[indexPhys(lig)][col] = c;
  }

  char lireCar(size_t lig, size_t col) const {
    if (lig >= nbLignes || col >= nbCol) return 0;
    return lesLignes[indexPhys(lig)][col];
  }

  const std::string& lireLigne(size_t lig) const {
    return lesLignes[indexPhys(lig)];
  }

  void scrollHaut() {
    lesLignes[tete].assign(nbCol, ' ');
    tete = (tete + 1) % nbLignes;
  }

private:
  size_t indexPhys(size_t lig) const {
    return (tete + lig) % nbLignes;
  }
};

Éventuellement d’autres fonctions pour juste ajouter une ligne entière à la fin et ça scroll up automatiquement etc

5

merci pour le code et le principe, dans mon cas je ne peux pas l’utiliser car c’est un terminal vt100 qui reprend le cahier des charges du vt100 et c’est assez compliqué, je vous explique meme pas la complexité, il y a la boucle, la partie process, le parser et le rendu c’est comme cela que fonctionne vt100.

6

Je comprends que le cahier des charges VT100 soit étoffé mais je ne vois pas pourquoi utiliser une classe pour représenter l’écran ne soit pas possible.