/*

Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.

The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.

*/

#include "config.h"

dofiletypeconfig()
{
    ULONG class;
    USHORT code,gadgetid;
    struct ConfigUndo *undo;
    struct DOpusRemember *key;
    struct DOpusListView *view;
    struct dopusfiletype *type,*tpos,*type1;
    struct fileclass *fclass,classbuf;
    int mode=-1,a,classchange=0;
    char **listptr,buf[256],*ptr;

    key=NULL; type1=NULL; firstclass=NULL;
    filetypeactionlist.items=NULL;
    filetypeactionlist.topitem=0;
    showconfigscreen(CFG_FILETYPE);
    ClearMenuStrip(Window);
    projectmenu.NextMenu=&classmenu;
    FSSetMenuStrip(Window,&projectmenu);
    listptr=makefiletypelist(&key);
    undo=makeundo(UNDO_FILETYPE);
    showtypelist(listptr);
    busy();
    readfileclasses();
    unbusy();

    FOREVER {
        Wait(1<<Window->UserPort->mp_SigBit);
        while (IMsg=getintuimsg()) {
            if ((view=ListViewIDCMP(&filetypeactionlist,IMsg))==(struct DOpusListView *)-1) {
                class=IMsg->Class; code=IMsg->Code;
                if (class==GADGETUP || class==GADGETDOWN)
                    gadgetid=((struct Gadget *)IMsg->IAddress)->GadgetID;
                ReplyMsg((struct Message *)IMsg);
                switch (class) {
                    case MENUPICK:
                        if (code==MENUNULL) break;
                        switch (MENUNUM(code)) {
                            case 0:
                                if (type1) {
                                    showtypelist(listptr);
                                    type1=NULL;
                                }
                                if (mode>-1) {
                                    select_gadget(&maingad[mode],0);
                                    mode=-1;
                                }
                                dogadgetinfo(NULL);
                                switch ((a=ITEMNUM(code))) {
                                    case 0:
                                    case 1:
                                        if (doload(CFG_FILETYPE,a)) {
                                            listptr=makefiletypelist(&key);
                                            showtypelist(listptr);
                                            if (a) dogadgetinfo(cfg_string[STR_NEW_FILETYPES_MERGED]);
                                            else dogadgetinfo(cfg_string[STR_DEFAULT_FILETYPES_MERGED]);
                                        }
                                        break;
                                }
                                break;
                            case 1:
                                switch (ITEMNUM(code)) {
                                    case 0:
                                        classbuf.type[0]=0;
                                        classbuf.typeid[0]=0;
                                        classbuf.recognition=NULL;
                                        classbuf.next=classbuf.last=NULL;
                                        if (editclass(&classbuf,1)) classchange=1;
                                        break;
                                    case 1:
                                        if (!(fclass=getfileclasslist(1))) break;
                                        if (editclass(fclass,0)) classchange=1;
                                        break;
                                    case 2:
                                        if (!(fclass=getfileclasslist(3))) break;
                                        CopyMem((char *)fclass,(char *)&classbuf,sizeof(struct fileclass));
                                        classbuf.recognition=getcopy(fclass->recognition,-1,NULL);
                                        classbuf.next=classbuf.last=NULL;
                                        if (editclass(&classbuf,1)) classchange=1;
                                        break;
                                    case 3:
                                        if (!(fclass=getfileclasslist(2))) break;
                                        lsprintf(buf,"\"%s\"\n%s",
                                            fclass->type,cfg_string[STR_REALLY_DELETE_THIS_CLASS]);
                                        if (request(buf)) {
                                            dogadgetinfo(cfg_string[STR_FILE_CLASS_DELETED]);
                                            removefileclass(fclass);
                                            classchange=1;
                                        }
                                        else dogadgetinfo(NULL);
                                        break;
                                    case 5:
                                        if (importfileclasses()) classchange=1;
                                        break;
                                    case 6:
                                        busy();
                                        if (savefileclasses()) classchange=0;
                                        unbusy();
                                        break;
                                    case 7:
                                        strcpy(dirbuf,classname);
                                        if (ptr=BaseName(dirbuf)) {
                                            strcpy(filebuf,ptr);
                                            *ptr=0;
                                        }
                                        else filebuf[0]=0;
                                        filereq.flags=0;
                                        filereq.title=cfg_string[STR_ENTER_NAME_TO_SAVE_CLASSES];
                                        filereq.window=Window;
                                        if (!(FileRequest(&filereq)) || !filebuf[0]) break;
                                        strcpy(classname,dirbuf);
                                        TackOn(classname,filebuf,256);
                                        busy();
                                        if (savefileclasses()) classchange=0;
                                        unbusy();
                                        break;
                                    case 8:
                                        if (firstclass && (request(cfg_string[STR_ERASE_ALL_CLASSES]))) {
                                            freefileclasses();
                                            classchange=0;
                                        }
                                        break;
                                }
                                break;
                        }
                        break;
                    case GADGETUP:
                        if (gadgetid<FILETYPE_OKAY) {
                            if (type1) {
                                showtypelist(listptr);
                                type1=NULL;
                            }
                            if (mode==gadgetid) {
                                mode=-1;
                                dogadgetinfo(NULL);
                                break;
                            }
                            if (mode>-1) {
                                select_gadget(&maingad[mode],0);
                            }
                        }
                        switch (gadgetid) {
                            case FILETYPE_OKAY:
                            case FILETYPE_CANCEL:
                                if (classchange && !(request(cfg_string[STR_EXIT_WITHOUT_SAVING_CLASSES])))
                                    break;
                                if (gadgetid==FILETYPE_CANCEL) doundo(undo,UNDO_FILETYPE);
                                doundo(undo,0);
                                RemoveListView(&filetypeactionlist,1);
                                LFreeRemember(&key);
                                freefileclasses();
                                ClearMenuStrip(Window); projectmenu.NextMenu=NULL;
                                FSSetMenuStrip(Window,&projectmenu);
                                return((gadgetid==FILETYPE_OKAY));
                            case FILETYPE_NEW:
                                if (!(fclass=getfileclasslist(0))) break;
                                type=firsttype;
                                while (type) {
                                    if (strcmp(type->type,fclass->type)==0) break;
                                    type=type->next;
                                }
                                if (!type || request(cfg_string[STR_REDEFINE_EXISTING_CLASS_ACTION])) {
                                    if (type=AllocMem(sizeof(struct dopusfiletype),MEMF_CLEAR)) {
                                        strcpy(type->type,fclass->type);
                                        strcpy(type->typeid,fclass->typeid);
                                        type->recognition=getcopy(fclass->recognition,-1,&typekey);
                                        for (a=0;a<4;a++) {
                                            type->stack[a]=4000;
                                            type->delay[a]=2;
                                        }
                                        if (editfiletype(type,&key,1)) {
                                            if (tpos=(struct dopusfiletype *)
                                                    getcopy((char *)type,sizeof(struct dopusfiletype),&typekey)) {
                                                tpos->recognition=getcopy(type->recognition,-1,&typekey);
                                                for (a=0;a<4;a++)
                                                    tpos->function[a]=getcopy(type->function[a],-1,&typekey);
                                                addfiletype(tpos);
                                            }
                                        }
                                        FreeMem(type,sizeof(struct dopusfiletype));
                                        listptr=makefiletypelist(&key);
                                        showtypelist(listptr);
                                    }
                                }
                                break;
                        }
                        mode=doinitfiletypetext(gadgetid);
                        break;
                }
            }
            else if (view) {
                if (view->listid==2) {
                    if (view->itemselected>-1) {
                        type=firsttype;
                        for (a=0;a<view->itemselected;a++,type=type->next)
                            if (!type) break;
                        if (type) {
                            switch (mode) {
                                case -1:
                                    editfiletype(type,&key,0);
                                    listptr=makefiletypelist(&key);
                                    showtypelist(listptr);
                                    break;
                                case FILETYPE_SWAP:
                                    if (type1) {
                                        if (strcmp(type->type,"Default")==0)
                                            dogadgetinfo(cfg_string[STR_DEFAULT_ACTION_CAN_NOT_BE_MOVED]);
                                        else if (type!=type1) {
                                            SwapMem((char *)type->type,(char *)type1->type,sizeof(struct dopusfiletype)-4);
                                            listptr=makefiletypelist(&key);
                                            dogadgetinfo(cfg_string[STR_CLASS_ACTIONS_SWAPPED]);
                                        }
                                        else dogadgetinfo(NULL);
                                        showtypelist(listptr);
                                        type1=NULL;
                                    }
                                    else {
                                        if (strcmp(type->type,"Default")==0) {
                                            showtypelist(listptr);
                                            dogadgetinfo(cfg_string[STR_DEFAULT_ACTION_CAN_NOT_BE_MOVED]);
                                        }
                                        else {
                                            type1=type;
                                            dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_SWAP_WITH_FIRST]);
                                        }
                                    }
                                    break;
                                case FILETYPE_DELETE:
                                    if (request(cfg_string[STR_REALLY_DELETE_THIS_ACTION])) {
                                        if (type==firsttype) firsttype=type->next;
                                        else {
                                            tpos=firsttype;
                                            while (tpos) {
                                                if (tpos->next==type) {
                                                    tpos->next=type->next;
                                                    break;
                                                }
                                                tpos=tpos->next;
                                            }
                                        }
                                        dogadgetinfo(cfg_string[STR_ACTION_DELETED]);
                                        listptr=makefiletypelist(&key);
                                    }
                                    else dogadgetinfo(NULL);
                                    showtypelist(listptr);
                                    break;
                            }
                        }
                    }
                }
            }
        }
    }
}
    
