ncurs_c.c

MIDI解码程序(用VC编写)

		else if(lyric[1] == '\\')
		{
		    display_lyric("\r", LYRIC_WORD_NOSEP);
		    display_lyric(lyric + 2, LYRIC_WORD_NOSEP);
		}
		else if(lyric[1] == '@')
		    display_lyric(lyric + 3, LYRIC_WORD_SEP);
		else
		    display_lyric(lyric + 1, LYRIC_WORD_NOSEP);
	    }
	    else
	    {
		if(*lyric == ME_CHORUS_TEXT || *lyric == ME_INSERT_TEXT)
		    display_lyric("\r", LYRIC_WORD_SEP);
		display_lyric(lyric + 1, LYRIC_WORD_SEP);
	    }
	}
	else
	    cmsg(CMSG_INFO, VERB_NORMAL, "%s", lyric + 1);
    }
}

static void ctl_lcd_mark(int status, int x, int y)
{
    int w;

    if(!ctl.trace_playing)
    {
	waddch(msgwin, status == GS_LCD_MARK_ON ? GS_LCD_MARK_CHAR : ' ');
	return;
    }

    w = (COLS - 28) / 12 * 12;
    if(status == GS_LCD_MARK_CLEAR)
      {
	int x, y;
	for(y = 0; y < 16; y++)
	  for(x = 0; x < 40; x++)
	    ctl_note(GS_LCD_MARK_OFF, y, x + (w - 40) / 2, 0);
	return;
      }

    if(w < GS_LCD_WIDTH)
    {
	if(x < w)
	    ctl_note(status, y, x, 0);
    }
    else
    {
	ctl_note(status, y, x + (w - GS_LCD_WIDTH) / 2, 0);
    }
}

static void ctl_gslcd(int id)
{
    char *lcd;
    int i, j, k, data, mask;
    char tmp[3];

    if((lcd = event2string(id)) == NULL)
	return;
    if(lcd[0] != ME_GSLCD)
	return;
    gslcd_last_display_time = get_current_calender_time();
    gslcd_displayed_flag = 1;
    lcd++;
    for(i = 0; i < 16; i++)
    {
	for(j = 0; j < 4; j++)
	{
	    tmp[0]= lcd[2 * (j * 16 + i)];
	    tmp[1]= lcd[2 * (j * 16 + i) + 1];
	    if(sscanf(tmp, "%02X", &data) != 1)
	    {
		/* Invalid format */
		return;
	    }
	    mask = 0x10;
	    for(k = 0; k < 10; k += 2)
	    {
		if(data & mask)
		{
 		    ctl_lcd_mark(GS_LCD_MARK_ON, j * 10 + k,     i);
		    ctl_lcd_mark(GS_LCD_MARK_ON, j * 10 + k + 1, i);
		}
		else
	        {
 		    ctl_lcd_mark(GS_LCD_MARK_OFF, j * 10 + k,     i);
		    ctl_lcd_mark(GS_LCD_MARK_OFF, j * 10 + k + 1, i);
		}
		mask >>= 1;
	    }
	}
	if(!ctl.trace_playing)
	{
	    waddch(msgwin, '\n');
	    wrefresh(msgwin);
	}
    }
}

static void ctl_reset(void)
{
    if(ctl.trace_playing)
	reset_indicator();
    N_ctl_refresh();
    ctl_ncurs_mode_init();
}

/***********************************************************************/

/* #define CURSED_REDIR_HACK */

