dopus/Config/main5.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
  33 int dofiletypeconfig()
  34 {
  35     ULONG class;
  36     UWORD code,gadgetid;
  37     struct ConfigUndo *undo;
  38     struct DOpusRemember *key;
  39     struct DOpusListView *view;
  40     struct dopusfiletype *type,*tpos,*type1;
  41     struct fileclass *fclass,classbuf;
  42     int mode=-1,a,classchange=0;
  43     char **listptr,buf[256],*ptr;
  44
  45     key=NULL; type1=NULL; firstclass=NULL;
  46     filetypeactionlist.items=NULL;
  47     filetypeactionlist.topitem=0;
  48     showconfigscreen(CFG_FILETYPE);
  49     ClearMenuStrip(Window);
  50     projectmenu.NextMenu=&classmenu;
  51     FSSetMenuStrip(Window,&projectmenu);
  52     listptr=makefiletypelist(&key);
  53     undo=makeundo(UNDO_FILETYPE);
  54     showtypelist(listptr);
  55     busy();
  56     readfileclasses();
  57     unbusy();
  58
  59     FOREVER {
  60         Wait(1<<Window->UserPort->mp_SigBit);
  61         while (IMsg=getintuimsg()) {
  62             if ((view=ListViewIDCMP(&filetypeactionlist,IMsg))==(struct DOpusListView *)-1) {
  63                 class=IMsg->Class; code=IMsg->Code;
  64                 if (class==GADGETUP || class==GADGETDOWN)
  65                     gadgetid=((struct Gadget *)IMsg->IAddress)->GadgetID;
  66                 ReplyMsg((struct Message *)IMsg);
  67                 switch (class) {
  68                     case MENUPICK:
  69                         if (code==MENUNULL) break;
  70                         switch (MENUNUM(code)) {
  71                             case 0:
  72                                 if (type1) {
  73                                     showtypelist(listptr);
  74                                     type1=NULL;
  75                                 }
  76                                 if (mode>-1) {
  77                                     select_gadget(&maingad[mode],0);
  78                                     mode=-1;
  79                                 }
  80                                 dogadgetinfo(NULL);
  81                                 switch ((a=ITEMNUM(code))) {
  82                                     case 0:
  83                                     case 1:
  84                                         if (doload(CFG_FILETYPE,a)) {
  85                                             listptr=makefiletypelist(&key);
  86                                             showtypelist(listptr);
  87                                             if (a) dogadgetinfo(cfg_string[STR_NEW_FILETYPES_MERGED]);
  88                                             else dogadgetinfo(cfg_string[STR_DEFAULT_FILETYPES_MERGED]);
  89                                         }
  90                                         break;
  91                                 }
  92                                 break;
  93                             case 1:
  94                                 switch (ITEMNUM(code)) {
  95                                     case 0:
  96                                         classbuf.type[0]=0;
  97                                         classbuf.typeid[0]=0;
  98                                         classbuf.recognition=NULL;
  99                                         classbuf.next=classbuf.last=NULL;
 100                                         if (editclass(&classbuf,1)) classchange=1;
 101                                         break;
 102                                     case 1:
 103                                         if (!(fclass=getfileclasslist(1))) break;
 104                                         if (editclass(fclass,0)) classchange=1;
 105                                         break;
 106                                     case 2:
 107                                         if (!(fclass=getfileclasslist(3))) break;
 108                                         CopyMem((char *)fclass,(char *)&classbuf,sizeof(struct fileclass));
 109                                         classbuf.recognition=getcopy(fclass->recognition,-1,NULL);
 110                                         classbuf.next=classbuf.last=NULL;
 111                                         if (editclass(&classbuf,1)) classchange=1;
 112                                         break;
 113                                     case 3:
 114                                         if (!(fclass=getfileclasslist(2))) break;
 115                                         lsprintf(buf,"\"%s\"\n%s",
 116                                             fclass->type,cfg_string[STR_REALLY_DELETE_THIS_CLASS]);
 117                                         if (request(buf)) {
 118                                             dogadgetinfo(cfg_string[STR_FILE_CLASS_DELETED]);
 119                                             removefileclass(fclass);
 120                                             classchange=1;
 121                                         }
 122                                         else dogadgetinfo(NULL);
 123                                         break;
 124                                     case 5:
 125                                         if (importfileclasses()) classchange=1;
 126                                         break;
 127                                     case 6:
 128                                         busy();
 129                                         if (savefileclasses()) classchange=0;
 130                                         unbusy();
 131                                         break;
 132                                     case 7:
 133                                         if (classname[0]) strcpy(dirbuf,classname);
 134                                         else strcpy(dirbuf,"PROGDIR:S/DirectoryOpus.CLA");
 135                                         if (ptr=BaseName(dirbuf)) {
 136                                             strcpy(filebuf,ptr);
 137                                             *ptr=0;
 138                                         }
 139 D(bug("filebuf: %s\t%s\n",dirbuf,filebuf));
 140                                         filereq.flags=0;
 141                                         filereq.title=cfg_string[STR_ENTER_NAME_TO_SAVE_CLASSES];
 142                                         filereq.window=Window;
 143                                         if (!(FileRequest(&filereq))) filebuf[0]=0;
 144                                         if (!filebuf[0]) break;
 145                                         strcpy(classname,dirbuf);
 146                                         TackOn(classname,filebuf,256);
 147                                         busy();
 148                                         if (savefileclasses()) classchange=0;
 149                                         unbusy();
 150                                         break;
 151                                     case 8:
 152                                         if (firstclass && (request(cfg_string[STR_ERASE_ALL_CLASSES]))) {
 153                                             freefileclasses();
 154                                             classchange=0;
 155                                         }
 156                                         break;
 157                                 }
 158                                 break;
 159                         }
 160                         break;
 161                     case GADGETUP:
 162                         if (gadgetid<FILETYPE_OKAY) {
 163                             if (type1) {
 164                                 showtypelist(listptr);
 165                                 type1=NULL;
 166                             }
 167                             if (mode==gadgetid) {
 168                                 mode=-1;
 169                                 dogadgetinfo(NULL);
 170                                 break;
 171                             }
 172                             if (mode>-1) {
 173                                 select_gadget(&maingad[mode],0);
 174                             }
 175                         }
 176                         switch (gadgetid) {
 177                             case FILETYPE_OKAY:
 178                             case FILETYPE_CANCEL:
 179                                 if (classchange && !(request(cfg_string[STR_EXIT_WITHOUT_SAVING_CLASSES])))
 180                                     break;
 181                                 if (gadgetid==FILETYPE_CANCEL) doundo(undo,UNDO_FILETYPE);
 182                                 doundo(undo,0);
 183                                 RemoveListView(&filetypeactionlist,1);
 184                                 LFreeRemember(&key);
 185                                 freefileclasses();
 186                                 ClearMenuStrip(Window); projectmenu.NextMenu=NULL;
 187                                 FSSetMenuStrip(Window,&projectmenu);
 188                                 return((gadgetid==FILETYPE_OKAY));
 189                             case FILETYPE_NEW:
 190                                 dogadgetinfo(NULL);
 191                                 if (!(fclass=getfileclasslist(0))) break;
 192                                 type=firsttype;
 193                                 while (type) {
 194                                     if (strcmp(type->type,fclass->type)==0) break;
 195                                     type=type->next;
 196                                 }
 197                                 if (!type || request(cfg_string[STR_REDEFINE_EXISTING_CLASS_ACTION])) {
 198                                     if (type=AllocMem(sizeof(struct dopusfiletype),MEMF_CLEAR)) {
 199                                         strcpy(type->type,fclass->type);
 200                                         strcpy(type->typeid,fclass->typeid);
 201                                         type->recognition=getcopy(fclass->recognition,-1,&typekey);
 202                                         for (a=0;a<4;a++) {
 203                                             type->stack[a]=4000;
 204                                             type->delay[a]=2;
 205                                         }
 206                                         if (editfiletype(type,&key,1)) {
 207                                             if (tpos=(struct dopusfiletype *)
 208                                                     getcopy((char *)type,sizeof(struct dopusfiletype),&typekey)) {
 209                                                 tpos->recognition=getcopy(type->recognition,-1,&typekey);
 210                                                 for (a=0;a<4;a++)
 211                                                     tpos->function[a]=getcopy(type->function[a],-1,&typekey);
 212                                                 addfiletype(tpos);
 213                                             }
 214                                         }
 215                                         FreeMem(type,sizeof(struct dopusfiletype));
 216                                         listptr=makefiletypelist(&key);
 217                                         showtypelist(listptr);
 218                                     }
 219                                 }
 220                                 break;
 221                         }
 222                         mode=doinitfiletypetext(gadgetid);
 223                         break;
 224                 }
 225             }
 226             else if (view) {
 227                 if (view->listid==2) {
 228                     if (view->itemselected>-1) {
 229                         type=firsttype;
 230                         for (a=0;a<view->itemselected;a++,type=type->next)
 231                             if (!type) break;
 232                         if (type) {
 233                             switch (mode) {
 234                                 case -1:
 235                                     editfiletype(type,&key,0);
 236                                     listptr=makefiletypelist(&key);
 237                                     showtypelist(listptr);
 238                                     break;
 239                                 case FILETYPE_SWAP:
 240                                     if (type1) {
 241                                         if (strcmp(type->type,"Default")==0)
 242                                             dogadgetinfo(cfg_string[STR_DEFAULT_ACTION_CAN_NOT_BE_MOVED]);
 243                                         else if (type!=type1) {
 244                                             SwapMem((char *)type->type,(char *)type1->type,sizeof(struct dopusfiletype)-4);
 245                                             listptr=makefiletypelist(&key);
 246                                             dogadgetinfo(cfg_string[STR_CLASS_ACTIONS_SWAPPED]);
 247                                         }
 248                                         else dogadgetinfo(NULL);
 249                                         showtypelist(listptr);
 250                                         type1=NULL;
 251                                     }
 252                                     else {
 253                                         if (strcmp(type->type,"Default")==0) {
 254                                             showtypelist(listptr);
 255                                             dogadgetinfo(cfg_string[STR_DEFAULT_ACTION_CAN_NOT_BE_MOVED]);
 256                                         }
 257                                         else {
 258                                             type1=type;
 259                                             dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_SWAP_WITH_FIRST]);
 260                                         }
 261                                     }
 262                                     break;
 263                                 case FILETYPE_DELETE:
 264                                     if (request(cfg_string[STR_REALLY_DELETE_THIS_ACTION])) {
 265                                         if (type==firsttype) firsttype=type->next;
 266                                         else {
 267                                             tpos=firsttype;
 268                                             while (tpos) {
 269                                                 if (tpos->next==type) {
 270                                                     tpos->next=type->next;
 271                                                     break;
 272                                                 }
 273                                                 tpos=tpos->next;
 274                                             }
 275                                         }
 276                                         dogadgetinfo(cfg_string[STR_ACTION_DELETED]);
 277                                         listptr=makefiletypelist(&key);
 278                                     }
 279                                     else dogadgetinfo(NULL);
 280                                     showtypelist(listptr);
 281                                     break;
 282                             }
 283                         }
 284                     }
 285                 }
 286             }
 287         }
 288     }
 289 }
 290
 291 char **makefiletypelist(key)
 292 struct DOpusRemember **key;
 293 {
 294     char **list;
 295     int count,a;
 296     struct dopusfiletype *type;
 297
 298     LFreeRemember(key);
 299     type=firsttype;
 300     for (count=0;type;count++,type=type->next);
 301     if (!(list=LAllocRemember(key,(count+1)*4,MEMF_CLEAR))) return(NULL);
 302     type=firsttype;
 303     for (a=0;a<count;a++) {
 304         if (list[a]=LAllocRemember(key,60,MEMF_CLEAR)) {
 305             if (type->type[0]) lsprintf(list[a],"%-50s%s",type->type,type->typeid);
 306             else {
 307                 list[a][0]=' '; list[a][1]=0;
 308             }
 309         }
 310         type=type->next;
 311     }
 312     return(list);
 313 }
 314
 315 void showtypelist(list)
 316 char **list;
 317 {
 318     filetypeactionlist.items=list; filetypeactionlist.itemselected=-1;
 319     RefreshListView(&filetypeactionlist,1);
 320 }
 321
 322 int doinitfiletypetext(id)
 323 int id;
 324 {
 325     int mode=-1;
 326
 327     switch (id) {
 328         case FILETYPE_SWAP:
 329             mode=FILETYPE_SWAP;
 330             dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_SWAP]);
 331             break;
 332         case FILETYPE_DELETE:
 333             mode=FILETYPE_DELETE;
 334             dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_DELETE]);
 335             break;
 336     }
 337     return(mode);
 338 }
 339
 340 void filetypetitle(type)
 341 struct dopusfiletype *type;
 342 {
 343     char title[80];
 344
 345     lsprintf(title,"%s : %s",cfg_string[STR_FILETYPE_CLASS],type->type);
 346     if (type->typeid[0]) {
 347         char extra[16];
 348
 349         lsprintf(extra," (%s)",type->typeid);
 350         strcat(title,extra);
 351     }
 352     doscreentitle(title);
 353 }
 354
 355 int editfiletype(type,key,new)
 356 struct dopusfiletype *type;
 357 struct DOpusRemember **key;
 358 int new;
 359 {
 360     struct dopusfunction editbuf;
 361     char *func[FILETYPE_FUNCNUM],*oldfunc[FILETYPE_FUNCNUM];
 362     int a,b;
 363
 364     RemoveListView(&filetypeactionlist,1);
 365     cleanconfigscreen();
 366     filetypetitle(type);
 367     editbuf.function=NULL;
 368     for (a=0;a<FILETYPE_FUNCNUM;a++) {
 369         oldfunc[a]=type->function[a];
 370         func[a]=getcopy(type->function[a],-1,NULL);
 371         type->function[a]=func[a];
 372     }
 373     b=editfunction(&editbuf,CFG_FILETYPE,type);
 374     if (new) {
 375         if (!b) {
 376             for (a=0;a<FILETYPE_FUNCNUM;a++) {
 377                 func[a]=oldfunc[a];
 378                 freestring(type->function[a]);
 379                 type->function[a]=func[a];
 380             }
 381         }
 382     }
 383     else {
 384         for (a=0;a<FILETYPE_FUNCNUM;a++) {
 385             if (b) func[a]=getcopy(type->function[a],-1,&typekey);
 386             else func[a]=oldfunc[a];
 387             freestring(type->function[a]);
 388             type->function[a]=func[a];
 389         }
 390     }
 391     showconfigscreen(CFG_FILETYPE);
 392     return(b);
 393 }
 394
 395 int editclass(class,new)
 396 struct fileclass *class;
 397 int new;
 398 {
 399     struct fileclass editbuf;
 400     int b,c;
 401
 402     makehelpname(cfg_string[STR_EDIT_CLASS]);
 403     if (new==-1) {
 404         new=c=0;
 405     }
 406     else {
 407         c=1;
 408         RemoveListView(&filetypeactionlist,2);
 409     }
 410     cleanconfigscreen();
 411     doscreentitle(cfg_string[STR_FILE_CLASS_EDIT_SCREEN]);
 412     strcpy(editbuf.type,class->type);
 413     strcpy(editbuf.typeid,class->typeid);
 414     editbuf.recognition=getcopy(class->recognition,-1,NULL);
 415     if ((b=editfileclass(&editbuf,new))) {
 416         if (c) {
 417             if (!new) removefileclass(class);
 418             addfileclass(editbuf.type,editbuf.typeid,editbuf.recognition);
 419         }
 420         else {
 421             freestring(class->recognition);
 422             class->recognition=getcopy(editbuf.recognition,-1,NULL);
 423             strcpy(class->type,editbuf.type);
 424             strcpy(class->typeid,editbuf.typeid);
 425         }
 426     }
 427     if (c) showconfigscreen(CFG_FILETYPE);
 428     freestring(editbuf.recognition);
 429     makehelpname((char *)-1);
 430     return(b);
 431 }
 432
 433 void addfiletype(type)
 434 struct dopusfiletype *type;
 435 {
 436     struct dopusfiletype *tpos;
 437
 438     if (!(tpos=firsttype)) firsttype=type;
 439     else {
 440         while (tpos->next) {
 441             if (strcmp(tpos->next->type,"Default")==0) {
 442                 type->next=tpos->next;
 443                 break;
 444             }
 445             tpos=tpos->next;
 446         }
 447         tpos->next=type;
 448     }
 449 }
 450
 451 void readfileclasses()
 452 {
 453     BPTR in;
 454     int size,pos,lsize,a;
 455     char *classbuf,buf[256],*typeid;
 456
 457     if ((CheckExist(classname,&size))>=0 ||
 458         !(classbuf=AllocMem(size,MEMF_CLEAR))) return;
 459     if (in=Open(classname,MODE_OLDFILE)) {
 460         Read(in,classbuf,size);
 461         Close(in);
 462         pos=0;
 463         FOREVER {
 464             if ((pos=readline(classbuf,pos,buf,size))==-1) break;
 465             typeid="";
 466             for (a=0;buf[a];a++) {
 467                 if (buf[a]==1) {
 468                     buf[a]=0;
 469                     typeid=&buf[a+1];
 470                     break;
 471                 }
 472             }
 473             for (lsize=pos;lsize<size;lsize++) if (!classbuf[lsize]) break;
 474             if (!(addfileclass(buf,typeid,&classbuf[pos]))) break;
 475             pos=lsize+1;
 476         }
 477     }
 478     FreeMem(classbuf,size);
 479 }
 480
 481 int importfileclasses()
 482 {
 483     BPTR in;
 484     int size,pos,lsize,num,a,b,tpos,ret=0;
 485     char *classbuf,**classlist,*classarray,**classtypeid,**classrecog,buf[256],buf2[256];
 486     struct DOpusRemember *key;
 487
 488     filereq.flags=0;
 489     filereq.title=cfg_string[STR_SELECT_CLASS_FILE_TO_LOAD];
 490     strcpy(dirbuf,classname);
 491     if (classbuf=BaseName(dirbuf)) *classbuf=0;
 492     filebuf[0]=0;
 493     filereq.window=Window;
 494     if (!(FileRequest(&filereq)) || !filebuf[0]) return(0);
 495     strcpy(buf,dirbuf); TackOn(buf,filebuf,256);
 496
 497     while (!(in=Open(buf,MODE_OLDFILE))) {
 498         lsprintf(buf2,cfg_string[STR_OPEN_FAILED],IoErr());
 499         if (!(request(buf2))) return(0);
 500     }
 501
 502     key=NULL;
 503
 504     if ((CheckExist(buf,&size))>=0 ||
 505         !(classbuf=LAllocRemember(&key,size+2,MEMF_CLEAR))) {
 506         Close(in);
 507         return(0);
 508     }
 509
 510     Read(in,classbuf,size);
 511     Close(in);
 512
 513     for (a=0,num=0;a<size;a++) if (!classbuf[a]) ++num;
 514     num/=2;
 515
 516     if ((classlist=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
 517         (classtypeid=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
 518         (classrecog=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
 519         (classarray=LAllocRemember(&key,num+1,MEMF_CLEAR))) {
 520         pos=0; a=0;
 521         FOREVER {
 522             tpos=pos;
 523             if ((pos=readline(classbuf,pos,buf,size))==-1) break;
 524             classlist[a]=&classbuf[tpos];
 525             classtypeid[a]="";
 526             for (b=0;buf[b];b++) {
 527                 if (buf[b]==1) {
 528                     classbuf[tpos+b]=0;
 529                     classtypeid[a]=&classbuf[tpos+b+1];
 530                     ++b;
 531                     break;
 532                 }
 533             }
 534             for (;buf[b];b++);
 535             classrecog[a++]=&classbuf[tpos+b+1];
 536             for (lsize=tpos+b+1;lsize<size;lsize++)
 537                 if (!classbuf[lsize]) break;
 538             pos=lsize+1;
 539         }
 540         if (classlist[0] &&
 541             (dolistwindow(cfg_string[STR_SELECT_CLASSES_TO_IMPORT],332,72,
 542                 classlist,DLVF_MULTI|DLVF_HIREC,classarray,NULL))) {
 543             for (a=0;a<num;a++) {
 544                 if (classarray[a]) {
 545                     if (!(addfileclass(classlist[a],classtypeid[a],classrecog[a]))) break;
 546                     ret=1;
 547                 }
 548             }
 549         }
 550     }
 551     LFreeRemember(&key);
 552     return(ret);
 553 }
 554
 555 int savefileclasses()
 556 {
 557     struct fileclass *fclass;
 558     BPTR out;
 559     int a;
 560     char f=0,g=1,buf[100];
 561
 562     if (!firstclass) return(1);
 563     if (!classname[0]) strcpy(classname,"PROGDIR:S/DirectoryOpus.CLA");
 564 D(bug("classname: %s\n",classname));
 565     while (!(out=Open(classname,MODE_NEWFILE))) {
 566         lsprintf(buf,cfg_string[STR_SAVE_FAILED],IoErr());
 567         if (!(request(buf))) return(0);
 568     }
 569     fclass=firstclass;
 570     while (fclass) {
 571         if (fclass->type[0]) {
 572             if ((Write(out,fclass->type,(a=strlen(fclass->type))))<a) break;
 573             if (fclass->typeid[0]) {
 574                 Write(out,&g,1);
 575                 if ((Write(out,fclass->typeid,(a=strlen(fclass->typeid))))<a) break;
 576             }
 577         }
 578         Write(out,&f,1);
 579         if (fclass->recognition) {
 580             if ((Write(out,fclass->recognition,(a=(strlen(fclass->recognition)+1))))<a)
 581                 break;
 582         }
 583         else Write(out,&f,1);
 584         fclass=fclass->next;
 585     }
 586     Close(out);
 587     return(1);
 588 }
 589
 590 int addfileclass(type,typeid,recog)
 591 char *type,*typeid,*recog;
 592 {
 593     struct fileclass *fclass,*newclass,*last;
 594
 595     fclass=firstclass;
 596     while (fclass) {
 597         if (LStrCmpI(fclass->type,type)>=0) break;
 598         if (!fclass->next) last=fclass;
 599         fclass=fclass->next;
 600     }
 601     if (!(newclass=AllocMem(sizeof(struct fileclass),MEMF_CLEAR))) return(0);
 602     if (fclass) {
 603         if (fclass->last) {
 604             fclass->last->next=newclass;
 605             newclass->last=fclass->last;
 606         }
 607         else if (fclass==firstclass) firstclass=newclass;
 608         newclass->next=fclass;
 609         fclass->last=newclass;
 610     }
 611     else if (firstclass) {
 612         last->next=newclass;
 613         newclass->last=last;
 614     }
 615     else firstclass=newclass;
 616     strcpy(newclass->type,type);
 617     strcpy(newclass->typeid,typeid);
 618     if (recog && (newclass->recognition=AllocMem(strlen(recog)+1,MEMF_CLEAR)))
 619         strcpy(newclass->recognition,recog);
 620     return(1);
 621 }
 622
 623 void freefileclasses()
 624 {
 625     struct fileclass *fclass,*newclass;
 626
 627     fclass=firstclass;
 628     while (fclass) {
 629         newclass=fclass->next;
 630         freestring(fclass->recognition);
 631         FreeMem(fclass,sizeof(struct fileclass));
 632         fclass=newclass;
 633     }
 634     firstclass=NULL;
 635 }
 636
 637 void removefileclass(fclass)
 638 struct fileclass *fclass;
 639 {
 640     if (fclass->last) fclass->last->next=fclass->next;
 641     if (fclass->next) fclass->next->last=fclass->last;
 642     if (fclass==firstclass) firstclass=fclass->next;
 643     freestring(fclass->recognition);
 644     FreeMem(fclass,sizeof(struct fileclass));
 645 }
 646
 647 char **makeclasslist(key)
 648 struct DOpusRemember **key;
 649 {
 650     char **list;
 651     int count,a;
 652     struct fileclass *fclass;
 653
 654     LFreeRemember(key);
 655     if (!firstclass) return(NULL);
 656     fclass=firstclass;
 657     for (count=0;fclass;count++,fclass=fclass->next);
 658     if (!(list=LAllocRemember(key,(count+1)*4,MEMF_CLEAR))) return(NULL);
 659     fclass=firstclass;
 660     for (a=0;a<count;a++) {
 661         if (list[a]=LAllocRemember(key,40,MEMF_CLEAR)) strcpy(list[a],fclass->type);
 662         fclass=fclass->next;
 663     }
 664     return(list);
 665 }
 666
 667 int readline(buf,pos,buf1,size)
 668 char *buf;
 669 int pos;
 670 char *buf1;
 671 int size;
 672 {
 673     int a;
 674
 675     for (a=0;a<256;a++) {
 676         if (size==pos || buf[pos]==0) {
 677             buf1[a]=0;
 678             if (size==pos) return(-1);
 679             return(pos+1);
 680         }
 681         buf1[a]=buf[pos];
 682         ++pos;
 683     }
 684     buf1[pos]=0;
 685     return(pos);
 686 }
 687
 688 int editfileclass(fclass,new)
 689 struct fileclass *fclass;
 690 int new;
 691 {
 692     int a,b,old,selitem,lasta=-1,x,y,mx,my,off,temp,waitbits,remapp=0,char_w;
 693     ULONG class,sec,mic,oldsec,oldmic;
 694     UWORD code,gadgetid,qual;
 695     struct Gadget *gad;
 696     struct DOpusListView *view;
 697     struct DOpusRemember *key=NULL;
 698     char
 699         *classlist[MAXFUNCS+1],classtype[MAXFUNCS],*displist[MAXFUNCS+1],
 700         *templist,temptype,buf[16];
 701     unsigned char c;
 702
 703     for (a=0;a<MAXFUNCS;a++) {
 704         displist[a]=LAllocRemember(&key,80,MEMF_CLEAR);
 705         classlist[a]=NULL;
 706     }
 707     makeeditclasslist(fclass,classlist,classtype);
 708     dispclasslist(classlist,classtype,displist);
 709
 710     namesinfo.MaxChars=32;
 711     strcpy(edit_namebuf,fclass->type);
 712     strcpy(edit_typeidbuf,fclass->typeid);
 713     edit_funcbuf[0]=0; edit_pathbuf[0]=0;
 714     editclassgadgets[4].Flags&=~SELECTED;
 715
 716     AddGadgetBorders(&key,
 717         &editclassgadgets[2],
 718         4,
 719         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
 720     AddGadgetBorders(&key,
 721         &editclassgadgets[6],
 722         3,
 723         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
 724     AddGadgetBorders(&key,
 725         &editclassgadgets[10],
 726         1,
 727         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
 728     AddGadgetBorders(&key,
 729         &editclassgadgets[12],
 730         2,
 731         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
 732
 733     SetAPen(rp,screen_pens[1].pen);
 734     AddGadgets(Window,
 735         editclassgadgets,
 736         editclassgads,
 737         14,
 738         screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
 739     doglassimage(&editclassgadgets[6]);
 740     doglassimage(&editclassgadgets[8]);
 741     Do3DBox(rp,
 742         x_off+37,y_off+140,
 743         116,12,
 744         screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
 745
 746     fileview_buf=NULL; fileview_lines=fileview_topline=0; fileview_type=1;
 747     char_w = rp->Font->tf_XSize;
 748     draw_file_view();
 749
 750     showclassop(0);
 751     seteditclassgads(0);
 752     setuplist(&editclasslist,7,88);
 753     editclasslist.topitem=0; editclasslist.itemselected=-1;
 754     editclasslist.items=displist;
 755     AddListView(&editclasslist,1);
 756     initsidegads(editfuncgads,0,0);
 757     ClearMenuStrip(Window);
 758     Window->Flags|=WFLG_RMBTRAP;
 759     selitem=-1;
 760     if (new) ActivateStrGad(&editclassgadgets[0],Window);
 761     oldsec=oldmic=0;
 762
 763     if (!appobject) {
 764         add_appobject(0);
 765         remapp=1;
 766     }
 767
 768     waitbits=1<<Window->UserPort->mp_SigBit;
 769     if (appobject) waitbits|=1<<appport->mp_SigBit;
 770
 771     FOREVER {
 772         if (appobject) {
 773             while (appmsg=(struct AppMessage *)GetMsg(appport)) {
 774                 ActivateWindow(Window);
 775                 if (appmsg->am_ID==MY_APPOBJECT &&
 776                     appmsg->am_NumArgs>0 &&
 777                     (*appmsg->am_ArgList[0].wa_Name)) {
 778                     PathName(appmsg->am_ArgList[0].wa_Lock,edit_pathbuf,256);
 779                     TackOn(edit_pathbuf,appmsg->am_ArgList[0].wa_Name,256);
 780                     RefreshStrGad(&editclassgadgets[9],Window);
 781                     load_file_view();
 782                 }
 783                 ReplyMsg((struct Message *)appmsg);
 784             }
 785         }
 786         while (IMsg=getintuimsg()) {
 787             if ((view=ListViewIDCMP(&editclasslist,IMsg))==(struct DOpusListView *)-1) {
 788                 class=IMsg->Class; code=IMsg->Code; qual = IMsg->Qualifier;
 789                 mx=IMsg->MouseX; my=IMsg->MouseY;
 790                 sec=IMsg->Seconds; mic=IMsg->Micros;
 791                 if (class==IDCMP_GADGETUP || class==IDCMP_GADGETDOWN) {
 792                     gad=(struct Gadget *)IMsg->IAddress;
 793                     gadgetid=gad->GadgetID;
 794                 }
 795                 ReplyMsg((struct Message *)IMsg);
 796                 switch (class) {
 797                     case IDCMP_MOUSEBUTTONS:
 798                         if (code!=SELECTDOWN ||
 799                             mx<x_off+11 || mx>x_off+505 ||
 800                             my<y_off+21 || my>x_off+68) break;
 801                         if (oldsec && DoubleClick(oldsec,oldmic,sec,mic)) off=1;
 802                         else off=0;
 803                         oldsec=sec; oldmic=mic;
 804                         FOREVER {
 805                             if (my>y_off+20 && my<y_off+69) {
 806
 807                                 x=((mx-x_off-11)/char_w)-10;
 808                                 if (x<0) x=0;
 809                                 if (x<36) {
 810                                     if ((x%9)==8) --x;
 811                                     a=x/9; x=(a*4)+((x%9)/2);
 812                                 }
 813                                 else if (x>35) {
 814                                     x-=36;
 815                                     if (x>15) x=15;
 816                                 }
 817
 818                                 y=((my-y_off-21)/8)+fileview_topline;
 819                                 if (y<fileview_topline) y=fileview_topline;
 820
 821                                 if (off) {
 822                                     a=(y*16)+x;
 823                                     if (a==fileview_position) {
 824                                         old=fileview_offset;
 825                                         if ((fileview_offset=a)<0 ||
 826                                             fileview_offset>=fileview_size) fileview_offset=-1;
 827                                         a=0; b=1;
 828                                     }
 829                                     else {
 830                                         a=-1;
 831                                         off=0;
 832                                     }
 833                                 }
 834                                 else {
 835                                     old=fileview_position;
 836                                     if ((fileview_position=(y*16)+x)<0 ||
 837                                         fileview_position>=fileview_size) fileview_position=-1;
 838                                     a=fileview_position; b=0;
 839                                     if (fileview_offset>fileview_position) show_view_number(-1,1);
 840                                     else if (fileview_offset>-1)
 841                                         show_view_number(fileview_position-fileview_offset,1);
 842                                 }
 843                                 if (a>-1 && a!=old) {
 844                                     fileview_oldtop=-1;
 845                                     show_file_view();
 846                                     show_view_number(a,b);
 847                                 }
 848                             }
 849                             if (off) break;
 850                             class=0;
 851                             while (IMsg=getintuimsg()) {
 852                                 if (IMsg->Class==IDCMP_MOUSEMOVE || IMsg->Class==IDCMP_MOUSEBUTTONS)
 853                                     class=IMsg->Class;
 854                                 code=IMsg->Code;
 855                                 ReplyMsg((struct Message *)IMsg);
 856                                 if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP) break;
 857                             }
 858                             if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP) break;
 859                             mx=Window->MouseX;
 860                             my=Window->MouseY;
 861                             if (my<y_off+21) {
 862                                 my=y_off+21;
 863                                 if (fileview_topline>0) {
 864                                     --fileview_topline; fileview_oldtop=fileview_position=-1;
 865                                     show_file_view();
 866                                     FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
 867                                 }
 868                             }
 869                             else if (my>y_off+68) {
 870                                 my=y_off+68;
 871                                 if (fileview_topline<fileview_lines-6) {
 872                                     ++fileview_topline; fileview_oldtop=fileview_position=-1;
 873                                     show_file_view();
 874                                     FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
 875                                 }
 876                             }
 877                             else if (class!=IDCMP_MOUSEMOVE) Wait(1<<Window->UserPort->mp_SigBit);
 878                         }
 879                         break;
 880
 881                     case IDCMP_RAWKEY:
 882                         switch (code) {
 883                             case CURSORUP:
 884                                 if (fileview_position>15) cursor_fileview(-16);
 885                                 break;
 886                             case CURSORDOWN:
 887                                 if (fileview_position<fileview_size-16) cursor_fileview(16);
 888                                 break;
 889                             case CURSORLEFT:
 890                                 if (fileview_position) cursor_fileview(-1);
 891                                 break;
 892                             case CURSORRIGHT:
 893                                 if (fileview_position<fileview_size-1) cursor_fileview(1);
 894                                 break;
 895                             default:
 896                              {
 897                               buf[0]=0;
 898                               RawkeyToStr(code,qual,NULL,buf,10);
 899                               c = LToLower(buf[0]);
 900                               if (c == getkeyshortcut(cfg_string[STR_EDITCLASS_FILECLASS]))
 901                                 ActivateStrGad(&editclassgadgets[0],Window);
 902                               else if (c == getkeyshortcut(cfg_string[STR_EDITCLASS_CLASSID]))
 903                                 ActivateStrGad(&editclassgadgets[1],Window);
 904                               else if (c == getkeyshortcut(cfg_string[STR_EDITCLASS_FILEVIEWER]))
 905                                 goto getfileview;
 906                              }
 907                         }
 908                         break;
 909
 910                     case IDCMP_GADGETDOWN:
 911                         switch (gadgetid) {
 912                             case CLASS_VIEWUP:
 913                             case CLASS_VIEWDOWN:
 914                             case CLASS_VIEWSLIDER:
 915                                 temp=0;
 916                                 FOREVER {
 917                                     if (gadgetid==CLASS_VIEWUP) {
 918                                         if (fileview_topline==0) break;
 919                                         --fileview_topline;
 920                                     }
 921                                     else if (gadgetid==CLASS_VIEWDOWN) {
 922                                         if (fileview_topline>=fileview_lines-6) break;
 923                                         ++fileview_topline;
 924                                     }
 925                                     else {
 926                                         fileview_topline=GetSliderPos(&editclassgadgets[11],fileview_lines,6);
 927                                     }
 928                                     if (fileview_topline!=fileview_oldtop) show_file_view();
 929                                     if (gadgetid!=CLASS_VIEWSLIDER) {
 930                                         FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
 931                                         if (!temp++) Delay(10);
 932                                     }
 933                                     while (IMsg=getintuimsg()) {
 934                                         class=IMsg->Class; code=IMsg->Code;
 935                                         ReplyMsg((struct Message *)IMsg);
 936                                         if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP)
 937                                             class=IDCMP_GADGETUP;
 938                                         if (class==IDCMP_GADGETUP) break;
 939                                     }
 940                                     if (class==IDCMP_GADGETUP) break;
 941                                 }
 942                                 ShowSlider(Window,&editclassgadgets[11]);
 943                                 break;
 944                         }
 945                         break;
 946
 947                     case IDCMP_GADGETUP:
 948                         switch (gadgetid) {
 949                             case CLASS_OKAY:
 950                                 makeclassrecog(fclass,classlist,classtype);
 951                                 strcpy(fclass->type,edit_namebuf);
 952                                 strcpy(fclass->typeid,edit_typeidbuf);
 953                             case CLASS_CANCEL:
 954                                 if (editclassgadgets[3].Flags&GFLG_DISABLED) seteditclassgads(1);
 955                                 RemoveListView(&editclasslist,1);
 956                                 LFreeRemember(&key);
 957                                 freefunclist(classlist);
 958                                 Window->Flags&=~WFLG_RMBTRAP;
 959                                 FSSetMenuStrip(Window,&projectmenu);
 960                                 if (remapp) rem_appobject(0);
 961                                 return((gadgetid==CLASS_OKAY));
 962
 963                             case CLASS_OPERATION:
 964                                 checkclassswap();
 965                                 if ((a=funcrequester(FREQ_FILETYPE,
 966                                     NULL,cfg_string[STR_LIST_OF_FILETYPE_COMMANDS]))) {
 967                                     classtype[selitem]=a;
 968                                     showclassop(classtype[selitem]);
 969                                     ActivateStrGad(&editclassgadgets[7],Window);
 970                                 }
 971                                 break;
 972
 973                             case CLASS_DELETE:
 974                                 edit_funcbuf[0]=0; classtype[selitem]=0;
 975                             case CLASS_FUNC:
 976                                 lasta=-1;
 977                             case CLASS_NEWENTRY:
 978                                 checkclassswap();
 979                                 a=-1;
 980                                 if (selitem>-1) {
 981                                     if (gadgetid==CLASS_NEWENTRY && !edit_funcbuf[0]) {
 982                                         ActivateStrGad(&editclassgadgets[7],Window);
 983                                         break;
 984                                     }
 985                                     editclasslist.itemselected=-1;
 986                                     if (!edit_funcbuf[0]) lasta=-1;
 987                                     endclassedit(selitem,classlist,classtype,displist);
 988                                     if (lasta==-1) a=selitem;
 989                                     else a=lasta+1;
 990                                     selitem=-1;
 991                                 }
 992                                 if (gadgetid==CLASS_NEWENTRY) {
 993                                     if (editclasslist.count>=MAXFUNCS) break;
 994                                     if (a>-1) selitem=a;
 995                                     else {
 996                                         selitem=editclasslist.count;
 997                                         seteditclassgads(1);
 998                                     }
 999                                     insertnewclass(classlist,classtype,selitem,displist," ",2);
1000                                     lasta=selitem;
1001                                 }
1002                                 else seteditclassgads(0);
1003                                 break;
1004
1005                             case CLASS_DUPLICATE:
1006                                 checkclassswap();
1007                                 if (editclasslist.count>=MAXFUNCS || !edit_funcbuf[0]) {
1008                                     ActivateStrGad(&editclassgadgets[7],Window);
1009                                     break;
1010                                 }
1011                                 editclasslist.itemselected=-1;
1012                                 endclassedit(selitem,classlist,classtype,displist);
1013                                 a=selitem; selitem=editclasslist.count;
1014                                 insertnewclass(classlist,classtype,selitem,displist,classlist[a],classtype[a]);
1015                                 break;
1016
1017                             case CLASS_FILEVIEWREQ:
1018 getfileview:
1019                                 if (!(funcrequester(FREQ_GENERIC,edit_pathbuf,NULL))) break;
1020                                 RefreshStrGad(&editclassgadgets[9],Window);
1021                             case CLASS_FILEVIEW:
1022                                 if (code!=0x9) load_file_view();
1023                                 break;
1024                             case CLASS_HEXDEC:
1025                                 fileview_type=1-fileview_type;
1026                                 DoCycleGadget(&editclassgadgets[10],Window,fileview_types,fileview_type);
1027                                 show_view_number(fileview_position,0);
1028                                 if (fileview_offset>fileview_position) show_view_number(-1,1);
1029                                 else if (fileview_offset>-1)
1030                                     show_view_number(fileview_position-fileview_offset,1);
1031                                 break;
1032                             case CLASS_TYPE:
1033                                 ActivateStrGad(&editclassgadgets[1],Window);
1034                                 break;
1035                             case CLASS_TYPEID:
1036                                 StrToUpper(edit_typeidbuf,edit_typeidbuf);
1037                                 RefreshStrGad(&editclassgadgets[1],Window);
1038                                 break;
1039                         }
1040                         break;
1041                 }
1042             }
1043             else if (view) {
1044                 do {
1045                     if (selitem!=-1) {
1046                         endclassedit(selitem,classlist,classtype,displist);
1047                         if (editclassgadgets[4].Flags&SELECTED) {
1048                             checkclassswap();
1049                             seteditclassgads(0);
1050                             templist=classlist[selitem];
1051                             classlist[selitem]=classlist[view->itemselected];
1052                             classlist[view->itemselected]=templist;
1053                             temptype=classtype[selitem];
1054                             classtype[selitem]=classtype[view->itemselected];
1055                             classtype[view->itemselected]=temptype;
1056                             dispclasslist(classlist,classtype,displist);
1057                             editclasslist.itemselected=-1;
1058                             RefreshListView(&editclasslist,1);
1059                             selitem=-1;
1060                             break;
1061                         }
1062                     }
1063                     else seteditclassgads(1);
1064                     selitem=view->itemselected;
1065                     if (classlist[selitem]) strcpy(edit_funcbuf,classlist[selitem]);
1066                     else edit_funcbuf[0]=0;
1067 //kprintf("selitem: %ld\tedit_funcbuf: %s\n",selitem,edit_funcbuf);
1068                     RefreshStrGad(&editclassgadgets[7],Window);
1069                     showclassop(classtype[selitem]);
1070                     ActivateStrGad(&editclassgadgets[7],Window);
1071                 }
1072                 while (0);
1073             }
1074         }
1075         Wait(waitbits);
1076     }
1077 }
1078
1079 void makeeditclasslist(class,classlist,classtype)
1080 struct fileclass *class;
1081 char **classlist,*classtype;
1082 {
1083     int a,b,len,type,pos,num;
1084     char buf[256];
1085
1086     if (!class->recognition) return;
1087     len=strlen(class->recognition);
1088     type=-1; pos=num=0;
1089     for (a=0;a<=len;a++) {
1090         if (type==-1) {
1091             if (class->recognition[a]<FTYC_COMMANDOK) {
1092                 type=class->recognition[a];
1093                 continue;
1094             }
1095             if (class->recognition[a]>FTYC_ENDLIMIT &&
1096                 class->recognition[a]<FTYC_ENDSECTION) {
1097 doandor:
1098                 classlist[num]=getcopy(" ",2,NULL);
1099                 for (b=0;b<12;b++) {
1100                     if (classopvals[b]==class->recognition[a]) {
1101                         classtype[num]=b+1;
1102                         break;
1103                     }
1104                 }
1105                 if ((++num)==MAXFUNCS) break;
1106             }
1107         }
1108         else if (pos==255 || class->recognition[a]>FTYC_ENDLIMIT ||
1109             !class->recognition[a]) {
1110             buf[pos]=0;
1111             if (classlist[num]=getcopy(buf,-1,NULL)) {
1112                 for (b=0;b<12;b++) {
1113                     if (classopvals[b]==type) {
1114                         classtype[num]=b+1;
1115                         break;
1116                     }
1117                 }
1118                 if ((++num)==MAXFUNCS) break;
1119             }
1120             pos=0; type=-1;
1121             if (class->recognition[a]>FTYC_ENDLIMIT &&
1122                 class->recognition[a]<FTYC_ENDSECTION) goto doandor;
1123         }
1124         else buf[pos++]=class->recognition[a];
1125     }
1126     for (a=num;a<MAXFUNCS;a++) classlist[a]=NULL;
1127 }
1128
1129 void dispclasslist(classlist,classtype,displist)
1130 char **classlist,*classtype,**displist;
1131 {
1132     int a;
1133     char buf[80],*ptr;
1134
1135     for (a=0;a<MAXFUNCS;a++) {
1136         if (!classlist[a]) break;
1137         strcpy(buf,classopslist[classtype[a]-1]);
1138         ptr=strchr(buf,' '); *ptr=0;
1139         StrCombine(displist[a],buf,spacestring,15);
1140         if (classopvals[classtype[a]-1]<FTYC_COMMANDOK) StrConcat(displist[a],classlist[a],75);
1141     }
1142     for (;a<MAXFUNCS;a++) displist[a][0]=0;
1143 }
1144
1145 void seteditclassgads(on)
1146 int on;
1147 {
1148     int a;
1149
1150     if (on) {
1151         for (a=3;a<6;a++) EnableGadget(&editclassgadgets[a],rp,4,2);
1152         EnableGadget(&editclassgadgets[6],rp,4,2);
1153         EnableGadget(&editclassgadgets[7],rp,0,0);
1154     }
1155     else {
1156         for (a=3;a<6;a++) DisableGadget(&editclassgadgets[a],rp,4,2);
1157         DisableGadget(&editclassgadgets[6],rp,4,2);
1158         DisableGadget(&editclassgadgets[7],rp,0,0);
1159     }
1160 }
1161
1162 void removeclassentry(classlist,classtype,entry)
1163 char **classlist,*classtype;
1164 int entry;
1165 {
1166     if (entry<MAXFUNCS-1) {
1167         CopyMem(&classlist[entry+1],&classlist[entry],(MAXFUNCS-1-entry)*4);
1168         CopyMem(&classtype[entry+1],&classtype[entry],(MAXFUNCS-1-entry));
1169     }
1170     classlist[MAXFUNCS-1]=NULL;
1171 }
1172
1173 void insertnewclass(classlist,classtype,entry,displist,string,type)
1174 char **classlist,*classtype;
1175 int entry;
1176 char **displist,*string;
1177 int type;
1178 {
1179     char *templist[MAXFUNCS],temptype[MAXFUNCS];
1180     int a;
1181
1182     a=MAXFUNCS-entry-1;
1183     CopyMem(&classlist[entry],templist,a*4);
1184     CopyMem(templist,&classlist[entry+1],a*4);
1185     classlist[entry]=getcopy(string,-1,NULL);
1186     CopyMem(&classtype[entry],temptype,a);
1187     CopyMem(temptype,&classtype[entry+1],a);
1188     classtype[entry]=type;
1189     dispclasslist(classlist,classtype,displist);
1190     if (entry<editclasslist.topitem ||
1191         entry>=editclasslist.topitem+editclasslist.lines) editclasslist.topitem=entry;
1192     editclasslist.itemselected=entry;
1193     RefreshListView(&editclasslist,1);
1194     if (string[0]==' ' && string[1]==0) edit_funcbuf[0]=0;
1195     else strcpy(edit_funcbuf,string);
1196     RefreshStrGad(&editclassgadgets[7],Window);
1197     showclassop(type);
1198     ActivateStrGad(&editclassgadgets[7],Window);
1199 }
1200
1201 void endclassedit(item,classlist,classtype,displist)
1202 int item;
1203 char **classlist,*classtype,**displist;
1204 {
1205 //kprintf("classtype[item]: %ld\tbuf: %s\n",classtype[item],edit_funcbuf);
1206     freestring(classlist[item]);
1207     if (classtype[item]<1 || classopvals[classtype[item]-1]<FTYC_COMMANDOK) {
1208         if (edit_funcbuf[0]) classlist[item]=getcopy(edit_funcbuf,-1,NULL);
1209         else removeclassentry(classlist,classtype,item);
1210     }
1211     else classlist[item]=getcopy(" ",2,NULL);
1212     dispclasslist(classlist,classtype,displist);
1213     RefreshListView(&editclasslist,1);
1214     edit_funcbuf[0]=0;
1215     RefreshStrGad(&editclassgadgets[7],Window);
1216     showclassop(0);
1217 }
1218
1219 void makeclassrecog(class,classlist,classtype)
1220 struct fileclass *class;
1221 unsigned char **classlist,*classtype;
1222 {
1223     int size,num,a;
1224     unsigned char *buf,buf2[2];
1225
1226     size=num=0;
1227     for (a=0;a<MAXFUNCS;a++) {
1228         if (!classlist[a]) break;
1229         size+=strlen(classlist[a])+2;
1230         ++num;
1231     }
1232     freestring(class->recognition); class->recognition=NULL;
1233     if (!size) return;
1234     if (!(buf=AllocMem(size+2,MEMF_CLEAR))) return;
1235     buf2[1]=0;
1236     for (a=0;a<num;a++) {
1237         buf2[0]=classopvals[classtype[a]-1];
1238         strcat(buf,buf2);
1239         if (buf2[0]<FTYC_COMMANDOK) {
1240             strcat(buf,classlist[a]);
1241             if (a==(num-1) || classopvals[classtype[a+1]-1]<FTYC_COMMANDOK) {
1242                 buf2[0]=FTYC_ENDSECTION;
1243                 strcat(buf,buf2);
1244             }
1245         }
1246     }
1247     class->recognition=getcopy(buf,-1,NULL);
1248     FreeMem(buf,size+2);
1249 }
1250
1251 void checkclassswap()
1252 {
1253     if (editclassgadgets[4].Flags&SELECTED) {
1254         editclassgadgets[4].Flags&=~SELECTED;
1255         select_gadget(&editclassgadgets[4],0);
1256     }
1257 }
1258
1259 void showclassop(op)
1260 int op;
1261 {
1262     char str[80],*ptr;
1263     int x,a;
1264
1265     SetAPen(rp,screen_pens[0].pen);
1266     RectFill(rp,
1267         x_off+37,y_off+140,
1268         x_off+152,y_off+151);
1269     SetAPen(rp,screen_pens[1].pen);
1270     if (op<1) ptr="----";
1271     else {
1272         strcpy(str,classopslist[op-1]);
1273         ptr=strchr(str,' '); *ptr=0;
1274         ptr=str;
1275     }
1276     a=strlen(ptr);
1277     x=((116-(a*8))/2)+x_off+37;
1278     Move(rp,x,y_off+148);
1279     Text(rp,ptr,a);
1280 }
1281
1282 struct fileclass *getfileclasslist(type)
1283 int type;
1284 {
1285     struct DOpusRemember *key=NULL;
1286     int a;
1287     struct fileclass *fclass=NULL;
1288
1289     fileclasslist=makeclasslist(&key);
1290     if ((a=funcrequester(FREQ_FILECLASS,NULL,fileclasstype[type]))) {
1291         fclass=firstclass;
1292         while ((--a) && fclass && fclass->next) fclass=fclass->next;
1293     }
1294     LFreeRemember(&key);
1295     return(fclass);
1296 }
1297
1298 void draw_file_view()
1299 {
1300     int a;
1301
1302     SetAPen(rp,screen_pens[0].pen);
1303     RectFill(rp,
1304         y_off+7,y_off+21,
1305         x_off+511,y_off+68);
1306     do3dbox(x_off+7,y_off+21,505,48);
1307     Do3DBox(rp,
1308         x_off+534,y_off+31,
1309         91,12,
1310         screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
1311     Do3DBox(rp,
1312         x_off+534,y_off+57,
1313         91,12,
1314         screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
1315     SetAPen(rp,screen_pens[1].pen);
1316     UScoreText(rp,
1317         cfg_string[STR_POSITION],
1318         x_off+535,y_off+27,
1319         -1);
1320     UScoreText(rp,
1321         cfg_string[STR_OFFSET],
1322         x_off+535,y_off+53,
1323         -1);
1324     for (a=0;a<2;a++)
1325         DoArrow(rp,
1326             editclassgadgets[12+a].LeftEdge+2,editclassgadgets[12+a].TopEdge+1,
1327             12,6,
1328             screen_pens[1].pen,screen_pens[0].pen,a);
1329     fix_slider(&editclassgadgets[11]);
1330     FixSliderBody(Window,&editclassgadgets[11],fileview_lines,6,0);
1331     FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,0);
1332     ShowSlider(Window,&editclassgadgets[11]);
1333     DoCycleGadget(&editclassgadgets[10],Window,fileview_types,fileview_type);
1334 }
1335
1336 void free_file_view()
1337 {
1338     int a;
1339
1340     if (fileview_buf) {
1341         FreeMem(fileview_buf,fileview_size);
1342         fileview_buf=NULL;
1343     }
1344     fileview_size=fileview_lines=fileview_topline=0;
1345     fileview_oldtop=fileview_offset=fileview_position=-1;
1346     for (a=0;a<2;a++) show_view_number(-1,a);
1347 }
1348
1349 void load_file_view()
1350 {
1351     BPTR file;
1352     int rsize;
1353
1354     free_file_view();
1355     busy();
1356     if ((CheckExist(edit_pathbuf,&fileview_size))<0 &&
1357         (file=Open(edit_pathbuf,MODE_OLDFILE))) {
1358         if (fileview_size>4096) fileview_size=4096;
1359         else if (fileview_size%16) fileview_size=((fileview_size+15)/16)*16;
1360         if (fileview_buf=AllocMem(fileview_size,MEMF_CLEAR)) {
1361             rsize=Read(file,fileview_buf,fileview_size);
1362             fileview_lines=(rsize+15)/16;
1363         }
1364         Close(file);
1365     }
1366     draw_file_view();
1367     if (!fileview_buf) {
1368         DisplayBeep(NULL);
1369         file_view_text(cfg_string[STR_FILE_NOT_FOUND],0);
1370     }
1371     else show_file_view();
1372     unbusy();
1373 }
1374
1375 void file_view_text(txt,line)
1376 char *txt;
1377 int line;
1378 {
1379     int len;
1380
1381     SetAPen(rp,screen_pens[1].pen);
1382     SetBPen(rp,screen_pens[0].pen);
1383     Move(rp,x_off+9,y_off+27+(line*8));
1384     if (txt) Text(rp,txt,(len=strlen(txt)));
1385     else len=0;
1386     if (len<62) Text(rp,spacestring,62-len);
1387 }
1388
1389 void show_file_view(void)
1390 {
1391     int line,a,off,old,top,bottom,scroll,ox,px,aox,apx,char_w;
1392     char buf[80],buf2[30];
1393
1394     top=0; bottom=5; scroll=0;
1395     if (fileview_oldtop>-1) {
1396         if ((a=fileview_topline-fileview_oldtop)>0 && a<6) {
1397             top=6-a;
1398             scroll=a*8;
1399         }
1400         else if (a<0 && a>-6) {
1401             bottom=-a-1;
1402             scroll=a*8;
1403         }
1404     }
1405     char_w = rp->Font->tf_XSize;
1406     SetDrMd(rp,JAM2);
1407
1408     for (line=0;line<6;line++) {
1409         if (line>=top && line<=bottom) {
1410             if (scroll) {
1411                 ScrollRaster(rp,0,scroll,x_off+7,y_off+21,x_off+511,y_off+68);
1412                 scroll=0;
1413             }
1414             if (fileview_lines<=line+fileview_topline) file_view_text(NULL,line);
1415             else {
1416                 off=(fileview_topline+line)*16;
1417                 lsprintf(buf,"%08lx: ",(long unsigned int)off);
1418                 old=off; ox=px=-1;
1419                 for (a=0;a<4;a++) {
1420 /*                    lsprintf(buf2,"%02lx%02lx%02lx%02lx ",
1421                         fileview_buf[off++],fileview_buf[off++],fileview_buf[off++],fileview_buf[off++]);
1422 */
1423                     lsprintf(buf2,"%08lx ",*((long *)(fileview_buf+off)));
1424                     off += 4;
1425
1426                     strcat(buf,buf2);
1427                     if (px==-1 && fileview_position>=off-4 && fileview_position<off) {
1428                         apx=fileview_position-(off-4);
1429                         px=(a*9)+(apx*2); apx+=(a*4)+36;
1430                     }
1431                     if (ox==-1 && fileview_offset>=off-4 && fileview_offset<off) {
1432                         aox=fileview_offset-(off-4);
1433                         ox=(a*9)+(aox*2); aox+=(a*4)+36;
1434                     }
1435                 }
1436                 off=old;
1437                 for (a=0;a<16;a++,off++)
1438                     buf[46+a]=(isprint(fileview_buf[off]))?fileview_buf[off]:'.';
1439                 buf[62]=0;
1440                 file_view_text(buf,line);
1441                 if (px>-1 && px!=ox) {
1442                     SetDrMd(rp,COMPLEMENT);
1443                     RectFill(rp,
1444                         x_off+9+(10+px)*char_w,y_off+21+(line*8),
1445                         x_off+8+(12+px)*char_w,y_off+28+(line*8));
1446                     RectFill(rp,
1447                         x_off+9+(10+apx)*char_w,y_off+21+(line*8),
1448                         x_off+8+(11+apx)*char_w,y_off+28+(line*8));
1449                     SetDrMd(rp,JAM2);
1450                 }
1451                 if (ox>-1) {
1452                     SetAPen(rp,screen_pens[2].pen);
1453                     lsprintf(buf2,"%02lx",(long unsigned int)fileview_buf[fileview_offset]);
1454                     Move(rp,x_off+9+(10+ox)*char_w,y_off+27+(line*8));
1455                     Text(rp,buf2,2);
1456                     buf2[0]=(isprint(fileview_buf[fileview_offset])?fileview_buf[fileview_offset]:'.');
1457                     Move(rp,x_off+9+(10+aox)*char_w,y_off+27+(line*8));
1458                     Text(rp,buf2,1);
1459                     SetAPen(rp,screen_pens[1].pen);
1460                 }
1461             }
1462         }
1463     }
1464     fileview_oldtop=fileview_topline;
1465 }
1466
1467 void show_view_number(num,pos)
1468 int num,pos;
1469 {
1470     char buf[20];
1471     int y;
1472
1473     if (num<0) {
1474         SetAPen(rp,screen_pens[0].pen);
1475         RectFill(rp,
1476             x_off+534,y_off+31+(26*pos),
1477             x_off+624,y_off+42+(26*pos));
1478         SetAPen(rp,screen_pens[1].pen);
1479     }
1480     else {
1481         y=y_off+39+(26*pos);
1482         if (fileview_type==0) lsprintf(buf,"$%08lx",(long unsigned int)num);
1483         else lsprintf(buf,"%09ld",(long int)num);
1484         UScoreText(rp,buf,x_off+543,y,-1);
1485     }
1486 }
1487
1488 void cursor_fileview(delta)
1489 int delta;
1490 {
1491     int ups=0;
1492
1493     fileview_position+=delta;
1494     if (fileview_position<0) fileview_position=0;
1495     else if (fileview_position>=fileview_size) fileview_position=fileview_size-1;
1496
1497     if (fileview_position<(fileview_topline*16)) {
1498         fileview_oldtop=-1;
1499         while (fileview_position<(fileview_topline*16)) {
1500             if (!fileview_topline) break;
1501             --fileview_topline;
1502         }
1503         ups=1;
1504     }
1505     else if (fileview_position>=((fileview_topline+6)*16)) {
1506         fileview_oldtop=-1;
1507         while (fileview_position>=((fileview_topline+6)*16)) {
1508             if (fileview_topline>=fileview_lines-6) break;
1509             ++fileview_topline;
1510         }
1511         ups=1;
1512     }
1513     show_file_view();
1514     show_view_number(fileview_position,0);
1515     if (fileview_offset>fileview_position) show_view_number(-1,1);
1516     else if (fileview_offset>-1)
1517         show_view_number(fileview_position-fileview_offset,1);
1518     if (ups) FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
1519 }