home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / DOpus4-GPL / Program / main4.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-27  |  12.8 KB  |  512 lines
  1. /*
  2.  
  3. Directory Opus 4
  4. Original GPL release version 4.12
  5. Copyright 1993-2000 Jonathan Potter
  6.  
  7. This program is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU General Public License
  9. as published by the Free Software Foundation; either version 2
  10. of the License, or (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. All users of Directory Opus 4 (including versions distributed
  22. under the GPL) are entitled to upgrade to the latest version of
  23. Directory Opus version 5 at a reduced price. Please see
  24. http://www.gpsoft.com.au for more information.
  25.  
  26. The release of Directory Opus 4 under the GPL in NO WAY affects
  27. the existing commercial status of Directory Opus 5.
  28.  
  29. */
  30.  
  31. #include "DOpus.h"
  32. #include "ppdata.h"
  33.  
  34. void makedir(rexx)
  35. int rexx;
  36. {
  37.     int len,a,success,win,err;
  38.     char dirname[32],new_directory[256];
  39.     struct FileInfoBlock __aligned fileinfo;
  40.     BPTR lock;
  41.  
  42.     win=data_active_window;
  43.     dirname[0]=new_directory[0]=0;
  44.     if (config->iconflags&ICONFLAG_MAKEDIRICON) len=25;
  45.     else len=30;
  46.  
  47.     FOREVER {
  48.         if (rexx) {
  49.             for (a=0;a<256;a++) {
  50.                 if (!rexx_args[0][a] || rexx_args[0][a]=='/' || rexx_args[0][a]==':') break;
  51.             }
  52.             if (!rexx_args[0][a]) {
  53.                 if (!(isvalidwindow(data_active_window))) return;
  54.                 strcpy(new_directory,str_pathbuffer[data_active_window]);
  55.                 TackOn(new_directory,rexx_args[0],256);
  56.             }
  57.             else {
  58.                 strcpy(new_directory,rexx_args[0]);
  59.                 win=-1;
  60.             }
  61.         }
  62.         else if (status_iconified) {
  63.             if (!(status_flags&STATUS_ISINBUTTONS) ||
  64.                 (!(getdummypath(new_directory,STR_ENTER_DIRECTORY_NAME)))) return;
  65.             win=-1;
  66.         }
  67.         else {
  68.             if (!(isvalidwindow(data_active_window))) return;
  69.             strcpy(new_directory,str_pathbuffer[data_active_window]);
  70.  
  71.             if (!(whatsit(globstring[STR_ENTER_DIRECTORY_NAME],len,dirname,NULL)) ||
  72.                 !dirname[0]) {
  73.                 myabort();
  74.                 return;
  75.             }
  76.             for (a=0;dirname[a];a++) {
  77.                 if (dirname[a]=='/' || dirname[a]==':') {
  78.                     dirname[a]=0;
  79.                     break;
  80.                 }
  81.             }
  82.             if (!dirname[0]) {
  83.                 myabort();
  84.                 return;
  85.             }
  86.             TackOn(new_directory,dirname,256);
  87.         }
  88.  
  89.         if (!(lock=CreateDir(new_directory))) {
  90.             doerror((err=IoErr()));
  91.             if (rexx || (a=checkerror(globstring[STR_CREATING_DIRECTORY],
  92.                 BaseName(new_directory),-err))==3) {
  93.                 myabort();
  94.                 return;
  95.             }
  96.             continue;
  97.         }
  98.  
  99.         Examine(lock,&fileinfo);
  100.         UnLock(lock);
  101.  
  102.         if (win>-1) {
  103.             addfile(dopus_curwin[win],win,fileinfo.fib_FileName,-1,
  104.                 fileinfo.fib_DirEntryType,&fileinfo.fib_Date,
  105.                 NULL,fileinfo.fib_Protection,0,TRUE,NULL,NULL,
  106.                 fileinfo.fib_OwnerUID,fileinfo.fib_OwnerGID);
  107.             seename(win);
  108.             update_buffer_stamp(win,1);
  109.         }
  110.  
  111.         success=1;
  112.         if (config->iconflags&ICONFLAG_MAKEDIRICON) {
  113.             strcat(new_directory,".info");
  114.             if ((iconwrite(ICONTYPE_DRAWER,new_directory))==1 &&
  115.                 (lockandexamine(new_directory,&fileinfo))) {
  116.                 if (win>-1) {
  117.                     addfile(dopus_curwin[win],win,fileinfo.fib_FileName,
  118.                         fileinfo.fib_Size,fileinfo.fib_DirEntryType,&fileinfo.fib_Date,
  119.                         fileinfo.fib_Comment,fileinfo.fib_Protection,0,TRUE,NULL,NULL,
  120.                         fileinfo.fib_OwnerUID,fileinfo.fib_OwnerGID);
  121.                     seename(win);
  122.                     update_buffer_stamp(win,1);
  123.                 }
  124.             }
  125.             else success=0;
  126.         }
  127.         break;
  128.     }
  129.     if (success) dostatustext(globstring[STR_DIRECTORY_CREATED]);
  130. }
  131.  
  132. void blackout(screen,backupmap)
  133. struct Screen *screen;
  134. ULONG *backupmap;
  135. {
  136.     get_palette(screen,backupmap);
  137.     LoadRGB4(&screen->ViewPort,nullpalette,1<<screen->RastPort.BitMap->Depth);
  138. }
  139.  
  140. iconwrite(type,name)
  141. int type;
  142. char *name;
  143. {
  144.     int suc,err;
  145.     struct DiskObject *diskobj;
  146.     char namebuf[256],*ptr,*originalicon,sourcebuf[256];
  147.     struct dopusfiletype *ftype;
  148.  
  149.     if (!IconBase) return(0);
  150.  
  151.     strcpy(namebuf,name);
  152.     if ((ptr=strstri(namebuf,".info"))) *ptr=0;
  153.  
  154.     if (type==ICONTYPE_DRAWER) originalicon=config->drawericon;
  155.     else if (type==ICONTYPE_TRASH) originalicon=NULL;
  156.     else {
  157.         ftype=checkfiletype(namebuf,-2,0);
  158.         if (ftype && ftype->iconpath) originalicon=ftype->iconpath;
  159.         else if (type==ICONTYPE_TOOL) originalicon=config->toolicon;
  160.         else originalicon=config->projecticon;
  161.     }
  162.  
  163.     if (originalicon) {
  164.         strcpy(sourcebuf,originalicon);
  165.         if (!(strstri(sourcebuf,".info"))) strcat(sourcebuf,".info");
  166.     }
  167.  
  168.     FOREVER {
  169.         if (originalicon && originalicon[0] && (CheckExist(sourcebuf,NULL)<0)) {
  170.             if ((copyicon(originalicon,namebuf,&err))>0) return(1);
  171.         }
  172.         else {
  173.             if (system_version2 && (diskobj=GetDefDiskObject(type+2))) {
  174.                 if (diskobj->do_Type==WBPROJECT && config->defaulttool[0]) {
  175.                     ptr=diskobj->do_DefaultTool;
  176.                     diskobj->do_DefaultTool=config->defaulttool;
  177.                 }
  178.                 else ptr=NULL;
  179.                 suc=PutDiskObject(namebuf,diskobj);
  180.                 if (ptr) diskobj->do_DefaultTool=ptr;
  181.                 FreeDiskObject(diskobj);
  182.                 if (suc) return(1);
  183.                 err=IoErr();
  184.             }
  185.             else {
  186.                 if (type==ICONTYPE_PROJECT)
  187.                     icontable[ICONTYPE_PROJECT]->do_DefaultTool=config->defaulttool;
  188.                 if (PutDiskObject(namebuf,icontable[type])) return(1);
  189.                 err=IoErr();
  190.             }
  191.         }
  192.         if ((suc=checkerror(globstring[STR_ADDING_ICON],BaseName(namebuf),err))==3)
  193.             return(-1);
  194.         if (suc==0 || suc==2) return(0);
  195.     }
  196. }
  197.  
  198. copyicon(srce,dest,err)
  199. char *srce,*dest;
  200. int *err;
  201. {
  202.     int suc;
  203.     struct DiskObject *diskobj;
  204.     char buf[256],buf1[256],*ptr;
  205.  
  206.     strcpy(buf1,srce);
  207.     if ((ptr=strstri(buf1,".info"))) *ptr=0;
  208.  
  209.     if (diskobj=GetDiskObject(buf1)) {
  210.         suc=PutDiskObject(dest,diskobj);
  211.         FreeDiskObject(diskobj);
  212.         if (!suc || CheckExist(dest,NULL)>=0) *err=IoErr();
  213.     }
  214.     else {
  215.         StrCombine(buf,dest,".info",256);
  216.         suc=copyfile(srce,buf,err,-1,NULL,0);
  217.     }
  218.     return(suc);
  219. }
  220.  
  221. char *isicon(name)
  222. char *name;
  223. {
  224.     int a;
  225.  
  226.     if ((a=strlen(name))<6) return(NULL);
  227.     if (LStrCmpI(&name[a-5],".info")==0) return(&name[a-5]);
  228.     return(NULL);
  229. }
  230.  
  231. char *getarexxpath(rexx,win,num,argnum)
  232. int rexx,win,num,argnum;
  233. {
  234.     int a,b;
  235.     char *ptr;
  236.     struct FileInfoBlock __aligned fblock;
  237.     APTR save;
  238.  
  239.     if (!rexx || !rexx_argcount) return(str_pathbuffer[win]);
  240.     if ((strchr(rexx_args[argnum],':') || strchr(rexx_args[argnum],'/')) &&
  241.         (a=CheckExist(rexx_args[argnum],&b))) {
  242.         if (!num) {
  243.             save=main_proc->pr_WindowPtr;
  244.             main_proc->pr_WindowPtr=(APTR)-1;
  245.             dos_global_entry.subtype=0;
  246.             if (lockandexamine(rexx_args[argnum],&fblock)) {
  247.                 dos_global_entry.protection=fblock.fib_Protection;
  248.                 dos_global_entry.comment=dos_copy_comment;
  249.                 strcpy(dos_copy_comment,fblock.fib_Comment);
  250.                 dos_global_entry.dispstr=NULL;
  251.                 getprot(dos_global_entry.protection,dos_global_entry.protbuf);
  252.                 CopyMem(&fblock.fib_Date,&dos_global_entry.date,sizeof(struct DateStamp));
  253.                 seedate(&dos_global_entry.date,dos_global_entry.datebuf,1);
  254.                 dos_global_entry.selected=0;
  255.             }
  256.             main_proc->pr_WindowPtr=save;
  257.             ptr=BaseName(rexx_args[argnum]);
  258.             strcpy(dos_global_entry.name,ptr);
  259.             if (ptr>rexx_args[argnum]) {
  260.                 *ptr=0;
  261.                 strcpy(rexx_pathbuffer[win],rexx_args[argnum]);
  262.                 TackOn(rexx_pathbuffer[win],NULL,256);
  263.             }
  264.             else rexx_pathbuffer[win][argnum]=0;
  265.             dos_global_entry.last=dos_global_entry.next=NULL;
  266.             dos_global_entry.type=a;
  267.             dos_global_entry.size=b;
  268.             func_single_entry=&dos_global_entry;
  269.             removeargstring(argnum);
  270.             return(rexx_pathbuffer[win]);
  271.         }
  272.         else {
  273.             strcpy(rexx_pathbuffer[win],rexx_args[argnum]);
  274.             TackOn(rexx_pathbuffer[win],NULL,256);
  275.             removeargstring(argnum);
  276.             return(rexx_pathbuffer[win]);
  277.         }
  278.     }
  279.     return(str_pathbuffer[win]);
  280. }
  281.  
  282. readfile(name,buf,size)
  283. char *name,**buf;
  284. int *size;
  285. {
  286.     int in,loadpp=0;
  287.  
  288.     if (PPBase) {
  289.         if ((in=ppLoadData(name,DECR_POINTER,MEMF_CLEAR,buf,size,NULL))) {
  290.             if (in==-1 || in==-2) return(-1);
  291.             if (in==-3) return(-2);
  292.         }
  293.         else loadpp=1;
  294.     }
  295.     if (!loadpp) {
  296.         if (CheckExist(name,size)>=0 || !(in=Open(name,MODE_OLDFILE))) return(-1);
  297.         if (!(*buf=AllocMem(*size,MEMF_CLEAR))) {
  298.             Close(in);
  299.             return(-2);
  300.         }
  301.         Read(in,*buf,*size);
  302.         Close(in);
  303.     }
  304.     return(0);
  305. }
  306.  
  307. getnewprot(old,new,mask)
  308. int old,new,mask;
  309. {
  310.     int val,a;
  311.  
  312.     if (!mask) return(new);
  313.     val=old&(~255);
  314.     for (a=0;a<8;a++) {
  315.         if (mask&(1<<a)) {
  316.             if (old&(1<<a)) val|=(1<<a);
  317.         }
  318.         else if (new&(1<<a)) val|=(1<<a);
  319.     }
  320.     return(val);
  321. }
  322.  
  323. dateformat(flag)
  324. int flag;
  325. {
  326.     int a;
  327.  
  328.     for (a=0;a<4;a++) {
  329.         if (flag&(1<<a)) return(a);
  330.     }
  331.     return(a);
  332. }
  333.  
  334. void dosound(type)
  335. int type;
  336. {
  337.     struct IOAudio audio;
  338.     static UBYTE achannels[8]={3,5,10,12,1,2,4,8};
  339.     int a;
  340.  
  341.     if (type==0 && system_version2>=OSVER_38) DisplayBeep(NULL);
  342.     else {
  343.         audio.ioa_Request.io_Message.mn_ReplyPort=general_port;
  344.         audio.ioa_Request.io_Message.mn_Node.ln_Pri=90;
  345.         audio.ioa_Data=achannels;
  346.         audio.ioa_Length=sizeof(achannels);
  347.         if (!(a=OpenDevice("audio.device",0,(struct IORequest *)&audio,0))) {
  348.             audio.ioa_Request.io_Command=CMD_WRITE;
  349.             audio.ioa_Request.io_Flags=ADIOF_PERVOL;
  350.             audio.ioa_Volume=64;
  351.             audio.ioa_Data=(UBYTE *)beepwave;
  352.             audio.ioa_Length=8;
  353.             switch (type) {
  354.                 case 0:
  355.                     audio.ioa_Period=500;
  356.                     audio.ioa_Cycles=100;
  357.                     BeginIO((struct IORequest *)&audio);
  358.                     WaitIO((struct IORequest *)&audio);
  359.                     break;
  360.                 case 1:
  361.                     audio.ioa_Cycles=60;
  362.                     for (a=0;a<5;a++) {
  363.                         audio.ioa_Period=800;
  364.                         BeginIO((struct IORequest *)&audio);
  365.                         WaitIO((struct IORequest *)&audio);
  366.                         audio.ioa_Period=1200;
  367.                         BeginIO((struct IORequest *)&audio);
  368.                         WaitIO((struct IORequest *)&audio);
  369.                     }
  370.                     audio.ioa_Period=800;
  371.                     BeginIO((struct IORequest *)&audio);
  372.                     WaitIO((struct IORequest *)&audio);
  373.                     break;
  374.             }
  375.             CloseDevice((struct IORequest *)&audio);
  376.         }
  377.     }
  378. }
  379.  
  380. checkscreenmode(mode)
  381. int mode;
  382. {
  383.     DisplayInfoHandle *handle;
  384.     struct DimensionInfo *dimension;
  385.     char buf[256];
  386.     int flags,minw,defw;
  387.  
  388.     if (mode==MODE_WORKBENCHUSE || mode==MODE_WORKBENCHCLONE || mode==MODE_PUBLICSCREEN)
  389.         return(mode);
  390.     if (!system_version2) {
  391.         if (mode==HIRES_KEY || mode==HIRESLACE_KEY) return(mode);
  392.         return(MODE_WORKBENCHCLONE);
  393.     }
  394.     if (!(handle=FindDisplayInfo(mode)) ||
  395.         !(GetDisplayInfoData(handle,buf,256,DTAG_DISP,0)) ||
  396.         ((struct DisplayInfo *)buf)->NotAvailable)
  397.         return(MODE_WORKBENCHCLONE);
  398.     flags=((struct DisplayInfo *)buf)->PropertyFlags;
  399.     if (flags&DIPF_IS_DUALPF || flags&DIPF_IS_PF2PRI || flags&DIPF_IS_HAM ||
  400.         !(GetDisplayInfoData(handle,buf,256,DTAG_DIMS,0)))
  401.         return(MODE_WORKBENCHCLONE);
  402.     dimension=(struct DimensionInfo *)buf;
  403.     if (mode&HIRES_KEY || mode&HIRESLACE_KEY) minw=640;
  404.     else {
  405.         minw=dimension->MinRasterWidth;
  406.         if (minw<160) minw*=10;
  407.     }
  408.     defw=(dimension->TxtOScan.MaxX-dimension->TxtOScan.MinX)+1;
  409.     if (minw<640 || defw<640 && dimension->MaxDepth>=5)
  410.         return(MODE_WORKBENCHCLONE);
  411.     return(mode);
  412. }
  413.  
  414. void doarrowgadgets(gad,dir)
  415. struct Gadget *gad;
  416. int dir;
  417. {
  418.     int a;
  419.  
  420.     for (a=0;a<2;a++) {
  421.         if (!gad) break;
  422.         do3dbox(main_rp,
  423.             gad->LeftEdge+2,
  424.             gad->TopEdge+1,
  425.             gad->Width-4,
  426.             gad->Height-2);
  427.         DoArrow(main_rp,
  428.             gad->LeftEdge+2,
  429.             gad->TopEdge+1,
  430.             gad->Width-4,
  431.             gad->Height-2,
  432.             screen_pens[config->arrowfg].pen,
  433.             screen_pens[config->arrowbg].pen,dir);
  434.         gad=gad->NextGadget;
  435.     }
  436. }
  437.  
  438. void makermbgad(rmbgad,gad,high)
  439. struct RMBGadget *rmbgad;
  440. struct Gadget *gad;
  441. int high;
  442. {
  443.     rmbgad->x=gad->LeftEdge;
  444.     rmbgad->y=gad->TopEdge;
  445.     rmbgad->w=gad->Width;
  446.     rmbgad->h=gad->Height;
  447.     if (high && gad->GadgetRender) {
  448.         rmbgad->flags|=RGF_ALTBORD;
  449.         rmbgad->high_bord[0]=gad->GadgetRender;
  450.         rmbgad->high_bord[1]=gad->SelectRender;
  451.     }
  452.     else rmbgad->flags&=~RGF_ALTBORD;
  453. }
  454.  
  455. void dolittlegads(gad,txt,num)
  456. struct Gadget *gad;
  457. char *txt;
  458. int num;
  459. {
  460.     int a,y;
  461.     struct TextFont *font;
  462.  
  463.     if (status_iconified || !Window) return;
  464.  
  465.     font=main_rp->Font;
  466.     SetFont(main_rp,scr_font[FONT_GENERAL]);
  467.     for (a=0;a<num;a++) {
  468.         do3dbox(main_rp,gad->LeftEdge+2,gad->TopEdge+1,gad->Width-4,gad->Height-2);
  469.         SetAPen(main_rp,screen_pens[config->littlegadbg].pen);
  470.         rectfill(main_rp,gad->LeftEdge+2,gad->TopEdge+1,gad->Width-4,gad->Height-2);
  471.         SetAPen(main_rp,screen_pens[config->littlegadfg].pen);
  472.         SetBPen(main_rp,screen_pens[config->littlegadbg].pen);
  473.         y=gad->TopEdge+1+(((gad->Height-2)-scr_font[FONT_GENERAL]->tf_YSize)/2);
  474.         if (y<gad->TopEdge+1) y=gad->TopEdge+1;
  475.         y+=scr_font[FONT_GENERAL]->tf_Baseline;
  476.         Move(main_rp,gad->LeftEdge+((gad->Width-scr_font[FONT_GENERAL]->tf_XSize)/2),y);
  477.         Text(main_rp,&txt[a],1);
  478.         RefreshGList(gad,Window,NULL,1);
  479.         if (!(gad=gad->NextGadget)) break;
  480.     }
  481.     SetFont(main_rp,font);
  482. }
  483.  
  484. void rectfill(r,x,y,w,h)
  485. struct RastPort *r;
  486. int x,y,w,h;
  487. {
  488.     if (w<0 || h<0) return;
  489.     RectFill(r,x,y,x+w-1,y+h-1);
  490. }
  491.  
  492. isinwindow(x,y)
  493. int x,y;
  494. {
  495.     int win;
  496.  
  497.     for (win=0;win<2;win++) {
  498.         if (x>=scrdata_dirwin_xpos[win] && x<scrdata_dirwin_xpos[win]+scrdata_dirwin_width[win] &&
  499.             y>=scrdata_dirwin_ypos[win] && y<scrdata_dirwin_height+scrdata_dirwin_ypos[win]) return(win);
  500.     }
  501.     return(-1);
  502. }
  503.  
  504. isvalidwindow(win)
  505. int win;
  506. {
  507.     if (!str_pathbuffer[win]) return(0);
  508.     if (dopus_curwin[win]->total>0 && dopus_curwin[win]->firstentry->type==ENTRY_CUSTOM)
  509.         return(0);
  510.     return(1);
  511. }
  512.