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