home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / DOpus4-GPL / Config / main3.c < prev    next >
C/C++ Source or Header  |  2000-01-27  |  37KB  |  1,334 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 "config.h"
  32.  
  33. #define NUM_TYPES 5
  34.  
  35. editfunction(func,type,data)
  36. struct dopusfunction *func;
  37. int type;
  38. APTR data;
  39. {
  40.     int a,selitem,x,y,b,ofp,obp,curtype=0,tof,waitbits;
  41.     ULONG class;
  42.     USHORT code,qual,gadgetid;
  43.     struct Gadget *gad;
  44.     char
  45.         flagsel[NUMFLAGS],*funclist[MAXFUNCS+1],functype[MAXFUNCS],
  46.         *displist[MAXFUNCS+1],buf[256],buf1[256],*ptr,t;
  47.     struct DOpusRemember *key=NULL;
  48.     struct DOpusListView *view;
  49.     struct fileclass fclass;
  50.     struct dopusfiletype *ftype;
  51.     struct dopushotkey *hotkey;
  52.  
  53.     if (type==CFG_FILETYPE) ftype=(struct dopusfiletype *)data;
  54.     else if (type==CFG_HOTKEYS) hotkey=(struct dopushotkey *)data;
  55.  
  56.     add_appobject(1);
  57.  
  58.     for (a=0;a<NUMFLAGS;a++) {
  59.         if (type!=CFG_HOTKEYS ||
  60.             gadflagvals[a]==FF_OUTPUTWIN ||
  61.             gadflagvals[a]==FF_NOQUOTE ||
  62.             gadflagvals[a]==FF_SHELLSTARTUP ||
  63.             gadflagvals[a]==FF_DOPUSSTARTUP) flagsel[a]=0;
  64.         else flagsel[a]=LVARRAY_DISABLED;
  65.     }
  66.  
  67.     selitem=-1;
  68.     displist[0]=LAllocRemember(&key,60*(MAXFUNCS+1),MEMF_CLEAR);
  69.     for (a=1;a<=MAXFUNCS;a++) {
  70.         if (displist[0]) displist[a]=displist[a-1]+60;
  71.         else displist[a]=NULL;
  72.     }
  73.     ofp=func->fpen; obp=func->bpen;
  74.     editfuncgadgets[1].Flags&=~SELECTED;
  75.     edit_actionbuf[0]=0;
  76.     makehelpname(cfg_string[STR_EDIT]);
  77.  
  78.     AddGadgetBorders(&key,
  79.         &editfuncgadgets[2],
  80.         4,
  81.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  82.     AddGadgetBorders(&key,
  83.         &editfuncgadgets[9],
  84.         1,
  85.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  86.     AddGadgetBorders(&key,
  87.         &editfuncgadgets[10],
  88.         3,
  89.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  90.     AddGadgetBorders(&key,
  91.         &editfuncgadgets[14],
  92.         1,
  93.         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  94.  
  95. startedit:
  96.     edit_funcbuf[0]=0;
  97.     SetAPen(rp,screen_pens[1].pen);
  98.     ClearMenuStrip(Window);
  99.     FSSetMenuStrip(Window,&editmenu);
  100.     editlists[1].next=NULL;
  101.     if (type==CFG_HOTKEYS) {
  102.         namesinfo.MaxChars=40;
  103.         strcpy(edit_namebuf,hotkey->name);
  104.         editfuncgadgets[1].NextGadget=&editfuncgadgets[2];
  105.         editfuncgadgets[12].NextGadget=NULL;
  106.         editfuncgadgets[0].LeftEdge=x_off+132;
  107.         editfuncgadgets[0].TopEdge=y_off+22;
  108.         editfuncgadgets[0].Width=320;
  109.         AddGadgets(Window,
  110.             editfuncgadgets,
  111.             editfuncgads2,
  112.             13,
  113.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
  114.     }
  115.     else if (type==CFG_GADGET || type==CFG_MENU) {
  116.         namesinfo.MaxChars=64;
  117.         if (((struct newdopusfunction *)func)->name)
  118.             strcpy(edit_namebuf,((struct newdopusfunction *)func)->name);
  119.         else edit_namebuf[0]=0;
  120.         editfuncgadgets[1].NextGadget=&editfuncgadgets[2];
  121.         editfuncgadgets[12].NextGadget=NULL;
  122.         editfuncgadgets[0].LeftEdge=x_off+188;
  123.         editfuncgadgets[0].TopEdge=y_off+42;
  124.         editfuncgadgets[0].Width=292;
  125.         AddGadgets(Window,
  126.             editfuncgadgets,
  127.             editfuncgads2,
  128.             13,
  129.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
  130.     }
  131.     else if (type==CFG_FILETYPE) {
  132.         curtype=fixfunctypelist(ftype);
  133.         editfuncgadgets[12].NextGadget=&editfuncgadgets[13];
  134.         if (curtype==-1) curtype=0;
  135.         editlists[1].next=&editlists[2];
  136.         editlists[2].topitem=curtype;
  137.         editlists[2].itemselected=curtype;
  138.         AddGadgets(Window,
  139.             &editfuncgadgets[2],
  140.             &editfuncgads2[2],
  141.             13,
  142.             screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
  143.     }
  144.     setupeditdisplay(func,type,data,curtype,displist,funclist,functype,flagsel,1);
  145.     doglassimage(&editfuncgadgets[10]);
  146.     if (type==CFG_GADGET || type==CFG_MENU) {
  147.         setupcolourbox(rp,x_off+150,y_off+15,func->fpen,func->bpen);
  148.         SetAPen(rp,screen_pens[1].pen);
  149.         do_gad_label(cfg_string[STR_SHORTCUT_KEY],x_off+121,y_off+62);
  150.         showfuncob(rp,edit_namebuf,func->fpen,func->bpen,type,x_off+244,y_off+5);
  151.         showkey(func->key,func->qual,x_off+130,y_off+55,374,10);
  152.     }
  153.     else if (type==CFG_HOTKEYS) {
  154.         SetAPen(rp,screen_pens[1].pen);
  155.         do_gad_label(cfg_string[STR_HOTKEY_USCORE],x_off+121,y_off+62);
  156.         showkey(hotkey->code,hotkey->qualifier,x_off+130,y_off+55,374,10);
  157.     }
  158.     if (type!=CFG_FILETYPE)
  159.         fixrmbimage(&sampleclearrmb,&editfuncgadgets[1],2,-1,-1);
  160.  
  161.     editgadsoff();
  162.  
  163.     waitbits=1<<Window->UserPort->mp_SigBit;
  164.     if (appobject) waitbits|=1<<appport->mp_SigBit;
  165.  
  166.     FOREVER {
  167.         if (appobject) {
  168.             tof=0;
  169.             while (appmsg=(struct AppMessage *)GetMsg(appport)) {
  170.                 ActivateWindow(Window);
  171.                 if (appmsg->am_ID==MY_APPOBJECT && appmsg->am_NumArgs>0) {
  172.                     for (a=0;a<appmsg->am_NumArgs;a++) {
  173.                         if ((*appmsg->am_ArgList[a].wa_Name)) {
  174.                             if (selitem>-1) {
  175.                                 freestring(funclist[selitem]); funclist[selitem]=NULL;
  176.                                 if (edit_funcbuf[0]) makenewentry(funclist,functype,displist,selitem);
  177.                                 else if (selitem<editlists[0].count)
  178.                                     deleteentry(funclist,functype,displist,selitem);
  179.                                 endedit(); selitem=-1;
  180.                             }
  181.                             if (editlists[0].count<MAXFUNCS) {
  182.                                 selitem=editlists[0].count;
  183.                                 editgadson(0);
  184.                                 functype[selitem]=2;
  185.                                 PathName(appmsg->am_ArgList[a].wa_Lock,edit_funcbuf,256);
  186.                                 TackOn(edit_funcbuf,appmsg->am_ArgList[a].wa_Name,256);
  187.                                 editlists[0].itemselected=-1;
  188.                                 setupforedit(functype[selitem],(a==(appmsg->am_NumArgs-1)));
  189.                                 tof=1;
  190.                             }
  191.                             else DisplayBeep(NULL);
  192.                         }
  193.                     }
  194.                 }
  195.                 ReplyMsg((struct Message *)appmsg);
  196.             }
  197.             if (tof && Screen) ScreenToFront(Screen);
  198.         }
  199.         while (IMsg=getintuimsg()) {
  200.             if ((view=ListViewIDCMP(editlists,IMsg))==(struct DOpusListView *)-1) {
  201.                 class=IMsg->Class; code=IMsg->Code; qual=IMsg->Qualifier;
  202.                 x=IMsg->MouseX; y=IMsg->MouseY;
  203.                 if (class==GADGETUP || class==GADGETDOWN) {
  204.                     gad=(struct Gadget *)IMsg->IAddress;
  205.                     gadgetid=gad->GadgetID;
  206.                 }
  207.                 ReplyMsg((struct Message *)IMsg);
  208.                 switch (class) {
  209.                     case IDCMP_MENUPICK:
  210.                         if (code==MENUNULL) break;
  211.                         switch (ITEMNUM(code)) {
  212.                             case 0:
  213.                             case 1:
  214.                                 if (type==CFG_FILETYPE) {
  215.                                     LStrnCpy(edit_namebuf,ftype->type,22);
  216.                                     edit_namebuf[22]=0;
  217.                                     lsprintf(buf," (%ld)",curtype+1);
  218.                                     StrConcat(edit_namebuf,buf,28);
  219.                                 }
  220.                                 copytoclip(func,funclist,functype,flagsel);
  221.                                 if (ITEMNUM(code)==1) break;
  222.                             case 2:
  223.                                 if (ITEMNUM(code)==2 && !(pasteclip(func,funclist,functype,displist,flagsel)))
  224.                                     break;
  225.                             case 4:
  226.                                 if (ITEMNUM(code)!=2)
  227.                                     erasefunction(func,funclist,displist,flagsel);
  228.                                 if (type==CFG_GADGET || type==CFG_MENU) {
  229.                                     edit_namebuf[255]=0;
  230.                                     showfuncob(rp,edit_namebuf,func->fpen,func->bpen,type,x_off+244,y_off+5);
  231.                                     showkey(func->key,func->qual,x_off+130,y_off+55,374,10);
  232.                                     setupcolourbox(rp,x_off+150,y_off+15,func->fpen,func->bpen);
  233.                                     RefreshStrGad(&editfuncgadgets[0],Window);
  234.                                 }
  235.                                 else if (type==CFG_HOTKEYS) {
  236.                                     edit_namebuf[39]=0;
  237.                                     showkey(hotkey->code,hotkey->qualifier,x_off+130,y_off+55,374,10);
  238.                                     RefreshStrGad(&editfuncgadgets[0],Window);
  239.                                 }
  240.                                 RefreshListView(editlists,3);
  241.                                 RefreshGList(&editfuncgadgets[6],Window,NULL,3);
  242.                                 break;
  243.                             case 6:
  244.                                 if (request(cfg_string[STR_REALLY_CLEAR_CLIPS])) {
  245.                                     LFreeRemember(&clipkey);
  246.                                     firstclip=NULL;
  247.                                     DeleteFile("t:configopus.clip");
  248.                                 }
  249.                                 break;
  250.                         }
  251.                         break;
  252.  
  253.                     case IDCMP_RAWKEY:
  254.                         if ((code>=0x60 && code<=0x67) || code&0x80) break;
  255.                         if ((type!=CFG_GADGET && type!=CFG_MENU && type!=CFG_HOTKEYS) ||
  256.                             !(editfuncgadgets[1].Flags&SELECTED)) {
  257.                             buf[0]=0;
  258.                             RawkeyToStr(code,qual,NULL,buf,10);
  259.                             switch (LToUpper(buf[0])) {
  260.                                 case 'N':
  261.                                     if (type==CFG_GADGET || type==CFG_MENU || type==CFG_HOTKEYS)
  262.                                         ActivateStrGad(&editfuncgadgets[0],Window);
  263.                                     break;
  264.                                 case 'H':
  265.                                     if (type!=CFG_HOTKEYS) break;
  266.                                 case 'K':
  267.                                     if (type==CFG_GADGET || type==CFG_MENU || type==CFG_HOTKEYS) {
  268.                                         fixrmbimage(&sampleclearrmb,NULL,0,-1,-1);
  269.                                         editfuncgadgets[1].Flags|=SELECTED;
  270.                                         select_gadget(&editfuncgadgets[1],1);
  271.                                         fixrmbimage(&sampleclearrmb,NULL,1,-1,-1);
  272.                                     }
  273.                                     break;
  274.                                 case 'S':
  275.                                     ActivateStrGad(&editfuncgadgets[6],Window);
  276.                                     break;
  277.                                 case 'P':
  278.                                     ActivateStrGad(&editfuncgadgets[7],Window);
  279.                                     break;
  280.                                 case 'C':
  281.                                     ActivateStrGad(&editfuncgadgets[8],Window);
  282.                                     break;
  283.                                 case 'E':
  284.                                     if (type==CFG_FILETYPE)
  285.                                         ActivateStrGad(&editfuncgadgets[13],Window);
  286.                                     break;
  287.                             }
  288.                             break;
  289.                         }
  290.                         qual&=IEQUALIFIER_LCOMMAND|IEQUALIFIER_RCOMMAND|
  291.                             IEQUALIFIER_CONTROL|IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT|
  292.                             IEQUALIFIER_LALT|IEQUALIFIER_RALT;
  293.                         if (type==CFG_HOTKEYS) {
  294.                             hotkey->code=code; hotkey->qualifier=qual;
  295.                         }
  296.                         else {
  297.                             func->key=code; func->qual=qual;
  298.                         }
  299.                         showkey(code,qual,x_off+130,y_off+55,374,10);
  300.                         break;
  301.  
  302.                     case IDCMP_MOUSEBUTTONS:
  303.                         if (code==SELECTDOWN) {
  304.                             if (type==CFG_GADGET || type==CFG_MENU) {
  305.                                 a=func->fpen; b=func->bpen;
  306.                                 docolourgad(rp,x_off+150,y_off+15,x,y,edit_namebuf,&a,&b,type);
  307.                                 func->fpen=a; func->bpen=b;
  308.                             }
  309.                         }
  310.                         else if (code==MENUDOWN) {
  311.                             if (type!=CFG_FILETYPE && (fixrmbimage(&sampleclearrmb,NULL,0,x,y))) {
  312.                                 a=DoRMBGadget(&sampleclearrmb,Window);
  313.                                 fixrmbimage(&sampleclearrmb,NULL,1,-1,-1);
  314.                                 if (a==0) {
  315.                                     if (type==CFG_HOTKEYS) {
  316.                                         hotkey->code=0;
  317.                                         hotkey->qualifier=0;
  318.                                     }
  319.                                     else {
  320.                                         func->key=0xff;
  321.                                         func->qual=0;
  322.                                     }
  323.                                     showkey(0,0,x_off+130,y_off+55,374,10);
  324.                                 }
  325.                                 editfuncgadgets[1].Flags&=~SELECTED;
  326.                                 help_ok=1;
  327.                                 break;
  328.                             }
  329.                         }
  330.                         break;
  331.  
  332.                     case IDCMP_GADGETUP:
  333.                         switch (gadgetid) {
  334.                             case EDIT_CANCEL:
  335.                             case EDIT_OKAY:
  336.                                 if (gadgetid==EDIT_CANCEL) {
  337.                                     func->fpen=ofp; func->bpen=obp;
  338.                                 }
  339.                                 else fixeditfunction(func,flagsel,funclist,functype,selitem,type,data,curtype);
  340.                                 freefunclist(funclist);
  341.                                 editgadson(1);
  342.                                 if (type==CFG_FILETYPE) freefunction(func);
  343.                                 LFreeRemember(&key);
  344.                                 RemoveListView(editlists,3);
  345.                                 ClearMenuStrip(Window);
  346.                                 FSSetMenuStrip(Window,&projectmenu);
  347.                                 makehelpname((char *)-1);
  348.                                 rem_appobject(1);
  349.                                 help_ok=1;
  350.                                 return((gadgetid==EDIT_OKAY));
  351.  
  352.                             case EDIT_EDITCLASS:
  353.                                 if (type!=CFG_FILETYPE) break;
  354.                                 fixeditfunction(func,flagsel,funclist,functype,selitem,type,data,curtype);
  355.                                 freefunclist(funclist);
  356.                                 editgadson(1);
  357.                                 RemoveListView(editlists,3);
  358.                                 fclass.last=fclass.next=NULL;
  359.                                 strcpy(fclass.type,ftype->type);
  360.                                 strcpy(fclass.typeid,ftype->typeid);
  361.                                 if (fclass.recognition=getcopy(ftype->recognition,-1,NULL)) {
  362.                                     if (editclass(&fclass,-1)) {
  363.                                         ftype->recognition=getcopy(fclass.recognition,-1,&typekey);
  364.                                         strcpy(ftype->type,fclass.type);
  365.                                         strcpy(ftype->typeid,fclass.typeid);
  366.                                     }
  367.                                     freestring(fclass.recognition);
  368.                                 }
  369.                                 cleanconfigscreen();
  370.                                 filetypetitle(ftype);
  371.                                 goto startedit;
  372.  
  373.                             case EDIT_NAME:
  374.                                 if (type!=CFG_HOTKEYS)
  375.                                     showfuncob(rp,edit_namebuf,func->fpen,func->bpen,type,x_off+244,y_off+5);
  376.                                 if (code!=0x9) getnextgadget(gad);
  377.                                 break;
  378.  
  379.                             case EDIT_STACK:
  380.                                 CheckNumGad(&editfuncgadgets[6],Window,4000,999999);
  381.                                 if (code!=0x9) getnextgadget(gad);
  382.                                 break;
  383.  
  384.                             case EDIT_PRIORITY:
  385.                                 CheckNumGad(&editfuncgadgets[7],Window,-127,127);
  386.                                 if (code!=0x9) getnextgadget(gad);
  387.                                 break;
  388.  
  389.                             case EDIT_DELAY:
  390.                                 CheckNumGad(&editfuncgadgets[8],Window,-1,60);
  391.                                 if (code!=0x9) getnextgadget(gad);
  392.                                 break;
  393.  
  394.                             case EDIT_TYPE:
  395.                                 checkswapgad();
  396.                                 if (qual&IEQUALIFIER_LSHIFT || qual&IEQUALIFIER_RSHIFT) {
  397.                                     if (type==CFG_HOTKEYS) {
  398.                                         if ((--functype[selitem])<1) functype[selitem]=NUM_TYPES-1;
  399.                                     }
  400.                                     else if ((--functype[selitem])<0) functype[selitem]=NUM_TYPES-1;
  401.                                 }
  402.                                 else if ((++functype[selitem])>=NUM_TYPES)
  403.                                     functype[selitem]=(type==CFG_HOTKEYS)?1:0;
  404.                                 SetAPen(rp,screen_pens[1].pen);
  405.                                 DoCycleGadget(&editfuncgadgets[9],Window,functypestr,functype[selitem]);
  406.                                 ActivateStrGad(&editfuncgadgets[11],Window);
  407.                                 break;
  408.  
  409.                             case EDIT_FUNC:
  410.                             case EDIT_DUPLICATE:
  411.                             case EDIT_NEWENTRY:
  412.                                 if (selitem>-1) {
  413.                                     freestring(funclist[selitem]); funclist[selitem]=NULL;
  414.                                     if (edit_funcbuf[0]) makenewentry(funclist,functype,displist,selitem);
  415.                                     else if (selitem<editlists[0].count)
  416.                                         deleteentry(funclist,functype,displist,selitem);
  417.                                 }
  418.                                 if (gadgetid==EDIT_DUPLICATE && edit_funcbuf[0] &&
  419.                                     editlists[0].count<MAXFUNCS) {
  420.                                     strcpy(edit_funcbuf,funclist[selitem]);
  421.                                     functype[editlists[0].count]=functype[selitem];
  422.                                     selitem=editlists[0].count;
  423.                                     editlists[0].topitem+=MAXFUNCS;
  424.                                     editlists[0].itemselected=-1;
  425.                                     setupforedit(functype[selitem],1);
  426.                                 }
  427.                                 else if (gadgetid==EDIT_NEWENTRY && editlists[0].count<MAXFUNCS) {
  428.                                     if (selitem>-1) {
  429.                                         for (a=MAXFUNCS-1;a>selitem;a--) {
  430.                                             funclist[a]=funclist[a-1];
  431.                                             functype[a]=functype[a-1];
  432.                                             makedispfunc(funclist[a],functype[a],displist[a]);
  433.                                         }
  434.                                         ++editlists[0].count;
  435.                                         funclist[selitem]=getcopy(" ",2,NULL);
  436.                                         makedispfunc(funclist[selitem],(type==CFG_HOTKEYS)?1:0,displist[selitem]);
  437.                                     }
  438.                                     else selitem=editlists[0].count;
  439.                                     editgadson(0);
  440.                                     functype[selitem]=(type==CFG_HOTKEYS)?1:0;
  441.                                     edit_funcbuf[0]=0;
  442.                                     editlists[0].itemselected=-1;
  443.                                     setupforedit(functype[selitem],1);
  444.                                 }
  445.                                 else {
  446.                                     endedit(); selitem=-1;
  447.                                 }
  448.                                 break;
  449.  
  450.                             case EDIT_DELETE:
  451.                                 if (selitem<editlists[0].count)
  452.                                     deleteentry(funclist,functype,displist,selitem);
  453.                                 endedit(); selitem=-1;
  454.                                 break;
  455.  
  456.                             case EDIT_ARGREQ:
  457.                                 cmdlist.topitem=0;
  458.                             case EDIT_REQUESTER:
  459.                                 if (funcrequester(
  460.                                     (gadgetid==EDIT_ARGREQ)?FREQ_ARGREQ:functype[selitem],buf,
  461.                                     (gadgetid==EDIT_ARGREQ)?cfg_string[STR_ARGUMENT_CONTROL_SEQUENCES]:
  462.                                         cfg_string[STR_AVAILABLE_COMMANDS])) {
  463.                                     strcpy(buf1,&edit_funcbuf[funcsinfo.BufferPos]);
  464.                                     edit_funcbuf[funcsinfo.BufferPos]=0;
  465.                                     StrConcat(edit_funcbuf,buf,256);
  466.                                     if (gadgetid==EDIT_ARGREQ || functype[selitem]!=FT_INTERNAL)
  467.                                         StrConcat(edit_funcbuf," ",256);
  468.                                     StrConcat(edit_funcbuf,buf1,256);
  469.                                     a=funcsinfo.BufferPos+strlen(buf)+1;
  470.                                     RefreshStrGad(&editfuncgadgets[11],Window);
  471.                                     funcsinfo.BufferPos=(a>255)?255:a;
  472.                                 }
  473.                                 if (!version2) Delay(5);
  474.                                 ActivateGadget(&editfuncgadgets[11],Window,NULL);
  475.                                 break;
  476.  
  477.                             case EDIT_FILETYPEACTION:
  478.                                 if (code!=0x9) getnextgadget(gad);
  479.                                 break;
  480.  
  481.                             case EDIT_SAMPLE:
  482.                                 help_ok=(editfuncgadgets[1].Flags&GFLG_SELECTED)?0:1;
  483.                                 break;
  484.                         }
  485.                         break;
  486.                 }
  487.             }
  488.             else if (view) {
  489.                 switch (view->listid) {
  490.                     case EDIT_FUNCTIONS:
  491.                         if (editfuncgadgets[4].Flags&SELECTED) {
  492.                             a=view->itemselected;
  493.                             SwapMem((char *)displist[selitem],(char *)displist[a],60);
  494.                             ptr=funclist[selitem]; funclist[selitem]=funclist[a]; funclist[a]=ptr;
  495.                             t=functype[selitem]; functype[selitem]=functype[a]; functype[a]=t;
  496.                             RefreshListView(&editlists[1],1);
  497.                             endedit(); selitem=-1;
  498.                         }
  499.                         else {
  500.                             if (selitem>-1) {
  501.                                 freestring(funclist[selitem]); funclist[selitem]=NULL;
  502.                                 if (edit_funcbuf[0]) makenewentry(funclist,functype,displist,selitem);
  503.                                 else if (selitem<editlists[0].count)
  504.                                     deleteentry(funclist,functype,displist,selitem);
  505.                             }
  506.                             selitem=view->itemselected;
  507.                             editgadson(1);
  508.                             strcpy(edit_funcbuf,funclist[selitem]);
  509.                             setupforedit(functype[selitem],1);
  510.                         }
  511.                         break;
  512.                     case EDIT_FLAGS:
  513.                         flagsel[view->itemselected]^=LVARRAY_SELECTED;
  514.                         checkmutflags(flagsel,view->itemselected);
  515.                         RefreshListView(&editlists[1],1);
  516.                         break;
  517.                     case EDIT_FUNCTIONTYPE:
  518.                         if (type!=CFG_FILETYPE) break;
  519.                         if (curtype==view->itemselected || view->itemselected>=FILETYPE_FUNCNUM)
  520.                             break;
  521.                         fixeditfunction(func,flagsel,funclist,functype,selitem,type,data,curtype);
  522.                         if (selitem>-1) {
  523.                             endedit(); selitem=-1;
  524.                         }
  525.                         curtype=view->itemselected;
  526.                         freefunclist(funclist);
  527.                         setupeditdisplay(func,type,data,curtype,displist,funclist,functype,flagsel,0);
  528.                         break;
  529.                 }
  530.             }
  531.         }
  532.         Wait(waitbits);
  533.     }
  534. }
  535.  
  536. void setuplist(list,x,y)
  537. struct DOpusListView *list;
  538. int x,y;
  539. {
  540.     list->window=Window;
  541.     list->slidercol=screen_pens[1].pen;
  542.     list->sliderbgcol=screen_pens[0].pen;
  543.     list->textcol=screen_pens[1].pen;
  544.     list->boxhi=screen_pens[config->gadgettopcol].pen;
  545.     list->boxlo=screen_pens[config->gadgetbotcol].pen;
  546.     list->arrowfg=screen_pens[1].pen;
  547.     list->arrowbg=screen_pens[0].pen;
  548.     list->itemfg=screen_pens[1].pen;
  549.     list->itembg=screen_pens[0].pen;
  550.     if (x>-1) {
  551.         list->x=x_off+x;
  552.         list->y=y_off+y;
  553.     }
  554. }
  555.  
  556. void makefunclist(func,funclist,functype)
  557. char *func,**funclist,*functype;
  558. {
  559.     int len,a,pos,num,gottype;
  560.     char buf[256],buf1[256];
  561.  
  562.     gottype=-1; pos=num=0;
  563.     if (func) {
  564.         len=strlen(func);
  565.         for (a=0;a<=len;a++) {
  566.             if (gottype==-1) {
  567.                 switch (func[a]) {
  568.                     case FC_CHDIR: gottype=FT_CHDIR; break;
  569.                     case FC_INTERNAL: gottype=FT_INTERNAL; break;
  570.                     case FC_WORKBENCH: gottype=FT_WORKBENCH; break;
  571.                     case FC_BATCH: gottype=FT_BATCH; break;
  572.                     case FC_AREXX: gottype=FT_AREXX; break;
  573.                     case FC_REQUESTER: gottype=FT_REQUESTER; break;
  574.                     default:
  575.                         if (!isspace(func[a]) && func[a]!='|') {
  576.                             gottype=FT_EXECUTABLE;
  577.                             --a;
  578.                         }
  579.                         break;
  580.                 }
  581.                 continue;
  582.             }
  583.             if ((gottype==FT_CHDIR && func[a]=='!') ||
  584.                 pos==255 || func[a]==0 || (func[a]=='|' && func[a+1]=='|')) {
  585.                 buf[pos]=0;
  586.                 if (gottype==FT_CHDIR) {
  587.                     StrCombine(buf1,"CD ",buf,256);
  588.                     strcpy(buf,buf1);
  589.                     gottype=FT_EXECUTABLE;
  590.                 }
  591.                 if (funclist[num]=getcopy(buf,-1,NULL)) {
  592.                     functype[num]=gottype;
  593.                     ++num;
  594.                     if (num==MAXFUNCS) break;
  595.                 }
  596.                 pos=0; gottype=-1;
  597.             }
  598.             else buf[pos++]=func[a];
  599.         }
  600.     }
  601.     for (a=num;a<MAXFUNCS;a++) funclist[a]=NULL;
  602. }
  603.  
  604. void makedispfunc(func,type,disp)
  605. char *func,type,*disp;
  606. {
  607.     if (!disp) return;
  608.     if (!func || !func[0] || type<0 || type>=NUM_TYPES) disp[0]=0;
  609.     else {
  610.         strcpy(disp,functypestr[type]);
  611.         StrConcat(disp,spacestring,13);
  612.         StrConcat(disp,func,58);
  613.     }
  614. }
  615.  
  616. char *compilefunclist(funclist,functype,key)
  617. char **funclist,*functype;
  618. struct DOpusRemember **key;
  619. {
  620.     int a,size,num;
  621.     char *buf,typec,buf2[2];
  622.  
  623.     size=1; num=0;
  624.     for (a=0;a<MAXFUNCS;a++) {
  625.         if (!funclist[a] || !funclist[a][0]) break;
  626.         if (a>0) size+=2;
  627.         size+=strlen(funclist[a]);
  628.         if (functype[a]!=FT_EXECUTABLE) ++size;
  629.         ++num;
  630.     }
  631.     if (key) buf=LAllocRemember(key,size,MEMF_CLEAR);
  632.     else buf=AllocMem(size,MEMF_CLEAR);
  633.     if (!buf) return(NULL);
  634.     buf2[1]=0;
  635.     for (a=0;a<num;a++) {
  636.         switch (functype[a]) {
  637.             case FT_INTERNAL: typec=FC_INTERNAL; break;
  638.             case FT_WORKBENCH: typec=FC_WORKBENCH; break;
  639.             case FT_BATCH: typec=FC_BATCH; break;
  640.             case FT_AREXX: typec=FC_AREXX; break;
  641.             case FT_REQUESTER: typec=FC_REQUESTER; break;
  642.             default: typec=0; break;
  643.         }
  644.         if (typec) {
  645.             buf2[0]=typec;
  646.             strcat(buf,buf2);
  647.         }
  648.         strcat(buf,funclist[a]);
  649.         if (a<(num-1)) strcat(buf,"||");
  650.     }
  651.     return(buf);
  652. }
  653.  
  654. void freefunclist(funclist)
  655. char **funclist;
  656. {
  657.     int a;
  658.  
  659.     for (a=0;a<MAXFUNCS;a++) {
  660.         freestring(funclist[a]); funclist[a]=NULL;
  661.     }
  662. }
  663.  
  664. void docolourbox(r,x,y,fg,num)
  665. struct RastPort *r;
  666. int x,y,fg,num;
  667. {
  668.     int a,b,ac,dn,w,h,x1,y1;
  669.     char *ptr;
  670.  
  671.     switch ((b=(1<<screen_depth))) {
  672.         case 4: ac=2; dn=2; break;
  673.         case 8: ac=4; dn=2; break;
  674.         case 16: ac=4; dn=4; break;
  675.         default: return;
  676.     }
  677.  
  678.     Do3DBox(r,x,y,84,22,screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  679.     SetAPen(r,screen_pens[1].pen);
  680.  
  681.     a=strlen((ptr=(fg)?cfg_string[STR_FOREGROUND]:cfg_string[STR_BACKGROUND]));
  682.     Move(r,x+42-(a*4),y-4);
  683.     Text(r,ptr,a);
  684.  
  685.     w=80/ac; h=20/dn;
  686.     x+=2; x1=x; y1=y+1;
  687.     for (a=0;a<b;a++) {
  688.         SetAPen(r,screen_pens[a].pen);
  689.         RectFill(r,x1,y1,x1+w-1,y1+h-1);
  690.         colour_box_xy[num][a][0]=x1;
  691.         colour_box_xy[num][a][1]=y1;
  692.         colour_box_xy[num][a][2]=x1+w-1;
  693.         colour_box_xy[num][a][3]=y1+h-1;
  694.         x1+=w;
  695.         if ((x1-x)==80) {
  696.             x1=x;
  697.             y1+=h;
  698.         }
  699.     }
  700.     colour_box_num=b;
  701. }
  702.  
  703. void docoloursel(r,x,y,pen)
  704. struct RastPort *r;
  705. int x,y,pen;
  706. {
  707.     int a,ac,dn,w,h,x1,y1;
  708.  
  709.     a=1<<screen_depth;
  710.     while (pen>=a && pen>-1) pen-=a;
  711.     if (pen<0) return;
  712.  
  713.     switch (a) {
  714.         case 4: ac=2; dn=2; break;
  715.         case 8: ac=4; dn=2; break;
  716.         case 16: ac=4; dn=4; break;
  717.         default: return;
  718.     }
  719.     w=80/ac; h=20/dn;
  720.     x+=2; x1=x; y1=y+1;
  721.     for (a=0;a<pen;a++) {
  722.         x1+=w;
  723.         if ((x1-x)==80) {
  724.             x1=x;
  725.             y1+=h;
  726.         }
  727.     }
  728.     drawcompbox(r,x1,y1,w,h);
  729. }
  730.  
  731. void drawcompbox(r,x1,y1,w,h)
  732. struct RastPort *r;
  733. int x1,y1,w,h;
  734. {
  735.     SetDrMd(r,COMPLEMENT);
  736.     Move(r,x1+2,y1+1); Draw(r,x1+w-3,y1+1);
  737.     Draw(r,x1+w-3,y1+h-2); Draw(r,x1+2,y1+h-2);
  738.     Draw(r,x1+2,y1+2); Draw(r,x1+3,y1+2); Draw(r,x1+3,y1+h-3);
  739.     Move(r,x1+w-4,y1+2); Draw(r,x1+w-4,y1+h-3);
  740.     SetDrMd(r,JAM2);
  741. }
  742.  
  743. void showkey(key,qual,x,y,w,h)
  744. USHORT key,qual;
  745. int x,y,w,h;
  746. {
  747.     char buf[60];
  748.     int a,l;
  749.  
  750.     Do3DBox(rp,x,y,w,h,screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
  751.     SetAPen(rp,screen_pens[0].pen);
  752.     RectFill(rp,x,y,x+w-1,y+h-1);
  753.     SetAPen(rp,screen_pens[1].pen);
  754.     if (key==0) key=255;
  755.     if (RawkeyToStr(key,qual,buf,NULL,60)) {
  756.         l=w/8;
  757.         Move(rp,x+2,y+((h-8)/2)+6);
  758.         a=strlen(buf);
  759.         Text(rp,buf,(a<l)?a:l);
  760.     }
  761. }
  762.  
  763. void showfuncob(r,name,fp,bp,type,x,y)
  764. struct RastPort *r;
  765. char *name;
  766. int fp,bp,type,x,y;
  767. {
  768.     int a,op;
  769.  
  770.     op=r->FgPen;
  771.     if (type==CFG_GADGET || type==CFG_DRIVE)
  772.         Do3DBox(r,x+10,y+12,124,8,screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
  773.     SetAPen(r,screen_pens[bp].pen);
  774.     a=strlen(name);
  775.     if (type==CFG_GADGET || type==CFG_DRIVE) {
  776.         if (a>15) a=15;
  777.         RectFill(r,x+10,y+12,x+133,y+19);
  778.         x+=8+((128-(a*8))/2);
  779.     }
  780.     else {
  781.         if (a>14) a=14;
  782.         RectFill(r,x+16,y+12,x+127,y+19);
  783.         x+=16;
  784.     }
  785.     SetDrMd(r,JAM1);
  786.     SetAPen(r,screen_pens[fp].pen);
  787.     Move(r,x,y+18); Text(r,name,a);
  788.     SetDrMd(r,JAM2);
  789.     SetAPen(r,op);
  790. }
  791.  
  792. void makeselflags(flags,buf)
  793. int flags;
  794. char *buf;
  795. {
  796.     int a;
  797.  
  798.     for (a=0;a<NUMFLAGS;a++) {
  799.         if (flags&gadflagvals[a]) buf[a]|=LVARRAY_SELECTED;
  800.         else buf[a]&=~LVARRAY_SELECTED;
  801.     }
  802. }
  803.  
  804. getselflags(buf)
  805. char *buf;
  806. {
  807.     int a,flags=0;
  808.  
  809.     for (a=0;a<NUMFLAGS;a++) if (buf[a]&LVARRAY_SELECTED) flags|=gadflagvals[a];
  810.     return(flags);
  811. }
  812.  
  813. void checkmutflags(flags,sel)
  814. char *flags;
  815. int sel;
  816. {
  817.     switch (sel) {
  818.         case SFB_OUTPUTWIN:
  819.             if (flags[SFB_RUNASYNC]&LVARRAY_SELECTED) flags[SFB_WB2F]|=LVARRAY_SELECTED;
  820.             flags[SFB_OUTPUTFILE]&=~LVARRAY_SELECTED;
  821.             if (!(flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED) && flags[SFB_RUNASYNC]&LVARRAY_SELECTED) {
  822.                 flags[SFB_WB2F]&=~LVARRAY_SELECTED;
  823.                 flags[SFB_DOPUS2F]&=~LVARRAY_SELECTED;
  824.             }
  825.             if (flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED && flags[SFB_AUTOICONIFY]&LVARRAY_SELECTED)
  826.                 flags[SFB_WB2F]|=LVARRAY_SELECTED;
  827.             break;
  828.         case SFB_OUTPUTFILE:
  829.             if (flags[SFB_OUTPUTFILE]&LVARRAY_SELECTED) {
  830.                 flags[SFB_OUTPUTWIN]&=~LVARRAY_SELECTED;
  831.                 if (flags[SFB_RUNASYNC]&LVARRAY_SELECTED) {
  832.                     flags[SFB_WB2F]&=~LVARRAY_SELECTED;
  833.                     flags[SFB_DOPUS2F]&=~LVARRAY_SELECTED;
  834.                 }
  835.             }
  836.             flags[SFB_RUNASYNC]&=~LVARRAY_SELECTED;
  837.             flags[SFB_AUTOICONIFY]&=~LVARRAY_SELECTED;
  838.             break;
  839.         case SFB_WB2F:
  840.             if (!(flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED) && flags[SFB_RUNASYNC]&LVARRAY_SELECTED)
  841.                 flags[SFB_DOPUS2F]&=~LVARRAY_SELECTED;
  842.             else if (flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED) {
  843.                 if (!(flags[SFB_WB2F]&LVARRAY_SELECTED)) flags[SFB_RUNASYNC]&=~LVARRAY_SELECTED;
  844.                 flags[SFB_AUTOICONIFY]&=~LVARRAY_SELECTED;
  845.             }
  846.             break;
  847.         case SFB_DOPUS2F:
  848.             if (!(flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED)) {
  849.                 if (flags[SFB_RUNASYNC]&LVARRAY_SELECTED) {
  850.                     flags[SFB_WB2F]&=~LVARRAY_SELECTED;
  851.                     flags[SFB_DOPUS2F]&=~LVARRAY_SELECTED;
  852.                 }
  853.                 else if (flags[SFB_DOPUS2F]&LVARRAY_SELECTED)
  854.                     flags[SFB_RUNASYNC]&=~LVARRAY_SELECTED;
  855.             }
  856.             break;
  857.         case SFB_RUNASYNC:
  858.             if (flags[SFB_OUTPUTFILE]&LVARRAY_SELECTED) {
  859.                 flags[SFB_OUTPUTFILE]&=~LVARRAY_SELECTED;
  860.                 flags[SFB_OUTPUTWIN]|=LVARRAY_SELECTED;
  861.             }
  862.             if (flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED) flags[SFB_WB2F]|=LVARRAY_SELECTED;
  863.             flags[SFB_RELOADFILE]&=~LVARRAY_SELECTED;
  864.             if (flags[SFB_RUNASYNC]&LVARRAY_SELECTED && !(flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED)) {
  865.                 flags[SFB_WB2F]&=~LVARRAY_SELECTED;
  866.                 flags[SFB_DOPUS2F]&=~LVARRAY_SELECTED;
  867.             }
  868.             if (!(flags[SFB_RUNASYNC]&LVARRAY_SELECTED))
  869.                 flags[SFB_AUTOICONIFY]&=~LVARRAY_SELECTED;
  870.             flags[SFB_OUTPUTFILE]&=~LVARRAY_SELECTED;
  871.             flags[SFB_RESCANSOURCE]&=~LVARRAY_SELECTED;
  872.             flags[SFB_RESCANDEST]&=~LVARRAY_SELECTED;
  873.             break;
  874.         case SFB_CDSOURCE:
  875.             flags[SFB_CDDEST]&=~LVARRAY_SELECTED;
  876.             break;
  877.         case SFB_CDDEST:
  878.             flags[SFB_CDSOURCE]&=~LVARRAY_SELECTED;
  879.             break;
  880.         case SFB_RELOADFILE:
  881.             flags[SFB_RUNASYNC]&=~LVARRAY_SELECTED;
  882.             flags[SFB_AUTOICONIFY]&=~LVARRAY_SELECTED;
  883.             break;
  884.         case SFB_AUTOICONIFY:
  885.             if (!(flags[SFB_RUNASYNC]&LVARRAY_SELECTED)) flags[SFB_RUNASYNC]|=LVARRAY_SELECTED;
  886.             if (flags[SFB_OUTPUTFILE]&LVARRAY_SELECTED) flags[SFB_OUTPUTWIN]|=LVARRAY_SELECTED;
  887.             if (flags[SFB_OUTPUTWIN]&LVARRAY_SELECTED) flags[SFB_WB2F]|=LVARRAY_SELECTED;
  888.             flags[SFB_OUTPUTFILE]&=~LVARRAY_SELECTED;
  889.             flags[SFB_RESCANSOURCE]&=~LVARRAY_SELECTED;
  890.             flags[SFB_RESCANDEST]&=~LVARRAY_SELECTED;
  891.             flags[SFB_RELOADFILE]&=~LVARRAY_SELECTED;
  892.             break;
  893.         case SFB_RESCANSOURCE:
  894.         case SFB_RESCANDEST:
  895.             flags[SFB_RUNASYNC]&=~LVARRAY_SELECTED;
  896.             flags[SFB_AUTOICONIFY]&=~LVARRAY_SELECTED;
  897.             break;
  898.     }
  899. }
  900.  
  901. void editgadsoff()
  902. {
  903.     int a;
  904.  
  905.     SetAPen(rp,screen_pens[1].pen);
  906.     DoCycleGadget(&editfuncgadgets[9],Window,functypestr,NUM_TYPES);
  907.     for (a=2;a<6;a++) {
  908.         if (a>2 || editlists[0].count>=MAXFUNCS)
  909.             DisableGadget(&editfuncgadgets[a],rp,4,2);
  910.     }
  911.     for (a=9;a<13;a++) DisableGadget(&editfuncgadgets[a],rp,(a==10 || a==12)?3:((a==9)?4:0),(a==11)?0:2);
  912. }
  913.  
  914. void editgadson(sel)
  915. int sel;
  916. {
  917.     int a;
  918.  
  919.     for (a=2;a<6;a++) {
  920.         if ((a==3 || a==4) && !sel) continue;
  921.         if ((a==2 || a==3) && editlists[0].count>=MAXFUNCS) continue;
  922.         EnableGadget(&editfuncgadgets[a],rp,4,2);
  923.     }
  924.     for (a=9;a<13;a++)
  925.         EnableGadget(&editfuncgadgets[a],rp,(a==10 || a==12)?3:((a==9)?4:0),(a==11)?0:2);
  926. }
  927.  
  928. void deleteentry(funclist,functype,displist,selitem)
  929. char **funclist,*functype,**displist;
  930. int selitem;
  931. {
  932.     int a;
  933.  
  934.     if (selitem>-1) {
  935.         if (selitem<MAXFUNCS-1) {
  936.             CopyMem(&funclist[selitem+1],&funclist[selitem],(MAXFUNCS-1-selitem)*4);
  937.             CopyMem(&functype[selitem+1],&functype[selitem],(MAXFUNCS-1-selitem));
  938.             for (a=selitem;a<MAXFUNCS-1;a++)
  939.                 makedispfunc(funclist[a],functype[a],displist[a]);
  940.         }
  941.         funclist[MAXFUNCS-1]=NULL;
  942.         displist[MAXFUNCS-1][0]=0;
  943.     }
  944. }
  945.  
  946. void endedit()
  947. {
  948.     checkswapgad();
  949.     edit_funcbuf[0]=0;
  950.     RefreshStrGad(&editfuncgadgets[11],Window);
  951.     editlists[0].itemselected=-1;
  952.     RefreshListView(&editlists[0],1);
  953.     editgadson(1);
  954.     editgadsoff();
  955. }
  956.  
  957. void setupforedit(type,act)
  958. int type,act;
  959. {
  960.     checkswapgad();
  961.     RefreshListView(&editlists[0],1);
  962.     SetAPen(rp,screen_pens[1].pen);
  963.     DoCycleGadget(&editfuncgadgets[9],Window,functypestr,type);
  964.     RefreshStrGad(&editfuncgadgets[11],Window);
  965.     if (act) ActivateStrGad(&editfuncgadgets[11],Window);
  966. }
  967.  
  968. void checkswapgad()
  969. {
  970.     if (editfuncgadgets[4].Flags&SELECTED) {
  971.         editfuncgadgets[4].Flags&=~SELECTED;
  972.         select_gadget(&editfuncgadgets[4],0);
  973.     }
  974. }
  975.  
  976. funcrequester(type,buf,title)
  977. int type;
  978. char *buf,*title;
  979. {
  980.     struct Window *wind;
  981.     ULONG class;
  982.     USHORT gadgetid;
  983.     struct DOpusListView *view;
  984.     char *ptr;
  985.     int ret=0;
  986.  
  987.     switch (type) {
  988.         case FT_INTERNAL:
  989.         case FREQ_ARGREQ:
  990.         case FREQ_FILETYPE:
  991.         case FREQ_FILECLASS:
  992.             setup_list_window(&requestwin,&cmdlist,&cmdcancelgad,1);
  993.             requestwin.Title=title;
  994.             if (!(wind=openwindow(&requestwin))) return(0);
  995.             setuplist(&cmdlist,-1,-1);
  996.             switch (type) {
  997.                 case FREQ_FILETYPE:
  998.                     cmdlist.items=classopslist;
  999.                     break;
  1000.                 case FREQ_FILECLASS:
  1001.                     cmdlist.items=fileclasslist;
  1002.                     break;
  1003.                 case FREQ_ARGREQ:
  1004.                     cmdlist.items=arglist;
  1005.                     break;
  1006.                 case FT_INTERNAL:
  1007.                     cmdlist.items=commandlist;
  1008.                     break;
  1009.             }
  1010.             cmdlist.window=wind;
  1011.             if (!(AddListView(&cmdlist,1))) {
  1012.                 CloseWindow(wind);
  1013.                 return(0);
  1014.             }
  1015.             SetAPen(wind->RPort,screen_pens[1].pen);
  1016.             AddGadgets(wind,
  1017.                 &cmdcancelgad,
  1018.                 &editfuncgads[4],
  1019.                 1,
  1020.                 screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
  1021.  
  1022.             busy();
  1023.  
  1024.             FOREVER {
  1025.                 Wait(1<<wind->UserPort->mp_SigBit);
  1026.                 while (IMsg=(struct IntuiMessage *)GetMsg(wind->UserPort)) {
  1027.                     if ((view=ListViewIDCMP(&cmdlist,IMsg))==(struct DOpusListView *)-1) {
  1028.                         class=IMsg->Class;
  1029.                         if (class==IDCMP_GADGETUP || class==IDCMP_GADGETDOWN)
  1030.                             gadgetid=((struct Gadget *)IMsg->IAddress)->GadgetID;
  1031.                         ReplyMsg((struct Message *)IMsg);
  1032.                         if (class==IDCMP_GADGETUP && gadgetid==0) {
  1033.                             RemoveListView(&cmdlist,1);
  1034.                             CloseWindow(wind);
  1035.                             unbusy();
  1036.                             return(0);
  1037.                         }
  1038.                     }
  1039.                     else if (view) {
  1040.                         if (buf) {
  1041.                             strcpy(buf,cmdlist.items[view->itemselected]);
  1042.                             ptr=buf;
  1043.                             while (*(ptr)) {
  1044.                                 if (*(ptr)==' ') {
  1045.                                     *ptr=0;
  1046.                                     break;
  1047.                                 }
  1048.                                 ++ptr;
  1049.                             }
  1050.                         }
  1051.                         RemoveListView(&cmdlist,1);
  1052.                         CloseWindow(wind);
  1053.                         unbusy();
  1054.                         return(view->itemselected+1);
  1055.                     }
  1056.                 }
  1057.             }
  1058.             break;
  1059.  
  1060.         default:
  1061.             filereq.flags=0;
  1062.             filereq.title=cfg_string[STR_SELECT_DESIRED_FILE];
  1063.  
  1064.             switch (type) {
  1065.                 case FT_EXECUTABLE:
  1066.                 case FT_WORKBENCH:
  1067.                 case FT_BATCH:
  1068.                 case FT_AREXX:
  1069.                     filebuf[0]=0;
  1070.                     if (CheckExist(defdir[type],NULL)) strcpy(dirbuf,defdir[type]);
  1071.                     else dirbuf[0]=0;
  1072.                     break;
  1073.                 case FREQ_GENERIC:
  1074.                     strcpy(dirbuf,buf);
  1075.                     if ((ptr=BaseName(dirbuf))>dirbuf) {
  1076.                         strcpy(filebuf,ptr);
  1077.                         *ptr=0;
  1078.                     }
  1079.                     else {
  1080.                         LStrnCpy(filebuf,buf,31);
  1081.                         dirbuf[0]=0;
  1082.                     }
  1083.                     break;
  1084.                 case FREQ_PATHREQ:
  1085.                     filereq.flags=DFRF_DIRREQ;
  1086.                     filereq.title=cfg_string[STR_SELECT_DESIRED_DIRECTORY];
  1087.                     break;
  1088.             }
  1089.  
  1090.             filereq.window=Window;
  1091.             if (!dirbuf[0]) {
  1092.                 BPTR lock;
  1093.  
  1094.                 if (lock=Lock("",ACCESS_READ)) {
  1095.                     PathName(lock,dirbuf,256);
  1096.                     UnLock(lock);
  1097.                 }
  1098.             }
  1099.             busy();
  1100.             if (FileRequest(&filereq)) {
  1101.                 strcpy(buf,dirbuf);
  1102.                 TackOn(buf,filebuf,256);
  1103.                 ret=1;
  1104.             }
  1105.             unbusy();
  1106.             break;
  1107.     }
  1108.     return(ret);
  1109. }
  1110.  
  1111. void makenewentry(funclist,functype,displist,selitem)
  1112. char **funclist,*functype,**displist;
  1113. int selitem;
  1114. {
  1115.     funclist[selitem]=getcopy(edit_funcbuf,-1,NULL);
  1116.     if (displist) {
  1117.         makedispfunc(funclist[selitem],functype[selitem],displist[selitem]);
  1118.         if (selitem>=editlists[0].count && editlists[0].topitem>=editlists[0].count-5)
  1119.             ++editlists[0].topitem;
  1120.     }
  1121. }
  1122.  
  1123. void setupcolourbox(r,x,y,fp,bp)
  1124. struct RastPort *r;
  1125. int x,y,fp,bp;
  1126. {
  1127.     docolourbox(r,x,y,1,0);
  1128.     docoloursel(r,x,y,fp);
  1129.     docolourbox(r,x+248,y,0,1);
  1130.     docoloursel(r,x+248,y,bp);
  1131.     Do3DBox(r,x+94,y-10,144,32,screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
  1132. }
  1133.  
  1134. void getfiletypefunc(func,ftype,type)
  1135. struct dopusfunction *func;
  1136. struct dopusfiletype *ftype;
  1137. int type;
  1138. {
  1139.     type=ftype_funcmap[type];
  1140.  
  1141.     func->which=ftype->which[type];
  1142.     func->stack=ftype->stack[type];
  1143.     func->pri=ftype->pri[type];
  1144.     func->delay=ftype->delay[type];
  1145.     freestring(func->function);
  1146.     func->function=getcopy(ftype->function[type],-1,NULL);
  1147.     strcpy(edit_actionbuf,ftype->actionstring[type]);
  1148. }
  1149.  
  1150. void makefiletypefunc(func,ftype,type)
  1151. struct dopusfunction *func;
  1152. struct dopusfiletype *ftype;
  1153. int type;
  1154. {
  1155.     type=ftype_funcmap[type];
  1156.  
  1157.     ftype->which[type]=func->which;
  1158.     ftype->stack[type]=func->stack;
  1159.     ftype->pri[type]=func->pri;
  1160.     ftype->delay[type]=func->delay;
  1161.     freestring(ftype->function[type]);
  1162.     ftype->function[type]=getcopy(func->function,-1,NULL);
  1163.     strcpy(ftype->actionstring[type],edit_actionbuf);
  1164. }
  1165.  
  1166. void fixeditfunction(func,flagsel,funclist,functype,selitem,type,data,curtype)
  1167. struct dopusfunction *func;
  1168. char *flagsel,**funclist,*functype;
  1169. int selitem,type;
  1170. APTR data;
  1171. int curtype;
  1172. {
  1173.     struct dopusfiletype *ftype;
  1174.     struct dopushotkey *hotkey;
  1175.  
  1176.     if (type==CFG_FILETYPE) ftype=(struct dopusfiletype *)data;
  1177.     else if (type==CFG_HOTKEYS) hotkey=(struct dopushotkey *)data;
  1178.  
  1179.     if (selitem>-1 && edit_funcbuf[0]) {
  1180.         freestring(funclist[selitem]); funclist[selitem]=NULL;
  1181.         makenewentry(funclist,functype,NULL,selitem);
  1182.     }
  1183.     freefunction(func);
  1184.     func->function=compilefunclist(funclist,functype,NULL);
  1185.     func->which=getselflags(flagsel);
  1186.     func->stack=atoi(edit_stackbuf);
  1187.     if (func->stack<4000) func->stack=4000;
  1188.     func->pri=atoi(edit_prioritybuf);
  1189.     if (func->pri<-127) func->pri=-127;
  1190.     else if (func->pri>127) func->pri=127;
  1191.     func->delay=atoi(edit_delaybuf);
  1192.     if (func->delay<-1) func->delay=-1;
  1193.     else if (func->delay>60) func->delay=60;
  1194.     if (type==CFG_FILETYPE) {
  1195.         makefiletypefunc(func,ftype,curtype);
  1196.         fixfunctypelist(ftype);
  1197.         RefreshListView(&editlists[2],1);
  1198.     }
  1199.     else if (type==CFG_HOTKEYS) strcpy(hotkey->name,edit_namebuf);
  1200.     else {
  1201.         freestring(((struct newdopusfunction *)func)->name);
  1202.         ((struct newdopusfunction *)func)->name=getcopy(edit_namebuf,-1,0);
  1203.     }
  1204. }
  1205.  
  1206. void setupeditdisplay(func,type,data,curtype,displist,funclist,functype,flagsel,add)
  1207. struct dopusfunction *func;
  1208. int type;
  1209. APTR data;
  1210. int curtype;
  1211. char **displist,**funclist,*functype,*flagsel;
  1212. int add;
  1213. {
  1214.     int a;
  1215.     struct dopusfiletype *ftype;
  1216.  
  1217.     if (type==CFG_FILETYPE) ftype=(struct dopusfiletype *)data;
  1218.  
  1219.     for (a=0;a<2;a++) {
  1220.         setuplist(&editlists[a],130,69+(a*60));
  1221.         editlists[a].itemselected=-1;
  1222.         editlists[a].topitem=0;
  1223.     }
  1224.     if (type==CFG_FILETYPE) {
  1225.         setuplist(&editlists[2],173,4);
  1226.         getfiletypefunc(func,ftype,curtype);
  1227.     }
  1228.     else if (type==CFG_HOTKEYS) editlists[1].topitem=5;
  1229.     makefunclist(func->function,funclist,functype);
  1230.     for (a=0;a<MAXFUNCS;a++) makedispfunc(funclist[a],functype[a],displist[a]);
  1231.     displist[MAXFUNCS]=funclist[MAXFUNCS]=NULL;
  1232.     editlists[0].items=displist;
  1233.     makeselflags(func->which,flagsel);
  1234.     editlists[1].selectarray=flagsel;
  1235.     if (add) {
  1236.         AddListView(editlists,3);
  1237.         initsidegads(editfuncgads,0,0);
  1238.     }
  1239.     else RefreshListView(editlists,3);
  1240.     edit_funcbuf[0]=0;
  1241.     lsprintf(edit_stackbuf,"%ld",func->stack);
  1242.     lsprintf(edit_prioritybuf,"%ld",func->pri);
  1243.     lsprintf(edit_delaybuf,"%ld",func->delay);
  1244.     RefreshGList(&editfuncgadgets[6],Window,NULL,3);
  1245.     if (type==CFG_FILETYPE) RefreshGList(&editfuncgadgets[13],Window,NULL,1);
  1246. }
  1247.  
  1248. void erasefunction(func,funclist,displist,flagsel)
  1249. struct dopusfunction *func;
  1250. char **funclist,**displist,*flagsel;
  1251. {
  1252.     int a;
  1253.  
  1254.     freefunclist(funclist);
  1255.     for (a=0;a<MAXFUNCS;a++) displist[a][0]=0;
  1256.     strcpy(edit_stackbuf,"4000");
  1257.     edit_prioritybuf[0]='0'; edit_prioritybuf[1]=0;
  1258.     edit_delaybuf[0]='2'; edit_delaybuf[1]=0;
  1259.     edit_namebuf[0]=0;
  1260.     if (func) {
  1261.         func->key=0; func->qual=0;
  1262.     }
  1263.     makeselflags(0,flagsel);
  1264. }
  1265.  
  1266. fixfunctypelist(ftype)
  1267. struct dopusfiletype *ftype;
  1268. {
  1269.     int a,type=-1,b;
  1270.  
  1271.     for (a=0;a<FILETYPE_FUNCNUM;a++) {
  1272.         if (!functypelist[a]) break;
  1273.         b=ftype_funcmap[a];
  1274.         if (ftype->function[b] && ftype->function[b][0]) {
  1275.             if (type==-1) type=a;
  1276.             functypelist[a][1]='*';
  1277.         }
  1278.         else functypelist[a][1]=' ';
  1279.     }
  1280.     if (type==-1) type=0;
  1281.     return(type);
  1282. }
  1283.  
  1284. void add_appobject(type)
  1285. int type;
  1286. {
  1287.     if (WorkbenchBase && appport) {
  1288.         if (Screen && type) {
  1289.             appobject=
  1290.                 (void *)AddAppIconA(MY_APPOBJECT,0,
  1291.                     cfg_string[STR_DROP_A_TOOL_HERE],
  1292.                     appport,
  1293.                     NULL,&dropboxobj,NULL);
  1294.         }
  1295.         else if (!Screen) {
  1296.             appobject=
  1297.                 (void *)AddAppWindowA(MY_APPOBJECT,0,
  1298.                     Window,appport,NULL);
  1299.         }
  1300.     }
  1301. }
  1302.  
  1303. void rem_appobject(type)
  1304. int type;
  1305. {
  1306.     if (WorkbenchBase && appobject) {
  1307.         if (Screen && type) RemoveAppIcon(appobject);
  1308.         else if (!Screen) RemoveAppWindow(appobject);
  1309.         while (appmsg=(struct AppMessage *)GetMsg(appport))
  1310.             ReplyMsg((struct Message *)appmsg);
  1311.     }
  1312.     appobject=NULL;
  1313. }
  1314.  
  1315. void do_gad_label(txt,x,y)
  1316. char *txt;
  1317. int x,y;
  1318. {
  1319.     char buf[140];
  1320.     int len,a,uspos=-1;
  1321.  
  1322.     for (len=0,a=0;txt[len] && a<139;len++) {
  1323.         if (txt[len]=='_' && uspos==-1) {
  1324.             uspos=a;
  1325.             continue;
  1326.         }
  1327.         buf[a++]=txt[len];
  1328.     }
  1329.     buf[a]=0;
  1330.  
  1331.     x-=a*8;
  1332.     UScoreText(rp,buf,x,y,uspos);
  1333. }
  1334.