 |
Vendredi 19 avril 2024 - 02:28 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Le mois dernier, nous avons étudié comment ouvrir un écran à l'aide de la bibliothèque graphics.library. Aujourd'hui, nous allons effectuer le même travail avec intuition.library.
Dans le même temps, nous aborderons la notion de fenêtre et (dans l'exemple) de requête, avec en fin d'article un programme récapitulant tous les aspects théoriques de cette étude. Commençons sans plus attendre par un tour d'horizon des fonctionnalités de la bibliothèque intuition.library.
Généralités sur Intuition
Intuition est un environnement de programmation permettant de créer, de manière simple, des programmes possédant une interface conviviale à base de menus déroulants, multifenêtrage et autres gadgets. Elle permet également, à partir d'outils standard, de développer une application personnalisée, et ce avec un minimum de contraintes (ces contraintes étant nécessaires pour la cohérence de l'ensemble). L'avantage d'un tel environnement de programmation standardisé apparait nettement : outre un temps de développement réduit, l'utilisateur peut d'appréhender un nouveau produit avec une impression réconfortante de "déjà-vu".
L'ensemble des objets et fonctionnalités d'Intuition peut être défini comme suit :
- Les écrans : ils servent de support aux fenêtres d'une application.
- Les fenêtres : elle permettent à l'application de communiquer avec l'utilisateur, aussi bien en entrée qu'en sortie d'informations.
- Les menus, requêtes et alertes : ce sont les différents mécanismes d'interaction entre l'utilisateur et l'application. Les menus gèrent l'envoi de commandes de la part de l'utilisateur, les requêtes (requesters), l'entrée d'informations et les alertes, les communications d'urgence (situations critiques).
Avant tout travail avec Intuition, il est nécessaire d'inclure les fichiers "include" se rapportant à Intuition, de déclarer un pointeur de type (struct IntuitionBase *) dénommé IntuitionBase et d'y stocker l'adresse de base de la bibliothèque Intuition renvoyée par la fonction OpenLibrary() (Cf. exemple).
Toute application repose sur un écran, que ce soit celui du Workbench ou celui que vous avez créé. Donc à tout seigneur tout honneur, nous allons commencer par voir de quelle manière ouvrir un écran.
Ouverture d'un écran
L'ouverture d'un écran sous Intuition est très simple, beaucoup plus simple qu'avec la graphics.library. En résumé, il suffit :
- De renseigner une structure NewScreen définissant l'écran à créer.
- De faire un appel à OpenScreen() qui crée physiquement l'écran à partir de la structure NewScreen.
- De récupérer le pointeur sur la structure Screen renvoyé par OpenScreen(), qui permettra par la suite de manipuler l'écran (cette fonction retourne NULL si l'écran n'a pu être ouvert).
struct NewScreen
{ SHORT LeftEdge, TopEdge, Width, Height, Depth;
UBYTE DetailPen, BlockPen;
USHORT ViewModes;
USHORT Type;
struct TextAttr *Font;
UBYTE *DefaultTitle;
struct Gadget *Gadgets;
struct BitMap *CustomBitMap;
};
|
LeftEdge : Indique la position initiale en X de l'écran. Il n'est pas utilisé actuellement en KickStart 1.2/1.3, mais doit être initialisé à 0 pour des questions de compatibilité ascendante. Le Kickstart 2.0 de l'Amiga 3000, lui, l'utilise.
TopEdge : Indique la position initiale en Y.
Width : Largeur de l'écran, soit 320 pixels en basse résolution ou 640 en haute résolution.
Height : Hauteur de l'écran, soit 256 lignes en mode non entrelacé (200 en NTSC) ou 512 en mode entrelacé (400 en NTSC).
Depth : Nombre de plans de bits associés à l'écran (de 1 à 6), ce qui influe directement sur le nombre de couleurs affichables N, tel que N=2^Depth.
DetailPen : Numéro du registre de couleur utilisé pour le titre de l'écran.
BlockPen : Numéro du registre de couleur utilisé pour la barre de titre.
ViewModes : Mode de visualisation de l'écran, lié à la hauteur et à la profondeur. Si la largeur est de 640, on indiquera HIRES (la profondeur maxi de l'écran étant alors de 4). Si la hauteur est de 512, on devra choisir INTERLACE. Tout cela suppose bien sûr que l'on désire que l'écran entier soit visualisable sur le moniteur (pas de défilement). Les modes SPRITES, DUALPF, EXTRA_HALFBRITE et HAM sont également utilisables.
Type : Indique... le type de l'écran. L'écran du Workbench est de type WBENCHSCREEN, l'écran d'une application est de type CUSTOMSCREEN. On peut également indiquer SCREENQUIET, qui empêche le dessin des gadgets dans la barre de titre (même s'ils sont toujours actifs) et SCREENBEHIND, qui ouvre l'écran derrière tous les autres (donc de manière invisible).
Font : Pointeur sur une structure TextAttr, qui définit la police de caractères utilisée par l'écran. Si ce pointeur est NULL, c'est la police Topaz 8 qui est choisie par défaut.
DefaultTitle : Titre de l'écran, représenté simplement par un pointeur sur une chaîne de caractères terminée par un caractère nul. On indique NULL si l'on ne veut pas de titre.
Gadget : Adresse du premier des gadgets liés à l'écran. Pour l'instant, il est impossible d'avoir des gadgets d'écran, il faut donc mettre ce pointeur à NULL pour garder une compatibilité ascendante.
CustomBitMap : Pointeur sur une structure BitMap initialisée par vos soins, par exemple pour créer une bitmap plus grande que l'écran et la faire défiler en tous sens. NULL sinon.
Voilà pour la structure NewScreen. Une fois cette structure correctement renseignée, il ne reste plus qu'à appeler OpenScreen().
struct Screen *ecran; ecran=(struct Screen *)OpenScreen(&nouvecran); |
OpenScreen() alloue et remplit la structure Screen et crée physiquement l'écran, mais qu'a-t-il bien pu mettre dans cette structure Screen...
La plupart des informations contenues dans la structure Screen servent selon l'application que vous développez. Dans ce premier article, nous allons nous contenter de les décrire, mais je vous rassure il nous serviront dans les prochains numéros.
TopEdge : Position du haut de l'écran suivant Y. Cette valeur va par exemple augmenter si l'utilisateur descend l'écran à la souris.
MouseX, MouseY : Position du pointeur de souris en X et Y relativement au coin haut et gauche de l'écran.
ViewPort, Rastport, BitMap, LayerInfo : Instances (et pas des pointeurs sur) des structures du même nom, décrivant les caractéristiques de l'écran comme nous avons pu les étudier le mois dernier.
BarLayer : Pointeur sur la structure layer liée à la barre de titre.
Le dernier point que nous allons voir ce mois-ci concernant les écrans, est la fonction qui nous permet de les refermer. Il s'agit de CloseScreen() à laquelle on passe le pointeur sur la structure Screen.
CloseScreen(ecran); |
Cette fonction se charge de refermer l'écran et de libérer toutes les ressources qui lui sont associées.
Ouverture d'une fenêtre
Nous allons maintenant étudier comment ouvrir une fenêtre en C. Vous savez tous ce qu'est une fenêtre, je ne m'étendrai donc pas sur sa description mais simplement sur la manière de l'ouvrir. De la même façon qu'il faut renseigner une structure NewScreen pour ouvrir un écran, nous allons commencer par regarder la description de la structure NewWindow qui va servir à Intuition pour créer la fenêtre. Elle est définie dans intuition/intuition.h :
struct NewWindow
{
SHORT LeftEdge,TopEdge;
SHORT Width, Height;
UBYTE DetailPen, BlockPen;
USHORT IDCMPFlags;
ULONG Flags;
struct Gadget *FirstGadget;
struct Image *CheckMark;
UBYTE *Title;
struct Screen *Screen;
struct BitMap *BitMap;
SHORT MinWidth,MinHeight;
SHORT MaxWidth, MaxHeight;
USHORT Type;
};
|
LeftEdge, TopEdge, Width, Height : Ces quatre valeurs décrivent la position initiale de la fenêtre à l'écran (au moment de l'ouverture). LeftEdge et TopEdge indiquent la position du coin haut-gauche de la fenêtre par rapport au coin haut-gauche de l'écran qui la contient. Width et Height représentent sa largeur et sa hauteur.
DetailPen, BlockPen : DetailPen contient le numéro du registre de couleur servant au tracé des détails associés à la fenêtre (texte dans la barre de titre, gadgets...). Une valeur de -1 dans ce champs indique à Intuition de prendre le même registre que celui de l'écran. BlockPen correspond quant à lui à la couleur utilisée pour le remplissage des blocs (barre de titre ou contour de la fenêtre). Une valeur de -1 correspond au même registre que pour l'écran.
Flags : Il est possible d'associer un certain nombre de valeurs à ce champ : WINDOWSIZING demande à Intuition de créer un gadget autorisant le dimensionnement de la fenêtre. En indiquant en plus SIZEBRIGHT, le gadget est placé dans la bordure droite (par défaut) alors qu'avec SIZEBOTTOM, il est placé dans la bordure du bas (on peut aussi mettre les deux). WINDOWDEPTH indique à Intuition de créer un gadget permettant à l'utilisateur de faire passer la fenêtre devant ou derrière d'autres fenêtres existantes. WINDOWCLOSE crée le gadget de fermeture de fenêtre. WINDOWDRAG transforme la barre de titre en un gadget permettant le déplacement de la fenêtre sur l'écran. SMARTREFRESH indique à Intuition qu'il doit vous avertir lorsque l'utilisateur utilise le gadget de dimensionnement (et seulement en ce cas). Ceci vous permet de modifier votre affichage par exemple. Par contre, dans le cas de superposition de fenêtres ou de déplacement, c'est Intuition qui gère le rafraîchissement de la fenêtre.
IDCMPFlags : Si un seul de ces drapeaux (flags) est positionné, Intuition préviendra l'application des interactions effectuées par l'utilisateur. Nous reviendrons plus en détails sur ce sujet dans un prochain article.
FirstGadget : Pointe sur le premier élément d'une liste de gadgets qui seront liés à la fenêtre (en dehors des gadgets système). NULL si aucun gagdget n'est à ajouter.
CheckMark : Pointe sur une Image qui remplacera le CheckMark par défaut des menus, par l'image de votre choix.
Titre : Pointe sur une chaîne de caractères qui représente le titre de la fenêtre.
Type : Indique le type de l'écran qui contient la fenêtre, soit WBENCHSCREEN, soit CUSTOMSCREEN.
Screen : Pointeur sur l'écran contenant la fenêtre, tel qu'il a été renvoyé par OpenScreen(). NULL si la fenêtre est dans l'écran du Workbench.
BitMap : Pointeur sur une BitMap associée à la fenêtre. Dans le cas où ce champ est NULL, Intuition se charge automatiquement de l'allocation de la BitMap.
MinWidth, MinHeight, MaxWidth, MaxHeight : Ces quatre valeurs correspondent respectivement aux largeur et hauteur minimum et maximum autorisées lors du dimensionnement de la fenêtre.
Une fois cette structure renseignée, il suffit de déclarer un pointeur sur une structure Window (que nous ne détaillerons que dans un prochain article, faute de place) et de faire appel à OpenWindow() pour ouvrir la fenêtre.
struct Window *fenetre; fenetre=OpenWindow(&Nouvfenetre); |
Pour refermer une fenêtre, il suffit d'appeler la fonction CloseWindow() :
CloseWindow(fenetre); |
Conclusion
Je vous conseille maintenant d'étudier le petit programme d'exemple associé à cet article. Pour la requête et la gestion des messages port, ne paniquez pas, il seront expliqués en détails dans un prochain numéro.
/*
Programmation : C - Ouverture d'un écran avec intuition.library
Article écrit par Pascal Amiable et extrait d'Amiga News Tech - avril 1991
http://obligement.free.fr/articles/c_ecrans_intuition.php
Retapé par Tygre, 2020/09/17
*/
/* ----------------------------------------------------------------- */
/* Ouverture d'un écran, d'une fenêtre et d'un requester */
/* Auteur Pascal AMIABLE (c) 1991 */
/* ----------------------------------------------------------------- */
/* ----------------------------------------------------------------- */
/* Quelques includes utiles... */
/* ----------------------------------------------------------------- */
#include <stdio.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <exec/types.h>
/* ----------------------------------------------------------------- */
/* Les defines maintenant */
/* ----------------------------------------------------------------- */
#define INTUITION_REV 0 /* Version de la bibliothèque (la dernière) */
/* ----------------------------------------------------------------- */
/* Définitions des variables globales */
/* ----------------------------------------------------------------- */
struct Screen *ecran = NULL;
struct Screen *OpenScreen();
struct Window *OpenWindow();
struct Window *fenetre = NULL;
struct IntuitionBase *IntuitionBase = NULL;
/* ----------------------------------------------------------------- */
/* Programme principal, il gère les interactions utilisateur */
/* ----------------------------------------------------------------- */
int main()
{
struct IntuiMessage *message;
long GetMsg();
ULONG classmessage;
void init(), ouvreecran(), ouvrefenetre(), ouvrerequete(), referme();
init();
ouvreecran();
ouvrefenetre();
ouvrerequete();
while(1) /* Boucle infinie */
{
message = (struct IntuiMessage *)GetMsg(fenetre->UserPort);
if (message) /* Y'a-t-il un message ? */
{
classmessage = message->Class; /* On récupère la classe */
ReplyMsg(message); /* Libère le message */
if (classmessage == CLOSEWINDOW) /* Fermeture ? */
{
referme(); /* On ferme tout */
exit(TRUE); /* et on sort tranquillement */
}
}
}
}
/* ----------------------------------------------------------------- */
/* On ouvre la bibliothèque "intuition.library" */
/* ----------------------------------------------------------------- */
void init()
{
struct Library *OpenLibrary();
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", INTUITION_REV);
if (!IntuitionBase)
{
printf("Mais où est donc passée Intuition ?");
exit(FALSE);
}
}
/* ----------------------------------------------------------------- */
/* Fonction permettant l'ouverture d'écran Intuition */
/* ----------------------------------------------------------------- */
void ouvreecran()
{
struct NewScreen nouvecran;
nouvecran.LeftEdge = 0;
nouvecran.TopEdge = 0;
nouvecran.Width = 640;
nouvecran.Height = 256;
nouvecran.Depth = 3;
nouvecran.DetailPen = 0;
nouvecran.BlockPen = 1;
nouvecran.ViewModes = HIRES;
nouvecran.Type = CUSTOMSCREEN;
nouvecran.Font = NULL;
nouvecran.DefaultTitle = "Un écran";
nouvecran.Gadgets = NULL;
nouvecran.CustomBitMap = NULL;
ecran = OpenScreen(&nouvecran);
if (ecran == NULL)
{
printf("L'écran ne veut pas apparaître");
if (IntuitionBase)
CloseLibrary(IntuitionBase);
exit(FALSE);
}
}
/* ----------------------------------------------------------------- */
/* Ouvre une fenêtre sous Intuition */
/* ----------------------------------------------------------------- */
void ouvrefenetre()
{
struct NewWindow nouvfenetre;
nouvfenetre.LeftEdge = 0;
nouvfenetre.TopEdge = 0;
nouvfenetre.Width = 300;
nouvfenetre.Height = 150;
nouvfenetre.DetailPen = 0;
nouvfenetre.BlockPen = 1;
nouvfenetre.Flags = WINDOWCLOSE | SMART_REFRESH | WINDOWSIZING | WINDOWDRAG | WINDOWDEPTH;
nouvfenetre.IDCMPFlags = CLOSEWINDOW;
nouvfenetre.FirstGadget = NULL;
nouvfenetre.Title = "Fenêtre et son requester";
nouvfenetre.Screen = ecran;
nouvfenetre.BitMap = NULL;
nouvfenetre.MinWidth = 50;
nouvfenetre.MinHeight = 50;
nouvfenetre.MaxWidth = 640;
nouvfenetre.MaxHeight = 200;
nouvfenetre.Type = CUSTOMSCREEN;
fenetre = OpenWindow(&nouvfenetre);
if (fenetre == NULL)
{
printf("La fenêtre ne veut pas s'ouvrir");
if (ecran)
CloseScreen(ecran);
if (IntuitionBase)
CloseLibrary(IntuitionBase);
exit(FALSE);
}
}
/* ----------------------------------------------------------------- */
/* Cette fonction referme l'écran et la fenêtre */
/* ----------------------------------------------------------------- */
void referme()
{
if (fenetre) CloseWindow(fenetre);
if (ecran) CloseScreen(ecran);
if (IntuitionBase) CloseLibrary(IntuitionBase);
}
/* ----------------------------------------------------------------- */
/* Cette fonction ouvre un requester de type Vrai/Faux */
/* ----------------------------------------------------------------- */
void ouvrerequete()
{
int val;
struct IntuiText blabla, positiftexte, negatiftexte;
blabla.FrontPen = 1;
blabla.BackPen = 0;
blabla.DrawMode = 1;
blabla.LeftEdge = 25;
blabla.TopEdge = 10;
blabla.ITextFont = NULL;
blabla.IText = "Comment ça va ?";
blabla.NextText = NULL;
positiftexte.FrontPen = 1;
positiftexte.BackPen = 0;
positiftexte.DrawMode = 1;
positiftexte.LeftEdge = 5;
positiftexte.TopEdge = 5;
positiftexte.ITextFont = NULL;
positiftexte.IText = "Bien";
positiftexte.NextText = NULL;
negatiftexte.FrontPen = 1;
negatiftexte.BackPen = 0;
negatiftexte.DrawMode = 1;
negatiftexte.LeftEdge = 5;
negatiftexte.TopEdge = 5;
negatiftexte.ITextFont = NULL;
negatiftexte.IText = "Mal";
negatiftexte.NextText = NULL;
val = AutoRequest(fenetre, &blabla, &positiftexte, &negatiftexte, NULL, NULL, 200L, 60L);
if (val == TRUE)
printf("Tant mieux");
else
printf("Tant pis");
}
|
Mise à jour de septembre 2020 : une archive contenant le listing adapté à vbcc, et avec les exécutables compilés par SAS C et vbcc, a été réalisée par Yann-Gaël Guéhéneuc et est disponible sur obligement.free.fr/files/antscreenwithgraphicslibrary.lha.
|