/*ARGSUSED*/
static int ctl_open(int using_stdin, int using_stdout)
{
    static int open_init_flag = 0;
#ifdef CURSED_REDIR_HACK
    FILE *infp = stdin, *outfp = stdout;
    SCREEN *dftscr;
#endif

#ifdef USE_PDCURSES
    PDC_set_ctrl_break(1);
#endif /* USE_PDCURSES */

    if(!open_init_flag)
    {
#ifdef CURSED_REDIR_HACK
	/* This doesn't work right */
	if(using_stdin && using_stdout)
	{
	    infp = outfp = stderr;
	    fflush(stderr);
	    setvbuf(stderr, 0, _IOFBF, BUFSIZ);
	}
	else if(using_stdout)
	{
	    outfp = stderr;
	    fflush(stderr);
	    setvbuf(stderr, 0, _IOFBF, BUFSIZ);
	}
	else if(using_stdin)
	{
	    infp = stdout;
	    fflush(stdout);
	    setvbuf(stdout, 0, _IOFBF, BUFSIZ);
	}
	dftscr = newterm(0, outfp, infp);
	if (!dftscr)
	    return -1;
#else
	initscr();
#endif /* CURSED_REDIR_HACK */

	if(LINES < NCURS_MIN_LINES)
	{
	    endwin();
	    cmsg(CMSG_FATAL, VERB_NORMAL, "Error: Screen is too small.");
	    return 1;
	}

	cbreak();
	noecho();
	nonl();
	nodelay(stdscr, 1);
	scrollok(stdscr, 0);
#ifndef USE_PDCURSES
	idlok(stdscr, 1);
#endif /* USE_PDCURSES */
	keypad(stdscr, TRUE);
	ctl.opened = 1;
	init_chan_status();
    }

    open_init_flag = 1;
    dftwin=stdscr;
    if(ctl.trace_playing)
	ctl_ncurs_mode = NCURS_MODE_TRACE;
    else
	ctl_ncurs_mode = NCURS_MODE_MAIN;

    ctl_ncurs_back = ctl_ncurs_mode;
    N_ctl_scrinit();

    if(ctl.trace_playing)
    {
	if(msgwin != NULL)
	{
	    delwin(msgwin);
	    msgwin = NULL;
	}
    }
    else
    {
	set_trace_loop_hook(NULL);
	msgwin = newwin(LINES - 6 - 1, COLS, 6, 0);
	N_ctl_werase(msgwin);
	scrollok(msgwin, 1);
	wrefresh(msgwin);
    }

    if(command_buffer == NULL)
	command_buffer = mini_buff_new(COMMAND_BUFFER_SIZE);

    N_ctl_refresh();

    return 0;
}

static void ctl_close(void)
{
  if (ctl.opened)
    {
      endwin();
      ctl.opened=0;
    }
}

#if SCREEN_BUGFIX
static void re_init_screen(void)
{
    static int screen_bugfix = 0;
    if(screen_bugfix)
	return;
    screen_bugfix = 1;
    touchwin(dftwin);
    N_ctl_refresh();
    if(msgwin)
    {
	touchwin(msgwin);
	wrefresh(msgwin);
    }
}
#endif

static void move_select_channel(int diff)
{
    if(selected_channel != -1)
    {
	int prev_chan;
	prev_chan = selected_channel;
	selected_channel += diff;
	init_trace_window_chan(prev_chan);
    }
    else
	selected_channel += diff;
    while(selected_channel < 0)
	selected_channel += display_channels + 1;
    while(selected_channel >= display_channels)
	selected_channel -= display_channels + 1;

    if(selected_channel != -1)
    {
	init_trace_window_chan(selected_channel);
	current_indicator_chan = selected_channel;
    }
    N_ctl_refresh();
}

static void ctl_cmd_dir_close(void)
{
    if(ctl_ncurs_mode == NCURS_MODE_DIR)
    {
	ctl_ncurs_mode = ctl_ncurs_back;
	ctl_ncurs_mode_init();
    }
}

static void ctl_cmd_J_move(int diff)
{
    int i;
    char num[16];

    i = atoi(mini_buff_gets(command_buffer)) + diff;
    if(i < 0)
	i = 0;
    else if(i > file_list.number)
	i = file_list.number;
    sprintf(num, "%d", i);
    mini_buff_sets(command_buffer, num);
}

static int ctl_cmd_J_enter(void)
{
    int i, rc;
    char *text;

    text = mini_buff_gets(command_buffer);

    if(*text == '\0')
	rc = RC_NONE;
    else
    {
	i = atoi(text);
	if(i < 0 || i > file_list.number)
	{
	    beep();
	    rc = RC_NONE;
	}
	else
	{
	    rc = RC_LOAD_FILE;
	    ctl_listmode = 1 + i / LIST_TITLE_LINES;
	    ctl_list_select[ctl_listmode] = i;
	}
    }

    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return rc;
}

