Ejemplo n.º 1
0
static void
test_winsdelln(WINDOW *win)
{
    STATUS st;
    int n;

    init_status(win, &st);

    do {
	(void) wattrset(win, st.attr | COLOR_PAIR(st.pair));
	switch (st.ch) {
	case 'i':
	    for (n = 0; n < st.count; ++n)
		winsertln(win);
	    break;
	case 'd':
	    for (n = 0; n < st.count; ++n)
		wdeleteln(win);
	    break;
	case 'I':
	    winsdelln(win, st.count);
	    break;
	case 'D':
	    winsdelln(win, -st.count);
	    break;
	case 'f':
	    fill_window(win);
	    reshow_status(win, &st);
	    break;
	case 'w':
	    do_subwindow(win, &st, test_winsdelln);
	    break;
	case 'q':
	    return;
	default:
	    update_status(win, &st);
	    break;
	}
    } while ((st.ch = wgetch(win)) != ERR);
}
Ejemplo n.º 2
0
Archivo: backlog.c Proyecto: hiciu/ekg2
void ncurses_backlog_display(window_t *w) {
	ncurses_window_t *n = w->priv_data;
	int y, n_rows, idx;
	backlog_line_t *bl;

	werase(n->window);

	if (n->backlog->len <= 0)
		return;

	calc_window_dimension(w);

	/* draw text */
	if (n->index == EKG_NCURSES_BACKLOG_END) {
		/* display from end of backlog */
		w->more = n->more_lines = n->cleared = 0;
		for (y = n->height, idx = n->backlog->len - 1; idx >= 0 && y > 0; idx--) {
			y -= ncurses_get_backlog_height(w, bl, idx);
			ncurses_backlog_display_line(w, y, bl);
		}

		if (y>0 && !(config_text_bottomalign && (!w->floating || config_text_bottomalign == 2))) {
			wmove(n->window, n->margin_top, 0);
			winsdelln(n->window, -y);
		}
	} else {
		/* display from line */
		idx = n->index;
		for (y = - n->first_row; idx < n->backlog->len && y < n->height; idx++) {
			n_rows = ncurses_get_backlog_height(w, bl, idx);
			ncurses_backlog_display_line(w, y, bl);
			y += n_rows;
		}
		/* count 'more' */
		if (n->more_lines && (n->backlog->len - idx < n->more_lines)) {
			n->more_lines = n->backlog->len - idx;
			if ((0 == n->more_lines) && (y >= n->height))
				n->more_lines = 1;
		}

		if ((!n->cleared && (!(idx < n->backlog->len) && (y <= n->height))) ||
		    ( n->cleared && !(y < n->height)))
		{
			ncurses_backlog_seek_end(n);
			ncurses_backlog_display(w);
		}
	}
}
Ejemplo n.º 3
0
static TACommandVerdict winsdelln_cmd(TAThread thread,TAInputStream stream)
{
    WINDOW *win;
    int n;
    int res;
    
    win = readPointer(&stream);
    n = readInt(&stream);
    
    START_TARGET_OPERATION(thread);
    
    res = winsdelln(win,n);
    
    END_TARGET_OPERATION(thread);
    
    writeInt(thread, res);
    sendResponse(thread);
    
    return taDefaultVerdict;
}
Ejemplo n.º 4
0
/* Scroll the given window up/down n lines. */
int
wscrl(WINDOW *win, int n)
{
	short	curx, cury;
	bool	 savimmed, savsync;

#ifdef	DEBUG
	if (outf)
		if (win == stdscr)
			fprintf(outf, "scroll(stdscr, %d)\n", n);
		else
			if (win == curscr)
				fprintf(outf, "scroll(curscr, %d)\n", n);
			else
				fprintf(outf, "scroll(%x, %d)\n", win, n);
#endif	/* DEBUG */
	if (!win->_scroll || (win->_flags & _ISPAD))
		return (ERR);

	savimmed = win->_immed;
	savsync = win->_sync;
	win->_immed = win->_sync = FALSE;

	curx = win->_curx; cury = win->_cury;

	if (cury >= win->_tmarg && cury <= win->_bmarg)
		win->_cury = win->_tmarg;
	else
		win->_cury = 0;

	(void) winsdelln(win, -n);
	win->_curx = curx;
	win->_cury = cury;

	win->_sync = savsync;

	if (win->_sync)
		wsyncup(win);

	return ((win->_immed = savimmed) ? wrefresh(win) : OK);
}
Ejemplo n.º 5
0
Archivo: tduint.c Proyecto: dse/tdu
void
tdu_interface_expand (int levels, int redraw)
{
	node_s *n;
	long scrolllines;

	n = find_node_numbered(root_node, cursor_line);
	if (!n) return;

	scrolllines = expand_tree(n, levels);
	if (!scrolllines) return;

	if (!redraw && (levels > 1))
		redraw = 1;

	if (redraw) {
		display_nodes(cursor_line - start_line,
			      visible_lines - (cursor_line - start_line),
			      root_node, cursor_line, cursor_line);
		tdu_interface_refresh();
	} 
	else {
		long maxlines = visible_lines - (cursor_line - start_line);

		if (scrolllines >= maxlines - 1) {
			display_nodes(cursor_line - start_line,
				      visible_lines - (cursor_line
						       - start_line),
				      root_node, cursor_line, cursor_line);
		}
		else {
			tdu_interface_refresh();
			winsdelln(main_window, scrolllines);
			display_nodes(cursor_line - start_line,
				      scrolllines + 1,
				      root_node, cursor_line, cursor_line);
		}
		tdu_interface_refresh();
	}
}
Ejemplo n.º 6
0
Archivo: tduint.c Proyecto: dse/tdu
void
tdu_interface_collapse (int redraw)
{
	node_s *n;
	long scrolllines;

	n = find_node_numbered(root_node, cursor_line);
	if (!n) return;

	scrolllines = collapse_tree(n);
	if (!scrolllines) return;

	if (redraw) {
		display_nodes(cursor_line - start_line,
			      visible_lines - (cursor_line - start_line),
			      root_node, cursor_line, cursor_line);
		tdu_interface_refresh();
	}
	else {
		long maxlines = visible_lines - (cursor_line - start_line);
		if (scrolllines >= maxlines - 1) {
			display_nodes(cursor_line - start_line,
				      visible_lines - (cursor_line
						       - start_line),
				      root_node, cursor_line, cursor_line);
		}
		else {
			tdu_interface_refresh();
			winsdelln(main_window, -scrolllines);
			display_nodes(cursor_line - start_line, 1,
				      root_node, cursor_line, cursor_line);
			display_nodes(visible_lines - scrolllines, scrolllines,
				      root_node,
				      cursor_line + maxlines - scrolllines,
				      cursor_line);
		}
		tdu_interface_refresh();
	}
}
Ejemplo n.º 7
0
/*
 * wscrl --
 *	Scroll a window n lines - up if n is positive, down if n is negative.
 */
