Aller au menu - Aller au contenu

Icône Des couleurs dans la console (Linux)

Avatar
Par Avatar TabDambrine
Mise à jour : 14/05/2009
Difficulté : Facile Facile Creative Commons BY-SA
338 visites depuis 7 jours, classé 311/786
Ce tuto a pour but de créer une fonction afin de pouvoir rajouter des couleurs de texte et de fond dans la console Linux ;) , mais ce n'est pas tout : on créera aussi une fonction qui va effacer l'écran.

Bref des petits trucs marrant pour égayer un peu un programme en console.

Prêts ? Alors on y va. :D

Qu'est-ce qu'on doit savoir pour faire ça ?


Il faut avoir suivi les cours de M@teo jusqu'aux directives préprocesseur et avoir compris de préférence :p .

PS : pour les windowsiens vous pouvez aller voir le tuto de guimers8 ;)
Retour en haut
Sommaire du tutoriel :
Icône du chapitre
Retour en haut

Effacer l'écran

On va commencer doucement en créant une fonction qui va effacer l'écran.

Mais heu... on peut pas le faire avec system("clear"); o_O


Si,si bien entendu mais celle-ci nous permettra d'éviter d'utiliser system(); ^^ .

Voilà l'instruction qui permet d'effacer l'écran :p :

Code : C
1
printf("\033[H\033[2J");


Mais ça veut dire quoi ce truc ?


Pas de panique ! En fait la chaîne de caractère n'est qu'une suite de "caractères spéciaux" interprétée par la console et qui a pour résultat d'effacer l'écran.

Attention ! Toutes les consoles n'utilisent pas les mêmes paramètres donc il se peut que ce code ne fonctionne pas sur tout les PC.
Ceci est également valable pour les fonctions sur les couleurs.


Evidemment on pourrait écrire cette instruction à chaque fois que l'on veut effacer l'écran mais le plus simple serait de créer un header contenant tout ce dont on a besoin.

Créeons donc le fichier couleurs.h et débutons le :

Code : C
1
2
3
4
5
6
#ifndef COULEURS
#define COULEURS

#include <stdio.h>

#endif


Pour le moment ce fichier est bien vide mais il va se remplir.

On va donc faire une directive préprocesseur qui va afficher notre ligne magique et donc effacer l'écran. :p

Notre directive va s'appeler : clrscr() pour clear screen (un bon moyen de s'en souvenir non ?) ;) .

Pour définir une directive préprocesseur il faut utiliser
Code : C
1
#define
vous vous rappelez ?

Créons donc la directive (enfin ! :-° ) :

Code : C
1
#define clrscr() printf("\033[H\033[2J")


nous l'utiliserons donc en faisant dans notre programme :
Code : C
1
2
#include "couleurs.h" //surtout ne pas l'oublier
clrscr();


Mais ?! Dans les cours de M@teo il est écrit que les directives préprocesseurs ne prennent pas de ";" o_O


C'est vrai mais regardez bien je n'ai pas mis de ";" dans le define donc il en faut pour finir l'instruction.

Pourquoi faire comme ça alors que ce que fait M@teo est plus simple


J'utilise cette technique afin de ne pas me faire avoir entre ";" ou pas ";" ?
Avec ceci je mets le ";" comme d'habitude.

Bien entendu vous faites comme vous voulez ^^ .

Voilà donc à quoi ressemble notre fichier couleurs.h
Code : C
1
2
3
4
5
6
7
8
#ifndef COULEURS
#define COULEURS

#include <stdio.h>

#define clrscr() printf("\033[H\033[2J")

#endif


Voilà pour l'effacement de l'écran. facile non ? ;) Maintenant nous allons rajouter un peu de couleur dans cette console. :pirate:
Retour en haut

Changer la couleur de Police

Maintenant que nous savons effacer l'écran nous allons pouvoir mettre un peu de couleurs dans le texte.

Prenons l'instruction suivante :

Code : C
1
printf("\033[%sm",param)
o_O