static void ctl_cmd_L_dir(int move)
{
    MFnode *mfp;
    int i;

    if(ctl_ncurs_mode != NCURS_MODE_DIR)
    {
	ctl_ncurs_back = ctl_ncurs_mode;
	ctl_ncurs_mode = NCURS_MODE_DIR;
	move = 0;
    }

    N_ctl_werase(listwin);

    if(command_buffer->files == NULL)
    {
	wmove(listwin, 0, 0);
	waddstr(listwin, "No match");
	wrefresh(listwin);
	N_ctl_refresh();
	ctl_mode_L_dispstart = 0;
	return;
    }

    ctl_mode_L_dispstart += move * (LIST_TITLE_LINES-1);
    mfp = MFnode_nth_cdr(command_buffer->files, ctl_mode_L_dispstart);
    if(mfp == NULL)
    {
	mfp = command_buffer->files;
	ctl_mode_L_dispstart = 0;
    }

    N_ctl_werase(listwin);
    waddstr(listwin, "Possible completions are:");
    for(i = 0; i < LIST_TITLE_LINES - 1 && mfp; i++, mfp = mfp->next)
    {
	wmove(listwin, i + 1, 0);
	waddnstr(listwin, mfp->file, COLS - 6);
    }
    wrefresh(listwin);
    N_ctl_refresh();
}

static int ctl_cmd_L_enter(void)
{
    char *text;
    MFnode *mfp;
    int i, rc = RC_NONE;
    struct double_list_string *hist;
    int nfiles;
    char *files[1], **new_files;
    MFnode *tail, *head;

    ctl_cmd_dir_close();
    text = mini_buff_gets(command_buffer);
    if(*text == '\0')
	goto end_enter;

    strncpy(ctl_mode_L_lastenter, text, COMMAND_BUFFER_SIZE - 1);
    ctl_mode_L_lastenter[COMMAND_BUFFER_SIZE - 1] = '\0';

    hist = (struct double_list_string *)
	safe_malloc(sizeof(struct double_list_string));
    hist->string = safe_strdup(ctl_mode_L_lastenter);
    hist->prev = NULL;
    hist->next = ctl_mode_L_histh;
    if(ctl_mode_L_histh != NULL)
	ctl_mode_L_histh->prev = hist;
    ctl_mode_L_histh = hist;

    i = strlen(ctl_mode_L_lastenter);
    while(i > 0 && !IS_PATH_SEP(ctl_mode_L_lastenter[i - 1]))
	i--;
    ctl_mode_L_lastenter[i] = '\0';


    /* Add new files */
    files[0] = text;
    nfiles  = 1;
    new_files = expand_file_archives(files, &nfiles);
    if(new_files == NULL)
      {
	rc = RC_NONE;
	beep();
      }
    else
      {
	head = tail = NULL;
	for(i = 0; i < nfiles; i++)
	{
	    if((mfp = make_new_MFnode_entry(new_files[i])) != NULL)
	    {
		if(head == NULL)
		    head = tail = mfp;
		else
		    tail = tail->next = mfp;
	    }
	}
	mfp = head;
	free(new_files[0]);
	free(new_files);
	if(mfp == NULL)
	{
	    rc = RC_NONE;
	    beep();
	    goto end_enter;
	}
	insert_MFnode_entrys(mfp, nc_playfile);
	ctl_list_mode(NC_LIST_NEW);
	rc = RC_NEXT;
    }

  end_enter:
    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return rc;
}

static int ctl_cmd_E_enter(int32 *val)
{
    int rc = RC_NONE;
    char *text;
    int lastb;

    *val = 1;
    text = mini_buff_gets(command_buffer);
    if(*text)
    {
	lastb = special_tonebank;
	if(set_extension_modes(text))
	    beep();
	else
	{
	    if(lastb == special_tonebank)
		rc = RC_SYNC_RESTART;
	    else
		rc = RC_RELOAD;
	}
    }
    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return rc;
}

