home *** CD-ROM | disk | FTP | other *** search
/ Audio 4.94 - Over 11,000 Files / audio-11000.iso / amiga / midi / med210.lhw / in.adf / Source / med210src.lzh / med-filereq.c < prev    next >
C/C++ Source or Header  |  1990-06-20  |  10KB  |  367 lines
  1. /* MED - music editor ⌐ 1989, 1990 by Teijo Kinnunen */
  2. /* med-filereq.c -- the filerequester... */
  3. #include "med.h"
  4. #include "medproto.h"
  5.  
  6. #define FirstMember(list,memb) { list = memb; memb->next=memb->prev=0L; }
  7. extern struct PropInfo propinfo[];
  8. extern struct Window *window;
  9. extern struct Gadget far gadget2[];
  10. extern char kappaleennimi[];
  11. extern struct RastPort *wrp;
  12. extern struct Screen *screen;
  13. extern struct StringInfo strinfo[];
  14. extern UWORD chip mouse0[],chip mouse1[],nykyinenosio;
  15. struct FData *firstfd = NULL;
  16. static struct FData *filelist = NULL;
  17. static WORD firstdspnum = -1,numfd = 0;
  18. BPTR currdir = NULL;    /* lock of the current requester directory */
  19. static UWORD propstep = 0;
  20. static void __regargs ReadFNames(void);
  21. static void __regargs InsFData(struct FData *,LONG);
  22. static void __regargs InsToList(struct FData **,struct FData *);
  23. static struct FData * __regargs FindFData(WORD);
  24. static void __regargs CalcNewPropSize(void);
  25. static void __regargs ChangeCurrDir(char *);
  26. static void __regargs GetPath(BPTR,char *);
  27.  
  28. void UpdateFReqDsp()
  29. {
  30.     register WORD dspcnt,chrcnt;
  31.     register struct FData *scanptr = firstfd;
  32.     if(!currdir) {
  33.         register UCOUNT linecnt;
  34.         SetAPen(wrp,1);
  35.         SetBPen(wrp,3);
  36.         for(linecnt = 0; linecnt < 5; linecnt++) {
  37.             Move(wrp,8,27 + linecnt * 8);
  38.             if(linecnt == 2) Text(wrp," Choose drive  ",15);
  39.             else Text(wrp,"               ",15);
  40.         }
  41.         return;
  42.     }
  43.     if(firstdspnum == -1 || firstfd == 0) return;
  44.     for(dspcnt = 0; dspcnt < firstdspnum; dspcnt++)
  45.         if(!(scanptr = scanptr->next)) {
  46.             firstdspnum = dspcnt - 4;
  47.             if(firstdspnum < 0) firstdspnum = 0;
  48.             UpdateFReqDsp();
  49.             return;
  50.         }
  51.     for(dspcnt = 0; dspcnt < 5; dspcnt++) {
  52.         char dspbuf[15];
  53.         Move(wrp,8,27 + 8 * dspcnt);
  54.         memcpy(dspbuf,"               ",15);
  55.         if(scanptr) {
  56.             if(scanptr->type > 0) SetAPen(wrp,1);
  57.             else SetAPen(wrp,0);
  58.             for(chrcnt = 0; chrcnt < 15; chrcnt++) {
  59.                 if(scanptr->fname[chrcnt] == '\0') break;
  60.                 dspbuf[chrcnt] = scanptr->fname[chrcnt];
  61.             }
  62.             scanptr = scanptr->next;
  63.         }
  64.         Text(wrp,dspbuf,15);
  65.     }
  66.     SetAPen(wrp,0);
  67. }
  68.  
  69. static void __regargs ReadFNames()
  70. {
  71.     register BPTR pdirtest;
  72.     register struct FData *newptr = 0L;
  73.     register struct FileInfoBlock *fib;
  74.     register UWORD pos;
  75.     FreeFDatas();
  76.     if(!(fib = (struct FileInfoBlock *)AllocMem(sizeof(struct
  77.         FileInfoBlock),MEMF_PUBLIC))) return;
  78.     if(Examine(currdir,fib)) {
  79.         pdirtest = ParentDir(currdir);
  80.         if(pdirtest) {
  81.             UnLock(pdirtest);
  82.             newptr = (struct FData *)AllocMem(sizeof(struct
  83.                 FData),MEMF_PUBLIC);
  84.             if(newptr) {
  85.                 strcpy(newptr->fname,"/ Parent Dir");
  86.                 InsFData(newptr,1);
  87.             }
  88.         }
  89.         if(!pdirtest || (pdirtest && newptr)) { /* OK!! */
  90.             for(;;) {
  91.                 if(!ExNext(currdir,fib)) break;
  92. /* This very difficult "if" */    if(strlen(fib->fib_FileName) >= 5 &&
  93. /* checks if the filename has */    !strcmp(&(fib->fib_FileName[
  94. /* ".info"-suffix. */            strlen(fib->fib_FileName) - 5]),
  95.                     ".info")) continue;
  96.                 newptr = (struct FData *)AllocMem(sizeof(struct
  97.                     FData),MEMF_PUBLIC);
  98.                 if(!newptr) break;
  99.                 strcpy(newptr->fname,fib->fib_FileName);
  100.                 InsFData(newptr,fib->fib_DirEntryType);
  101.             }
  102.         }
  103.     }
  104.     firstdspnum = 0;
  105.     if(filelist) {
  106.         if(firstfd) {
  107.             for(newptr = firstfd; newptr->next; newptr =
  108.                 newptr->next);
  109.             newptr->next = filelist;
  110.             filelist->prev = newptr;
  111.         }
  112.         else firstfd = filelist;
  113.     }
  114.     UpdateFReqDsp();
  115.     pos = RemoveGadget(window,&gadget2[6]);
  116.     propinfo[0].VertPot = 0;
  117.     AddGadget(window,&gadget2[6],pos);
  118.     RefreshGList(&gadget2[6],window,NULL,1);
  119.     FreeMem((void *)fib,sizeof(struct FileInfoBlock));
  120. }
  121.  
  122. static void __regargs InsToList(struct FData **list,struct FData *fd)
  123. {
  124.     register struct FData *scanptr = *list;
  125.     for(;stricmp(scanptr->fname,fd->fname) <= 0 && scanptr->next;
  126.         scanptr = scanptr->next);
  127.     if(!scanptr->next && stricmp(scanptr->fname,fd->fname) < 0) {
  128.             fd->next = NULL;
  129.             scanptr->next = fd;
  130.             fd->prev = scanptr;
  131.             return;
  132.     }
  133.     fd->next = scanptr;
  134.     fd->prev = scanptr->prev;
  135.     if(fd->prev) fd->prev->next = fd;
  136.     else *list = fd;
  137.     scanptr->prev = fd;
  138. }
  139.  
  140. static void __regargs InsFData(struct FData *fdata,LONG type)
  141. {
  142.     fdata->type = type;
  143.     if(type < 0) {
  144.         if(filelist)    InsToList(&filelist,fdata);
  145.         else FirstMember(filelist,fdata);
  146.     }
  147.     else {
  148.         if(firstfd)    InsToList(&firstfd,fdata);
  149.         else FirstMember(firstfd,fdata);
  150.     }
  151.     numfd++;
  152. }
  153.  
  154. void FreeFDatas()
  155. {
  156.     register struct FData *freeptr = firstfd,*fptr2;
  157.     while(freeptr) {
  158.         fptr2 = freeptr->next;
  159.         FreeMem((void *)freeptr,sizeof(struct FData));
  160.         freeptr = fptr2;
  161.     }
  162.     firstfd = filelist = NULL;
  163.     numfd = 0;
  164. }
  165.  
  166. static void __regargs CalcNewPropSize()
  167. {
  168.     register UWORD pos;
  169.     if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[6]);
  170.     propinfo[0].VertPot = 0;
  171.     if(numfd <= 5)    {
  172.         propinfo[0].VertBody = MAXBODY;
  173.         propstep = 0;
  174.     }
  175.     else    {
  176.         propinfo[0].VertBody = (MAXBODY * 5) / numfd;
  177.         propstep = MAXBODY / (numfd - 5) - 1;
  178.     }
  179.     if(nykyinenosio != 2) return;
  180.     AddGadget(window,&gadget2[6],pos);
  181.     RefreshGList(&gadget2[6],window,NULL,1);
  182. }
  183.     
  184. static void __regargs ChangeCurrDir(char *name)
  185. {
  186.     register BPTR newlock,oldcurr;
  187.     register UWORD pos;
  188.     struct FileInfoBlock *fib = AllocMem(sizeof(struct FileInfoBlock),
  189.         MEMF_PUBLIC|MEMF_CLEAR);
  190.     extern char hakemisto[];
  191.     if(!fib) { Ilmoita(nomem); return; }
  192.     if(!strcmp(name,"/ Parent Dir")) newlock = ParentDir(currdir);
  193.     else {
  194.         if(currdir) oldcurr = CurrentDir(currdir);
  195.         newlock = Lock(name,ACCESS_READ);
  196.         if(currdir) CurrentDir(oldcurr);
  197.         if(!newlock) {
  198.             DisplayBeep(screen);
  199.             FreeMem((void *)fib,sizeof(struct FileInfoBlock));
  200.             return;
  201.         }
  202.     }
  203.     if(!Examine(newlock,fib) || fib->fib_DirEntryType < 0) {
  204.         UnLock(newlock);
  205.         FreeMem((void *)fib,sizeof(struct FileInfoBlock));
  206.         DisplayBeep(screen);
  207.         return;
  208.     }
  209.     FreeMem((void *)fib,sizeof(struct FileInfoBlock));
  210.     UnLock(currdir);
  211.     currdir = newlock;
  212.     StartLoad();
  213.     if(nykyinenosio == 2) pos = RemoveGadget(window,&gadget2[8]);
  214.     GetPath(DupLock(newlock),hakemisto);
  215.     strinfo[0].DispPos = strinfo[0].BufferPos = 0;
  216.     if(nykyinenosio == 2) {
  217.         AddGadget(window,&gadget2[8],pos);
  218.         RefreshGList(&gadget2[8],window,NULL,1);
  219.     }
  220.     Ilmoita("Loading directory...");
  221.     ReadFNames();
  222.     Ilmoita(NULL);
  223.     CalcNewPropSize();
  224.     StopLoad();
  225. }
  226.  
  227. static void __regargs GetPath(BPTR lock,char *buff)
  228. {
  229.     register struct FileInfoBlock *fib;
  230.     register BPTR pdirlock;
  231.     *buff = '\0';
  232.     if(!(fib = (struct FileInfoBlock *)AllocMem(sizeof(struct
  233.         FileInfoBlock),MEMF_PUBLIC))) return;
  234.     for(;;) {
  235.         if(!Examine(lock,fib)) break;
  236.         pdirlock = ParentDir(lock);
  237.         strcat(fib->fib_FileName,pdirlock ? "/" : ":");
  238.         if(strlen(buff) + strlen(fib->fib_FileName) < 99)
  239.             strins(buff,fib->fib_FileName);
  240.         if(!pdirlock) break;
  241.         UnLock(lock);
  242.         lock = pdirlock;
  243.     }
  244.     UnLock(lock);
  245.     FreeMem((void *)fib,sizeof(struct FileInfoBlock));
  246.     buff += strlen(buff) - 1;
  247.     if(*buff == '/') *buff = '\0';
  248. }
  249.  
  250. static struct FData * __regargs FindFData(num)
  251. WORD num;
  252. {
  253.     register struct FData *scanptr = firstfd;
  254.     if(num >= numfd) return(NULL);
  255.     for(;num > 0 ;num--) scanptr = scanptr->next;
  256.     return(scanptr);
  257. }
  258.  
  259. void FReqHandler(UWORD gid)
  260. {
  261.     static char *drives[] = { "DF0:","DF1:","DF2:","DH0:","DH1:" };
  262.     register UWORD pos;
  263.     if(gid >= 0x20F && gid <= 0x213) ChangeCurrDir(drives[gid-0x20F]);
  264.     else if(gid >= 0x200 && gid <= 0x204) {
  265.         struct FData *tmpptr = FindFData((WORD)(firstdspnum+(gid-0x200)));
  266.         if(tmpptr) {
  267.             if(tmpptr->type > 0) ChangeCurrDir(tmpptr->fname);
  268.             else {
  269.                 if(strlen(tmpptr->fname) < 49) {
  270.                     pos = RemoveGadget(window,&gadget2[9]);
  271.                     strcpy(kappaleennimi,tmpptr->fname);
  272.                     strinfo[1].DispPos = strinfo[1].BufferPos = 0;
  273.                     AddGadget(window,&gadget2[9],pos);
  274.                     RefreshGList(&gadget2[9],window,NULL,1);
  275.                 }
  276.             }
  277.         }
  278.     }
  279.     else if(gid == 0x205 && firstdspnum > 0) {
  280.         pos = RemoveGadget(window,&gadget2[6]);
  281.         if(propinfo[0].VertPot > propstep)
  282.             propinfo[0].VertPot -= propstep;
  283.         else    propinfo[0].VertPot = 0;
  284.         AddGadget(window,&gadget2[6],pos);
  285.         RefreshGList(&gadget2[6],window,NULL,1);
  286.         gid = 0x206;
  287.     }
  288.     else if(gid == 0x207 && firstdspnum < numfd-5) {
  289.         pos = RemoveGadget(window,&gadget2[6]);
  290.         if(propinfo[0].VertPot < MAXPOT - propstep && firstdspnum <
  291.            numfd - 6) propinfo[0].VertPot += propstep;
  292.         else propinfo[0].VertPot = MAXPOT;
  293.         AddGadget(window,&gadget2[6],pos);
  294.         RefreshGList(&gadget2[6],window,NULL,1);
  295.         gid = 0x206;
  296.     }
  297.     else if(gid == 0x208) ChangeCurrDir(hakemisto);
  298.     if(gid == 0x206) {
  299.         if(propstep) firstdspnum = (propinfo[0].VertPot +ápropstep / 2) / propstep;
  300.         else firstdspnum = 0;
  301.         UpdateFReqDsp();
  302.     }
  303. }
  304.  
  305. void InsertSavedFile(char *name)
  306. {
  307.     struct FData *newentry,*lastdir;
  308.     char *tstptr = name;
  309.     while(*tstptr)  /* Does this file go to this directory ??? */
  310.         if(*tstptr == ':' || *tstptr == '/') return; else tstptr++;
  311.     if(!currdir) return;    /* The directory isn't displayed */
  312.     newentry = (struct FData *)AllocMem(sizeof(struct
  313.         FData),MEMF_PUBLIC|MEMF_CLEAR);
  314.     if(!newentry) { Ilmoita(nomem); return; }
  315.     strcpy(newentry->fname,name);
  316.     InsFData(newentry,-1);
  317.     if(!newentry->prev && !newentry->next) {
  318.         if(!firstfd) firstfd = newentry;
  319.         else {
  320.             for(lastdir = firstfd; lastdir->next; lastdir =
  321.                 lastdir->next);
  322.             lastdir->next = newentry;
  323.             newentry->prev = lastdir;
  324.             filelist = newentry;
  325.         }
  326.     }
  327.     CalcNewPropSize();
  328.     UpdateFReqDsp();
  329. }
  330.  
  331. void RemFilename(char *name)
  332. {
  333.     struct FData *srcp = firstfd;
  334.     while(srcp)
  335.         if(!strcmpi(name,srcp->fname)) {
  336.             if(firstfd == srcp) firstfd = srcp->next;
  337.             if(filelist == srcp) filelist = srcp->next;
  338.             if(srcp->next) srcp->next->prev = srcp->prev;
  339.             if(srcp->prev) srcp->prev->next = srcp->next;
  340.             FreeMem((void *)srcp,sizeof(struct FData));
  341.             numfd--;
  342.             break;
  343.         } else srcp = srcp->next;
  344.     firstdspnum = 0;
  345.     CalcNewPropSize();
  346.     UpdateFReqDsp();
  347. }
  348.  
  349. BPTR Open2(char *name,long mode)
  350. {
  351.     BPTR prevdir,openres;
  352.     if(currdir) prevdir = CurrentDir(currdir);
  353.     openres = Open(name,mode);
  354.     if(currdir) CurrentDir(prevdir);
  355.     return(openres);
  356. }
  357.  
  358. BOOL IsHere(char *name)
  359. {
  360.     BPTR prevdir,lock;
  361.     if(currdir) prevdir = CurrentDir(currdir);
  362.     lock = Lock(name,ACCESS_READ);
  363.     if(currdir) CurrentDir(prevdir);
  364.     if(lock) { UnLock(lock); return(TRUE); }
  365.     return(FALSE);
  366. }
  367.