Impedire il lampeggiamento del testo / dello schermo quando si cancella

La mia sceneggiatura fa qualcosa del tipo:

while :;
   clear

   do_a_lot_of_output_here

   sleep 1
done

C'è qualche opzione per evitare che lo schermo lampeggi quando eseguo la cancellazione e l'output? Voglio farlo come al watchcomando (ma è scritto in C). Qualche consiglio?

clear | hexdump -C

00000000  1b 5b 48 1b 5b 32 4a                              |.[H.[2J|
00000007

PS. Sto bashsolo usando .

Il lampeggiamento si verifica perché lo script cancella l'intero schermo. Se dipinge sul testo esistente e cancella solo se necessario, non ci sarà sfarfallio.

Ecco un esempio:

#!/bin/sh
watchit() {
    HOME=$(tput cup 0 0)
    ED=$(tput ed)
    EL=$(tput el)
    ROWS=$(tput lines)
    COLS=$(tput cols)
    printf '%s%s' "$HOME" "$ED"
    while true
    do
        CMD="$@"
        ${SHELL:=sh} -c "$CMD" | head -n $ROWS | while IFS= read LINE; do
            printf '%-*.*s%s\n' $COLS $COLS "$LINE" "$EL"
        done
        printf '%s%s' "$ED" "$HOME"
        sleep 1
    done
}

watchit top -b -n 1

Lo fa:

• stampa l'output dal comando dato che si adatta allo schermo (nessun avvolgimento o scorrimento)
• scrive su righe esistenti, cancellando la parte di ciascuna riga che non viene sovrascritta
• utilizza la edcapacità del terminale per stampare dalla posizione corrente alla fine dello schermo.

Se desideri gestire uno schermo ridimensionabile, puoi spostare le assegnazioni all'interno ROWSe COLSall'interno del loop esterno, ad es.

#!/bin/sh
watchit() {
    HOME=$(tput cup 0 0)
    ED=$(tput ed)
    EL=$(tput el)
    printf '%s%s' "$HOME" "$ED"
    while true
    do
        ROWS=$(tput lines)
        COLS=$(tput cols)
        CMD="$@"
        ${SHELL:=sh} -c "$CMD" | head -n $ROWS | while IFS= read LINE; do
            printf '%-*.*s%s\n' $COLS $COLS "$LINE" "$EL"
        done
        printf '%s%s' "$ED" "$HOME"
        sleep 1
    done
}

watchit top -b -n 1

perché tputchiede l'attuale dimensione dello schermo dal sistema.

Ulteriori letture:

• terminfo- banca dati di capacità terminale
• tput, reset - inizializza un terminale o interroga il database terminfo

Un modo per evitare il lampeggiamento è ottenere tutto l'output prima di cancellare lo schermo in modo che ci sia un tempo minimo tra la cancellazione e il ridisegno. Questo è simile al concetto di doppio buffering:

while :; do
   output=$(do_a_lot_of_output_here)
   clear
   echo "$output"
   sleep 1
done

Questo non elimina completamente lo sfarfallio, ma accade significativamente meno frequentemente nella mia esperienza.

Il lampeggiamento è un risultato inevitabile dell'azzeramento dello schermo ogni volta attorno al loop. È possibile spostare il cursore nella parte superiore dello schermo e sovrascrivere invece parti del vecchio output.

# You may want to do this if your code is in a script.
unhide_cursor() {
    printf '\e[?25h'
}
trap unhide_cursor EXIT

# Hide the cursor (there is probably a much better way to do this)
printf '\e[?25l'
clear 
while true ; do
    # Move the cursor to the top of the screen but don't clear the screen
    printf '\033[;H' 
    do_a_lot_of_output_here
    sleep 1
done

Questo script lascerà artefatti se l'output si restringe. Inoltre, non è molto probabile che sia portatile. L'ho provato solo con urxvt, xterm e st.

Come estensione della risposta di Cristian, ho realizzato la seguente funzione bash che funziona se la finestra della console è più piccola dell'output del comando:

function watcher()
{
    lines=$(tput lines)
    while true; do
        output="$($@ | head -n $lines)"
        clear
        echo -e "$output"
        sleep 2
    done
}

Ciò ti consente di passare qualsiasi comando all'osservatore. Se stai usando git, usa git config --global color.status alwayse poi:

watcher git status

Visualizzerà un output di stato git sempre aggiornato.