IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

[mode console sous windows xp] MAJ dynamique d'un tableau


Sujet :

C

  1. #1
    Membre éprouvé
    Profil pro
    Inscrit en
    Septembre 2009
    Messages
    1 821
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2009
    Messages : 1 821
    Points : 979
    Points
    979
    Par défaut [mode console sous windows xp] MAJ dynamique d'un tableau
    Bonjours,

    J'ai fait un petit programme sous windows xp en mode console.
    Je voudrais afficher un tableau dynamique : c'est à dire que sur certains événements de nouvelles lignes soient ajoutées et que sur d'autres évènements, certains champs du tableau soient modifiés.

    Pour ajouter des nouvelles lignes, rien de bien compliqué, il suffit de continuer à écrire dans le flux de sortie standard mais comment faut-il faire pour modifier mes champs ?

    Remarque : je cherche une méthode la plus simple possible et rapide à mettre en place : pas besoins que l'affichage soit parfait (ex : pas besoin de gérer la taille de l'écran) car c'est un programme pour faire du debug et qu'il ne sera utilisé que par moi.

    Merci d'avance,

  2. #2
    Expert éminent sénior
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Points : 13 926
    Points
    13 926
    Par défaut
    Tu n'es pas assez précis sur ton problème pour avoir des réponses pertinentes.
    Ton tableau dynamique est un tableau de quoi ? Est-il de taille fixe ou non ? Qu'est-ce que tu appelles un "champ" du tableau ? Quel genre de modification doivent-ils subir ?
    Quel rapport entre ce tableau et les lignes affichées ?
    Publication : Concepts en C

    Mon avatar : Glenn Gould

    --------------------------------------------------------------------------
    Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !

  3. #3
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Juin 2009
    Messages
    4 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : Juin 2009
    Messages : 4 481
    Points : 13 679
    Points
    13 679
    Billets dans le blog
    1
    Par défaut
    A partir du moment où tu as écris quelque chose dans la console, tu ne peux pas le modifier. Il faut revenir en arrière et écraser ce que tu as écrit précédemment.

  4. #4
    Membre éprouvé
    Profil pro
    Inscrit en
    Septembre 2009
    Messages
    1 821
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2009
    Messages : 1 821
    Points : 979
    Points
    979
    Par défaut
    bonjour,

    Mon tableau à un nombre de colonnes fixes mais des lignes peuvent être ajoutées pendant le processus

    Les cases des premières colonnes ont des valeurs des valeurs fixes et la dernière case est un compteur qui doit être mis régulièrement à jour.

    J'ai réussi à résoudre le problème en me faisant une petite library : on peut enregistrer à un moment donné la position du curseur puis le replacer pas la suite à l'endroit enregistré
    => ça à l'air de bien fonctionner (mais je ne sais pas si a marche si le buffer de la console est plein => de combien est-il d’ailleurs ? la valeur est fixe ou paramétrable ?)

    Aussi est-il possible de cacher le curseur ? car ça fait moche pensant la mise à jour des champs, on voit le curseur se balader de partout...
    Est-il possible de détecter/récupérer le changement de taille de la fenêtre de la console ?
    Est-il possible au démarrage de l'application de forcer la taille de la console pour être sur que mon tableau soit affichable ?


    Fichier .h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
     
    #ifndef _CONSOLE_H
    #define _CONSOLE_H
     
    #include <stdarg.h>
     
    #define  CONSOLE_INPUT_BUF_SIZE 500
     
     
    typedef enum _CONSOLE_ECHO_MODE {
        CONSOLE_ECHO_MODE_NORMAL = 0,
        CONSOLE_ECHO_MODE_DONT_ECHO
    } CONSOLE_ECHO_MODE;
     
    typedef struct _CONSOLE_CURSOR {
        unsigned int x;
        unsigned int y;
    } CONSOLE_CURSOR;
     
     
    typedef struct _CONSOLE_STRUCT {
     
        CONSOLE_ECHO_MODE echoMode;
        CONSOLE_CURSOR cursor;
     
        struct {
            unsigned int width;
            unsigned int high;
        } screen;
     
        char inputBuf[CONSOLE_INPUT_BUF_SIZE];
     
    } CONSOLE_STRUCT;
     
     
    void console_init(CONSOLE_STRUCT *console);
    void console_putch(CONSOLE_STRUCT *console, char c);
    void console_puts(CONSOLE_STRUCT *console, const char *str);
    int console_vsnprintf(CONSOLE_STRUCT *console, int maxsize, const char *fmt, va_list arg_ptr);
    int console_vsprintf(CONSOLE_STRUCT *console, const char *fmt, va_list arg_ptr);
    int console_printf(CONSOLE_STRUCT *console, const char *fmt, ...);
    void console_scanf(CONSOLE_STRUCT *console, const char *fmt, ...);
    void console_getCursorPosition(const CONSOLE_STRUCT *console, CONSOLE_CURSOR *cursor);
    void console_setCursorPosition(CONSOLE_STRUCT *console, const CONSOLE_CURSOR *cursor);
    void console_overwriteField(CONSOLE_STRUCT *console, const CONSOLE_CURSOR *cursor, int len, const char *fmt, ...);
     
    #endif
    Fichier .c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
     
    #include "console.h"
     
    #include <stdio.h>
    #include <windows.h>
     
    // pour la gestion du curseur dans la console
     
    //#define CONSOLE_DISABLE_OUTPUT // si non commenté, ça bloque les focntions d'affichage
     
     
    void console_init(CONSOLE_STRUCT *console){
        console->screen.width = 80;
        console->screen.high = 25;
     
        console->cursor.x = 0;
        console->cursor.y = 0;
     
        console->echoMode = CONSOLE_ECHO_MODE_NORMAL;
        console->inputBuf[0] = '\0';
    }
     
    void console_putch(CONSOLE_STRUCT *console, char c){
     
        switch (c){
            case '\r':
                console->cursor.x = 0;
                break;
     
            case '\n':
                console->cursor.x = 0;
                console->cursor.y++;
                break;
     
            default:
                console->cursor.x++;
                if(console->cursor.x >= console->screen.width){
                    console->cursor.x = 0;
                    console->cursor.y++;
                }
                break;
     
        }
     
        if(console->echoMode == CONSOLE_ECHO_MODE_NORMAL){
            #ifndef CONSOLE_DISABLE_OUTPUT
            putc (c, stdout);
            #endif
        }
     
    }
     
    void console_puts(CONSOLE_STRUCT *console, const char *str){
     
        while(*str != '\0'){
            console_putch(console, *str);
            str++;
        }
     
    }
     
     
    int console_vsnprintf(CONSOLE_STRUCT *console, int maxsize, const char *fmt, va_list arg_ptr){
     
        int len;
     
        if(maxsize > CONSOLE_INPUT_BUF_SIZE){
            maxsize = CONSOLE_INPUT_BUF_SIZE;
        }
     
    	len = vsnprintf(console->inputBuf, maxsize, fmt, arg_ptr);
     
        console_puts(console, console->inputBuf);
        return len;
    }
     
     
    int console_vsprintf(CONSOLE_STRUCT *console, const char *fmt, va_list arg_ptr){
     
        int len;
    	len = console_vsnprintf(console, CONSOLE_INPUT_BUF_SIZE, fmt, arg_ptr);
        return len;
    }
     
     
    int console_printf(CONSOLE_STRUCT *console, const char *fmt, ...){
     
    	va_list arg_ptr;
        int len;
     
    	va_start(arg_ptr, fmt);
    	len = console_vsprintf(console, fmt, arg_ptr);
    	va_end(arg_ptr);
     
        return len;
    }
     
     
    // il faut gérer le scanf car sinon lorsqu'on appuye sur la touche entrée, le '\n' n'est pas prix en compte
    void console_scanf(CONSOLE_STRUCT *console, const char *fmt, ...){
     
    	va_list arg_ptr;
     
        if(fgets(console->inputBuf, CONSOLE_INPUT_BUF_SIZE, stdin) == NULL){
            return;
        }
     
        console->echoMode = CONSOLE_ECHO_MODE_DONT_ECHO; // pour ne pas que les caractères soient imprimés
        console_puts(console, console->inputBuf);
        console->echoMode = CONSOLE_ECHO_MODE_NORMAL;
     
    	va_start(arg_ptr, fmt);
    	vsscanf(console->inputBuf, fmt, arg_ptr);
    	va_end(arg_ptr);
    }
     
     
     
    void console_getCursorPosition(const CONSOLE_STRUCT *console, CONSOLE_CURSOR *cursor){
        cursor->x = console->cursor.x;
        cursor->y = console->cursor.y;
    }
     
    void console_setCursorPosition(CONSOLE_STRUCT *console, const CONSOLE_CURSOR *cursor){
        // utilise #include <windows.h>
     
        /* STD_OUTPUT_HANDLE fait reference a la sortie standard du programme qui est par defaut la console */
        #ifndef CONSOLE_DISABLE_OUTPUT
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        #endif
        COORD  Pos;
     
        Pos.X = cursor->x;
        Pos.Y = cursor->y;
     
        #ifndef CONSOLE_DISABLE_OUTPUT
        SetConsoleCursorPosition(hConsole, Pos);
        #endif
     
        console->cursor.x = cursor->x;
        console->cursor.y = cursor->y;
     
    }
     
    void console_overwriteField(CONSOLE_STRUCT *console, const CONSOLE_CURSOR *cursor, int len, const char *fmt, ...){
     
        console_setCursorPosition(console, cursor);
     
    	va_list arg_ptr;
        int i, loc_len;
     
    	va_start(arg_ptr, fmt);
    	loc_len = console_vsnprintf(console, len+1, fmt, arg_ptr);
    	va_end(arg_ptr);
     
        for(i=loc_len; i<len; i++){
            console_putch(console, ' ');
        }
     
    }
    => des remarques particulières pour améliorer ma lib ?

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Septembre 2009
    Messages
    1 821
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2009
    Messages : 1 821
    Points : 979
    Points
    979
    Par défaut
    J'ai trouvé comment récupérer la taille de la fenetre et cacher le curseur :
    voir fonctions non standard GetConsoleScreenBufferInfo() et SetConsoleCursorInfo()
    => par contre je ne sais pas comment détecter le changement de la taille de la console : Il ne faut quand même pas appeler régulièrement GetConsoleScreenBufferInfo() (c'est lourd) ?

Discussions similaires

  1. probleme tomcat en mode debug sous windows
    Par mazizou dans le forum Tomcat et TomEE
    Réponses: 3
    Dernier message: 03/04/2007, 09h28
  2. [C++] Programme console sous Windows
    Par Invité4 dans le forum Windows
    Réponses: 4
    Dernier message: 17/08/2006, 21h53
  3. Réponses: 6
    Dernier message: 20/12/2005, 00h03
  4. [web] [PerlTk] Console sous windows
    Par Cyspak dans le forum Interfaces Graphiques
    Réponses: 2
    Dernier message: 28/04/2004, 14h21
  5. [TP]Problème de modes graphiques sous Windows XP
    Par Gabi dans le forum Turbo Pascal
    Réponses: 11
    Dernier message: 04/04/2004, 17h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo