interface.cpp

linux 下 源代码测试系统 用 tar 打开

		} else if ((ch >= 33 && ch <= 127) || ch == ' ')
		{
			if ((int)str.length() == maxlen)
				continue;
			if (str_pos < str.length())
				str.insert(str_pos, 1, char(ch));
			else str.append(1, char(ch));
			str_pos ++;
			cursor ++;
			if (cursor == win_width)
				cursor --;
			PRINT_STR;
		}
	}
	strcpy(data, str.c_str());
	curs_set(0);
#undef PRINT_STR
}

int ncurses::Window::print_longmsg(const char *msg, int key_return)
{
	Str_array lines(1);
	int ccount = 0;
	for (const char *ptr = msg; *ptr != '\0'; ptr ++)
	{
		if (*ptr == '\n')
		{
			ccount = 0;
			lines.push_back(string());
			continue;
		}
		lines.back().append(1, *ptr);
		ccount ++;
		if (ccount == getmaxx(v->win))
		{
			ccount = 0;
			lines.push_back(string());
		}
	}
	if (lines.back().empty())
		lines.erase(lines.end() - 1);
	werase(v->win);
	for (Str_array::size_type i = 0; i < lines.size() && (int)i < getmaxy(v->win); i ++)
		mvwprintw(v->win, (int)i, 0, "%s", lines[i].c_str());
	int curline = 0;
	while (true)
	{
		update();
		int ch;
		while (true)
		{
			ch = getch();
			if (ch == KEY_UP || ch == KEY_DOWN || ch == KEY_PPAGE || ch == KEY_NPAGE)
				break;
			if (ch == key_return || key_return == -1)
				return ch;
		}
		if ((int)lines.size() <= getmaxy(v->win))
			continue;
		int delta = 0;
		switch (ch)
		{
			case KEY_UP : 
				delta = -3; break;
			case KEY_DOWN :
				delta = 3; break;
			case KEY_PPAGE :
				delta = -getmaxy(v->win) + 1; break;
			case KEY_NPAGE :
				delta = getmaxy(v->win) - 1; break;
		}
		if (curline + delta < 0)
			delta = 0 - curline;
		if (curline + delta + getmaxy(v->win) >= (int)lines.size())
			delta = lines.size() - 1 - curline - getmaxy(v->win);
		if (delta == 0)
			continue;
		mvwprintw(v->win, 0, 0, "");
		winsdelln(v->win, -delta);
		if (delta > 0)
		{
			int w_line = getmaxy(v->win) - delta;
			int orig_line = curline + getmaxy(v->win);
			for (int i = 0; i < delta; i ++)
				mvwprintw(v->win, w_line + i, 0, "%s", lines[orig_line + i].c_str());
			curline += delta;
		} else
		{
			curline += delta;
			delta = -delta;
			for (int i = 0; i < delta; i ++)
				mvwprintw(v->win, i, 0, "%s", lines[curline + i].c_str());
		}
	}
}

void ncurses::Window::set_title(const char *str)
{
	if (v->win_border == NULL)
		return;
	box(v->win_border, 0, 0);
	if (str == NULL)
		return;
	int len = strlen(str) + 2;
	mvwprintw(v->win_border, 0, (getmaxx(v->win_border) - len) / 2, " %s ", str);
}

void ncurses::Window::set_scroll(bool val)
{
	scrollok(v->win, (val ? TRUE : FALSE));
}

void ncurses::Window::draw_hline(int starty)
{
	mvwhline(v->win, starty, 0, ACS_HLINE, getmaxx(v->win));
}

struct ncurses::Menu::Vars
{
	bool deleted, multiple_cols;
	int nitems;
	ITEM **items;
	MENU *menu;
	WINDOW *menu_win, *menu_win_sub;
	PANEL *menu_win_panel, *menu_win_sub_panel;
	const int *key_allowable;
};

ncurses::Menu::Menu()
{
	v = new Vars;
	v->deleted = true;
}

ncurses::Menu::~Menu()
{
	free();
	delete v;
}

void ncurses::Menu::set_arg(Window &win, const char * const items[], const int *key_allowable_, const char *msg, 
		int height, int width, int starty, int startx, int ncols)
{
	if (!v->deleted)
		free();
	v->deleted = false;
	int msg_nlines = 0;
	if (msg != NULL)
	{
		win.clean();
		win.printf(msg);
		msg_nlines = get_str_nlines(msg, win.get_ncols());
	}
	if (height == 0)
		height = win.get_nlines() - msg_nlines;
	if (width == 0)
		width = win.get_ncols();
	if (height < 3)
		height = 3;
	if (width < 3)
		width = 3;
	if (msg_nlines + height > win.get_nlines())
		height = win.get_nlines() - msg_nlines;
	if (width > win.get_ncols())
		width = win.get_ncols();
	if (startx == -1)
		startx = (win.get_ncols() - width) / 2;
	if (starty == -1)
		starty = (win.get_nlines() - height - msg_nlines) / 2 + msg_nlines;
	v->menu_win = newwin(height, width, starty + getbegy(win.v->win), startx + getbegx(win.v->win));
	box(v->menu_win, 0, 0);
	v->menu_win_panel = new_panel(v->menu_win);
	v->menu_win_sub = derwin(v->menu_win, height - 2, width - 2, 1, 1);
	v->menu_win_sub_panel = new_panel(v->menu_win_sub);
	v->key_allowable = key_allowable_;
	v->nitems = 0;
	while (items[v->nitems])
		v->nitems ++;
	v->items = new ITEM*[v->nitems + 1];
	for (int i = 0; i < v->nitems; i ++)
		v->items[i] = new_item(items[i], "");
	v->items[v->nitems] = NULL;
	v->menu = new_menu(v->items);
	set_menu_win(v->menu, v->menu_win);
	set_menu_sub(v->menu, v->menu_win_sub);
	set_menu_mark(v->menu, "*");
	set_menu_format(v->menu, height - 2, ncols);
	v->multiple_cols = (ncols > 1);
	if (post_menu(v->menu) != E_OK)
		throw Error("Failed while post_menu(). ", __PRETTY_FUNCTION__, __LINE__);
}