char **makefiletypelist(key)
struct DOpusRemember **key;
{
    char **list;
    int count,a;
    struct dopusfiletype *type;

    LFreeRemember(key);
    type=firsttype;
    for (count=0;type;count++,type=type->next);
    if (!(list=LAllocRemember(key,(count+1)*4,MEMF_CLEAR))) return(NULL);
    type=firsttype;
    for (a=0;a<count;a++) {
        if (list[a]=LAllocRemember(key,60,MEMF_CLEAR)) {
            if (type->type[0]) lsprintf(list[a],"%-50s%s",type->type,type->typeid);
            else {
                list[a][0]=' '; list[a][1]=0;
            }
        }
        type=type->next;
    }
    return(list);
}

void showtypelist(list)
char **list;
{
    filetypeactionlist.items=list; filetypeactionlist.itemselected=-1;
    RefreshListView(&filetypeactionlist,1);
}

doinitfiletypetext(id)
int id;
{
    int mode=-1;

    switch (id) {
        case FILETYPE_SWAP:
            mode=FILETYPE_SWAP;
            dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_SWAP]);
            break;
        case FILETYPE_DELETE:
            mode=FILETYPE_DELETE;
            dogadgetinfo(cfg_string[STR_SELECT_ACTION_TO_DELETE]);
            break;
    }
    return(mode);
}

void filetypetitle(type)
struct dopusfiletype *type;
{
    char title[80];

    lsprintf(title,"%s : %s",cfg_string[STR_FILETYPE_CLASS],type->type);
    if (type->typeid[0]) {
        char extra[16];

        lsprintf(extra," (%s)",type->typeid);
        strcat(title,extra);
    }
    doscreentitle(title);
}

editfiletype(type,key,new)
struct dopusfiletype *type;
struct DOpusRemember **key;
int new;
{
    struct dopusfunction editbuf;
    char *func[FILETYPE_FUNCNUM],*oldfunc[FILETYPE_FUNCNUM];
    int a,b;

    RemoveListView(&filetypeactionlist,1);
    cleanconfigscreen();
    filetypetitle(type);
    editbuf.function=NULL;
    for (a=0;a<FILETYPE_FUNCNUM;a++) {
        oldfunc[a]=type->function[a];
        func[a]=getcopy(type->function[a],-1,NULL);
        type->function[a]=func[a];
    }
    b=editfunction(&editbuf,CFG_FILETYPE,type);
    if (new) {
        if (!b) {
            for (a=0;a<FILETYPE_FUNCNUM;a++) {
                func[a]=oldfunc[a];
                freestring(type->function[a]);
                type->function[a]=func[a];
            }
        }
    }
    else {
        for (a=0;a<FILETYPE_FUNCNUM;a++) {
            if (b) func[a]=getcopy(type->function[a],-1,&typekey);
            else func[a]=oldfunc[a];
            freestring(type->function[a]);
            type->function[a]=func[a];
        }
    }
    showconfigscreen(CFG_FILETYPE);
    return(b);
}

