home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / dropbox-1.1.lha / DropBox / src / fileio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-05  |  10.5 KB  |  541 lines
  1. /** DoRev Header ** Do not edit! **
  2. *
  3. * Name             :  fileio.c
  4. * Copyright        :  Copyright 1993 Steve Anichini. All Rights Reserved.
  5. * Creation date    :  12-Jun-93
  6. * Translator       :  SAS/C 5.1b
  7. *
  8. * Date       Rev  Author               Comment
  9. * ---------  ---  -------------------  ----------------------------------------
  10. * 01-Jul-93    4  Steve Anichini       Support for v1 pref file works now. Ugly
  11. * 26-Jun-93    3  Steve Anichini       Added Support for Version 1 of DropBox p
  12. * 26-Jun-93    2  Steve Anichini       Fixed Illegal Address problem in LoadPre
  13. * 21-Jun-93    1  Steve Anichini       First Release.
  14. * 12-Jun-93    0  Steve Anichini       Beta Release 1.0
  15. *
  16. *** DoRev End **/
  17.  
  18. #include "DropBox.h"
  19. #include "window.h"
  20. #include "fileio.h"
  21.  
  22. extern BOOL FirstSave, modified;
  23. extern LONG IconX, IconY;
  24.  
  25. struct Library *AslBase = NULL;
  26. char preffile[DEFLEN]; 
  27. char prefdir[DEFLEN];
  28. char prefpat[DEFLEN];
  29.  
  30. ULONG LoadPrefs(char *pfile)
  31. {
  32.     struct IFFHandle *iff = NULL;
  33.     struct DBNode *nd = NULL;
  34.     struct PatNode *pnd = NULL;
  35.     BPTR goofy;
  36.     struct GenPref gprf;
  37.     register int i;
  38.     UBYTE *buf = NULL, *bob = NULL;
  39.     struct ContextNode *cn = NULL;
  40.     ULONG size = MAX_DENT, patnodes = 0;
  41.     LONG list[] = {ID_DROP,ID_GPRF,ID_DROP,ID_DBSE, ID_DROP, ID_DENT};
  42.     LONG ifer = 0;
  43.         
  44.     if(!(IFFParseBase = OpenLibrary("iffparse.library", DEF_LOWEST_REV)))
  45.         return NO_IFFLIB;
  46.         
  47.     if(!(iff = AllocIFF()))
  48.         return NO_FILE;
  49.         
  50.     if(!(goofy = Open(pfile, MODE_OLDFILE)))
  51.     {
  52.         FreeIFF(iff);
  53.         return NO_FILE;
  54.     }
  55.     
  56.     iff->iff_Stream = goofy;
  57.     InitIFFasDOS(iff);
  58.     if(OpenIFF(iff, IFFF_READ))
  59.     {
  60.         Close(goofy);
  61.         FreeIFF(iff);
  62.         return NO_FILE;
  63.     }
  64.     
  65.     StopChunks(iff, list,3);
  66.     
  67.     ifer = ParseIFF(iff, IFFPARSE_SCAN);
  68.     
  69.     if(ifer)
  70.     {
  71.         CloseIFF(iff);
  72.         Close(goofy);
  73.         FreeIFF(iff);
  74.         return NO_FILE;
  75.     }
  76.     
  77.     if(!(cn = CurrentChunk(iff)))
  78.     {
  79.         CloseIFF(iff);
  80.         Close(goofy);
  81.         FreeIFF(iff);
  82.         return NO_FILE;
  83.     }
  84.  
  85.     ReadChunkBytes(iff, (UBYTE *)&gprf, cn->cn_Size);
  86.             
  87.     CleanDB();
  88.     InitDB();
  89.     
  90.     switch(gprf.gp_Version)
  91.     {
  92.         
  93.         case 0:
  94.             
  95.             MainPrefs = gprf; /* copy general preferences */
  96.             /* Fix up window size */
  97.             MainPrefs.gp_IOLeft = 0;
  98.             MainPrefs.gp_IOTop  = 50;
  99.             MainPrefs.gp_IOWidth = 640;
  100.             MainPrefs.gp_IOHeight = 100;
  101.  
  102.             if(ParseIFF(iff, IFFPARSE_SCAN))
  103.             {
  104.                 CloseIFF(iff);
  105.                 Close(goofy);
  106.                 FreeIFF(iff);
  107.                 return NO_FILE;
  108.             }
  109.  
  110.             if(!(cn = CurrentChunk(iff)))
  111.             {
  112.                 CloseIFF(iff);
  113.                 Close(goofy);
  114.                 FreeIFF(iff);
  115.                 return NO_FILE;
  116.             }
  117.  
  118.             if(!(buf = AllocVec(cn->cn_Size, MEMF_PUBLIC)))
  119.             {
  120.                 CloseIFF(iff);
  121.                 Close(goofy);
  122.                 FreeIFF(iff);
  123.                 return NO_MEMFILE;
  124.             }
  125.  
  126.             bob = buf;
  127.  
  128.             ReadChunkBytes(iff,    buf, cn->cn_Size);
  129.  
  130.             for(i = 0; i < gprf.gp_Nodes ; i++)
  131.             {
  132.                 if(nd = (struct DBNode *) NewNode(NT_DBNODE))
  133.                 {
  134.                     strcpy(nd->db_Name, buf);
  135.                     buf += strlen(nd->db_Name)+1;
  136.                     if((strlen(nd->db_Name)+1)%2)
  137.                         buf++;
  138.  
  139.                     if(!(pnd = (struct PatNode *) NewNode(NT_PATNODE)))
  140.                         return NO_MEMFILE;
  141.                     strcpy(pnd->pat_Str, buf);
  142.                     buf += strlen(pnd->pat_Str)+1;
  143.                     if((strlen(pnd->pat_Str)+1)%2)
  144.                         buf++;
  145.                     pnd->pat_Flags = PFLG_NOFLAG;
  146.                     pnd->pat_Reserved = 0;
  147.                     AddNode((struct Node *)pnd,nd->db_Pats);
  148.  
  149.                     strcpy(nd->db_Dest, buf);
  150.                     buf += strlen(nd->db_Dest)+1;
  151.                     if((strlen(nd->db_Dest)+1)%2)
  152.                         buf++;
  153.                     strcpy(nd->db_Com, buf);
  154.                     buf += strlen(nd->db_Com)+1;
  155.                     if((strlen(nd->db_Com)+1)%2)
  156.                         buf++;
  157.                     strcpy(nd->db_Template, buf);
  158.                     buf += strlen(nd->db_Template)+1;
  159.                     if((strlen(nd->db_Template)+1)%2)
  160.                         buf++;
  161.                     nd->db_Flags = *((ULONG *) buf);
  162.                     buf += sizeof(ULONG);
  163.                     if(nd->db_Flags & DFLG_SUPINPUT)
  164.                         nd->db_Flags |= DFLG_SUPOUTPUT;
  165.                 }
  166.                 else
  167.                     return NO_MEMFILE;
  168.  
  169.                 AddNode((struct Node *)nd, DataBase);
  170.             }
  171.  
  172.             FreeVec(bob);
  173.             break;
  174.  
  175.         case 1:
  176.             MainPrefs = gprf;
  177.  
  178.             ParseIFF(iff, IFFPARSE_SCAN);
  179.  
  180.             cn = CurrentChunk(iff);
  181.  
  182.             if(cn)
  183.             {
  184.                 size = max(cn->cn_Size,MAX_DENT);
  185.  
  186.                 if(!(buf = AllocVec(size, MEMF_PUBLIC)))
  187.                 {
  188.                     CloseIFF(iff);
  189.                     Close(goofy);
  190.                     FreeIFF(iff);
  191.                     return NO_MEMFILE;
  192.                 }
  193.             }
  194.  
  195.             bob = buf;
  196.  
  197.             while(cn)
  198.             {
  199.                 if(cn->cn_Size != ReadChunkBytes(iff, buf, cn->cn_Size))
  200.                 {
  201.                     FreeVec(bob);
  202.                     CloseIFF(iff);
  203.                     Close(goofy);
  204.                     FreeIFF(iff);
  205.                     return NO_FILE;
  206.                 }
  207.  
  208.                 if(nd = (struct DBNode *) NewNode(NT_DBNODE))
  209.                 {
  210.                     strcpy(nd->db_Name, buf);
  211.                     buf += strlen(nd->db_Name)+1;
  212.                     if((strlen(nd->db_Name)+1)%2)
  213.                         buf++;
  214.                     strcpy(nd->db_Dest, buf);
  215.                     buf += strlen(nd->db_Dest)+1;
  216.                     if((strlen(nd->db_Dest)+1)%2)
  217.                         buf++;
  218.                     strcpy(nd->db_Com, buf);
  219.                     buf += strlen(nd->db_Com)+1;
  220.                     if((strlen(nd->db_Com)+1)%2)
  221.                         buf++;
  222.                     strcpy(nd->db_Template, buf);
  223.                     buf += strlen(nd->db_Template)+1;
  224.                     if((strlen(nd->db_Template)+1)%2)
  225.                         buf++;
  226.                     nd->db_Flags = *((ULONG *) buf);
  227.                     buf += sizeof(ULONG);
  228.                     if(nd->db_Flags & DFLG_SUPINPUT)
  229.                         nd->db_Flags |= DFLG_SUPOUTPUT;
  230.  
  231.                     patnodes = *((ULONG *) buf);
  232.                     buf += sizeof(ULONG);
  233.                     for(i = 0; i < patnodes; i++)
  234.                     {
  235.                         if(!(pnd = (struct PatNode *) NewNode(NT_PATNODE)))
  236.                             return NO_MEMFILE;
  237.                         strncpy(pnd->pat_Str, buf,PATLEN);
  238.                         buf += PATLEN;
  239.                         pnd->pat_Flags = *((ULONG *)buf);
  240.                         buf += sizeof(ULONG);
  241.                         pnd->pat_Reserved = *((ULONG *)buf);
  242.                         buf += sizeof(ULONG);
  243.                         AddNode((struct Node *)pnd, nd->db_Pats);
  244.                     }
  245.                 }
  246.                 else
  247.                     return NO_MEMFILE;
  248.  
  249.                 AddNode((struct Node *)nd,DataBase);
  250.  
  251.                 if(ifer = ParseIFF(iff, IFFPARSE_SCAN))
  252.                 {
  253.                     FreeVec(bob);
  254.                     cn = NULL;
  255.                 }
  256.                 else
  257.                 {
  258.                     cn = CurrentChunk(iff);
  259.                     if(cn)
  260.                     {
  261.                         if (cn->cn_Size > size)
  262.                         {
  263.                             FreeVec(bob);
  264.                             size = cn->cn_Size;
  265.                             if(!(buf = AllocVec(size, MEMF_PUBLIC)))
  266.                             {
  267.                                 CloseIFF(iff);
  268.                                 Close(goofy);
  269.                                 FreeIFF(iff);
  270.                                 return NO_MEMFILE;
  271.                             }
  272.                             bob = buf;
  273.                         }
  274.                         else
  275.                             buf = bob;
  276.                     }
  277.                     else
  278.                         FreeVec(bob);
  279.                 }
  280.             }
  281.             break;
  282.     } /* Switch */
  283.  
  284.     CloseIFF(iff);
  285.  
  286.     if(goofy)
  287.         Close(goofy);
  288.  
  289.     FreeIFF(iff);
  290.  
  291.     if(IFFParseBase)
  292.         CloseLibrary(IFFParseBase);
  293.  
  294.     return NO_ERROR;
  295. }
  296.  
  297. ULONG SavePrefs(char *pfile)
  298. {
  299.     struct IFFHandle *iff = NULL;
  300.     struct GenPref gprf;
  301.     struct DBNode *nd = NULL;
  302.     struct PatNode *pnd = NULL;
  303.     BPTR goofy;
  304.     ULONG len, temp;
  305.  
  306.     if(!(IFFParseBase = OpenLibrary("iffparse.library", DEF_LOWEST_REV)))
  307.         return NO_IFFLIB;
  308.     else
  309.     {
  310.  
  311.         iff = AllocIFF();
  312.  
  313.         if(!(goofy = Open(pfile, MODE_NEWFILE)))
  314.         {
  315.             FreeIFF(iff);
  316.             return NO_DIR;
  317.         }
  318.  
  319.         iff->iff_Stream = goofy;
  320.  
  321.         InitIFFasDOS(iff);
  322.         if(OpenIFF(iff, IFFF_WRITE))
  323.         {
  324.             Close(goofy);
  325.             FreeIFF(iff);
  326.             return NO_DIR;
  327.         }
  328.  
  329.         PushChunk(iff, ID_DROP, ID_FORM, IFFSIZE_UNKNOWN);
  330.  
  331.         /* General Prefrences Chunk */
  332.         PushChunk(iff, ID_DROP, ID_GPRF, sizeof(struct GenPref));
  333.  
  334.         gprf = MainPrefs;
  335.         gprf.gp_Nodes = CountNodes(DataBase);
  336.         gprf.gp_Version = GPRF_VERSION;
  337.         gprf.reserved[0] = 0;
  338.         gprf.reserved[1] = 0;
  339.         gprf.reserved[2] = 0;
  340.  
  341.         WriteChunkBytes(iff, (UBYTE *)&gprf, sizeof(struct GenPref));
  342.  
  343.         PopChunk(iff);
  344.  
  345.         /* Database Chunk */
  346.  
  347.         nd = (struct DBNode *) DataBase->lh_Head;
  348.  
  349.         while(nd->db_Nd.ln_Succ)
  350.         {
  351.             PushChunk(iff, ID_DROP, ID_DENT, IFFSIZE_UNKNOWN);
  352.  
  353.             len = strlen(nd->db_Name)+1;
  354.             len += len%2;
  355.             WriteChunkBytes(iff, (UBYTE *) nd->db_Name, len*sizeof(char));
  356.             len = strlen(nd->db_Dest)+1;
  357.             len += len%2;
  358.             WriteChunkBytes(iff, (UBYTE *) nd->db_Dest, len*sizeof(char));
  359.             len = strlen(nd->db_Com)+1;
  360.             len+= len%2;
  361.             WriteChunkBytes(iff, (UBYTE *) nd->db_Com, len*sizeof(char));
  362.             len = strlen(nd->db_Template)+1;
  363.             len += len%2;
  364.             WriteChunkBytes(iff, (UBYTE *) nd->db_Template, len*sizeof(char));
  365.             WriteChunkBytes(iff, (UBYTE *) &(nd->db_Flags), sizeof(ULONG));
  366.             temp = CountNodes(nd->db_Pats);
  367.             WriteChunkBytes(iff, (UBYTE *) &temp, sizeof(ULONG));
  368.  
  369.             pnd = (struct PatNode *) nd->db_Pats->lh_Head;
  370.  
  371.             while(pnd->pat_Nd.ln_Succ)
  372.             {
  373.                 WriteChunkBytes(iff, (UBYTE *) pnd->pat_Str, sizeof(char)*PATLEN+sizeof(ULONG)*2);
  374.  
  375.                 pnd = (struct PatNode *) pnd->pat_Nd.ln_Succ;
  376.             }
  377.  
  378.             nd = (struct DBNode *) nd->db_Nd.ln_Succ;
  379.             PopChunk(iff);
  380.         }
  381.  
  382.         PopChunk(iff);
  383.  
  384.         CloseIFF(iff);
  385.         
  386.         if(goofy)
  387.             Close(goofy);
  388.             
  389.         FreeIFF(iff);
  390.         
  391.         if(IFFParseBase)
  392.             CloseLibrary(IFFParseBase);
  393.             
  394.     }
  395.     
  396.     return NO_ERROR;
  397. }
  398.  
  399. ULONG FileRequest(char *file, char *dir, char *pat, BOOL save, BOOL dirs)
  400. {
  401.     struct FileRequester *req = NULL;
  402.     ULONG oldflags;
  403.     
  404.     if(!(AslBase = OpenLibrary("asl.library", DEF_LOWEST_REV)))
  405.         return NO_ASLLIB;
  406.     
  407.     CleanWindow(DropBoxWnd);
  408.     oldflags = DropBoxWnd->IDCMPFlags;
  409.     ModifyIDCMP(DropBoxWnd, NULL);
  410.         
  411.     if(!(req = (struct FileRequester *) AllocAslRequestTags(ASL_FileRequest,
  412.         ASL_Hail, (ULONG) FILEHAIL, ASL_Window, (ULONG) DropBoxWnd,
  413.         ASL_File, (ULONG) (file?file:""), ASL_Dir, (ULONG) (dir?dir:""),
  414.         ASL_Pattern, (ULONG) (pat?pat:""), ASL_FuncFlags,
  415.         (save?FILF_SAVE:0)|FILF_PATGAD,
  416.         ASL_ExtFlags1, (dirs?FIL1F_NOFILES:0),TAG_DONE)))
  417.     {
  418.         CloseLibrary(AslBase);
  419.         ModifyIDCMP(DropBoxWnd, oldflags);
  420.         return NO_FILEREQ;
  421.     }
  422.  
  423.     if(!AslRequestTags((APTR)req, TAG_DONE)) 
  424.     {
  425.         FreeAslRequest((APTR)req);
  426.         CloseLibrary(AslBase);
  427.         ModifyIDCMP(DropBoxWnd, oldflags);
  428.         return ASLCANCEL;
  429.     }
  430.     
  431.     if(file)
  432.         strcpy(file, (char *)req->rf_File);
  433.     if(dir)
  434.         strcpy(dir, (char *)req->rf_Dir);
  435.     if(pat)
  436.         strcpy(pat, (char *)req->rf_Pat);
  437.     
  438.     FreeAslRequest((APTR) req);
  439.     CloseLibrary(AslBase);
  440.  
  441.     ModifyIDCMP(DropBoxWnd, oldflags);
  442.         
  443.     return NO_ERROR;
  444. }
  445.  
  446. ULONG JustSave()
  447. {
  448.     char temp[DEFLEN];
  449.     
  450.     strcpy(temp, prefdir);
  451.     AddPart(temp, preffile, DEFLEN);
  452.     
  453.     return SavePrefs(temp);
  454. }
  455.  
  456. ULONG JustLoad()
  457. {
  458.     char temp[DEFLEN];
  459.     
  460.     strcpy(temp, prefdir);
  461.     AddPart(temp, preffile, DEFLEN);
  462.     
  463.     return LoadPrefs(temp);
  464. }
  465.  
  466. void PrefIO(BOOL save)
  467. {
  468.     LONG err = 0;
  469.     
  470.     if(err = FileRequest(preffile, prefdir, prefpat, save, FALSE))
  471.     {
  472.         if(err > 0)
  473.             DisplayErr(err);
  474.     }
  475.     else
  476.     {
  477.         if(save)
  478.             err = JustSave();
  479.         else
  480.             err = JustLoad();
  481.             
  482.         if(err)
  483.             DisplayErr(err);
  484.         else
  485.             modified = FALSE;
  486.     }
  487. }
  488.  
  489. void InitIO(char *file, char *dir, char *pat)
  490. {
  491.     if(file)
  492.         strcpy(preffile, file);
  493.     else
  494.         strcpy(preffile, FILEPREF);
  495.         
  496.     if(dir)
  497.         strcpy(prefdir, dir);
  498.     else
  499.         strcpy(prefdir, DIRPREF);
  500.         
  501.     if(pat)
  502.         strcpy(prefpat, pat);
  503.     else
  504.         strcpy(prefpat, PATPREF);
  505. }
  506.     
  507. void GetDest(char *current)
  508. {
  509.     LONG err = 0;
  510.     
  511.     if(err = FileRequest(NULL, current, NULL, FALSE, TRUE))
  512.     {
  513.         if(err > 0)
  514.             DisplayErr(err);
  515.     }
  516. }
  517.  
  518. void GetCom(char *current)
  519. {
  520.     LONG err = 0;
  521.     char dir[DEFLEN], file[DEFLEN];
  522.     char *temp;
  523.     
  524.     strcpy(dir, current);
  525.     strcpy(file, FilePart(current));
  526.     temp = FilePart(dir);
  527.     *temp = '\0';
  528.     
  529.     if(err = FileRequest(file, dir, NULL, FALSE, FALSE))
  530.     {
  531.         if(err > 0)
  532.             DisplayErr(err);
  533.     }
  534.     else
  535.     {
  536.         AddPart(dir, file, DEFLEN);
  537.         strcpy(current, dir);
  538.     }
  539. }
  540.     
  541.