int
wscrl(WINDOW *win, int nlines)
{
	int     oy, ox;

#ifdef DEBUG
	__CTRACE(__CTRACE_WINDOW, "wscrl: (%p) lines=%d\n", win, nlines);
#endif

	if (!(win->flags & __SCROLLOK))
		return (ERR);
	if (!nlines)
		return (OK);

	getyx(win, oy, ox);
#ifdef DEBUG
	__CTRACE(__CTRACE_WINDOW, "wscrl: y=%d\n", oy);
#endif
	if (oy < win->scr_t || oy > win->scr_b)
		/* Outside scrolling region */
		wmove(win, 0, 0);
	else
		/* Inside scrolling region */
		wmove(win, win->scr_t, 0);
	winsdelln(win, 0 - nlines);
	wmove(win, oy, ox);

	if (win == curscr) {
		__cputchar('\n');
		if (!__NONL)
			win->curx = 0;
#ifdef DEBUG
		__CTRACE(__CTRACE_WINDOW, "scroll: win == curscr\n");
#endif
	}
	return (OK);
}
Ejemplo n.º 8
0
void outputTest(WINDOW *win)
{
    WINDOW *win1;
    char Buffer[80];
    chtype ch;
    int by, bx;

    nl();
    wclear(win);
    mvwaddstr(win, 1, 1, "You should now have a screen in the upper "
                         "left corner, and this text should have wrapped");
    waddstr(win,"\nThis text should be down\n");
    waddstr(win,  "and broken into two here ^");
    Continue(win);

    wclear(win);
    wattron(win, A_BOLD);
    mvwaddstr(win, 1, 1, "A new window will appear with this text in it");
    mvwaddstr(win, 8, 1, "Press any key to continue");
    wrefresh(win);
    wgetch(win);

    getbegyx(win, by, bx);

    if (LINES < 24 || COLS < 75)
    {
        mvwaddstr(win, 5, 1, "Some tests have been skipped as they require a");
        mvwaddstr(win, 6, 1, "display of at least 24 LINES by 75 COLUMNS");
        Continue(win);
    }
    else
    {
        win1 = newwin(10, 50, 14, 25);

        if (win1 == NULL)
        {
            endwin();
            return;
        }

#ifdef A_COLOR
        if (has_colors())
        {
            init_pair(3, COLOR_BLUE, COLOR_WHITE);
            wbkgd(win1, COLOR_PAIR(3));
        }
        else
#endif
            wbkgd(win1, A_NORMAL);

        wclear(win1);
        mvwaddstr(win1, 5, 1, "This text should appear; using overlay option");
        copywin(win, win1, 0, 0, 0, 0, 9, 49, TRUE);
        box(win1, ACS_VLINE, ACS_HLINE);
        wmove(win1, 8, 26);
        wrefresh(win1);
        wgetch(win1);

        wclear(win1);

        wattron(win1, A_BLINK);
        mvwaddstr(win1, 4, 1,
                  "This blinking text should appear in only the second window");
        wattroff(win1, A_BLINK);

        mvwin(win1, by, bx);
        overlay(win, win1);
        mvwin(win1, 14, 25);
        wmove(win1, 8, 26);
        wrefresh(win1);
        wgetch(win1);

        delwin(win1);
    }

    clear();
    wclear(win);
    wrefresh(win);
    mvwaddstr(win, 6, 2, "This line shouldn't appear");
    mvwaddstr(win, 4, 2, "Only half of the next line is visible");
    mvwaddstr(win, 5, 2, "Only half of the next line is visible");
    wmove(win, 6, 1);
    wclrtobot(win);
    wmove(win, 5, 20);
    wclrtoeol(win);
    mvwaddstr(win, 8, 2, "This line also shouldn't appear");
    wmove(win, 8, 1);
    winsdelln(win, -1);
    Continue(win);

    wmove(win, 5, 9);
    ch = winch(win);

    wclear(win);
    wmove(win, 6, 2);
    waddstr(win, "The next char should be l:  ");
    winsch(win, ch);
    Continue(win);

    mvwinsstr(win, 6, 2, "A1B2C3D4E5");
    Continue(win);

    wmove(win, 5, 1);
    winsdelln(win, 1);
    mvwaddstr(win, 5, 2, "The lines below should have moved down");
    Continue(win);

    wclear(win);
    wmove(win, 2, 2);
    wprintw(win, "This is a formatted string in a window: %d %s\n",
            42, "is it");
    mvwaddstr(win, 10, 1, "Enter a string: ");
    wrefresh(win);
    echo();
    wscanw(win, "%s", Buffer);

    printw("This is a formatted string in stdscr: %d %s\n", 42, "is it");
    mvaddstr(10, 1, "Enter a string: ");
    scanw("%s", Buffer);

    wclear(win);
    curs_set(2);
    mvwaddstr(win, 1, 1, "The cursor should be in high-visibility mode");
    Continue(win);

    wclear(win);
    curs_set(0);
    mvwaddstr(win, 1, 1, "The cursor should have disappeared");
    Continue(win);

    wclear(win);
    curs_set(1);
    mvwaddstr(win, 1, 1, "The cursor should be normal");
    Continue(win);

#ifdef A_COLOR
    if (has_colors())
    {
        wclear(win);
        mvwaddstr(win, 1, 1, "Colors should change after you press a key");
        Continue(win);

        init_pair(1, COLOR_RED, COLOR_WHITE);
        wrefresh(win);
    }
#endif
    werase(win);
    mvwaddstr(win, 1, 1, "Information About Your Terminal");
    mvwaddstr(win, 3, 1, termname());
    mvwaddstr(win, 4, 1, longname());

    if (termattrs() & A_BLINK)
        mvwaddstr(win, 5, 1, "This terminal claims to support blinking.");
    else
        mvwaddstr(win, 5, 1, "This terminal does NOT support blinking.");

    mvwaddnstr(win, 7, 5, "Have a nice day!ok", 16);
    wrefresh(win);

    mvwinnstr(win, 7, 5, Buffer, 18);
    mvaddstr(LINES - 2, 10, Buffer);
    refresh();
    Continue(win);
}
Ejemplo n.º 9
0
NCURSES_EXPORT(int) (insertln) (void)
{
	T((T_CALLED("insertln()"))); returnCode(winsdelln(stdscr,1));
}
Ejemplo n.º 10
0
int scrollback_do(int window_nr, buffer *pbuf, int *winnrs, char *header)
{
	int rc = 0;
	char *find = NULL;
	char fullscreen = scrollback_fullscreen_default;
	NEWWIN *mywin1 = NULL, *mywin2 = NULL;

	int nlines, ncols;
	compute_text_dimensions(&nlines, &ncols, fullscreen);

	int offset = max(0, pbuf -> curpos - nlines); /* FIXME: aantal regels laten afhangen van lengte */
	char redraw = 2;
	int line_offset = 0;
	char show_winnr = default_sb_showwinnr;
	mybool_t case_insensitive = re_case_insensitive;
	buffer cur_lb;
	int loop = 0;

	memset(&cur_lb, 0x00, sizeof(cur_lb));

	for(loop=0; loop<pbuf -> curpos; loop++)
	{
		if ((pbuf -> be)[loop].Bline == NULL)
			continue;

		cur_lb.be = myrealloc(cur_lb.be, (cur_lb.curpos + 1) * sizeof(buffered_entry));
		cur_lb.be[cur_lb.curpos].pi    = (pbuf -> be)[loop].pi;
		if ((pbuf -> be)[loop].pi != NULL && (!IS_MARKERLINE((pbuf -> be)[loop].pi)) && (pbuf -> be)[loop].pi -> cdef.term_emul != TERM_IGNORE)
		{
			color_offset_in_line *cmatches;
			int n_cmatches;
			cur_lb.be[cur_lb.curpos].Bline = emulate_terminal((pbuf -> be)[loop].Bline, &cmatches, &n_cmatches);
			myfree(cmatches);
		}
		else
			cur_lb.be[cur_lb.curpos].Bline = strdup((pbuf -> be)[loop].Bline);
		cur_lb.be[cur_lb.curpos].ts    = (pbuf -> be)[loop].ts;
		cur_lb.curpos++;
	}

	LOG("---\n");
	if (global_highlight_str)
	{
		find = mystrdup(global_highlight_str);
	}

	create_scrollback_windows(&mywin1, &mywin2, nlines, ncols, fullscreen);

	for(;;)
	{
		int c, uc;

		if (redraw == 2)
		{
			int index = 0;
			int lines_used = 0;

			if (mywin1)
			{
				ui_inverse_on(mywin1);
				mvwprintw(mywin1 -> win, nlines + 1, 1, "%s - %d buffered lines", shorten_filename(header, max(24, ncols - 24)), cur_lb.curpos);
				ui_inverse_off(mywin1);

				if (!no_linewrap) ui_inverse_on(mywin1);
				mvwprintw(mywin1 -> win, nlines + 1, ncols - 8, "LINEWRAP");
				if (!no_linewrap) ui_inverse_off(mywin1);
			}

			werase(mywin2 -> win);

			if (!no_linewrap && line_offset > 0)
			{
				int temp_line_offset = line_offset;
				int n_chars_to_display_left = strlen((cur_lb.be)[offset].Bline) - temp_line_offset;

				while(lines_used < nlines && n_chars_to_display_left > 0)
				{
					scrollback_displayline(winnrs?winnrs[offset]:window_nr, mywin2, &cur_lb, offset, lines_used, temp_line_offset, 1, show_winnr);

					temp_line_offset += ncols;
					n_chars_to_display_left -= ncols;

					lines_used++;
				}

				index++;
			}

			for(;(offset + index) < cur_lb.curpos && lines_used < nlines;)
			{
				int lines_needed = get_lines_needed((cur_lb.be)[offset + index].Bline, ncols);

				if (no_linewrap || lines_needed == 1)
				{
					scrollback_displayline(winnrs?winnrs[offset + index]:window_nr, mywin2, &cur_lb, offset + index, lines_used, no_linewrap?line_offset:0, no_linewrap, show_winnr);
					lines_used++;
				}
				else
				{
					int cur_line_offset = 0;

					while(lines_used < nlines && lines_needed > 0)
					{
						scrollback_displayline(winnrs?winnrs[offset + index]:window_nr, mywin2, &cur_lb, offset + index, lines_used, cur_line_offset, 1, show_winnr);
						cur_line_offset += ncols;
						lines_used++;
						lines_needed--;
					}
				}

				index++;
			}

			redraw = 1;
		}

		if (redraw == 1)
		{
			mydoupdate();

			redraw = 0;
		}

		c = wait_for_keypress(HELP_SCROLLBACK_HELP, 0, NULL, 1);
		uc = toupper(c);

		if (c == 'q' || c == abort_key || c == KEY_CLOSE || c == KEY_EXIT)
		{
			break;
		}
		else if (c == 'Q' || c == -1)		/* Q: close whole stack of scrollbackwindows, -1: something got closed */
		{
			rc = -1;
			break;
		}
		else if (c == 20 && winnrs != NULL)	/* ^t */
		{
			show_winnr = 1 - show_winnr;
			redraw = 2;
		}
		else if (c == 'x')
		{
			send_to_clipboard(pbuf);
		}
		else if (c == 'Y')
		{
			no_linewrap = !no_linewrap;
			redraw = 2;
			line_offset = 0;
		}
		else if (c == KEY_F(9) || c == 23)	/* ^w */
		{
			fullscreen = ! fullscreen;
						
			compute_text_dimensions(&nlines, &ncols, fullscreen);

			create_scrollback_windows(&mywin1, &mywin2, nlines, ncols, fullscreen);

			redraw = 2;
		}
		else if (c == 't')
		{
			statistics_menu();
		}
		else if ((c == KEY_LEFT || c == KEY_BACKSPACE) && no_linewrap)
		{
			if (line_offset > 0)
				line_offset--;

			redraw = 2;
		}
		else if (c == KEY_SLEFT && no_linewrap)
		{
			if (line_offset >= (ncols / 2))
				line_offset -= (ncols / 2);
			else
				line_offset = 0;

			redraw = 2;
		}
		else if (c == KEY_SRIGHT && no_linewrap)
		{
			line_offset += (ncols / 2);

			redraw = 2;
		}
		else if (c == KEY_BEG && no_linewrap)
		{
			if (line_offset)
			{
				line_offset = 0;
				redraw = 2;
			}
		}
		else if (c == KEY_BTAB)
		{
			if (line_offset >= 4)
				line_offset -= 4;
			else
				line_offset = 0;

			redraw = 2;
		}
		else if (c == KEY_RIGHT && no_linewrap)
		{
			line_offset++;
			redraw = 2;
		}
		else if ((c == KEY_UP ||
					c == 'y' ||
					c == 25  || /* ^y */
					c == 'k' ||
					/* c == 11  || */ /* ^k */
					c == 16)    /* ^p */
				&& (offset > 0 || (!no_linewrap && line_offset > 0)))
		{
			if (no_linewrap)
			{
				offset--;
			}
			else if (line_offset > 0)
			{
				line_offset = max(0, line_offset - ncols);
			}
			else
			{
				offset--;

				line_offset = (get_lines_needed((cur_lb.be)[offset].Bline, ncols) - 1) * ncols;
			}

			wmove(mywin2 -> win, 0, 0);
			winsdelln(mywin2 -> win, 1);

			scrollback_displayline(winnrs?winnrs[offset]:window_nr, mywin2, &cur_lb, offset, 0, line_offset, no_linewrap, show_winnr);

			redraw = 1;
		}
		else if ((c == KEY_DOWN ||
					c == 'e' ||
					c == 5   || /* ^e */
					c == 'j' ||
					c == 14  || /* ^n */
					c == 13  ||
					c == KEY_ENTER)
				&& offset < (cur_lb.curpos - 1))
		{
			if (no_linewrap)
			{
				offset++;
			}
			else if (strlen((cur_lb.be)[offset].Bline) > (line_offset + ncols))
			{
				line_offset += ncols;
			}
			else if (offset < (cur_lb.curpos - 1))
			{
				if (strlen((cur_lb.be)[offset].Bline) > (line_offset + ncols))
					line_offset += ncols;
				else
				{
					line_offset = 0;
					offset++;
				}
			}

			redraw = 2;
		}
		else if ((c == KEY_NPAGE ||
					c == 'f' ||
					c == 6   || /* ^f */
					c == ('V' - 65 + 1) || /* ^v */
					c == ' ' ||
					c == 'z' ||
					c == 'u' ||
					c == ('U' - 65 + 1))   /* ^u */
				&& offset < (cur_lb.curpos - 1))
		{
			if (no_linewrap)
			{
				offset += nlines;
				if (offset >= cur_lb.curpos)
					offset = cur_lb.curpos - 1;
			}
			else
			{
				int n_lines_to_move = nlines;

				while(n_lines_to_move > 0 && offset < (cur_lb.curpos))
				{
					if (line_offset > 0)
					{
						if (line_offset + ncols >= strlen((cur_lb.be)[offset].Bline))
						{
							line_offset = 0;
							offset++;
							n_lines_to_move--;
						}
						else
						{
							line_offset += ncols;
							n_lines_to_move--;
						}
					}
					else
					{
						n_lines_to_move -= get_lines_needed((cur_lb.be)[offset].Bline, ncols);
						offset++;
					}
				}

				if (n_lines_to_move < 0)
					line_offset = (-n_lines_to_move) * ncols;
			}

			redraw = 2;
		}
		else if ((c == KEY_PPAGE ||
					c == 'b' ||
					c == 2   ||     /* ^b */
					c == 'w' ||
					c == 'd' ||
					c == 4)         /* ^d */
				&& offset > 0)
		{
			if (no_linewrap)
			{
				offset -= nlines;
				if (offset < 0)
					offset = 0;
			}
			else
			{
				int n_lines_to_move = nlines;

				if (line_offset)
					n_lines_to_move -= line_offset / ncols;

				while(n_lines_to_move > 0 && offset > 0)
				{
					offset--;

					n_lines_to_move -= get_lines_needed((cur_lb.be)[offset].Bline, ncols);

					if (n_lines_to_move < 0)
					{
						line_offset = (get_lines_needed((cur_lb.be)[offset].Bline, ncols) + n_lines_to_move) * ncols;
					}
				}
			}

			redraw = 2;
		}
		else if ((c == KEY_HOME ||
					c == 'g' ||
					c == '<' ||
					c == KEY_SBEG)
				&& offset > 0)
		{
			line_offset = offset = 0;
			redraw = 2;
		}
		else if ((c == KEY_END ||
					c == 'G' ||
					c == '>' ||
					c == KEY_SEND)
				&& offset < (cur_lb. curpos - 1))
		{
			offset = cur_lb. curpos - 1;
			redraw = 2;
		}
		else if (uc == 'R' || c == ('R' - 65 + 1) || c == ('L' - 65 + 1) || c == KEY_REFRESH)
		{
			redraw = 2;
		}
		else if (c == ('K' - 65 + 1) || c == KEY_MARK)
		{
			scrollback_find_popup(&find, &case_insensitive);

			if (find)
			{
				int rc;

				regfree(&global_highlight_re);
				myfree(global_highlight_str);
				global_highlight_str = NULL;

				if ((rc = regcomp(&global_highlight_re, find, (case_insensitive == MY_TRUE?REG_ICASE:0) | REG_EXTENDED)))
				{
					regexp_error_popup(rc, &global_highlight_re);
					myfree(find);
				}
				else
				{
					global_highlight_str = find;
				}

				redraw = 2; /* force redraw */
			}

		}
		else if (c == 'f' || c == '/' || c == '?' || c == KEY_FIND || c == KEY_SFIND)
		{
			char direction = (c == '?' || c == KEY_SFIND) ? -1 : 1;

			scrollback_find_popup(&find, &case_insensitive);

			if (find)
			{
				if (scrollback_search_new_window)
				{
					if (scrollback_search_to_new_window(&cur_lb, header, find, case_insensitive) == -1)
					{
						/* cascaded close */
						rc = -1;
						break;
					}
				}
				else
				{
					int new_f_index;

					redraw = 2; /* force redraw */

					regfree(&global_highlight_re);
					myfree(global_highlight_str);
					global_highlight_str = NULL;

					new_f_index = find_string(&cur_lb, find, 0, direction, case_insensitive);
					if (new_f_index == -1)
					{
						wrong_key();
					}
					else
					{
						offset = new_f_index;
						line_offset = 0;
					}
				}
			}
		}
		else if (uc == 'N' || c == KEY_NEXT || c == KEY_PREVIOUS || c == KEY_SNEXT)
		{
			if (find != NULL)
			{
				char direction = (c == 'n' || c == KEY_NEXT) ? 1 : -1;
				int start_offset = offset + direction;
				int new_f_index = find_string(&cur_lb, find, start_offset, direction, case_insensitive);
				if (new_f_index == -1)
				{
					wrong_key();
				}
				else
				{
					redraw = 2; /* force redraw */
					offset = new_f_index;
					line_offset = 0;
				}
			}
			else
			{
				wrong_key();
			}
		}
		else if (c == 's' || c == KEY_SAVE)
		{
			scrollback_savefile(&cur_lb);
			redraw = 2;	/* force redraw */
		}
		else if (c == 'h')
		{
			show_help(HELP_SCROLLBACK_HELP);
		}
		else if (c == 'c')
		{
			toggle_colors();
			redraw = 2;	/* force redraw */
		}
		else if (c == 'i')
		{
			info();
		}
		else if (c == 'T')
		{
			statistics_menu();
		}
		else if (c == 20)
		{
			toggle_subwindow_nr();
			redraw = 2;	/* force redraw */
		}
		else
		{
			wrong_key();
		}
	}

	delete_popup(mywin2);
	if (mywin1)
		delete_popup(mywin1);

	myfree(find);

	delete_be_in_buffer(&cur_lb);

	return rc;
}
Ejemplo n.º 11
0
int
sc_insertLines(int lines)
{
  return (winsdelln(stdscr, lines) != ERR);
}
Ejemplo n.º 12
0
int
sc_deleteLines(int lines)
{
  return (winsdelln(stdscr, -lines) != ERR);
}
Ejemplo n.º 13
0
NCURSES_EXPORT(int) (winsertln) (WINDOW * z)
{
	T((T_CALLED("winsertln(%p)"), (const void *)z)); returnCode(winsdelln(z,1));
}
Ejemplo n.º 14
0
int insdelln(int n)
{
    PDC_LOG(("insdelln() - called\n"));

    return winsdelln(stdscr, n);
}
Ejemplo n.º 15
0
NCURSES_EXPORT(int) (insdelln) (int z)
{
	T((T_CALLED("insdelln(%d)"), z)); returnCode(winsdelln(stdscr,z));
}
Ejemplo n.º 16
0
int
insertln(void)
{
	return (winsdelln(stdscr, 1));
}
Ejemplo n.º 17
0
int
winsertln(WINDOW *w)
{
	return (winsdelln(w, 1));
}
Ejemplo n.º 18
0
int
wdeleteln(WINDOW *w)
{
	return (winsdelln(w, -1));
}
Ejemplo n.º 19
0
int
insdelln(int n)
{
	return (winsdelln(stdscr, n));
}
Ejemplo n.º 20
0
int
deleteln(void)
{
	return (winsdelln(stdscr, -1));
}
Ejemplo n.º 21
0
EIF_INTEGER c_ecurses_winsdelln(EIF_POINTER w, EIF_INTEGER n)
{
    return winsdelln ( ((WINDOW *) w), (int) n) ;
};
Ejemplo n.º 22
0
NCURSES_EXPORT(int) (deleteln) (void)
{
	T((T_CALLED("deleteln()"))); returnCode(winsdelln(stdscr,-1));
}