Linux : Gestion d’adressage du curseur avec tput

I. Présentation

Afin d’aller plus loin dans la démarche de colorisation du texte au sein d’une session shell, GNU/Linux met à notre disposition un outil très appréciable : tput. Il s’agit d’une commande permettant de gérer l’adressage du curseur sur l’écran et de gérer les séquences de contrôle du terminal, que l’on a vu dans le précédent billet, concernant les séquences Escape-Control.

Dis comme cela, il n’ y a rien de vraiment engageant. Et pourtant, cette simple commande va avoir deux fonctions essentielles :

- Le positionnement du curseur dans l’écran d’un terminal (fonction d’adressage)
- Les effets de texte (couleurs, gras, italiques…) en gérant les séquences Escape-Control.

Le gros avantage, par rapport à la solution précédente c’est que l’on n’aura plus à saisir les codes "Escape" à chaque fois que l’on souhaite mettre de l’effet dans le texte à afficher. En effet, la commande tput introduit une option permettant de spécifier le type du terminal. Ainsi, on n’a plus à se soucier de la conversion des tables de caractères et des séquences à saisir.

Par ailleurs, l’option cup permet de positionner le curseur dans l’écran à l’emplacement exact d’un pixel. On peut ainsi non seulement mettre de l’effet dans l’affichage à l’écran du texte, mais, on peut en plus, positionner le contenu à afficher là où l’on souhaite.

II. Synopsis de la commande

La commande possède quatre modes spécifiques :

- Mode d’initialisation du terminal : tput init (ou reset)
- Mode d’adressage du curseur dans l’écran du terminal : tput cup...
- Mode de Scripting des commandes : tput -S
- Mode d’effet de texte et/ou du curseur : tput [-T<Type>] <Option>

REMARQUE : il existe une option permettant de faire afficher la version du programme semi-graphique sous-jacent : ncurses. Il s’agit de l’option –V :

# tput -V

Exemples : quelques exemples d’utilisation de la commande tput :

# tput init             ==> pour initialiser le terminal
# tput –Tvt220 reset    ==> pour réinitialiser le terminal type vt220
# tput cup 10 4         ==> curseur ligne 10 et colonne 4

 

II. Les commandes en mode terminal

Il est donc possible d’initialiser un terminal dans le mode souhaité. Pour se faire, on peut avoir recours à deux commandes :

# tput init

Cette première commande initialise le terminal selon le type défini ou détecté depuis la variable d’environnement TERM. Bien évidemment, cette variable doit exister dans le fichier d’initialisation de session .profile (ou .bashrc).

ASTUCE : pour connaître la valeur du type de terminal utilisé, il suffit simplement d’exécuter la commande suivante :

# tput longname
xterm with 256 colors

Pour avoir la totalité des propriétés du terminal, il suffit simplement d’exécuter la commande suivante :

# infocmp screen

Si l’on souhaite écraser les propriétés définies dans la variable TERM, il faut plutôt utiliser la commande suivante :

# tput -T<Type> reset

On peut également positionner le curseur à un emplacement spécifique de l’écran :

# tput cup 2 5

La première valeur correspond au n° de ligne et la seconde, au n° de colonne. Si l’on souhaite visualiser le nombre de colonnes pour un type de terminal, il suffit d’exécuter :

# tput –Tvt220 cols
 80

La commande tput peut aussi avoir une influence sur le prompt PS1 qui est généralement défini à partir d’un certain nombre de variables. Si l’on souhaite visualiser ces variables, on peut exécuter la commande ci-dessous :

# tput cup
%i%p1%d ;%p2%dH

On peut rendre le curseur totalement invisible :

# tput civis

Pour le rendre de nouveau visible, il faut alors exécuter la commande suivante :

# tput cnorm

Le synopsis de la commande est le suivant :

# tput [-T<Type>] <Option> [Params]

<Type> Indique le type du terminal. Par défaut tput sélectionne la valeur de TERM.
<Option> Indique la capacité utilisée (initialisée dans la base termcap).
<Params> Fournis les arguments de l’option sélectionnée

 

III. Les commandes en mode escape-control

Comme on l’a dit en préambule, la commande tput peut également permettre de faire afficher du texte avec des effets : gras, italique, colorisation… Pour se faire, on peut alors définir les différentes séquences codées de la façon suivante, en fonction des effets à fournir :

# tput setab [1-7]         permet de définir une couleur de fond d’écran (escape ANSI)
# tput setb [1-7]          permet de définir une couleur de fond d’écran standard
# tput setaf [1-7]         permet de définir une couleur d’avant-plan (escape ANSI)
# tput setf [1-7]          permet de définir une couleur d’avant-plan standard
# tput bold                permet de passer en mode gras
# tput dim                 permet de diminuer de moitié la luminosité
# tput smul                permet de passer en mode souligné
# tput rmul                permet d’arrêter le mode surligné
# tput rev                 permet de passer en mode reverse
# tput smso                permet de passer en mode surligné
# tput rmso                permet d’arrêter le mode surligné
# tput sgr0                permet de réinitialiser tous les critères

RAPPEL : les codes couleurs utilisés par la commande tput (ainsi que par les séquences escape-control) sont les suivants :

- 0 Noir
- 1 Rouge
- 2 Vert
- 3 Jaune
- 4 Bleu
- 5 Magenta (rose)
- 6 Cyan (bleu clair)
- 7 Blanc

On retrouve ainsi le même fonctionnement qu’avec les séquences escape-control. Mais, ici, il n’est pas nécessaire de les taper à chaque fois puisque l’on peut parfaitement définir sous forme de variable celles dont on a besoin :

# bold=`tput smso`
# offbold=`tput rmso`
# echo –en “${bold}Entrer votre Nom :${offbold}“

