Accueil        Lexique        UNITéS        Algorithmes        Tutoriel   

Les unités de Pure Pascal (langage Pascal pour les ordinateurs de la gamme Atari ST), compatible Turbo Pascal.

Unité GEM : Liste des fenêtre

Lors du rafraîchissement des fenêtres (déclenché par un message WM_REDRAW, par exemple), seules les zones réellement visibles à l'écran peuvent être redessinées.

AES garde la trace des parties d'une fenêtre qui ne sont pas couvertes par d'autres fenêtres. Il construit une liste de rectangles contenus dans la zone de travail de la fenêtre, non couverts par d'autres fenêtres et, non obstrués par la zone de travail de la fenêtre. Cette liste est accessible à l'aide de la fonction wind_get.

Malheureusement, cela devient encore plus compliqué: AES ne tient pas compte du fait qu'une fenêtre peut également être partiellement à l'extérieur de l'écran, c'est-à-dire que la partie extérieure apparaît également dans la liste rectangulaire. Mais vous n'êtes pas autorisé à y dessiner quoi que ce soit.

Pour tirer le meilleur parti des complications, il se peut que seule une partie de la fenêtre soit redessinée car, par exemple, seule une partie de celle-ci était couverte par une boîte de dialogue.

Heureusement, il existe une approche normalisée qui répond à toutes ces exigences et qui peut être appliquée à de nouveaux programmes avec relativement peu de travail.

Voici un exemple:

procedure  Redraw( winHandle : Integer; dirty : Rect );

    procedure  RectIntersect( r1 : Rect; var r2 : Rect );

        functionMin( a, b : Integer ) : Integer;
        begin
            if a < b then
                Min := a
            else
                Min := b;
        end;

        function Max( a, b : Integer ) : Integer;
        begin
            if a > b then
                Max := a
            else
                Max := b;
        end;

        var
            x, y, w, h : Integer;

        begin
            x := Max( r1.x, r2.x );
            y := Max( r1.y, r2.y );
            w := Min( r1.x + r1.w, r2.x + r2.w ) - x;
            h := Min( r1.y + r1.h, r2.y + r2.h ) - y;
            r2.x := x;
            r2.y := y;
            r2.w := w;
            r2.h := h;
        end;

    var
    f, r : Rect;
    pxyarray : ARRAY_4;

    begin
        wind_update( BEG_UPDATE );
        wind_get( 0, WF_WORKXYWH, f.x, f.y, f.w, f.h );
        RectIntersect( f, dirty );
        wind_get( winHandle, WF_FIRSTXYWH, r.x, r.y, r.w, r.h );
        while ( r.w > 0 ) and ( r.h > 0 ) do begin
        RectIntersect( dirty, r );
        if ( r.w > 0 ) and ( r.h > 0 ) then
        begin
            pxyarray[0] := r.x;
            pxyarray[1] := r.y;
            pxyarray[2] := r.x + r.w - 1;
            pxyarray[3] := r.y + r.h - 1;
            vs_clip( GemInit.vdiHandle, 1, pxyarray );
            graf_mouse( M_OFF, nil );
            DrawWindowContents( winHandle, r );
            graf_mouse( M_ON, nil );
            vs_clip( GemInit.vdiHandle, 0, pxyarray );
        end;
        wind_get( winHandle, WF_NEXTXYWH, r.x, r.y, r.w, r.h );
    end;
    wind_update( END_UPDATE );
end;
La procédure auxiliaire RectIntersect calcule l'intersection de deux rectangles, c'est-à-dire la zone où les deux se chevauchent.

L'appel wind_update verrouille les structures de données internes à AES afin que la liste des rectangles ne change pas pendant que nous la traitons.

L'appel wind_get(0, WF_WORKXYWH, ...) récupère les dimensions de l'écran. Si nous coupons ceci avec le rectangle à dessiner ("sale"), nous obtenons un rectangle pour la zone à dessiner sur l'écran.

Ensuite, la liste des rectangles est traitée. Chaque rectangle est récupéré avec wind_get et coupé avec le rectangle à dessiner. Si l'intersection n'est pas vide, les options de dessin VDI sont limitées au rectangle avec vs_clip et le contenu est dessiné en appelant une procédure DrawWindowContents. La souris doit d'abord être allumée puis éteinte (appels à graf_mouse).

Enfin, nous publions les structures de données internes AES avec un autre appel wind_update.


Vous trouverez dans cette zone la liste de toutes les Unités (équivalent des "Librairies" en C) de Pure Pascal. Les Unités indiqués comme standards existent dans la majorité des compilateurs Pascal existant sur ordinateurs 16 bits et au dela (dont Turbo Pascal 3 mini). Les unités indiqués comme Atari sont spécifiques aux systèmes d'exploitation des Atari ST (TOS n.n).

Accès aux unités

Les menus déroulants de chaque unité sont des accès directs aux procédures et fonctions, classés alphabétiquement (sans tenir compte de la casse, puisque le langage Pascal ne tient pas compte de la casse!)
CRT (Standard)

DOS (Standard)

GEM : AES (Atari)

GEM : VDI (Atari)

Graph (Standard)

Overlay (Standard)

Printer Strings (Standard)

System (Standard)

TOS : BIOS (Atari)

TOS : GEMDOS (Atari)

TOS : XBIOS (Atari)

Cette page Unités est issu du fichier UNIT.HLP de la documentation de Pure Pascal (d'Application Systems Heidelberg), qui a été convertie en format TXT puis traduite de l'Allemand grâce à Google Translator : des milliers de copier/coller de et vers Google translator ont été nécessaires, ne connaissant pas un mot d'Allemand!


Copyright © 2021 par Albatros Concept (Bruno Aubin)