Main Loop Hooks/fr

│ English (en) │ français (fr) │ 日本語 (ja) │ slovenčina (sk) │ 中文（中国大陆） (zh_CN) │

Enoncé du problème

Vous devez attendre un événement (sur le socket[1] ou pipe ou ...) qui arrive, mais vous voulez faire cela dans le processus principal (GUI) et vous ne voulez pas bloquer le GUI et aussi vous ne voulez pas faire du multi-threading. La solution à ce problème est la possibilité d'ajouter des "handles" [2] supplémentaires pour être observés dans la boucle d'événement principale.

Les détails de la Solution

Dans l'unité LCLIntf deux fonctions ont été ajoutées pour tenir compte de cette fonctionnalité, ce sont :

AddEventHandler(AHandle: THandle; AFlags: dword; 
    AEventHandler: TWaitHandleEvent; AData: PtrInt): PEventHandler;
RemoveEventHandler(var AHandler: PEventHandler);
SetEventHandlerFlags(AHandler: PEventHandler; NewFlags: dword);

Le TWaitHandleEvent est déclaré dans l'unité InterfaceBase comme :

 TWaitHandleEvent = procedure(AData: PtrInt; AFlags: dword) of object;

AddEventHandler ajoute un handle pour être observé dans la boucle d'évênement principale. Quand le handle est "signalé ", alors la procédure indiqué dans ACallback sera appellé avec comme paramètre AData qui était passé lors de l'enregistrement du traiteur d'évênement, et tous drapeaux , qui dont spécifiques au système d'exploitation. Le drapeau passés à AddEventHandler peut être modifié en utilisants le SetEventHandlerFlags. Le handler retourné (un pointeur) par AddEventHandler devrait être passé à RemoveEventHandler pour cesser d'observer l'handle associée .

RemoveEventHandler arrête d'observer l'handle spécifié. RemoveEventHandler fixera AHandler à nil avant le renvoi . Son argument est un pointeur retourné par AddEventHandler.

Windows

Le paramètre AFlags dans AddEventHandler n'est pas utilisé, et le AFlags dans TWaitHandleEvent a pour valeur dans l'implémentation actuelle.

Win32 supportes les types de handeles suivants, basiquement les choses supportées par MsgWaitForMultipleObjects:

• notifications de changement (pour les fichiers et dossiers)
• entrées de console (console input)
• events: signalés avec la fonction winapi SetEvent
• mutexes: signalés quand il n 'est plus possédé par quoi que ce soit
• processes: signalés quand ils sont terminés
• semaphore: signalés quand son count est supérieur à 0
• threads: signalés quand ils sont terminés
• timers: signalés quand ils expirent, voir SetWaitableTimer

Gtk/Unix

Le paramètre AFlags de AddEventHandler spécifie la condition dans laquelle le handle devrait être signalé, avec pour valeurs possibles celles documentées dans le type GIOCondition dans la référence glib.

Dans le callback, AFlags contiendra la condition, comme référencée dans le type GIOCondition vu ci-dessus, qui doit être satistfaite.

Gtk/unix supporte les types de handles suivants:

• fichiers
• sockets
• pipes

Notez que win32 ne supporte pas les sockets ou les pipes (du moins, leur usage est "découragé" par MSDN). Suggestion: utiliser WSAEventSelect pour créer un évenement associé à une socket et passer le handle d'évenement.

Pipes et Terminaison de Processus

Pour offrir une solution cross-platform pour les pipes (mal supportés sous win32) et les processus (mal supportés sous gtk/unix) des fonctions additionnelles ont été ajoutées:

TChildExitReason = (cerExit, cerSignal);
TPipeReason = (prDataAvailable, prBroken, prCanWrite);
TPipeReasons = set of TPipeReason;

TChildExitEvent = procedure(AData: PtrInt; AReason: TChildExitReason; AInfo: dword) of object;
TPipeEvent = procedure(AData: PtrInt; AReasons: TPipeReasons) of object;

function  AddProcessEventHandler(AHandle: THandle; 
    AEventHandler: TChildExitEvent; AData: PtrInt): PProcessEventHandler;
procedure RemoveProcessEventHandler(var AHandler: PProcessEventHandler);

function  AddPipeEventHandler(AHandle: THandle; 
    AEventHandler: TPipeEvent; AData: PtrInt): PPipeEventHandler;
procedure RemovePipeEventHandler(var AHandler: PPipeEventHandler);

Quand un processus se termine le handler d'événement spécifié sera appelé. AInfo contiendra le code de sortie si AReason est cerExit, ou (sous unix seulement) le signal de terminaison si AReason est cerSignal. Pour gtk/unix, utilisez le PID pour surveiller en tant que AHandle. En interne, un handler de signal est installé pour surveiller le signal SIGCHLD. Sous win32, AddEventHandler est utilisé pour surveiller la terminaison de processus.

Pour surveiller les données entrantes d'un pipe, passez le descripteur de fichier (unix) ou le handle de la partie lecture du pipe à AddPipeEventHandler avec une méthode de handler d'événement personnalisé choisi en tant que AEventHandler. Sous gtk/unix, AddEventHandler est appelé pour surveiller le traffic sur le descripteur de fichier. Sous win32, la boucle de message fait un timeout toutes les 100 msecs pour vérifier s'il y a des données disponibles sur tous les pipes surveillés; si des données sont disponibles, le handler d'événement est appelé.