Les premières interfaces graphiques sont apparues avec l'invention de la souris (1967) et des écrans graphiques,
c'est à dire capables d'afficher des images.
Avant cela les écrans d'ordinateur n'affichaient que du texte et ressemblaient plutot à ceci:
C'est ce que l'on appelle aujourd'hui le mode console.
On peut le simuler sur les ordinateurs actuels en ouvrant une fenêtre de commande.
Sous Windows, une telle fenêtre
ressemble à ceci:
En mode console, tout se fait sans souris, en tapant du texte. Par exemple, pour obtenir la liste des fichiers
du répertoire courant, on utilisait la commande dir.
Cette ancienne commande du système MS-DOS (ancêtre de Windows)
est encore accessible aujourd'hui depuis une fenêtre de commande:
Aujourd'hui, on utilise pour cela l'explorateur de fichier, qui permet de lister le contenu d'un répertoire, déplacer ou
copier des fichier etc ...
En 1973 apparait le premier ordinateur avec interface graphique : la station graphique Xerox Alto
fabriquée en Californie, à Palo Alto,
par la société Xerox (par ailleurs
à l'origine de la machine à photocopier).
|
| La station Xerox Alto |
En 1983, cet ordinateur a inspiré le premier PC de Apple, le LISA ancêtre des Macintosh puis en 1985, le
premier système Windows (Windows 1.0) de Microsoft.
|
| Le Lisa |
C'est ainsi que son apparues les premiers systèmes d'exploitation munis d'interfaces graphiques
dans lesquels les applications apparaissent sous forme de fenêtres ou d'icônes sur lesquels on
peut agir grâce à la souris.
De manière générale, l' interface graphique d'un programme est
la manière dont il se présente visuellement à l'écran lorsqu'il s'exécute.
Dans cette partie, nous décrivons plus particulièrement, l'interface graphique du système qui apparait
au démarrage d'un ordinateur.
Dans Windows par exemple, elle est constituée du bureau et d'une barre de tâche.
Le bureau contient des icônes de différents programmes. La barre des tâches donne accès (entre autre) au menu
démarrer par l'intermédiaire duquel on peut accéder à différents composants du système, configurer l'ordinateur,
arrêter l'ordinateur etc ...
Tout ceci constitue l'interface graphique du système d'exploitation.
On voit également apparaitre le curseur qui se présente généralement
sous la forme d'une petite flèche.
Le curseur permet d'indiquer sur quel élément de l'interface graphique on veut agir.
Lorsque l'utilisateur déplace la souris, il provoque une
interruption gérée par le système d'exploitation.
Le traitement par défaut de cette interruption consiste à déplacer le curseur.
Comme nous l'avons vu, un clic provoque une interruption qui est tout d'abord interceptée par le
système d'exploitation. Le traitement de cette interruption dépendra de la position du curseur. Nous reviendrons
la dessus plus en détails un peu plus loin.
Lorsque l'on clique sur l'icone d'un programme par exemple, le système le charge en
mémoire et lance son exécution.
L'interface graphique de ce programme s'affiche alors à l'écran.
L'interface graphique d'une application se présente généralement sous la forme
d'un ou plusieurs rectangles appelés fenêtres dans lesquels apparaissent des
composants ou contrôles. Les composants sont par exemple
des menus, des barres d'outils, des champs de texte, ....
Voici par exemple une partie de l'interface graphique d'excel 2003:
Les champs de texte sont des zones rectangulaires de l'écran dans
lesquelles il est possible de taper
du texte sur une ligne. Nous reviendrons plus en détail sur ce composant graphique.
Parmis les différents types de fenêtres qu'utilisent les applications, on trouve fréquemment
des fenêtres du type formulaire, dans lesquelles apparaissent d'autres types de composants comme
des boutons, des champs de texte, des cases à cocher ...
Voici un exemple de formulaire contenant ces composants:
A un moment donné, l'écran contient une (ou plusieurs) fenêtre(s) pour chaque application ouverte.
Par exemple, une fenetre pour Internet Explorer, une fenêtre pour Word, une autre pour Photoshop, etc ...
Mais parmis toutes ces fenêtre, il y a une seule fenêtre active: c'est
la fenetre qui apparait en premier plan et qui contient le curseur.
Lorsqu'il se produit une interruption souris (déplacement de la souris ou clic) ou clavier
(touche appuyée ou relachée),
il y a deux possibilités:
- Il n'y a aucune fenêtre active. Dans ce cas, l'interruption est directement gèrée par le système.
Sous Windows, c'est par exemple le cas lorsque vous cliquez sur le bureau.
- Il y a une fenêtre active. Dans ce cas, le système intercepte tout d'abord l'interruption,
mais il ne la gère pas forcément entièrement. Une partie
de la gestion de l'interruption est sous-traitée à l'application associée à cette fenêtre.
Pour cela, il communique toutes les informations utiles à l'application
sous la forme d'un évènement.
Les parties d'une l'application qui interceptent les évènements
et les gèrent sont appelées des gestionnaires d'évènement.
Un évènement est lié à un composant particulier de la fenêtre, que l'on pourrait appeler
le composant
actif : c'est le composant contenant le curseur au moment de l'évènement.
Une application pourra ainsi savoir sur quel composant l'utilisateur a cliqué
ou quel était le composant actif lorsqu'il a appuyé sur telle touche du clavier.
Les interfaces graphiques sont généralement concues pour éviter au maximum de taper du texte.
Mais il arrive que ce soit inévitable. Par exemple pour donner une adresse mail, un mot de passe,
pour faire une recherche par mots clés, etc ...
Dans une interface graphique, la saisie de texte se fait par
l'intermédiaire des champs de texte, zones rectangulaires
dans lesquelles il est possible de "rentrer" du texte.
Pour cela l'utilisateur doit tout d'abord activer le champ de texte en cliquant dedans.
Le curseur change alors de forme.
En général il se transforme en une barre verticale clignotante, ce qui signifie que le champ
de texte est actif et prêt à recevoir du texte.
Lorsqu'un champ de texte est actif, les caractères frappés au clavier viennent s'afficher à l'écran
à l'intérieur de celui-ci. On a ainsi l'impression que les caractères sont directement transférés du clavier
vers l'écran. En réalité, ils sont tout d'abord transférés en mémoire par le système d'exploitation.
En effet, à chaque champ de texte est associé une plage mémoire, appelée buffer,
destinée à mémoriser les caractères frappés.
Supposons qu'un champ de texte soit actif et que l'utilisateur appuie sur la touche 's'.
Le système va alors transférer le caractère 's' dans le buffer associé à ce champ de texte, puis
en un deuxième temps afficher le contenu du buffer à l'écran à l'intérieur du champ de texte.
S'il appuie ensuite sur la touche 't', le caractère 't' va être rajouté dans le buffer après le 's', puis
le buffer va être réaffiché.