 |
Vendredi 23 mai 2025 - 15:03 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Un regard sur l'Amiga par le créateur d'Intuition
Cet article présente les éléments constitutifs du noyau du système présent dans la ROM (read-only memory) de l'Amiga 1000. J'examinerai le noyau en ROM, y compris AmigaDOS et les bibliothèques et périphériques logiques sur disquette, et présenterai des exemples de traduction de code d'autres machines vers l'Amiga. Enfin, j'examinerai le matériel et les caractéristiques spéciales du noyau en ROM, en décrivant comment les utiliser directement de manière intégrée au système.
Vue d'ensemble du système
Il est rare que les groupes d'ingénieurs logiciels et matériels travaillent aussi étroitement ensemble que nous l'avons fait chez Amiga. Nous avons échangé et débattu des idées en permanence pendant la création de l'Amiga. Cette relation étroite a influencé la conception, apportant de nouvelles fonctionnalités au matériel et permettant au logiciel de tirer pleinement parti du matériel.
Les plus grandes forces de l'Amiga résident dans sa modularité et les interconnexions entre les composants du système, qu'ils soient matériels ou logiciels. Les équipes de conception ont conçu et développé simultanément et, dès le départ, elles étaient destinées à se compléter. Même si nous avons conçu les pièces matérielles pour qu'elles s'assemblent étroitement, vous pouvez utiliser n'importe quel sous-ensemble de fonctions sans avoir à contrôler l'ensemble de la machine. Il en va de même pour le système en ROM, dont les éléments fonctionnent étroitement ensemble mais peuvent être autonomes.
Le matériel et le logiciel combinent leurs efforts de plusieurs façons pour obtenir les performances de l'Amiga. Par exemple, le matériel comprend un coprocesseur spécial, le Copper, qui se synchronise sur la position de l'affichage du faisceau vidéo sans bloquer le bus ou le processeur. Le Copper peut déplacer des données vers l'un des nombreux registres matériels ou provoquer une interruption 68000, qu'Exec, noyau multitâche de l'Amiga (également appelé Executive), traite ensuite. Cela fait du Copper un outil auxiliaire puissant et discret. Il est utilisé par la bibliothèque Graphics pour les changements orientés vers l'affichage et par le périphérique logique audio pour les manipulations de canaux audio critiques en termes de temps. Vous pouvez utiliser le Copper pour des opérations critiques en termes de temps car il est lié à l'affichage, dont le fonctionnement est garanti à 60 Hz (les processeurs d'affichage partent du haut de l'écran 60 fois par seconde).
La façon dont l'Amiga gère les communications avec ses périphériques est un autre exemple de l'union du matériel et du logiciel. Les signaux qui passent entre l'Amiga et ses périphériques sont pilotés par des interruptions. Les périphériques ne perturbent donc pas le système et ne nécessitent pas de surveillance tant que des informations ne doivent pas être communiquées. Exec fonctionne avec la communication par interruption en gérant un mécanisme complet de traitement des interruptions, fournissant un traitement pratique, entrelacé et hiérarchisé des interruptions.
Exec et son multitâche constitue le noyau du système ; c'est une collection compacte de routines qui sous-tend le reste du système en ROM de l'Amiga. Les développeurs ont tenté d'optimiser Exec en termes d'espace, de performances, de clarté d'utilisation et de création et gestion de listes, qui sont les principaux composants d'Exec. Tous les autres composants d'Exec sont construits sur des listes et, par conséquent, fournissent des performances avec un minimum de charge processeur. Vous serez en mesure d'utiliser même les fonctions les plus ésotériques d'Exec une fois que vous aurez appris le concept de la liste Exec.
Exec est le point de départ de toutes les autres parties du système en ROM, principalement parce qu'il est le contrôleur des tâches et des interruptions. Chacun des composants logiciels du noyau en ROM est conçu pour être autonome autant que possible ; les programmeurs peuvent choisir les composants à utiliser. Mais en même temps, les composants ont été conçus pour partager des ressources et une interface commune autant que possible, pour aider le programmeur à comprendre le système dans son ensemble.
Principaux éléments logiciels du noyau en ROM
La figure 1 résume les nombreux composants du noyau en ROM de l'Amiga et leurs interrelations. Cette section présente brièvement les composants que je vais décrire plus en détail.
Composants système en ROM
Presque tout le code qui s'exécute dans l'Amiga est, au niveau le plus bas du système, une tâche. Chaque tâche possède son propre environnement d'exécution ; en d'autres termes, chaque tâche semble contrôler l'ensemble de la machine, à l'exception de la mémoire qu'Exec ne lui permet pas d'allouer.
Exec gère également la mémoire disponible et fournit des routines qui permettent à une application d'allouer un bloc de mémoire et d'effectuer sa propre gestion de la mémoire dans ce bloc. Enfin, Exec fournit des routines qui permettent un accès uniforme aux périphériques et bibliothèques Amiga.
Un périphérique logique est un mécanisme spécial d'entrée/sortie qui utilise des tâches pour créer un accès systématique à un composant matériel. Par exemple, en utilisant le périphérique logique "timer.device" de l'Amiga, vous pouvez recevoir une interruption ou être réveillé d'un état d'attente après une période que vous spécifiez. En utilisant le périphérique logique "console.device", qui est décrit plus loin, votre application peut recevoir des entrées et écrire des sorties texte de la manière la plus simple possible, comme si elle était connectée à un terminal d'ordinateur normal.
Une bibliothèque est une collection de routines apparentées qui se trouvent en ROM ou que vous chargez à partir de la disquette. Les routines n'ont pas d'adresse fixe et vous les appelez indirectement. Les applications n'ont donc pas besoin de connaître l'adresse absolue d'une routine de bibliothèque lors de la compilation du programme. Plus important encore, à l'exception de l'adresse qui contient le pointeur vers la base de données Exec, les adresses absolues ne sont nécessaires nulle part dans le système.
La bibliothèque Graphics, un autre composant important du noyau en ROM de l'Amiga et un exemple de bibliothèque Exec, fournit une "coquille logicielle" entre le programmeur et le matériel graphique de l'Amiga.
Le matériel graphique est extrêmement complexe, mais les routines graphiques éliminent une grande partie de cette complexité en traduisant les demandes de rendu simples en écritures systématiques dans les registres du matériel. Ces routines programment également le coprocesseur spécial de l'Amiga. Les applications peuvent utiliser la bibliothèque graphique simplement pour tracer des lignes et remplir des zones ou pour faire des choses plus complexes comme accéder systématiquement aux mécanismes matériels spéciaux comme le coprocesseur et le dispositif de transfert de blocs. Une application ne connaît les routines graphiques que sous forme de décalages dans une table, et l'application ne connaît pas la table avant d'ouvrir la bibliothèque au moment de l'exécution.
Intuition est un autre exemple de bibliothèque. Il s'agit d'une collection de routines qui gèrent et fournissent un accès pratique aux capacités multitâches d'Exec. Elle fournit également des mécanismes qui permettent aux utilisateurs d'interagir facilement avec les applications. Intuition utilise la bibliothèque Graphics pour créer des environnements d'affichage dans lesquels de nombreuses applications peuvent coexister. Intuition fournit également une autre source d'entrée pour les applications qui ne veulent pas utiliser le périphérique logique de console pour les données prétraitées.
Multitâche
Chaque unité d'exécution (à l'exception du programme exécuté par le coprocesseur) obtient son propre environnement ; en fait, elle obtient une machine complète. La tâche dispose de ses propres registres, de sa pile et de son état de traitement, et elle peut accéder aux périphériques d'entrées/sorties (dont la disquette et l'écran graphique) sans se préoccuper des autres tâches qui peuvent être en concurrence pour les mêmes ressources.
Les tâches sont très simples. Elles constituent le composant exécutable le plus élémentaire sous Exec. Tout est construit au-dessus de la tâche, même les programmes de tâches simples, les périphériques logiques et les processus AmigaDOS.
Les programmeurs peuvent, s'ils le souhaitent, ignorer les capacités multitâches de l'Amiga pour la plupart. Si vous écrivez un programme simple à exécuter sur l'Amiga, vous n'avez pas à vous soucier des autres programmes qui peuvent partager la mémoire et les ressources matérielles. Pour que votre programme se comporte bien dans l'environnement multitâche, vous devez simplement vous rappeler de toujours abandonner le contrôle du processeur et des ressources chaque fois que cela est possible pour permettre l'exécution d'autres tâches. Par exemple, lorsque vous attendez un événement comme une frappe sur le clavier, vous devriez utiliser la fonction Exec "Wait()", qui fournit un mécanisme pratique pour rester à l'écart et laisser les autres programmes s'exécuter jusqu'à ce que l'événement se produise.
Parce que l'Amiga n'a qu'un seul microprocesseur (le 68000), et que les tâches partagent le processeur, une seule tâche peut être active à la fois. Chaque tâche a un numéro de priorité, qui est un indicateur de l'importance de l'exécution de cette tâche. Les numéros vont de -128 à 127 ; la plupart des tâches ont la priorité 0. La tâche ayant la priorité la plus élevée est exécutée dès qu'elle est prête, même si elle doit interrompre le travail d'une tâche de priorité inférieure. Si deux tâches ont la même priorité et sont toutes deux prêtes à s'exécuter, elles partagent le processeur ("timeslicing") en s'exécutant pendant un temps donné (64 millisecondes) avant de transférer le contrôle à l'autre tâche. Lorsqu'une tâche a terminé son travail et qu'elle est prête à "s'endormir" temporairement et à abandonner le contrôle du système, elle appelle la fonction Exec "Wait()". L'appel de fonction comprend des instructions décrivant l'événement qui va réveiller la tâche (voir la table 1 pour la séquence des événements nécessaires à la mise en place et au démarrage d'une tâche simple). En général, l'appel de fonction est un événement externe, annoncé par l'arrivée d'un message ou d'un signal. Lorsqu'une tâche "attend", la tâche suivante de même priorité commence à s'exécuter. Lorsque toutes les tâches de la plus haute priorité sont en attente, la tâche suivante de plus basse priorité est autorisée à s'exécuter. Ce sommeil et ce réveil des tâches, appelés "commutation de tâches", sont gérés par Exec.
Table 1 : la séquence d'événements pour ouvrir une tâche
|
Messages et signaux
Les tâches communiquent entre elles à l'aide de messages et de signaux. Le signal, la forme la plus simple de communication inter-tâches, est physiquement un bit dans un mot de 32 bits (appelé mot de bits de signal). Chaque tâche reçoit 32 bits de signal. Certains des bits de poids faible sont réservés à l'usage du système. L'argument de la fonction "Wait()" est un mot long (32 bits) avec des paramètres de bits correspondant aux signaux que la tâche veut attendre. Lorsque la tâche appelle "Wait()", elle indique à Exec qu'elle veut attendre qu'un ou plusieurs événements se produisent. Lorsque la tâche se "réveille", la fonction "Wait()" renvoie un argument. L'argument est un long mot contenant les bits de signal (plusieurs sont possibles) qui ont été renvoyés à la tâche afin de la réveiller à nouveau.
À l'aide de la fonction Exec "AllocSignal()", la tâche alloue ses bits de signal pour identifier les types d'informations qui sont transmises. Elle peut attacher le signal à un message qu'elle envoie afin de pouvoir identifier facilement la réponse. Les tâches peuvent également mettre le signal à la disposition des autres tâches, soit sous forme de variable globale dans un programme composé de nombreuses tâches, soit sous forme d'information dans un message transmis via la structure de messages. Les tâches peuvent communiquer entre elles en utilisant des signaux et la fonction d'exécution "Signal()".
Les tâches peuvent également utiliser des messages pour communiquer. Les tâches connaissent les ports des autres, soit par une variable déclarée globalement, soit par un nom préétabli pour les ports. Il existe plusieurs fonctions Exec pour gérer les ports. Une tâche crée un port de message en utilisant la fonction Exec "CreatePort()" et peut attribuer un nom de texte à ce port. Ensuite, d'autres tâches peuvent trouver le port en utilisant la fonction "FindPort()". La fonction "CreatePort()" alloue et initialise la mémoire et un bit de signal pour un port de message, puis appelle "AddPort()" pour installer le nouveau message dans le système.
La fonction "PutMsg()" envoie un message à un autre port. Une fois que vous avez envoyé un message, vous pouvez choisir d'attendre une réponse (entrée/sortie synchrone) ou de continuer le traitement et de vérifier plus tard s'il y a une réponse (entrée/sortie asynchrone). Une tâche reçoit des messages en utilisant "GetMsg()", qui renvoie l'adresse d'un message ou zéro si aucun message n'est disponible.
Allocation mémoire
Plusieurs routines d'Exec et d'Intuition gèrent l'allocation et la désallocation de la mémoire vive. Les fonctions de base sont "AllocMem()" et "FreeMem()" d'Exec. Utilisez "AllocMem()" pour spécifier la quantité et le type de mémoire que vous voulez (adresse basse, adresse haute, et si elle doit être effacée par des zéros pour vous). "FreeMem()" renvoie votre morceau de mémoire dans le pool disponible.
D'autres routines d'allocation de mémoire d'Exec vous permettent de contrôler vous-même la gestion de la mémoire. Tout d'abord, vous allouez un bloc de mémoire à l'aide de la fonction "AllocMem()". Ensuite, vous effectuez la gestion de la mémoire au sein du bloc de mémoire en utilisant les fonctions Exec "Allocate()" et "Deallocate()".
Les tâches peuvent utiliser la fonctionnalité de liste d'Exec pour allouer de la mémoire de telle sorte que la mémoire soit automatiquement libérée lorsque la tâche se termine. Pour ce faire, vous pouvez allouer des blocs de mémoire à l'aide de la fonction "AllocEntry()", puis attacher la liste de mémoire renvoyée par "AllocEntry()" au champ MemList du bloc de données de contrôle de la tâche. Lorsque la tâche est fermée, Exec désalloue toute liste de mémoire qu'il trouve dans le bloc de contrôle de la tâche.
Intuition fournit une paire de routines de gestion de la mémoire, "AllocRemember()" et "FreeRemember()". Chaque appel à "AllocRemember()" ajoute à une liste de mémoire de la tâche appelante. Un appel unique à "FreeRemember()" libère toute la mémoire allouée par des appels répétés à "AllocRemember()".
La bibliothèque graphique
La bibliothèque de gestion graphique a deux objectifs principaux. Elle fournit une interface simplifiée aux mécanismes complexes du matériel d'affichage Amiga, et elle fournit un accès procédural aux fonctions de rendu des puces Amiga. Je ne décrirai ici que les fonctions de rendu de base de la bibliothèque Graphics.
La bibliothèque graphique fournit plusieurs structures de données pour définir et manipuler la mémoire d'affichage. La mémoire d'affichage est une mémoire vive (RAM) organisée en plans de pixels d'information. Chaque plan contient un seul bit d'information pour chaque pixel de l'affichage. Un affichage normal contient de un à cinq plans de données de pixel. Cela signifie que chaque pixel peut être défini à l'aide de 1 à 5 bits significatifs.
La structure de la mémoire
Les structures les plus basiques de la bibliothèque graphique sont le BitMap et le RastPort (port raster). La structure BitMap définit comment les plans de bits sont regroupés pour former la mémoire d'affichage. La structure RastPort est un recueil de paramètres nécessaires au rendu dans la mémoire d'affichage du BitMap. Ce rendu est effectué par les routines graphiques, les routines texte et les objets d'animation. La table 2 décrit les composants les plus importants de la structure RastPort.
|
Table 2 : les principaux composants d'une structure RastPort Stylo de rendu primaire FgPen (ForegroundPen, ou PrimaryPen) est le stylo de dessin principal. Lorsqu'un seul stylo est utilisé (simples tracés de lignes et remplissages de zones rectangulaires), c'est ce stylo. Stylo de rendu secondaire BgPen (BackgroundPen, ou SecondaryPen) est le stylo utilisé lorsqu'un deuxième stylo est nécessaire, par exemple pour dessiner du texte. Mode de dessin DrawMode est la variable qui décrit la manière dont le rendu doit s'effectuer, par exemple, en utilisant les sujets traités ci-dessous :
|
Le stylo graphique
Lorsque la bibliothèque Graphics effectue un rendu, elle utilise souvent le "stylo" RastPort, qui décrit à la fois le registre de couleur et la position d'affichage utilisés pour tracer des lignes, écrire du texte et remplir des zones rectangulaires simples. Le stylo principal utilisé pour le rendu des graphismes est le stylo de premier plan, connu sous le nom de "stylo A". Vous utilisez le stylo d'arrière-plan, ou "stylo B", pour effectuer des rendus plus élaborés, tels que des lignes à motifs et le rendu du premier plan et de l'arrière-plan des caractères de texte.
La routine "SetApen()" définit la valeur du stylo, qui spécifie l'un des registres de couleur du matériel. Le stylo a également une coordonnée spécifiée dans un RastPort. Vous utilisez "Move()" pour définir la position du stylo, le point de départ des lignes et la ligne de base des caractères de texte.
Tracé des lignes et remplissage des rectangles
Le dessin d'une ligne ne nécessite que quatre étapes (voir listing 1). Tout d'abord, vous définissez la couleur du stylo pour la ligne. Les numéros de stylo disponibles dépendent du nombre de plans de bits que vous avez dans votre BitMap. Ensuite, vous définissez le mode de dessin de la ligne que vous souhaitez tracer. En général, vous sélectionnez le mode de dessin JAM1 pour les lignes simples. Enfin, déplacez le stylo à la position de départ de la ligne et dessinez jusqu'à la position d'arrivée.
Par conséquent, l'instruction DrawLine(RPort, 1, JAM1, 10, 10, 15, 25); dessine une ligne de couleur 1 de la position (10,10) à la position (15,25). En fait, la fonction "Draw()" fait glisser le stylo vers le nouvel emplacement, en laissant une trace pour montrer où il s'est déplacé. Dans la terminologie des traceurs de lignes, "Move()" équivaut à "déplacer le stylo vers le haut" et "Draw()" à "déplacer le stylo vers le bas".
Une fois définies, les variables "drawing-mode" et "pen-color" conservent leurs valeurs jusqu'à ce que vous les changiez. Vous n'avez pas besoin de définir le mode de dessin et la couleur du stylo à chaque fois que vous dessinez une ligne.
La bibliothèque graphique dispose également d'une routine permettant de remplir les rectangles parallèles aux axes horizontal et vertical avec une couleur donnée. La fonction "RectFill()" utilise le stylo et le mode de dessin qui ont été configurés par les appels précédents aux opérateurs RastPort. La routine accepte deux coordonnées, les coins haut-gauche et bas-droit d'un rectangle. Elle utilise ensuite le matériel Amiga pour dessiner les rectangles. Dans un système non encombré, la bibliothèque Graphics peut créer environ mille rectangles de 96x96 pixels par seconde.
Listing 1 : la procédure suivante en langage C illustre les étapes du tracé d'une ligne
DrawLine(RPort, Pen, Mode, StartX, StartY, EndX, EndY)
struct RastPort *RPort;
UBYTE Pen, Mode;
SHORT StartX, StartY, EndX, EndY;
{
SetAPen(RPort, Pen);
SetDrMd(RPort, Mode);
Move(RPort, StartX, StartY);
Draw(RPort, EndX, EndY);
}
|
Affichage du texte
Vous pouvez également utiliser les stylos graphiques pour afficher du texte. La position du stylo graphique décrit la position dans laquelle le texte sera rendu. La coordonnée x indique la position en pixels du premier caractère. La coordonnée y décrit la "ligne de base" des caractères, comme les lignes d'un papier ligné. Les bas de caractères reposeront sur la ligne de base ; les bas de caractères s'étendront en dessous.
Vous utilisez le stylo de premier plan pour dessiner les caractères. Le mode de dessin JAM1 dessine les images des caractères sur l'arrière-plan dans la couleur du stylo de premier plan, et le BitMap apparaît dans l'espace vide autour de l'image du caractère. Le mode de dessin JAM2 utilise à la fois les stylos de premier plan et d'arrière-plan. Comme dans JAM1, le stylo d'avant-plan rend l'image du caractère, mais l'espace vide qui entoure le caractère est maintenant rendu dans la couleur du stylo d'arrière-plan, oblitérant ainsi toute information BitMap sous le caractère. Le mode de dessin "INVERSEVID" (vidéo inverse) combine les deux modes de dessin pour inverser la signification des stylos.
Pour configurer les stylos et les modes de dessin afin d'écrire du texte, vous utilisez les mêmes routines que pour le dessin de lignes. Vous définissez les valeurs du stylo et le mode de dessin avec "SetAPen()", "SetBPen()" et "SetDrMd()". Vous déplacez le stylo à une position donnée avec "Move()". Vous appelez ensuite "Text()" pour rendre votre texte dans le RastPort (voir le listing 2). Comme pour le dessin au trait, il n'est pas nécessaire de réinitialiser les stylos, le mode de dessin ou de déplacer la position du stylo avant de rendre le texte. Si vous appelez "Text()" deux fois, la deuxième ligne de texte suivra, correctement espacée, sur la même ligne de base que la première.
Listing 2 : une procédure C illustrant les étapes de l'affichage d'un texte
PrintText(RPort, String, StringLength, FrontPen, BackPen, TextMode, X, Y) struct
RastPort *RPort;
BYTE *String;
UBYTE FrontPen, BackPen;
SHORT TextMode;
SHORT X, Y, StringLength;
{
SetAPen(RPort, FrontPen);
SetBPen(RPort, BackPen);
SetDrMd(RPort, TextMode);
Move(RPort, X, Y);
Text(RPort, String, StringLength);
}
|
Intuition
Intuition est appelé l'interface utilisateur Amiga, mais il fournit également des mécanismes simples pour créer des affichages qui gèrent le multitâche. Intuition prend de nombreux aspects complexes du système et les réduit à de simples appels de procédures. Vous n'avez même pas besoin de comprendre ces appels pour les utiliser. L'un des principaux objectifs d'Intuition était de faciliter la tâche des programmeurs en simplifiant autant que possible l'interface avec le noyau du système en ROM. Intuition fournit des outils pour créer un environnement intuitif pour l'utilisateur et pratique pour le concepteur d'applications. Les concepteurs sont libres de tirer parti de toute combinaison d'outils et de constructions qu'Intuition fournit et gère.
L'écran est l'unité de base de l'affichage d'Intuition. Un écran est une combinaison de mémoire d'affichage et d'instructions au matériel graphique de l'Amiga sur la façon de traduire cette mémoire d'affichage en affichage vidéo. La mémoire d'affichage de l'écran est utilisée pour toutes les fonctions de la bibliothèque graphique, et tous les composants d'affichage d'Intuition sont finalement rendus dans la mémoire d'affichage de l'écran.
Vous utilisez les appels de la bibliothèque Graphics pour créer l'affichage de l'écran. Lorsque vous créez des écrans pour la première fois, ils remplissent normalement la totalité de l'affichage vidéo. L'aspect graphique de l'écran est en fait un sur-ensemble du ViewPort de la bibliothèque Graphics. La bibliothèque Graphics configure le matériel Amiga pour créer l'affichage désiré tel que spécifié dans les champs de la structure de données de l'écran.
Vous pouvez créer des écrans en vous rendant directement à la bibliothèque Graphics, sans utiliser Intuition. Les concepteurs désireux de prendre le contrôle de la machine entière le feront, mais c'est plus difficile que d'utiliser Intuition. La création d'un affichage implique de nombreuses étapes et nécessite que vous fassiez les bons appels de procédure avec les bons arguments. Intuition vous aide en faisant le travail de base, réduisant la création d'un écran à deux étapes : l'initialisation d'une structure de données NewScreen, et un seul appel de procédure à la fonction Intuition "OpenScreen()".
Un concepteur d'application peut créer n'importe quel affichage Amiga possible en définissant et en ouvrant un écran Intuition. Tous les écrans sont rectangulaires ; vous décidez de la largeur et de la hauteur de l'écran, ainsi que du nombre de couleurs qui apparaîtront. Vous décidez également du type d'affichage (basse ou haute résolution, entrelacé ou non, etc.). De plus, si vous créez l'écran comme un écran Intuition, il peut coexister sur l'écran vidéo avec d'autres écrans Intuition, ce qui permet aux utilisateurs de choisir (en les faisant glisser vers le haut et vers le bas ou en les organisant en profondeur) parmi plusieurs tâches, même si chaque tâche nécessite son propre écran.
Fenêtres
Les fenêtres sont des zones d'affichage et de sortie distinctes qui s'ouvrent à l'intérieur des écrans. Les données écrites dans une fenêtre n'affectent jamais les autres fenêtres, quelle que soit leur position relative. Les fenêtres sont souples et faciles à créer ; il ne fait aucun doute que la plupart des applications les exploiteront (bien que la mémoire d'affichage de l'écran puisse être utilisée directement, sans ouvrir de fenêtre). Les fenêtres peuvent être dimensionnées, déplacées et disposées en profondeur, soit par l'utilisateur, soit par programmation par l'application. Lorsqu'un utilisateur manipule une fenêtre, celle-ci peut réagir aux changements ou les ignorer. C'est le programmeur qui décide. L'utilisateur décidera quelle fenêtre sera active pour la saisie à tout moment, mais vous pouvez même ignorer si votre fenêtre est active ou non pour la saisie. Vous pouvez écrire dans n'importe quelle fenêtre à tout moment, indépendamment de ce qui se passe dans le système.
Étant donné que l'application peut entièrement ignorer la forme, la position et l'état de la fenêtre, chaque fenêtre peut agir comme un "terminal virtuel" pour le programme d'application. En fait, l'application ne peut rien apprendre de plus sur Intuition que la façon d'ouvrir et de fermer une fenêtre, puis d'ouvrir le périphérique de console et d'effectuer des entrées/sorties, comme si elle était connectée à un terminal ANSI (American National Standards Institute) normal. Vous ouvrez une fenêtre, comme un écran, en initialisant une structure de données, NewWindow, et en appelant une seule procédure, "OpenWindow()". Vous devez également sélectionner un type de fenêtre (voir table 3).
Intuition fournit des mécanismes de contrôle spéciaux appelés gadgets, que vous pouvez attacher à une fenêtre. Il y a quatre types de gadgets définis par le système :
- Le gadget de dimensionnement, qui permet aux utilisateurs de dimensionner la fenêtre.
- Le gadget de disposition en profondeur, avec lequel les utilisateurs peuvent disposer la fenêtre d'avant en arrière par rapport aux autres fenêtres.
- Le gadget de déplacement, qui permet aux utilisateurs de déplacer la fenêtre sur l'écran.
- Le gadget de fermeture de fenêtre, qui envoie un message spécifiant que l'utilisateur souhaite fermer la fenêtre.
- Les booléens, pour les sélections vraies ou fausses.
- Les proportionnels, qui renvoient une plage allant de 0 à 65535.
- Les chaînes de caractères, qui permettent à l'utilisateur d'entrer une chaîne de texte.
- Les entiers, pour les chaînes de caractères uniquement entières.
|
Table 3 : une liste des caractéristiques les plus importantes des fenêtres Types de fenêtres spéciales Ils ne s'excluent pas mutuellement. Vous pouvez combiner les types de fenêtres spéciales.
|
Les menus et l'IDCMP
Le système de menus d'Intuition vous permet de regrouper et d'afficher les fonctions et les options que votre application offre. Les éléments de menu peuvent être des images graphiques ou du texte, et vous pouvez les positionner de n'importe quelle manière. Vous pouvez sélectionner un ou deux niveaux de menu pour présenter les éléments. Les utilisateurs peuvent sélectionner les éléments de menu à l'aide de la souris ou de raccourcis clavier.
L'application typique découvre la sélection d'une option de menu par le biais des IDCMP (Intuition Direct Communications Message Ports), des ports de messages Exec standard et un passage de messages simplifié pour les développeurs. Lorsque Intuition configure un IDCMP, il alloue et initialise les deux ports nécessaires au passage des messages (un pour recevoir le message et l'autre pour recevoir la réponse). Vous n'avez pas besoin d'apprendre les nombreux mécanismes de création et de maintenance des ports ; vous devez seulement apprendre à recevoir des messages.
Vous recevez des "messages" sur les événements du clavier, les mouvements de la souris et les boutons de la souris, les événements de la disquette et les événements d'Intuition par le biais de l'IDCMP. L'autre moyen d'obtenir des entrées est le périphérique de console, qui effectue un prétraitement des données semblable à celui d'un terminal pour créer un code ASCII et des séquences d'échappement ANSI. Les applications qui veulent s'appuyer fortement sur la capacité de terminal virtuel de l'Amiga utiliseront le périphérique logiciel Console plutôt que l'IDCMP.
Synthèse
Ce qui a commencé comme une machine de jeu très puissante il y a trois ans s'est transformé en un ordinateur complet. Cet article présente trois composants du système : Exec, Graphics et Intuition. Mais d'autres aspects du système sont tout aussi utiles et puissants ; tel est l'Amiga.
Note : Robert J. Mical. Directeur d'Intuition pour Commodore-Amiga, a créé Intuition et le système GELS de l'Amiga. Vous pouvez le joindre à Commodore-Amiga Inc. 983 University Ave. #D, Los Gatos. CA 95030.
|
