home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / td187src.lzh / FILE.I < prev    next >
Text File  |  1991-12-14  |  17KB  |  649 lines
  1. IMPLEMENTATION MODULE File ;
  2.  
  3. FROM SYSTEM   IMPORT ADDRESS , ADR;
  4. FROM Storage  IMPORT ALLOCATE , DEALLOCATE ;
  5. FROM Dialoge  IMPORT BusyStart, BusyEnd;
  6. FROM Diverses IMPORT GetFSelText, NumAlert;
  7. FROM Types    IMPORT DrawObjectTyp, TextPosTyp, CodeAryTyp,
  8.                      CharPtrTyp, ObjectPtrTyp;
  9. IMPORT MagicDOS ;
  10. IMPORT MagicStrings;
  11. IMPORT MagicSys;
  12. IMPORT mtAlerts ;
  13. IMPORT Diverses;
  14. IMPORT GetFile;
  15. IMPORT FileIO;
  16.  
  17. IMPORT Variablen ;
  18. IMPORT CommonData ;
  19. (**
  20. IMPORT RTD;
  21. **)
  22.  
  23. TYPE   ReadOrWrite = ( R , W ) ;
  24.  
  25.  
  26. VAR    FileHandle : INTEGER ;
  27.        Button     : INTEGER ;
  28.        FileVersion: INTEGER ;
  29.        Idum       : INTEGER ;
  30.        Bdum       : BOOLEAN ;
  31.        Cdum       : CARDINAL ;
  32.        Ldum       : MagicSys.lCARDINAL ;
  33.        MergeMode  : BOOLEAN;
  34.  
  35. PROCEDURE Correct(REF Filename    : ARRAY OF CHAR;
  36.                   VAR unilen,
  37.                       resolution,
  38.                       release     : INTEGER ) : BOOLEAN;
  39. VAR res    : BOOLEAN;
  40.     long   : MagicSys.lCARDINAL;
  41.     Handle : INTEGER;
  42.     Button : INTEGER;
  43.     code   : ARRAY [0..39] OF INTEGER;
  44.     adr    : ADDRESS;
  45.     num    : ARRAY [0..9] OF CHAR;
  46.     dtaptr : MagicDOS.PtrDTA;
  47. BEGIN
  48. (**
  49.   RTD.SetDevice(RTD.printer);
  50.   RTD.Write('Correct:', Filename);
  51. **)
  52.   res  := TRUE;
  53.   long := 20 ;
  54.   adr  := ADR ( code );
  55.   dtaptr := MagicDOS.Fgetdta() ;
  56.   Button := MagicDOS.Fsfirst ( Filename ,
  57.              {MagicDOS.ReadOnly, MagicDOS.Archive,
  58.               MagicDOS.Hidden, MagicDOS.System});
  59.   IF (Button=0) AND (dtaptr^.dLength>=20) THEN
  60.     FileIO.Reset(Handle, Filename);
  61.     IF Handle<0 THEN
  62.       res := FALSE;
  63.      ELSE
  64. (**
  65.     MagicDOS.Fread ( Handle , long , adr ) ;
  66. **)
  67.       FileIO.ReadNWords(Handle, 10, code);
  68.  
  69.       FileIO.Close ( Handle ) ;
  70.       IF ORD(code[0])<>ORD(Picture) THEN
  71.         res := FALSE;
  72.       END;
  73.       unilen     := code[6];
  74.       resolution := code[7];
  75.       release    := code[8];
  76.       IF (resolution<1) OR (resolution>5) THEN
  77.         resolution := 3;
  78.       END; (* altes Format *)
  79.     END;
  80.    ELSE
  81.     res := FALSE;
  82.   END;
  83.   IF NOT res THEN
  84.     mtAlerts.SetIcon(mtAlerts.Graphic);
  85. (**
  86.     Button := Diverses.Alert(1, NoPicFile);
  87. **)
  88.     Button := NumAlert(4, 1);
  89.   END;
  90. (**
  91.   RTD.Message('Leaving Correct');
  92. **)
  93.   RETURN res;
  94. END Correct;
  95.  
  96. PROCEDURE SelectFile ( VAR Name   : ARRAY OF CHAR;
  97.                        MSG        : ARRAY OF CHAR;
  98.                        LeaveName  : BOOLEAN;
  99.                        HasToExist : BOOLEAN  ) : INTEGER ;
  100.  
  101. VAR titel    : ARRAY [ 0..128 ] OF CHAR ;
  102.     path     : ARRAY [ 0..128 ] OF CHAR ;
  103.     file     : ARRAY [ 0..12  ] OF CHAR ;
  104.     ext      : ARRAY [ 0..4   ] OF CHAR ;
  105.     tmp1,tmp2: ARRAY [ 0..14   ] OF CHAR ;
  106.     titeladr : ADDRESS ;
  107.     fileadr  : ADDRESS ;
  108.     drive    : CARDINAL ;
  109.     index    : INTEGER ;
  110.     merke    : INTEGER ;
  111.     dummy    : BOOLEAN;
  112.  
  113. BEGIN
  114. (**
  115.   RTD.Message('Into SelectFile ');
  116. **)
  117.   IF LeaveName THEN
  118.     MagicStrings.Assign(Name, titel);
  119.     GetFile.ReplacePath(titel, '');
  120.   END;
  121.   tmp1 := '*.';
  122.   tmp2 := '.';
  123.   MagicStrings.Append(CommonData.Extensions[1], tmp1);
  124.   MagicStrings.Append(CommonData.Extensions[1], tmp2);
  125.   IF GetFile.GetFileName(Name, titel, tmp1, tmp2, CommonData.LTDPath, MSG,
  126.                          dummy, LeaveName, HasToExist, TRUE, FALSE) THEN
  127. (**
  128.     RTD.Message('Leaving SelectFile ');
  129. **)
  130.     RETURN 1;
  131.    ELSE
  132. (**
  133.     RTD.Message('Leaving SelectFile ');
  134. **)
  135.     RETURN 0;
  136.   END;
  137. END SelectFile ;
  138.  
  139.  
  140. PROCEDURE ReadWriteFile ( FileName : ARRAY OF CHAR;
  141.                           RW : ReadOrWrite;
  142.                           SelectFlag : BOOLEAN ) : BOOLEAN ;
  143. (* Lese bzw. schreibe Baum *)
  144.  
  145. VAR rw       : CARDINAL ;
  146.     long     : MagicSys.lCARDINAL ;
  147.     long2    : MagicSys.lCARDINAL ;
  148.     adr      : ADDRESS ;
  149.     z        : INTEGER;
  150.     dummy    : BOOLEAN;
  151.     lookset  : BITSET;
  152.     num      : ARRAY [ 0..3 ] OF CHAR ;
  153.     object   : ObjectPtrTyp ;
  154.     code     : CodeAryTyp ;
  155.     cptr     : CharPtrTyp ;
  156.     eptr     : ADDRESS;
  157.     cbuffer  : ARRAY [0..255] OF CHAR;
  158.     Surround : ARRAY [0..3] OF INTEGER;
  159.  
  160.   PROCEDURE SaveTree(first : ObjectPtrTyp;
  161.                      Subpic, OnlySelected : BOOLEAN) ;
  162.   VAR object : ObjectPtrTyp ;
  163.       number : INTEGER;
  164.   BEGIN
  165. (**
  166.     RTD.Message('Into SaveTree');
  167. **)
  168.     IF Subpic THEN
  169.      object := first^.Children;
  170.      ELSE
  171.       object := first^.Next;
  172.     END;
  173.     number := 0;
  174.     WHILE object<>NIL DO
  175.       IF OnlySelected THEN
  176.         IF object^.Selected THEN
  177.           number := number + 1;
  178.         END;
  179.        ELSE
  180.         number := number + 1;
  181.       END;
  182.       object := object^.Next;
  183.     END;
  184.     first^.Code[5] := number;
  185.     adr := ADR ( first^.Code ) ;
  186.     long := 20;
  187.     MagicDOS.Fwrite ( FileHandle , long , adr ) ;
  188.     IF Subpic THEN
  189.      object := first^.Children;
  190.      ELSE
  191.       object := first^.Next;
  192.     END;
  193.     WHILE object <> NIL DO
  194.       IF (NOT OnlySelected) OR
  195.          (OnlySelected AND object^.Selected) THEN
  196.         IF ORD(object^.Code[0]) <> ORD(Picture) THEN
  197.           long := 20 ;
  198.           adr := ADR ( object^.Code ) ;
  199.           MagicDOS.Fwrite ( FileHandle , long , adr ) ;
  200.           IF object^.Code [ 9 ]  > 0 THEN
  201.             long := MagicSys.CastToLCard ( object^.Code [ 9 ] ) ;
  202.             MagicDOS.Fwrite ( FileHandle , long , object^.CPtr ) ;
  203.           END;
  204.           CASE VAL(DrawObjectTyp, object^.Code[0]) OF
  205.             EpicSolidLine,
  206.             EpicDottedLine,
  207.             EpicDashedLine :
  208.               long2 := 4 * MagicSys.CastToLCard ( object^.Code [ 3 ] ) ;
  209.               IF long2 > 0 THEN
  210.                 MagicDOS.Fwrite ( FileHandle , long2 , object^.EPtr ) ;
  211.               END;|
  212.            ELSE
  213.             long2 := 0;
  214.           END;
  215.          ELSE
  216.           SaveTree(object, TRUE, FALSE);
  217.         END;
  218.       END;
  219.  
  220.       object := object^.Next ;
  221.     END;
  222. (**
  223.     RTD.Message('Leaving SaveTree');
  224. **)
  225.   END SaveTree;
  226.  
  227.   PROCEDURE LoadTree(flag, SelectIt  : BOOLEAN;
  228.                      anzahl: INTEGER) : BOOLEAN;
  229.   (* Ist Flag = 0  so merken wir uns den LastObject-Status und hängen    *)
  230.   (* den Zweig des Baumes um, dabei gehen wir davon aus, da₧ das zuletzt *)
  231.   (* erzeugte Objekt das Vaterobjekt ist.                                *)
  232.   VAR laststate : ObjectPtrTyp;
  233.       i, read   : INTEGER;
  234.       ok        : BOOLEAN;
  235.   BEGIN
  236. (**
  237.     RTD.Message('LoadTree');
  238.     RTD.ShowVar('anzahl', anzahl);
  239. **)
  240.     IF flag THEN
  241.       laststate := Variablen.LastObject;
  242.     END;
  243.     read := 0;
  244.     ok   := TRUE;
  245.     WHILE (read<anzahl) DO
  246.       long := 20 ;
  247.       adr := ADR ( code ) ;
  248. (**
  249.       MagicDOS.Fread ( FileHandle , long , adr ) ;
  250. **)
  251.       FileIO.ReadNWords( FileHandle, 10, code );
  252.  
  253.       IF ORD(code[0])<>ORD(Picture) THEN
  254. (**
  255.         long := MagicSys.CastToLCard ( code [ 9 ] ) ;
  256. **)
  257.         IF code[9] > 0 THEN
  258. (**
  259.           MagicDOS.Fread ( FileHandle , long , ADR(cbuffer) ) ;
  260. **)
  261. (**
  262.           RTD.Message('Text');
  263.           RTD.ShowVar('len', code[9]);
  264. **)
  265.           FileIO.ReadNBytes( FileHandle, code[9], cbuffer);
  266.           cbuffer[code[9]] := 0C;
  267. (**
  268.           RTD.Write('T ready', cbuffer);
  269.           FOR i:=0 TO code[9] DO
  270.             RTD.ShowVar('cbuf', cbuffer[i]);
  271.           END;
  272. **)
  273.         END (* if *);
  274.         CASE VAL(DrawObjectTyp, code[0]) OF
  275.           EpicSolidLine,
  276.           EpicDottedLine,
  277.           EpicDashedLine :
  278.             long2 := 4 * MagicSys.CastToLCard ( code [ 3 ] ) ; (* 2 * 2 Bytes *)
  279.             IF code[3] > 0 THEN
  280. (**
  281.               MagicDOS.Fread ( FileHandle , long2 , ADR(Variablen.ebuffer) ) ;
  282. **)
  283. (**
  284.               RTD.Message('Epic-Line');
  285. **)
  286.               FileIO.ReadNWords ( FileHandle, 2 * code[3], Variablen.ebuffer );
  287. (**
  288.               RTD.Message('EL ready');
  289. **)
  290.             END;|
  291.          ELSE
  292.           long2 := 0;
  293.         END (* case *);
  294. (**
  295.         RTD.Message('NewOb');
  296. **)
  297.         IF long2<>0 THEN
  298.           IF long<> 0 THEN
  299.             Variablen.NewObject ( code , ADR(cbuffer), ADR(Variablen.ebuffer), Surround ) ;
  300.            ELSE
  301.             Variablen.NewObject ( code , NIL, ADR(Variablen.ebuffer), Surround ) ;
  302.           END (* if *);
  303.          ELSE
  304.           IF long<> 0 THEN
  305.             Variablen.NewObject ( code , ADR(cbuffer), NIL, Surround ) ;
  306.            ELSE
  307.             Variablen.NewObject ( code , NIL, NIL, Surround ) ;
  308.           END (* if *);
  309.         END (* if *);
  310. (**
  311.         RTD.Message('NO ready');
  312. **)
  313.         Variablen.LastObject^.Selected  := SelectIt;
  314.         Variablen.LastObject^.SurrDirty := TRUE;
  315.        ELSE
  316.         Variablen.NewObject(code, NIL, NIL, Surround);
  317.         Variablen.LastObject^.SurrDirty := TRUE;
  318.         Variablen.LastObject^.Selected  := SelectIt;
  319.         ok := LoadTree(TRUE, SelectIt, code[5]);
  320.         IF NOT ok THEN
  321.           read := anzahl;
  322.         END (* if *);
  323.       END;
  324.  
  325.       read := read + 1;
  326.     END (* while *);
  327.     IF flag THEN
  328.       laststate^.Children  := laststate^.Next;
  329.       laststate^.Next      := NIL;
  330.       Variablen.LastObject := laststate;
  331.     END;
  332. (**
  333.     RTD.Message('Leaving LoadTree');
  334. **)
  335.     RETURN ok;
  336.   END LoadTree;
  337.  
  338. BEGIN
  339. (**
  340.   RTD.Message('Into ReadWriteFile ');
  341. **)
  342.   lookset := {MagicDOS.ReadOnly, MagicDOS.Archive,
  343.               MagicDOS.Hidden, MagicDOS.System};
  344.  
  345.   FOR z := 0 TO 3 DO
  346.     Surround[z] := 0; (* Das wird ja beim ersten Show korrigiert *)
  347.   END;
  348.  
  349.   CASE RW OF
  350.     R : rw := MagicDOS.Read ; |
  351.     W : rw := MagicDOS.Write ; |
  352.   END;
  353.   IF RW=R THEN
  354.     FileIO.Reset(FileHandle, FileName);
  355.     IF FileHandle<0 THEN
  356. (**
  357.       RTD.Message('Abort "FileHandle<0"');
  358. **)
  359.       RETURN FALSE ;
  360.      ELSE
  361. (**
  362.       long := 20 ;
  363.       adr := ADR ( code );
  364.       MagicDOS.Fread ( FileHandle , long , adr ) ;
  365.       Button := MagicDOS.Fclose ( FileHandle ) ;
  366. **)
  367.       FileIO.ReadNWords( FileHandle, 10, code );
  368.       FileIO.Close(FileHandle);
  369.       IF ORD(code[0])<>ORD(Picture) THEN
  370.         (* Sollte eigentlich schon abgefangen worden sein... *)
  371.         RETURN FALSE;
  372.       END;
  373.     END;
  374.   END;
  375.   IF RW=W THEN
  376.     FileHandle := MagicDOS.Fcreate ( FileName , {} );
  377.     Button     := MagicDOS.Fclose ( FileHandle ) ;
  378.     dummy      := FileIO.Fopen ( FileHandle, MagicDOS.Write, FileName );
  379.    ELSE
  380.   (**
  381.     dummy      := FileIO.Fopen ( FileHandle, MagicDOS.Read, FileName);
  382.   **)
  383.     FileIO.Reset ( FileHandle, FileName);
  384.     dummy := FileHandle>=0;
  385. (**
  386.     RTD.ShowVar('Handle', FileHandle);
  387. **)
  388.   END;
  389.   IF NOT dummy THEN
  390. (**
  391.     RTD.Message('Abort "NOT dummy"');
  392. **)
  393.     RETURN FALSE ;
  394.    ELSE
  395.     BusyStart(FileName, TRUE);
  396.     CASE RW OF
  397.       R : Idum := MagicDOS.Fsfirst ( FileName , lookset );
  398.           cptr := ADR(cbuffer); (* Charpuffer  *)
  399.           eptr := ADR(Variablen.ebuffer); (* Datenpuffer *)
  400.           long := 20 ;
  401.           IF MergeMode THEN
  402.             adr := ADR ( code );
  403. (**
  404.             MagicDOS.Fread ( FileHandle , long , adr ) ;
  405. **)
  406.             FileIO.ReadNWords( FileHandle, 10, code );
  407.             z   := code [ 5 ];
  408.            ELSE
  409. (**
  410.             adr := ADR ( Variablen.FirstObject^.Code ) ;
  411.             MagicDOS.Fread ( FileHandle , long , adr ) ;
  412. **)
  413.             FileIO.ReadNWords( FileHandle, 10, code );
  414.             FOR z:=0 TO 9 DO
  415.               Variablen.FirstObject^.Code[ z ] := code[z];
  416.             END;
  417.  
  418.             z   := Variablen.FirstObject^.Code[ 7 ];
  419.             IF (z<1) OR (z>5) THEN z := 3; END;
  420.             CommonData.InternalResolution := z;
  421.             Variablen.FirstObject^.Code[ 7 ] := z;
  422.             Variablen.FirstObject^.Selected := SelectFlag;
  423.             z   := Variablen.FirstObject^.Code[ 5 ];
  424. (**
  425.             RTD.ShowVar('objects', z);
  426. **)
  427.           END;
  428.  
  429.           dummy := LoadTree(FALSE, SelectFlag, z); |
  430.  
  431.       W : SaveTree(Variablen.FirstObject, FALSE, SelectFlag) ; |
  432.     END;
  433.  
  434.     Button := MagicDOS.Fclose ( FileHandle ) ;
  435.     BusyEnd;
  436. (**
  437.     RTD.Message('Leaving ReadWriteFile ');
  438. **)
  439.     RETURN TRUE ;
  440.   END;
  441. END ReadWriteFile ;
  442.  
  443.  
  444. (*------------------------------------------------------------------------*)
  445. (*                        Exportierte Prozeduren                          *)
  446. (*------------------------------------------------------------------------*)
  447.  
  448. PROCEDURE LoadFile (REF FileName : ARRAY OF CHAR ) : BOOLEAN ;
  449. VAR object,
  450.     next : ObjectPtrTyp ;
  451.     res  : BOOLEAN;
  452.     dummy: INTEGER;
  453.     vers : INTEGER;
  454. BEGIN
  455. (**
  456.   RTD.Message('Into LoadFile');
  457. **)
  458.   MergeMode := FALSE;
  459.   res :=  Correct(FileName, dummy, dummy, FileVersion);
  460.   IF res THEN
  461. (**
  462.     RTD.Message('File correct');
  463. **)
  464.     (* Alle bisherigen Objekte löschen *)
  465.     next := Variablen.FirstObject^.Next ;
  466.     WHILE next <> NIL DO
  467.       object := next ;
  468.       next := next^.Next ;
  469.       Variablen.DeleteObject ( object ) ;
  470.     END;
  471.     Variablen.LastObject := Variablen.FirstObject ;
  472.     Variablen.FirstObject^.Next := NIL;
  473.  
  474.     res := ReadWriteFile ( FileName, R, FALSE );
  475.     IF res THEN
  476.       MagicStrings.Assign(FileName, CommonData.FileName);
  477.     END;
  478.   END;
  479. (**
  480.   RTD.Message('Leaving LoadFile');
  481. **)
  482.   RETURN res;
  483. END LoadFile;
  484.  
  485. PROCEDURE Load ( ) : BOOLEAN ;
  486. VAR tree : ADDRESS ;
  487.     object , p1, p2, next : ObjectPtrTyp ;
  488.     res  : BOOLEAN;
  489.     dummy: INTEGER;
  490.     msg,
  491.     name : ARRAY [0..255] OF CHAR;
  492. BEGIN
  493. (**
  494.   RTD.Message('Into Load ');
  495. **)
  496.   res := FALSE;
  497.   MagicStrings.Assign(CommonData.FileName, name);
  498.  
  499.   GetFSelText(1, msg);
  500.   Button := SelectFile ( CommonData.FileName, msg, FALSE, TRUE);
  501.  
  502.   IF Button = 1 THEN
  503.     res := LoadFile(CommonData.FileName);
  504.   END;
  505.   IF NOT res THEN
  506.     MagicStrings.Assign(name, CommonData.FileName);
  507.   END;
  508. (**
  509.   RTD.Message('Leaving Load ');
  510. **)
  511.   RETURN res;
  512. END Load ;
  513.  
  514. PROCEDURE Merge ( SelectObjects : BOOLEAN ) ;
  515.  
  516. VAR tree          : ADDRESS ;
  517.     object , next : ObjectPtrTyp ;
  518.     dum           : BOOLEAN;
  519.     msg, MergeName: ARRAY [0..255] OF CHAR; (* zu Konservierungszwecken *)
  520.     adr           : ADDRESS ;
  521.     dummy         : BOOLEAN;
  522.     i, unilen     : INTEGER;
  523.     resolution    : INTEGER;
  524.     num           : ARRAY [ 0..9 ] OF CHAR ;
  525.     str           : ARRAY [ 0..159 ] OF CHAR ;
  526.     code          : CodeAryTyp ;
  527. BEGIN
  528. (**
  529.   RTD.Message('Into Merge ');
  530. **)
  531.   MergeMode := TRUE;    (* Bisherige Objekte beibehalten *)
  532.  
  533.   GetFSelText(2, msg);
  534.   Button := SelectFile ( MergeName, msg, FALSE, TRUE);
  535.  
  536.   IF Button = 1 THEN
  537.     IF Correct( MergeName, unilen, resolution, FileVersion ) THEN
  538.       IF (unilen<>Variablen.FirstObject^.Code[6]) OR
  539.          (resolution<>Variablen.FirstObject^.Code[7]) THEN
  540.  
  541.         Button := NumAlert(25, 1);
  542.         IF Button<>1 THEN
  543.           RETURN;
  544.         END;
  545.       END;
  546.       dum := ReadWriteFile ( MergeName, R, SelectObjects );
  547.      ELSE
  548.       RETURN;
  549.     END;
  550.   END;
  551.  
  552.   IF CommonData.FileName[0]=0C THEN
  553.     MagicStrings.Assign( MergeName, CommonData.FileName );
  554.   END;
  555. (**
  556.   RTD.Message('Leaving Merge ');
  557. **)
  558. END Merge ;
  559.  
  560. (*------------------------------------------------------------------------*)
  561.  
  562. PROCEDURE Save ( ) ;
  563.  
  564. BEGIN
  565. (**
  566.   RTD.Message('Into Save ');
  567. **)
  568.   Bdum := ReadWriteFile ( CommonData.FileName, W, FALSE ) ;
  569. (**
  570.   RTD.Message('Leaving Save ');
  571. **)
  572. END Save ;
  573.  
  574. (*------------------------------------------------------------------------*)
  575.  
  576. PROCEDURE SaveAs ( OnlySelectedObjects : BOOLEAN ) : BOOLEAN;
  577. VAR SaveName, msg : ARRAY [0..255] OF CHAR;
  578.     dummy    : INTEGER;
  579. BEGIN
  580. (**
  581.   RTD.Message('Into SaveAs ');
  582. **)
  583.   MagicStrings.Assign(CommonData.FileName, SaveName);
  584.  
  585.   REPEAT
  586.     IF OnlySelectedObjects THEN
  587.       GetFSelText(4, msg);
  588.      ELSE
  589.       GetFSelText(3, msg);
  590.     END;
  591.     Button := SelectFile ( SaveName, msg, TRUE, FALSE ) ;
  592.     IF Button = 1 THEN
  593.       IF NOT GetFile.Check(SaveName) THEN
  594.         Button := -1;
  595.       END;
  596.     END;
  597.   UNTIL (Button<>-1);
  598.  
  599.   IF Button = 1 THEN
  600. (*
  601.     FileHandle := MagicDOS.Fcreate ( SaveName , {} );
  602.     dummy      := MagicDOS.Fclose ( FileHandle ) ;
  603. *)
  604.     Bdum := ReadWriteFile ( SaveName, W, OnlySelectedObjects );
  605.     IF NOT OnlySelectedObjects THEN
  606.       IF CommonData.FileName[0]=0C THEN
  607.         MagicStrings.Assign(SaveName, CommonData.FileName);
  608.       END;
  609.     END;
  610.   END;
  611. (**
  612.   RTD.Message('Leaving SaveAs ');
  613. **)
  614.   RETURN Button=1;
  615. END SaveAs ;
  616.  
  617.  
  618. PROCEDURE InsertFile (VAR filehandle : INTEGER;
  619.                       REF SecondFile : ARRAY OF CHAR);
  620. (*
  621.    Da das ja nur fürs Schreiben gilt, brauchen wir keine
  622.    gro₧en Klimmzüge machen.
  623. *)
  624. VAR SecondHandle : INTEGER;
  625.     str          : ARRAY [0..255] OF CHAR;
  626. BEGIN
  627.   IF CommonData.IncludePath[0]<>0C THEN
  628.     MagicStrings.Assign(CommonData.IncludePath, str);
  629.     MagicStrings.Append(SecondFile, str);
  630.    ELSE
  631.     MagicStrings.Assign(SecondFile, str);
  632.   END;
  633.   FileIO.Reset(SecondHandle, str);
  634.   IF (SecondHandle>0) THEN
  635.     WHILE NOT FileIO.EOF DO
  636.       FileIO.ReadLn(SecondHandle, str);
  637.       FileIO.WriteLn(filehandle, str);
  638.     END;
  639.     FileIO.Close(SecondHandle);
  640.   END;
  641. END InsertFile;
  642.  
  643.  
  644. (**
  645. BEGIN
  646.   RTD.SetDevice(RTD.printer);
  647. **)
  648. END File .
  649.