home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Utilities / ACDPlay / src / V1.6 / File.c < prev    next >
C/C++ Source or Header  |  1998-01-17  |  5KB  |  177 lines
  1. /* File.c - Dateifunktionen */
  2.  
  3. #include "Constants.h"
  4.  
  5. #include <exec/memory.h>
  6. #include <dos/dos.h>
  7. #include <libraries/asl.h>
  8. #include "Structures/AppAsl.h"
  9. #include "Structures/DirNode.h"
  10.  
  11. #include <clib/alib_protos.h>
  12. #include <clib/exec_protos.h>
  13. #include <clib/dos_protos.h>
  14. #include <clib/asl_protos.h>
  15. #include <string.h>
  16. #include "AsmLib/QuickFuncs.h"
  17.  
  18. extern struct Library *AslBase;
  19.  
  20. unsigned long ExamineFileLength(char * name)
  21. {
  22.     /* Ermittelt die Länge der Datei 'name' in Bytes */
  23.  
  24.     long            filelock;
  25.     struct FileInfoBlock   *fib;
  26.     unsigned long         length = 0;
  27.  
  28.     if (filelock = Lock(name, ACCESS_READ)) {
  29.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)) {
  30.             if (Examine(filelock, fib) == DOSTRUE)
  31.                 length = fib->fib_Size;
  32.  
  33.             FreeDosObject(DOS_FIB, (APTR)fib);
  34.         }
  35.         UnLock(filelock);
  36.     }
  37.     return (length);
  38. }
  39.  
  40. unsigned long ExamineDiskSpace(char * name)
  41. {
  42.     /* Ermittelt den Platz des Gerätes, auf dem sich 'name' befindet, in Bytes */
  43.  
  44.     long            filelock;
  45.     struct InfoData           *infodata;
  46.     long            space = 0;
  47.  
  48.     if (filelock = Lock(name, ACCESS_READ)) {
  49.         if (infodata = GetVecA(sizeof(struct InfoData), MEMF_PUBLIC | MEMF_CLEAR)) {
  50.             if (Info(filelock, infodata) == DOSTRUE)
  51.                 space = (long)((double)infodata->id_NumBlocks - infodata->id_NumBlocksUsed) * (double)infodata->id_BytesPerBlock;
  52.  
  53.             FreeVec(infodata);
  54.         }
  55.         UnLock(filelock);
  56.     }
  57.     return(space);
  58. }
  59.  
  60. char *OpenFile(char * name)
  61. {
  62.     /* Öffnet eine Datei und kopiert den Inhalt in einen (char-)Buffer */
  63.  
  64.     long            filehandle;
  65.     struct FileInfoBlock   *fib;
  66.     void               *buffer = NULL;
  67.  
  68.     if (filehandle = Open(name, MODE_OLDFILE)) {
  69.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)) {
  70.             if (ExamineFH(filehandle, fib) == DOSTRUE) {
  71.                 if (fib->fib_Size) {
  72.                     if (buffer = (char *)GetVecA(fib->fib_Size, MEMF_PUBLIC | MEMF_CLEAR)) {
  73.                         if (Read(filehandle, buffer, fib->fib_Size) != fib->fib_Size) {
  74.                             FreeVec(buffer);
  75.                             buffer = NULL;
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.             FreeDosObject(DOS_FIB, (APTR)fib);
  81.         }
  82.         Close(filehandle);
  83.     }
  84.     return ((char *)buffer);
  85. }
  86.  
  87. short SaveFile(char *name, char *buffer, long len)
  88. {
  89.     /* Speichert die Daten in 'buffer' in die Datei 'name' */
  90.  
  91.     long            filehandle;
  92.     short            success = FALSE;
  93.  
  94.     if (filehandle = Open(name, MODE_NEWFILE)) {
  95.         if (Write(filehandle, (void *)buffer, len) == len)
  96.             success = TRUE;
  97.         Close(filehandle);
  98.     }
  99.     return (success);
  100. }
  101.  
  102. struct List *GetDirContents(char *name)
  103. {
  104.     /* Ermittelt den Inhalt eines Verzeichnisses und legt ihn in einer
  105.        DirNode-Liste ab. */
  106.  
  107.     long            filelock;
  108.     struct FileInfoBlock   *fib;
  109.     struct List           *dirlist = NULL;
  110.  
  111.     if (filelock = Lock(name, SHARED_LOCK)) {
  112.         if (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)) {
  113.             if (Examine(filelock, fib) != DOSFALSE) {
  114.                 if (fib->fib_DirEntryType >= 0 && fib->fib_DirEntryType != ST_SOFTLINK)    {
  115.                     if (dirlist = GetVecA(sizeof(struct List), MEMF_PUBLIC | MEMF_CLEAR)) {
  116.                         struct DirNode               *tempnode;
  117.                         NewList(dirlist);
  118.  
  119.                         while (ExNext(filelock, fib) != DOSFALSE) {
  120.                             if (tempnode = GetVecA(sizeof(struct DirNode), MEMF_PUBLIC | MEMF_CLEAR)) {
  121.                                 strncpy(tempnode->dn_Name, fib->fib_FileName, FILENAMELENGTH);
  122.                                 AddTail(dirlist, (struct Node *)tempnode);
  123.                             }
  124.                         }
  125.                     }
  126.                 }
  127.             }
  128.             FreeDosObject(DOS_FIB, (void *)fib);
  129.         }
  130.         UnLock(filelock);
  131.     }
  132.     return (dirlist);
  133. }
  134.  
  135. BOOL GetFileName(struct AppAsl *asl, struct Screen *screen)
  136. {
  137.     /* Die Funktion schreibt den Pfad in eine spezielle ASL-Verwaltungsstruktur und merkt
  138.        sich dort auch alle anderen Requesterdaten (z.B. Position, Größe, etc.  */
  139.  
  140.     BOOL success = FALSE;
  141.  
  142.     if (AslBase)    /* damit die ASL-Lib nicht zwingend erforderlich ist */
  143.     {
  144.         struct FileRequester           *filereq;
  145.         struct TagItem            filetags[] = {
  146.                             ASLFR_TitleText,    (unsigned long)asl->titletext,
  147.                             ASLFR_InitialLeftEdge,    asl->leftedge,
  148.                             ASLFR_InitialTopEdge,    asl->topedge,
  149.                             ASLFR_InitialWidth,    asl->width,
  150.                             ASLFR_InitialHeight,    asl->height,
  151.                             ASLFR_RejectIcons,    asl->noicons,
  152.                             ASLFR_InitialFile,    (unsigned long)asl->filename,
  153.                             ASLFR_InitialDrawer,    (unsigned long)asl->dirname,
  154.                             ASLFR_Screen,         (unsigned long)screen,
  155.                             TAG_DONE
  156.                         };
  157.  
  158.         if (filereq = (struct FileRequester *)AllocAslRequest(ASL_FileRequest, filetags)) {
  159.             if (AslRequest(filereq, NULL)) {
  160.                 /* Kopieren der Werte */
  161.                 asl->leftedge    = filereq->fr_LeftEdge;
  162.                 asl->topedge    = filereq->fr_TopEdge;
  163.                 asl->width    = filereq->fr_Width;
  164.                 asl->height    = filereq->fr_Height;
  165.                 strncpy(asl->filename, filereq->fr_File, FILENAMELENGTH);
  166.                 strncpy(asl->dirname, filereq->fr_Drawer, DISKPATHLENGTH - FILENAMELENGTH);
  167.  
  168.                 /* Erstellen des gesamten Pfades */
  169.                 strncpy(asl->pathname, filereq->fr_Drawer, DISKPATHLENGTH - FILENAMELENGTH);
  170.                 if (AddPart(asl->pathname, filereq->fr_File, DISKPATHLENGTH))
  171.                     success = TRUE;
  172.             }
  173.             FreeAslRequest(filereq);
  174.         }
  175.     }
  176.     return (success);
  177. }