#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <ctype.h>
#include    <msdos.cf>
#include    <egb.h>
#include    <mos.h>
#include    <snd.h>
#include    "event.h"
#include    "graphic.h"
#include    "msg.h"
#include    "defs.h"
#include    "coldef.h"

#define	SECRET		(CMDS_MAX-1)

#define	CLIP_UP		10
#define	CLIP_Y		18

#define	DRV_X		320
#define	DRV_Y		196

#define	FILE_X		404
#define	FILE_Y		36

#define	CMDS_X		320
#define	CMDS_Y		36

#define	CMDS_MAX	9
#define	CMDS_LEN	8

#define	DRV_MAX		17	/* A - Q */
#define	DRV_LEN		8

#define	FILE_MAX	25

#define	DSP_X		CLIP_UP
#define	DSP_Y		(CLIP_Y+18)
#define	DSP_MAX		25
#define	DSP_LEN		36

#define	CLIP_DOWN	(CLIP_UP+CLIP_LEN*8+5)
#define	CLIP_X		(CLIP_DOWN+CLIP_LEN*8+5)
#define	CLIP_EXIT	(CLIP_X+CLIP_SIZ*8+5)

#define	CLIP_LEN	2
#define	CLIP_SIZ	26

#define	SPC_Y		16
#define	SIZ_Y		11
#define	FNT_SIZ		8		/* 8 or 16 */
#define	FNT_SPC		2

#define	WIND_COL	COL_JACK
#define	STD_COL		COL_CHR
#define	W_BAK_COL	COL_JACK
#define	HIT_COL		COL_JACK2
#define	BOX1_COL	COL_LINE

#define	ISDIR(c)	(c->att&0x10)

#define	IS_FLP		0x00
#define	IS_RES		0x01
#define	IS_SCSI		0x02
#define	IS_RAM		0x03
#define	IS_MDC		0x04
#define	IS_ROM		0x05
#define	IS_CDR		0x06
#define	IS_NON		0xFF

typedef struct _WCBUF {
    struct _WCBUF       *next;
    short int		mark;
    short int           att;
    unsigned short int  time,date;
    unsigned long       size;
    char                name[14];
} WCBUF;

extern int	errno;

int	ESR_setupInfo(char *out_buf);
char	*strdup(char *str);
char	*macget(char *str);

static int	CDRV=0;
static int	dir_count=0;
static int	file_count=0;
static int	disk_total_free=0;
static int	disk_write_free=0;
static int	topno=0,now_no=0;
static WCBUF    *topwp=NULL,*now_wp=NULL;
static int	sel_event=ERR;
static char	where[256];
static char	sel_buf[2048];
static char	*file_stack[FILE_MAX];
static unsigned char	drive[]={
	ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR,
	ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR,
	ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR };
static char	*dev_name[]={
	"FDD ","??? ","HDD ","RAM ",
	"MDC ","ROM ","CDR ","??? ",
	"??? ","??? ","??? ","??? " };
