Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 14:58  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Quizz
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Trucs et astuces
 · Articles divers

 · Articles in english


Twitter

Suivez-nous sur Twitter




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

 · Menu des galeries

 · BD d'Amiga Spécial
 · Caricatures Dudai
 · Caricatures Jet d'ail
 · Diagrammes de Jay Miner
 · Images insolites
 · Fin de jeux (de A à E)
 · Fin de Jeux (de F à O)
 · Fin de jeux (de P à Z)
 · Galerie de Mike Dafunk
 · Logos d'Obligement
 · Pubs pour matériels
 · Systèmes d'exploitation
 · Trombinoscope Alchimie 7
 · Vidéos


Téléchargement

 · Documents
 · Jeux
 · Logiciels
 · Magazines
 · Divers


Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


Programmation : Amiga C Manual - Les écrans
(Article écrit par Anders Bjerin et extrait d'Amiga C Manual - mars 1990)


Note : traduction par Serge Hammouche.

1. Les écrans

1.1 Introduction

L'écran est la base de l'affichage sous Intuition. Il détermine le nombre de couleurs que vous pouvez utiliser, quelles sont ces couleurs, en quelle résolution, etc. Chaque fenêtre, gadget, icône, dessin est lié à un écran. En déplaçant cet écran vous déplacez aussi les objets qui lui sont liés. Vous pouvez avoir plusieurs écrans ouverts en même temps (ayant chacun leur propre résolution, couleurs, etc.), et vous pouvez les tous les afficher en même temps.

1.2 Les différents types d'écrans

Avant d'utiliser un écran, vous devez d'abord décider si vous utiliserez un écran standard (Workbench) ou un écran que vous aurez personnalisé (Custom Screen).
  • Workbench Screen (l'écran du Workbench) : c'est l'écran standard d'Intuition. C'est un écran quatre couleurs, en haute résolution.
  • Custom Screens (les écrans personnalisés) : quand il vous faut un écran dans votre propre mode d'affichage, vous devez utiliser un écran personnalisé. Vous pouvez alors choisir vous-même son nombre de couleurs, la palette de couleurs, la résolution et donc la taille, etc.
Si votre programme doit utiliser un écran haute résolution et que quatre couleurs suffisent, je vous conseille d'utiliser l'écran Workbench, ce qui économise beaucoup de mémoire (il n'y en a pas d'allouée pour un écran personnalisé) et permet à utilisateur de visualiser simultanément plusieurs programmes en cours. Toutefois, s'il vous faut plus de couleurs, une autre résolution ou un autre mode d'affichage, vous devez utiliser un écran personnalisé.

1.3 Workbench Screen (l'écran du Workbench)

Le "Workbench Screen" est un écran haute résolution (640 pixels de large), en quatre couleurs. Sa hauteur est de 200 ou 256 lignes selon que vous avez un ordinateur NTSC (Américain) ou PAL (Européen). 400/512 lignes en mode entrelacé.

L'écran Workbench s'ouvre automatiquement s'il n'y a aucun autre écran. Si vous ne voulez pas de l'écran Workbench et qu'il vous faut beaucoup de mémoire, vous pouvez essayer de le fermer avec CloseWorkBench(). Pensez à le rouvrir avec OpenWorkBench() quand votre programme se termine.

Je vous conseille de toujours appeler la fonction OpenWorkBench() à la fin de vos programmes, même si vous ne l'avez pas vous-même fermé. Un autre programme peut l'avoir fermé à cause du manque de mémoire, et quand votre programme se termine, il peut y avoir assez de mémoire. Ceci rendra l'écran Workbench accessible aussi souvent que possible.

1.4 Custom Screens (écrans personnalisés)

Si vous voulez utiliser un écran personnalisé, vous devez initialiser une structure (NewScreen) selon vos besoins. Vous devez aussi ouvrir l'écran vous-même en appelant la fonction OpenScreen().

Voici une liste des choix importants qu'il faut faire avant d'ouvrir l'écran :

1.4.1 La résolution

Vous pouvez avoir un écran en haute résolution ou en basse résolution. Un écran en haute résolution fait 640 pixels de large, tandis qu'un écran en basse résolution en fait seulement 320 pixels. De plus, un écran en haute résolution a une profondeur maximale de 4 bits (maximum 16 couleurs), tandis qu'un écran en basse résolution peut aller jusqu'à 5 (32 couleurs), ou même 6 avec des modes d'affichage spéciaux.

1.4.2 La profondeur

La profondeur d'un écran est le nombre de bits utilisés pour chaque pixel. Plus il y a de bits, plus il y a de combinaisons, donc de couleurs possibles :

   Profondeur      Nombre de couleurs            Nombre de registres couleur
-----------------------------------------------------------------------------------
       1                   2                          0 -  1
       2                   4                          0 -  3
       3                   8                          0 -  7
       4                  16                          0 - 15
       5                  32                          0 - 31  (en basse résolution)

Un écran en basse résolution peut même avoir une profondeur de 6 bits dans des modes d'affichage spéciaux (HAM, Extra Half-Bright).

Chaque couleur peut être choisie dans une palette de 4096 couleurs. Quand vous avez ouvert votre écran personnalisé, vous pouvez changer les couleurs grâce à la fonction graphique SetRGB4().

1.4.3 L'entrelacement

Un écran entrelacé peut avoir 400 lignes (NTSC) ou 512 (PAL) tandis qu'un écran non-entrelacé peut en avoir au plus 200/256. Je vous recommande d'utiliser si possible un écran non-entrelacé parce qu'un affichage entrelacé tremble si l'utilisateur n'a pas un moniteur spécial à haute persistance (c'est le cas de 99% d'entre eux).

Le moniteur rafraîchit normalement l'affichage 50 fois par seconde. Si vous utilisez un écran entrelacé, l'Amiga n'affichera d'abord que les lignes paires, et au passage d'après les lignes impaires. C'est pourquoi un écran entrelacé semble trembler. Vous pouvez atténuer sensiblement le tremblement en utilisant des couleurs peu contrastées, par exemple noir et gris au lieu de noir et blanc.

1.4.4 Le HAM et l'Extra Half-Bright

Si vous avez un écran en basse résolution avec six plans de bits (Depth 6) vous pouvez utiliser le mode HAM ou le mode Extra Half-Bright. Le HAM vous permet d'afficher les 4096 couleurs simultanément mais avec quelques restrictions et il est complexe à utiliser. L'Extra Half-Bright vous procure 32 couleurs supplémentaires qui sont semblables aux 32 premières couleurs mais en un peu plus brillant.

Le HAM et l'Extra Half-Bright consomment tous deux beaucoup de mémoire et de temps machine et ne sont donc pas couramment utilisés.

1.4.5 Les Dual Playfields

Les Dual Playfields vous permettent d'avoir deux écrans l'un sur l'autre. L'écran du dessus peut être transparent par endroits (registre couleur 0) et laisser apparaître l'écran du dessous.

1.4.6 Les polices de caractères (fonts)

Vous pouvez spécifier une police de caractères par défaut qui sera utilisée, sauf indication contraire, pour afficher du texte à l'écran. La police de caractères par défaut du système s'appelle Topaz et existe en deux tailles :
  • TOPAZ_SIXTY : neuf lignes de haut, 64/32 caractères par ligne.
  • TOPAZ_EIGHTY : huit lignes de haut, 80/40 caractères par ligne.
Cette police est résidente sur l'Amiga et est donc toujours accessible (voir le chapitre 3 - Les graphismes pour plus d'informations).

1.4.7 Taille et position

Le haut de votre écran n'a pas besoin de coïncider avec le haut de l'affichage. Vous pouvez ouvrir plusieurs écrans et les placer les uns au-dessous des autres. Si, par exemple, vous écrivez un jeu d'aventure, vous pouvez mettre un écran basse résolution en 32 couleurs en haut de l'affichage (avec une belle image), et avoir un écran haute résolution en deux couleurs en bas de l'affichage (pour le texte). Rappelez-vous que l'utilisateur peut lui-même monter ou descendre les écrans.

La largeur de l'écran doit être de 320 (basse résolution) ou 640 pixels (haute résolution).

La hauteur peut varier entre 1 et 200/256 lignes en non-entrelacé, et entre 1 et 400/512 lignes en entrelacé.

1.4.8 L'intitulé

En haut de chaque écran (sur la barre de déplacement) il y a un intitulé d'écran. Il y a deux sortes d'intitulés :
  • L'intitulé par défaut, qui est spécifié dans la structure NewScreen.
  • Un intitulé courant qui est celui de la fenêtre actuellement activée (voir le chapitre 2 - Les fenêtres pour plus d'informations).
1.4.9 Gadgets

Pour le moment, vous n'êtes pas autorisés à attacher des gadgets personnalisés à un écran (voir le chapitre 4 - Les gadgets pour plus d'informations sur les gadgets).

1.5 Initialiser un écran personnalisé

Avant d'ouvrir un écran personnalisé (Custom Screen), vous devez initialiser une structure NewScreen comme suit :

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 (bord gauche) : position initiale de l'écran en x. Doit toujours valoir 0.
  • TopEdge (bord supérieur) : position initiale de l'écran en y.
  • Width (largeur) : 320 pour un écran basse résolution, 640 sinon.
  • Height (hauteur) : entre 1 et 200/256 pour un écran non entrelacé, entre 1 et 400/512 sinon.
  • Depth (profondeur) : de 1 à 4 en haute résolution, de 1 à 6 sinon.
  • DetailPen (crayon de détail) : le registre couleur utilisé pour afficher le texte.
  • BlockPen (crayon de bloc) : le registre couleur utilisé pour les remplissages de blocs, etc.
  • ViewModes (mode) : vous pouvez utiliser aucun ou plusieurs drapeaux. Si vous utilisez plusieurs drapeaux, séparez les par un "|" (vous ne pouvez pas activer à la fois les drapeaux HIRES et DUALPF, HIRES et HAM, DUALPF et HAM).

    • HIRES : activez ce drapeau si vous voulez un écran haute résolution (basse résolution par défaut).
    • INTERLACE : activez ce drapeau si vous voulez un écran entrelacé (non entrelacé par défaut).
    • SPRITES : activez ce drapeau si vous prévoyez d'afficher des sprites.
    • DUALPF : activez ce drapeau pour utiliser le mode Dual Playfields.
    • HAM : activez ce drapeau pour utiliser le mode Hold And Modify (HAM).

  • Type : doit être CUSTOMSCREEN. Vous pouvez aussi activer le drapeau CUSTOMBITMAP si vous voulez utiliser dans votre écran un bitmap que vous avez déclaré et initialisé (voir le chapitre 2 - Les fenêtres pour plus d'informations sur les bitmaps personnalisés).
  • Font (police de caractères) : pointeur sur une structure TextAttr déjà initialisée. L'écran l'utilisera comme police par défaut (voir le chapitre 3 - Les graphismes pour plus d'informations sur les polices). NULL si vous voulez utiliser la police par défaut courante.
  • DefaultTitle (intitulé par défaut) : pointeur sur une chaîne de texte qui sera l'intitulé par défaut.
  • Gadgets : ne pas utiliser pour le moment. Mettez NULL.
  • CustomBitMap : si vous voulez utiliser votre propre bitmap, vous devez fournir à ce champ un pointer sur la structure BitMap que vous avez déclarée et initialisée. Pensez à activer le drapeau CUSTOMBITMAP dans la variable Type. Toutefois, si vous voulez qu'Intuition s'occupe du bitmap, fixez ce champ à NULL (voir le chapitre 2 - Les fenêtres pour plus d'informations sur les bitmaps personnalisés).
1.6 Ouvrir un écran personnalisé

Quand vous avez déclaré et initialisé la structure NewScreen, appelez la fonction OpenScreen() pour ouvrir votre écran personnalisé. Quand votre écran est ouvert vous pouvez, si vous aviez alloué de la mémoire pour la structure NewScreen, la libérer si vous n'avez plus besoin de la structure.

Voici comment appeler la fonction OpenScreen() :

my_screen = OpenScreen( &my_new_screen ); 

Où "my_screen" a été déclaré comme :

struct Screen *my_screen;

Où "my_new_screen" a été declaré comme :

struct NewScreen my_new_screen;

...et initialisé selon vos besoins.

OpenScreen() retourne un pointeur sur une structure Screen, ou NULL si elle n'a pas pu ouvrir l'écran (manque de mémoire par exemple). Vérifiez toujours ce qu'OpenScreen() retourne !

if( my_screen==NULL )
{
  /* PANIQUE! Impossible d'ouvrir l'écran */
}

1.7 La structure Screen

Quand vous ouvrez l'écran, vous obtenez un pointeur sur une structure Screen qui ressemble à ceci :

struct Screen
{
  struct Screen *NextScreen;    /* Pointeur sur le prochain écran,   */
                                /* ou NULL.                          */
  struct Window *FirstWindow;   /* Pointeur sur la première fenêtre  */
                                /* de cet écran.                     */
  SHORT LeftEdge, TopEdge;      /* Position de l'écran.              */
  SHORT Width, Height;          /* Taille de l'écran.                */
  SHORT MouseY, MouseX;         /* Position de relative la souris    */
                                /* par rapport au coin supérieur     */
                                /* gauche de l'écran.                */
  USHORT Flags;                 /* Les drapeaux activés.             */
  UBYTE *Title;                 /* L'intitulé courant de l'écran.    */
  UBYTE *DefaultTitle;          /* L'intitulé par défaut de l'écran. */

  BYTE BarHeight, BarVBorder,
       BarHBorder, MenuVBorder,
       MenuHBorder;
  BYTE WBorTop, WBorLeft,
       WBorRight, WBorBottom;

  struct TextAttr *Font;        /* La police par défaut de l'écran.  */
  struct ViewPort ViewPort;     /* Le ViewPort de l'écran, etc. :     */
  struct RastPort RastPort;
  struct BitMap BitMap;
  struct Layer_Info LayerInfo;
  struct Gadget *FirstGadget;
  UBYTE DetailPen, BlockPen;
  USHORT SaveColor0;
  struct Layer *BarLayer;
  UBYTE *ExtData;
  UBYTE *UserData;
};

Vous n'utiliserez probablement pas souvent cette structure, mais certaines variables/structures peuvent être utiles par la suite. Quand vous utilisez, par exemple, la fonction SetRGB4(). Nous y reviendrons plus tard.

1.8 Les fonctions

Voici des fonctions courantes qui agissent sur les écrans :

OpenScreen()

Cette fonction ouvre un écran personnalisé selon vos besoins.
  • Synopsis : my_screen = OpenScreen( my_new_screen );
  • my_screen : (struct Screen *). Pointeur sur la structure Screen. Il pointe sur votre écran nouvellement ouvert ou est égal à NULL si l'écran n'a pas pu être ouvert.
  • my_new_screen : (struct NewScreen *). Pointeur sur la structure NewScreen qui contient vos préférences.
CloseScreen()

Cette fonction ferme un Custom Screen que vous avez précédemment ouvert.
  • Synopsis : CloseScreen( my_screen );
  • my_screen : (struct Screen *). Pointeur sur l'écran déjà ouvert.
Toutes les fenêtres (voir le chapitre 2 - Les fenêtres pour plus d'informations) de votre écran doivent avoir été fermées avant que vous ne puissiez fermer l'écran. Si vous fermez une fenêtre après avoir fermé l'écran, le système se plantera (déconseillé).

S'il n'y a plus d'écrans après la fermeture des vôtres, Intuition rouvrira automatiquement l'écran du Workbench.

MoveScreen()

Cette fonction déplace l'écran. Pour le moment vous ne pouvez le bouger que verticallement.
  • Synopsis : MoveScreen( my_screen, delta_x, delta_y );
  • my_screen : (struct Screen *). Pointeur sur l'écran que vous voulez déplacer.
  • delta_x : (long). Nombre de pixels dont l'écran doit bouger horizontalement. Pour le moment, vous ne pouvez pas bouger un écran horizontalement, fixez le donc à 0.
  • delta_y : (long). Nombre de lignes dont l'écran doit bouger verticalement.
ScreenToBack()

Place l'écran derrière tous les autres écrans.
  • Synopsis : ScreenToBack( my_screen );
  • my_screen : (struct Screen *). Pointeur sur l'écran que vous voulez déplacer.
ScreenToFront()

Place l'écran devant tous les autres écrans.
  • Synopsis : ScreenToFront( my_screen );
  • my_screen : (struct Screen *). Pointeur sur l'écran que vous voulez déplacer.
ShowTitle()

Cette fonction fera s'afficher le nom d'un écran devant ou derrière une fenêtre d'arrière-plan (Voir le chapitre 2 - Les fenêtres pour plus d'informations sur les fenêtres d'arrière-plan, alias "backdrop windows"). Le nom de l'écran apparaît toujours derrière les fenêtres normales.
  • Synopsis : ShowTitle( my_screen, show_it );
  • my_screen : (struct Screen *). Pointeur sur l'écran.
  • show_it : (long). Un paramètre booléen qui peut être :
    • TRUE : le nom sera devant toutes les fenêtres d'arrière-plan, mais derrière toutes les autres fenêtres.
    • FALSE : le nom sera derrière toutes les fenêtres.
OpenWorkBench()

Cette fonction essaie d'ouvrir l'écran du Workbench s'il y a assez de mémoire disponible.
  • Synopsis : result = OpenWorkBench();
  • result : (long). Une valeur booléenne qui indique si l'écran du Workbench a été (ou était déjà) ouvert (TRUE) ou non (FALSE).
CloseWorkBench()

Cette fonction essaiera de fermer l'écran du Workbench si possible. Si un autre programme utilise l'écran du Workbench, la fonction ne peut pas le fermer. La fermeture du Workbench libère de la mémoire et peut donc être utilisée si votre programme requiert plus de mémoire Pensez à rouvrir l'écran du Workbench quand votre programme se termine.
  • Synopsis : result = CloseWorkBench();
  • result : (long). Un paramètre booléen qui nous indique si l'écran du Workbench a été (ou était déjà) fermé (TRUE), ou non (FALSE).
WBenchToBack()

Place l'écran du Workbench derrière tous les autres écrans.
  • Synopsis : result = WBenchToBack();
  • result : (long). Un paramètre booléen qui est TRUE si l'écran du Workbench était ouvert, ou FALSE s'il ne l'était pas.
WBenchToFront()

Place l'écran du Workbench devant tous les autres écrans.
  • Synopsis : result = WBenchToFront();
  • result : (long). Un paramètre booléen qui est TRUE si l'écran du Workbench était ouvert, ou FALSE s'il ne l'était pas.
SetRGB4()

Cette fonction vous permet de changer vos couleurs d'écran. Chaque couleur peut être prise dans une palette de 4096 couleurs (16 niveaux de rouge, 16 niveaux de vert et 16 niveaux de bleu ; 16*16*16 = 4096).

Attention : avant d'utiliser cette fonction, vous devez avoir ouvert la Graphics.library (toutes les autres fonctions sont dans Intuition.library, voir le chapitre 0 - Introduction pour plus d'informations).
  • Synopsis : SetRGB4( viewport, register, red, green, blue );
  • viewport : (struct ViewPort *). Pointeur sur le ViewPort dont les registres de couleur vont changer. Nous pouvons trouver le ViewPort de l'écran dans la structure Screen (si my_screen est le pointeur sur la structure Screen, ceci nous donnera un pointeur sur le ViewPort de l'écran : &my_screen->ViewPort).
  • register : (long) le registre couleur que vous voulez modifier. La profondeur d'écran fixe le nombre de registres couleur que l'écran peut avoir :
 Profondeur  Registres Couleur
-----------------------------
    1            0 - 1
    2            0 - 3
    3            0 - 7
    4            0 - 15
    5            0 - 31
    6            0 - 63

  • red : composante rouge (0 - 15).
  • green : composante verte (0 - 15).
  • blue : composante bleue (0 - 15).
Par exemple : SetRGB4( &my_screen->ViewPort, 2, 15, 15, 0 ) ; change le registre couleur 2 en jaune clair (rouge et vert donnent du jaune).

1.9 Exemples

Nous avons donc parlé des différents écrans : l'écran Workbench et vos écrans personnalisés. Nous avons vu comment vous pouvez changer le mode d'affichage, la résolution, la profondeur, etc., d'un écran personnalisé et nous avons décrit des fonctions importantes. Maintenant, il est temps de voir quelques exemples (dans le répertoire "Amiga_C_Manual/1.Ecrans") pour dissiper toute ambiguïté.

Tous les exemples, les programmes et les codes source, sont dans le même répertoire que ce document.

Exemple 1

Ce programme ouvre un écran personnalisé en basse résolution, non entrelacé, 8 couleurs. Il l'affiche pendant trente secondes, puis le ferme.

Exemple 2

Comme l'exemple 1 mais l'écran est en haute résolution, entrelacé, 4 couleurs.

Exemple 3

Comme l'exemple 1 mais il utilise la police TOPAZ_SIXTY en style italique comme police par défaut (voir le chapitre 3 - Les graphismes pour plus d'informations sur les styles de texte).

Exemple 4

Ce programme ouvre deux écrans, l'un (en basse résolution 32 couleurs) en haut de l'affichage, et l'autre (en haute résolution 16 couleurs) un peu plus bas.

Exemple 5

Comme l'exemple 4 sauf qu'après dix secondes l'écran en basse résolution descend de 75 lignes. Encore dix secondes après, il passe au-dessus de tous les autres écrans. Dix secondes plus tard il descend encore de 75 lignes. Le programme attend alors dix secondes puis ferme les écrans et se termine.

Exemple 6

Ce programme ouvre un écran personnalisé en basse résolution, non entrelacé, 4 couleurs. Après cinq secondes, il commence à changer les couleurs d'écran, puis ferme l'écran et se termine près un moment.


[Retour en haut] / [Retour aux articles] [Chapitre précédent : introduction] / [Chapitre suivant : les fenêtres]