From madore@news.ens.fr
Path: eleves!not-for-mail
From: madore@news.ens.fr (GroTeXdieck)
Newsgroups: ens.forum.informatique.x11
Subject: Re: Livre sur la programmation X
Date: 14 Oct 1998 19:14:24 GMT
Lines: 157
Sender: madore@clipper.ens.fr
Message-ID: <702t6g$ag7$1@clipper.ens.fr>
References: <702gj7$iq2$1@clipper.ens.fr>
NNTP-Posting-Host: clipper.ens.fr
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 8bit
X-Trace: clipper.ens.fr 908392464 10759 129.199.129.1 (14 Oct 1998 19:14:24 GMT)
X-Complaints-To: forum@clipper.ens.fr
NNTP-Posting-Date: 14 Oct 1998 19:14:24 GMT
X-Newsreader: Flrn (0.3.0 - 10/98)
Xref: eleves ens.forum.informatique.x11:13

[Attention, très long.]

La programmation en X peut se faire à différents niveaux.  Le plus
bas, c'est le Protocole X, ou comment le client et le serveur
échangent des données sur le socket.  On ne programme (à peu près)
jamais directement au niveau du Protocole, mais il peut servir de le
connaître, de façon à décoder les informations qui passent (par
exemple).

Le niveau au-dessus, c'est la Xlib.  La Xlib propose une traduction
assez directe des requêtes du Protocole en appels de fonctions.  Elle
permet de créer et de manipuler des fenêtres (dans un sens assez
basique : une fenêtre c'est juste un rectangle dans lequel on peut
dessiner, et qu'on peut soulever ou baisser par rapport aux autres -
et on peut aussi imbriquer des fenêtres - la décoration des fenêtres
de plus haut niveau est apportée par le Window Manager), de dessiner
dedans (ce qui se fait par l'intermédiaire de machins appelés graphics
contexts (GC) qui contiennent des informations comme la couleur
courante, la largeur des traits, etc), de recevoir des événements
(clavier, souris, exposition des fenêtres, messages inter-clients,
etc.)

La programmation directe en Xlib est surtout adaptée lorsqu'il s'agit
de faire juste des dessins, ou bien des programmes qui n'ont une
interface utilisateur que très limitée.  Par exemple, le (célèbre) jeu
xlaby est écrit en Xlib pure.  Dès qu'on veut faire un truc un tant
soit peu sophistiqué, la Xlib ne suffit plus.

Le niveau suivant, c'est le X Toolkit, Xt en abrégé.  En fait, il y a
deux choses, les X toolkit intrinsics, et un jeu de widgets.  Le X
Toolkit, c'est un système orienté objets (mais quand même entièrement
en C) qui permet de manipuler des ``widgets'', qui sont des fenêtres
munies de ressources et de méthodes, leur permettant de réagir
``toutes seules'' à certains événements.  Les intrinsics sont le cadre
dans lequel on peut communiquer avec les widgets, et proposent
quelques widgets tout à fait rudimentaires (dont le widget Core, qui
est juste une fenêtre qui ne réagit à rien), et ensuite il y a des
jeux de widgets disponibles.  L'autre (célèbre) jeu xletters est écrit
en Xt : les boutons et les labels en haut de la fenêtre sont des
widgets Athena (de classe Command, Toggle ou Label), et l'espace de
jeu est un widget Core, que le programme manipule avec des moyens plus
bas niveau que le Xt.

Il y a plusieurs jeux de widgets disponibles pour le X toolkit.  Le
jeu Athena, développé au MIT, est un jeu assez petit et pas très
complet, mais qui a l'avantage d'être léger, standard et gratuit.  Le
jeu Motif de l'OSF est très commun pour les applications commerciales
(comme Netscape), et il n'est pas gratuit (toutefois, il en existe un
clone sous GPL, appelé lesstif).  Motif n'est pas un bon exemple,
toutefois, parce qu'il propose en plus de ses widgets tout un tas de
fonctions qui court-circuitent celles du X toolkit, de sorte qu'on ne
voit plus vraiment le X toolkit quand on programme en Motif.  Je le
trouve assez pénible parce qu'ils veulent absolument obliger le
programmeur à suivre certaines conventions parfois contestables (dans
le cadre de programmes bien précis).  Sinon, il y a un jeu de widgets
OpenLook qui est censé imiter le look de SunTools (et qui en est le
remplaçant).

