Initiez-vous à la programmation avec DOS conio
Français
L’une des raisons pour lesquelles tant d’applications DOS arboraient une interface utilisateur texte (ou TUI) parce que c’était si facile à faire. Le moyen standard de contrôler inconvénientUnique jeentrée et osortie (conio) était avec le conio bibliothèque pour de nombreux programmeurs C. Il s’agit d’une bibliothèque standard de facto sur DOS, qui a gagné en popularité lorsqu’elle a été implémentée par le compilateur C propriétaire de Borland comme conio.h. Vous pouvez également trouver un similaire conio implémentation dans le port DOS IA-16 de TK Chia du compilateur GNU C dans le libi86 bibliothèque de routines non standard. La bibliothèque comprend des implémentations de conio.h fonctions qui imitent Borland Turbo C++ pour définir les modes vidéo, afficher du texte en couleur, déplacer le curseur, etc.
Pendant des années, FreeDOS a inclus le compilateur OpenWatcom C dans les distributions standard. OpenWatcom prend en charge sa propre version de conio, mis en œuvre en conio.h pour des fonctions d’entrée et de sortie de console particulières, et dans graph.h pour définir les couleurs et effectuer d’autres manipulations. Étant donné que le compilateur OpenWatcom C est utilisé depuis longtemps par de nombreux développeurs, ce conio la mise en œuvre est également très populaire. Commençons par l’OpenWatcom conio les fonctions.
Réglage du mode vidéo
Tout ce que vous faites est immédiatement affiché à l’écran via le matériel. Ceci est différent du ncurses bibliothèque sous Linux, où tout est affiché via l’émulation de terminal. Sous DOS, tout fonctionne sur le matériel. Et cela signifie DOS conio les programmes peuvent facilement accéder aux modes vidéo et exploiter les régions d’écran d’une manière difficile avec Linux ncurses.
Pour commencer, vous devez définir le mode vidéo. Sur OpenWatcom, vous le faites avec le _setvideomode fonction. Cette fonction prend l’une des valeurs possibles, mais pour la plupart des programmes qui s’exécutent en mode couleur sur un écran standard 80×25, utilisez _TEXTC80 comme mode.
#include
#includeint
main()
{
_setvideomode(_TEXTC80);
…
Lorsque vous avez terminé votre programme et prêt à revenir au DOS, vous devez réinitialiser le mode vidéo aux valeurs qu’il avait auparavant. Pour cela, vous pouvez utiliser _DEFAULTMODE comme mode.
_setvideomode(_DEFAULTMODE);
return 0;
}
Définir les couleurs
Chaque PC construit après l’adaptateur couleur/graphique de 1981 prend en charge 16 couleurs de texte et 8 couleurs d’arrière-plan. Les couleurs d’arrière-plan sont adressées avec des indices de couleur 0 à 7, et les couleurs du texte peuvent être n’importe quelle valeur de 0 à 15 :
| 0 Noir | 8 noir brillant | ||
| 1 bleu | 9 bleu vif | ||
| 2 Vert | 10 Vert vif | ||
| 3 cyan | 11 Cyan brillant | ||
| 4 Rouge | 12 rouge vif | ||
| 5 magenta | 13 magenta brillant | ||
| 6 Marron | 14 Jaune | ||
| 7 Blanc | 15 blanc brillant |
Vous pouvez définir à la fois la couleur du texte et la couleur sous-jacente. Utilisez le _settextcolor fonction pour définir la couleur du “premier plan” du texte et _setbkcolor pour définir la couleur de “fond” du texte. Par exemple, pour définir les couleurs sur du texte jaune sur fond rouge, vous utiliseriez cette paire de fonctions :
_settextcolor(14);
_setbkcolor(4);
Texte de positionnement
Dans conio, les coordonnées d’écran sont toujours ligne,col et commencez par 1,1 dans le coin supérieur gauche. Pour un affichage standard de 80 colonnes avec 25 lignes, le coin inférieur droit est 25,80.
Utilisez le _settextposition pour déplacer le curseur vers une coordonnée d’écran spécifique, puis utilisez _outtext pour imprimer le texte que vous souhaitez afficher. Si vous avez défini les couleurs, votre texte utilisera les dernières couleurs que vous avez définies, indépendamment de ce qui est déjà à l’écran.
Par exemple, pour imprimer le texte “FreeDOS” à la ligne 12 et à la colonne 36 (qui est plus ou moins centrée sur l’écran) utilisez ces deux fonctions :
_settextposition(12, 36);
_outtext("FreeDOS");
Voici un petit exemple de programme :
#include <conio.h>
#include <graph.h>int
main()
{
_setvideomode(_TEXTC80);_settextcolor(14);
_setbkcolor(4);_settextposition(12, 36);
_outtext("FreeDOS");getch();
_setvideomode(_DEFAULTMODE);
return 0;
}
Compilez et exécutez le programme pour voir cette sortie :
Fenêtres de texte
L’astuce pour libérer la puissance de conio est de tirer parti d’une fonctionnalité de l’affichage vidéo du PC où un programme peut contrôler le matériel vidéo par région. Celles-ci sont appelées fenêtres de texte et sont une fonctionnalité vraiment intéressante de conio.
Une fenêtre de texte n’est qu’une zone de l’écran, définie comme un rectangle commençant à un ligne,col et se terminant à un autre ligne,col. Ces régions peuvent occuper tout l’écran ou être aussi petites qu’une seule ligne. Une fois que vous avez défini une fenêtre, vous pouvez l’effacer avec une couleur d’arrière-plan et y positionner le texte.
Pour définir une fenêtre de texte commençant à la ligne 5 et à la colonne 10, et s’étendant jusqu’à la ligne 15 et la colonne 70, vous utilisez le _settextwindow fonctionne comme ceci :
_settextwindow(5, 10, 15, 70);Maintenant que vous avez défini la fenêtre, tout texte que vous y dessinez utilise 1,1 comme coin supérieur gauche de la fenêtre de texte. Placer du texte à 1,1 positionnera en fait ce texte à la ligne 5 et à la colonne 10, là où la fenêtre commence à l’écran.
Vous pouvez également effacer la fenêtre avec une couleur d’arrière-plan. Les _clearscreen La fonction a une double fonction pour effacer soit le plein écran, soit simplement la fenêtre actuellement définie. Pour effacer tout l’écran, donnez la valeur _GCLEARSCREEN à la fonction. Pour effacer uniquement la fenêtre, utilisez _GWINDOW. Quelle que soit l’utilisation, vous remplirez cette région avec la dernière couleur d’arrière-plan que vous avez définie. Par exemple, pour effacer tout l’écran avec du cyan (couleur 3) et une fenêtre de texte plus petite avec du bleu (couleur 1), vous pouvez utiliser ce code :
_clearscreen(_GCLEARSCREEN);
_setbkcolor(3);
_settextwindow(5, 10, 15, 70);
_setbkcolor(1);
_clearscreen(_GWINDOW);
Cela permet de remplir très facilement certaines zones de l’écran. En fait, définir une fenêtre et la remplir de couleur est une chose si courante que je crée souvent une fonction pour faire les deux à la fois. Beaucoup de mes conio les programmes incluent une variation de ces deux fonctions pour effacer l’écran ou la fenêtre :
#include
#includevoid
clear_color(int fg, int bg)
{
_settextcolor(fg);
_setbkcolor(bg);
_clearscreen(_GCLEARSCREEN);
}void
textwindow_color(int top, int left, int bottom, int right, int fg, int bg)
{
_settextwindow(top, left, bottom, right);
_settextcolor(fg);
_setbkcolor(bg);
_clearscreen(_GWINDOW);
}
Une fenêtre de texte peut avoir n’importe quelle taille, même une seule ligne. C’est pratique pour définir une barre de titre en haut de l’écran ou une ligne d’état en bas de l’écran. Encore une fois, je trouve que c’est un ajout si utile à mes programmes que j’écrirai fréquemment des fonctions pour le faire pour moi :
#include
#include#include <string.h> /* for strlen */
void
clear_color(int fg, int bg)
{
…
}void
textwindow_color(int top, int left, int bottom, int right, int fg, int bg)
{
…
}void
print_header(int fg, int bg, const char *text)
{
textwindow_color(1, 1, 1, 80, fg, bg);_settextposition(1, 40 - (strlen(text) / 2));
_outtext(text);
}void
print_status(int fg, int bg, const char *text)
{
textwindow_color(25, 1, 25, 80, fg, bg);_settextposition(1, 1);
_outtext(text);
}
Mettre tous ensemble
Avec cette introduction à conio, et avec l’ensemble de fonctions que nous avons défini ci-dessus, vous pouvez créer les contours de presque n’importe quel programme. Écrivons un exemple rapide qui montre comment les fenêtres de texte fonctionnent avec conio. Nous allons effacer l’écran avec une couleur, puis imprimer un exemple de texte sur la deuxième ligne. Cela laisse de la place pour mettre une ligne de titre en haut de l’écran. Nous imprimerons également une ligne d’état en bas de l’écran.
C’est la base de nombreux types d’applications. Placer une fenêtre de texte vers la droite de l’écran pourrait être utile si vous écriviez un programme “moniteur”, tel qu’une partie d’un système de contrôle, comme ceci :
#include
#includeint
main()
{
_setvideomode(_TEXTC80);clear_color(7, 1); /* white on blue */
_settextposition(2, 1);
_outtext("test");print_header(0, 7, "MONITOR"); /* black on white */
textwindow_color(3, 60, 23, 79, 15, 3); /* br white on cyan */
_settextposition(3, 2);
_outtext("hi mom");print_status(0, 7, "press any key to quit..."); /* black on white */
getch();_setvideomode(_DEFAULTMODE);
return 0;
}
Ayant déjà écrit nos propres fonctions de fenêtre pour effectuer la plupart des travaux répétitifs, ce programme devient très simple : effacez l’écran avec un fond bleu, puis imprimez “test” sur la deuxième ligne. Il y a une ligne d’en-tête et une ligne d’état, mais la partie intéressante se trouve au milieu où le programme définit une fenêtre de texte près du bord droit de l’écran et imprime un exemple de texte. Les getch() La fonction attend que l’utilisateur appuie sur une touche du clavier, utile lorsque vous devez attendre que l’utilisateur soit prêt :
Nous ne pouvons changer que quelques valeurs pour changer complètement l’apparence et la fonction de ce programme. En définissant l’arrière-plan sur du texte vert et rouge sur une fenêtre blanche, nous avons le début d’un jeu de cartes en solitaire :
#include
#includeint
main()
{
_setvideomode(_TEXTC80);clear_color(7, 2); /* white on green */
_settextposition(2, 1);
_outtext("test");print_header(14, 4, "SOLITAIRE"); /* br yellow on red */
textwindow_color(10, 10, 17, 22, 4, 7); /* red on white */
_settextposition(3, 2);
_outtext("hi mom");print_status(7, 6, "press any key to quit..."); /* white on brown */
getch();_setvideomode(_DEFAULTMODE);
return 0;
}
Vous pouvez ajouter un autre code à cet exemple de programme pour imprimer les valeurs et les couleurs des cartes, placer des cartes sur d’autres cartes et d’autres fonctionnalités pour créer un jeu complet. Mais pour cette démo, nous allons simplement dessiner une seule “carte” affichant du texte :
Vous pouvez créer d’autres effets à l’aide de fenêtres de texte. Par exemple, avant de dessiner une fenêtre de message, vous pouvez d’abord dessiner une fenêtre noire décalée d’une ligne et d’une colonne. La fenêtre de texte apparaîtra pour créer une ombre sur cette zone de l’écran pour l’utilisateur. Et nous pouvons tout faire en ne modifiant que quelques valeurs dans notre exemple de programme :
#include
#includeint
main()
{
_setvideomode(_TEXTC80);clear_color(7, 1); /* white on blue */
_settextposition(2, 1);
_outtext("test");print_header(15, 3, "PROGRAMMING IN CONIO"); /* br white on cyan */
textwindow_color(11, 36, 16, 46, 7, 0); /* shadow */
textwindow_color(10, 35, 15, 45, 7, 4); /* white on red */
_settextposition(3, 2);
_outtext("hi mom");print_status(0, 7, "press any key to quit..."); /* black on white */
getch();_setvideomode(_DEFAULTMODE);
return 0;
}
Vous voyez souvent cet effet “d’ombre” utilisé dans les programmes DOS pour ajouter une touche visuelle :
Le DOS conio fonctions peuvent faire beaucoup plus que ce que j’ai montré ici, mais avec cette introduction à conio programmation, vous pouvez créer diverses applications pratiques et passionnantes. L’accès direct à l’écran signifie que vos programmes peuvent être plus interactifs qu’un simple utilitaire de ligne de commande qui fait défiler le texte à partir du bas de l’écran. Tirez parti de la flexibilité de conio programmation et faites de votre prochain programme DOS un excellent programme.
Téléchargez l’aide-mémoire de conio
En explorant la programmation avec conio, il est utile d’avoir une liste des fonctions courantes à portée de main. J’ai créé une feuille de triche recto-verso avec toutes les bases de conio, donc télécharge le et l’utiliser sur votre prochain conio projet.