editclass(class,new)
struct fileclass *class;
int new;
{
    struct fileclass editbuf;
    int b,c;

    makehelpname(cfg_string[STR_EDIT_CLASS]);
    if (new==-1) {
        new=c=0;
    }
    else {
        c=1;
        RemoveListView(&filetypeactionlist,2);
    }
    cleanconfigscreen();
    doscreentitle(cfg_string[STR_FILE_CLASS_EDIT_SCREEN]);
    strcpy(editbuf.type,class->type);
    strcpy(editbuf.typeid,class->typeid);
    editbuf.recognition=getcopy(class->recognition,-1,NULL);
    if ((b=editfileclass(&editbuf,new))) {
        if (c) {
            if (!new) removefileclass(class);
            addfileclass(editbuf.type,editbuf.typeid,editbuf.recognition);
        }
        else {
            freestring(class->recognition);
            class->recognition=getcopy(editbuf.recognition,-1,NULL);
            strcpy(class->type,editbuf.type);
            strcpy(class->typeid,editbuf.typeid);
        }
    }
    if (c) showconfigscreen(CFG_FILETYPE);
    freestring(editbuf.recognition);
    makehelpname((char *)-1);
    return(b);
}

void addfiletype(type)
struct dopusfiletype *type;
{
    struct dopusfiletype *tpos;

    if (!(tpos=firsttype)) firsttype=type;
    else {
        while (tpos->next) {
            if (strcmp(tpos->next->type,"Default")==0) {
                type->next=tpos->next;
                break;
            }
            tpos=tpos->next;
        }
        tpos->next=type;
    }
}

void readfileclasses()
{
    int in,size,pos,lsize,a;
    char *classbuf,buf[256],*typeid;

    if ((CheckExist(classname,&size))>=0 ||
        !(classbuf=AllocMem(size,MEMF_CLEAR))) return;
    if (in=Open(classname,MODE_OLDFILE)) {
        Read(in,classbuf,size);
        Close(in);
        pos=0;
        FOREVER {
            if ((pos=readline(classbuf,pos,buf,size))==-1) break;
            typeid="";
            for (a=0;buf[a];a++) {
                if (buf[a]==1) {
                    buf[a]=0;
                    typeid=&buf[a+1];
                    break;
                }
            }
            for (lsize=pos;lsize<size;lsize++) if (!classbuf[lsize]) break;
            if (!(addfileclass(buf,typeid,&classbuf[pos]))) break;
            pos=lsize+1;
        }
    }
    FreeMem(classbuf,size);
}