Ceci permet les attributs suivants :
  • Changer la couleur du texte
  • Changer la couleur de fond du texte
  • Faire clignoter le texte
  • Réinitialiser le systeme de couleur



Sympa non ? :)

Nous allons donc voir comment changer la couleur du texte dans ce paragraphe. ;)

Je le répète : Attention ! Toutes les consoles n'utilisent pas les mêmes paramètres donc il se peut que ce code ne fonctionne pas sur tout les PC.


Nous allons commencer par créer une directive préprocesseur que nous appellerons couleur() et qui prendra en paramètre les paramètres que nous passerons au printf(); afin de changer la couleur du texte.

Créons donc la directive :

Code : C
1
#define couleur(param) printf("\033[%sm",param)


Afin de fonctionner lors de l'appel nous devrons l'utiliser comme suit :

Code : C
1
2
3
couleur("34");
printf("test");
couleur("0");


Tu nous fais quoi là ? o_O


Ce code est constitué comme vous l'avez vu de trois instructions :
  • couleur("34"); met la couleur du texte en bleu.
  • printf("test"); écrit le mot test tout bêtement
  • couleur("0"); réinitialise le système de couleur.


Ok pour les deux premières instructions mais pourquoi réinitialiser ?


Cette technique a un énorme défaut : si vous ne réinitialisez pas le système de couleur, tout le reste sera affecté : oui tout ! Donc la réinitialisation permet d'éviter ce problème.

Voici la liste des paramètres pour changer la couleur. En face de chaque paramètre se trouve la couleur correspondante.

0 == réinitialisation.

ParamètreCouleur
30 Noir
31 Rouge
32 Vert
33 Jaune
34 Bleu
35 Magenta
36 Cyan
37 Blanc


Deux autres paramètres peuvent être intéressants :

"5" permet de faire clignoter le texte.
"1" active la haute intensité des caractères.
"7" inverse la sélection de couleurs : si votre système est noir sur fond blanc cela deviendra blanc sur fond noir.

Voilà pour la couleur des caractères. Prochaine étape : la couleur de fond. :)
Retour en haut

Changer la couleur de Fond

Bon maintenant que vous savez changer la couleur de la police,il serait bien de changer la couleur de fond afin de faire des contrastes. ;)

Si vous voulez obtenir un jeu de couleur dans ce style :

Image utilisateur

Il va falloir modifier la couleur de fond.

Pour modifier la couleur de fond l'instruction est exactement la même que pour la couleur :

Code : C
1
printf("\033[%sm",param)


Ainsi notre directive précedemment écrite :

Code : C
1
#define couleur(param) printf("\033[%sm",param)


fonctionnera aussi bien pour la couleur de la police que pour la couleur de fond du texte.

Les paramètres à donner à cette instruction sont :

ParamètreCouleur
40 Noir
41 Rouge
42 Jaune
43 Vert
44 Bleu
45 Magenta
46 Cyan
47 Blanc


Faisons un test :
Code : C
1
2
3
couleur("46");
printf("texte");
couleur("0");


Ce code écrira le mot texte en couleur par défaut (pas de changement de police) sur fond cyan et réinitialisera le système de couleur afin de ne pas perturber la suite de l'affichage. :)

C'est sympa ton truc mais si je veux écrire en blanc sur fond noir je le fais dans quel sens ? d'abord le fond ou d'abord la police ?


Aucune importance pour le sens car tout le système sera modifié avant l'affichage.

Et je dois faire deux fois l'instruction pour que cela fonctionne ?


Non, une seule instruction peut suffire.
En effet ce code :
Code : C
1
2
3
couleur("40;37");
printf("texte");
couleur("0");

écrira en blanc sur fond noir comme voulu.

Pour utiliser plusieurs paramètres il suffit de les séparer dans la chaine par des ";".

Et voilà maintenant vous savez tout pour changer la couleur de vos textes ainsi que celle de fond dans votre console. :D