static char	*cmds_name[CMDS_MAX]={
	 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
static char	*cmds_func[CMDS_MAX]={
	 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };

void	dsp_drive();
void	dsp_all();
void	dsp_file_stack();
void	dsp_one_file();

int	dos_err_chk(void)
{
    if ( (Registers.Flags & 0x0001) != 0 ) {
	errno = Registers.AX.R;
	return ERR;
    } else
	return FALSE;
}
int	chdrv(int no)
{
    Registers.AX.R = 0x0E00;
    Registers.DX.R = no;
    calldos();
    return dos_err_chk();
}
int	mkdir(char *name)
{
    Registers.AX.R = 0x3900;
    Registers.DX.R = (int)name;
    Registers.DS.R = getds();
    calldos();
    return dos_err_chk();
}
int	rmdir(char *name)
{
    Registers.AX.R = 0x3A00;
    Registers.DX.R = (int)name;
    Registers.DS.R = getds();
    calldos();
    return dos_err_chk();
}
int	chdir(char *name)
{
    Registers.AX.R = 0x3B00;
    Registers.DX.R = (int)name;
    Registers.DS.R = getds();
    calldos();
    return dos_err_chk();
}
int	getdir(char *name)
{
    Registers.AX.R = 0x4700;
    Registers.DX.R = 0x0000;
    Registers.SI.R = (int)name+3;
    Registers.DS.R = getds();
    calldos();
    if ( dos_err_chk() != 0 )
	return ERR;

    Registers.AX.R = 0x1900;
    calldos();
    if ( dos_err_chk() != 0 )
	return ERR;

    *(name++) = 'A' + (Registers.AX.R & 0xFF);
    *(name++) = ':';
    *(name++) = '\\';
    if ( *name != '\0' )
	strcat(name,"\\");

    return dos_err_chk();
}
void	disk_free(int drv)
{
    Registers.AX.R = 0x3600;
    Registers.DX.R = drv;
    calldos();
    disk_total_free = Registers.DX.R * Registers.AX.R * Registers.CX.R;
    disk_write_free = Registers.BX.R * Registers.AX.R * Registers.CX.R;
}
WCBUF   *wc_read(arg,mode)
char    *arg;
int     mode;
{
    static int   opflg=FALSE;
    static struct {
	unsigned char      dd_dmy[22];
	unsigned short int dd_time,dd_date;
	unsigned long      dd_size;
	char               dd_name[13];
    } dma;
    WCBUF    *wp;

    if ( opflg == FALSE ) {
        Registers.AX.R = 0x1A00;
        Registers.DX.R = (int)&dma;
        Registers.DS.R = getds();
        calldos(); 
        Registers.AX.R = 0x4E00;
        Registers.CX.R = mode;
        Registers.DX.R = (int)arg;
        Registers.DS.R = getds();
        opflg = TRUE;
    } else
        Registers.AX.R = 0x4F00;

    calldos();
    if ( (Registers.Flags & 0x0001) != 0 ) {
        opflg = FALSE;
	return NULL;
    }
    if ( (wp = (WCBUF *)malloc(sizeof(WCBUF))) != NULL ) {
	wp->next = NULL;
	wp->mark = ERR;
	wp->att = dma.dd_dmy[21];
	wp->date = dma.dd_date;
	wp->time = dma.dd_time;
	wp->size = dma.dd_size;
	strcpy(wp->name,dma.dd_name);
    }
    return wp;
}
char    *subname(name)
register char   *name;
{
    char    *p;

    if ( strcmp(name,".") == 0 ||
	 strcmp(name,"..") == 0 ||
	 (p = strrchr(name,'.')) == NULL )
	while ( *name != '\0' ) name++;
    else
	name = p + 1;
    return name;
}
char	*formname(name)
char	*name;
{
    int     i;
    char    *p;
    static char tmp[16];

    p = subname(name);
    if ( *p != '\0' ) p--;

    for ( i = 0 ; name < p && i < 8 ; i++ )
	tmp[i] = *(name++);

    for ( ; i < 9 ; i++ )
	tmp[i] = ' ';

    if ( *p == '.' ) p++;

    while ( *p != '\0' )
	tmp[i++] = *(p++);

    for ( ; i < 12 ; i++ )
	tmp[i] = ' ';

    tmp[i] = '\0';
    return tmp;
}
int     cmpname(sp,dp)
WCBUF   *sp,*dp;
{
    int     cd;

    if ( ISDIR(sp) != ISDIR(dp) )
	return ISDIR(sp) ? ERR:TRUE;
    if ( (cd = strcmp(subname(sp->name),subname(dp->name))) != 0 )
	return cd;
    return strcmp(sp->name,dp->name);
}
WCBUF   *wc_sort(sp,dp)
WCBUF   *sp,*dp;
{
    register WCBUF *tp;
    WCBUF tmp;

    tp = &tmp;
    if ( (tp->next = sp) == NULL )
	return dp;
    while ( tp->next != NULL ) {
	if ( cmpname(tp->next,dp) >= 0 )
	    break;
	tp = tp->next;
    }
    dp->next = tp->next;
    tp->next = dp;
    return tmp.next;
}
void    wc_del(wp)
WCBUF   *wp;
{
    WCBUF   *tp;

    while ( wp != NULL ) {
	tp = wp->next;
	free(wp);
	wp = tp;
    }
}
WCBUF   *wc_open()
{
    WCBUF   *wp;

    DSP_mos(2);

    if ( topwp != NULL )
	wc_del(topwp);

    topwp = NULL;
    topno = 0;
    getdir(where);

    dir_count = file_count = 0;
    while ( (wp = wc_read("*.*",0x31)) != NULL ) {
	if ( ISDIR(wp) ) dir_count++; else file_count++;
	topwp = wc_sort(topwp,wp);
    }
    disk_free(0);
    DSP_mos(0);

    return topwp;
}
void	SEL_file_event(EVENT *ep,int x,int y,int sw)
{
    int     i;
    WCBUF   *wp;

    switch(ep->now) {

    case EVT_CLIP_MOS:
	EVT_clip_on(ep);
    case EVT_ON_MOS:
	DSP_mos(1);
	break;

    case EVT_SELECT_MOS:
	EVT_clip_off(ep);
	DSP_mos(0);
	if ( ep->no == 0 ) {
	    sel_event = 3;
	    break;
	} else if ( ep->no == (-1) ) {
	    sel_event = 2;
	    break;
	}

	wp = (WCBUF *)(ep->no);
	if ( ISDIR(wp) ) {
	    chdir(wp->name);
	    wc_open();
	    dsp_all(topwp,0);
	} else {
	    strcpy(sel_buf,where);
	    strcat(sel_buf,wp->name);

	    if ( wp->mark != FALSE ) {
		for ( i = 0 ; i < FILE_MAX ; i++ ) {
		    if ( file_stack[i] != NULL &&
			 strcmp(sel_buf,file_stack[i]) == 0 ) {
			free(file_stack[i]);
			file_stack[i] = NULL;
			dsp_file_stack(i);
			break;
		    }
		}
		wp->mark = FALSE;
	    } else {
	    	for ( i = 0 ; i < FILE_MAX ; i++ ) {
		    if ( file_stack[i] == NULL ) {
			file_stack[i] = strdup(sel_buf);
	        	wp->mark = TRUE;
			dsp_file_stack(i);
			break;
		    }
		}
	    }
	    MOS_disp(FALSE);
	    dsp_one_file(wp);
	    MOS_disp(TRUE);
	}
	break;

    case EVT_DOLACK_MOS:
	ep->now = EVT_NON;
    case EVT_MOVE_MOS:
	EVT_clip_off(ep);
    case EVT_OFF_MOS:
	DSP_mos(0);
	break;
    }
}
void	SEL_drv_event(EVENT *ep,int x,int y,int sw)
{
    switch(ep->now) {

    case EVT_CLIP_MOS:
	EVT_clip_on(ep);
    case EVT_ON_MOS:
	DSP_mos(1);
	break;

    case EVT_SELECT_MOS:
	EVT_clip_off(ep);
	DSP_mos(0);
	chdrv(ep->no);
	CDRV = ep->no;
	dsp_drive();
	wc_open();
	dsp_all(topwp,0);
	break;

    case EVT_DOLACK_MOS:
	ep->now = EVT_NON;
    case EVT_MOVE_MOS:
	EVT_clip_off(ep);
    case EVT_OFF_MOS:
	DSP_mos(0);
	break;
    }
}
void	SEL_stack_event(EVENT *ep,int x,int y,int sw)
{
    int     i;
    WCBUF   *wp;

    switch(ep->now) {

    case EVT_CLIP_MOS:
	EVT_clip_on(ep);
    case EVT_ON_MOS:
	DSP_mos(1);
	break;

    case EVT_SELECT_MOS:
	EVT_clip_off(ep);
	DSP_mos(0);
	if ( file_stack[ep->no] != NULL ) {
	    for ( wp = topwp ; wp != NULL ; wp = wp->next ) {
		strcpy(sel_buf,where);
		strcat(sel_buf,wp->name);
		if ( strcmp(file_stack[ep->no],sel_buf) == 0 ) {
		    wp->mark = FALSE;
	    	    MOS_disp(FALSE);
	    	    dsp_one_file(wp);
	    	    MOS_disp(TRUE);
		    break;
		}
	    }
	    free(file_stack[ep->no]);
	    file_stack[ep->no] = NULL;
	    MOS_disp(FALSE);
	    dsp_file_stack(ep->no);
	    MOS_disp(TRUE);
	}
	break;
	
    case EVT_DOLACK_MOS:
	ep->now = EVT_NON;
    case EVT_MOVE_MOS:
	EVT_clip_off(ep);
    case EVT_OFF_MOS:
	DSP_mos(0);
	break;
    }
}
void	SEL_menu_event(EVENT *ep,int x,int y,int sw)
{
    switch(ep->now) {

    case EVT_CLIP_MOS:
	EVT_clip_on(ep);
    case EVT_ON_MOS:
	DSP_mos(1);
	break;

    case EVT_SELECT_MOS:
	sel_event = ep->no;
    case EVT_DOLACK_MOS:
	ep->now = EVT_NON;
    case EVT_MOVE_MOS:
	EVT_clip_off(ep);
    case EVT_OFF_MOS:
	DSP_mos(0);
	break;
    }
}
void	dsp_name(wp,dmy)
register WCBUF   *wp;
char	*dmy;
{
    sprintf(dmy,"%-12s ",formname(wp->name));
    if ( ISDIR(wp) )
	sprintf(dmy + 13,"   <DIR> ");
    else
	sprintf(dmy + 13,"%8ld ",wp->size);
    sprintf(dmy + 22,"%02d-%02d-%02d %02d:%02d",
	80+(wp->date >> 9),
	(wp->date >> 5) & 0x0F,
	wp->date & 0x1F,
	wp->time >> 11,
	(wp->time >> 5) & 0x3F);
}
void	dsp_one_file(register WCBUF *tp)
{
    int     i;
    register WCBUF *wp;
    char    tmp[80];

    wp = now_wp;
    for ( i = 0 ; wp != NULL && i < DSP_MAX ; i++ ) {
	if ( i == 0 && now_no > 0 )
	    continue;
	else if ( i == (DSP_MAX - 1) && wp != NULL )
	    continue;

	else if ( wp == tp ) {
	    dsp_name(wp,tmp);
	    DSP_box(DSP_X,DSP_Y+i*SPC_Y,
		    DSP_X+DSP_LEN*8+4,DSP_Y+i*SPC_Y+SIZ_Y,
		    BOX1_COL,
		    wp->mark == FALSE ? W_BAK_COL:HIT_COL);
	    wrtstr(tmp,
		page_ofs,(DSP_X+FNT_SPC)/2 + (DSP_Y+i*SPC_Y+FNT_SPC)*512,
		col_cnv[STD_COL],
		col_cnv[wp->mark == FALSE ? W_BAK_COL:HIT_COL],FNT_SIZ);
	}
	wp = wp->next;
    }
}

void	dsp_all(wp,top)
register WCBUF	*wp;
int	top;
{
    int     i,j,no,cl;
    char    tmp[80];

    now_wp = wp;
    now_no = top;

    EVT_level_free(300);

    MOS_disp(FALSE);

    DSP_box(DSP_X-2,DSP_Y-2,
	    DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+2,
	    BOX1_COL,WIND_COL);

    DSP_box(DSP_X-2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+4,
	    DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+4+SIZ_Y+2,
	    BOX1_COL,WIND_COL);

    if ( disk_total_free > 0 ) {
        sprintf(tmp,"%9d/%-9d(%3d%%)%4d/%-4d",
		disk_total_free,disk_write_free,
		100 - ((disk_write_free * 200) /  disk_total_free) / 2,
		file_count,dir_count);
        DSP_string(tmp,DSP_X,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+7,
	        STD_COL,WIND_COL);
    }

    for ( no = i = 0 ; wp != NULL && i < DSP_MAX ; i++ ) {
	if ( i == 0 && top > 0 ) {
	    strcpy(tmp,"  ��    ��    ��    ��    ��    ��  ");
	    no = 0; cl = HIT_COL;
	} else if ( i == (DSP_MAX - 1) && wp != NULL ) {
	    strcpy(tmp,"  ��    ��    ��    ��    ��    ��  ");
	    no = (-1); cl = HIT_COL;
	} else {
	    dsp_name(wp,tmp);
	    no = (int)wp;
	    if ( wp->mark == ERR ) {
		wp->mark = FALSE;
		strcpy(sel_buf,where);
		strcat(sel_buf,wp->name);
		for ( j = 0 ; j < FILE_MAX ; j++ ) {
		    if ( file_stack[j] != NULL &&
			 strcmp(sel_buf,file_stack[j]) == 0 ) {
			wp->mark = TRUE;
			break;
		    }
		}
	    }
	    cl = wp->mark == FALSE ? W_BAK_COL:HIT_COL;
	    wp = wp->next;
	}
	EVT_sw(DSP_X,DSP_Y+i*SPC_Y,
		tmp,STD_COL,cl,
		300,SEL_file_event,no);
    }

    MOS_disp(TRUE);
}
void	dsp_drive()
{
    int     i,n;
    unsigned char tmp[200];

    static int drv_max=ERR;

    if ( drv_max == ERR ) {
	ESR_setupInfo((char *)tmp);
	drv_max = 0;
	for ( i = 0 ; i < 16 ; i++ ) {
	    if ( (drive[i] = tmp[0x30 + i * 2]) != IS_NON )
		drv_max++;
	}
	drive[2] = IS_NON;	/* C: drive delete */
	drive[16] = IS_CDR;	/* Q: drive apend */
    }
    getdir((char *)tmp);
    CDRV = (tmp[0] - 'A');

    EVT_level_free(301);

    MOS_disp(FALSE);

    DSP_box(DRV_X-2,DRV_Y-2,
	    DRV_X+DRV_LEN*8+4+2,DRV_Y+(drv_max-1)*SPC_Y+SIZ_Y+2,
	    BOX1_COL,WIND_COL);

    for ( i = n = 0 ; i < DRV_MAX ; i++ ) {
	if ( drive[i] != IS_NON ) {
	    sprintf((char *)tmp," %c: %s",i + 'A',dev_name[drive[i]]);
	    EVT_sw(DRV_X,DRV_Y+n*SPC_Y,
		   (char *)tmp,STD_COL,
		   i == CDRV ? HIT_COL:W_BAK_COL,
		   301,SEL_drv_event,i);
	    n++;
	}
    }
    MOS_disp(TRUE);
}
void	dsp_clip()
{
    int     i;
    char    tmp[40];

    EVT_level_free(302);

    EVT_set_node(JACK_X,2,JACK_X+4*8+4,13,302,SEL_menu_event,0);
    EVT_set_node(HELP_X,2,HELP_X+4*8+4,13,302,SEL_menu_event,5);
    EVT_set_node(EXIT_X,2,EXIT_X+4*8+4,13,302,SEL_menu_event,6);
    EVT_set_node(MIKE_X,2,MIKE_X+4*8+4,13,302,SEL_menu_event,7);
    EVT_set_node(JOHN_X,2,JOHN_X+4*8+4,13,302,SEL_menu_event,8);
    EVT_set_node(KENT_X,2,KENT_X+4*8+4,13,302,SEL_menu_event,9);

    MOS_disp(FALSE);

    DSP_string("JACK",JACK_X+2,4,COL_CHR,COL_WHIS);
    DSP_box(CMDS_X-2,CMDS_Y-2,
	    CMDS_X+CMDS_LEN*8+4+2,CMDS_Y+(CMDS_MAX-1)*SPC_Y+SIZ_Y+2,
	    BOX1_COL,WIND_COL);

    for ( i = 0 ; i < CMDS_MAX ; i++ ) {
	if ( cmds_name[i] != NULL ) {
	    EVT_sw(CMDS_X,CMDS_Y+i*SPC_Y,cmds_name[i],
	           i == SECRET ? 6:STD_COL,W_BAK_COL,
	           302,SEL_menu_event,10+i);
	}
    }

    MOS_disp(TRUE);
}
void	dsp_file_stack(int no)
{
    char    tmp[80];

    sprintf(tmp,"%-28.28s",file_stack[no] != NULL ? file_stack[no]:"");
    wrtstr(tmp,
	   page_ofs,(FILE_X+FNT_SPC)/2 + (FILE_Y+no*SPC_Y+FNT_SPC) * 512,
	   col_cnv[STD_COL],col_cnv[W_BAK_COL],FNT_SIZ);
}
void	dsp_file(void)
{
    int     i;
    char    tmp[80];

    EVT_level_free(303);

    MOS_disp(FALSE);

    DSP_box(FILE_X-2,FILE_Y-2,
	    FILE_X+28*8+4+2,FILE_Y+(FILE_MAX-1)*SPC_Y+SIZ_Y+2,
	    BOX1_COL,WIND_COL);

    for ( i = 0 ; i < FILE_MAX ; i++ ) {
	sprintf(tmp,"%-28.28s",file_stack[i] != NULL ? file_stack[i]:"");
	EVT_sw(FILE_X,FILE_Y+i*SPC_Y,
		tmp,STD_COL,W_BAK_COL,
		303,SEL_stack_event,i);
    }

    MOS_disp(TRUE);
}
int	SEL_file(void)
{
    int     i,n,fg=ERR,now_act;
    WCBUF   *wp;
    char    *file=NULL;
    BLOCK   *save[4];

    macset("MODE","OPEN");
    now_act = macval("ACTWIND");
    macvalset("ACTWIND",3);
    macvalset("WIND",3);
    MSG_wind(WIND_MSG);

    for ( i = 0 ; i < FILE_MAX ; i++ )
	file_stack[i] = NULL;

/*********************************
    MOS_disp(FALSE);
    save[0] = DSP_push_vram(CMDS_X-2,CMDS_Y-2,
		CMDS_X+CMDS_LEN*8+4+2,CMDS_Y+(CMDS_MAX-1)*SPC_Y+SIZ_Y+2);
    save[1] = DSP_push_vram(DRV_X-2,DRV_Y-2,
		DRV_X+DRV_LEN*8+4+2,DRV_Y+(DRV_MAX-1)*SPC_Y+SIZ_Y+2);
    save[2] = DSP_push_vram(DSP_X-2,DSP_Y-2,
		DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+2);
    save[3] = DSP_push_vram(FILE_X-2,FILE_Y-2,
		FILE_X+28*8+4+2,FILE_Y+(FILE_MAX-1)*SPC_Y+SIZ_Y+2);
**********************************/
    dsp_clip();
    dsp_drive();
    dsp_file();
    wc_open();
    dsp_all(topwp,0);

    for ( ; ; ) {

	sel_event = ERR;
	TIME_dsp();
	EVT_loop(300);

	if ( sel_event == 0 ) {
	    break;

	} else if ( sel_event == 5 ) {
	    MSG_wind(HELP_MSG);

	} else if ( sel_event == 6 ) {
	    fg = 6;
	    break;

	} else if ( sel_event == 7 ) {
	    fg = 1;
	    break;

	} else if ( sel_event == 8 ) {
	    fg = 2;
	    break;

	} else if ( sel_event == 9 ) {
	    fg = 3;
	    break;

	} else if ( sel_event == 2 ) {
	    wp = topwp;
	    n = topno + (topno > 0 ? (DSP_MAX-2):(DSP_MAX-1));
	    for ( i = 0 ; i < n && wp != NULL ; i++ )
		    wp = wp->next;
	    if ( wp != NULL ) {
		topno = n;
	        dsp_all(wp,topno);
	    }

	} else if ( sel_event == 3 ) {
	    if ( topno > 0 ) {
		topno -= (topno > (DSP_MAX-1) ? (DSP_MAX-2):(DSP_MAX-1));
	        for ( i = 0 ,wp = topwp ; i < topno && wp != NULL ; i++ )
		    wp = wp->next;
	        dsp_all(wp,topno);
	    }
	} else if ( sel_event >= 10 && sel_event < (CMDS_MAX+10) ) {
	    sel_buf[0] = '\0';
	    for ( i = 0 ; i < FILE_MAX ; i++ ) {
		if ( file_stack[i] != NULL ) {
		    strcat(sel_buf,file_stack[i]);
		    strcat(sel_buf," ");
		}
	    }
	    macset("FILE",sel_buf);
	    n = MSG_wind(cmds_func[sel_event-10]);

	    dsp_clip();
	    if ( n == 0 ) {
		for ( i = 0 ; i < FILE_MAX ; i++ ) {
		    if ( file_stack[i] != NULL ) {
			free(file_stack[i]);
			file_stack[i] = NULL;
		    }
		}
		dsp_drive();
		dsp_file();
		wc_open();
		dsp_all(topwp,0);
	    }
	}

    }

    EVT_level_free(300);
    EVT_level_free(301);
    EVT_level_free(302);
    EVT_level_free(303);

    wc_del(topwp);
    topwp = NULL;

    for ( i = 0 ; i < FILE_MAX ; i++ ) {
	if ( file_stack[i] != NULL )
	    free(file_stack[i]);
    }

    MOS_disp(FALSE);
/***************************
    DSP_pop_vram(save[0]);
    DSP_pop_vram(save[1]);
    DSP_pop_vram(save[2]);
    DSP_pop_vram(save[3]);
****************************/
    DSP_string("JACK",JACK_X+2,4,COL_WHIS2,COL_WHIS);

    WIN_resize();

    MOS_disp(TRUE);

    macset("MODE","CLOSE");
    MSG_wind(WIND_MSG);
    macvalset("ACTWIND",now_act);

    return fg;
}
int	CMDS_init(char *argv[])
{
    int     i;
    char    tmp[16];

    for ( i = 0 ; i < CMDS_MAX ; i++ ) {
	if ( cmds_name[i] != NULL ) {
	    free(cmds_name[i]);
	    free(cmds_func[i]);
	    cmds_name[i] = NULL;
	    cmds_func[i] = NULL;
	}
	if ( *argv != NULL ) {
	    if ( *argv[0] != '\0' ) {
		sprintf(tmp,"%-8.8s",*(argv++));
		cmds_name[i] = strdup(tmp);
		cmds_func[i] = strdup(*(argv++));
	    } else
		argv += 2;
	}
    }
    return i;
}