importfileclasses()
{
    int in,size,pos,lsize,num,a,b,tpos,ret=0;
    char *classbuf,**classlist,*classarray,**classtypeid,**classrecog,buf[256],buf2[256];
    struct DOpusRemember *key;

    filereq.flags=0;
    filereq.title=cfg_string[STR_SELECT_CLASS_FILE_TO_LOAD];
    strcpy(dirbuf,classname);
    if (classbuf=BaseName(dirbuf)) *classbuf=0;
    filebuf[0]=0;
    filereq.window=Window;
    if (!(FileRequest(&filereq)) || !filebuf[0]) return(0);
    strcpy(buf,dirbuf); TackOn(buf,filebuf,256);

    while (!(in=Open(buf,MODE_OLDFILE))) {
        lsprintf(buf2,cfg_string[STR_OPEN_FAILED],IoErr());
        if (!(request(buf2))) return(0);
    }

    key=NULL;

    if ((CheckExist(buf,&size))>=0 ||
        !(classbuf=LAllocRemember(&key,size+2,MEMF_CLEAR))) {
        Close(in);
        return(0);
    }

    Read(in,classbuf,size);
    Close(in);

    for (a=0,num=0;a<size;a++) if (!classbuf[a]) ++num;
    num/=2;

    if ((classlist=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
        (classtypeid=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
        (classrecog=LAllocRemember(&key,(num+1)*4,MEMF_CLEAR)) &&
        (classarray=LAllocRemember(&key,num+1,MEMF_CLEAR))) {
        pos=0; a=0;
        FOREVER {
            tpos=pos;
            if ((pos=readline(classbuf,pos,buf,size))==-1) break;
            classlist[a]=&classbuf[tpos];
            classtypeid[a]="";
            for (b=0;buf[b];b++) {
                if (buf[b]==1) {
                    classbuf[tpos+b]=0;
                    classtypeid[a]=&classbuf[tpos+b+1];
                    ++b;
                    break;
                }
            }
            for (;buf[b];b++);
            classrecog[a++]=&classbuf[tpos+b+1];
            for (lsize=tpos+b+1;lsize<size;lsize++)
                if (!classbuf[lsize]) break;
            pos=lsize+1;
        }
        if (classlist[0] &&
            (dolistwindow(cfg_string[STR_SELECT_CLASSES_TO_IMPORT],332,72,
                classlist,DLVF_MULTI|DLVF_HIREC,classarray,NULL))) {
            for (a=0;a<num;a++) {
                if (classarray[a]) {
                    if (!(addfileclass(classlist[a],classtypeid[a],classrecog[a]))) break;
                    ret=1;
                }
            }
        }
    }
    LFreeRemember(&key);
    return(ret);
}

savefileclasses()
{
    struct fileclass *class;
    int out,a;
    char f=0,g=1,buf[100];

    if (!firstclass) return(1);
    if (!classname[0]) strcpy(classname,"s:DirectoryOpus.CLA");
    while (!(out=Open(classname,MODE_NEWFILE))) {
        lsprintf(buf,cfg_string[STR_SAVE_FAILED],IoErr());
        if (!(request(buf))) return(0);
    }
    class=firstclass;
    while (class) {
        if (class->type[0]) {
            if ((Write(out,class->type,(a=strlen(class->type))))<a) break;
            if (class->typeid[0]) {
                Write(out,&g,1);
                if ((Write(out,class->typeid,(a=strlen(class->typeid))))<a) break;
            }
        }
        Write(out,&f,1);
        if (class->recognition) {
            if ((Write(out,class->recognition,(a=(strlen(class->recognition)+1))))<a)
                break;
        }
        else Write(out,&f,1);
        class=class->next;
    }
    Close(out);
    return(1);
}

addfileclass(type,typeid,recog)
char *type,*typeid,*recog;
{
    struct fileclass *class,*newclass,*last;

    class=firstclass;
    while (class) {
        if (LStrCmpI(class->type,type)>=0) break;
        if (!class->next) last=class;
        class=class->next;
    }
    if (!(newclass=AllocMem(sizeof(struct fileclass),MEMF_CLEAR))) return(0);
    if (class) {
        if (class->last) {
            class->last->next=newclass;
            newclass->last=class->last;
        }
        else if (class==firstclass) firstclass=newclass;
        newclass->next=class;
        class->last=newclass;
    }
    else if (firstclass) {
        last->next=newclass;
        newclass->last=last;
    }
    else firstclass=newclass;
    strcpy(newclass->type,type);
    strcpy(newclass->typeid,typeid);
    if (recog && (newclass->recognition=AllocMem(strlen(recog)+1,MEMF_CLEAR)))
        strcpy(newclass->recognition,recog);
    return(1);
}

void freefileclasses()
{
    struct fileclass *class,*newclass;

    class=firstclass;
    while (class) {
        newclass=class->next;
        freestring(class->recognition);
        FreeMem(class,sizeof(struct fileclass));
        class=newclass;
    }
    firstclass=NULL;
}

void removefileclass(class)
struct fileclass *class;
{
    if (class->last) class->last->next=class->next;
    if (class->next) class->next->last=class->last;
    if (class==firstclass) firstclass=class->next;
    freestring(class->recognition);
    FreeMem(class,sizeof(struct fileclass));
}

char **makeclasslist(key)
struct DOpusRemember **key;
{
    char **list;
    int count,a;
    struct fileclass *class;

    LFreeRemember(key);
    if (!firstclass) return(NULL);
    class=firstclass;
    for (count=0;class;count++,class=class->next);
    if (!(list=LAllocRemember(key,(count+1)*4,MEMF_CLEAR))) return(NULL);
    class=firstclass;
    for (a=0;a<count;a++) {
        if (list[a]=LAllocRemember(key,40,MEMF_CLEAR)) strcpy(list[a],class->type);
        class=class->next;
    }
    return(list);
}

readline(buf,pos,buf1,size)
char *buf;
int pos;
char *buf1;
int size;
{
    int a;

    for (a=0;a<256;a++) {
        if (size==pos || buf[pos]==0) {
            buf1[a]=0;
            if (size==pos) return(-1);
            return(pos+1);
        }
        buf1[a]=buf[pos];
        ++pos;
    }
    buf1[pos]=0;
    return(pos);
}

editfileclass(fclass,new)
struct fileclass *fclass;
int new;
{
    int a,b,old,selitem,lasta=-1,x,y,mx,my,off,temp,waitbits,remapp=0;
    ULONG class,sec,mic,oldsec,oldmic;
    USHORT code,gadgetid;
    struct Gadget *gad;
    struct DOpusListView *view;
    struct DOpusRemember *key=NULL;
    char
        *classlist[MAXFUNCS+1],classtype[MAXFUNCS],*displist[MAXFUNCS+1],
        *templist,temptype;

    for (a=0;a<MAXFUNCS;a++) {
        displist[a]=LAllocRemember(&key,80,MEMF_CLEAR);
        classlist[a]=NULL;
    }
    makeeditclasslist(fclass,classlist,classtype);
    dispclasslist(classlist,classtype,displist);

    namesinfo.MaxChars=32;
    strcpy(edit_namebuf,fclass->type);
    strcpy(edit_typeidbuf,fclass->typeid);
    edit_funcbuf[0]=0; edit_pathbuf[0]=0;
    editclassgadgets[4].Flags&=~SELECTED;

    AddGadgetBorders(&key,
        &editclassgadgets[2],
        4,
        screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
    AddGadgetBorders(&key,
        &editclassgadgets[6],
        3,
        screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
    AddGadgetBorders(&key,
        &editclassgadgets[10],
        1,
        screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);
    AddGadgetBorders(&key,
        &editclassgadgets[12],
        2,
        screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen);

    SetAPen(rp,screen_pens[1].pen);
    AddGadgets(Window,
        editclassgadgets,
        editclassgads,
        14,
        screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
    doglassimage(&editclassgadgets[6]);
    doglassimage(&editclassgadgets[8]);
    Do3DBox(rp,
        x_off+37,y_off+140,
        116,12,
        screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);

    fileview_buf=NULL; fileview_lines=fileview_topline=0; fileview_type=1;
    draw_file_view();

    showclassop(0);
    seteditclassgads(0);
    setuplist(&editclasslist,7,88);
    editclasslist.topitem=0; editclasslist.itemselected=-1;
    editclasslist.items=displist;
    AddListView(&editclasslist,1);
    initsidegads(editfuncgads,0,0);
    ClearMenuStrip(Window);
    Window->Flags|=WFLG_RMBTRAP;
    selitem=-1;
    if (new) ActivateStrGad(&editclassgadgets[0],Window);
    oldsec=oldmic=0;

    if (!appobject) {
        add_appobject(0);
        remapp=1;
    }

    waitbits=1<<Window->UserPort->mp_SigBit;
    if (appobject) waitbits|=1<<appport->mp_SigBit;

    FOREVER {
        if (appobject) {
            while (appmsg=(struct AppMessage *)GetMsg(appport)) {
                ActivateWindow(Window);
                if (appmsg->am_ID==MY_APPOBJECT &&
                    appmsg->am_NumArgs>0 &&
                    (*appmsg->am_ArgList[0].wa_Name)) {
                    PathName(appmsg->am_ArgList[0].wa_Lock,edit_pathbuf,256);
                    TackOn(edit_pathbuf,appmsg->am_ArgList[0].wa_Name,256);
                    RefreshStrGad(&editclassgadgets[9],Window);
                    load_file_view();
                }
                ReplyMsg((struct Message *)appmsg);
            }
        }
        while (IMsg=getintuimsg()) {
            if ((view=ListViewIDCMP(&editclasslist,IMsg))==(struct DOpusListView *)-1) {
                class=IMsg->Class; code=IMsg->Code;
                mx=IMsg->MouseX; my=IMsg->MouseY;
                sec=IMsg->Seconds; mic=IMsg->Micros;
                if (class==IDCMP_GADGETUP || class==IDCMP_GADGETDOWN) {
                    gad=(struct Gadget *)IMsg->IAddress;
                    gadgetid=gad->GadgetID;
                }
                ReplyMsg((struct Message *)IMsg);
                switch (class) {
                    case IDCMP_MOUSEBUTTONS:
                        if (code!=SELECTDOWN ||
                            mx<x_off+11 || mx>x_off+505 ||
                            my<y_off+21 || my>x_off+68) break;
                        if (oldsec && DoubleClick(oldsec,oldmic,sec,mic)) off=1;
                        else off=0;
                        oldsec=sec; oldmic=mic;
                        FOREVER {
                            if (my>y_off+20 && my<y_off+69) {
                                x=((mx-x_off-11)/8)-10;
                                if (x<0) x=0;
                                y=((my-y_off-21)/8)+fileview_topline;
                                if (y<fileview_topline) y=fileview_topline;
                                if (x<36) {
                                    if ((x%9)==8) --x;
                                    a=x/9; x=(a*4)+((x%9)/2);
                                }
                                else if (x>35) {
                                    x-=36;
                                    if (x>15) x=15;
                                }
                                if (off) {
                                    a=(y*16)+x;
                                    if (a==fileview_position) {
                                        old=fileview_offset;
                                        if ((fileview_offset=a)<0 ||
                                            fileview_offset>=fileview_size) fileview_offset=-1;
                                        a=0; b=1;
                                    }
                                    else {
                                        a=-1;
                                        off=0;
                                    }
                                }
                                else {
                                    old=fileview_position;
                                    if ((fileview_position=(y*16)+x)<0 ||
                                        fileview_position>=fileview_size) fileview_position=-1;
                                    a=fileview_position; b=0;
                                    if (fileview_offset>fileview_position) show_view_number(-1,1);
                                    else if (fileview_offset>-1)
                                        show_view_number(fileview_position-fileview_offset,1);
                                }
                                if (a>-1 && a!=old) {
                                    fileview_oldtop=-1;
                                    show_file_view();
                                    show_view_number(a,b);
                                }
                            }
                            if (off) break;
                            class=0;
                            while (IMsg=getintuimsg()) {
                                if (IMsg->Class==IDCMP_MOUSEMOVE || IMsg->Class==IDCMP_MOUSEBUTTONS)
                                    class=IMsg->Class; code=IMsg->Code;
                                ReplyMsg((struct Message *)IMsg);
                                if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP) break;
                            }
                            if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP) break;
                            mx=Window->MouseX;
                            my=Window->MouseY;
                            if (my<y_off+21) {
                                my=y_off+21;
                                if (fileview_topline>0) {
                                    --fileview_topline; fileview_oldtop=fileview_position=-1;
                                    show_file_view();
                                    FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
                                }
                            }
                            else if (my>y_off+68) {
                                my=y_off+68;
                                if (fileview_topline<fileview_lines-6) {
                                    ++fileview_topline; fileview_oldtop=fileview_position=-1;
                                    show_file_view();
                                    FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
                                }
                            }
                            else if (class!=IDCMP_MOUSEMOVE) Wait(1<<Window->UserPort->mp_SigBit);
                        }
                        break;

                    case IDCMP_RAWKEY:
                        switch (code) {
                            case CURSORUP:
                                if (fileview_position>15) cursor_fileview(-16);
                                break;
                            case CURSORDOWN:
                                if (fileview_position<fileview_size-16) cursor_fileview(16);
                                break;
                            case CURSORLEFT:
                                if (fileview_position) cursor_fileview(-1);
                                break;
                            case CURSORRIGHT:
                                if (fileview_position<fileview_size-1) cursor_fileview(1);
                                break;
                            case 0x23:
                                ActivateStrGad(&editclassgadgets[0],Window);
                                break;
                            case 0x17:
                                ActivateStrGad(&editclassgadgets[1],Window);
                                break;
                            case 0x34:
                                goto getfileview;
                        }
                        break;

                    case IDCMP_GADGETDOWN:
                        switch (gadgetid) {
                            case CLASS_VIEWUP:
                            case CLASS_VIEWDOWN:
                            case CLASS_VIEWSLIDER:
                                temp=0;
                                FOREVER {
                                    if (gadgetid==CLASS_VIEWUP) {
                                        if (fileview_topline==0) break;
                                        --fileview_topline;
                                    }
                                    else if (gadgetid==CLASS_VIEWDOWN) {
                                        if (fileview_topline>=fileview_lines-6) break;
                                        ++fileview_topline;
                                    }
                                    else {
                                        fileview_topline=GetSliderPos(&editclassgadgets[11],fileview_lines,6);
                                    }
                                    if (fileview_topline!=fileview_oldtop) show_file_view();
                                    if (gadgetid!=CLASS_VIEWSLIDER) {
                                        FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
                                        if (!temp++) Delay(10);
                                    }
                                    while (IMsg=getintuimsg()) {
                                        class=IMsg->Class; code=IMsg->Code;
                                        ReplyMsg((struct Message *)IMsg);
                                        if (class==IDCMP_MOUSEBUTTONS && code==SELECTUP)
                                            class=IDCMP_GADGETUP;
                                        if (class==IDCMP_GADGETUP) break;
                                    }
                                    if (class==IDCMP_GADGETUP) break;
                                }
                                ShowSlider(Window,&editclassgadgets[11]);
                                break;
                        }
                        break;

                    case IDCMP_GADGETUP:
                        switch (gadgetid) {
                            case CLASS_OKAY:
                                makeclassrecog(fclass,classlist,classtype);
                                strcpy(fclass->type,edit_namebuf);
                                strcpy(fclass->typeid,edit_typeidbuf);
                            case CLASS_CANCEL:
                                if (editclassgadgets[3].Flags&GFLG_DISABLED) seteditclassgads(1);
                                RemoveListView(&editclasslist,1);
                                LFreeRemember(&key);
                                freefunclist(classlist);
                                Window->Flags&=~WFLG_RMBTRAP;
                                FSSetMenuStrip(Window,&projectmenu);
                                if (remapp) rem_appobject(0);
                                return((gadgetid==CLASS_OKAY));

                            case CLASS_OPERATION:
                                checkclassswap();
                                if ((a=funcrequester(FREQ_FILETYPE,
                                    NULL,cfg_string[STR_LIST_OF_FILETYPE_COMMANDS]))) {
                                    classtype[selitem]=a;
                                    showclassop(classtype[selitem]);
                                    ActivateStrGad(&editclassgadgets[7],Window);
                                }
                                break;

                            case CLASS_DELETE:
                                edit_funcbuf[0]=0; classtype[selitem]=0;
                            case CLASS_FUNC:
                                lasta=-1;
                            case CLASS_NEWENTRY:
                                checkclassswap();
                                a=-1;
                                if (selitem>-1) {
                                    if (gadgetid==CLASS_NEWENTRY && !edit_funcbuf[0]) {
                                        ActivateStrGad(&editclassgadgets[7],Window);
                                        break;
                                    }
                                    editclasslist.itemselected=-1;
                                    if (!edit_funcbuf[0]) lasta=-1;
                                    endclassedit(selitem,classlist,classtype,displist);
                                    if (lasta==-1) a=selitem;
                                    else a=lasta+1;
                                    selitem=-1;
                                }
                                if (gadgetid==CLASS_NEWENTRY) {
                                    if (editclasslist.count>=MAXFUNCS) break;
                                    if (a>-1) selitem=a;
                                    else {
                                        selitem=editclasslist.count;
                                        seteditclassgads(1);
                                    }
                                    insertnewclass(classlist,classtype,selitem,displist," ",2);
                                    lasta=selitem;
                                }
                                else seteditclassgads(0);
                                break;

                            case CLASS_DUPLICATE:
                                checkclassswap();
                                if (editclasslist.count>=MAXFUNCS || !edit_funcbuf[0]) {
                                    ActivateStrGad(&editclassgadgets[7],Window);
                                    break;
                                }
                                editclasslist.itemselected=-1;
                                endclassedit(selitem,classlist,classtype,displist);
                                a=selitem; selitem=editclasslist.count;
                                insertnewclass(classlist,classtype,selitem,displist,classlist[a],classtype[a]);
                                break;

                            case CLASS_FILEVIEWREQ:
getfileview:
                                if (!(funcrequester(FREQ_GENERIC,edit_pathbuf,NULL))) break;
                                RefreshStrGad(&editclassgadgets[9],Window);
                            case CLASS_FILEVIEW:
                                if (code!=0x9) load_file_view();
                                break;
                            case CLASS_HEXDEC:
                                fileview_type=1-fileview_type;
                                DoCycleGadget(&editclassgadgets[10],Window,fileview_types,fileview_type);
                                show_view_number(fileview_position,0);
                                if (fileview_offset>fileview_position) show_view_number(-1,1);
                                else if (fileview_offset>-1)
                                    show_view_number(fileview_position-fileview_offset,1);
                                break;
                            case CLASS_TYPE:
                                ActivateStrGad(&editclassgadgets[1],Window);
                                break;
                            case CLASS_TYPEID:
                                StrToUpper(edit_typeidbuf,edit_typeidbuf);
                                RefreshStrGad(&editclassgadgets[1],Window);
                                break;
                        }
                        break;
                }
            }
            else if (view) {
                do {
                    if (selitem!=-1) {
                        endclassedit(selitem,classlist,classtype,displist);
                        if (editclassgadgets[4].Flags&SELECTED) {
                            checkclassswap();
                            seteditclassgads(0);
                            templist=classlist[selitem];
                            classlist[selitem]=classlist[view->itemselected];
                            classlist[view->itemselected]=templist;
                            temptype=classtype[selitem];
                            classtype[selitem]=classtype[view->itemselected];
                            classtype[view->itemselected]=temptype;
                            dispclasslist(classlist,classtype,displist);
                            editclasslist.itemselected=-1;
                            RefreshListView(&editclasslist,1);
                            selitem=-1;
                            break;
                        }
                    }
                    else seteditclassgads(1);
                    selitem=view->itemselected;
                    if (classlist[selitem]) strcpy(edit_funcbuf,classlist[selitem]);
                    else edit_funcbuf[0]=0;
                    RefreshStrGad(&editclassgadgets[7],Window);
                    showclassop(classtype[selitem]);
                    ActivateStrGad(&editclassgadgets[7],Window);
                }
                while (0);
            }
        }
        Wait(waitbits);
    }
}

void makeeditclasslist(class,classlist,classtype)
struct fileclass *class;
char **classlist,*classtype;
{
    int a,b,len,type,pos,num;
    char buf[256];

    if (!class->recognition) return;
    len=strlen(class->recognition);
    type=-1; pos=num=0;
    for (a=0;a<=len;a++) {
        if (type==-1) {
            if (class->recognition[a]<FTYC_COMMANDOK) {
                type=class->recognition[a];
                continue;
            }
            if (class->recognition[a]>FTYC_ENDLIMIT &&
                class->recognition[a]<FTYC_ENDSECTION) {
doandor:
                classlist[num]=getcopy(" ",2,NULL);
                for (b=0;b<11;b++) {
                    if (classopvals[b]==class->recognition[a]) {
                        classtype[num]=b+1;
                        break;
                    }
                }
                if ((++num)==MAXFUNCS) break;
            }
        }
        else if (pos==255 || class->recognition[a]>FTYC_ENDLIMIT ||
            !class->recognition[a]) {
            buf[pos]=0;
            if (classlist[num]=getcopy(buf,-1,NULL)) {
                for (b=0;b<11;b++) {
                    if (classopvals[b]==type) {
                        classtype[num]=b+1;
                        break;
                    }
                }
                if ((++num)==MAXFUNCS) break;
            }
            pos=0; type=-1;
            if (class->recognition[a]>FTYC_ENDLIMIT &&
                class->recognition[a]<FTYC_ENDSECTION) goto doandor;
        }
        else buf[pos++]=class->recognition[a];
    }
    for (a=num;a<MAXFUNCS;a++) classlist[a]=NULL;
}

void dispclasslist(classlist,classtype,displist)
char **classlist,*classtype,**displist;
{
    int a;
    char buf[80],*ptr;

    for (a=0;a<MAXFUNCS;a++) {
        if (!classlist[a]) break;
        strcpy(buf,classopslist[classtype[a]-1]);
        ptr=strchr(buf,' '); *ptr=0;
        StrCombine(displist[a],buf,spacestring,15);
        if (classopvals[classtype[a]-1]<FTYC_COMMANDOK) StrConcat(displist[a],classlist[a],75);
    }
    for (;a<MAXFUNCS;a++) displist[a][0]=0;
}

void seteditclassgads(on)
int on;
{
    int a;

    if (on) {
        for (a=3;a<6;a++) EnableGadget(&editclassgadgets[a],rp,4,2);
        EnableGadget(&editclassgadgets[6],rp,4,2);
        EnableGadget(&editclassgadgets[7],rp,0,0);
    }
    else {
        for (a=3;a<6;a++) DisableGadget(&editclassgadgets[a],rp,4,2);
        DisableGadget(&editclassgadgets[6],rp,4,2);
        DisableGadget(&editclassgadgets[7],rp,0,0);
    }
}

void removeclassentry(classlist,classtype,entry)
char **classlist,*classtype;
int entry;
{
    if (entry<MAXFUNCS-1) {
        CopyMem(&classlist[entry+1],&classlist[entry],(MAXFUNCS-1-entry)*4);
        CopyMem(&classtype[entry+1],&classtype[entry],(MAXFUNCS-1-entry));
    }
    classlist[MAXFUNCS-1]=NULL;
}

void insertnewclass(classlist,classtype,entry,displist,string,type)
char **classlist,*classtype;
int entry;
char **displist,*string;
int type;
{
    char *templist[MAXFUNCS],temptype[MAXFUNCS];
    int a;

    a=MAXFUNCS-entry-1;
    CopyMem(&classlist[entry],templist,a*4);
    CopyMem(templist,&classlist[entry+1],a*4);
    classlist[entry]=getcopy(string,-1,NULL);
    CopyMem(&classtype[entry],temptype,a);
    CopyMem(temptype,&classtype[entry+1],a);
    classtype[entry]=type;
    dispclasslist(classlist,classtype,displist);
    if (entry<editclasslist.topitem ||
        entry>=editclasslist.topitem+editclasslist.lines) editclasslist.topitem=entry;
    editclasslist.itemselected=entry;
    RefreshListView(&editclasslist,1);
    if (string[0]==' ' && string[1]==0) edit_funcbuf[0]=0;
    else strcpy(edit_funcbuf,string);
    RefreshStrGad(&editclassgadgets[7],Window);
    showclassop(type);
    ActivateStrGad(&editclassgadgets[7],Window);
}

void endclassedit(item,classlist,classtype,displist)
int item;
char **classlist,*classtype,**displist;
{
    freestring(classlist[item]);
    if (classtype[item]<1 || classopvals[classtype[item]-1]<FTYC_COMMANDOK) {
        if (edit_funcbuf[0]) classlist[item]=getcopy(edit_funcbuf,-1,NULL);
        else removeclassentry(classlist,classtype,item);
    }
    else classlist[item]=getcopy(" ",2,NULL);
    dispclasslist(classlist,classtype,displist);
    RefreshListView(&editclasslist,1);
    edit_funcbuf[0]=0;
    RefreshStrGad(&editclassgadgets[7],Window);
    showclassop(0);
}

void makeclassrecog(class,classlist,classtype)
struct fileclass *class;
unsigned char **classlist,*classtype;
{
    int size,num,a;
    unsigned char *buf,buf2[2];

    size=num=0;
    for (a=0;a<MAXFUNCS;a++) {
        if (!classlist[a]) break;
        size+=strlen(classlist[a])+2;
        ++num;
    }
    freestring(class->recognition); class->recognition=NULL;
    if (!size) return;
    if (!(buf=AllocMem(size+2,MEMF_CLEAR))) return;
    buf2[1]=0;
    for (a=0;a<num;a++) {
        buf2[0]=classopvals[classtype[a]-1];
        strcat(buf,buf2);
        if (buf2[0]<FTYC_COMMANDOK) {
            strcat(buf,classlist[a]);
            if (a==(num-1) || classopvals[classtype[a+1]-1]<FTYC_COMMANDOK) {
                buf2[0]=FTYC_ENDSECTION;
                strcat(buf,buf2);
            }
        }
    }
    class->recognition=getcopy(buf,-1,NULL);
    FreeMem(buf,size+2);
}

void checkclassswap()
{
    if (editclassgadgets[4].Flags&SELECTED) {
        editclassgadgets[4].Flags&=~SELECTED;
        select_gadget(&editclassgadgets[4],0);
    }
}

void showclassop(op)
int op;
{
    char str[80],*ptr;
    int x,a;

    SetAPen(rp,screen_pens[0].pen);
    RectFill(rp,
        x_off+37,y_off+140,
        x_off+152,y_off+151);
    SetAPen(rp,screen_pens[1].pen);
    if (op<1) ptr="----";
    else {
        strcpy(str,classopslist[op-1]);
        ptr=strchr(str,' '); *ptr=0;
        ptr=str;
    }
    a=strlen(ptr);
    x=((116-(a*8))/2)+x_off+37;
    Move(rp,x,y_off+148);
    Text(rp,ptr,a);
}

struct fileclass *getfileclasslist(type)
int type;
{
    struct DOpusRemember *key=NULL;
    int a;
    struct fileclass *fclass=NULL;

    fileclasslist=makeclasslist(&key);
    if ((a=funcrequester(FREQ_FILECLASS,NULL,fileclasstype[type]))) {
        fclass=firstclass;
        while ((--a) && fclass && fclass->next) fclass=fclass->next;
    }
    LFreeRemember(&key);
    return(fclass);
}

void draw_file_view()
{
    int a;

    SetAPen(rp,screen_pens[0].pen);
    RectFill(rp,
        y_off+7,y_off+21,
        x_off+511,y_off+68);
    do3dbox(x_off+7,y_off+21,505,48);
    Do3DBox(rp,
        x_off+534,y_off+31,
        91,12,
        screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
    Do3DBox(rp,
        x_off+534,y_off+57,
        91,12,
        screen_pens[config->gadgetbotcol].pen,screen_pens[config->gadgettopcol].pen);
    SetAPen(rp,screen_pens[1].pen);
    UScoreText(rp,
        cfg_string[STR_POSITION],
        x_off+535,y_off+27,
        -1);
    UScoreText(rp,
        cfg_string[STR_OFFSET],
        x_off+535,y_off+53,
        -1);
    for (a=0;a<2;a++)
        DoArrow(rp,
            editclassgadgets[12+a].LeftEdge+2,editclassgadgets[12+a].TopEdge+1,
            12,6,
            screen_pens[1].pen,screen_pens[0].pen,a);
    fix_slider(&editclassgadgets[11]);
    FixSliderBody(Window,&editclassgadgets[11],fileview_lines,6,0);
    FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,0);
    ShowSlider(Window,&editclassgadgets[11]);
    DoCycleGadget(&editclassgadgets[10],Window,fileview_types,fileview_type);
}

void free_file_view()
{
    int a;

    if (fileview_buf) {
        FreeMem(fileview_buf,fileview_size);
        fileview_buf=NULL;
    }
    fileview_size=fileview_lines=fileview_topline=0;
    fileview_oldtop=fileview_offset=fileview_position=-1;
    for (a=0;a<2;a++) show_view_number(-1,a);
}

void load_file_view()
{
    int file,rsize;

    free_file_view();
    busy();
    if ((CheckExist(edit_pathbuf,&fileview_size))<0 &&
        (file=Open(edit_pathbuf,MODE_OLDFILE))) {
        if (fileview_size>4096) fileview_size=4096;
        else if (fileview_size%16) fileview_size=((fileview_size+15)/16)*16;
        if (fileview_buf=AllocMem(fileview_size,MEMF_CLEAR)) {
            rsize=Read(file,fileview_buf,fileview_size);
            fileview_lines=(rsize+15)/16;
        }
        Close(file);
    }
    draw_file_view();
    if (!fileview_buf) {
        DisplayBeep(NULL);
        file_view_text(cfg_string[STR_FILE_NOT_FOUND],0);
    }
    else show_file_view();
    unbusy();
}

void file_view_text(txt,line)
char *txt;
int line;
{
    int len;

    SetAPen(rp,screen_pens[1].pen);
    SetBPen(rp,screen_pens[0].pen);
    Move(rp,x_off+9,y_off+27+(line*8));
    if (txt) Text(rp,txt,(len=strlen(txt)));
    else len=0;
    if (len<62) Text(rp,spacestring,62-len);
}

void show_file_view(void)
{
    int line,a,off,old,top,bottom,scroll,ox,px,aox,apx;
    char buf[80],buf2[30];

    top=0; bottom=5; scroll=0;
    if (fileview_oldtop>-1) {
        if ((a=fileview_topline-fileview_oldtop)>0 && a<6) {
            top=6-a;
            scroll=a*8;
        }
        else if (a<0 && a>-6) {
            bottom=-a-1;
            scroll=a*8;
        }
    }
    SetDrMd(rp,JAM2);

    for (line=0;line<6;line++) {
        if (line>=top && line<=bottom) {
            if (scroll) {
                ScrollRaster(rp,0,scroll,x_off+7,y_off+21,x_off+511,y_off+68);
                scroll=0;
            }
            if (fileview_lines<=line+fileview_topline) file_view_text(NULL,line);
            else {
                off=(fileview_topline+line)*16;
                lsprintf(buf,"%08lx: ",off);
                old=off; ox=px=-1;
                for (a=0;a<4;a++) {
/*                    lsprintf(buf2,"%02lx%02lx%02lx%02lx ",
                        fileview_buf[off++],fileview_buf[off++],fileview_buf[off++],fileview_buf[off++]);
*/
                    lsprintf(buf2,"%08lx ",*((long *)(fileview_buf+off)));
                    off += 4;

                    strcat(buf,buf2);
                    if (px==-1 && fileview_position>=off-4 && fileview_position<off) {
                        apx=fileview_position-(off-4);
                        px=(a*9)+(apx*2); apx+=(a*4)+36;
                    }
                    if (ox==-1 && fileview_offset>=off-4 && fileview_offset<off) {
                        aox=fileview_offset-(off-4);
                        ox=(a*9)+(aox*2); aox+=(a*4)+36;
                    }
                }
                off=old;
                for (a=0;a<16;a++,off++)
                    buf[46+a]=(isprint(fileview_buf[off]))?fileview_buf[off]:'.';
                buf[62]=0;
                file_view_text(buf,line);
                if (px>-1 && px!=ox) {
                    SetDrMd(rp,COMPLEMENT);
                    RectFill(rp,
                        x_off+89+(px*8),y_off+21+(line*8),
                        x_off+104+(px*8),y_off+28+(line*8));
                    RectFill(rp,
                        x_off+89+(apx*8),y_off+21+(line*8),
                        x_off+96+(apx*8),y_off+28+(line*8));
                    SetDrMd(rp,JAM2);
                }
                if (ox>-1) {
                    SetAPen(rp,screen_pens[2].pen);
                    lsprintf(buf2,"%02lx",fileview_buf[fileview_offset]);
                    Move(rp,x_off+89+(ox*8),y_off+27+(line*8));
                    Text(rp,buf2,2);
                    buf2[0]=(isprint(fileview_buf[fileview_offset])?fileview_buf[fileview_offset]:'.');
                    Move(rp,x_off+89+(aox*8),y_off+27+(line*8));
                    Text(rp,buf2,1);
                    SetAPen(rp,screen_pens[1].pen);
                }
            }
        }
    }
    fileview_oldtop=fileview_topline;
}

void show_view_number(num,pos)
int num,pos;
{
    char buf[20];
    int y;

    if (num<0) {
        SetAPen(rp,screen_pens[0].pen);
        RectFill(rp,
            x_off+534,y_off+31+(26*pos),
            x_off+624,y_off+42+(26*pos));
        SetAPen(rp,screen_pens[1].pen);
    }
    else {
        y=y_off+39+(26*pos);
        if (fileview_type==0) lsprintf(buf,"$%08lx",num);
        else lsprintf(buf,"%09ld",num);
        UScoreText(rp,buf,x_off+543,y,-1);
    }
}

void cursor_fileview(delta)
int delta;
{
    int ups=0;

    fileview_position+=delta;
    if (fileview_position<0) fileview_position=0;
    else if (fileview_position>=fileview_size) fileview_position=fileview_size-1;

    if (fileview_position<(fileview_topline*16)) {
        fileview_oldtop=-1;
        while (fileview_position<(fileview_topline*16)) {
            if (!fileview_topline) break;
            --fileview_topline;
        }
        ups=1;
    }
    else if (fileview_position>=((fileview_topline+6)*16)) {
        fileview_oldtop=-1;
        while (fileview_position>=((fileview_topline+6)*16)) {
            if (fileview_topline>=fileview_lines-6) break;
            ++fileview_topline;
        }
        ups=1;
    }
    show_file_view();
    show_view_number(fileview_position,0);
    if (fileview_offset>fileview_position) show_view_number(-1,1);
    else if (fileview_offset>-1)
        show_view_number(fileview_position-fileview_offset,1);
    if (ups) FixSliderPot(Window,&editclassgadgets[11],fileview_topline,fileview_lines,6,1);
}