A suivre : le fichier couleurs.h est inscrit avec commentaires afin de mieux comprendre et de l'avoir en entier. ;)
Retour en haut

Résumé de couleurs.h

Voici le moment de mettre un petit résumé de notre fichier couleurs.h :

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#ifndef COULEURS
#define COULEURS

#include <stdio.h>

// Efface l'écran et replace le curseur en haut à gauche
#define clrscr() printf("\033[H\033[2J")

// Sélection de couleurs
#define couleur(param) printf("\033[%sm",param)
/*   param devant être un const char *, vide (identique à "0") ou formé
     d'une où plusieurs valeurs séparées par des ; parmi
         0  réinitialisation         1  haute intensité (des caractères)
         5  clignotement             7  video inversé
         30, 31, 32, 33, 34, 35, 36, 37 couleur des caractères
         40, 41, 42, 43, 44, 45, 46, 47 couleur du fond
            les couleurs, suivant la logique RGB, étant respectivement
               noir, rouge, vert, jaune, bleu, magenta, cyan et blanc */

#endif
Retour en haut
Maintenant vous allez pouvoir embellir vos programmes consoles sous Linux. Si jamais vous n'arrivez pas à faire fonctionner ce système : envoyer moi un MP avec votre distribution et votre bureau afin que je puisse faire une liste des consoles non compatibles :) .

Voilà c'est fini ! en espérant vous avoir aidé ! Maintenant vous pouvez retourner à vos activités habituelles.
Retour en haut

Partager

Retour en haut
28 commentaires pour "Des couleurs dans la console (Linux)"
Note moyenne : 3.30 / 4 (20 votes)
Pseudo Commentaire
Hors ligne popolz77 # Posté le 22/09/2010 à 13:39:47

petite question bete : on le met ou ce code pour le faire fonctionner dans la console ???
Hors ligne Fire4764 # Posté le 06/11/2010 à 20:20:45
Mangez des pommes.
Avatar

 Bonjour, j'ai juste un petit problème, c'est que la commande en C++ pour effacer fonctionne bien avec le cout. Mais je n'arrive pas a changer la couleur avec le cout, et je ne sais pas si ca vient de ma distrib ou du fait que c'est du C++.
Je suis sous Kubuntu.
Maître Corbeau, sur un arbre perché...
Saurez vous arriver au bout de cette fable, qui nous emmène au 4 coins de l'internet ? :)
Projet : Moonland Prophecy (1~2%)
 
Hors ligne achebalion # Posté le 06/08/2011 à 16:29:01
Avatar

 bonjour.
je suis sous windows et j'ai remarqu" que le lien vers le tuto de guimers8 ne marche pas. on m'affiche:


Citation : Message n° 14

Ce tutoriel n'existe pas.

<=Précédent - Suivant=>


sinon, bon tuto,

Windows 8 en beta, sdz ofline, ... o_O vous me croyez pas ?
 
Hors ligne gwenadu # Posté le 22/08/2011 à 00:56:11

Bonjour,

Merci pour ces informations, cela m'a été utile pour égailler un peu mes programmes consoles.

Par contre, en travaillant les fonctions du C++ et en jouant avec ces couleurs j'ai eu l'envie de mettre plusieurs paramètres en même temps.

Donc j'ai gardé les fonctions proposées par raphamil et j'en ai rajouté une afin d'envoyer plusieurs paramètres en simultanée.

Donc j'ai écrit deux fonctions la première pour passer des entiers, les membres de l'enumération (de 0 à 4 .. en nombre) l'autre pour passer des chaines de char (les #define)

couleur.cpp
Code : C++
 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
#include <stdio.h>
#include <iostream>         // gestion des flux d'entrée-sortie
#include <cstdarg>          // pour va_arg et va_list

int clscr(void)                     { return printf("\033[H\033[2J"); }

static int _couleur(const char c[]) { return printf("\033[%sm", c);   }

int resetCols(void)                 { return _couleur("0");           }

int couleur(const char c[])         { return _couleur(c);             }