Sinon, il y a d'autres surcouches de la Xlib qui ont été écrites, qui
remplissent les mêmes fonctions que Xt mais qui sont disjoint de lui.
Entre autres gtk.  Si tu veux développer un gros programme, il faut te
demander longuement à l'avance ce qui est le plus adapté.  Mais pour
un petit truc pas compliqué, je crois que Xt+Athena (Xaw) s'impose.
C'est en tout cas la ligne ``canonique''.  Contrairement à une rumeur
répandue, ce n'est pas compliqué, ni même vraiment long, et c'est très
puissant (en trois lignes tu peux rajouter un éditeur presque complet
dans ton programme).  Là où ça devient très Meta-W-ique, c'est quand
on veut créer ses propres widgets.  Mais pour faire juste des petits
boutons, des popups, des menus, des labels (qui peuvent changer, bien
sûr) et des choses comme ça, ce n'est pas nécessaire.

Pour apprendre la Xlib, les pages man peuvent suffire.  Pour apprendre
le X toolkit, ce n'est plus vraiment le cas, et pour les widgets
Athena, il n'y a pas du tout de pages man.  Il y a deux sources
canoniques de documentation.

D'abord, les manuels O'Reilly intitulés ``The Definitive Guides to the
X Window System''.  Il y en a (je crois) douze volumes (sans compter
le nutshell et les guides de différentes extensions de X) :

Volume 0: X Protocol Reference Manual

Volume 1: Xlib Programming Manual

Volume 2: Xlib Reference Manual

Volume 3: X Window System User's Guide

Volume 4: X Toolkit Intrinsics Programming Manual

Volume 5: X Toolkit Intrinsics Reference Manual [+ référence des
widgets Athena]

Volume 6A: Motif Programming Manual

Volume 6B: Motif Reference Manual

Volume 6C: ?

Volume 7: XView Programming Manual [+ référence]

Volume 8: X Window System Administrator's Guide

Programmer's supplement for X11R6

Les volumes sont assez indépendants les uns des autres.  Les volumes
du type ``Programming Manual'' (volumes 1, 4, 6A) sont très clairs et
sont une excellente introduction au sujet traité.  On y apprend
progressivement les bases et les techniques de programmation.  Ils
sont organisés par sujet.  Les volumes du type ``Reference Manual''
(volumes 2, 5, 6B) contiennent un classement alphabétique des
différentes fonctions, variables, types, widgets et autres.  On y
trouve des informations en général plus complètes que les pages man et
des exemples.  En plus, les volumes 5 et 6B contiennent un index
permuté qui permet de faire l'équivalent de man -k sur papier.

Le volume vraiment indispensable, c'est le volume 4.  C'est mon
préféré.  Pour apprendre à faire des programmes même assez complexes
avec le X toolkit, il est nécessaire et suffisant.  Dans le temps, il
y en avait une édition Athena et une édition Motif : dans les deux cas
il est question des intrinsics, mais les exemples étaient donnés avec
l'un ou l'autre jeu de widgets.  Malheureusement, la version Athena
n'existe plus.  Les widgets Athena proprement dits ne sont donc
documentés que dans le volume 5.

Je précise que je n'ai pas d'actions chez O'Reilly.

L'autre source de documentation fiable, ce sont les documents publiés
par le Consortium X lui-même (pardon, le groupe Open maintenant).
Dans les sources de X ils se trouvent dans le répertoire xc/doc/ et
ils sont au format nroff.  Ces documents sont plus à jour que les
manuels O'Reilly (puisqu'ils viennent avec le programme lui-même),
mais ils sont aussi moins lisibles.  Ce sont des documents de
référence, mais ils sont quand même établis avec un souci didactique
évident.  J'ai lu celui sur la Xlib (avant de m'acheter les manuels
O'Reilly qui vont bien) et celui sur les widgets Athena.  Ils sont
assez bons et si on ne veut pas / ne peut pas s'acheter les guides
O'Reilly, ils peuvent s'y substituer.

En salle S, dans l'armoire magique (pour savoir qui a les clefs, man
salle_S), il y a une édition périmée du volume 0, ainsi que les
volumes 1 et 2.  C'est pour cette raison que xlaby est écrit en Xlib
et non avec le X toolkit, parce que Péter et moi avons appris à
programmer en X grâce à ces livres.  Soit dit en passant, ce serait
une bonne idée à mon avis d'acheter le volume 4 et peut-être le 5, ou
au moins d'imprimer les documents du Consortium sur ces sujets
(attendu, je le répète, que les pages man sont insuffisantes).

Sinon, il y a le moyen de prendre un programme existant et de
comprendre comment il fonctionne.  Le problème c'est que trouver un
programme assez petit pour être clair mais assez gros pour contenir
tout ce qu'on veut apprendre n'est pas toujours trivial.  Une autre
solution est de tomber sur un Wonderful Wizard of X quand il est en
salle S et le persuader de t'aider à écrire un premier programme.  Une
fois le premier écrit, c'est très facile de l'améliorer.

Consulte aussi la faq de comp.windows.x