Index
alphabétique des événements
Dans cette annexe les événements sont présentés par ordre alphabétique sur les types. Les masques permettant de sélectionner les événements (s'il en existe) sont indiqués en caractères machine en face du type considéré. Le type de la structure qui leur est associée figure en italique et son champ d'accès dans un événement event de type XEvent est indiqué en face sur la même ligne.
ButtonPress
ButtonPressMask
ButtonRelease
ButtonReleaseMask
type : XButtonEvent
event.xbutton
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* fenêtre à laquelle est rapporté l’ev. */
Window root; /* racine sur laquelle l'ev. s’est produit */
Window subwindow; /* fenêtre fille dans laquelle s'est produit l'ev. */
Time time; /* heure de l’ev. en millisecondes */
int x, y; /* coordonnées du pointeur relatives à window */
int x_root, y_root; /* coordonnées relatives à root */
unsigned int state; /* masque d'état des boutons et modifieurs */
unsigned int button; /* numéro du bouton */
Bool same_screen; /* vrai si la souris est encore sur le même écran */
} XButtonEvent;
Un bouton de souris est enfoncé ou relâché. On sélectionne ces événements par ButtonPressMask et ButtonReleaseMask. Ces événements sont normalement envoyés à la fenêtre située sous le curseur de souris, sauf en cas de saisie (monopolisation) de la souris. La structure event.xbutton contient les informations suivantes : heure de l'événement, fenêtre recevant l'événement, état des modifieurs, numéro du bouton enfoncé, position du pointeur relativement à la fenêtre ayant reçu l'événement et relativement à la fenêtre racine, etc. Le champ subwindow contient l'identificateur de la fenêtre dans laquelle s'est produit l'événement s'il a eu lieu dans une fenêtre fille de window (cf. chapitre 4, section 4.4. La propagation des événements).
L'événement
ButtonPress déclenche
automatiquement un monopole de la
souris par la fenêtre qui a récupéré cet
événement. Cette fenêtre sera la seule à recevoir
des événements souris jusqu'à ce que tous les boutons
de la souris soient relâchés.
Durant toute cette période, le curseur de souris garde la forme qui lui
était attribuée dans la fenêtre accaparante (même
s'il se trouve à l'extérieur de la fenêtre) et aucune
fenêtre ne reçoit plus d'événement souris. La
fenêtre accaparante, à l'inverse, reçoit les
événements qu'elle a sélectionnés même s'ils
se produisent dans une autre fenêtre.
On peut supprimer cette redirection automatique des événements vers la fenêtre accaparante au niveau de l'application et rendre les événements à la fenêtre de l'application située sous le curseur de souris en ajoutant le masque OwnerGrabButtonMask lors de la sélection de l'événement ButtonPress[1]. Dans ce cas, les événements souris sont envoyés à la fenêtre située sous le curseur de souris, pourvu qu'elle appartienne à l'application propriétaire de la saisie et qu'elle ait sélectionné ces événements. Pour plus d'informations sur ces événements voir le chapitre 5, en particulier les sections 5.1 et 5.2.
CirculateNotify
StructureNotifyMask
SubstructureNotifyMask
type : XCirculateEvent
event.xcirculate
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* la fenêtre recevant l’ev. */
Window window; /* la fenêtre réempilée */
int place; /* PlaceOnTop, PlaceOnBottom */
} XCirculateEvent;
Une fenêtre a été déplacée par suite d'un appel d'un client à XCirculateWindowUp ou XCirculateWindowDown. Si le window manager a empêché cette opération, l'événement ne sera pas envoyé. Cet événement indique l’identificateur de la fenêtre qui a été empilée dans le champ window, et la fenêtre qui a reçu l’événement dans le champ event. L’entier place indique si la fenêtre a été placée en tête ou en queue de file.
CirculateRequest
SubstructureRedirectMask
type : XCirculateRequestEvent
event.xcirculaterequest
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window parent; /* le parent de la fenêtre ré-empilée */
Window window; /* la fenêtre empilée */
int place; /* PlaceOnTop, PlaceOnBottom */
} XCirculateRequestEvent;
L'événement CirculateRequest rapporte qu'un client a fait appel à une requête d'empilement de sous-fenêtres comme XCirculateSubwindowsDown ou Up, ou XCirculateSubwindows. Quand un tel événement est reçu, la requête d'empilement n’a pas été traitée par le serveur, ce qui donne au parent qui a sélectionné l'événement (en général, le window manager) l’opportunité de reformuler la requête (cf. chapitre 1, la redirection des requêtes).
ClientMessage
type : XClientMessageEvent
event.xclient
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* fenêtre à qui l'ev. a été envoyé */
Atom message_type; /* type de la propriété envoyée */
int format; /* format de la propriété */
union {
char b [20];
short s [10];
long l [5];
} data; /* les données elles-mêmes */
} XClientMessageEvent;
L'événement ClientMessage est envoyé directement par un client à une fenêtre quelconque avec la fonction XSendEvent. N’importe quel type d’événement peut être envoyé par cette requête. La fenêtre cible a pu être désignée par PointerWindow (fenêtre contenant le pointeur de souris) ou InputFocus (fenêtre possédant le focus).
Le champ message_type contient un atome qui spécifie une propriété et indique comment les données data doivent être interprétées par le client. Cette interprétation se fera suivant un protocole d'accord entre les clients. On peut imaginer par exemple que ce champ serve à indiquer une sorte de type secondaire pour l'événement. Le champ format spécifie le format de la propriété spécifiée par message_type. Il peut prendre les valeurs 8, 16 ou 32. Le serveur n’interprète pas les données mais impose qu’elles se présentent sous la forme d’une liste d'éléments de 8, 16 ou 32 bits. Les données se présentent toujours sous la forme d’une liste de vingt données dans le format 8-bits, dix données dans le format 16-bits et cinq dans le format 32-bits, que tout l'espace mémoire soit ou non utilisé.
Si votre application souhaite communiquer avec d'autres applications qu'elle‑même (ou une autre occurrence d'elle-même), consultez la documentation sur les ICCCM pour connaître les protocoles les plus standards.
ColormapNotify
ColormapChangeMask
type : XColormapEvent
event.xcolormap
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* celle dont l’attribut change */
Colormap colormap; /* une Colormap ou None */
Bool new;
int state; /* ColormapInstalled, ColormapUninstalled */
} XColormapEvent;
Quelqu'un a modifié la table de couleurs standard ou l'attribut colormap de la fenêtre. S’il n’y a plus de table, le champ colormap est à None. Le champ new indique par True que l’attribut de la fenêtre a changé, et par False que la table a été installée ou désinstallée. Le champ state indique si la table spécifiée dans le champ colormap est ou n'est pas installée.
ConfigureNotify
StructureNotifyMask
SubstructureNotifyMask
type : XConfigureEvent
event.xconfigure
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* celle qui reçoit l’ev. */
Window window; /* celle qui est modifiée */
int x, y; /* les nouvelles composantes relatives au parent */
int width, height; /* les nouvelles dimensions */
int border_width;
Window above; /* la sœur juste dessous */
Bool override_redirect; /* l’attribut de la fenêtre modifiée */
} XConfigureEvent;
Cet événement annonce tout changement survenu dans la configuration géométrique d'une fenêtre (taille, position, bord, ordre d'empilement). On le sélectionne avec le masque StructureNotifyMask. Pour le recevoir pour tous les enfants d'une fenêtre, il suffit de sélectionner SubstructureNotifyMask sur la fenêtre parent. Le champ above précise la fenêtre devant laquelle se trouve la fenêtre reconfigurée dans la pile de ses sœurs. S’il est à None, c’est que la fenêtre se trouve en fond de pile.
ConfigureRequest
SubstructureRedirectMask
type : XConfigureRequestEvent
event.xconfigurerequest
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window parent; /* celle qui a sélectionné l’ev. */
Window window; /* la fenêtre à reconfigurer */
int x, y; /* les arguments de la requête */
int width, height;
int border_width;
Window above;
int detail; /* Above, Below, TopIf, BottomIf, Opposite */
unsigned long value_mask;
} XConfigureRequestEvent;
L'événement ConfigureRequest informe qu'un client a essayé de modifier la taille, la position, le bord et/ou le rang d'empilement de la fenêtre window par une requête (comme XConfigureWindow). La requête n’a cependant pas été satisfaite et ce type d’événement est normalement sélectionné par le window manager. C'est lui qui décide de reformuler la requête ou de l’ignorer. Le champ above indique la sœur devant laquelle la fenêtre à reconfigurer souhaite être placée. S'il vaut None, la fenêtre devrait être placée en fond de pile.
CreateNotify
SubstructureNotifyMask
type : XCreateWindowEvent
event.xcreatewindow
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window parent; /* parent de la fenêtre */
Window window; /* identificateur de la fenêtre créée */
int x, y; /* position de la fenêtre */
int width, height; /* taille de la fenêtre */
int border_width; /* épaisseur du bord */
Bool override_redirect; /* indique si la création devrait être ignorée du
window manager*/
} XCreateWindowEvent;
L'événement CreateNotify informe le client qui le souhaite (a priori le window manager) de la création d'une fenêtre fille. Cet événement est sélectionné par SubstructureNotifyMask sur la fenêtre parent (habituellement la racine de l'écran). Si l’attribut override_redirect est à True, le window manager doit normalement ignorer cet événement. Sinon, il récupère l'identificateur de la fenêtre créée et y sélectionne les événements qui l'intéressent (par exemple ConfigureRequest).
DestroyNotify
SubstructureNotifyMask
type : XDestroyWindowEvent
event.xdestroywindow
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* fenêtre qui a selectionné l’ev. */
Window window; /* la fenêtre détruite */
} XDestroyWindowEvent;
L'événement DestroyNotify informe de la destruction d'une fenêtre. Cet événement est sélectionné par SubstructureNotifyMask sur la fenêtre parent.
EnterNotify
EnterWindowMask
LeaveNotify
LeaveWindowMask
type : XCrossingEvent
event.xcrossing
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre à laquelle est rapportée l’ev. */
Window root; /* racine sur laquelle l'ev. s’est produit */
Window subwindow; /* fenêtre fille */
Time time; /* millisecondes */
int x, y; /* coordonnées du pointeur relatives à window */
int x_root, y_root; /* coordonnées relatives à root */
int mode; /* NotifyNormal, NotifyGrab, NotifyUngrab */
int detail; /* NotifyAncestor, NotifyVirtual, NotifyInferior,
* NotifyNonlinear, NotifyNonlinearVirtual */
Bool same_screen; /* si le pointeur n’a pas changé d’écran */
Bool focus; /* si la fenêtre a le focus */
unsigned int state; /* masque d'état des boutons + modifieurs */
} XCrossingEvent;
La souris est entrée ou sortie d'une fenêtre. Ces événements se produisent lorsque l'on déplace la souris d'une fenêtre à l'autre ou lorsque l'on affiche (ou retire) une fenêtre sous la souris. La fenêtre qui reçoit EnterNotify est avertie qu’elle peut recevoir ensuite des événements souris. Normalement, elle reçoit aussi le focus du clavier, sauf en cas de saisie du clavier ou du focus. Le champ focus de l'événement permet de savoir si la fenêtre bénéficie du focus du clavier. En outre, des événements EnterNotify et LeaveNotify sont envoyés aux fenêtres qui sont traversées virtuellement. Ces fenêtres sont celles qui se trouvent entre la fenêtre d'origine et la fenêtre de destination dans la hiérarchie des fenêtres. (En effet, les ancêtres des fenêtres concernées par les événements d'entrée/sortie sont elles aussi concernées par ces événements, car elles peuvent normalement recevoir les événements souris par propagation.) Dans ce cas, le champ detail de la structure event.xcrossing contient la valeur NotifyVirtual.
Des événements de type EnterNotify et LeaveNotify sont également envoyés quand la souris est saisie et que le pointeur ne se trouvait pas déjà dans la fenêtre accaparante. Dans ce cas, la fenêtre accaparante reçoit un EnterNotify qui lui indique qu’elle va recevoir les événements souris et la fenêtre dans laquelle se trouvait le pointeur reçoit un LeaveNotify. La position du pointeur dans les deux événements est celle qui précédait au déclenchement de la saisie. Quand le monopole se termine, on a émission d'événements symétriques indiquant la fin du processus d'appropriation.
Pour une description complète de ces événements, voir chapitre 5 la section 5.5. qui leur est consacrée.
Expose
ExposureMask
type : XExposeEvent event.xexpose
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre à réafficher */
int x, y; /* la zone à réafficher */
int width, height;
int count; /* nb d'ev. du même type encore à venir */
} XExposeEvent;
Si l'application effectue des dessins à l'écran, ces dessins devront être tracés sur la réception d'un événement de type Expose. Un événement de type Expose est envoyé quand une fenêtre affichée devient visible ou quand une partie précédemment invisible devient visible. C'est l'indication pour l'application qu'elle peut dessiner ou redessiner le contenu de la fenêtre ayant reçu l'événement, dans la zone indiquée par l'événement. Cet événement est sélectionné avec ExposureMask et ne concerne que les fenêtres InputOutput. La structure associée contient la géométrie du rectangle devenu visible et le champ count indique le nombre des autres événements de type Expose encore en attente de réception.
Pour optimiser l'affichage, il est recommandé de ne réafficher les dessins que dans la zone indiquée par l'événement Expose en affectant la zone de clipping du contexte graphique passé en argument à la requête de dessin. Pour optimiser encore davantage, on peut ne dessiner que sur réception d'un événement Expose dont le champ count est à zéro. Dans ce cas, il faut stocker les différents rectangles exposés dans un tableau de XRectangle (tant que le champ count n'est pas à zéro) et dessiner ensuite avec un contexte graphique dont la zone de clipping aura été affectée par la réunion des différents rectangles exposés grâce à la fonction XSetClipRectangles). Pour plus de précision sur ces événements, se reporter à la section 6.5.
FocusIn
FocusChangeMask
FocusOut
type : XFocusChangeEvent
event.xfocus
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* fenêtre de l’événement */
int mode; /* NotifyNormal, NotifyGrab, NotifyUngrab */
int detail; /* NotifyAncestor, NotifyVirtual, NotifyInferior,
* NotifyNonlinear, NotifyNonlinearVirtual,
* NotifyPointer, NotifyPointerRoot,
* NotifyDetailNone */
} XFocusChangeEvent;
FocusIn informe l'application qu'elle a saisi le focus du clavier et FocusOut qu'elle l'a perdu. Ces événements sont envoyés quand le focus d'une fenêtre change après un appel à XSetInputFocus. Cette fonction permet de restreindre le focus à une fenêtre affichée et ses descendantes. (Pour revenir au comportement par défaut, on passera la valeur None à XSetInputFocus comme identificateur de fenêtre.) Ces événements sont analogues à EnterNotify et LeaveNotify mais ils concernent le clavier alors que EnterNotify et LeaveNotify concernent la souris. La fenêtre ayant le focus du clavier et ses descendantes sont les seules à pouvoir recevoir les événements clavier. (Par défaut c'est la fenêtre racine qui a le focus, ce qui a pour effet de transmettre le focus à toute fenêtre dans laquelle se trouve la souris.)
On peut également recevoir des événements de type Focus en cas d'appropriation du clavier. Le champ mode de la structure indiquera s'il s'agit d'événements simples, virtuels ou s'ils résultent d'une appropriation. Le champ detail indique la position exacte de la fenêtre par rapport aux fenêtres suivantes : origine (ancien focus), destination (nouveau focus) et fenêtre contenant la souris au moment du changement de focus. La section 5.6. de ce manuel décrit en détail ces événements.
GraphicsExpose
NoExpose
type : XGraphicsExposeEvent,
event.xgraphicsexpose
XNoExposeEvent
event.xnoexpose
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Drawable drawable; /* fenêtre InputOutput ou Pixmap */
int x, y; /* zone à réafficher */
int width, height;
int count; /* nb d'ev. de même type encore à venir */
int major_code; /* X_CopyArea ou X_CopyPlane */
int minor_code; /* indéfini */
} XGraphicsExposeEvent;
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Drawable drawable;
int major_code; /* X_CopyArea ou X_CopyPlane */
int minor_code; /* zéro, sauf extension */
} XNoExposeEvent;
On ne
sélectionne pas ces événements par des masques. Pour
recevoir ces événements, il faut avoir positionné
l'attribut graphic_exposures du
contexte graphique à True dans
la requête de copie (cf. section 6.4.). Pour tester le champ
major_code il faut avoir inclu le fichier
<X11/Xproto.h>.
Ces événements indiquent si la partie copiée par XCopyArea ou XCopyPlane était effectivement accessible dans la source au moment du traitement de la requête de transfert. Les événements de type GraphicsExpose avertissent de l'échec partiel de la copie quand il est dû à une indisponibilité de la source. En cas d’échec, le serveur envoie un ou plusieurs événements de type GraphicsExpose pour indiquer les zones qui devront être réexposées à la requête de copie.
L'événement de type NoExpose signifie qu'aucun événement de type GraphicsExpose n'est envoyé. Cela peut donc signifier que la source était entièrement disponible (et que la requête a été exécutée avec succès), ou bien que la destination était indisponible (dans ce cas le serveur considère que l'état de la source n'importe pas bien qu'en un certain sens il y ait eu échec total du transfert).
GravityNotify
StructureNotifyMask
SubstructureNotifyMask
type : XGravityEvent
event.xgravity
typedef struct {
int type;
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* la fenêtre qui a sélectionné l’ev. */
Window window; /* la fenêtre qui a bougé */
int x, y; /* nouvelle position relative au parent */
} XGravityEvent;
Un événement de type GravityNotify est émis quand un déplacement de fenêtre est causé par un changement de taille de son parent (cf. section 3.4. Attributs pour les changements de taille des fenêtres).
KeymapNotify
KeymapStateMask
type : XKeymapEvent
event.xkeymap
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* celle qui a reçu FocusIn ou EnterNotify */
char key_vector [32]; /* l’état des touches */
} XKeymapEvent;
Cet événement est envoyé pour permettre aux applications qui le souhaitent de récupérer l'état du clavier avant de lire des entrées. Cet événement est émis juste après un EnterNotify ou un FocusIn — ces deux types d’événements étant susceptibles d’indiquer à l’application qu’elle va recevoir des entrées.
KeymapNotify ne garantit pas que la
fenêtre qui le reçoit ait le focus mais donne l'état
initial de toutes les touches (cf. section 5.6). Le champ key_vector
donne les 256 bits correspondant aux diverses touches. Une touche donnée
a pour keycode la position de son bit
dans le key_vector. On peut
également lire ce vecteur en appelant XQueryKeymap
(mais les performances sont moins bonnes). En fait, cet événement
est peu utilisé car l'état des modifieurs figure dans
l'événement rapportant l'enfoncements d'une touche.
KeyPress
KeyPressMask
KeyRelease
KeyReleaseMask
type : XKeyEvent
event.xkey
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* fenêtre à laquelle est rapporté l’ev. */
Window root; /* racine sur laquelle l’ev. s’est produit */
Window subwindow; /* fenêtre fille */
Time time; /* millisecondes */
int x, y; /* coordonnées du pointeur relatives à window */
int x_root, y_root; /* coordonnées relatives à root */
unsigned int state; /* masque d'état des boutons et modifieurs */
unsigned int keycode; /* détail */
Bool same_screen; /* si le pointeur est encore sur le même écran */
} XKeyEvent;
Une touche du clavier est enfoncée ou relâchée. Pour recevoir ces événements il faut bénéficier du focus du clavier[2] et avoir sélectionné l'événement par KeyPressMask (ou KeyReleaseMask). La structure de l'événement contient le code émis par la touche dans le champ keycode.
L'événement permet en outre de connaître l'état des modifieurs (ce sont les touches Shift, Control, MetaLeft, MetaRight, Compose etc.) et l'état des boutons grâce à la valeur du masque fournie dans le champ state.
On interprète généralement le code émis par la touche à partir de l'événement grâce à la fonction XLookupString (XmbLookupString et XwcLookupString dans la Release 5). Ces fonctions permettent de récupérer à la fois le code symbolique associé à l’événement compte tenu de l’état des modifieurs, et la chaîne ASCII qui lui est associée, si elle existe[3]. (La fonction XKeycodeToKeysym permet également d'effectuer la conversion mais nécessite de tester l’état des modifieurs.)
Pour
reconnaître les codes symboliques et les constantes de retour fournies
par XLookupString il faut inclure les
fichiers <X11/keysym.h> et <X11/Xutil.h>.
LeaveNotify
LeaveWindowMask
type : XCrossingEvent
event.xcrossing
cf. la description de EnterNotify.
MapNotify
StructureNotifyMask
UnmapNotify
SubstructureNotifyMask
types : XMapEvent
event.xmap
XUnmapEvent
event.xunmap
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* celle qui a sélectionné l’ev. */
Window window; /* fenêtre affichée */
Bool override_redirect; /* valeur de l’attribut de window */
} XMapEvent;
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* celle qui a reçu l’ev. */
Window window; /* fenêtre supprimée de l'affichage */
Bool from_configure; /* pour indiquer l’origine de l’ev. */
} XUnmapEvent;
Ces événements sont envoyés par le serveur quand une fenêtre passe de l'état Map à Unmap et vice versa. Le booléen from_configure permet de distinguer les événements de type UnmapNotify qui proviennent d’une requête de reconfiguration de ceux qui proviennent d’un changement de taille du parent quand la fenêtre a positionné l'attribut win_gravity à UnmapGravity (cf. la description de win_gravity dans le chapitre 3 sur les fenêtres).
MappingNotify
type : XMappingEvent
event.xmapping
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* non utilisé */
int request; /* MappingModifier, MappingKeyboard,
* ou MappingPointer */
int first_keycode; /* premier code modifié s’il y en a */
int count; /* nb des codes modifiés */
} XMappingEvent;
L'événement MappingNotify informe qu'un changement d'association a été effectué par un autre client sur les liens concernant le clavier ou la souris. Cet événement peut provenir d’un appel à :
• XChangeKeyboardMapping, qui modifie les liens entre les codes physiques keycode et les codes symboliques keysym.
• XSetModifierMapping, qui modifie les liens entre les touches et les modifieurs logiques.
• XSetPointerMapping, qui modifie les liens entre les boutons physiques et les bouton logiques de la souris.
Le champ request de l’événement indique le type de modification effectuée. La réaction normale à un changement sur les touches (champ request à MappingKeyboard) est un appel à XRefreshKeyboardMapping pour remettre à jour les tables locales.
Une application ne doit normalement pas réagir aux autres requêtes (MappingPointer ou MappingModifier) car elle doit n’utiliser que les liens symboliques pour permettre à l’utilisateur de les changer au besoin. (Si cependant l’application utilise des liaisons physiques particulières elle peut appeler XGetModifierMapping ou XGetPointerMapping pour connaître les nouvelles associations.)
MapRequest
SubstructureRedirectMask
type : XMapRequestEvent
event.xmaprequest
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window parent; /* parent de la fenêtre à afficher */
Window window; /* fenêtre à afficher */
} XMapRequestEvent;
Cet événement est envoyé pour informer qu'un appel à XMapRaised ou à XMapWindow a été effectué par un client, mais la fenêtre qui était l'objet de la requête n’a cependant pas été affichée quand cet événement est reçu. Cet événement est sélectionné par le window manager avec le masque SubstructureRedirectMask sur la fenêtre parent. L'attribut override_redirect de la fenêtre considérée doit normalement être à False pour que l'événement soit reçu. Au lieu d’afficher la fenêtre sur la requête, le serveur envoie cet événement à l’unique client (le premier) qui l’aura sélectionné. Ce mécanisme porte le nom de redirection des requêtes. Il permet au window manager de réviser la taille ou la position de la fenêtre avant de l’afficher lui-même en y rajoutant des décorations.
MotionNotify
PointerMotionMask
ButtonMotionMask
Button<N>MotionMask
type : XMotionEvent
event.xmotion
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre à laquelle est rapportée l’ev. */
Window root; /* racine sur laquelle s’est produit l’ev. */
Window subwindow; /* fenêtre fille */
Time time; /* millisecondes */
int x, y; /* coordonnées du pointeur relatives à window */
int x_root, y_root; /* coordonnées relatives à root */
unsigned int state; /* masque d'état des boutons + modifieurs */
char is_hint; /* si c’est une trace */
Bool same_screen; /* si le pointeur est resté sur le même écran */
} XMotionEvent;
La
souris a bougé. Cet événement peut être
envoyé pour un mouvement quelconque de souris s'il a été
sélectionné avec PointerMotionMask.
On peut cependant restreindre l'envoi des événements aux
mouvements se produisant avec un bouton enfoncé en utilisant ButtonMotionMask, ou Button<n>MotionMask (n prévu de 1 à 5) au
lieu de PointerMotionMask. Les cinq
masques Button<n>MotionMask
permettent de spécifier précisément quel bouton est
enfoncé et on peut les combiner entre eux.
En outre, on peut combiner les masques de sélection avec le masque PointerMotionHintMask qui précise qu'un nouveau mouvement de souris doit être envoyé quand on sera dans la situation suivante :
- un changement d'état (enfoncé/relâché) d'une touche ou d'un bouton se produit
- la souris sort de la fenêtre
- le client fait un appel à XQueryPointer ou à XGetMotionEvents.
Le
masque PointerMotionHintMask ne sélectionne
pas en lui-même d'événement mais il instaure un
mécanisme d'envoi d'événements qui permet de mieux suivre
les mouvements de la souris (cf. sections 5.2. et 5.3.).
NoExpose
type : XNoExposeEvent
event.xnoexpose
cf.
la description de GraphicsExpose.
PropertyNotify
PropertyChangeMask
type : XPropertyEvent
event.xproperty
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre dont la propriété à été modifiée */
Atom atom; /* la propriété modifiée */
Time time; /* heure de la modification */
int state; /* NewValue, Deleted */
} XPropertyEvent;
L'événement PropertyNotify indique qu'une propriété de la fenêtre a été modifiée - à tout le moins qu'il y a été rajouté une chaîne de longueur zéro. Cet événement rapporte l'heure de la modification et le nom (Atom) de la propriété modifiée.
ReparentNotify
StructureNotifyMask
SubstructureNotifyMask
type : XReparentEvent
event.xreparent
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window event; /* celle qui reçoit l’ev. */
Window window; /* celle dont le parent a changé */
Window parent; /* le nouveau parent */
int x, y; /* coordonnées relatives au nouveau parent */
Bool override_redirect; /* celui de la fenêtre "reparentée" (window) */
} XReparentEvent;
L'événement ReparentNotify indique que le parent de la fenêtre window a changé. Il est important de sélectionner cet événement si l'on s'intéresse à la position d'une fenêtre fille de la racine, car celle-ci est susceptible d'être "reparentée" par un window manager. L'événement contient l'identificateur du nouveau parent et les coordonnées de la fenêtre relativement à ce nouveau parent.
ResizeRequest
ResizeRedirectMask
type : XResizeRequestEvent
event.xresizerequest
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre devant être retaillée */
int width, height; /* les dimensions souhaitées, sans les bords */
} XResizeRequestEvent;
L’événement ResizeRequest indique qu'un autre client souhaite changer la taille de la fenêtre (alors que celle-ci n'a pas changée). Un seul client (habituellement le window manager) peut sélectionner cet événement car il entraîne un mécanisme de redirection. Quand il a été sélectionné, le serveur émet cet événement au lieu de valider la requête de changement de taille.
SelectionClear
type : XSelectionClearEvent
event.xselectionclear
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window; /* la fenêtre qui reçoit l’ev. et perd la sélection */
Atom selection; /* la sélection dont on perd la propriété */
Time time; /* l’instant du changement enregistré */
} XSelectionClearEvent;
L'événement SelectionClear rapporte au propriétaire courant de la sélection qu'un nouveau propriétaire a été défini. Cet événement n'est pas sélectionné par masque, mais toujours envoyé à l'ancien propriétaire d'une sélection lorsqu'un autre client appelle XSetSelectionOwner pour la même sélection. La fonction XSetSelectionOwner admet les arguments suivants :
XSetSelectionOwner (dpy, selection, owner, time)
Atom selection ;
Window owner ;
Time time ;
Si l'application elle-même fait appel à XSetSelectionOwner elle recevra cet événement.
SelectionNotify
type : XSelectionEvent
event.xselection
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window requestor; /* la fenêtre de l'appel à XConvertSelection */
Atom selection;
Atom target; /* type des données */
Atom property; /* un atome ou None */
Time time;
} XSelectionEvent;
Cet événement est envoyé directement par un client (avec XSendEvent) à la fenêtre de l'application qui a fait un appel à XConvertSelection (cf. la description de l'événement SelectionRequest). L'envoi aura été effectué après que la sélection ait été convertie et stockée dans une propriété, ou bien même lorsque la conversion demandée n'aura pu être effectuée (ce qui sera alors indiqué par un champ property à None). Si l'application elle-même appelle XConvertSelection, elle doit recevoir cet événement. Rappelons que la fonction XConvertSelection admet les arguments suivants :
XConvertSelection (dpy, selection, target, property, requestor, time)
Atom selection, target, property ;
Window requestor ;
Time time ;
Les champs de l’événement ont les mêmes valeurs que celles spécifiées dans la requête à XConvertSelection qui a provoqué l’envoi de cet événement par le propriétaire — à ceci près que le champ property peut, soit spécifier l’atome de la propriété indiquée par le demandeur (le type cible étant alors indiqué dans target), soit être à None, ce qui indique que les données n’ont pu être converties dans le type cible (target).
SelectionRequest
type : XSelectionRequestEvent
event.xselectionrequest
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window owner; /* le propriétaire */
Window requestor; /* le demandeur */
Atom selection; /* la sélection demandée */
Atom target; /* le type cible de conversion */
Atom property;
Time time;
} XSelectionRequestEvent;
SelectionRequest est envoyé au propriétaire de la sélection quand un autre client en demande le contenu par XConvertSelection. Le propriétaire est alors tenu d’envoyer en réponse un événement SelectionNotify à la fenêtre intéressée. Les champs de cet événement ont les valeurs spécifiées dans la requête à XConvertSelection qui a déclenché l’envoi de cet événement. Le propriétaire est tenu de convertir (si possible) la sélection en se basant sur le type spécifié dans target. Si une propriété est spécifiée, le propriétaire doit stocker les résultats sur cette propriété de la fenêtre requestor et envoyer un événement de type SelectionNotify à cette fenêtre par XSendEvent. S’il ne peut satisfaire la demande spécifiée, le propriétaire doit envoyer un événement SelectionNotify de champ property à None.
UnmapNotify
SubstructureNotifyMask
StructureNotifyMask
types : XUnmapEvent
event.xunmap
cf.
description de MapNotify.
VisibilityNotify
VisibilityChangeMask
type : XVisibilityEvent
event.xvisibility
typedef struct {
int type; /* type de l’événement */
unsigned long serial; /* n° de la dernière requête traitée par le serveur */
Bool send_event; /* vrai si l’ev. provient d’un appel à XSendEvent */
Display *display; /* terminal sur lequel l’ev. s’est produit */
Window window;
int state; /* constante d’état de visibilité */
} XVisibilityEvent;
L'événement VisibilityNotify rapporte tout changement de visibilité dans une fenêtre de type InputOutput. Les fenêtres de classe InputOnly ne peuvent recevoir ce type d’événement et les sous-fenêtres d’une fenêtre donnée sont ignorées dans le calcul de la visibilité. Le champ state peut valoir VisibilityUnobscured, VisibilityPartiallyObscured ou VisibilityFullyObscured.