int couleurD(const int c) {
    char s[4] = {'\0'};
    sprintf(s, "%i", c);
    return couleur(s);
}

// on peut passer de 0 à 4 param. Si il y a 0 param on fait un reset
int p_colorDint(int a=0, int b=-1, int c=-1, int d=-1){
    char         s[4] = {'\0'};  sprintf(s, "%i", a);    couleur(s);
    if(b!=-1){   s[0] =  '\0' ;  sprintf(s, "%i", b);    couleur(s); }
    else        return 0;
    if(c!=-1){   s[0] =  '\0' ;  sprintf(s, "%i", c);    couleur(s); }
    else        return 0;
    if(d!=-1){   s[0] =  '\0' ;  sprintf(s, "%i", d);    couleur(s); }
    else        return 0;

    return 0;
}
// utilisat° de cstdarg ... 
// je triche un peu en utilisant entree comme une donnée 
int p_colorC(char * entree, ...){
      va_list p_list;
      char * s;
      va_start(p_list, entree);
      s = entree;
      do{
        printf("\033[%sm", s);
        s = va_arg(p_list, char *);
      }while(s != NULL);
}


couleur.h
Code : C++
 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
#ifndef DEF_ECRAN
    #define DEF_ECRAN

    #include<stdio.h>

    #define RESET "0"
    #define INTENSE "1"
    #define CLIGNOTE "5"
    #define INVERSER "7"

    #define NOIR "30"
    #define ROUGE "31"
    #define VERT "32"
    #define JAUNE "33"
    #define BLEU "34"
    #define MAGENTA "35"
    #define CYAN "36"
    #define BLANC "37"

    #define F_NOIR "40"
    #define F_ROUGE "41"
    #define F_VERT "42"
    #define F_JAUNE "43"
    #define F_BLEU "44"
    #define F_MAGENTA "45"
    #define F_CYAN "46"
    #define F_BLANC "47"


    enum {
        Reset = 0, Intense = 1,
        Clignoter = 5, Inverser = 7,

        Noir = 30, Rouge, Vert, Jaune,
        Bleu, Magenta, Cyan, Blanc,

        F_Noir = 40, F_Rouge, F_Vert, F_Jaune,
        F_Bleu, F_Magenta, F_Cyan, F_Blanc
    } e_Couleur;

    int clscr(void);
    int resetCols(void);
    int couleur(const char c[]);
    int couleurD(const int c);
    int p_colorDint(int a=0, int b=-1, int c=-1, int d=-1);
    int p_colorC(char * entree, ... );
    
#endif


un main.cpp plutôt simple pour tester les fonctionnalités


Code : C++
 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
#include <iostream>         // gestion des flux d'entrée-sortie
#include <string>           // gestion du "type" string
#include "couleur.h"

using namespace std;        // utilisat° espace de nom lib standard


