FR 2738943 A1 19970321 FR 9611424 A 19960919 Domaine de l'invention La présente invention concerne un système d'affichage graphique indépendant qui permet de partager des dispositifs d'entrée avec d'autres systèmes d'affichage graphique indépendants. Plus particulièrement, l'invention concerne un dispositif de logiciel qui permet l'utilisation d'une souris simultanément par une pluralité d'appareils d'affichage graphique indépendants. Arrière-plan de l'invention L'utilisation d'une souris comportant un curseur correspondant sur un terminal d'affichage afin d'interagir avec un programme d'ordinateur est bien connue. L'utilisation d'un clavier pour entrer du texte ou toute autre donnée et/ou pour déplacer un curseur sur un terminal d'affichage est également bien connue. Dans certains environnements, il est souhaitable de disposer de multiples terminaux d'affichage positionnes physiquement de manière à être adjacents les uns aux autres de telle sorte qu'ils puissent être utilisés en conjonction les uns avec les autres. Un exemple d'un tel environnement est une station de contrôle de trafic aérien. Plus particulièrement, une pluralité de terminaux d'affichage peuvent être utilisés pour représenter une partie d'un espace aérien important au voisinage d'un aéroport. Chaque terminal représente une partie de l'espace aérien total qu'il est souhaitable de surveiller. Les terminaux de la pluralité de terminaux considérés ensemble représentent l'espace aérien total. Dans des conditions normales, un contrôleur de trafic aérien peut se voir assigner une partie de l'espace aérien représentée par un unique terminal d'affichage. Le contrôleur disposerait d'un clavier et d'une souris en vue d'une utilisation en conjonction avec ce terminal d'affichage particulier. Par exemple, lorsqu'un écho (un réseau de pixels éclairés) représentant un avion apparaît sur son écran d'affichage, le contrôleur de trafic aérien peut déplacer sa souris afin de positionner le curseur de souris audessus de cet écho et peut cliquer dessus afin d'ouvrir une boite pour entrer une information. Le contrôleur peut ensuite utiliser le clavier pour entrer une information pertinente pour cet écho telle qu'une information identifiant la ligne aérienne et le numéro de vol de l'avion représenté par l'écho et toute autre information. Normalement, chaque terminal d'affichage se voit associer sa propre station de travail séparée, laquelle inclut un clavier et une souris. Il est souvent souhaitable de permettre à un contrôleur de trafic aérien de contrôler l'espace aérien représenté par une multiplicité des écrans d'affichage. Dans une telle situation, il serait extrêmement commode que le contrôleur de trafic aérien puisse commuter des claviers et des souris chaque fois qu'il a à manipuler des données sur un écran d'affichage/une station de travail différent(e). Par conséquent, on connait dans l'art antérieur des systèmes permettant à un clavier et une souris d'une unique station de travail d'être établis pour contrôler une pluralité de terminaux d'affichage. Dans ces systèmes, une carte de contrôleur d'affichage pour chaque terminal d'affichage est enfichée dans une fente séparée d'une unique station de travail. Un logiciel de liaison conçu spécialement est déroulé sur cette station de travail, lequel logiciel relie toutes les cartes d'affichage ensemble et permet à l'unique jeu clavier et souris associé à cette station de travail d'être utilisé en connexion avec celui quelconque des terminaux d'affichage qui est associé à cette station de travail. Un inconvénient de ce type de système réside dans le fait que les divers terminaux d'affichage doivent pouvoir être supportés par le logiciel de liaison. Dans le monde réel, ceci signifie de façon générale que les terminaux d'affichage doivent être identiques les uns aux autres ou au moins fabriqués par le même fabricant. Par ailleurs, le logiciel de liaison utilise fréquemment des extensions par rapport au langage d'affichage de base. Par exemple, le logiciel d'affichage de contrôle de trafic aérien utilise typiquement le langage et le protocole X-Windows, lesquels comprennent 212 commandes standardisées. Cependant, un logiciel de commande de multiples écrans utilise classiquement des extensions par rapport au langage de base. Ce logiciel peut être utilisé seulement avec des affichages et des cartes de contrôleur graphique qui supportent ces extensions particulières. Ceci limite sévèrement la sélection des terminaux d'affichage. La figure 1 est un schéma fonctionnel de logiciel qui représente de façon générale un système d'affichage d'ordinateur typique tel qu'un système de contrôle de trafic aérien qui utilise le langage et le protocole X-Windows. Dans le schéma fonctionnel de logiciel de cette application, des éléments représentés par des cadres rectangulaires sont des composants et des éléments représentés par des cadres ovoïdes ou circulaires concernent le logiciel. Un ordinateur hôte 10 se voit associer un clavier 12, une souris 14 et un terminal d'affichage 16. Plusieurs éléments de logiciel sont déroulés sur l'ordinateur hôte , y compris un système d'exploitation 18 tel que par exemple UNIX, une pluralité de programmes d'application (ou client) 20a, 20b et 20c et un programme de serveur X 22. Le logiciel client peut comprendre par exemple un programme de système de contrôle de trafic aérien, un programme de traitement de texte, un programme de tableur etc... La couche de logiciel du serveur X 22 inclut un dispositif de pilotage 24 pour piloter l'affichage 16. Fondamentalement, le serveur X reçoit des données en provenance des dispositifs d'entrée (par exemple le clavier et la souris) par l'intermédiaire du système d'exploitation ainsi que des commandes X provenant des clients et traite ces commandes et données afin de piloter l'affichage en conformité avec. Le serveur X peut également envoyer une information de protocole X (appelée événements) au client ou système d'exploitation soit directement depuis la couche de serveur X, soit depuis l'affichage par l'intermédiaire de la couche de serveur X. Un flux de données depuis la couche de serveur X jusqu'aux clients ou système d'exploitation est déclenché typiquement par exemple en réponse au serveur X qui reçoit des données de déplacement de curseur depuis une souris. Plus spécifiquement, des programmes d'application ont typiquement besoin de connaître o le curseur de souris apparaît sur l'écran. Par conséquent, lorsque le serveur X reçoit des données de déplacement de souris provenant de la souris, il envoie typiquement des événements sur un ou plusieurs programmes d'application pour l'informer ou les informer du déplacement et/ou de la position du curseur. Le clavier 12 et la souris 14 communiquent avec le logiciel client 20a, 20b, 20c et l'affichage 16 par l'intermédiaire de la couche UNIX et du serveur X 22. Les programmes client et la couche de logiciel UNIX 18 communiquent avec le terminal d'affichage 16 par l'intermédiaire de la couche de logiciel de serveur X. Plus particulièrement, chaque client peut envoyer des commandes X-Windows au serveur X 22. Le logiciel de serveur X 22 reçoit les commandes et pilote le terminal d'affichage 16 tel que dicté par les commandes reçues depuis les programmes client. Certaines commandes de protocole X nécessitent des réponses soit depuis le serveur X, soit depuis le dispositif d'affichage (par l'intermédiaire du serveur X). Par conséquent, les voies de communication entre les programmes client et le serveur X sont représentées comme étant des voies bidirectionnelles. Comme il sera décrit de manière davantage détaillée ci-après, un unique serveur X peut piloter un unique affichage (comme représenté sur la figure 1) ou de multiples affichages. En outre, un programme client peut communiquer avec un ou plusieurs serveurs X. Par conséquent, un programme client peut générer des modifications au niveau de l'affichage sur de multiples affichages par l'intermédiaire de l'un ou l'autre de ces mécanismes ou des deux. Par ailleurs, un client peut communiquer avec les serveurs X et les affichages sur le même ordinateur hôte ou sur des ordinateurs hôtes différents. Bien entendu, afin de communiquer avec des serveurs X et des affichages sur différents hôtes, l'ordinateur sur lequel le programme client est résident et l'ordinateur sur lequel la couche de serveur X particulière est résidente doivent être connectés par l'intermédiaire d'une liaison de communication telle qu'un réseau local (RLE). De fait, une pluralité de clients sur une pluralité d'ordinateurs hôtes différents peuvent communiquer par l'intermédiaire d'une liaison RLE ou de toute autre liaison de communication avec un ou plusieurs serveurs X (chaque serveur pilotant un ou plusieurs terminaux d'affichage) sur d'autres ordinateurs hôtes (ou sur un terminal X libre). X-Windows constitue un environnement variable qui permet au programme client de spécifier l'affichage sur lequel des données ou des commandes sont en train d'être envoyées. Plus particulièrement, X- Windows constitue un environnement variable appelé AFFICHAGE (affichage). La variable AFFICHAGE est suivie par un nom d'hôte (qui par exemple est une adresse éthernet identifiant l'ordinateur hôte ou terminal X contenant l'affichage avec lequel il convient de communiquer). Le nom d'hôte est suivi par un numéro de serveur et par un numéro d'écran. Par conséquent, en identifiant l'hôte, le serveur sur l'hôte et l'écran sur ce serveur, la variable d'environnement AFFICHAGE spécifie un affichage particulier sur lequel il est en train d'envoyer des commandes de protocole X. Bien entendu, un client peut spécifier plus d'un affichage si nécessaire. Selon une variante, le dispositif d'affichage particulier peut être spécifié par un paramètre de chaîne mobile. Classiquement cependant, le logiciel client utilise diverses extensions par rapport au langage X-Windows standard. Par conséquent, les terminaux d'affichage et d'autres matériels utilisés dans le système doivent également supporter les extensions de langage spécifique utilisées par le logiciel client. Lorsque ces extensions doivent être supportées, ceci limite significativement la sélection des matériels disponibles pour un concepteur système. Certains groupes d'extensions X sont standardisés et bien connus. D'autres peuvent être entièrement personnalisés. Le langage X-Windows constitue un mécanisme au moyen duquel une unique souris peut être utilisée simultanément en conjonction avec une pluralité d'écrans de telle sorte qu'un unique jeu curseur souris et clavier puisse se déplacer entre des écrans. Ceci est connu en tant que mode à multiples écrans. La figure 2 représente de façon générale un système dans lequel un unique jeu clavier et souris est utilisé en commun avec une pluralité d'écrans dans un mode à multiples écrans X-Windows. Selon cet exemple, un ordinateur hôte 20 fait fonctionner un système d'exploitation 22 tel que UNIX. L'ordinateur hôte 20 fait fonctionner également un ou plusieurs programmes d'application tels qu'un programme de contrôle de trafic aérien 24. Un logiciel de serveur X 26 réalise une interface entre les écrans 28, 30 et 32 et le programme client 24. Un clavier 34 et une souris 36 sont couplés à l'ordinateur hôte 20. Le clavier et la souris peuvent être utilisés pour entrer des instructions ou des données utilisées par des programmes client. Comme préalablement noté, le clavier et la souris communiquent avec le programme d'application client et l'écran d'affichage par l'intermédiaire de la couche de logiciel de système d'exploitation et de la couche de logiciel de serveur X. Dans un mode à multiples écrans, de multiples écrans sont pilotés par un unique serveur X de telle sorte qu'un unique curseur souris peut être déplacé depuis un écran jusqu'à un autre écran. En d'autres termes, par report à la figure 2, si la souris est déplacée vers la droite sur l'écran 28 jusqu'au bord le plus à droite de l'écran 28, elle disparaît de l'écran 28 et elle apparaît au niveau du bord le plus à gauche de l'écran 30. Lorsque le curseur continue son déplacement vers la droite au travers de l'écran 30 et atteint le bord le plus à droite de cet écran, il réalise un bouclage et réapparaît au niveau du bord le plus à gauche de l'écran 28 et il continue à se déplacer vers la droite sur l'écran 28. Le clavier peut être amené à suivre la souris depuis un écran jusqu'à un autre écran de telle sorte que l'activation des touches du clavier affecte l'écran (et des programmes client en interface avec l'écran) sur lequel le curseur souris apparaît. Certains des problèmes associés à l'utilisation du mode à multiples écrans de X-Windows sont représentés sur la figure 3. Sur la figure 3, des écrans 40 et 42 sont de deux types d'écran différents (par exemple de tailles différentes et de fabrications différentes). L'ordinateur hôte inclut une carte de contrôleur graphique 48 et 50 pour chaque écran. Chaque carte de contrôleur graphique est fournie par le vendeur de l'appareil d'affichage (écran) qu'elle commande et elles sont différentes les unes des autres. Le serveur X inclut des éléments distincts de logiciel de pilotage 44 et 46 pour respectivement piloter chaque carte de contrôleur graphique 48 et 50. Par conséquent, le logiciel de serveur X doit être développé pour l'écran ou les écrans particuliers qui doivent être pilotés par celui-ci. Par conséquent, chaque fois qu'un écran ou un contrôleur de carte graphique est remplacé ou modifié, le logiciel de serveur X doit également être remplacé ou modifié. Dans l'industrie des logiciels et plus particulièrement dans l'industrie des affichages graphiques, les produits sont mis à jour ou remplacés selon une moyenne d'environ tous les deux ans. Par conséquent, il est souhaitable de disposer d'une isolation aussi importante que possible entre des composants de logiciel de telle sorte que lorsqu'un composant de logiciel est remplacé ou modifié, d'autres composants de logiciel n'aient pas besoin d'être remplacés ou modifiés. Cependant, comme représenté par la figure 3, chaque fois qu'un contrôleur d'écran ou graphique est remplacé ou modifié, le logiciel de serveur X doit également être remplacé ou modifié. Par conséquent, un objet de la présente invention consiste à proposer un procédé et un appareil d'affichage graphique améliorés dans lesquels des claviers souris peuvent être partagés par divers appareils d'affichage indépendants. Plus particulièrement, un objet de la présente invention consiste à proposer un procédé et un appareil d'affichage graphique indépendant qui permettent l'utilisation d'un unique clavier et/ou d'une unique souris en conjonction avec un fonctionnement du type à multiples écrans avec une pluralité de terminaux d'affichage non afférents. Un autre objet de la présente invention consiste à proposer un procédé et un appareil d'affichage graphique indépendant qui permettent l'utilisation d'un unique clavier et/ou d'une unique souris en conjonction avec un large réseau de terminaux d'affichage fabriqués par différents fabricants sans personnalisation du logiciel de serveur X pour piloter les terminaux d'affichage. Selon encore un autre objet de la présente invention, on propose un procédé et un appareil d'affichage graphique indépendant qui permettent à un unique clavier et/ou une unique souris de contrôler une pluralité de terminaux d'affichage différents en utilisant seulement les commandes de logiciel X-Windows standards. Résumé de l'invention L'invention est constituée par un procédé et un appareil permettant l'utilisation d'un unique clavier et/ou d'une unique souris associé(e) à une première station de travail lors d'un fonctionnement du type à multiples écrans avec une pluralité de terminaux d'affichage (écrans) non uniformes couplés à une pluralité de serveurs X résidant sur une pluralité de stations de travail. Par exemple, lorsqu'un utilisateur manipule une souris pour forcer un curseur souris à se déplacer sur un premier terminal d'affichage de la gauche vers la droite, le curseur atteindra éventuellement le bord droit de cet affichage. Normalement, le curseur souris s'arrête de se déplacer vers la droite lorsqu'il atteint le bord droit de l'affichage même si l'utilisateur continue à déplacer la souris vers la droite. Selon la présente invention cependant, une construction de logiciel fait que le curseur souris disparaît du premier affichage et apparaît au niveau du bord le plus à gauche d'un second affichage et continue à se déplacer vers la droite sur le second affichage. Le clavier suit automatiquement le curseur souris jusqu'au nouvel écran de telle sorte que le fonctionnement du clavier affecte les données affichées seulement sur l'écran dans lequel le curseur souris apparaît présentement. Un élément de logiciel (ci-après appelé logiciel de gestionnaire de périphérique) séparé d'un quelconque logiciel de serveur X ou d'un quelconque logiciel de contrôle d'affichage fonctionne sur une station de travail particulière afin d'assurer ce fonctionnement. Chaque serveur X inclut un dispositif de pilotage pour piloter une ou plusieurs cartes de contrôleur graphique. Chaque carte est associée à l'un des écrans. Chaque serveur X est également couplé à un ou plusieurs programmes client tels qu'un programme de contrôle de trafic aérien. L'un des écrans d'affichage est sélectionné en tant qu'écran primaire, tous les autres écrans étant considérés en tant qu'écrans secondaires. Le logiciel de gestionnaire de périphérique est traité par les serveurs X en tant qu'autre programme client. Lorsque le curseur se trouve sur l'écran primaire, la souris et le clavier communiquent avec les programmes client et l'affichage par l'intermédiaire d'un serveur X d'une façon essentiellement normale, le gestionnaire de périphérique observant simplement les événements X provenant du serveur X qui se rapportent au curseur entrant dans une fenêtre de transition prédéfinie sur l'écran. Une fenêtre de transition est une partie d'un bord de l'écran qui a été définie en tant que frontière entre l'écran et un autre écran ou tout ce bord. Lorsque le curseur entre dans une fenêtre de transition sur un écran secondaire, le gestionnaire de périphérique délivre une commande de clavier GRAB (extraction) et une commande de souris EXTRACTION au serveur X pour l'écran primaire, d'o l'interception de tous les événements de clavier et de souris tout en ne permettant pas à un quelconque autre client de les recevoir. Il y a ensuite masquage du curseur sur l'écran primaire afin de faire en sorte qu'il disparaisse de l'écran primaire et déplacement d'un curseur souris et positionnement de celui-ci au niveau de l'emplacement approprié sur l'écran secondaire. Il y a également simulation de tous les événements souris et clavier reçus interceptés en provenance du serveur X d'écran primaire et envoi de ceux-ci sur le serveur X associé à l'écran secondaire. Le serveur X associé à l'écran secondaire peut être le même serveur X que celui associé à l'écran primaire. Dans ce cas, la partie d'identification (ID) d'écran de la commande est modifiée afin d'identifier l'écran secondaire au lieu de l'écran primaire. En outre, le gestionnaire de périphérique repositionne le curseur maintenant invisible sur l'écran primaire à la même position relative que le point au niveau duquel il apparaît sur l'écran secondaire. Cette dernière fonction est réalisée du fait que le déplacement du curseur continuera à être suivi par le gestionnaire de périphérique sur l'écran primaire et à être simulé sur l'écran secondaire. Par conséquent, le curseur invisible sur l'écran primaire doit correspondre en position relative au curseur visible sur l'écran secondaire. Si les écrans primaire et secondaire ne présentent pas une taille et une résolution identiques, l'échelle des événements simulés par rapport aux événements originaux peut être réglée. Le serveur X pour l'écran secondaire croit essentiellement qu'il est en train de recevoir des événements clavier et souris d'une façon normale. Tous les événements clavier et souris sont en train d'être interceptés depuis le serveur X de l'écran primaire par le gestionnaire de périphérique et d'être simulés sur le serveur X pour l'écran secondaire. Puisque le curseur sur l'écran primaire est maintenant masqué pour être invisible, l'utilisateur ne voit pas de quelconques déplacements souris-curseur sur l'écran primaire mais seulement sur l'écran secondaire. Le serveur X pour l'écran secondaire envoie en sortie des données sur l'écran secondaire ainsi qu'à tous les programmes client qui recevraient normalement les données provenant de ce serveur X s'il était en train de recevoir un flux normal de données de clavier et/ou souris. Des écrans secondaires supplémentaires peuvent également être inclus dans le système de telle sorte que, par exemple, le curseur puisse réaliser une transition depuis l'écran secondaire sur un troisième écran (un autre écran secondaire). Les fenêtres de transition entre deux écrans quelconques peuvent être définies arbitrairement au niveau d'une table de cartographie de telle sorte que le curseur souris puisse réaliser une transition depuis une quelconque position sur un écran jusqu'à une quelconque position sur un autre écran. Par conséquent, les écrans peuvent être placés selon n'importe quelle orientation les uns par rapport aux autres et le curseur peut réaliser une transition depuis un écran jusqu'à un autre écran d'une façon semblant naturelle. Le logiciel de la présente invention utilise seulement les commandes de base du protocole X-Windows standard et par conséquent, il peut supporter n'importe quel terminal d'affichage il compatible avec X- Windows. Les divers terminaux d'affichage sur un système donné peuvent être totalement non rapportés et provenir de vendeurs différents pour autant qu'ils supportent tous le protocole de langage X-Windows standard. Brève description des dessins La figure i est un schéma fonctionnel de logiciel d'une station de travail typique de l'art antérieur faisant fonctionner une pluralité de programmes client et utilisant X-Windows; la figure 2 est un schéma fonctionnel de logiciel d'une station de travail typique de l'art antérieur faisant fonctionner une pluralité de programmes client et utilisant X-Windows dans un mode multiples écrans; la figure 3 est un schéma fonctionnel de logiciel davantage détaillé d'une station de travail de l'art antérieur faisant fonctionner un programme client et utilisant X-Windows afin de piloter deux écrans dans un mode multiples écrans; la figure 4 est une représentation schématique d'un affichage à multiples écrans; la figure 5 est un schéma fonctionnel de logiciel d'un mode de réalisation typique de la présente invention; la figure 6 est un schéma fonctionnel de logiciel qui représente un premier mode de réalisation de la présente invention; la figure 7 est un schéma fonctionnel de logiciel qui représente un second mode de réalisation de la présente invention; la figure 8 est un schéma fonctionnel de logiciel qui représente un troisième mode de réalisation de la présente invention; les figures 9A, 9B, 9C et 9D sont des représentations schématiques de cartes de pixels illustrant comment le curseur souris est tracé et non tracé sur un écran d'affichage; les figures 10A, 0lB, 10C, 10D et 10E sont des organigrammes qui représentent le fonctionnement de la présente invention; et la figure 11 est un schéma fonctionnel de logiciel qui représente un autre mode de réalisation de la présente invention. Description détaillée des modes de réalisation particuliers de l'invention Le terme "fonctionnement à multiples écrans" est utilisé ici pour identifier le type de partage multiples écrans du clavier et de la souris qui est réalisé au moyen de la présente invention. La figure 4 représente les écrans de cinq appareils d'affichage distincts agencés sur un mur. Lors d'un fonctionnement à multiples écrans, des fenêtres de transition telles que les fenêtres de transition 200, 202, 204, 206, 208, 210, 212, 214, 216 et 218 sont définies. Un curseur souris 220 est représenté par un X sur la figure 4 et il se voit associer une unique souris. Le curseur peut être déplacé au travers des écrans de telle sorte que, par exemple, lorsque le curseur souris est déplacée vers la droite, comme représenté par une flèche 222, et qu'il atteint le bord le plus à droite 224 d'un écran 3, soit une partie dont le bord est défini en tant que fenêtre de transition 206, au lieu de s'arrêter au niveau de ce bord, le curseur disparaît de l'écran 3 et apparaît en une position 220a sur un écran 5. Par conséquent, la fenêtre de transition 206 sur l'écran 3 et la fenêtre de transition 214 sur l'écran 5 sont des fenêtres de transition conjuguées. Si l'opérateur de la souris continue à déplacer la souris vers la droite, le curseur continue à se déplacer vers la droite au travers de l'écran 5. Comme il sera décrit de manière davantage détaillée ci-après, le logiciel de gestionnaire de périphérique de la présente invention maintient une table de fenêtres de transition conjuguées nécessaire pour le fonctionnement de curseur souris décrit ci-avant. Comme il apparaîtra clairement, les fenêtres de transition conjuguées peuvent comprendre n'importe quelle partie d'un bord d'écran ou tout ce bord. Par exemple, la partie du bord gauche 236 de l'écran 3 identifiée à l'aide de l'index de référence 230 sur la figure 4 est entre les fenêtres de transition 200 et 202. Par conséquent, si le curseur représenté à la position 220c est déplacé horizontalement vers la gauche afin de rencontrer une partie 230 du bord gauche 236 de l'écran 3, il n'entre pas dans une quelconque fenêtre de transition et se comporte en tant que curseur souris normal. C'est-à-dire qu'il s'arrêterait de se déplacer vers la gauche même si l'opérateur de la souris continuait à déplacer la souris vers la gauche. Si, cependant, l'opérateur de la souris déplaçait la souris vers le haut jusqu'à la position 20d et la déplaçait vers la gauche, le curseur souris entrerait dans la fenêtre de transition et disparaîtrait de l'écran 3 et apparaîtrait en une position 220e dans l'écran 1 et continuerait à se déplacer vers la gauche. En outre, lorsque le curseur a continué à se déplacer vers la gauche sur l'écran 1 et qu'il atteint la position 220f au niveau de la fenêtre de transition 216, si des fenêtres de transition 216 et 218 étaient définies en tant que fenêtres de transition conjuguées, le curseur réapparaîtrait en une position 220g sur l'écran 4 et continuerait à se déplacer vers la gauche sur l'écran 4. Par conséquent, les fenêtres de transition qui sont conjuguées l'une par rapport à l'autre peuvent être définies de façon arbitraire. Par conséquent, si, pour une quelconque raison, lorsque le curseur atteint la position 220f dans l'écran 1, il est souhaitable qu'il disparaisse de l'écran 1 et qu'il apparaisse à la position 220h sur l'écran 2, au lieu de la position 220g sur l'écran 4, cette opération pourrait être mise en oeuvre. La fonction de transition appropriée a tout simplement besoin d'être définie par le gestionnaire de périphérique. Par exemple, sur lafigure 4, il n'y a pas de fenêtre de transition au niveau de la partie supérieure ou de la partie inférieure d'un quelconque écran. Cependant, si on le souhaite, les fenêtres de transition peuvent être définies en n'importe quelle position de n'importe quel écran. L'invention comprend un élément de logiciel ci-après appelé gestionnaire de périphérique. La figure 5 représente le fonctionnement logique d'une station de travail utilisant la présente invention pour assurer un fonctionnement du type à multiples écrans selon lequel un unique clavier et/ou une unique souris peut être utilisé(e) avec de multiples écrans. Une station de travail hôte 52 se voit associer un clavier 54 et une souris 56 pour entrer des données et des instructions dans un programme d'application tel qu'un programme 58. Le programme client 58 est par exemple un programme de contrôle de trafic aérien comme préalablement décrit. L'ordinateur hôte 52 est en train de faire fonctionner un système d'exploitation 60 tel que par exemple UNIX. Deux terminaux d'affichage 62 et 64 sont respectivement amenés à fonctionner à partir de cartes de contrôleur graphique 66 et 68. Le langage et le protocole d'affichage graphique pour le mode de réalisation particulier de l'invention sont X-Windows. Ce langage et ce protocole d'affichage graphique particuliers sont un langage et un protocole standards maintenus par Massachusetts Institute of Technology et ils sont pleinement décrits dans O'Reilly & Associates, Inc., Xlib Programming Manual, 3rd Edition, Adrian Nye (Editor) et O'Reilly & Associates, Inc., Xlib Reference Manual, 3rd Edition, Adrian Nye (Editor). La description qui suit suppose la connaissance du fonctionnement des protocole et langage X-Windows. Chaque carte de contrôleur graphique 66 et 68 est respectivement interfacée avec un logiciel de serveur X 70 et 72. Le logiciel de serveur X reçoit normalement des commandes X-Windows provenant de programmes client et des données de commande de curseur provenant de la souris et les convertit en signaux de commande qui peuvent être compris par la carte de contrôleur graphique associée 66 ou 68. Afin de mieux illustrer les caractéristiques et avantages de la présente invention, les deux appareils d'affichage 62 et 64 sont présumés être fabriqués par des vendeurs différents et être de différentes tailles et de différentes résolutions. Par conséquent, les cartes de contrôleur graphique 66 et 68 qui constituent l'interface entre l'appareil d'affichage et les serveurs X diffèrent l'une de l'autre du point de vue de la taille, de la résolution et du fabricant. Un serveur X est un élément de logiciel qui, entre autres choses, reçoit des commandes et délivre des événements selon le protocole et le langage X-Windows. Il convertit également des commandes et des données de déplacement de curseur selon une forme qui peut être comprise par les cartes de contrôleur graphique pour forcer un appareil d'affichage à générer un affichage particulier. De façon générale, et telles qu'utilisées ici, les données de protocole X transmises par un programme d'application sont appelées commandes X tandis que des communications de protocole X non sollicitées transmises depuis un serveur X sur un programme d'application sont appelées événements X. (Quelquefois, un programme d'application a besoin de données provenant d'un serveur X: la réponse provenant du serveur X n'est pas considérée en tant qu'événement mais en tant que réponse à l'interrogation). Les données reçues en provenance de dispositifs d'entrée tels que des claviers et souris (et à partir desquelles un serveur X peut générer des événements pour une transmission sur des programmes d'application) ne constituent pas une communication de protocole X. La présente invention entend fonctionner avec des appareils d'affichage et des cartes de contrôleur graphique disponibles commercialement. Par conséquent, le fonctionnement et l'interfaçage détaillés des cartes de contrôleur graphique avec leurs appareils d'affichage respectifs ne font pas l'objet d'une discussion ici. Les blocs de logiciel de serveur X 70 et 72 incluent des dispositifs de pilotage 74 et 76 pour respectivement piloter les cartes de contrôleur graphique 66 et 68. Les blocs de logiciel de serveur X 70 et 72 reconnaissent également des programmes client pour lesquels des événements doivent être dirigés et font avancer les divers événements jusqu'aux programmes client appropriés qui doivent recevoir ces événements. Plus particulièrement, suite à une initialisation, chaque programme client s'enregistre lui-même en relation avec un ou plusieurs serveurs X depuis le(s)quel(s) il a besoin de recevoir des événements. Plus particulièrement, chaque client dit au serveur ou aux serveurs X pertinent(s) les types d'événements X-Windows qu'il souhaite se voir envoyer. Le serveur X stocke dans une table une liste des clients qui lui sont couplés et une liste des types d'événements que chacun de ces clients a demandé en requête de lui envoyer. Un bloc de logiciel de gestionnaire de périphérique 78 est interfacé avec les serveurs X. Selon ce mode de réalisation de l'invention, les données provenant du clavier et de la souris sont envoyées au gestionnaire de périphérique 78 au lieu d'être envoyées directement à un serveur X. Comme représenté sur la figure 5, le clavier 54 et la souris 56 sont interfacés avec le gestionnaire de périphérique 78 par l'intermédiaire de la couche de système d'exploitation 60. Le gestionnaire de périphérique 78 garde trace de l'appareil d'affichage sur lequel le curseur souris apparaît présentement ainsi que de la position exacte sur cet affichage du curseur souris. Le gestionnaire de périphérique envoie les données de clavier et de souris reçues par l'intermédiaire de la couche de système d'exploitation 60 au serveur X 70 ou 72 associé à l'affichage 62 ou 64 sur lequel le curseur souris apparaît présentement et n'envoie pas ces événements à de quelconques autres serveurs X. Le gestionnaire de périphérique garde constamment trace de la position du curseur souris. Il maintient également un enregistrement de la ou des plusieurs fenêtres de transition pour chacun des écrans. Les fenêtres de transition sont des zones sur l'écran (habituellement un bord) pour lesquelles, lorsque le curseur souris entre dans cette zone, il est censé disparaître de l'écran et apparaître sur un autre écran. Chaque fenêtre de transition dispose d'une fenêtre de transition conjuguée sur un autre écran o le curseur est censé apparaître lorsqu'il disparaît du premier écran. Lorsque le curseur souris entre dans une fenêtre de transition, la position du curseur souris telle que stockée par le serveur X se voit sur-écrire un nouvel emplacement correspondant à la position sur le nouvel écran o le curseur souris est censé apparaître lorsqu'il entre dans la fenêtre de transition particulière. Ensuite, le gestionnaire de périphérique simule des événements X correspondant aux données reçues depuis le clavier et la souris pour le serveur X associé au nouvel écran au lieu de le faire pour celui associé à l'ancien écran. Selon une variante, le gestionnaire de périphérique peut simplement envoyer des données reçues depuis le curseur et/ou le clavier au serveur X au lieu de tout d'abord générer des événements X en vue de leur envoi. Lorsque le gestionnaire de périphérique observe qu'un curseur souris est entré dans une fenêtre de transition, il provoque une sur- écriture de la position du curseur souris telle que stockée par le serveur X à l'aide d'un nouvel emplacement correspondant à la position sur le nouvel écran o le curseur souris est censé apparaître lorsqu'il entre dans la fenêtre de transition particulière. Ensuite, le gestionnaire de périphérique simule des événements X correspondant aux données reçues depuis le clavier et la souris pour le serveur X associé au nouvel écran au lieu de le faire pour l'ancien écran. Selon une variante, le gestionnaire de périphérique pourrait simplement envoyer les données reçues depuis le curseur et/ou le clavier au serveur X au lieu des générer des événements X en vue de leur envoi. Quel que soit le mode de réalisation, le curseur disparaît du premier écran et apparaît en un emplacement approprié sur le second écran. Si les écrans primaire et secondaire ne présentent pas des tailles et des résolutions identiques, les événements de déplacement de curseur simulés peuvent avoir besoin d'être mis à l'échelle. Les serveurs X n'ont pas connaissance de ou ne prêtent pas attention à la source depuis laquelle ils reçoivent les événements X (ou les données de clavier et de souris selon un autre mode de réalisation). Comme lors d'un fonctionnement normal, le serveur X qui reçoit les événements vérifie ses tables pour déterminer si l'un quelconque des clients qui lui sont couplés doit recevoir les événements et envoie des événements appropriés aux clients appropriés. Il pilote également son affichage conformément aux événements simulés. Il est bien entendu que n'importe lequel des logiciels représentés sur la figure 5, voir tous, peuvent être résidents sur différentes stations de travail. Par exemple, le serveur X 70 et le serveur X 72 peuvent être sur différentes stations de travail (pour autant qu'ils sont couplés ensemble par l'intermédiaire d'un canal de communication tel qu'un réseau local). Il est également bien entendu, bien que la figure 5 représente deux écrans, que le nombre d'écrans ainsi que le nombre des fenêtres de transition peuvent être établis arbitrairement. En outre, bien que la figure 5 représente seulement un unique programme d'application client 58, n'importe quel nombre de programmes client ou n'importe quel nombre de stations de travail pourraient être couplé(e)s à n'importe quel nombre de serveurs X. Par exemple, plusieurs programmes d'application client pourraient être couplés à un quelconque unique serveur X, pourraient être enregistrés pour recevoir le même type d'événement ou des types d'événements différents et pourraient envoyer des commandes X-Windows au même serveur X. Par exemple, la figure 6 représente un mode de réalisation de l'invention selon lequel des programmes client fonctionnant sur la station de travail A et un programme client supplémentaire fonctionnant sur la station de travail B communiquent avec un unique serveur X fonctionnant sur la station de travail B. La figure 7 représente un mode de réalisation de l'invention selon lequel des programmes client A et B fonctionnant sur la station de travail A et un programme client C fonctionnant sur la station de travail B sont couplés à deux serveurs X fonctionnant sur des terminaux X indépendants. Les communications entre les terminaux X et les stations de travail séparés sont réalisées par l'intermédiaire d'un RLE. Les modes de réalisation de l'invention représentés au moyen des figures 5 à 7 représentent de façon logique diverses façons selon lesquelles l'invention peut être mise en oeuvre. La figure 8 représente un mode de réalisation d'une mise en oeuvre présentement préférée de l'invention. Comme il ressort d'une comparaison entre les figures 5 et 8, les modes de réalisation sont sensiblement identiques à ceci près que le clavier 102 et la souris 104 de la figure 8 sont couplés, par l'intermédiaire de la couche UNIX 116, directement au serveur X 120 au lieu de l'être au gestionnaire de périphérique 122. Le fonctionnement est essentiellement le même que celui décrit ci-avant en relation avec la figure 5 à ceci près que les flux de données depuis le clavier 102 et la souris 104 sont reçus par le serveur X 120 (ci-après appelé serveur X primaire) au lieu de l'être par le gestionnaire de périphérique 122. Selon ce mode de réalisation de l'invention, le gestionnaire de périphérique enregistre un masque d'événement à l'aide du serveur X primaire de telle sorte qu'il reçoive une information consistant à déterminer quand le curseur souris entre dans une fenêtre de transition. Lorsque le curseur apparaît sur l'écran primaire 110 (associé au serveur X primaire 120), le gestionnaire de périphérique 122 veut recevoir tous les événements ENTREE FENETRE provenant du serveur X. Plus particulièrement, le protocole et le langage X- Windows permettent la définition de fenêtres. Par conséquent, les fenêtres de transition sont aisément désignées et définies selon X- Windows. Le protocole et le langage X-Windows produisent également un événement ENTREE FENETRE qui est délivré par le serveur X lorsque le curseur entre dans une fenêtre définie. Comme il sera décrit de manière davantage détaillée ci-après, lorsque le curseur est sur l'écran primaire, le gestionnaire de périphérique ne réalise pas une quelconque fonction sauf si et jusqu'à ce que le curseur entre dans l'une des fenêtres de transition (c'est-à-dire jusqu'à ce que le gestionnaire de périphérique reçoive un événement ENTREE FENETRE en provenance du serveur X). Lorsque le curseur est sur l'écran primaire 110, le gestionnaire de périphérique a besoin de recevoir seulement les événements ENTREE FENETRE et de déterminer si oui ou non une fenêtre qui a subi une entrée est une fenêtre de transition. Par conséquent, le gestionnaire de périphérique 122 qui est fondamentalement un programme client pour le serveur X primaire , suite à un enregistrement, crée un masque d'événement à l'aide du serveur X primaire 120 de telle sorte qu'il reçoit seulement des événements ENTREE FENETRE associés à certaines fenêtres sur l'écran, à savoir les fenêtres de transition prédéfinies. Par conséquent, lorsque le curseur souris entre dans une fenêtre de transition sur l'écran primaire 110, le serveur X 120 modifie le gestionnaire de périphérique 122 par l'envoi à celui-ci d'un événement ENTREE FENETRE. En réponse à cela, le gestionnaire de périphérique entre dans un second mode de fonctionnement appelé le mode EXTRACTION. Dans ce mode, le gestionnaire de périphérique 122 délivre une commande de clavier EXTRACTION et une commande de souris EXTRACTION. Dans ce mode, le gestionnaire de périphérique reçoit tbus les événements de clavier et de souris générés par le serveur X primaire en réponse à des données reçues depuis le clavier et la souris. Les commandes EXTRACTION empêchent le serveur X primaire 120 d'envoyer des événements X de clavier et souris n'importe o ailleurs qu'au dispositif qui a délivré les commandes EXTRACTION, c'est-à-dire le gestionnaire de périphérique 122. Par conséquent, lorsque le curseur souris entre dans une fenêtre de transition, le gestionnaire de périphérique 122 extrait tous les événements de souris et tous les événements de clavier, ce qui empêche que le serveur X primaire 120 ne les envoie à de quelconques autres clients. Après délivrance des commandes de clavier EXTRACTION et de souris EXTRACTION, le gestionnaire de périphérique est tout d'abord à la source de plusieurs choses. Plus particulièrement, le gestionnaire de périphérique a pour effet que le curseur sur l'écran primaire devient invisible et a pour effet que le curseur sur l'écran secondaire apparaît à la position appropriée dans le nouvel écran 108. Ces deux opérations cependant sont davantage compliquées qu'elles n'apparaissent de prime abord. Plus particulièrement, même si le curseur est maintenant invisible sur l'écran primaire 110, le flux de données souris et clavier est encore reçu directement depuis la souris et clavier par le serveur X primaire 120. Le déplacement du curseur est suivi sur l'écran primaire 110 par le gestionnaire de périphérique 122 en demandant en requête tous les événements de déplacement de pointeur en provenance du serveur X primaire 120. Ces déplacements sont ensuite simulés par le gestionnaire de périphérique 122 et sont envoyés sur le serveur X 118 qui joue le rôle d'écran secondaire 108, en utilisant des commandes WARP POINTER (modification pointeur). Par conséquent, lorsque le curseur entre dans une fenêtre de transition, il est repositionné sur l'écran primaire 110 en une position correspondant à la position à laquelle il est censé maintenant apparaître sur l'écran secondaire 108 en utilisant la table de fenêtres de transition conjuguées prédéfinies et une fonction de transition pour cette fenêtre pour définir o le curseur est censé apparaître dans la fenêtre de transition conjuguée sur le nouvel écran. Cette nouvelle information remplace l'ancienne information de position de curseur maintenue par le gestionnaire de périphérique. En outre, si l'écran primaire 110 et l'écran secondaire 108 sont de tailles différentes ou de résolutions différentes, le gestionnaire de périphérique 122 doit réaliser une fonction de mise à l'échelle lors de la simulation des déplacements de curseur sur l'écran primaire 110 sur le serveur X 118 en vue d'un affichage sur le nouvel écran 108. Ceci est réalisé en appliquant tout simplement un facteur de mise à l'échelle à de quelconques commandes MODIFICATION POINTEUR avant de les délivrer. Bien que le curseur soit encore suivi sur l'écran primaire 110 (du fait que les événements de curseur sont en train de provenir du serveur X primaire), l'utilisateur peut voir le curseur seulement sur le nouvel écran 108. Par conséquent, le curseur sur l'écran 110 doit être rendu invisible. Ceci est réalisé en masquant le curseur comme il sera décrit de manière davantage détaillée ci-après. Pour autant que le curseur est sur un écran autre que l'écran primaire, tous les événements de clavier et de souris sont interceptés par le gestionnaire de périphérique à partir du serveur X primaire 120 et sont simulés et envoyés au serveur X 118. Pour autant que le serveur X 118 est concerné, il n'est pas averti de la couche de gestionnaire de périphérique 112 et il n'a pas connaissance de ou il ne prête pas attention à l'endroit depuis lequel il est en train de recevoir les événements de clavier et de souris. Tandis que l'on est dans le mode EXTRACTION, si le gestionnaire de périphérique observe que le curseur souris est entré dans une fenêtre de transition dans l'écran secondaire qui le ramène dans l'écran primaire 110, il met simplement à jour ses données d'écran courantes, il libère les commandes de clavier EXTRACTION et de souris EXTRACTION et il retourne au fonctionnement préalablement décrit selon lequel il observe tout simplement les événements ENTREE FENETRE. Si cependant le curseur devait entrer dans une fenêtre de transition depuis l'écran secondaire 108 jusqu'à un troisième écran (non représenté sur la figure 8), le fonctionnement se poursuivrait dans le mode EXTRACTION mais les données d'écran courantes et les données de position de curseur courantes dans le gestionnaire de périphérique seraient mises à jour à nouveau juste comme décrit en relation avec l'instant o le curseur est entré dans la fenêtre de transition entre l'écran maître 110 et l'écran secondaire 108. Le curseur apparaîtrait maintenant sur le troisième écran au lieu d'apparaître sur le second écran. Cependant, le fonctionnement dans le mode EXTRACTION reste essentiellement inchangé par rapport à celui décrit ci-avant à l'exception du fait que les événements X simulés sont en train d'être envoyés à un troisième écran maintenant au lieu d'être envoyés au second écran. Le facteur de mise à l'échelle peut être modifié également, si le troisième écran présente une taille ou une résolution différente de celle du second écran. Le mode de réalisation de la figure 8 peut également être adapté pour une utilisation avec des écrans et des serveurs X sur différentes stations de travail connectées sur un RLE ou similaire, comme il a été représenté au moyen des autres modes de réalisation de l'invention représentés sur les figures 5 à 7. Même dans ce cas, le mode de réalisation de la figure 8 peut être aisément adapté à un système dans lequel de multiples écrans sont desservis par un unique serveur X. Un tel système fonctionne essentiellement comme décrit par report à la figure 8, à ceci près qu'au lieu de modifier la variable de serveur X de la commande AFFICHAGE selon la commande X simulée et selon le train d'événements simulé, la variable d'écran est modifiée. Les figures 9A à 9D représentent comment un curseur est tracé sur un écran d'affichage et comment la présente invention a pour effet de le rendre invisible lorsqu'on est dans le mode EXTRACTION. Un curseur est classiquement tracé sur un écran d'affichage en tant que combinaison d'un symbole de glyphe rectangulaire et d'un masque. Le symbole de glyphe définit les couleurs du curseur en utilisant un bit par position de pixel o "'1" représente un pixel dans la couleur de premier plan courante et "0" représente un pixel dans la couleur de fond courante. Si le curseur doit être un X comme représenté sur la figure 9A, alors un réseau de pixels de glyphe rectangulaire tel que représenté sur la figure 9B est généré. Puis un masque est typiquement généré, lequel comprend un autre réseau de pixels rectangulaire, tel que représenté sur la figure 9C, dans lequel des pixels désignés par "1" sont tracés conformément à la spécification de glyphe et des pixels désignés par "0" ne sont pas tracés du tout indépendamment du réseau de glyphe. Par conséquent, afin de provoquer la disparition du curseur, la spécification de masque est désignée en tant que tout à zéro, comme représenté sur la figure 9D. Par conséquent, le curseur disparaît complètement. Selon la présente invention, chaque bloc de logiciel est séparé et indépendant des autres blocs de logiciel. Par conséquent, un remplacement d'un appareil d'affichage ou d'une carte de contrôleur graphique ne nécessite pas le remplacement du serveur X, ni celui du logiciel de gestionnaire de périphérique. Par conséquent, un fonctionnement multi-écran ou à multiples écrans peut être assuré pour différents écrans fabriqués par différents vendeurs présentant différentes tailles et/ou résolutions sans la nécessité de disposer d'un serveur X ou d'un logiciel de gestionnaire de périphérique personnalisé pour différents écrans. Les figures 10A à 10E sont des organigrammes qui représentent le fonctionnement du logiciel de gestionnaire de périphérique, plus particulièrement adapté conformément au mode de réalisation de l'invention de la figure 8. La figure 10A montre que la programmation du gestionnaire de périphérique comprend trois programmes généraux, incluant un programme d'initialisation 200, un programme d'événement de processus 300 et un programme de nettoyage 400. Au niveau des organigrammes des figures 10A, 10B et 10C, la convention qui suit est utilisée. Les rectangles munis de bords latéraux doubles (par exemple 200, 300 et 400) représentent des sous-programmes dont les détails sont représentés ailleurs au niveau des organigrammes. Des rectangles réguliers représentent des processus qui sont réalisés sur l'hôte principal mettant en oeuvre le gestionnaire de périphérique. Des parallélogrammes représentent des opérations d'entrée/sortie. Il est à noter que toutes les opérations graphiques sont considérées comme étant des opérations d'entrée/sortie (I/O) puisque l'un quelconque des écrans d'affichage pourrait être sur une station de travail différente de celle du gestionnaire de périphérique. Les cadres en forme de losange représentent des étapes décisionnelles. Les cadres à extrémités ouvertes sont des commentaires se rapportant au cadre auquel ils sont connectés. Les étapes représentées sous forme de cercles sont simplement des connecteurs. Pour finir, les étapes représentées sous forme d'ovales représentent des points d'extrémité, c'est-à-dire soit un début, soit une fin d'un programme. Comme représenté sur la figure 10A, suite à une mise en route, le gestionnaire de périphérique est initialisé (étape 200). Pendant le fonctionnement, le gestionnaire de périphérique traite des événements tels que dictés par le sous-programme 300. Pour finir, à la fin d'une cession multi-écran, diverses étapes doivent être considérées pour le nettoyage (étape 400) du logiciel afin de permettre un fonctionnement en non multi-écran. La figure 10B représente le sous-programme d'initialisation 200 de manière davantage détaillée. Au niveau d'une étape 205, les définitions d'écran primaire sont retrouvées. Ces définitions incluent le descripteur d'écran, la taille et la résolution de l'écran, et des définitions des fenêtres de transition. Cette information pourrait également inclure le nom du serveur X sur lequel une connexion doit être réalisée pour une communication avec l'écran primaire. Au niveau d'une étape 210, des définitions similaires pour l'écran secondaire sont obtenues et enregistrées. Pour les écrans secondaires cependant, il y a une information supplémentaire. Plus particulièrement, les fenêtres de transition sur les écrans secondaires ne sont pas seulement définies mais leurs fenêtres de transition conjuguées sur l'écran primaire (ou sur d'autres écrans secondaires) sont définies. Au niveau d'étapes 215 et 220, les connexions sur les serveurs X primaire et secondaire sont respectivement réalisées au moyen de l'utilisation des commandes d'écran ouvert. Puis au niveau d'étapes 225 et 230, les plages de coordonnées des premier et second écrans sont déterminées. Cette information est nécessaire pour rendre la plate-forme de logiciel de gestionnaire de périphérique indépendante et pour générer une définition complète des fenêtres de transition de telle sorte que le curseur puisse être partagé par de multiples écrans. Au niveau d'une étape 235, le gestionnaire de périphérique établit une carte de coordonnées de la totalité de l'espace sur lequel le curseur peut se déplacer. Les fenêtres de transition sont définies dans cette carte de coordonnées au niveau d'étapes 240 et 245. Maintenant que les fenêtres de transition sont définies dans la carte de coordonnées, une fonction doit être définie pour repositionner le curseur lorsqu'il entre dans une fenêtre de transition. Par exemple, lorsque le curseur entre dans une fenêtre de transition au niveau de l'angle droit supérieur d'un écran, il doit disparaitre au niveau de l'angle gauche supérieur de l'écran secondaire à la droite de l'écran primaire. Cette fonction de transfert est définie au niveau d'une étape 250. Des fonctions de transfert similaires sont définies pour les écrans secondaires au niveau d'une étape 255. Au niveau d'étapes 260 et 265, les cartes de pixels pour rendre respectivement invisible le curseur sur les écrans primaire et secondaire sont définies. Pour finir, le curseur doit apparaître sur seulement un écran. Par conséquent, au niveau d'une étape 270, le programme de curseur invisible secondaire est activé de telle sorte que, suite à une initialisation, le curseur apparaisse sur l'écran primaire seulement. Au niveau d'une étape 275, le sous-programme se termine et le traitement est ramené au sous-programme d'événement de processus 300. Les figures 10C et 10D constituent un organigramme qui représente le sous-programme d'événement de processus 300 de manière davantage détaillée. Au niveau d'une étape 302, le gestionnaire de périphérique effectue un enregistrement avec les serveurs X (crée un masque d'événement) pour les événements qu'il souhaite recevoir. Comme il a été préalablement discuté, lorsque le curseur est sur l'écran primaire, le gestionnaire de périphérique observe tout simplement des événements ENTREE FENETRE pour les fenêtres de transition. Par conséquent, au niveau d'une étape 302, le masque d'événement pour le gestionnaire de périphérique est établi pour recevoir depuis le serveur X seulement des événements ENTREE FENETRE pour les fenêtres de transition spécifiées. Au niveau d'une étape 304, le programme attend simplement de recevoir une commande ENTREE FENETRE. Au niveau d'une étape 306, il détermine si le curseur est entré dans une fenêtre de transition. S'il en est ainsi, alors le gestionnaire de périphérique veut maintenant recevoir depuis le serveur X tous les événements clavier et souris. Par conséquent, au niveau d'étapes 308 et 310, le gestionnaire de périphérique délivre respectivement une commande de pointeur primaire EXTRACTION et une commande de clavier primaire EXTRACTION. Comme noté au niveau des cadres 308a et 310a, le gestionnaire de périphérique recevra maintenant de façon exclusive tous les événements de déplacement, de pression de bouton et de libération de bouton se rapportant au curseur et le gestionnaire de périphérique recevra maintenant de façon exclusive tous les événements X de pression de touche et de libération de touche délivrés par le serveur X en réponse au train de données de clavier. Au niveau d'une étape 312, le pointeur secondaire est maintenant déplacé jusqu'à une position particulière sur l'écran secondaire conformément à la fonction de transfert établie au niveau de l'étape 250. Au niveau d'une étape 314, le curseur primaire est rendu invisible. Au niveau d'une étape 316, le curseur secondaire est rendu visible. Au niveau d'une étape 318, le curseur primaire maintenant invisible est déplacé jusqu'à une position sur l'écran primaire correspondant à la position du curseur secondaire sur l'écran secondaire. Comme préalablement noté, ceci est nécessaire du fait que le déplacement du curseur est toujours suivi sur l'écran primaire et est simulé pour les écrans secondaires. Au niveau d'une étape 320, la position du curseur est mise à jour dans la carte d'écran et la programmation est ramenée à l'étape 304. Cependant, maintenant que les commande de pointeur primaire EXTRACTION et de clavier primaire EXTRACTION ont été délivrées, au niveau de l'étape 304, le gestionnaire de périphérique réagira à tous les événements souris et clavier. Maintenant que le curseur est sur l'écran secondaire, le résultat la décision au niveau de l'étape 306 consistant à savoir si oui ou non le curseur est entré dans une fenêtre de transition primaire sera maintenant NON puisque le curseur ne peut pas entrer dans une fenêtre de transition primaire depuis un écran secondaire. Par conséquent, lorsqu'un événement se produit, la programmation passe de l'étape 304 à l'étape 306 et à l'étape 322. Au niveau de l'étape 322, il est déterminé si l'événement de serveur X primaire détecté au niveau de l'étape 304 était un événement de déplacement curseur. S'il en est ainsi, la programmation passe à l'étape 324. Au niveau de l'étape 324, le déplacement sur l'écran primaire est cartographié sur l'écran secondaire. Puis au niveau d'une étape 326, il est déterminé si le déplacement du curseur a abouti au fait que le curseur est entré dans une fenêtre de transition dans l'écran secondaire. Si cela n'est pas le cas, alors la programmation passe à l'étape 328 au niveau de laquelle le curseur secondaire est déplacé jusqu'à la position cartographiée. Ensuite, au niveau d'une étape 330, la position du curseur sur la carte de coordonnées d'écran, qui a été établie au niveau de l'étape 235, est mise à jour et la programmation revient à l'étape 304. Si cependant, au niveau de l'étape 326, le curseur secondaire n'est pas entré dans une fenêtre de transition secondaire, la programmation en lieu et place passe de l'étape 326 à l'étape 332. Au niveau des étapes 332 et 334, le pointeur primaire et le clavier sont non soumis à extraction. L'action de non extraction du clavier et de la souris restaure le masque d'événement précédent de telle sorte que le gestionnaire de périphérique reçoit maintenant seulement des événements ENTREE FENETRE à nouveau. Au niveau de l'étape 336, le curseur secondaire est rendu invisible à nouveau. Puis au niveau d'une étape 338, le curseur primaire est déplacé jusqu'à une position appropriée sur l'écran primaire en correspondance avec l'endroit o il doit apparaître, tel que dicté par les fonctions définies au niveau de l'étape d'initiation 255. Seulement après que le curseur primaire est positionné à la position correcte, il est rendu visible (étape 340). Puis la programmation passe à une étape 342 au niveau de laquelle la position du curseur est mise à jour dans la carte d'écran qui a été créée au niveau de l'étape d'initiation 255. Pour finir, la programmation revient à l'étape 304 pour attendre une autre commande ENTREE FENETRE. Si le curseur visible est dans un état secondaire et que le gestionnaire de périphérique détecte un événement de bouton souris au niveau de l'étape 304, la programmation passe de l'étape 304 par l'intermédiaire des étapes 306 et 322 à l'étape 344. Au niveau de l'étape 344, il est déterminé que l'événement détecté a été un événement de bouton souris et la programmation passe à l'étape 346. Au niveau de l'étape 346, l'événement de bouton est simulé sur le serveur X secondaire et la programmation revient à l'étape 304. Si cependant l'événement détecté au niveau de l'étape 304 était un événement de clavier (et que le curseur visible est dans l'écran secondaire), alors la programmation passe de l'étape 304 par l'intermédiaire des étapes 306, 322 et 344 à l'étape 348. Au niveau de l'étape 348, il est déterminé que l'événement était un événement de clavier et la programmation passe à l'étape 350. Au niveau de l'étape 350, l'événement de clavier est simulé sur le serveur X secondaire. La programmation revient ensuite à l'étape 304. Si l'événement détecté n'est aucun des événements mentionnés ci-avant et n'est pas un événement de terminaison, la programmation passe par les étapes 304, 306, 322, 344, 348 et 352 pour revenir à l'étape 304. Pour finir, si l'événement qui est détecté au niveau de l'étape 304 est un événement de terminaison, selon que le curseur visible est sur l'écran primaire ou secondaire, la programmation passe par les étapes 304, 306, 322, 344 et 348 pour aller à l'étape 352. Au niveau de l'étape 352, il est déterminé qu'un événement de terminaison s'est produit et la programmation passe à l'étape 354, laquelle revient au sous-programme de nettoyage 400. La figure 10E représente le sous-programme de nettoyage. Plus particulièrement, au niveau d'étapes 410 et 420, les données de fenêtre de transition primaire et secondaire sont détruites. Au niveau d'étapes 430 et 440, les curseurs primaire et secondaire originaux sont respectivement restaurés. Au niveau d'étapes 450 et 460, les curseurs invisibles primaire et secondaire sont respectivement détruits. Pour finir, au niveau d'étapes 470 et 480, les connexions sur les serveurs X primaire et secondaire sont fermées. Au niveau d'une étape 490, le programme de gestionnaire de périphérique est terminé. En annexe A se trouve une mise en oeuvre minimum d'un mode de réalisation particulier du logiciel de gestionnaire de périphérique 78 de la présente invention destiné à une utilisation dans un système muni d'un écran primaire et d'un écran secondaire (nom de fichier xmwm.c). Seulement des commandes complètement standards X- Windows X1 15R5 X-lib sont utilisées. Le programme est écrit en code de langage C générique Kerrigan et Ritchie. Par conséquent, le programme est une plate-forme complètement indépendante à la fois de l'hôte et du système graphique. Il est bien entendu que, lorsque l'on est dans le mode EXTRACTION, le gestionnaire de périphérique peut, si l'application le demande, envoyer les événements simulés sur plus d'un serveur X. Il doit également être bien entendu que, si l'application le demande, le curseur peut être sous la commande de plusieurs souris simultanément. Pareillement, plusieurs claviers peuvent être simultanément en fonctionnement en relation avec un unique appareil d'affichage. Bien entendu, dans la plupart des applications, il est probable que le gestionnaire de périphérique bloquera le clavier et la souris associés à la station de travail locale lorsque le curseur associé au clavier et à la souris de la station de travail maître est en train d'apparaître sur l'écran associé à cette station de travail locale. La figure 11 est un schéma fonctionnel de logiciel qui représente un autre mode de réalisation de la présente invention. Selon ce mode de réalisation, chaque serveur X 150 et 152 dispose de son propre gestionnaire de périphérique 154 et 156. A titre d'exemple, les serveurs X 150 et 152 sont représentés respectivement sur deux stations de travail séparées 158 et 160 et ils sont connectés sur un RLE 162. Cependant, les serveurs X peuvent être sur la même station de travail. Comme au préalable, les claviers et souris 164, 166, 168 et communiquent avec leurs serveurs X locaux respectifs 150 et 152 par l'intermédiaire des couches UNIX 172 et 174. Cependant, au lieu de la couche UNIX 172 ou 174 qui envoie les événements directement au serveur X associé 150 ou 152, il y a une couche de logiciel intermédiaire 176 ou 178 entre la couche UNIX et le serveur X. Le logiciel intermédiaire réalise également un interfaçage avec le gestionnaire de périphérique associé 154 ou 156 comme expliqué ci- après. En outre, les logiciels intermédiaires sont couplés l'un à l'autre sur le RLE. En fonctionnement, chaque gestionnaire de périphérique s'enregistre avec son serveur X associé pour recevoir les événements ENTREE FENETRE pour des fenêtres de transition dans l'affichage associé. Lorsque le gestionnaire de périphérique reçoit l'information consistant en ce que le curseur est entré dans une fenêtre de transition dans l'affichage associé, il commande le logiciel intermédiaire associé pour rediriger les trains de données clavier et souris sur le RLE jusqu'au logiciel intermédiaire associé à l'écran et au serveur X sur lequel le curseur doit réaliser une transition. Par conséquent, si un opérateur active la souris 168 sur l'écran 180 et que le gestionnaire de périphérique 154 observe que le curseur souris est entré dans une fenêtre de transition qui réalise une transition entre des écrans 180 et 182, il donne instruction au logiciel intermédiaire 176 d'envoyer les trains de données de souris et de clavier depuis la souris 168 et le clavier 164 sur le RLE 162 au logiciel intermédiaire 178 au lieu de les envoyer au serveur X 150. Le logiciel intermédiaire 178 sur la station de travail 160 reçoit les trains de données de souris * et de clavier et les envoie au serveur X 152. Lorsque le logiciel intermédiaire 178 reçoit les trains de données sur le RLE 162, il bloque de préférence tous les événements de clavier et de souris locaux en provenance du clavier 166 et de la souris 170. Cependant, si on le souhaite, les deux jeux constitués d'une part par la souris locale et le clavier local et d'autre part par la souris à distance et le clavier à distance peuvent tous deux être autorisés à contrôler le curseur simultanément. Pour autant que les serveurs X sont concernés, ils n'ont pas connaissance de la source des événements X-Windows. Par conséquent, peu importe si les événements proviennent du serveur X 152 par l'intermédiaire du logiciel intermédiaire 178 sur le RLE 162 ou par l'intermédiaire du logiciel intermédiaire 178 localement depuis le clavier 166 et la souris 170. Selon ce mode de réalisation de l'invention, l'effet de transition entre les écrans est réalisé complètement à l'extérieur de l'environnement XWindows. Par conséquent, tandis que selon le mode de réalisation de la figure 8, un client autre que le gestionnaire de périphérique peut délivrer des commandes de clavier EXTRACTION et de souris EXTRACTION, ce qui met en défaite son propre fonctionnement, ceci n'est pas possible selon le mode de réalisation de la figure 11. L'obtention d'un effet d'interférence résultant d'autres clients disparaît du fait que le train de données de commande X- Windows est en train d'être redirigé à l'extérieur de X-Windows. Par ailleurs, selon le mode de réalisation de la figure 11 de l'invention, les gestionnaires de périphérique ont une tâche plus simple. Plus particulièrement, lorsqu'ils (1) observent les événements ENTREE FENETRE appropriés, (2) suppriment le curseur de l'écran maître lors de l'entrée dans une fenêtre de transition sur un autre écran, (3) repositionnent le curseur lors de la réalisation d'une transition et (4) donnent en instruction au logiciel intermédiaire l'endroit o envoyer les événements X-Windows reçus depuis le clavier et la souris associés. Le mode de réalisation de la figure 11 constitue également un mode de réalisation de performance plus élevée (plus rapide) du fait qu'il n'y a pas de simulation des événements X-Windows. En lieu et place, les trains de données de clavier et de souris réels sont io simplement re-aiguillés conformément à la position du curseur souris. Bien que jusqu'ici, quelques modes de réalisation particuliers de l'invention aient été décrits, diverses variantes, modifications et améliorations apparaîtront aisément à l'homme de l'art. Par exemple, il est bien entendu que bien que la description ci-avant de certains modes i5 de réalisation particuliers de l'invention utilise une souris en tant que dispositif de commande de curseur, n'importe quels dispositifs d'entrée tels qu'une bille de commande, une souris stylet, un crayon lumineux ou un écran tactile fonctionneraient également efficacement avec la présente invention. Ces variantes, modifications et améliorations telles que rendues évidentes par la présente description sont destinées à constituer une partie de la présente description bien qu'elles ne soient pas mises expressément en exergue ici et sont destinées à tomber dans le cadre de l'invention. Par conséquent, la description qui précède est présentée à titre d'exemple seulement et non pas de limitation. Ainsi, I'invention concerne un procédé de partage d'un dispositif de commande de curseur entre des premier et second dispositifs d'affichage graphique, ledit dispositif de commande de curseur générant des données pour commander un premier curseur sur lesdits dispositifs d'affichage graphique, ledit procédé étant caractérisé en ce qu'il comprend les étapes de: (1) définition d'une première fenêtre de transition dans ledit premier dispositif d'affichage graphique et d'une seconde fenêtre de o transition conjuguée dans ledit second dispositif d'affichage graphique; (2) détermination de lorsque ledit premier curseur a été déplacé jusqu'à une première position dans ladite première fenêtre de transition; (3) lorsque ledit premier curseur entre dans ladite première fenêtre de transition, tracé d'un second curseur sur ledit second dispositif d'affichage graphique en une seconde position prédéterminée correspondant à ladite première position sur ledit premier dispositif d'affichage graphique; (4) lorsque ledit premier curseur entre dans ladite fenêtre de transition, repositionnement automatique dudit premier curseur en une troisième position sur ledit premier dispositif d'affichage graphique correspondant à ladite seconde positon prédéterminée sur ledit second dispositif d'affichage graphique; (5) lorsque ledit premier curseur est entré dans ladite fenêtre de transition, masquage dudit premier curseur sur ledit premier écran de telle sorte qu'il n'apparaisse pas; et (6) après que ledit premier curseur est entré dans ladite fenêtre de transition, envoi de simulations desdites données générées par ledit dispositif de commande de curseur audit second dispositif d'affichage graphique. L'étape (6) comprend: (6.1) l'observation desdites données générées par ledit dispositif de commande de curseur; et (6.2) l'envoi de simulations desdites données générées par ledit dispositif de commande de curseur audit second dispositif d'affichage graphique. Ledit appareil comprend en outre un dispositif d'entrée sous forme de clavier pour entrer des données et l'étape (6) comprend en outre: (6.3) l'observation desdites données entrées depuis ledit dispositif d'entrée sous forme de clavier; et (6.4) l'envoi de simulations desdites données entrées depuis ledit dispositif d'entrée sous forme de clavier sur ledit second dispositif d'affichage graphique. Le procédé comprend en outre les étapes de: (7) détermination de lorsque ledit second curseur a été déplacé jusqu'à une quatrième position dans ladite seconde fenêtre de transition; (8) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième position, suppression dudit second curseur au niveau du second appareil d'affichage graphique; (9) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième position, démasquage dudit premier curseur; et (10) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième position, repositionnement dudit curseur en une cinquième position sur ledit premier dispositif d'affichage graphique correspondant à ladite quatrième position sur ledit second dispositif d'affichage graphique. L'invention concerne un procédé de partage d'un dispositif d'entrée entre une pluralité de dispositifs d'affichage dans un appareil comprenant au moins des premier et second dispositifs d'affichage, un dispositif d'entrée de commande de curseur pour délivrer des données pour déplacer un premier curseur sur ledit premier dispositif d'affichage et un second curseur sur un second dispositif d'affichage, et au moins un premier serveur X pour recevoir lesdites données provenant dudit dispositif de commande de curseur et pour commander ledit premier o dispositif d'affichage, ledit procédé étant caractérisé en ce qu'il comprend les étapes de: (1) définition de première et seconde fenêtres de transition conjuguées sur respectivement lesdits premier et second dispositifs d'affichage; (2) détermination de lorsque ledit premier curseur entre dans ladite première fenêtre de transition, lorsque ledit curseur entre dans ladite première fenêtre de transition, (3a) extraction depuis ledit serveur X desdites données délivrées par ledit dispositif de commande de curseur; (3b) positionnement dudit second curseur en une certaine position sur ledit second dispositif d'affichage, ladite position étant une fonction d'une positon dudit premier curseur lorsqu'il est entré dans ladite première fenêtre de transition; (3c) masquage dudit premier curseur de telle sorte qu'il n'apparaisse pas sur ledit premier dispositif d'affichage; (3d) démasquage dudit second curseur de telle sorte qu'il apparaisse sur ledit second dispositif d'affichage; et (3e) repositionnement dudit premier curseur sur ledit premier dispositif d'affichage en une positon correspondant spatialement à ladite position dudit second curseur sur ledit second dispositif d'affichage; et (4) après que ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition, simulations desdites données provenant dudit dispositif de commande de curseur sur ledit second dispositif d'affichage. Ledit appareil comprend en outre un dispositif d'entrée sous forme de clavier pour délivrer des données audit serveur X et ledit procédé comprend en outre les étapes de: (3f) lorsque ledit curseur entre dans ladite première fenêtre de transition, extraction depuis ledit serveur X de données délivrées par ledit dispositif d'entrée sous forme de clavier; et (5) après que ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition, simulation desdites données provenant dudit dispositif d'entrée sous forme de clavier sur ledit second dispositif d'affichage. Le procédé comprend en outre les étapes de: lorsque ledit second curseur entre dans ladite seconde fenêtre de transition, (6a) abandon desdites données provenant dudit dispositif de commande de curseur; (6b) masquage dudit second curseur de telle sorte qu'il n'apparaisse pas sur ledit second dispositif d'affichage; (6c) démasquage dudit premier curseur de telle sorte qu'il apparaisse sur ledit premier dispositif d'affichage; et (6d) repositionnement dudit premier curseur sur ledit premier dispositif d'affichage en une certaine position sur ledit premier dispositif d'affichage, ladite position étant une fonction d'une positon dudit second curseur lorsqu'il est entré dans ladite seconde fenêtre de transition. Selon un autre mode particulier de réalisation de l'invention, ledit appareil comprend en outre un second serveur X pour commander ledit second dispositif d'affichage et l'étape (4) comprend l'étape de: (4.1) simulation desdites données provenant dudit dispositif de commande de curseur sur ledit second serveur X. Selon une variante de réalisation, ledit serveur X commande lesdits premier et second dispositifs d'affichage et identifie le dispositif d'affichage sur lequel lesdites données sont dirigées au moyen de l'utilisation d'une identification (ID) d'écran et l'étape (4) comprend l'étape de: (4.1) altération de ladite ID d'écran desdites données provenant dudit dispositif de commande de curseur afin d'identifier ledit second o dispositif d'affichage. L'invention concerne encore un appareil pour partager un dispositif d'entrée entre une pluralité d'écrans d'affichage, caractérisé en ce qu'il comprend: des premier et second écrans d'affichage 62, 64; un dispositif de commande de curseur pour délivrer des données pour commander le déplacement d'un premier curseur; un moyen pour définir une première fenêtre de transition dans ledit premier écran d'affichage et une seconde fenêtre de transition dans ledit second écran d'affichage; un moyen pour déterminer lorsque ledit premier curseur a été déplacé par ledit dispositif de commande de curseur dans ladite première fenêtre de transition; un moyen pour tracer un second curseur en une position prédéterminée sur ledit second écran d'affichage lorsque ledit premier curseur entre dans ladite première fenêtre de transition, ladite position prédéterminée étant une fonction d'une position dudit premier curseur lorsque ledit premier curseur entre dans ladite première fenêtre de transition; un moyen pour repositionner ledit premier curseur en une certaine position sur ledit premier dispositif d'affichage graphique correspondant spatialement à ladite position prédéterminée sur ledit second dispositif d'affichage graphique lorsque ledit premier curseur entre dans ladite fenêtre de transition; un moyen pour masquer ledit premier curseur sur ledit premier écran de telle sorte qu'il n'apparaisse pas lorsque ledit premier curseur entre dans ladite première fenêtre de transition; et un moyen pour envoyer des données depuis ledit dispositif de commande de curseur audit second écran d'affichage après que ledit premier curseur est entré dans ladite première fenêtre de transition et avant que ledit second curseur ne soit entré dans ladite seconde fenêtre de transition. Ledit appareil comprend en outre un premier serveur X 70 pour io commander lesdits premier et second écrans d'affichage 62, 64 et ledit moyen pour envoyer envoie lesdites données audit serveur X avec une identification d'écran qui identifie ledit premier écran d'affichage lorsque ledit premier curseur n'est pas masqué et avec une identification d'écran qui identifie ledit second écran d'affichage lorsque ledit premier curseur est masqué. Selon une variante de réalisation, ledit appareil comprend en outre des premier et second serveurs X 70, 72 pour commander respectivement lesdits premier et second écrans d'affichage 62, 64 et en outre ledit moyen d'envoi comprend: un moyen pour envoyer lesdites données délivrées par ledit dispositif de commande de curseur audit second serveur X 72 lorsque ledit premier curseur est masqué et pour ne pas envoyer lesdites données audit second serveur X lorsque ledit premier curseur n'est pas masque. Ledit moyen pour envoyer et lesdits premier et second écrans d'affichage 62, 64 sont supportés sur une première station de travail 52. Au moins l'un desdits premier et second écrans d'affichage est supporté sur une première station de travail et ledit moyen pour envoyer est supporté sur une seconde station de travail, lesdites première et seconde stations de travail étant connectées sur un réseau local. L'appareil sus-visé comprend en outre un dispositif d'entrée sous forme de clavier 54 pour délivrer des données et dans lequel ledit moyen pour envoyer comprend en outre un moyen pour envoyer des données délivrées par ledit dispositif d'entrée sous forme de clavier. Selon un autre aspect de l'invention, l'appareil comprend en outre: un moyen pour déterminer lorsque ledit curseur a été déplacé jusqu'à une position dans ladite seconde fenêtre de transition; un moyen pour masquer ledit second curseur sur ledit second o appareil d'affichage graphique lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour démasquer ledit premier curseur lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; et un moyen pour repositionner ledit premier curseur en une position prédéterminée sur ledit premier écran d'affichage, ladite position prédéterminée étant une fonction d'une position dudit second curseur lorsqu'il est entré dans ladite seconde fenêtre de transition, lorsque ledit second curseur entre dans ladite seconde fenêtre de transition. L'invention concerne encore un appareil pour partager un dispositif d'entrée entre une pluralité de dispositifs d'affichage, caractérisé en ce qu'il comprend: des premier et second dispositifs d'affichage 62, 64; un dispositif d'entrée de commande de curseur pour délivrer des données pour déplacer un premier curseur sur ledit premier dispositif d'affichage et un second curseur sur un second dispositif d'affichage; un premier serveur X 70 pour recevoir lesdites données provenant dudit dispositif de commande de curseur et pour commander au moins ledit premier dispositif d'affichage; un moyen pour définir des première et seconde fenêtres de transition conjuguées sur respectivement lesdits premier et second dispositifs d'affichage; un moyen pour déterminer lorsque ledit premier curseur entre dans ladite première fenêtre de transition; un moyen pour extraire à partir dudit premier serveur X (70) lesdites données délivrées par ledit dispositif de commande de curseur, après que ledit premier curseur entre dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite o seconde fenêtre de transition; un moyen pour positionner ledit second curseur en une position prédéterminéesur ledit second dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition, ladite position prédéterminée étant une fonction d'une position dudit premier curseur i5 lorsqu'il est entré dans ladite première fenêtre de transition; un moyen pour masquer ledit premier curseur de telle sorte qu'il n'apparaisse pas sur ledit premier dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition; un moyen pour démasquer ledit second curseur de telle sorte qu'il apparaisse sur ledit second dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition; un moyen pour repositionner ledit premier curseur sur ledit premier dispositif d'affichage en une position correspondant spatialement à ladite position dudit second curseur sur ledit second dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition; et un moyen pour simuler lesdites données depuis ledit dispositif de commande de curseur jusqu'audit second dispositif d'affichage après que ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition. L'appareil comprend en outre: un dispositif d'entrée sous forme de clavier pour délivrer des événements de données audit serveur X; un moyen pour entrer à partir dudit serveur X lesdites données délivrées par ledit dispositif d'entrée sous forme de clavier lorsque ledit premier curseur entre dans ladite première fenêtre de transition; et un moyen pour simuler lesdites données depuis ledit dispositif d'entrée sous forme de clavier jusqu'audit second dispositif d'affichage après que 1o ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition. Selon un autre aspect de l'invention, l'appareil comprend en outre: ]5 un moyen pour abandonner lesdites données provenant dudit dispositif de commande de curseur lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour masquer ledit second curseur de telle sorte qu'il n'apparaisse pas sur ledit second dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour démasquer ledit premier curseur de telle sorte qu'il apparaisse sur ledit premier dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; et un moyen pour repositionner ledit premier curseur sur ledit premier dispositif d'affichage en une certaine position sur ledit premier dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition, ladite position étant une fonction d'une position dudit second curseur lorsqu'il est entré dans ladite première fenêtre de transition. L'appareil peut comprendre en outre un second serveur X pour commander ledit second dispositif d'affichage et un moyen pour simuler lesdites données provenant dudit dispositif de commande de curseur et lesdites données depuis ledit dispositif d'entrée sous forme de clavier jusqu'audit second serveur X lorsque ledit premier curseur est masqué. Selon une variante de réalisation, ledit premier serveur X commande lesdits premier et second dispositifs d'affichage et l'appareil comprend en outre un moyen pour altérer une identification d'écran dans lesdites données provenant dudit dispositif de commande de curseur et dudit dispositif d'entrée sous forme de clavier pour identifier ledit second dispositif d'affichage lorsque ledit premier curseur est masqué. ANNEXE EXEMPLE DE LOGICIEL POUR LA MISE EN OEUVRE DE L'INVENTION Nom de fichier: xmwm.c Titre: gestionnaire de multiples stations de travail Données de Programmation initiales: 20 Avril 1993 Auteur: J. Trueblood Description: Ceci est une mise en oeuvre minimum du concept d'un procédé et d'un appareil qui partageront des périphériques (clavier et souris) entre deux systèmes graphiques basés sur X-Windows. Ces systèmes sont appelés primaire et secondaire et ils peuvent être distribués sur un réseau selon le fonctionnement normal de X-Windows. Des commandes complètement standards X-Windows X 11 R5 xlib sont utilisées et ce programme est écrit selon un code en langage C strictement générique de Kerrigan et Ritchie. Par conséquent, ce programme est une plate-forme complètement indépendante de tous les systèmes graphiques et hôtes. Compilation runstring: cc -o xmwm xmwm.c -1 Xl 1 #include #include #include #include #include #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE define FALSE 0 #endif int FgPixel, BgPixel; int first = TRUE #define SECONDARY_ SERVER ("agp 0") #define primaryTRANSFER_X (1278) #define primaryTRANSFER_Y (0) #define primaryTRANSFER_WIDTH (2) #define secondaryTRANSFER_HEIGHT (1023) #define secondaryTRANSFER_X (0) #define secondaryTRANSFER_Y (0) #define secondaryTRANSFER_WIDTH (2) #define secondaryTRANSFER_HEIGHT (1024) #define secondaryMAX_X (2047) #define secondaryMAX_Y (2047) #define PRIMMAX_X (1279) #define BORDERTHRESH (2) #define acxhot (8) #define acyhot (8) #define acblankwidth 16 #define ac_blank_height 16 static char ac_blankbits [] = { OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO, OxOO}; Display *secondary; Window primary_root _w, secondaryrootw; Window primaryTransferWindow, secondaryTransferWindow; int base_x, base_y, secondary_x, secondary_y, map_x, map_y; int GrabActive; Unsigned long mask; XsetWindowAttributes attributes; Display *primary; int screen; char *ProgName; Pixmap_BlankPixmap, BlankMask, secondaryBlankMask, secondary BlankPixmap; Cursor Blankcursor, secondary Blankcursor; l* *SetupDisplay - établissement connexion sur serveur X. */ SetupDisplay(server) char *server; { int i; dummy; primary = XOpenDisplay(server); if (primary == NULL) { fprintf (stderr, "%s: impossible ouvrir affichage '%s'/n", ProgName, XDisplayName (server)); exit (1) } screen = DefaultScreen(primary); secondary = XOpenDisplay(SECONDARY_SERVER); if (secondary == NULL) { fprintf (stderr, "%s: impossible ouvrir affichage '%s'/n", ProgName, XDisplayName (SECONDARY_SERVER)); exit(1); } /*Pendant le deboggage, il est utile de lancer X de façon synchrone XSynchronize(primary, 1); XSynchronize(secondary, 1); */ } * Setup - Réalisation création de fenêtre initiale, etc. **/ Setup (geom, argc, argv) int argc; char *argv[]; { int minwidth, minheight; int i; Visual visual; 4FgPixel = BlackPixel (primary, screen); FgPixel = WhitBlackPixel (primary, screen); BgPixel = WhitePixel (primary, screen); ** création de la fenêtre de transfert /AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA visual;visualid = CopyFromParent; primary_ root_w = DefaultRootWindow(primary); secondary_ root_w = DefaultRootWindow(secondary); mask = CWbackPixel I CWBorderPixel I CWOverrideRedirect I CWEventMask attributes.background_pixel = BlackPixel (primary, screen); attributes borderpixel = BlackPixel(primary, screen); attributes overrideredirect = True; attributes eventmask = EnterWindowMask; primaryTransferWindow = XCreateWindow(primary, primaryroot_w); primaryTRANSFER_X, primaryTRANSFER_Y, primaryTRANSFER_WIDTH, primaryTRANSFER_H EIGHT, O, O, InputOutput, &visual, mask, &attributes); / chargement des curseurs vierges /*11 est à noter que leprocédé permettant de faire apparaître un curseur à effacer consiste simplement à assigner un curseur vierge avec tous les bits de masque à 0. */ { XColor FGcolor, BGcolor; FGcolor.red=O; FGcolor.green=O; FGcolor. blue=O; BGcolor.red=Oxffff; BGcolor.green=Oxffff; BGcolor.blue=Oxffff; /* chargement tout d'abord du curseur vierge primaire */ BlankPixmap=XCreateBitmapFromData(primary,primary_rootw ac_blank_bits, ac_blank_width, ac_blank- height); BlankMask=XCreateBitmapFromData(primary, primary_root_w, acblank_bits, ac_blank_width, ac_blank- height); BlankCursor = XCreateBitmapCursor(primary, BlankPixmap, BlankMask, &FGcolor, &BGcolor, acxhot, acy_hot); /* maintenant pour le SECONDAIRE */ secondaryBlankPixmap=XCreateBitmapFromData(secondary, secondary_rootw, ac_blank_bits, ac_blank_width, ac_blanckheight); secondaryBlankMask=XCreateBitmapFromData(secondary, secondary_rootw, ac_blank_bits, ac_blank_width, ac_blank- height); secondaryBlankCursor = XCreateBitmapCursor(secondary, secondaryBlankPixmap, secondaryBlankMask, &FGcolor, &BGcolor, acxhot, acy_hot); 4Y /* maintenant "effacer le curseur secondaire*/ XDefineCursor (secondary, secondary_rootw, secondaryBlankCursor); } XMapWindow (primary, primaryTransferWindow); } ProcessEnterWindow (event) XEnterWindowEvent *event; { int x,y; /* Cet événement se produira seulement lorsque l'affichage primaire comprendra le curseur et que l'utilisateur aura déplacé le curseur dans la fenêtre de transfert. Ceci signifie que le curseur doit alors être déplacé logiquement sur l'affichage secondaire et que le curseur primaire doit être "rendu vierge" */ map_x = PRIM_MAX_X + BORDER-THRESH; basex = 0; base_y = primaryTRANSFER_Y; secondary_x = BORDER_THRESH; secondaryy = event-> y_root + secondaryTRANSFER_Y; map_y = secondary_y; XUndefineCursor (secondary, secondary_root_w); XWarpPointer (secondary, None, secondary_root_w, 0, 0, 0, 0, secondaryx, secondaryy); XFlush (primary); GrabActive = True; XGrabPointer (primary, primary_root_w, True, PointerMotionMask I ButtonPressMask] ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, BlankCursor, CurrentTime); XGrabKeyboard(primary, primary_rootw, True, GrabModeAsync, GrabModeAsync, CurrentTime); x = O; y = secondaryy>>1; XWarpPointer (primary, None, primary_rootw, 0, 0, 0, 0, x, y); } ProcessMotion (event) XMotionEvent *event; { /* Cet événement se produit seulement lorsque le pointeur est déplacé tandis que l'affichage secondaire inclut logiquement le curseur *l secondary_x = 2 * event ->x_root; secondaryy = 2 * event ->y_root; /*printf ("%d, %d\n", secondary_x, secondaryy); */ /*Première vérification pour frontière maximum secondaire */ if ((basex + event->x_root) > secondaryMaxX) { printf ("Maximum X-boundary reached!\n"); XWarpPointer (primary, None, primary_root_w, 0, 0, 0, 0, secondaryMAX_X - base_x, event->y); return; } /*if*/ if ((base_y + event->y_root) > secondaryMAX_Y) { printf ("Maximum Y-boundary reached!\n"); XWarpPointer (primary, None, primary_root_w, 0, 0, 0, 0, event->x, secondaryMAXY - base_y); return; } /* if*/ map_x = PRIM_MAX_X + secondaryx; map_y = secondary _y; XWarpPointer (secondary, None, secondary_root_w, 0, 0, 0, 0, secondary_x, secondaryy); XFlush (secondary); /* Vérification déplacement curseur en retour sur affichage primaire */ if ((map_x secondaryTRANSFER_y) && (map_y type); printf ("\tserial = %d\n", event-> serial); prinff ("'\ttime = %d\n", event->time); printf ("tstate = Ox%x\n", event->state); printf ("tbutton = Ox%x\n", event->button); } PrintKeyEvent (disp, event, press) Display *disp; XKeyEvent *event; Bool press; { /* utile pour deboggage */ if (press) { if (disp == secondaray) prinff ("SECONDARY - "); else prinff ("DPY - "); /* if (press) prinff ("PRESS\n") else prinff ("RELEASE\n"); prinff ("'ttype = %d\n", event-> type); prinff ("\tserial = %d\n", event->serial); prinff ("\ttime = %d\n", event->time); prinff ("tstate = Ox%x\n", event->state); prinff ('\tkeycode = Ox%x\n", event->keycode); */ prinff ("Ox%x\n", event-> keycode); if (disp == secondary) prinff ("\n"); } ProcessKeySECONDARY (event, press) XKeyEvent *event; Bool press; { /* utile pour deboggage */ PrintKeyEvent (secondary, event, press); } ProcessButton SECONDARY (event) XButtonEvent *event; { /* utile pour deboggage */ PrintButtonEvent (event); } ProcessButton (event) XButtonEvent *event; { int state, x_root, yroot, x, y; fond; Window w, rootw, child_w; /*Cet événement se produira seulement lorsque l'affichage secondaire possèdera logiquement le curseur et qu'un bouton sera pressé sur la souris primaire */ */ XGetlnputFocus (secondary, &w, &state); prinff ("input focus = %x\n", w); */ event->display = secondary event->root = secondary_rootw; found = False; w = secondaryrootw; 4- while (!found) { XQueryPointer (secondary, W, &rootw, &child_w, &xroot, &y_root, &x, &y, &state); event->window = w; event->subwindow = childw; event->x = x; event->y = y; event->x_root = x_root; event->y_root = yroot; XSendEvent (secondary, w, False, ButtonPressMask J ButtonReleaseMask, event); if (childw == None) { /* prinff ("Window found! id=%x\n", w); */ found = True; } else { /* printf ("Child window button! id=%x\n", child_w; */ w = child_w; } XFlush (secondary); return; */pour le deboggage, n'importe quel bouton terminera (en enlevant l'instruction return ci-avant) */ XUndefineCursor (secondary, secondary_rootw); XUndefineCursor (primary, primary_rootw); exit (O); } jA AA AAAAAA*A* A AAAAAAAAA AA A AA ALA A. AA. A.A AAAAA AA** ProcessKey (event, press) XKeyEvent *event; Bool press; int state, x_root, yroot, x, y, found; Window w, root_w, child_w; /* cet événement reviendra seulement lorsque l'affichage secondaire possédera logiquement le curseur et qu'une touche de clavier sera pressée depuis l'affichage primaire /* printkeyevent (primary, event, press);*/ XGetlnputFocus (secondary, &w, &state); */ prinff ("key event: input focus = %x\n", w); */ if (w == PointerRoot) I I (w == None)) return: /* ignore key*/ XQueryPointer (secondary, W, &root_w, &childw, &x_root, &y_root, &x, &y, &state); event ->display=secondary; event-> root=secondaryrootw; event->window = w; event->subwindow = child_w; event->x = x; event->y = y; event->x_root = x_root; event->y_root = yroot; event ->Keycode = Keytable(event ->Keycode);/*traduire code touche*/ XSendEvent (secondary, w, False, KeyPressMask I KeyReleaseMask, event); XFlush (secondary); } ProcesslInputO { XEvent event; while(1) { GetNextEvent (&event); ProcessEvent (&event); /* Le code ci-après provoquera interrogation des événements au lieu de suspendre (pour déboggage) if (XEventsQueued(secondary, QueuedAfterFlush)) { GetNextEventSECONDARY (&event); if (XEventsQueued(primary, QueuedAfterFlush)) } GetNextEvent (&event); ProcessEvent (&event); } *1 } } GetNextEvent (event); Event *event; { NextEvent (primary, event); } GetNextEventSECONDARY (event); XEvent *event; { XNextEvent (secondary, event); } ProcessEvent (event); Xevent *event; { switch (event->type) { case KeyPress: ProcessKey (event, True); break; case KeyRelease: ProcessKey (event, False); -7 break; case ButtonPress: case ButtonRelease: ProcessButton (event); break; case MotionNotify: ProcessMotion (event); break; case EnterNotify: ProcessEnterWindow (event); break; default: break; } { ProcessEventSECONDARY (event) Xevent *event; { switch (event->type) { case KeyPress; case KeyRelease; ProcessKeySECONDARY (event); break; case ButtonPress; case ButtonRelease; ProcessButtonSECONDARY (event); break; default; break; } } fAAAAAAAAA AA AA A AAA AAAAAAA A A AAA A A A AA AAAA AA AA AAA /** principal main (argc, argv) int argc; e, char *argv []; { int i, count; char *ServeName, *Geometry; char *puzzlesize = NULL; char *option; ProgName = argv [0]; ServName = ""; /** options de lignes de commande d'analyse de syntaxe **/ fo (i=1; i AA . AAAAAAAAAAAAAAAA.À J static char *help_message [] = { "where options include:", " -display host:dpy X server to use", NULL); usage () { char **cpp; fprinff (stderr, "usage: %s [-options...]\n\n", ProgName); for (cpp = help_message; *cpp; cpp++) { fprintf (stderr, "%s\n", *cpp); } fprintf (stderr,'\n"); exit (1); } error (str) char *str; { fprinff (stderr, "Error %s\n", strt); exit (1); } /* Keyboard Cross Translation Table: IBM RS6000 to AGP */ /***Ceci est une routine de traduction de codes de touches généralisée qui rend très simple l'implémentation programmable des touches logiques. Chaque touche entrée exécutera un établissement séparé de traduction qui ne fait rien de plus initialement que la traduction du code de touche du clavier primaire pour le code d'événement secondaire correspondant approprié pour cette touche. Toute touche peut être codée logiquement pour des fonctions additionnelles en ajoutant simplement plus de fonctions exécutables dans l'établissement de cas approprié. int Keytable (key) int key; switch (key) { case OxOO: break; case 0x02: break case 0x03: break case 0x04: break case 0x05: break case Ox06: break case Ox07: break case Ox08: break case Ox09: key = Ox30; break; case OxOa: key = Ox9; break; case OxOb: key = Oxa; break; case OxOc: key = Oxb; break; case OxOd: key = Oxc; break; case OxOe: key = Oxd; break; case OxOf: key = Oxe; break; case Ox 10: key = Oxf; break; case Ox 11: key= Oxl O; break; case 0x12: key = Oxl 1; break; case 0x13: key = 0x12; break; case 0x14: key = 0x13; break; case 0x15: key = 0x14; break; case Ox16: break; case Ox1 7: key = 0x15; break; case Ox1 8: key = 0x16; break; case 0x19: key = Ox1 7; break; case Oxl a: key = Ox1 8; break; case Oxl b: key = Ox1 9; break; case Oxl c: key = Oxl a; break; case Oxl d: key = Oxl b; break; case Oxl e: key = Oxl c; break; case Oxl f: key = Oxl d; break; case 0x20: key = Oxl e; break; case 0x21: key = Oxl f; break; case 0x22: key = 0x20; break; case 0x23: key = 0x21; break; case 0x24: key = 0x22; break; case 0x25: key = Ox5d; break; case 0x26: key = 0x41; break; case 0x27: key = 0x25; break; case 0x28: key = 0x26; break; case 0x29: key = 0x27; break; case Ox2a: key = 0x28; break; case Ox2b: key = 0x29; break; case Ox2c: key = Ox2a; break; case Ox2d: key = Ox2b; break; case Ox2e: key = Ox2c; break; case Ox2f: key = Ox2d; break; case 0x30: key = Ox2e; break; case 0x31: key = Ox2f; break; case 0x32: break; case 0x33: key =0x23; break; case 0x34: key = 0x31; break; case 0x35: break; case 0x36: key = 0x33; break; case 0x37: key = 0x34; break; case 0x38: key = 0x35; break; case 0x39: key = 0x36; break; case Ox3a: key = 0x37; break; case Ox3b: key = 0x38; break; case Ox3c: key = 0x39; break; case Ox3d: key = Ox3a; break; case Ox3e: key = Ox3b; break; case Ox3f: key = Ox3c; break; case 0x40: break; case 0x41: key = Ox3d; break; case 0x42: key = 0x24; break; case 0x43: break; case 0x44: key = Ox3f; break; case 0x45: key = 0x40; break; case 0x46: key = Ox3f; break; case 0x47: break; case 0x48: key = 0x24; break; case 0x49: break; case Ox4a: break; case Ox4b: break; case Ox4c: break; case Ox4d: break; case Ox4e: break; case Ox4f: break; case 0x50: break; case 0x51: break; case 0x52: break; case 0x53: key = 0x59; break; case 0x54: key = Ox5a; break; case 0x55: break case 0x56: break; case 0x57: break; case 0x58: key = Ox4e; break; case Ox59: key = 0x56; break; case Ox5a: break; case Ox5b: break; case Ox5c: break; case Ox5d: key = 0x50; break; case Ox5e: key = 0x58; break; case Ox5f: break; case 0x60: =break; case 0x61: break; case 0x62 key = Ox4c; break; case 0x63: key = Ox4e; break; case Ox64: key = 0x52; break; case 0x65: key = 0x56; break; case 0x66: break; case 0x67: key = Ox3c; break; case 0x68: key = Ox4f; break; case 0x69: key = 0x53; break; case Ox6a: key = 0x57; break; case Ox6b: key = 0x59; break; case Ox6c: key = Ox3e; break; case Ox6d: key = 0x50; break; case Ox6d: key = 0x54; break; case Ox6f: key = 0x58; break; case 0x70: key = Ox5a; break; case 0x71: key = 0x51; break; case 0x72: key = 0x55; break; case 0x73: break; case 0x74: key = 0x23; break; case 0x75: break; case 0x76: key = 0x8; break; case 0x77: break; case 0x78: key = 0x42; break; case Ox79: key = 0x43; break; case Ox7a: key = 0x44; break; case Ox7b: key = 0x45; break; case Ox7c: key = 0x46; break; case Ox7d: key = 0x47; break; case Ox7e: key = 0x48; break; case Ox7f: key = Ox49; break; case 0x80: key = Ox4a; break; case 0x81: key = Ox4b; break; case 0x82: key = Ox5e; break; case 0x83: key = Ox5f; break; case 0x84: key = 0x31; break; case 0x85: key = Ox4d; break; case 0x86: key = 0x24; break; case 0x87: break; case 0x88: break; case 0x89: break; case Ox8a: break; case Ox8b: break; case Ox8c: break; case Ox8d: break; case Ox8e: break; case Ox8f: break; case Ox90: break; case 0x91: break; case 0x92: break; case 0x93: break; case 0x94: break; case 0x95: break; case 0x97: break; case 0x98: break; case 0x99: break; case Ox9a: break; case Ox9b: break; case Ox9c: break; case Ox9d: break; case Ox9e: break; case Ox9f: break; default: break } return (key); }fin /!'''''::-':--:''' fin de fichier:':':--::' '."-:--::--.-''/ REVENDICATIONS 1. Procédé de partage d'un dispositif de commande de curseur entre des premier et second dispositifs d'affichage graphique, ledit dispositif de commande de curseur générant des données pour commander un premier curseur sur lesdits dispositifs d'affichage graphique, ledit procédé étant caractérisé en ce qu'il comprend les étapes de: (1) définition d'une première fenêtre de transition dans ledit premier dispositif d'affichage graphique et d'une seconde fenêtre de io transition conjuguée dans ledit second dispositif d'affichage graphique; (2) détermination de lorsque ledit premier curseur a été déplacé jusqu'à une première positon dans ladite première fenêtre de transition; (3) lorsque ledit premier curseur entre dans ladite première fenêtre de transition, tracé d'un second curseur sur ledit second dispositif d'affichage graphique en une seconde position prédéterminée correspondant à ladite première position sur ledit premier dispositif d'affichage graphique; (4) lorsque ledit premier curseur entre dans ladite fenêtre de transition, repositionnement automatique dudit premier curseur en une troisième positon sur ledit premier dispositif d'affichage graphique correspondant à ladite seconde position prédéterminée sur ledit second dispositif d'affichage graphique; (5) lorsque ledit premier curseur est entré dans ladite fenêtre de transition, masquage dudit premier curseur sur ledit premier écran de telle sorte qu'il n'apparaisse pas; et (6) après que ledit premier curseur est entré dans ladite fenêtre de transition, envoi de simulations desdites données générées par ledit dispositif de commande de curseur audit second dispositif d'affichage graphique. 2. Procédé selon la revendication 1, caractérisé en ce que l'étape (6) comprend: (6.1) I'observation desdites données générées par ledit dispositif de commande de curseur; et (6.2) l'envoi de simulations desdites données générées par ledit dispositif de commande de curseur audit second dispositif d'affichage graphique. 3. Procédé selon la revendication 2, caractérisé en ce que o ledit appareil comprend en outre un dispositif d'entrée sous forme de clavier pour entrer des données et en ce que l'étape (6) comprend en outre: (6.3) I'observation desdites données entrées depuis ledit dispositif d'entrée sous forme de clavier; et (6.4) I'envoi de simulations desdites données entrées depuis ledit dispositif d'entrée sous forme de clavier sur ledit second dispositif d'affichage graphique. 4. Procédé selon la revendication 1, caractérisé en ce qu'il comprend en outre les étapes de: (7) détermination de lorsque ledit second curseur a été déplacé jusqu'à une quatrième position dans ladite seconde fenêtre de transition (8) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième position, suppression dudit second curseur au niveau du second appareil d'affichage graphique; (9) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième positon, démasquage dudit premier curseur; et (10) lorsque ledit second curseur a été déplacé jusqu'à ladite quatrième position, repositionnement dudit curseur en une cinquième positon sur ledit premier dispositif d'affichage graphique correspondant à ladite quatrième positon sur ledit second dispositif d'affichage graphique. 5. Procédé selon la revendication 3, caractérisé en ce que ledit dispositif de commande de curseur comprend une souris. 6i 6. Procédé de partage d'un dispositif d'entrée entre une pluralité de dispositifs d'affichage dans un appareil comprenant au moins des premier et second dispositifs d'affichage, un dispositif d'entrée de commande de curseur pour délivrer des données pour déplacer un premier curseur sur ledit premier dispositif d'affichage et un second curseur sur un second dispositif d'affichage, et au moins un premier serveur X pour recevoir lesdites données provenant dudit dispositif de commande de curseur et pour commander ledit premier o dispositif d'affichage, ledit procédé étant caractérisé en ce qu'il comprend les étapes de: (1) définition de première et seconde fenêtres de transition conjuguées sur respectivement lesdits premier et second dispositifs d'affichage; (2) détermination de lorsque ledit premier curseur entre dans ladite première fenêtre de transition, lorsque ledit curseur entre dans ladite première fenêtre de transition, (3a) extraction depuis ledit serveur X desdites données délivrées par ledit dispositif de commande de curseur; (3b) positionnement dudit second curseur en une certaine position sur ledit second dispositif d'affichage, ladite position étant une fonction d'une position dudit premier curseur lorsqu'il est entré dans ladite première fenêtre de transition; (3c) masquage dudit premier curseur de telle sorte qu'il n'apparaisse pas sur ledit premier dispositif d'affichage; (3d) démasquage dudit second curseur de telle sorte qu'il apparaisse sur ledit second dispositif d'affichage; et (3e) repositionnement dudit premier curseur sur ledit premier dispositif d'affichage en une position correspondant spatialement à ladite position dudit second curseur sur ledit second dispositif d'affichage; et (4) après que ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition, simulations desdites 61B données provenant dudit dispositif de commande de curseur sur ledit second dispositif d'affichage. 7. Procédé selon la revendication 6, caractérisé en ce que ledit appareil comprend en outre un dispositif d'entrée sous forme de clavier pour délivrer des données audit serveur X et en ce que ledit procédé comprend en outre les étapes de: (3f) lorsque ledit curseur entre dans ladite première fenêtre de transition, extraction depuis ledit serveur X de données délivrées par o ledit dispositif d'entrée sous forme de clavier; et (5) après que ledit premier curseur est entré dans ladite première fenêtre de transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition, simulation desdites données provenant dudit dispositif d'entrée sous forme de clavier sur ledit second dispositif d'affichage. 8. Procédé selon la revendication 6, caractérisé en ce qu'il comprend en outre les étapes de: lorsque ledit second curseur entre dans ladite seconde fenêtre de transition, (6a) abandon desdites données provenant dudit dispositif de commande de curseur; (6b) masquage dudit second curseur de telle sorte qu'il n'apparaisse pas sur ledit second dispositif d'affichage; (6c) démasquage dudit premier curseur de telle sorte qu'il apparaisse sur ledit premier dispositif d'affichage; et (6d) repositionnement dudit premier curseur sur ledit premier dispositif d'affichage en une certaine position sur ledit premier dispositif d'affichage, ladite position étant une fonction d'une position dudit second curseur lorsqu'il est entré dans ladite seconde fenêtre de transition. 9. Procédé selon la revendication 7, dans lequel ledit appareil est caractérisé en ce qu'il comprend en outre un second serveur X pour commander ledit second dispositif d'affichage et en ce que l'étape (4) comprend l'étape de: (4.1) simulation desdites données provenant dudit dispositif de commande de curseur sur ledit second serveur X. 10. Procédé selon la revendication 7, caractérisé en ce que ledit serveur X commande lesdits premier et second dispositifs d'affichage et identifie le dispositif d'affichage sur lequel lesdites données sont dirigées au moyen de l'utilisation d'une identification (ID) d'écran et en ce que l'étape (4) comprend l'étape de: (4.1) altération de ladite ID d'écran desdites données provenant o dudit dispositif de commande de curseur afin d'identifier ledit second dispositif d'affichage. 11. Appareil pour partager un dispositif d'entrée entre une pluralité d'écrans d'affichage, caractérisé en ce qu'il comprend: des premier et second écrans d'affichage (62, 64); un dispositif de commande de curseur pour délivrer des données pour commander le déplacement d'un premier curseur; un moyen pour définir une première fenêtre de transition dans ledit premier écran d'affichage et une seconde fenêtre de transition dans ledit second écran d'affichage; un moyen pour déterminer lorsque ledit premier curseur a été déplacé par ledit dispositif de commande de curseur dans ladite première fenêtre de transition; un moyen pour tracer un second curseur en une positon prédéterminée sur ledit second écran d'affichage lorsque ledit premier curseur entre dans ladite première fenêtre de transition, ladite position prédéterminée étant une fonction d'une position dudit premier curseur lorsque ledit premier curseur entre dans ladite première fenêtre de transition; un moyen pour repositionner ledit premier curseur en une certaine positon sur ledit premier dispositif d'affichage graphique correspondant spatialement à ladite position prédéterminée sur ledit second dispositif d'affichage graphique lorsque ledit premier curseur entre dans ladite fenêtre de transition; un moyen pour masquer ledit premier curseur sur ledit premier écran de telle sorte qu'il n'apparaisse pas lorsque ledit premier curseur entre dans ladite première fenêtre de transition; et un moyen pour envoyer des données depuis ledit dispositif de commande de curseur audit second écran d'affichage après que ledit premier curseur est entré dans ladite première fenêtre de transition et avant que ledit second curseur ne soit entré dans ladite seconde fenêtre de transition. o10 12. Appareil selon la revendication 11, caractérisé en ce que ledit appareil comprend en outre un premier serveur X (70) pour commander lesdits premier et second écrans d'affichage (62, 64) et en ce que ledit moyen pour envoyer envoie lesdites données audit serveur X avec une identification d'écran qui identifie ledit premier écran d'affichage lorsque ledit premier curseur n'est pas masqué et avec une identification d'écran qui identifie ledit second écran d'affichage lorsque ledit premier curseur est masque. 13. Appareil selon la revendication 11, caractérisé en ce que ledit appareil comprend en outre des premier et second serveurs X (70, 72) pour commander respectivement lesdits premier et second écrans d'affichage (62, 64) et en outre en ce que ledit moyen d'envoi comprend: un moyen pour envoyer lesdites données délivrées par ledit dispositif de commande de curseur audit second serveur X (72) lorsque ledit premier curseur est masqué et pour ne pas envoyer lesdites données audit second serveur X lorsque ledit premier curseur n'est pas masque. 14. Appareil selon la revendication 11, caractérisé en ce que ledit moyen pour envoyer et lesdits premier et second écrans d'affichage (62, 64) sont supportés sur une première station de travail (52). 15. Appareil selon la revendication 11, caractérisé en ce qu'au moins l'un desdits premier et second écrans d'affichage est supporté sur une première station de travail et ledit moyen pour envoyer est supporté sur une seconde station de travail, lesdites première et seconde stations de travail étant connectées sur un réseau local. 16. Appareil selon la revendication 11, caractérisé en ce qu'il comprend en outre un dispositif d'entrée sous forme de clavier (54) pour délivrer des données et dans lequel ledit moyen pour envoyer comprend en outre un moyen pour envoyer des données délivrées par ledit dispositif d'entrée sous forme de clavier. 17. Appareil selon la revendication 11, caractérisé en ce qu'il o comprend en outre: un moyen pour déterminer lorsque ledit curseur a été déplacé jusqu'à une position dans ladite seconde fenêtre de transition; un moyen pour masquer ledit second curseur sur ledit second appareil d'affichage graphique lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour démasquer ledit premier curseur lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; et un moyen pour repositionner ledit premier curseur en une position prédéterminée sur ledit premier écran d'affichage, ladite position prédéterminée étant une fonction d'une position dudit second curseur lorsqu'il est entré dans ladite seconde fenêtre de transition, lorsque ledit second curseur entre dans ladite seconde fenêtre de transition. 18. Appareil selon la revendication 11, caractérisé en ce que ledit dispositif de commande de curseur comprend une souris (56). 19. Appareil pour partager un dispositif d'entrée entre une pluralité de dispositifs d'affichage, caractérisé en ce qu'il comprend: des premier et second dispositifs d'affichage (62, 64); un dispositif d'entrée de commande de curseur pour délivrer des données pour déplacer un premier curseur sur ledit premier dispositif d'affichage et un second curseur sur un second dispositif d'affichage; un premier serveur X (70) pour recevoir lesdites données provenant dudit dispositif de commande de curseur et pour commander au moins ledit premier dispositif d'affichage; ?a. un moyen pour définir dos première et seconde fenêtres de transition conjuguées sur respectivement lesdits premier et second dispositifs d'affichage; s un moyen pour déterminer lorsque ledit premier curseur entre dans ladite premèlbre fenêtre de transition; un moyen pour extraire à partir dudit premier serveur X (70) lesdites données délivrées par ledit dispositif de commande de curseur, après que ledit premier curseur entre dans ladite première fenêre de o0 transition et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour positionner ledit second curseur en une position prédéterminée sur ledit second dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition, ladite position is prédéterminée étant une fonction d'une position dudit premier curseur lorsqu'il est entré dans ladite première fenêtre de transition, un moyen pour masquer ledit premier curseur de telle sorte quil n'apparaisse pas sur ledit premier dispositif d'affichage lorsque ledit curseur entre dans ladite premibre fenêtre de transition; un moyen pour démasquer ledit second curseur de telle sorte qu'il apparalsse sur ledit second dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition; un moyen pour repositionner ledit premier curseur sur ledit premier dispositif d'affichage en une position correspondant 2s spatlalement à ladite position dudit second curseur sur ledit seoond dispositif d'affichage lorsque ledit curseur entre dans ladite première fenêtre de transition; et un moyen pour simuler lesdites données depuis ledit dispositif de commande de curseur jusqu'audit second dispositif d'affichage après que ledit premier curseur est entré dans ladite première fenêtre de transition et Jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition. 20. Appareil selon la revendication 19, caractérisé en ce qu'il comprend en outre: un dispositif d'entrée sous forme de clavier (54) pour délivrer des événements de données audit serveur X (70); un moyen pour entrer à partir dudit serveur X lesdites données s délivrées par ledit dispositif d'entrée sous forme de clavier lorsque ledit premier curseur entre dans ladite première fenêtre de transition; et un moyen pour simuler lesdites données depuis ledit dispositif d'entrée sous forme de clavier jusqu'audit second dispositif d'affichage après que ledit premier curseur est entré dans ladite première fenêtre de transition o et jusqu'à ce que ledit second curseur entre dans ladite seconde fenêtre de transition. 21. Appareil selon la revendication 19, caractérisé en ce qu'il comprend en outre: un moyen pour abandonner lesdites données provenant dudit i5 dispositif de commande de curseur lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour masquer ledit second curseur de telle sorte qu'il n'apparaisse pas sur ledit second dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; un moyen pour démasquer ledit premier curseur de telle sorte qu'il apparaisse sur ledit premier dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition; et un moyen pour repositionner ledit premier curseur sur ledit premier dispositif d'affichage en une certaine position sur ledit premier dispositif d'affichage lorsque ledit second curseur entre dans ladite seconde fenêtre de transition, ladite position étant une fonction d'une position dudit second curseur lorsqu'il est entré dans ladite première fenêtre de transition. 22. Appareil selon la revendication 20, comprenant en outre un second serveur X pour commander ledit second dispositif d'affichage et un moyen pour simuler lesdites données provenant dudit dispositif de commande de curseur et lesdites données depuis ledit dispositif d'entrée sous forme de clavier (54) jusqu'audit second serveur X lorsque ledit premier curseur est masque. 23. Appareil selon la revendication 20, caractérisé en ce que ledit premier serveur X commande lesdits premier et second dispositifs d'affichage et en ce qu'il comprend en outre un moyen pour altérer une5 identification d'écran dans lesdites données provenant dudit dispositif de commande de curseur et dudit dispositif d'entrée sous forme de clavier pour identifier ledit second dispositif d'affichage lorsque ledit premier curseur est masqué.