static int ctl_cmd_S_enter(void)
{
    char *file;

    ctl_cmd_dir_close();
    file = mini_buff_gets(command_buffer);
    if(*file)
    {
	if(midi_file_save_as(NULL, file) == -1)
	    beep();
    }

    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return RC_NONE;
}

static int ctl_cmd_R_enter(int32 *valp)
{
    char *rateStr;
    int rc = RC_NONE;

    rateStr = mini_buff_gets(command_buffer);
    if(*rateStr)
    {
	*valp = atoi(rateStr);
	rc = RC_CHANGE_RATE;
    }
    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return rc;
}

static int ctl_cmd_D_enter(int32 *val)
{
    int rc = RC_NONE, ch;
    char *text;

    text = mini_buff_gets(command_buffer);
    if(*text)
    {
	if(*text == '+')
	{
	    ch = atoi(text + 1) - 1;
	    if(ch >= 0 && ChannelStatus[ch].is_drum)
	    {
		*val = ch;
		rc = RC_TOGGLE_DRUMCHAN;
	    }
	}
	else if(*text == '-')
	{
	    ch = atoi(text + 1) - 1;
	    if(ch >= 0 && ChannelStatus[ch].is_drum)
	    {
		*val = ch;
		rc = RC_TOGGLE_DRUMCHAN;
	    }
	}
	else
	{
	    *val = atoi(text) - 1;
	    if(*val >= 0)
		rc = RC_TOGGLE_DRUMCHAN;
	}
    }
    mini_buff_clear(command_buffer);
    ctl_cmdmode = 0;
    return rc;
}

/* Previous history */
static void ctl_cmd_L_phist(void)
{
    if(ctl_mode_L_histh == NULL ||
       (ctl_mode_L_histc != NULL && ctl_mode_L_histc->next == NULL))
    {
	beep();
	return;
    }

    if(ctl_mode_L_histc != NULL)
	ctl_mode_L_histc = ctl_mode_L_histc->next;
    else
    {
	strcpy(ctl_mode_L_lastenter, mini_buff_gets(command_buffer));
	ctl_mode_L_lastenter[COMMAND_BUFFER_SIZE - 1] = '\0';
	ctl_mode_L_histc = ctl_mode_L_histh;
    }
    mini_buff_sets(command_buffer, ctl_mode_L_histc->string);
}

/* Next history */
static void ctl_cmd_L_nhist(void)
{
    if(ctl_mode_L_histc == NULL)
    {
	beep();
	return;
    }
    ctl_mode_L_histc = ctl_mode_L_histc->prev;
    if(ctl_mode_L_histc != NULL)
	mini_buff_sets(command_buffer, ctl_mode_L_histc->string);
    else
	mini_buff_sets(command_buffer, ctl_mode_L_lastenter);
}

static int ctl_cmd_forward_search(void)
{
    MFnode *mfp;
    int i, n, found;
    char *ptn, *name;

    if(mini_buff_len(command_buffer) == 0)
    {
	if(ctl_mode_SEARCH_lastenter[0] == 0)
	{
	    mini_buff_clear(command_buffer);
	    ctl_cmdmode = 0;
	    return 1;
	}
	mini_buff_sets(command_buffer, ctl_mode_SEARCH_lastenter);
    }
    else
	strcpy(ctl_mode_SEARCH_lastenter, mini_buff_gets(command_buffer));

    /* Put '*' into buffer with first and last */
    while(mini_buff_backward(command_buffer))
	;
    mini_buff_insertc(command_buffer, '*');
    while(mini_buff_forward(command_buffer))
	;
    mini_buff_insertc(command_buffer, '*');

    ptn = mini_buff_gets(command_buffer);
    n = ctl_list_select[ctl_listmode] + 1;
    mfp = MFnode_nth_cdr(file_list.MFnode_head, n);
    found = 0;
    for(i = 0; i < file_list.number; i++, n++)