int main(void) {

    cout<<"hello tout le monde \n";
    cout<<"pressez une touche pour effacer l'écran\n";

    /* attente d'une saisie clavier */
    cin.ignore( numeric_limits<streamsize>::max(), '\n' );
    clscr();        // fonct° de couleur.h : efface console
    cout<<"La suite est en couleur \n";

    couleurD(Intense);
    couleur(ROUGE); // on passe en rouge
    cout<< "en ROUGE avec couleur(char*)\n";
    couleur(RESET); // reprend couleur par defaut

    p_colorD(Rouge, true, F_Rouge);
    cout<< "Rouge intense et fond rouge avec p_colorD\n";
    p_colorD(Vert, F_Bleu, false, true);
    cout<< "Couleur Verte et fond bleu\n";

    // test des valeurs possibles *************************
    cout<<"\n\ntest des valeurs possibles **************\n";
    for(int i = 0 ;i<100 ; i++) {  
        couleurD(i); cout.width(4); cout<<i;   
    }
    cout<<endl;

    // test de la fonct° avec argum variables int(de l'enum)
    cout<<"\ntest de la fonct° avec argum variables int (de l'enum)\n";
    p_colorDint(); cout<<"p_colorDint()\n";     // pas d'arg => reset
    p_colorDint(Rouge); cout<<"p_colorDint(Rouge)\n";
    p_colorDint(Vert,F_Bleu); cout<<"p_colorDint(Vert,F_bleu)\n";

    p_colorDint(Reset, Intense, F_Rouge); 
    cout<<"p_colorDint(Reset, Intense, F_Rouge)\n";

    p_colorDint(Inverser); cout<<"p_colorDint(Inverser)\n";
    p_colorDint(); cout<<"p_colorDint()\n";

    /* test de la fonct° avec arguments variables en chaine de char(des
     * define). Le dernier argument doit être la cste NULL pour marquer
     * la fin de la liste.
     */
    cout<<"\ntest de la fonct° avec argum variables int (de l'enum)\n";

    p_colorC(VERT,F_VERT,INTENSE, NULL); 
    cout<<"p_colorC(VERT,F_VERT,INTENSE, NULL)\n";

    p_colorC(RESET,F_ROUGE, NULL); 
    cout<<"p_colorC(RESET,F_ROUGE, NULL)\n";

    p_colorC(INVERSER,NULL);cout<<"p_colorC(INVERSER,NULL)\n";
    
    couleur(RESET); // on reprend la couleur par defaut
    cout<<"\n\nc'est fini !!!"<<endl;
    return (EXIT_SUCCESS);
}


explication (si besoin est ...)

Pour int p_colorDint(int a=0, int b=-1, int c=-1, int d=-1);

Il y a donc 4 arguments entier pré-déclaré. Ainsi on peut n'en passer 4 ou moins lors de l'appel
pour l'appel: p_colorDint();
// pas d'argument passé donc a vaudra 0 dans la fonction et l'exécution de couleur(0) donne un reset
pour l'appel: p_colorDint(Rouge);
// un argument passé donc a vaut la valeur de Rouge alors que b, c et d vaudront -1

pour l'appel: p_colorDint(Vert,F_Bleu);
// 2 arguments passés donc a vaut la valeur de Rouge et b vaut la valeur de F_Bleu alors que c et d valent -1

int p_colorC(char * entree, ... );

C'est une fonctions variadiques dixit un cours de jussieu sur le sujet. Si vous voulez le lien dites le moi, je ne sais pas si c'est autorisé sur ce forum.
va_list est un type spécifique pour conserver des informations sur les arguments variables

va_start est une macro qui sert à initialiser une liste d'arguments variable
va_arg est une macro qui sert à récupérer l'argument suivant .. ici c'est un pointeur sur char

Il existe une macro va_end mais je n'en comprends pas bien l'intérêt ;)

Donc on scrute donc la pile d'argument grâce à va_arg et on récupère toutes les chaines de char. En théorie char * entree est utilisé pour gérer la pile mais je l'utilise comme chaine utile pour éviter une argument de plus.

Pour la fonction p_colorC il ne faut pas oublier de placer le pointeur NULL en dernier argument lors de l'appel.

Si vous avez des remarques, je suis preneur car je souhaite améliorer ma maitrise des fonctions.

RQ 26/08/11 : Cela marche sous windows avec en compilant avec cigwin sous netbeans ou C::B10. Cela ne marche pas avec minGW (du moins mes trois version minGW, minGW de QT et le compilo minGW ournit avec C::B10). Je ne sais pas pourquoi mais en changeant de compilo ce matin j'ai noté que cela ne marchait pas :euh:

Le bon côté c'est que cela marche sous windows ;)
Connecté Toufik37 # Posté le 07/04/2012 à 10:11:33
Rock climbing = Fun
Avatar

Avis : Très bon

Ville : Huismes
Pays : France métropolitaine

 Petit tuto très intéressant !
Pas mal pour embellir ses programmes en console !
Merci
Mon site
Langage favoris C - PHP - LaTeX
OS Ubuntu 12.04 LTS
Application Firefox - LibreOffice - Gimp
 

Voir tous les commentaires