int ncurses::Menu::wait_key()
{
	if (v->deleted)
		throw Error("Operate on an uninitalized menu.", __PRETTY_FUNCTION__, __LINE__);
	int ch;
	while (true)
	{
		update();
		ch = getch();
		bool done = false;
		for (const int *i = v->key_allowable; *i; i ++)
			if (ch == *i)
			{
				done = true;
				break;
			}
		if (done)
			break;
		move_current_item(ch, v->menu, v->multiple_cols);
	}
	return ch;
}

bool ncurses::Menu::wait_move_key(int &ch)
{
	if (v->deleted)
		throw Error("Operate on an uninitalized menu.", __PRETTY_FUNCTION__, __LINE__);
	bool ret;
	while (true)
	{
		update();
		ch = getch();
		bool done = false;
		for (const int *i = v->key_allowable; *i; i ++)
			if (ch == *i)
			{
				done = true;
				ret = false;
				break;
			}
		if (done)
			break;
		if (move_current_item(ch, v->menu, v->multiple_cols))
		{
			ret = true;
			break;
		}
	}
	return ret;
}

int ncurses::Menu::multiple_choice(bool *result, char *items[])
{
	if (v->deleted)
		throw Error("Operate on an uninitalized menu.", __PRETTY_FUNCTION__, __LINE__);
	unpost_menu(v->menu);
	menu_opts_off(v->menu, O_ONEVALUE);
	set_menu_mark(v->menu, "->");
	if (post_menu(v->menu) != E_OK)
		throw Error("Failed to post menu.", __PRETTY_FUNCTION__, __LINE__);
	int ch;
	bool done = false;
	while (!done)
	{
		update();
		ch = getch();
		if (move_current_item(ch, v->menu, v->multiple_cols))
			continue;
		if (ch == v->key_allowable[0])
		{
			items[get_choice()][0] = (item_value(current_item(v->menu)) == TRUE ? ' ' : '*');
			menu_driver(v->menu, REQ_TOGGLE_ITEM);
		}
		else if (ch == v->key_allowable[1])
			for (int i = 0; i < item_count(v->menu); i ++)
			{
				items[i][0] = '*';
				set_item_value(v->items[i], TRUE);
			}
		else
			for (const int *i = v->key_allowable + 2; *i; i ++)
				if (*i == ch)
				{
					done = true;
					break;
				}
	}
	for (int i = 0; i < item_count(v->menu); i ++)
		result[i] = (item_value(v->items[i]) == TRUE);
	unpost_menu(v->menu);
	set_menu_mark(v->menu, "*");
	menu_opts_on(v->menu, O_ONEVALUE);
	post_menu(v->menu);
	return ch;
}

int ncurses::Menu::get_choice()
{
	ITEM *cur = current_item(v->menu);
	for (int i = 0; i < item_count(v->menu); i ++)
		if (v->items[i] == cur)
			return i;
	return 0;
}

void ncurses::Menu::free()
{
	if (v->deleted)
		return;
	v->deleted = true;
	unpost_menu(v->menu);
	free_menu(v->menu);
	for (int i = 0; i < v->nitems; i ++)
		free_item(v->items[i]);
	delete []v->items;
	del_panel(v->menu_win_sub_panel);
	delwin(v->menu_win_sub);
	del_panel(v->menu_win_panel);
	destroy_win(v->menu_win);
}

bool move_current_item(int key, MENU *menu, bool mulc)
{
	switch (key)
	{
		case KEY_LEFT	:
			if (mulc)
			{
				menu_driver(menu, REQ_LEFT_ITEM);
				break;
			}
		case KEY_UP		:
			menu_driver(menu, REQ_UP_ITEM);
			break;
		case KEY_RIGHT	:
			if (mulc)
			{
				menu_driver(menu, REQ_RIGHT_ITEM);
				break;
			}
		case KEY_DOWN	:
			menu_driver(menu, REQ_DOWN_ITEM);
			break;
		case KEY_PPAGE	:
			menu_driver(menu, REQ_SCR_UPAGE);
			break;
		case KEY_NPAGE	:
			menu_driver(menu, REQ_SCR_DPAGE);
			break;
		case KEY_HOME	:
			menu_driver(menu, REQ_FIRST_ITEM);
			break;
		case KEY_END	:
			menu_driver(menu, REQ_LAST_ITEM);
			break;
		default			:
			return false;
	}
	return true;
}

void destroy_win(WINDOW *win)
{
	wborder(win, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ');
	werase(win);
	delwin(win);
}

ncurses::Error::Error(const char *msg_, const char *func, int line)
{
	msg = new char[strlen(msg_) + strlen(func) + 20];
	sprintf(msg, "function: %s, line: %d . Description: \n%s", func, line, msg_);
	end();
}