Grâce à ces deux modes, on peut facilement créer un script permettant de placer le curseur où l’on souhaite et de définir un menu de type choix et proposer aux utilisateurs de faire leur sélection.

REMARQUE : on notera les quotes inversées permettant d’exécuter une commande en renvoyant le résultat. Directement dans la variable d’environnement.

Il existe de nombreuses autres possibilités (la liste d’options est assez longue). On peut consulter la page suivante pour plus de détails : GNU TPUT. Il existe des capacités booléennes, numériques, de chaînes de caractères...

Il existe une option particulière permettant de scripter les différentes commandes tput à passer. Par exemple, pour le script suivant :

...
tput sc
tput cup 3 45
tput rev

ASTUCE : on pourrait plutôt exécuter cela sous forme de script avec l’option –S (ou --standard-input) :

# tput –S << EOF
sc
cup 3 45
rev
EOF

 

IV. Script d’affichage

Pour illustrer cela, on fera simple. On souhaite afficher un menu proposant d’afficher en première option, le nom de la machine et la date dernier reboot (uptime), en option 2, de faire afficher l’espace disque, en option 3, de faire afficher l’espace utilisé pour la partition /home :

#!/bin/bash      
# tput sample: Un menu pour avoir les informations système
BKG_BLUE="$(tput setab 4)"     
BKG_BLACK="$(tput setab 0)"     
FOG_GREEN="$(tput setaf 2)"     
FOG_WHITE="$(tput setaf 7)"      

# Save screen     
tput smcup      

# Display menu until selection == 0     
while [[ $REPLY != 0 ]];
do       
echo -n ${BKG_BLUE}${FOG_WHITE}       
clear       
cat <<EOF EOF         
Please Select:          
1. Display Hostname and Uptime         
2. Display Disk Space         
3. Display Home Space Utilization         
4. Display  Distribution & Version
0. Quit      
EOF        

read -p "Enter selection [0-4] > " selection              
# Clear area beneath menu       
tput cup 10 0       
echo -n ${BKG_BLACK}${FOG_GREEN}       
tput ed       
tput cup 11 0        

# Act on selection       
case $selection in         
1)  echo "Hostname: $HOSTNAME"             
       uptime             
   ;;         
2)  df -h             
   ;;         
3) if [[ $(id -u) -eq 0 ]]; then               
    echo "Home Space Utilization (All Users)"               
    du -sh /home/* 2> /dev/null             
     else               
    echo "Home Space Utilization ($USER)"               
    du -s $HOME/* 2> /dev/null | sort -nr             
    fi             
  ;;     
4) lsb_release –a
  ;;    
0)    break             
       ;;         
*)  echo "Invalid entry."             
   ;;       
esac       

printf "\n\nPress any key to continue."       
read -n 1     
done      

# Restore screen     
tput rmcup     

echo "Program terminated."

Ainsi, après rendu ce script exécutable dans le sous-répertoire dans lequel on travaille, il suffit de l’exécuter :

$ chmod 700 sample_tput.sh
$ ./sample_tput.sh

Lors de cette exécution s’affiche alors sur l’écran le menu suivant :

Selon les options que l’on va saisir, on aura différents résultats, correspondant aux commandes que l’on fait exécuter dans le script :

- Option 1 :

- Option 2 :

- Option 3 :

- Option 4 :

Pour sortir de la boucle infinie du menu, il suffit de taper "0". Si l’on tape une autre valeur ou une lettre, on reçoit un message d’erreur. J’en conviens ce petit script basic ne va pas très loin. Mais cela montre toute la puissance de la commande tput et de ses capacités de gestion du curseur.

V. Messages d’erreur

La commande tput renvoie différents messages selon que le retour est ou non en erreur. Si tout se passe ben le code retour est 0.

Un code retour à 1 signifie que la capacité booléenne ou de type chaîne de caractère qui est mentionnée n’est pas disponible.

Un code retour de 2 signifie que la commande tput fournit des arguments invalides. A contrario, un code retour à 3 signifie que le type de terminal mentionné n’existe pas, ni dans la variable TERM ni par la valeur spécifiée par l’option –T.

ATTENTION : ce dernier code retour peut aussi symboliser le fait que la base termcap n’est pas (ou plus) lisible.

Enfin, le code retour 4 signifie que la capacité mentionnée en paramètre n’existe pas ou est inconnue de la base. Un code retour supérieur à 4 arrive généralement lorsqu’en utilisant le mode script (option –S) on se trompe dans la syntaxe.

En conclusion, on peut dire que lorsqu’il s’agit juste de transformer quelques lignes avec de l’effet de texte, on peut utiliser directement les séquences escape-control. Sinon, il vaut mieux utiliser la commande tput, plus complète et plus facile à manipuler. D’ailleurs, vous verrez certainement qu’avec l’usage vous adopterez très vite, j’en suis sûr, cette commande.

Partagez cet article Partager sur Twitter Partager sur Facebook Partager sur Linkedin Partager sur Google+ Envoyer par mail

Philippe PIERRE

A exercé de nombreuses années en tant qu'administrateur de base de données et comme administrateur Système Unix/Linux. Il a enseigné les réseaux au CNAM (Paris). Aujourd'hui, employé en tant qu'ingénieur infrastructure, au sein d'un laboratoire pharmaceutique et administrant un cluster de calculs HPC, il connaît parfaitement les environnements GNU/Linux dans le cadre d'une entreprise et des systèmes de haute disponibilité. Il aime partager son expérience.

    philippe-pierre a publié 17 articles sur IT-Connect.See all posts by philippe-pierre

    2 réactions sur “Linux : Gestion d’adressage du curseur avec tput

    Laisser un commentaire

    Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *