home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / modula2 / library / filetool / toolutil.mod < prev   
Text File  |  1987-12-29  |  12KB  |  446 lines
  1. IMPLEMENTATION MODULE ToolUtilities;
  2.  
  3. (*
  4. Title    : TOOLUTIL.MOD
  5. LastEdit : 12/31/87
  6. Author   : Russell G. Osterlund, Jr.
  7. System   : LOGITECH MODULA-2/86, REPERTOIRE, BlackBeard
  8.  
  9. This product has been developed with the use of, and embodies portions of,
  10. LOGITECH software development tools - compiler, linker, and M2MAKE.
  11.  
  12. *)
  13.  
  14. FROM SYSTEM IMPORT
  15.   SIZE;
  16. FROM MemoryOperations IMPORT
  17.   FillChar;
  18. FROM Drectory IMPORT (* REPERTOIRE *)
  19.   ModeSet, FileInfoRec,
  20.   FindFirstFile, FindNextFile,
  21.   GetDefaultDrive, SetDefaultDrive, VolumeLabel, ChDir;
  22. FROM StringIO IMPORT (* REPERTOIRE *)
  23.   ErrorMessage;
  24. FROM Strings IMPORT
  25.   Assign, Pos, Copy, Length, Concat, CompareStr;
  26. FROM StrEdit IMPORT (* REPERTOIRE *)
  27.   CAPstr;
  28. FROM ToolDisplay IMPORT
  29.   DisplayInfo, DisplaySummaryLine;
  30. FROM ToolTypes IMPORT
  31.   DirectoryRecPtr, DirectoryInfo, FileInfoRecord,
  32.   ActiveWindow, BothWindowsActive, WindowType;
  33.  
  34. PROCEDURE InitDirectoryInfo (directory: DirectoryRecPtr);
  35. VAR
  36.   i: CARDINAL;
  37. BEGIN
  38.   WITH directory^ DO
  39.     NumberOfEntries := 0;
  40.     NumberTagged := 0;
  41.     CurrentFile := 0;
  42.     FirstDisplayed := 0;
  43.     DirectorySize := VAL (LONGINT, 0);
  44.     TaggedSize := VAL (LONGINT, 0);
  45.     DirectoryDrive := ' ';
  46.     FillChar (DirectoryPath, SIZE (DirectoryPath), ' ');
  47.     FillChar (Label, SIZE (Label), ' ');
  48.     FillChar (DirectoryMask, SIZE (DirectoryMask), ' ');
  49.     FOR i := 0 TO HIGH (FileInfoArray) DO
  50.       WITH FileInfoArray [i] DO
  51.     tagged := FALSE;
  52.     FileAttribute := ModeSet {};
  53.     FileHour := 0;
  54.     FileMinute := 0;
  55.     FileSecond := 0;
  56.     FileMonth := 0;
  57.     FileDay := 0;
  58.     FileYear := 0;
  59.     FileSize := VAL (LONGINT, 0);
  60.     FillChar (FileName, SIZE (FileName), CHR (255));
  61.     FillChar (FileExtension, SIZE (FileExtension), CHR (255));
  62.       END;
  63.     END;
  64.   END;
  65. END InitDirectoryInfo;
  66.  
  67. PROCEDURE ReadInfo (directory: DirectoryRecPtr);
  68. VAR
  69.   p: CARDINAL;
  70.   DOSInfo: FileInfoRec;
  71.   SavedMessage: ErrorMessage;
  72.  
  73. BEGIN
  74.   WITH directory^ DO
  75.     NumberOfEntries := 0;
  76.     DirectoryDrive := GetDefaultDrive ();
  77.     VolumeLabel (GetDefaultDrive (), Label);
  78.     SavedMessage := FindFirstFile (DirectoryMask, DOSInfo);
  79.     WHILE SavedMessage = NoError DO
  80.       WITH FileInfoArray [NumberOfEntries] DO
  81.     FileAttribute := DOSInfo . attribute;
  82.     FileHour := DOSInfo . hour;
  83.     FileMinute := DOSInfo . minute;
  84.     FileSecond := DOSInfo . second;
  85.     FileMonth := DOSInfo . month;
  86.     FileDay := DOSInfo . day;
  87.     FileYear := DOSInfo . year;
  88.     FileSize := DOSInfo .size;
  89.     IF (DOSInfo . name [0] = '.') OR          (* special DOS *)
  90.       ((DOSInfo . name [0] = '.') AND
  91.        (DOSInfo . name [1] = '.')) THEN       (* files       *)
  92.       Assign (DOSInfo . name, FileName);
  93.       FillChar (FileExtension, SIZE (FileExtension), ' ');
  94.     ELSE
  95.       p := Pos ('.', DOSInfo . name);
  96.       IF p = HIGH (DOSInfo . name) + 1 THEN   (* not found *)
  97.         FillChar (FileExtension, SIZE (FileExtension), ' ');
  98.         Copy (DOSInfo . name, 0, Length (DOSInfo . name), FileName);
  99.       ELSE
  100.         Copy (DOSInfo . name, 0, p, FileName);
  101.         Copy (DOSInfo . name, p + 1, Length (DOSInfo . name) - p, FileExtension);
  102.         Concat (FileExtension, '   ', FileExtension);
  103.       END;
  104.     END;
  105.       END;
  106.       DirectorySize := DirectorySize + DOSInfo . size;
  107.       SavedMessage := FindNextFile (DOSInfo);
  108.       INC (NumberOfEntries);
  109.     END (* while *);
  110.     IF NumberOfEntries # 0 THEN
  111.       DEC (NumberOfEntries);
  112.       CurrentFile := 0;
  113.     END;
  114.   END;
  115. END ReadInfo;
  116.  
  117. PROCEDURE SortByName (l, r: INTEGER);
  118. VAR
  119.   iDone,
  120.   jDone: BOOLEAN;
  121.   i, j: INTEGER;
  122.   Pivot,
  123.   Temp: FileInfoRecord;
  124. BEGIN
  125.   WITH DirectoryInfo [ORD (ActiveWindow)] DO
  126.     IF r > l THEN
  127.       Pivot := FileInfoArray [r];
  128.       i := l - 1;
  129.       j := r;
  130.       REPEAT
  131.     iDone := FALSE;
  132.     REPEAT
  133.       INC (i);
  134.       WITH FileInfoArray [i] DO
  135.         IF (CompareStr (FileName, Pivot . FileName) > 0) OR
  136.           ((CompareStr (FileName, Pivot . FileName) = 0) AND
  137.            (CompareStr (FileExtension, Pivot . FileExtension) > -1)) THEN
  138.           iDone := TRUE;
  139.         END;
  140.       END;
  141.     UNTIL (iDone) OR
  142.           (i = r);
  143.     jDone := FALSE;
  144.     REPEAT
  145.       DEC (j);
  146.       WITH FileInfoArray [j] DO
  147.         IF (CompareStr (FileName, Pivot . FileName) < 0) OR
  148.           ((CompareStr (FileName, Pivot . FileName) = 0) AND
  149.            (CompareStr (FileExtension, Pivot . FileExtension) < 1)) THEN
  150.           jDone := TRUE;
  151.         END;
  152.       END;
  153.     UNTIL (jDone) OR
  154.           (j = l);
  155.     Temp := FileInfoArray [i];
  156.     FileInfoArray [i] := FileInfoArray [j];
  157.     FileInfoArray [j] := Temp;
  158.       UNTIL j <= i;
  159.       FileInfoArray [j] := FileInfoArray [i];
  160.       FileInfoArray [i] := FileInfoArray [r];
  161.       FileInfoArray [r] := Temp;
  162.       SortByName (l, i - 1);
  163.       SortByName (i + 1, r);
  164.     END;
  165.   END;
  166. END SortByName;
  167.  
  168. PROCEDURE SortByExtension (l, r: INTEGER);
  169. VAR
  170.   iDone,
  171.   jDone: BOOLEAN;
  172.   i, j: INTEGER;
  173.   Pivot,
  174.   Temp: FileInfoRecord;
  175. BEGIN
  176.   WITH DirectoryInfo [ORD (ActiveWindow)] DO
  177.     IF r > l THEN
  178.       Pivot := FileInfoArray [r];
  179.       i := l - 1;
  180.       j := r;
  181.       REPEAT
  182.     iDone := FALSE;
  183.     REPEAT
  184.       INC (i);
  185.       WITH FileInfoArray [i] DO
  186.         IF (CompareStr (FileExtension, Pivot . FileExtension) > 0) OR
  187.           ((CompareStr (FileExtension, Pivot . FileExtension) = 0) AND
  188.            (CompareStr (FileName, Pivot . FileName) > -1)) THEN
  189.           iDone := TRUE;
  190.         END;
  191.       END;
  192.     UNTIL (iDone) OR
  193.           (i = r);
  194.     jDone := FALSE;
  195.     REPEAT
  196.       DEC (j);
  197.       WITH FileInfoArray [j] DO
  198.         IF (CompareStr (FileExtension, Pivot . FileExtension) < 0) OR
  199.           ((CompareStr (FileExtension, Pivot . FileExtension) = 0) AND
  200.            (CompareStr (FileName, Pivot . FileName) < 1)) THEN
  201.           jDone := TRUE;
  202.         END;
  203.       END;
  204.     UNTIL (jDone) OR
  205.           (j = l);
  206.     Temp := FileInfoArray [i];
  207.     FileInfoArray [i] := FileInfoArray [j];
  208.     FileInfoArray [j] := Temp;
  209.       UNTIL j <= i;
  210.       FileInfoArray [j] := FileInfoArray [i];
  211.       FileInfoArray [i] := FileInfoArray [r];
  212.       FileInfoArray [r] := Temp;
  213.       SortByExtension (l, i - 1);
  214.       SortByExtension (i + 1, r);
  215.     END;
  216.   END;
  217. END SortByExtension;
  218.  
  219. PROCEDURE SortBySize (l, r: INTEGER);
  220. VAR
  221.   i, j: INTEGER;
  222.   Pivot,
  223.   Temp: FileInfoRecord;
  224. BEGIN
  225.   WITH DirectoryInfo [ORD (ActiveWindow)] DO
  226.     IF r > l THEN
  227.       Pivot := FileInfoArray [r];
  228.       i := l - 1;
  229.       j := r;
  230.       REPEAT
  231.     REPEAT
  232.       INC (i);
  233.     UNTIL NOT (FileInfoArray [i] . FileSize > Pivot . FileSize) OR
  234.           (i = r);
  235.     REPEAT
  236.       DEC (j);
  237.     UNTIL NOT (FileInfoArray [j] . FileSize < Pivot . FileSize) OR
  238.           (j = l);
  239.     Temp := FileInfoArray [i];
  240.     FileInfoArray [i] := FileInfoArray [j];
  241.     FileInfoArray [j] := Temp;
  242.       UNTIL j <= i;
  243.       FileInfoArray [j] := FileInfoArray [i];
  244.       FileInfoArray [i] := FileInfoArray [r];
  245.       FileInfoArray [r] := Temp;
  246.       SortBySize (l, i - 1);
  247.       SortBySize (i + 1, r);
  248.     END;
  249.   END;
  250. END SortBySize;
  251.  
  252. PROCEDURE SortByDate (l, r: INTEGER);
  253. VAR
  254.   iDone,
  255.   jDone: BOOLEAN;
  256.   i, j: INTEGER;
  257.   Pivot,
  258.   Temp: FileInfoRecord;
  259. BEGIN
  260.   WITH DirectoryInfo [ORD (ActiveWindow)] DO
  261.     IF r > l THEN
  262.       Pivot := FileInfoArray [r];
  263.       i := l - 1;
  264.       j := r;
  265.       REPEAT
  266.     iDone := FALSE;
  267.     REPEAT
  268.       INC (i);
  269.       IF FileInfoArray [i] . FileYear > Pivot . FileYear THEN
  270.         iDone := TRUE
  271.       ELSE
  272.         IF FileInfoArray [i] . FileYear = Pivot . FileYear THEN
  273.           IF FileInfoArray [i] . FileMonth > Pivot . FileMonth THEN
  274.         iDone := TRUE
  275.           ELSE
  276.         IF FileInfoArray [i] . FileMonth = Pivot . FileMonth THEN
  277.           IF FileInfoArray [i] . FileDay > Pivot . FileDay THEN
  278.             iDone := TRUE
  279.           ELSE
  280.             IF FileInfoArray [i] . FileDay = Pivot . FileDay THEN
  281.               IF FileInfoArray [i] . FileHour > Pivot . FileHour THEN
  282.             iDone := TRUE
  283.               ELSE
  284.             IF FileInfoArray [i] . FileHour = Pivot . FileHour THEN
  285.               IF FileInfoArray [i] . FileMinute > Pivot . FileMinute THEN
  286.                 iDone := TRUE
  287.               ELSE
  288.                 IF FileInfoArray [i] . FileMinute = Pivot . FileMinute THEN
  289.                   IF FileInfoArray [i] . FileSecond > Pivot . FileSecond THEN
  290.                 iDone := TRUE
  291.                   END;
  292.                 END;
  293.               END;
  294.             END;
  295.               END;
  296.             END;
  297.           END;
  298.         END;
  299.           END;
  300.         END;
  301.       END;
  302.     UNTIL (iDone) OR
  303.           (i = r);
  304.     jDone := FALSE;
  305.     REPEAT
  306.       DEC (j);
  307.       IF FileInfoArray [j] . FileYear < Pivot . FileYear THEN
  308.         jDone := TRUE
  309.       ELSE
  310.         IF FileInfoArray [j] . FileYear = Pivot . FileYear THEN
  311.           IF FileInfoArray [j] . FileMonth < Pivot . FileMonth THEN
  312.         jDone := TRUE
  313.           ELSE
  314.         IF FileInfoArray [j] . FileMonth = Pivot . FileMonth THEN
  315.           IF FileInfoArray [j] . FileDay < Pivot . FileDay THEN
  316.             jDone := TRUE
  317.           ELSE
  318.             IF FileInfoArray [j] . FileDay = Pivot . FileDay THEN
  319.               IF FileInfoArray [j] . FileHour < Pivot . FileHour THEN
  320.             jDone := TRUE
  321.               ELSE
  322.             IF FileInfoArray [j] . FileHour = Pivot . FileHour THEN
  323.               IF FileInfoArray [j] . FileMinute < Pivot . FileMinute THEN
  324.                 jDone := TRUE
  325.               ELSE
  326.                 IF FileInfoArray [j] . FileMinute = Pivot . FileMinute THEN
  327.                   IF FileInfoArray [j] . FileSecond < Pivot . FileSecond THEN
  328.                 jDone := TRUE
  329.                   END;
  330.                 END;
  331.               END;
  332.             END;
  333.               END;
  334.             END;
  335.           END;
  336.         END;
  337.           END;
  338.         END;
  339.       END;
  340.     UNTIL (jDone) OR
  341.           (j = l);
  342.     Temp := FileInfoArray [i];
  343.     FileInfoArray [i] := FileInfoArray [j];
  344.     FileInfoArray [j] := Temp;
  345.       UNTIL j <= i;
  346.       FileInfoArray [j] := FileInfoArray [i];
  347.       FileInfoArray [i] := FileInfoArray [r];
  348.       FileInfoArray [r] := Temp;
  349.       SortByDate (l, i - 1);
  350.       SortByDate (i + 1, r);
  351.     END;
  352.   END;
  353. END SortByDate;
  354.  
  355. PROCEDURE BuildFullFileName (directory: DirectoryRecPtr;
  356.                  filenum: CARDINAL;
  357.              VAR FullFileName: ARRAY OF CHAR);
  358. BEGIN
  359.   FullFileName [0] := 0C;
  360.   WITH directory^ . FileInfoArray [filenum] DO
  361.     Concat (FileName, '.', FullFileName);
  362.     Concat (FullFileName, FileExtension, FullFileName);
  363.   END;
  364. END BuildFullFileName;
  365.  
  366. PROCEDURE BuildFullPath (TheDrive: CHAR;
  367.              ThePath: ARRAY OF CHAR;
  368.              VAR FullPath: ARRAY OF CHAR);
  369. BEGIN
  370.   FullPath [0] := 0C;
  371.   Concat (TheDrive, ':', FullPath);
  372.   Concat (FullPath, ThePath, FullPath);
  373.   CAPstr (FullPath);
  374. END BuildFullPath;
  375.  
  376. PROCEDURE ConcatPathFile (Path: ARRAY OF CHAR;
  377.               FileName: ARRAY OF CHAR;
  378.               VAR Combined: ARRAY OF CHAR);
  379. BEGIN
  380.   IF Path [Length (Path) - 1] = '\' THEN
  381.     Concat (Path, FileName, Combined);
  382.   ELSE
  383.     Concat (Path, '\', Combined);
  384.     Concat (Combined, FileName, Combined);
  385.   END;
  386.   CAPstr (Combined);
  387. END ConcatPathFile;
  388.  
  389. PROCEDURE RedisplayDirectory (directory: DirectoryRecPtr;
  390.                   first: CARDINAL);
  391. VAR
  392.   SaveDrive: CHAR;
  393.   SaveCurrent: CARDINAL;
  394.   SaveMask: ARRAY [0 .. 11] OF CHAR;
  395.   SavePath: ARRAY [0 .. 65] OF CHAR;
  396.   error: ErrorMessage;
  397. BEGIN
  398.   WITH directory^ DO
  399.     SaveDrive := DirectoryDrive;
  400.     SaveCurrent := CurrentFile;
  401.     Assign (DirectoryPath, SavePath);
  402.     Assign (DirectoryMask, SaveMask);
  403.     InitDirectoryInfo (directory);
  404.     Assign (SavePath, DirectoryPath);
  405.     Assign (SaveMask, DirectoryMask);
  406.     DirectoryDrive := SaveDrive;
  407.     FirstDisplayed := first;
  408.     SetDefaultDrive (DirectoryDrive);
  409.     error := ChDir (DirectoryPath);
  410.     ReadInfo (directory);
  411.     CurrentFile := SaveCurrent;
  412.     DisplayInfo (directory, first, TRUE);
  413.     DisplaySummaryLine (directory);
  414.   END;
  415. END RedisplayDirectory;
  416.  
  417. PROCEDURE RedisplayScreen (directory, LeftDirectory, RightDirectory: DirectoryRecPtr);
  418. VAR
  419.   SaveWindow: WindowType;
  420. BEGIN
  421.   IF BothWindowsActive THEN
  422.     SaveWindow := ActiveWindow;
  423.     ActiveWindow := LeftWindow;
  424.     IF SaveWindow = LeftWindow THEN
  425.       DisplayInfo (LeftDirectory, LeftDirectory^ . FirstDisplayed, TRUE);
  426.     ELSE
  427.       DisplayInfo (LeftDirectory, LeftDirectory^ . FirstDisplayed, FALSE);
  428.     END;
  429.     DisplaySummaryLine (LeftDirectory);
  430.     ActiveWindow := RightWindow;
  431.     IF SaveWindow = RightWindow THEN
  432.       DisplayInfo (RightDirectory, RightDirectory^ . FirstDisplayed, TRUE);
  433.     ELSE
  434.       DisplayInfo (RightDirectory, RightDirectory^ . FirstDisplayed, FALSE);
  435.     END;
  436.     DisplaySummaryLine (RightDirectory);
  437.     ActiveWindow := SaveWindow;
  438.   ELSE
  439.     DisplayInfo (directory, directory^ . FirstDisplayed, TRUE);
  440.     DisplaySummaryLine (directory);
  441.   END;
  442. END RedisplayScreen;
  443.  
  444. BEGIN
  445. END ToolUtilities.
  446.