home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 10 / screen.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-08-01  |  5.9 KB  |  111 lines
  1. (* ----------------------------------------------------------------------- *)
  2. (*                               PASSCR.PAS                                *)
  3. (*         Bildschirm-Sicherung/-Restaurierung mit Standard-Pascal         *)
  4. (* Im Prinzip fuer jeden Pascal-Compiler und jeden Rechner anwendbar, so-  *)
  5. (* fern die Organisation und Adresse des Bildschirmspeichers bekannt ist.  *)
  6. (* Desweiteren muss eine Ueberwachung von Zeigern durch das Pascal Lauf-   *)
  7. (* zeit-System abschaltbar sein, falls selbiges stattfinden sollte.        *)
  8. (* Hier die Implementationen fuer Pascal ST Plus auf Atari ST sowie den    *)
  9. (* MS-DOS Pascal-Compiler BCI-Pascal. Die nicht benoetigte Version  v o r  *)
  10. (* der Compilierung  l o e s c h e n !!                                    *)
  11.  
  12. PROGRAM screendemo;
  13.  
  14. (* Typen und Variablen an entsprechender Stelle im Programm (global)       *)
  15. (* vereinbaren. Die Struktur des Bildschirmspeichers (VideoRam) ist        *)
  16. (* systemabhaengig und muss entsprechend angepasst werden. Ebenso muss     *)
  17. (* der Adresse-Type (hier LONG-INTEGER, entspricht der Darstellung von     *)
  18. (* Zeigern auf dem ST, 2 Worte) dem System angepasst werden - die meisten  *)
  19. (* MS-DOS Pascal-Compiler kennen keine LONG-Integers - also z.B. ein       *)
  20. (* Record mit Segment und Offset vom Typ Integer verwenden.                *)
  21. (* ----------------------------------------------------------------------- *)
  22. (*                     fuer Atari ST und Pascal ST Plus:                   *)
  23. TYPE
  24.   VideoRam  = ARRAY [1..400,1..20] OF LONG_INTEGER;            (* 32 kByte *)
  25.   ScreenPtr = RECORD CASE BOOLEAN OF                     (* der CASE-Trick *)
  26.                 FALSE: (VideoAdr: LONG_INTEGER);
  27.                 TRUE : (VideoMem: ^VideoRam);
  28.                END;
  29.  
  30. VAR                                              (* fuer die Demonstration *)
  31.   ScreenBuffer: ScreenPtr;  i: INTEGER;  ch: CHAR;
  32. (* ----------------------------------------------------------------------- *)
  33. (*           Adresse des aktiven Bildschirmspeichers ermitteln:            *)
  34. FUNCTION LogScreenBase: LONG_INTEGER; XBios(3);
  35. (* ----------------------------------------------------------------------- *)
  36. (*                             Bildschirm sichern:                         *)
  37. PROCEDURE SaveScreen (VAR Screen: ScreenPtr);
  38. VAR LogScreen: ScreenPtr;
  39. BEGIN
  40.   New(Screen.VideoMem);      (* neuen Bildschirmspeicher dynamisch anlegen *)
  41.   LogScreen.VideoAdr := LogScreenBase;
  42.   (*$P-*)      (* Ueberwachung von Zeigern durch Laufzeitsystem abschalten *)
  43.    (* folgende Zuweisung erledigt die ganze Maloche - und das recht flott: *)
  44.   Screen.VideoMem^ := LogScreen.VideoMem^;
  45.   (*$P=*)      (* vorherigen Zustand d. Compiler-Option wieder herstellen  *)
  46. END;
  47. (* ----------------------------------------------------------------------- *)
  48. (*                          Bildschirm restaurieren:                       *)
  49. PROCEDURE RestoreScreen (VAR Screen: ScreenPtr);
  50. VAR LogScreen: ScreenPtr;
  51. BEGIN
  52.   LogScreen.VideoAdr := LogScreenBase;                            (* dito! *)
  53.   (*$P-*)
  54.   LogScreen.VideoMem^ := Screen.VideoMem^;
  55.   (*$P=*)
  56.   Dispose(Screen.VideoMem);  (* dynam. Bildschirmspeicher wieder freigeben *)
  57. END;
  58. (* ----------------------------------------------------------------------- *)
  59. (* ----------------------------------------------------------------------- *)
  60. (*                       fuer MS-DOS und BCI-Pascal:                       *)
  61.  
  62. (*$Z+*)            (* "long pointers" um Bildschirmspeicher zu adressieren *)
  63. TYPE
  64.   BYTE      = 0..255;
  65.   VideoRam  = ARRAY[1..2000,1..2] OF BYTE; (* character, attribute, 4000 B.*)
  66.   ScreenPtr = RECORD CASE BOOLEAN OF           (* ebenfalls der CASE-Trick *)
  67.                  FALSE: (VideoSeg, VideoOfs: INTEGER);
  68.                  TRUE : (VideoMem: ^VideoRam);
  69.               END;
  70.  
  71. VAR                                              (* fuer die Demonstration *)
  72.   ScreenBuffer: ScreenPtr;  i: INTEGER;  ch: CHAR;
  73. (* ----------------------------------------------------------------------- *)
  74. (*     Adresse des aktiven, angezeigten Bildschirmspeichers ermitteln:     *)
  75. FUNCTION LogScreenBase: ScreenPtr;
  76. BEGIN                             (* hier einfach die Konstanten fuer CGA: *)
  77.   LogScreenBase.VideoSeg := 0B800h;  LogScreenBase.VideoOfs := 0000h;
  78. END;
  79. (* ----------------------------------------------------------------------- *)
  80. (*                             Bildschirm sichern:                         *)
  81. PROCEDURE SaveScreen (VAR Screen: ScreenPtr);
  82. VAR LogScreen: ScreenPtr;
  83. BEGIN
  84.   New(Screen.VideoMem);      (* neuen Bildschirmspeicher dynamisch anlegen *)
  85.   LogScreen := LogScreenBase;
  86.    (* folgende Zuweisung erledigt die ganze Maloche - und das recht flott: *)
  87.   Screen.VideoMem^ := LogScreen.VideoMem^;
  88. END;
  89. (* ----------------------------------------------------------------------- *)
  90. (*                          Bildschirm restaurieren:                       *)
  91. PROCEDURE RestoreScreen (VAR Screen: ScreenPtr);
  92. VAR LogScreen: ScreenPtr;
  93. BEGIN
  94.   LogScreen := LogScreenBase;                                     (* dito! *)
  95.   LogScreen.VideoMem^ := Screen.VideoMem^;
  96.   Dispose(Screen.VideoMem);  (* dynam. Bildschirmspeicher wieder freigeben *)
  97. END;
  98. (* ----------------------------------------------------------------------- *)
  99. (* ----------------------------------------------------------------------- *)
  100. (*                           und die Demonstration:                        *)
  101.  
  102. BEGIN (* screendemo *)
  103.   FOR i := 1 TO 2000 DO Write('A');   (* Bildschirm mit 'A' fuellen...     *)
  104.   SaveScreen(ScreenBuffer);           (* Inhalt des selbigen sichern...    *)
  105.   Write('RETURN druecken...'); ReadLn(ch);            (* auf RETURN warten *)
  106.   FOR i := 1 TO 25 DO WriteLn;        (* und jetzt den Bildschirm loeschen *)
  107.   Write('RETURN druecken...'); ReadLn(ch);
  108.   RestoreScreen(ScreenBuffer);        (* alten Bildschirm wieder zeigen... *)
  109.   Write('RETURN druecken...'); ReadLn(ch);
  110. END.
  111.