dopus/Config/main3.c

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