TopWare Tools/TOOLS.iso/tools/top1654/gepackt.exe/MEM.MOD

Text File | 1994-01-28 | 5.4 KB | 189 lines

MODULE MemInfoElems; (* CS/MH/RG c't 3/94 *)
(* Textelement, das den zur Verfügung stehenden Heap-Speicher *)
(* anzeigt. Version ohne Ticker (Aktualisierung nur durch     *)
(* Kommando-Klick auf das Textelement) *)

IMPORT
   Kernel, Files, Input, Display, Viewers, Fonts, Texts, Oberon,
   TextFrames;

TYPE
   (* Wenn das Textelement Daten speichert, braucht man einen *)
   (* eigenen, von Texts.ElemDesc abgeleiteten Typ. *)

   MemInfoElem* = POINTER TO MemInfoElemDesc;
   MemInfoElemDesc* = RECORD (Texts.ElemDesc)
      (* Praktischerweise müßte memavail eine globale Variable *)
      (* sein, weil der zu Verfügung stehende Heap-Speicher    *)
      (* eine globale Größe ist. Hier lokal, damit das Text-   *)
      (* element seinen Wert speichert. *)

      memavail: LONGINT;
   END;

(* Manipulatoren *)

PROCEDURE ^Handle (e: Texts.Elem; VAR msg: Texts.ElemMsg);
   (* Das ist eine Forward-Deklaration. *)

PROCEDURE Open* (e: MemInfoElem);
BEGIN
   (* "Konstruktor" *)
   (* Initialisiert die Werte eines MemInfoElems-Records. *)

   e.W := 5 * TextFrames.mm;     (* 5 mm Breite/Höhe *)
   e.H := e.W;
   e.handle := Handle;           (* Handler für Interaktionen *)
   e.memavail := 0
END Open;

PROCEDURE Copy* (se, de: MemInfoElem);
BEGIN
   (* "Kopier-Konstruktor" *)
   (* Erzeugt ein neues MemInfo-Element durch Kopie eines alten. *)

   Texts.CopyElem(se, de);
   de.memavail := 0;
END Copy;

PROCEDURE Alloc*;
VAR
   e: MemInfoElem;
BEGIN
   (* "new MemInfoElem" *)
   (* Erzeugt ein neues MemInfo-Element. *)

   NEW(e); Open(e);
   Texts.new := e;
END Alloc;

(* Zeichner *)

PROCEDURE PrepDraw* (e: MemInfoElem; fnt: Fonts.Font);
VAR
   dx, x, y, w, h: INTEGER;
   pat: Display.Pattern;
BEGIN
   (* Bereitet Zeichnen vor, indem es die tatsächliche Breite/Höhe *)
   (* berechnet. Display.GetChar liefert Informationen zu einem    *)
   (* Zeichen eines best. Fonts. *)

   Display.GetChar(fnt.raster, '0', dx, x, y, w, h, pat);
   e.W := 8 * LONG(dx) * TextFrames.Unit;
   e.H := LONG(fnt.height) * TextFrames.Unit;
END PrepDraw;

PROCEDURE Draw* (e: MemInfoElem; msg: TextFrames.DisplayMsg);
VAR
   p: TextFrames.Parc;
   pat: Display.Pattern;
   beg, memavail: LONGINT;
   x, y, w, h, cx, cy, dx: INTEGER;
BEGIN
   (* Zeichnet ein MemInfo-Element, nachdem es sich vergewissert hat, *)
   (* dass sich die Daten geändert haben. *)

   memavail := Kernel.Available();
   IF memavail # e.memavail THEN
      e.memavail := memavail;
      (* Vorbereitung: holt den für das Element gültige Parcn *)
      (* und berechnet Position/Breite/Hähe in Pixeln. *)

      TextFrames.ParcBefore(Texts.ElemBase(e), msg.pos, p, beg);
      w := SHORT(e.W DIV TextFrames.Unit);
      h := SHORT(p.dsr DIV TextFrames.Unit);
      x := msg.X0 + w;
      y := msg.Y0 + h;

      (* Zeichnet Ziffer für Ziffer (von rechts nach links) *)
      (* Display.CopyPattern zeichnet ein Muster im angegebenen *)
      (* Modus (replace). *)

      WHILE memavail # 0 DO
         Display.GetChar(msg.fnt.raster, CHR(memavail MOD 10 + ORD('0')),
            dx, cx, cy, w, h, pat);
         DEC(x, dx);
         Display.CopyPattern(msg.col, pat, x + cx, y + cy,
            Display.replace);
         memavail := memavail DIV 10;
      END;
   END;
END Draw;

PROCEDURE Track* (e: MemInfoElem; msg: TextFrames.TrackMsg);
VAR
   keysum, keys: SET;
BEGIN
   (* Zeichnet den Mauszeiger, solange mind. eine Taste gedrückt ist. *)

   IF msg.keys = {1} THEN keysum := msg.keys END;
   REPEAT
      Oberon.DrawCursor(Oberon.Mouse, Oberon.Arrow, msg.X, msg.Y);
      Input.Mouse(keys, msg.X, msg.Y);
      keysum := keysum + keys;
   UNTIL keys = {};

   IF keysum = {1} THEN
      (* Nur die mittlere Taste wurde gedràckt => Zeichne MemInfo- *)
      (* Element neu. Texts.ChangeLooks schickt dem Element eine   *)
      (* Display-Nachricht. *)

      Texts.ChangeLooks(Texts.ElemBase(e), msg.pos, msg.pos + 1, {},
         NIL, 0, 0);
   END;
END Track;

(* Handler *)

PROCEDURE Handle (e: Texts.Elem; VAR msg: Texts.ElemMsg);
VAR
   copy: MemInfoElem;
BEGIN
   (* Der Interaktions-Handler fàr die MemInfo-Elemente. *)
   (* Reagiert auf die Nachrichten "Copy", "Identify",   *)
   (* "Display" und "Track". *)

   WITH e: MemInfoElem DO
      IF msg IS Texts.CopyMsg THEN
         NEW(copy); Copy(e, copy); msg(Texts.CopyMsg).e := copy;
      ELSIF msg IS Texts.IdentifyMsg THEN
         WITH msg: Texts.IdentifyMsg DO
            msg.mod := "MemInfoElems"; msg.proc := "Alloc";
         END
      ELSIF msg IS TextFrames.DisplayMsg THEN
         WITH msg: TextFrames.DisplayMsg DO
            IF msg.prepare THEN PrepDraw(e, msg.fnt)
            ELSE Draw(e, msg) END;
         END;
      ELSIF msg IS TextFrames.TrackMsg THEN
         WITH msg: TextFrames.TrackMsg DO Track(e, msg) END;
      END;
   END;
END Handle;

(* Anwender-Kommandos *)

PROCEDURE Insert*;
VAR
   e: MemInfoElem;
   M: TextFrames.InsertElemMsg;
BEGIN
   (* Implementiert das Kommando "MemInfoElems.Insert". Nach der *)
   (* Aktivierung wird ein MemInfo-Element an die Stelle des     *)
   (* Carets eingefàgt. *)

   NEW(e); Open(e);
   M.e := e;

   (* Schickt dem fokussierten Viewer (das Fenster, das das Caret *)
   (* enthält) die Nachricht "InsertElem". *)

   Oberon.FocusViewer.handle(Oberon.FocusViewer, M);
END Insert;

(* Initialisierung *)

BEGIN
   (* ohne Initialisierung *)
END MemInfoElems.