How to refresh the screen continuously and update it in real time [closed]

Answer 1

As the others have said, you probably want to look at the ncurses library. But if you don't need advanced formatting, perhaps something simple like this can be enough:

#include <stdio.h>
#include <unistd.h>

int main(void) {
    int number = 0;
    while (1) {
        ++number;
        printf("\rThe number is now %d.", number);
        fflush(stdout);
        sleep(1);
    }
    return 0;
}

Answer 2

To keep it portable across terminal types, you need to use a library such as ncurses. Check out that link, its an exhaustive tutorial.

Here is a basic program that prints an ever increasing number at the top left corner of the screen:

#include <stdio.h>
#include <ncurses.h>

int main (void)

{
        /* compile with gcc -lncurses file.c */
        int c = 0;
        /* Init ncurses mode */
        initscr ();
        /* Hide cursor */
        curs_set (0);
        while (c < 1000) {
                /* Print at row 0, col 0 */
                mvprintw (0, 0, "%d", c++);
                refresh ();
                sleep (1);
        }
        /* End ncurses mode */
        endwin();
        return 0;
}

Thats how you refresh the window. Now, if you want to display rows of data as top does, the data you display needs to be maintained in an ordered data-structure (depending on your data, it maybe something as simple as an array or a linked list). You would have to sort the data based on whatever your logic dictates and re-write to the window (as shown in the example above) after a clear() or wclear().

Answer 3

As well as using the ncurses library to do the screen handling, if you want to update it "continuously" and "in real time" you're probably going to want to look into timers and signal handling, too. timer_create() and timer_settime() can get you a timer going, and then you can use sigaction() to set a handler function to trap the SIGALRM signal and do your updating.

EDIT: Here's some sample code, as requested:

#define TIMESTEP 200000000

timer_t SetTimer(void) {
    struct itimerspec new_its;
    struct sigevent sevp;
    timer_t main_timer;

    sevp.sigev_notify = SIGEV_SIGNAL;
    sevp.sigev_signo = SIGALRM;
    timer_create(CLOCK_REALTIME, &sevp, &main_timer);

    new_its.it_interval.tv_sec = 0;
    new_its.it_interval.tv_nsec = TIMESTEP;
    new_its.it_value.tv_sec = 0;
    new_its.it_value.tv_nsec = TIMESTEP;

    timer_settime(main_timer, 0, &new_its, NULL);
    return main_timer;
}

void SetSignals(void) {
    struct sigaction sa;

    /*  Fill in sigaction struct  */

    sa.sa_handler = handler;
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);

    /*  Set signal handler  */

    sigaction(SIGALRM, &sa, NULL);
}

void handler(int signum) {
    switch (signum) {
    case SIGALRM:
        update_stuff();    /*  Do your updating here  */
        break;
    }
}

Answer 4

Depending on your situation, you can use the "watch" command on the command line to get quick views like top. You can also watch multiple commands at the same time.

ex:

watch 'ls -l <somefile>; ps -fC <someprocess>; ./some_script'

Answer 5

Ncurses may be the way to go. Since you said program, then ncurses, c, c++. Look into all of it. But if you plan on doing just something "shelL" related, go with perl.

Edit: To add onto my point, here's some modules that can give you an idea.

http://metacpan.org/pod/Curses::UI::Dialog::Progress

http://metacpan.org/pod/Smart::Comments

window.clrtobot()

And for good measure, a call for curses to clear the whole window.

Answer 6

If you are under xterm or VT100 compatible, you can make use of console codes, example:

#include <stdio.h>
#include <unistd.h> /* for sleep */

#define update() printf("\033[H\033[J")
#define gotoxy(x, y) printf("\033[%d;%dH", x, y)

int main(void)
{
    update();
    puts("Hello");
    puts("Line 2");
    sleep(2);
    gotoxy(0, 0);
    puts("Line 1");
    sleep(2);
    return(0);
}

You can do almost everything with escape sequences, but as pointed out in wikipedia: ncurses optimizes screen changes, in order to reduce the latency experienced when using remote shells.