/*
* Display a dialog box and get the search term from user
*/
static int
get_search_term (WINDOW * win, char *search_term, int height, int width)
{
int i, x, y, input_x = 0, scroll = 0, key = 0;
int box_height = 3, box_width = 30;
x = (width - box_width) / 2;
y = (height - box_height) / 2;
#ifdef HAVE_LIBNCURSES
if (use_shadow)
draw_shadow (win, y, x, box_height, box_width);
#endif
draw_box (win, y, x, box_height, box_width, dialog_attr,
searchbox_border_attr);
wattrset (win, searchbox_title_attr);
wmove (win, y, x + box_width / 2 - 4);
waddstr (win, " Search ");
box_width -= 2;
wmove (win, y + 1, x + 1);
wrefresh (win);
search_term[0] = '\0';
wattrset (win, searchbox_attr);
while (key != ESC) {
key = wgetch (win);
switch (key) {
case '\n':
if (search_term[0] != '\0')
return 0;
break;
case KEY_BACKSPACE:
case 127:
if (input_x || scroll) {
if (!input_x) {
scroll = scroll < box_width - 1 ?
0 : scroll - (box_width - 1);
wmove (win, y + 1, x + 1);
for (i = 0; i < box_width; i++)
waddch (win, search_term[scroll + input_x + i] ?
search_term[scroll + input_x + i] : ' ');
input_x = strlen (search_term) - scroll;
} else
input_x--;
search_term[scroll + input_x] = '\0';
wmove (win, y + 1, input_x + x + 1);
waddch (win, ' ');
wmove (win, y + 1, input_x + x + 1);
wrefresh (win);
}
break;
case ESC:
break;
default:
if (isprint (key))
if (scroll + input_x < MAX_LEN) {
search_term[scroll + input_x] = key;
search_term[scroll + input_x + 1] = '\0';
if (input_x == box_width - 1) {
scroll++;
wmove (win, y + 1, x + 1);
for (i = 0; i < box_width - 1; i++)
waddch (win, search_term[scroll + i]);
} else {
wmove (win, y + 1, input_x++ + x + 1);
waddch (win, key);
}
wrefresh (win);
}
}
}
return -1; /* ESC pressed */
}
void Screen::Print() {
w->ReadLock();
if ( updated || !player ) {
w->Unlock();
return;
}
updated=true;
switch ( player->UsingType() ) {
case OPEN:
PrintInv(rightWin,
player->UsingBlock()->HasInventory());
break;
default: PrintFront(rightWin);
}
switch ( player->UsingSelfType() ) {
case OPEN:
if ( player->PlayerInventory() ) {
PrintInv(leftWin,
player->PlayerInventory());
break;
} //no break;
default: PrintNormal(leftWin);
}
const short dur=player->HP();
const short breath=player->Breath();
const short satiation=player->Satiation();
werase(hudWin);
ushort i;
//quick inventory
Inventory * const inv=player->GetP() ?
player->GetP()->HasInventory() : 0;
if ( inv ) {
for (i=0; i<inv->Size(); ++i) {
wstandend(hudWin);
const int x=36+i*2;
mvwaddch(hudWin, 0, x, 'a'+i);
if ( inv->Number(i) ) {
wcolor_set(hudWin,
Color( inv->GetInvKind(i),
inv->GetInvSub(i) ), NULL);
mvwaddch(hudWin, 1, x,
CharName( inv->GetInvKind(i),
inv->GetInvSub(i) ));
mvwprintw(hudWin, 2, x, "%hu", inv->Number(i));
}
}
}
w->Unlock();
wstandend(leftWin);
QString str;
if ( -1!=dur ) { //HitPoints line
str=QString("%1").arg(dur, -10, 10, QChar('.'));
mvwaddstr(leftWin, SCREEN_SIZE+1, 1, "HP[..........]");
wcolor_set(leftWin, WHITE_RED, NULL);
mvwaddstr(leftWin, SCREEN_SIZE+1, 4,
qPrintable(str.left(10*dur/MAX_DURABILITY+1)));
wstandend(leftWin);
}
if ( -1!=breath ) { //breath line
str=QString("%1").arg(breath, -10, 10, QChar('.'));
mvwaddstr(leftWin, SCREEN_SIZE+1, SCREEN_SIZE*2-13,
"BR[..........]");
wcolor_set(leftWin, WHITE_BLUE, NULL);
mvwaddstr(leftWin, SCREEN_SIZE+1, SCREEN_SIZE*2-13+3,
qPrintable(str.left(10*breath/MAX_BREATH+1)));
}
//action mode
(void)wmove(hudWin, 0, 0);
wstandend(hudWin);
waddstr(hudWin, "Action: ");
switch ( actionMode ) {
case USE: waddstr(hudWin, "Use in inventory"); break;
case THROW: waddstr(hudWin, "Throw"); break;
case OBTAIN: waddstr(hudWin, "Obtain"); break;
case WIELD: waddstr(hudWin, "Wield"); break;
case INSCRIBE: waddstr(hudWin, "Inscribe in inventory"); break;
case EAT: waddstr(hudWin, "Eat"); break;
case BUILD: waddstr(hudWin, "Build"); break;
case CRAFT: waddstr(hudWin, "Craft"); break;
case TAKEOFF: waddstr(hudWin, "Take off"); break;
default: waddstr(hudWin, "Unknown");
fprintf(stderr,
"Screen::Print: Unlisted actionMode: %d\n",
actionMode);
}
if ( -1!=satiation ) { //satiation line
(void)wmove(hudWin, 1, 0);
if ( SECONDS_IN_DAY<satiation ) {
wcolor_set(hudWin, BLUE_BLACK, NULL);
waddstr(hudWin, "Gorged");
} else if ( 3*SECONDS_IN_DAY/4<satiation ) {
wcolor_set(hudWin, GREEN_BLACK, NULL);
waddstr(hudWin, "Full");
} else if (SECONDS_IN_DAY/4>satiation) {
wcolor_set(hudWin, RED_BLACK, NULL);
waddstr(hudWin, "Hungry");
}
}
//shifted focus
wstandend(hudWin);
if ( shiftFocus ) {
mvwaddstr(hudWin, 0, 100, ( -1==shiftFocus ) ?
"Focus shift down" : "Focus shift up");
}
if ( player->GetCreativeMode() ) {
mvwaddstr(leftWin, SCREEN_SIZE+1, 1, "Creative Mode");
//coordinates
mvwprintw(hudWin, 1, 0, "xyz: %hu, %hu, %hu. XY: %ld, %ld",
player->X(), player->Y(), player->Z(),
player->GetLatitude(), player->GetLongitude());
wcolor_set(leftWin, BLACK_WHITE, NULL);
switch ( player->Dir() ) {
case NORTH:
mvwaddstr(leftWin, SCREEN_SIZE+1,
SCREEN_SIZE*2-8, "^ North ^");
break;
case SOUTH:
mvwaddstr(leftWin, SCREEN_SIZE+1,
SCREEN_SIZE*2-8, "v South v");
break;
case EAST:
mvwaddstr(leftWin, SCREEN_SIZE+1,
SCREEN_SIZE*2-8, "> East>");
break;
case WEST:
mvwaddstr(leftWin, SCREEN_SIZE+1,
SCREEN_SIZE*2-8, "<West <");
break;
}
} else if ( player->GetP() && player->GetP()->IsFalling() ) {
mvwaddstr(hudWin, 2, 0, "Falling!");
}
wnoutrefresh(hudWin);
wnoutrefresh(leftWin);
doupdate();
}
void
print_channel(struct deviceinfo *unit)
{
int i = 0, option = EOF, scr_opt = 0;
int rc;
fd_set rfds;
struct timeval tv;
int max_fd;
struct digi_node node;
struct digi_chan chan;
int port = 0;
char ttyname[100];
int d_invokes_capture = 1; /* 0 if 'D' should invoke "exam_panel" */
/* 1 if 'D' should invoke "scope_panel" */
WINDOW *chanwin = GetWin(ChanWin);
/*
* scr_opt is just used to determine which field to
* highlight.
*/
show_panel (GetPan(ChanWin));
update_panels ();
doupdate ();
DPAOpenDevice(unit);
while ((option != 'Q') && (option != 'q') && (option != ESC))
{
/* Get port info for current port */
DPAGetNode(unit, &node);
DPAGetChannel(unit, &chan, port);
if (DPAGetPortName(unit, &node, &chan, port, ttyname) == NULL) {
ttyname[0] = '\0';
}
max_fd = 0;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
mvwprintw (chanwin, 1, 2, "Device Description: %-54.54s", node.nd_ps_desc);
mvwprintw (chanwin, 5, 35, "Name: %-10.10s", ttyname);
wattrset (chanwin, make_attr (A_BOLD, WHITE, BLACK));
mvwprintw (chanwin, 5, 56, "Status: %-10.10s",
chan.ch_open ? "Open" : "Closed");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
if (scr_opt == 1)
{
wattrset (chanwin, make_attr (A_REVERSE | A_STANDOUT, WHITE, BLACK));
mvwprintw (chanwin, 3, 5, "Unit IP Address: %-15.15s", unit->host);
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
mvwprintw (chanwin, 5, 8, "Port Number : %-2d", port + 1);
}
else if (scr_opt == 2)
{
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
mvwprintw (chanwin, 3, 5, "Unit IP Address: %-15.15s", unit->host);
wattrset (chanwin, make_attr (A_REVERSE | A_STANDOUT, WHITE, BLACK));
mvwprintw (chanwin, 5, 8, "Port Number : %-2d", port + 1);
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
}
else
{
mvwprintw (chanwin, 3, 5, "Unit IP Address: %-15.15s", unit->host);
mvwprintw (chanwin, 5, 8, "Port Number : %-2d", port + 1);
}
if (!vanilla) wattrset (chanwin, make_attr (A_ALTCHARSET, GREEN, BLACK));
else wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
for (i = 0; i < 62; i++)
mvwaddch (chanwin, 6, 8 + i, mapchar(ACS_HLINE));
mvwaddch (chanwin, 6, 7, mapchar(ACS_ULCORNER));
mvwaddch (chanwin, 6, 70, mapchar(ACS_URCORNER));
mvwaddch (chanwin, 7, 7, mapchar(ACS_VLINE));
mvwaddch (chanwin, 7, 70, mapchar(ACS_VLINE));
mvwaddch (chanwin, 8, 7, mapchar(ACS_VLINE));
mvwaddch (chanwin, 8, 70, mapchar(ACS_VLINE));
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
mvwprintw (chanwin, 12, 24, "Signal Active = ");
wattrset (chanwin, make_attr (A_STANDOUT, WHITE, GREEN));
waddstr (chanwin, "X");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
mvwaddstr (chanwin, 12, 46, "Inactive =");
wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
mvwaddstr (chanwin, 12, 57, "_");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
mvwaddstr (chanwin, 8, 13,
"Tx: RTS CTS DSR DCD DTR RI OFC IFC");
mvwaddstr (chanwin, 9, 13,
"Rx: ");
if (!vanilla)
wattrset (chanwin, make_attr (A_ALTCHARSET, GREEN, BLACK));
else
wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
mvwaddch (chanwin, 9, 7, mapchar(ACS_VLINE));
mvwaddch (chanwin, 9, 70, mapchar(ACS_VLINE));
mvwaddch (chanwin, 10, 7, mapchar(ACS_VLINE));
mvwaddch (chanwin, 10, 70, mapchar(ACS_VLINE));
mvwaddch (chanwin, 11, 7, mapchar(ACS_LLCORNER));
mvwaddch (chanwin, 11, 70, mapchar(ACS_LRCORNER));
for (i = 0; i < 62; i++)
mvwaddch (chanwin, 11, 8 + i, mapchar(ACS_HLINE));
wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
mvwprintw (chanwin, 8, 17, "%-10d", chan.ch_txcount);
mvwprintw (chanwin, 9, 17, "%-10d", chan.ch_rxcount);
{
int msigs=6;
int mbits[] = { MS_RTS, MS_CTS, MS_DSR, MS_DCD, MS_DTR, MS_RI };
char *mhstr[] = { "X", "X", "X", "X", "X", "X" };
char *mlstr[] = { "_", "_", "_", "_", "_", "_" };
int mpos[] = { 30, 35, 40, 45, 50, 55 };
int sig=0;
for(sig = 0; sig < msigs; sig++)
{
if (chan.ch_s_mstat & mbits[sig])
{
wattrset (chanwin, make_attr (A_STANDOUT, WHITE, GREEN));
mvwprintw (chanwin, 9, mpos[sig], mhstr[sig]);
}
else
{
wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
mvwprintw (chanwin, 9, mpos[sig], mlstr[sig]);
}
}
}
{
int events=2;
int ebits[] = { EV_OPALL, EV_IPALL };
char *ehstr[] = { "X", "X" };
char *elstr[] = { "_", "_" };
int epos[] = { 59, 64 };
int ev=0;
for(ev=0; ev<events; ev++)
{
if (chan.ch_s_estat & ebits[ev])
{
wattrset (chanwin, make_attr (A_STANDOUT, WHITE, GREEN));
mvwprintw (chanwin, 9, epos[ev], ehstr[ev]);
}
else
{
wattrset (chanwin, make_attr (A_NORMAL, GREEN, BLACK));
mvwprintw (chanwin, 9, epos[ev], elstr[ev]);
}
}
}
wattrset (chanwin, make_attr (A_BOLD, WHITE, BLACK));
mvwaddstr (chanwin, 14, 1, " Input Modes ");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
wprintw (chanwin, " ");
wmove (chanwin, 14, 15);
if (chan.ch_s_iflag & IF_IGNBRK)
wprintw (chanwin, ":IGNBRK");
if (chan.ch_s_iflag & IF_BRKINT)
wprintw (chanwin, ":BRKINT");
if (chan.ch_s_iflag & IF_IGNPAR)
wprintw (chanwin, ":IGNPAR");
if (chan.ch_s_iflag & IF_PARMRK)
wprintw (chanwin, ":PARMRK");
if (chan.ch_s_iflag & IF_INPCK)
wprintw (chanwin, ":INPCK");
if (chan.ch_s_iflag & IF_ISTRIP)
wprintw (chanwin, ":ISTRIP");
if (chan.ch_s_iflag & IF_IXON)
wprintw (chanwin, ":IXON");
if (chan.ch_s_iflag & IF_IXANY)
wprintw (chanwin, ":IXANY");
if (chan.ch_s_iflag & IF_IXOFF)
wprintw (chanwin, ":IXOFF");
if (chan.ch_s_xflag & XF_XIXON)
wprintw (chanwin, ":IXONA");
if (chan.ch_s_xflag & XF_XTOSS)
wprintw (chanwin, ":ITOSS");
if (chan.ch_s_iflag & IF_DOSMODE)
wprintw (chanwin, ":DOSMODE");
wprintw (chanwin, ":");
wattrset (chanwin, make_attr (A_BOLD, WHITE, BLACK));
mvwprintw (chanwin, 15, 1, " Output Modes ");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
wprintw (chanwin, " ");
wmove (chanwin, 15, 15);
if (chan.ch_s_xflag & XF_XCASE)
wprintw (chanwin, ":XCASE");
if (chan.ch_s_oflag & OF_OLCUC)
wprintw (chanwin, ":OLCUC");
if (chan.ch_s_oflag & OF_ONLCR)
wprintw (chanwin, ":ONLCR");
if (chan.ch_s_oflag & OF_OCRNL)
wprintw (chanwin, ":OCRNL");
if (chan.ch_s_oflag & OF_ONOCR)
wprintw (chanwin, ":ONOCR");
if (chan.ch_s_oflag & OF_ONLRET)
wprintw (chanwin, ":ONLRET");
/* TODO -- tab expansion / TABDLY interpretation */
wprintw (chanwin, ":");
wattrset (chanwin, make_attr (A_BOLD, WHITE, BLACK));
mvwprintw (chanwin, 16, 1, "Control Modes ");
wattrset (chanwin, make_attr (A_NORMAL, WHITE, BLACK));
/*
* clear the field, then write the new one
*/
wprintw (chanwin, " ");
wmove (chanwin, 16, 15);
if (chan.ch_open) {
/* Jira RP-77: In early stages of a port open, ch_open is set before ch_s_brate
* is initialized, which, undetected, causes an arithmetic exception here.
*/
if (chan.ch_s_brate)
wprintw (chanwin, ":%d Baud", PDIVIDEND / chan.ch_s_brate);
else
wprintw (chanwin, ":?? Baud");
switch (chan.ch_s_cflag & CF_CSIZE)
{
case CF_CS5:
wprintw (chanwin, ":5 Char Bits");
break;
case CF_CS6:
wprintw (chanwin, ":6 Char Bits");
break;
case CF_CS7:
wprintw (chanwin, ":7 Char Bits");
break;
case CF_CS8:
wprintw (chanwin, ":8 Char Bits");
break;
default:
wprintw (chanwin, ":No Char Bits");
break;
}
if (chan.ch_s_cflag & CF_CSTOPB)
wprintw (chanwin, ":2 Stop Bits");
else
wprintw (chanwin, ":1 Stop Bits");
if (chan.ch_s_cflag & CF_PARENB)
{
if (chan.ch_s_xflag & XF_XPAR)
{
if (chan.ch_s_cflag & CF_PARODD)
wprintw (chanwin, ":Parity Odd");
else
wprintw (chanwin, ":Parity Even");
}
else
{
if (chan.ch_s_cflag & CF_PARODD)
wprintw (chanwin, ":Parity Space");
else
wprintw (chanwin, ":Parity Mark");
}
}
else
{
wprintw (chanwin, ":No Parity");
}
}
else {
wprintw (chanwin, ":");
}
wattrset (GetWin(MainWin), make_attr (A_NORMAL, WHITE, BLUE));
commandline (clbuf, helpstr, "ESC=Quit", lrudstr,
"T=LoopBack", "D=DataMonitor", "^P=Print", NULL);
mvwprintw (GetWin(MainWin), KEY_LINE, 0, clbuf);
wattroff (GetWin(MainWin), make_attr (A_NORMAL, WHITE, BLUE));
wrefresh (GetWin(MainWin));
wrefresh (chanwin);
change_term (0, TIMEOUT);
option = EOF;
tv.tv_sec = 0; tv.tv_usec = 500000;
rc = select( max_fd + 1, &rfds, NULL, NULL, &tv );
if (rc < 0)
{
fprintf (stderr, "FATAL ERROR: select failure.\n");
EndCurses (-13);
/* FIXME: This code will not be executed as
EndCurses() calls exit(). */
exit (-2);
}
else if (rc > 0)
{
if (FD_ISSET(0, &rfds))
{
option = getch();
}
}
else
{
scr_opt = 0;
}
/*
* If the user hasn't selected anything keep doing the
* original screen.
*/
switch (option)
{
case EOF:
break;
case ' ':
scr_opt = 0;
refresh_screen ();
break;
#ifdef KEY_LEFT
case KEY_LEFT:
#endif
case 'H':
case 'h':
port--;
if (port < 0)
port = unit->nports - 1;
scr_opt = 2;
break;
#ifdef KEY_RIGHT
case KEY_RIGHT:
#endif
case 'L':
case 'l':
port++;
if (port >= (int) unit->nports)
port = 0;
scr_opt = 2;
break;
#ifdef KEY_UP
case KEY_UP:
#endif
case 'K':
case 'k':
{
int curr_unit = unit->unit_number;
do {
curr_unit--;
if (curr_unit < 0)
curr_unit = num_devices - 1;
}
while (device_info[curr_unit].status != UP);
unit = &device_info[curr_unit];
if (port >= (int) unit->nports)
port = unit->nports - 1;
}
scr_opt = 1;
break;
#ifdef KEY_DOWN
case KEY_DOWN:
#endif
case 'J':
case 'j':
{
int curr_unit = unit->unit_number;
do {
if (curr_unit < num_devices - 1)
curr_unit++;
else
curr_unit = 0;
}
while (device_info[curr_unit].status != UP);
unit = &device_info[curr_unit];
if (port >= (int) unit->nports)
port = unit->nports - 1;
}
scr_opt = 1;
break;
case 'q':
case 'Q':
case ESC:
hide_panel (GetPan(ChanWin));
erase_win (ChanWin);
update_panels ();
doupdate ();
scr_opt = 0;
break;
case 'T':
case 't':
scr_opt = 0;
hide_panel (GetPan(ChanWin));
update_panels ();
doupdate ();
handle_loopback(unit, &node, &chan, port);
change_term (0, TIMEOUT);
show_panel (GetPan(ChanWin));
update_panels ();
doupdate ();
wrefresh (chanwin);
break;
case 'D':
case 'd':
scr_opt = 0;
{
int invoke_one = 1;
while (invoke_one)
{
if (d_invokes_capture)
{
invoke_one = handle_scope (unit, &node, &chan, port);
}
else
{
invoke_one = handle_exam (unit, &node, port);
}
if (invoke_one)
d_invokes_capture = 1 - d_invokes_capture;
}
}
touchwin (chanwin);
wrefresh (chanwin);
update_panels ();
doupdate ();
break;
#ifdef KEY_PRINT
case KEY_PRINT:
#endif
case '':
scr_opt = 0;
screen_save (ChanWin, logfile);
touchwin (chanwin);
wrefresh (chanwin);
update_panels ();
doupdate ();
break;
case KEY_F (1): /* Help info */
case '?':
scr_opt = 0;
info_screen (dpa_info2, dpa_info2_len, NULL);
update_panels ();
doupdate ();
break;
default:
scr_opt = 0;
mvwprintw (chanwin, 16, 60, "Invalid key");
wrefresh (chanwin);
sleep (1);
mvwprintw (chanwin, 16, 60, " ");
wrefresh (chanwin);
break;
} /* End Case */
} /* End While */
}
/*
* Display a temporary window listing the keystroke-commands we recognize.
*/
void
help_edit_field(void)
{
int x0 = 4;
int y0 = 2;
int y1 = 0;
int y2 = 0;
int wide = COLS - ((x0 + 1) * 2);
int high = LINES - ((y0 + 1) * 2);
WINDOW *help = newwin(high, wide, y0, x0);
WINDOW *data = newpad(2 + SIZEOF(commands), wide - 4);
unsigned n;
int ch = ERR;
begin_popup();
keypad(help, TRUE);
keypad(data, TRUE);
waddstr(data, "Defined form edit/traversal keys:\n");
for (n = 0; n < SIZEOF(commands); ++n) {
const char *name;
#ifdef NCURSES_VERSION
if ((name = form_request_name(commands[n].result)) == 0)
#endif
name = commands[n].help;
wprintw(data, "%s -- %s\n",
keyname(commands[n].code),
name != 0 ? name : commands[n].help);
}
waddstr(data, "Arrow keys move within a field as you would expect.");
y2 = getcury(data);
do {
switch (ch) {
case KEY_HOME:
y1 = 0;
break;
case KEY_END:
y1 = y2;
break;
case KEY_PREVIOUS:
case KEY_PPAGE:
if (y1 > 0) {
y1 -= high / 2;
if (y1 < 0)
y1 = 0;
} else {
beep();
}
break;
case KEY_NEXT:
case KEY_NPAGE:
if (y1 < y2) {
y1 += high / 2;
if (y1 >= y2)
y1 = y2;
} else {
beep();
}
break;
case CTRL('P'):
case KEY_UP:
if (y1 > 0)
--y1;
else
beep();
break;
case CTRL('N'):
case KEY_DOWN:
if (y1 < y2)
++y1;
else
beep();
break;
default:
beep();
break;
case ERR:
break;
}
werase(help);
box(help, 0, 0);
wnoutrefresh(help);
pnoutrefresh(data, y1, 0, y0 + 1, x0 + 1, high, wide);
doupdate();
} while ((ch = wgetch(data)) != ERR && ch != QUIT && ch != ESCAPE);
werase(help);
wrefresh(help);
delwin(help);
delwin(data);
end_popup();
}
void
show_interactive_menu (void)
{
int search_win = 0;
int time_win = 0;
int i;
int y,
x;
time_t t;
WINDOW *win = initscr ();
start_color ();
cbreak ();
noecho ();
nonl ();
intrflush (win, FALSE);
curs_set (0);
keypad (win, TRUE);
while (1)
{
werase (win);
getmaxyx (win, y, x);
time (&t);
/*
* Check if there is enough horizontal space to draw the package
* name, version and date+time.
*/
if (x > strlen (PACKAGE_NAME) + strlen (PACKAGE_VERSION) + 28)
{
wmove (win, 0, 1);
waddstr (win, PACKAGE_NAME);
wmove (win, 0, (x - 24) / 2);
attrset (A_BOLD);
waddnstr (win, ctime (&t), 24);
attrset (A_NORMAL);
wmove (win, 0, x - strlen (PACKAGE_VERSION) - 1);
waddstr (win, PACKAGE_VERSION);
} else
{
/*
* Check if there is enough horizontal space to draw the package
* name and date+time.
*/
if (x > strlen (PACKAGE_NAME) + 26)
{
wmove (win, 0, 1);
waddstr (win, PACKAGE_NAME);
wmove (win, 0, x - 25);
waddnstr (win, ctime (&t), 24);
} else
{
/*
* Check if there is enough horizontal space to draw the
* date+time.
*/
if (x >= 24)
{
wmove (win, 0, (x - 24) / 2);
waddnstr (win, ctime (&t), 24);
}
}
}
wmove (win, y - 1, 0);
//waddnstr (win, "3.3k records", 12);
waddnstr (win, "<CONN ERROR>", 12);
wmove (win, y - 1, x - 5);
waddnstr (win, "user", 4);
/* Draw a horizontal line */
wmove (win, 1, 0);
hline ('-', x);
wmove (win, 1, x - 4);
waddstr (win, "[R]");
wmove (win, 1, x - 8);
waddstr (win, "[A]");
wmove (win, 1, x - 30);
waddstr (win, "[Time ]");
wmove (win, 1, x - 60);
waddstr (win, "[Value ]");
wmove (win, 1, 0);
waddstr (win, "[Item ]");
if (time_win)
{
show_timeframe_dialog (win, 1, 5);
}
if (search_win)
{
show_search_dialog (win, 1, 5);
}
if (time_win == search_win)
{
/* Draw slider */
wmove (win, 3, x - 1);
vline (' ' | A_REVERSE, y - 4);
wmove (win, 2, x - 1);
addch (ACS_UARROW | A_REVERSE);
wmove (win, 3, x - 1);
addch (' ');
wmove (win, y - 2, x - 1);
addch (ACS_DARROW | A_REVERSE);
/*******/
wmove (win, 2, 1);
waddstr (win,
"cpu.load.avg[1] | 0.12");
wmove (win, 2, x - 31);
waddstr (win,
"| 2015/01/04 12:23:34 | x |");
wmove (win, 3, 1);
waddstr (win,
"cpu.load.avg[5] | 0.12");
wmove (win, 3, x - 31);
waddstr (win,
"| 2015/01/04 12:23:34 | x |");
}
//waddch (win, i);
//waddch (win, i);
wmove (win, y, 0);
if (search_win == 1)
{
if (search_dialog_input () != 0)
{
search_win = 0;
}
} else
{
if (time_win == 1)
{
if (timeframe_dialog_input () != 0)
{
time_win = 0;
}
} else
{
i = wgetch (win);
if (i == 'q')
{
wclear (win);
wrefresh (win);
break;
}
if (i == 't')
{
time_win = 1;
wclear (win);
wrefresh (win);
}
if (i == '/')
{
search_win = 1;
wclear (win);
wrefresh (win);
}
}
}
}
endwin ();
}
void
put_bool(void *b)
{
waddstr(hw, *(bool *) b ? "True" : "False");
}
void
put_inv_t(void *ip)
{
waddstr(hw, inv_t_name[*(int *) ip]);
}
void emu_exception(struct em8051 *aCPU, int aCode)
{
WINDOW * exc;
switch (aCode)
{
case EXCEPTION_IRET_SP_MISMATCH:
if (opt_exception_iret_sp) return;
break;
case EXCEPTION_IRET_ACC_MISMATCH:
if (opt_exception_iret_acc) return;
break;
case EXCEPTION_IRET_PSW_MISMATCH:
if (opt_exception_iret_psw) return;
break;
case EXCEPTION_ACC_TO_A:
if (!opt_exception_acc_to_a) return;
break;
case EXCEPTION_STACK:
if (!opt_exception_stack) return;
break;
case EXCEPTION_ILLEGAL_OPCODE:
if (!opt_exception_invalid) return;
break;
}
nocbreak();
cbreak();
nodelay(stdscr, FALSE);
halfdelay(1);
while (getch() > 0) {}
runmode = 0;
setSpeed(speed, runmode);
exc = subwin(stdscr, 7, 50, (LINES-6)/2, (COLS-50)/2);
wattron(exc,A_REVERSE);
werase(exc);
box(exc,ACS_VLINE,ACS_HLINE);
mvwaddstr(exc, 0, 2, "Exception");
wattroff(exc,A_REVERSE);
wmove(exc, 2, 2);
switch (aCode)
{
case -1: waddstr(exc,"Breakpoint reached");
break;
case EXCEPTION_STACK: waddstr(exc,"SP exception: stack address > 127");
wmove(exc, 3, 2);
waddstr(exc,"with no upper memory, or SP roll over.");
break;
case EXCEPTION_ACC_TO_A: waddstr(exc,"Invalid operation: acc-to-a move operation");
break;
case EXCEPTION_IRET_PSW_MISMATCH: waddstr(exc,"PSW not preserved over interrupt call");
break;
case EXCEPTION_IRET_SP_MISMATCH: waddstr(exc,"SP not preserved over interrupt call");
break;
case EXCEPTION_IRET_ACC_MISMATCH: waddstr(exc,"ACC not preserved over interrupt call");
break;
case EXCEPTION_ILLEGAL_OPCODE: waddstr(exc,"Invalid opcode: 0xA5 encountered");
break;
default:
waddstr(exc,"Unknown exception");
}
wmove(exc, 6, 12);
wattron(exc,A_REVERSE);
waddstr(exc, "Press any key to continue");
wattroff(exc,A_REVERSE);
wrefresh(exc);
getch();
delwin(exc);
change_view(aCPU, MAIN_VIEW);
}
/*
* Display a dialog box for inputing a string
*/
int dialog_inputbox(const char *title, const char *prompt, int height,
int width, const char *init)
{
WINDOW *dialog;
unsigned char *instr = dialog_input_result;
int i, x, y, box_y, box_x, box_width;
int input_x = 0, scroll = 0, key = 0, button = -1;
/* center dialog box on screen */
x = (COLS - width) / 2;
y = (LINES - height) / 2;
draw_shadow(stdscr, y, x, height, width);
dialog = newwin(height, width, y, x);
keypad(dialog, TRUE);
draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr);
wattrset(dialog, border_attr);
mvwaddch(dialog, height - 3, 0, ACS_LTEE);
for (i = 0; i < width - 2; i++)
waddch(dialog, ACS_HLINE);
wattrset(dialog, dialog_attr);
waddch(dialog, ACS_RTEE);
if (title != NULL) {
wattrset(dialog, title_attr);
mvwaddch(dialog, 0, (width - strlen(title)) / 2 - 1, ' ');
waddstr(dialog, (char *) title);
waddch(dialog, ' ');
}
wattrset(dialog, dialog_attr);
print_autowrap(dialog, prompt, width - 2, 1, 3);
/* Draw the input field box */
box_width = width - 6;
getyx(dialog, y, x);
box_y = y + 2;
box_x = (width - box_width) / 2;
draw_box(dialog, y + 1, box_x - 1, 3, box_width + 2,
border_attr, dialog_attr);
print_buttons(dialog, height, width, 0);
/* Set up the initial value */
wmove(dialog, box_y, box_x);
wattrset(dialog, inputbox_attr);
if (!init)
instr[0] = '\0';
else
strcpy(instr, init);
input_x = strlen(instr);
if (input_x >= box_width) {
scroll = input_x - box_width + 1;
input_x = box_width - 1;
for (i = 0; i < box_width - 1; i++)
waddch(dialog, instr[scroll + i]);
} else
waddstr(dialog, instr);
wmove(dialog, box_y, box_x + input_x);
wrefresh(dialog);
while (key != ESC) {
key = wgetch(dialog);
if (button == -1) { /* Input box selected */
switch (key) {
case TAB:
case KEY_UP:
case KEY_DOWN:
break;
case KEY_LEFT:
continue;
case KEY_RIGHT:
continue;
case KEY_BACKSPACE:
case 127:
if (input_x || scroll) {
wattrset(dialog, inputbox_attr);
if (!input_x) {
scroll = scroll < box_width - 1 ?
0 : scroll - (box_width - 1);
wmove(dialog, box_y, box_x);
for (i = 0; i < box_width; i++)
waddch(dialog, instr[scroll + input_x + i] ?
instr[scroll + input_x + i] : ' ');
input_x = strlen(instr) - scroll;
} else
input_x--;
instr[scroll + input_x] = '\0';
mvwaddch(dialog, box_y, input_x + box_x, ' ');
wmove(dialog, box_y, input_x + box_x);
wrefresh(dialog);
}
continue;
default:
if (key < 0x100 && isprint(key)) {
if (scroll + input_x < MAX_LEN) {
wattrset(dialog, inputbox_attr);
instr[scroll + input_x] = key;
instr[scroll + input_x + 1] = '\0';
if (input_x == box_width - 1) {
scroll++;
wmove(dialog, box_y, box_x);
for (i = 0; i < box_width - 1; i++)
waddch(dialog, instr[scroll + i]);
} else {
wmove(dialog, box_y, input_x++ + box_x);
waddch(dialog, key);
}
wrefresh(dialog);
} else
flash(); /* Alarm user about overflow */
continue;
}
}
}
switch (key) {
case 'O':
case 'o':
delwin(dialog);
return 0;
case 'H':
case 'h':
delwin(dialog);
return 1;
case KEY_UP:
case KEY_LEFT:
switch (button) {
case -1:
button = 1; /* Indicates "Cancel" button is selected */
print_buttons(dialog, height, width, 1);
break;
case 0:
button = -1; /* Indicates input box is selected */
print_buttons(dialog, height, width, 0);
wmove(dialog, box_y, box_x + input_x);
wrefresh(dialog);
break;
case 1:
button = 0; /* Indicates "OK" button is selected */
print_buttons(dialog, height, width, 0);
break;
}
break;
case TAB:
case KEY_DOWN:
case KEY_RIGHT:
switch (button) {
case -1:
button = 0; /* Indicates "OK" button is selected */
print_buttons(dialog, height, width, 0);
break;
case 0:
button = 1; /* Indicates "Cancel" button is selected */
print_buttons(dialog, height, width, 1);
break;
case 1:
button = -1; /* Indicates input box is selected */
print_buttons(dialog, height, width, 0);
wmove(dialog, box_y, box_x + input_x);
wrefresh(dialog);
break;
}
break;
case ' ':
case '\n':
delwin(dialog);
return (button == -1 ? 0 : button);
case 'X':
case 'x':
key = ESC;
case ESC:
break;
}
}
delwin(dialog);
return -1; /* ESC pressed */
}
void emu_load(struct em8051 *aCPU)
{
WINDOW * exc;
int pos = 0;
int ch = 0;
int result;
pos = (int)strlen(filename);
runmode = 0;
setSpeed(speed, runmode);
exc = subwin(stdscr, 5, 50, (LINES-6)/2, (COLS-50)/2);
wattron(exc, A_REVERSE);
werase(exc);
box(exc,ACS_VLINE,ACS_HLINE);
mvwaddstr(exc, 0, 2, "Load Intel HEX File");
wattroff(exc, A_REVERSE);
wmove(exc, 2, 2);
// 12345678901234567890123456780123456789012345
waddstr(exc,"[____________________________________________]");
wmove(exc,2,3);
waddstr(exc, filename);
wrefresh(exc);
while (ch != '\n')
{
ch = getch();
if (ch > 31 && ch < 127 || ch > 127 && ch < 255)
{
if (pos < 44)
{
filename[pos] = ch;
pos++;
filename[pos] = 0;
waddch(exc,ch);
wrefresh(exc);
}
}
if (ch == KEY_DC || ch == 8 || ch == KEY_BACKSPACE)
{
if (pos > 0)
{
pos--;
filename[pos] = 0;
wmove(exc,2,3+pos);
waddch(exc,'_');
wmove(exc,2,3+pos);
wrefresh(exc);
}
}
}
result = load_obj(aCPU, filename);
delwin(exc);
refreshview(aCPU);
switch (result)
{
case -1:
emu_popup(aCPU, "Load error", "File not found.");
break;
case -2:
emu_popup(aCPU, "Load error", "Bad file format.");
break;
case -3:
emu_popup(aCPU, "Load error", "Unsupported HEX file version.");
break;
case -4:
emu_popup(aCPU, "Load error", "Checksum failure.");
break;
case -5:
emu_popup(aCPU, "Load error", "No end of data marker found.");
break;
}
}
int emu_readvalue(struct em8051 *aCPU, const char *aPrompt, int aOldvalue, int aValueSize)
{
WINDOW * exc;
int pos = 0;
int ch = 0;
char temp[16];
pos = aValueSize;
runmode = 0;
setSpeed(speed, runmode);
if (aValueSize == 2)
exc = subwin(stdscr, 5, 30, (LINES-6)/2, (COLS-30)/2);
else
exc = subwin(stdscr, 5, 50, (LINES-6)/2, (COLS-50)/2);
wattron(exc,A_REVERSE);
werase(exc);
box(exc,ACS_VLINE,ACS_HLINE);
mvwaddstr(exc, 0, 2, aPrompt);
wattroff(exc,A_REVERSE);
wmove(exc, 2, 2);
if (aValueSize == 2)
{
sprintf(temp, "%02X", aOldvalue);
waddstr(exc,"[__]");
wmove(exc,2,3);
waddstr(exc, temp);
}
else
{
sprintf(temp, "%04X", aOldvalue);
waddstr(exc,"[____]");
wmove(exc,2,3);
waddstr(exc, temp);
}
wrefresh(exc);
do
{
if (aValueSize == 2)
{
int currvalue = strtol(temp, NULL, 16);
wmove(exc,2,5 + aValueSize);
wprintw(exc,"%d %d %d %d %d %d %d %d",
(currvalue >> 7) & 1,
(currvalue >> 6) & 1,
(currvalue >> 5) & 1,
(currvalue >> 4) & 1,
(currvalue >> 3) & 1,
(currvalue >> 2) & 1,
(currvalue >> 1) & 1,
(currvalue >> 0) & 1);
}
else
{
int currvalue = strtol(temp, NULL, 16);
char assembly[64];
decode(aCPU, currvalue, assembly);
wmove(exc,2,5 + aValueSize);
waddstr(exc, " ");
wmove(exc,2,5 + aValueSize);
waddstr(exc, assembly);
}
wmove(exc,2,3 + pos);
wrefresh(exc);
ch = getch();
if (ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'f' || ch >= 'A' && ch <= 'F')
{
if (pos < aValueSize)
{
temp[pos] = ch;
pos++;
temp[pos] = 0;
waddch(exc,ch);
}
}
if (ch == KEY_DC || ch == 8 || ch == KEY_BACKSPACE)
{
if (pos > 0)
{
pos--;
temp[pos] = 0;
wmove(exc,2,3+pos);
waddch(exc,'_');
wmove(exc,2,3+pos);
}
}
}
// for emscripten
int wgetnstr(WINDOW *win, char *str, int n)
{
#ifdef PDC_WIDE
wchar_t wstr[MAXLINE + 1];
if (n < 0 || n > MAXLINE)
n = MAXLINE;
if (wgetn_wstr(win, (wint_t *)wstr, n) == ERR)
return ERR;
return PDC_wcstombs(str, wstr, n);
#else
int ch, i, num, x, chars;
char *p;
bool stop, oldecho, oldcbreak, oldnodelay;
PDC_LOG(("wgetnstr() - called\n"));
if (!win || !str)
return ERR;
chars = 0;
p = str;
stop = FALSE;
x = win->_curx;
oldcbreak = SP->cbreak; /* remember states */
oldecho = SP->echo;
oldnodelay = win->_nodelay;
SP->echo = FALSE; /* we do echo ourselves */
cbreak(); /* ensure each key is returned immediately */
win->_nodelay = FALSE; /* don't return -1 */
wrefresh(win);
while (!stop)
{
ch = wgetch(win);
switch (ch)
{
case '\t':
ch = ' ';
num = TABSIZE - (win->_curx - x) % TABSIZE;
for (i = 0; i < num; i++)
{
if (chars < n)
{
if (oldecho)
waddch(win, ch);
*p++ = ch;
++chars;
}
else
beep();
}
break;
case _ECHAR: /* CTRL-H -- Delete character */
if (p > str)
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
chars--;
}
break;
case _DLCHAR: /* CTRL-U -- Delete line */
while (p > str)
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
}
chars = 0;
break;
case _DWCHAR: /* CTRL-W -- Delete word */
while ((p > str) && (*(p - 1) == ' '))
{
if (oldecho)
waddstr(win, "\b \b");
--p; /* remove space */
chars--;
}
while ((p > str) && (*(p - 1) != ' '))
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
chars--;
}
break;
case '\n':
case '\r':
stop = TRUE;
if (oldecho)
waddch(win, '\n');
break;
default:
if (chars < n)
{
if (!SP->key_code && ch < 0x100)
{
*p++ = ch;
if (oldecho)
waddch(win, ch);
chars++;
}
}
else
beep();
break;
}
wrefresh(win);
}
*p = '\0';
SP->echo = oldecho; /* restore old settings */
SP->cbreak = oldcbreak;
win->_nodelay = oldnodelay;
return OK;
#endif
}
static void wgetnstr_async_1(void *arg)
{
char *p = wgetnstr_async__p;
char *str = wgetnstr_async__str;
int chars = wgetnstr_async__chars;
int n = wgetnstr_async__n;
WINDOW * win = wgetnstr_async__win;
bool oldecho = wgetnstr_async__oldecho;
bool oldcbreak = wgetnstr_async__oldcbreak;
bool oldnodelay = wgetnstr_async__oldnodelay;
int ch = (int)arg;
int i,num;
switch (ch)
{
case '\t':
ch = ' ';
num = TABSIZE - (win->_curx - wgetnstr_async__x) % TABSIZE;
for (i = 0; i < num; i++)
{
if (chars < n)
{
if (oldecho)
waddch(win, ch);
*p++ = ch;
++chars;
}
else
beep();
}
break;
case _ECHAR: /* CTRL-H -- Delete character */
if (p > str)
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
chars--;
}
break;
case _DLCHAR: /* CTRL-U -- Delete line */
while (p > str)
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
}
chars = 0;
break;
case _DWCHAR: /* CTRL-W -- Delete word */
while ((p > str) && (*(p - 1) == ' '))
{
if (oldecho)
waddstr(win, "\b \b");
--p; /* remove space */
chars--;
}
while ((p > str) && (*(p - 1) != ' '))
{
if (oldecho)
waddstr(win, "\b \b");
ch = (unsigned char)(*--p);
if ((ch < ' ') && (oldecho))
waddstr(win, "\b \b");
chars--;
}
break;
case '\n':
case '\r':
wgetnstr_async__stop = TRUE;
if (oldecho)
waddch(win, '\n');
break;
default:
if (chars < n)
{
if (!SP->key_code && ch < 0x100)
{
*p++ = ch;
if (oldecho)
waddch(win, ch);
chars++;
}
}
else
beep();
break;
}
wrefresh(win);
if(!wgetnstr_async__stop)
{
wgetnstr_async__p = p;
wgetnstr_async__str = str;
wgetnstr_async__chars = chars;
wgetch_async(win, wgetnstr_async_1);
}
else
{
*p = '\0';
SP->echo = oldecho; /* restore old settings */
SP->cbreak = oldcbreak;
win->_nodelay = oldnodelay;
(*wgetnstr_async__callback)((void*)OK);
}
}
int
get_monster_number(char *message)
{
int i;
int pres_monst = 1;
int ret_val = -1;
char buf[2 * LINELEN];
char monst_name[2 * LINELEN];
while (ret_val == -1)
{
msg("Which monster do you wish to %s? (* for list)", message);
if ((get_string(buf, cw)) != NORM)
return(0);
if ((i = atoi(buf)) != 0)
ret_val = i;
else if (buf[0] != '*')
{
for (i = 1; i < nummonst; i++)
if ((strcmp(monsters[i].m_name, buf) == 0))
ret_val = i;
}
/* The following hack should be redone by the windowing code */
else
while (pres_monst < nummonst) /* Print out the monsters */
{
int num_lines = LINES - 3;
wclear(hw);
touchwin(hw);
wmove(hw, 2, 0);
for (i = 0; i < num_lines && pres_monst < nummonst; i++)
{
sprintf(monst_name, "[%d] %s\n", pres_monst,
monsters[pres_monst].m_name);
waddstr(hw, monst_name);
pres_monst++;
}
if (pres_monst < nummonst)
{
mvwaddstr(hw, LINES - 1, 0, morestr);
wrefresh(hw);
wait_for(' ');
}
else
{
mvwaddstr(hw, 0, 0, "Which monster");
waddstr(hw, "? ");
wrefresh(hw);
}
}
get_monst:
get_string(monst_name, hw);
ret_val = atoi(monst_name);
if ((ret_val < 1 || ret_val > nummonst - 1))
{
mvwaddstr(hw, 0, 0, "Please enter a number in the displayed range -- ");
wrefresh(hw);
goto get_monst;
}
/* Set up for redraw */
clearok(cw, TRUE);
touchwin(cw);
}
return(ret_val);
}
// Force text to the input screen
void Terminal::in_print_(const char* input_){
cursX += cstrlen(input_);
waddstr(input_window, input_);
update_cursor_();
refresh_();
}
/* add the formatted text to the curses window 'w'. The window 'w'
* must already be initiatlized with curses
*/
static void _owl_fmtext_curs_waddstr(const owl_fmtext *f, WINDOW *w, int do_search)
{
/* char *tmpbuff; */
/* int position, trans1, trans2, trans3, len, lastsame; */
char *s, *p;
char attr;
short fg, bg, pair = 0;
if (w==NULL) {
owl_function_debugmsg("Hit a null window in owl_fmtext_curs_waddstr.");
return;
}
s = f->textbuff;
/* Set default attributes. */
attr = f->default_attrs;
fg = f->default_fgcolor;
bg = f->default_bgcolor;
_owl_fmtext_wattrset(w, attr);
_owl_fmtext_update_colorpair(fg, bg, &pair);
_owl_fmtext_wcolor_set(w, pair);
/* Find next possible format character. */
p = strchr(s, OWL_FMTEXT_UC_STARTBYTE_UTF8);
while(p) {
if (owl_fmtext_is_format_char(g_utf8_get_char(p))) {
/* Deal with all text from last insert to here. */
char tmp;
tmp = p[0];
p[0] = '\0';
if (owl_global_is_search_active(&g)) {
/* Search is active, so highlight search results. */
char tmp2;
int start, end;
while (owl_regex_compare(owl_global_get_search_re(&g), s, &start, &end) == 0) {
/* Prevent an infinite loop matching the empty string. */
if (end == 0)
break;
/* Found search string, highlight it. */
tmp2 = s[start];
s[start] = '\0';
waddstr(w, s);
s[start] = tmp2;
_owl_fmtext_wattrset(w, attr ^ OWL_FMTEXT_ATTR_REVERSE);
_owl_fmtext_wcolor_set(w, pair);
tmp2 = s[end];
s[end] = '\0';
waddstr(w, s + start);
s[end] = tmp2;
_owl_fmtext_wattrset(w, attr);
_owl_fmtext_wcolor_set(w, pair);
s += end;
}
}
/* Deal with remaining part of string. */
waddstr(w, s);
p[0] = tmp;
/* Deal with new attributes. Initialize to defaults, then
process all consecutive formatting characters. */
attr = f->default_attrs;
fg = f->default_fgcolor;
bg = f->default_bgcolor;
while (owl_fmtext_is_format_char(g_utf8_get_char(p))) {
_owl_fmtext_update_attributes(g_utf8_get_char(p), &attr, &fg, &bg);
p = g_utf8_next_char(p);
}
_owl_fmtext_wattrset(w, attr | f->default_attrs);
if (fg == OWL_COLOR_DEFAULT) fg = f->default_fgcolor;
if (bg == OWL_COLOR_DEFAULT) bg = f->default_bgcolor;
_owl_fmtext_update_colorpair(fg, bg, &pair);
_owl_fmtext_wcolor_set(w, pair);
/* Advance to next non-formatting character. */
s = p;
p = strchr(s, OWL_FMTEXT_UC_STARTBYTE_UTF8);
}
else {
p = strchr(p+1, OWL_FMTEXT_UC_STARTBYTE_UTF8);
}
}
if (s) {
waddstr(w, s);
}
wbkgdset(w, 0);
}
/*
* Print a string of text in a window, automatically wrap around to the
* next line if the string is too long to fit on one line. Newline
* characters '\n' are propperly processed. We start on a new line
* if there is no room for at least 4 nonblanks following a double-space.
*/
void print_autowrap(WINDOW * win, const char *prompt, int width, int y, int x)
{
int newl, cur_x, cur_y;
int prompt_len, room, wlen;
char tempstr[MAX_LEN + 1], *word, *sp, *sp2, *newline_separator = 0;
strcpy(tempstr, prompt);
prompt_len = strlen(tempstr);
if (prompt_len <= width - x * 2) { /* If prompt is short */
wmove(win, y, (width - prompt_len) / 2);
waddstr(win, tempstr);
} else {
cur_x = x;
cur_y = y;
newl = 1;
word = tempstr;
while (word && *word) {
sp = strpbrk(word, "\n ");
if (sp && *sp == '\n')
newline_separator = sp;
if (sp)
*sp++ = 0;
/* Wrap to next line if either the word does not fit,
or it is the first word of a new sentence, and it is
short, and the next word does not fit. */
room = width - cur_x;
wlen = strlen(word);
if (wlen > room ||
(newl && wlen < 4 && sp
&& wlen + 1 + strlen(sp) > room
&& (!(sp2 = strpbrk(sp, "\n "))
|| wlen + 1 + (sp2 - sp) > room))) {
cur_y++;
cur_x = x;
}
wmove(win, cur_y, cur_x);
waddstr(win, word);
getyx(win, cur_y, cur_x);
/* Move to the next line if the word separator was a newline */
if (newline_separator) {
cur_y++;
cur_x = x;
newline_separator = 0;
} else
cur_x++;
if (sp && *sp == ' ') {
cur_x++; /* double space */
while (*++sp == ' ') ;
newl = 1;
} else
newl = 0;
word = sp;
}
}
}
void
death(int monst)
{
char **dp = (char **) rip, *killer;
struct tm *lt;
time_t date;
char buf[80];
int c;
if (is_wearing(R_RESURRECT) || rnd(wizard ? 3 : 67) == 0)
{
int die = TRUE;
if (resurrect-- == 0)
msg("You've run out of lives.");
else if (!save_resurrect(ring_value(R_RESURRECT)))
msg("Your attempt to return from the grave fails.");
else
{
struct linked_list *item;
struct linked_list *next_item;
struct object *obj;
int rm, flags;
coord pos;
die = FALSE;
msg("You feel a sudden warmth and then nothingness.");
teleport();
if (ring_value(R_RESURRECT) > 1 && rnd(10))
{
pstats.s_hpt = 2 * pstats.s_const;
pstats.s_const = max(pstats.s_const - 1, 3);
}
else
{
for (item = pack; item != NULL; item = next_item)
{
obj = OBJPTR(item);
if (obj->o_flags & ISOWNED || obj->o_flags & ISPROT)
{
next_item = next(item);
continue;
}
flags = obj->o_flags;
obj->o_flags &= ~ISCURSED;
dropcheck(obj);
obj->o_flags = flags;
next_item = next(item);
rem_pack(obj);
if (obj->o_type == ARTIFACT)
has_artifact &= ~(1 << obj->o_which);
do
{
rm = rnd_room();
rnd_pos(&rooms[rm], &pos);
}
while(winat(pos.y, pos.x) != FLOOR);
obj->o_pos = pos;
add_obj(item, obj->o_pos.y, obj->o_pos.x);
}
pstats.s_hpt = pstats.s_const;
pstats.s_const = max(pstats.s_const - roll(2, 2), 3);
}
chg_str(roll(1, 4), TRUE, FALSE);
pstats.s_lvl = max(pstats.s_lvl, 1);
no_command += 2 + rnd(4);
if (on(player, ISHUH))
lengthen_fuse(FUSE_UNCONFUSE, rnd(8) + HUHDURATION);
else
light_fuse(FUSE_UNCONFUSE, 0, rnd(8) + HUHDURATION, AFTER);
turn_on(player, ISHUH);
light(&hero);
}
if (die)
{
wmove(cw, mpos, 0);
waddstr(cw, morestr);
wrefresh(cw);
wait_for(' ');
}
else
return;
}
time(&date);
lt = localtime(&date);
clear();
wclear(cw);
move(8, 0);
while (*dp)
printw("%s\n", *dp++);
mvaddstr(14, 28 - ((int)(strlen(whoami) + 1) / 2), whoami);
sprintf(buf, "%d+%ld Points", pstats.s_lvl, pstats.s_exp);
mvaddstr(15, 28 - ((int)(strlen(buf) + 1) / 2), buf);
killer = killname(monst,buf);
mvaddstr(17, 28 - ((int)(strlen(killer) + 1) / 2), killer);
mvaddstr(18, 28, (sprintf(prbuf, "%2d", lt->tm_year), prbuf));
move(LINES - 1, 0);
mvaddstr(LINES - 1, 0, retstr);
while ((c = readcharw(stdscr)) != '\n' && c != '\r')
continue;
idenpack();
wrefresh(cw);
refresh();
score(pstats.s_exp, pstats.s_lvl, KILLED, monst);
byebye();
}
void
put_str(void *str)
{
waddstr(hw, (char *) str);
}
/*
* Render the given form (and all of the widgets it contains) in the
* curses backing store. Does not cause the form to be displayed.
*/
void
curses_form_draw(struct curses_form *cf)
{
struct curses_widget *w;
float sb_factor = 0.0;
size_t sb_off = 0, sb_size = 0;
curses_colors_set(cf->win, CURSES_COLORS_NORMAL);
curses_window_blank(cf->win);
curses_colors_set(cf->win, CURSES_COLORS_BORDER);
/* draw_frame(cf->left - 1, cf->top - 1, cf->width + 2, cf->height + 2); */
wborder(cf->win, 0, 0, 0, 0, 0, 0, 0, 0);
/*
* If the internal dimensions of the form exceed the physical
* dimensions, draw scrollbar(s) as appropriate.
*/
if (cf->int_height > cf->height) {
sb_factor = (float)cf->height / (float)cf->int_height;
sb_size = cf->height * sb_factor;
if (sb_size == 0) sb_size = 1;
sb_off = cf->y_offset * sb_factor;
curses_colors_set(cf->win, CURSES_COLORS_SCROLLAREA);
mvwvline(cf->win, 1, cf->width + 1, ACS_CKBOARD, cf->height);
curses_colors_set(cf->win, CURSES_COLORS_SCROLLBAR);
mvwvline(cf->win, 1 + sb_off, cf->width + 1, ACS_BLOCK, sb_size);
}
if (cf->int_width > cf->width) {
sb_factor = (float)cf->width / (float)cf->int_width;
sb_size = cf->width * sb_factor;
if (sb_size == 0) sb_size = 1;
sb_off = cf->x_offset * sb_factor;
curses_colors_set(cf->win, CURSES_COLORS_SCROLLAREA);
mvwhline(cf->win, cf->height + 1, 1, ACS_CKBOARD, cf->width);
curses_colors_set(cf->win, CURSES_COLORS_SCROLLBAR);
mvwhline(cf->win, cf->height + 1, 1 + sb_off, ACS_BLOCK, sb_size);
}
curses_colors_set(cf->win, CURSES_COLORS_BORDER);
/*
* Render the title bar text.
*/
wmove(cf->win, 0, (cf->width - strlen(cf->title)) / 2 - 1);
waddch(cf->win, ACS_RTEE);
waddch(cf->win, ' ');
curses_colors_set(cf->win, CURSES_COLORS_FORMTITLE);
waddstr(cf->win, cf->title);
curses_colors_set(cf->win, CURSES_COLORS_BORDER);
waddch(cf->win, ' ');
waddch(cf->win, ACS_LTEE);
/*
* Render a "how to get help" reminder.
*/
if (cf->help_text != NULL) {
static const char *help_msg = "Press F1 for Help";
wmove(cf->win, cf->height + 1,
(cf->width - strlen(help_msg)) / 2 - 1);
waddch(cf->win, ACS_RTEE);
waddch(cf->win, ' ');
curses_colors_set(cf->win, CURSES_COLORS_FORMTITLE);
waddstr(cf->win, help_msg);
curses_colors_set(cf->win, CURSES_COLORS_BORDER);
waddch(cf->win, ' ');
waddch(cf->win, ACS_LTEE);
}
/*
* Render the widgets.
*/
for (w = cf->widget_head; w != NULL; w = w->next) {
curses_widget_draw(w);
}
/* to put the cursor there */
curses_widget_draw_tooltip(cf->widget_focus);
curses_widget_draw(cf->widget_focus);
}
int
get_str(void *vopt, WINDOW *win)
{
char *opt = (char *) vopt;
char *sp;
int oy, ox;
int i;
signed char c;
static char buf[MAXSTR];
getyx(win, oy, ox);
wrefresh(win);
/*
* loop reading in the string, and put it in a temporary buffer
*/
for (sp = buf; (c = readchar()) != '\n' && c != '\r' && c != ESCAPE;
wclrtoeol(win), wrefresh(win))
{
if (c == -1)
continue;
else if (c == erasechar() || c == 8 || c == 127) /* process erase character */
{
if (sp > buf)
{
sp--;
for (i = (int) strlen(unctrl(*sp)); i; i--)
waddch(win, '\b');
}
continue;
}
else if (c == killchar()) /* process kill character */
{
sp = buf;
wmove(win, oy, ox);
continue;
}
else if (sp == buf)
{
if (c == '-' && win != stdscr)
break;
else if (c == '~')
{
strcpy(buf, home);
waddstr(win, home);
sp += strlen(home);
continue;
}
}
if (sp >= &buf[MAXINP] || !(isprint(c) || c == ' '))
putchar(CTRL('G'));
else
{
*sp++ = c;
waddstr(win, unctrl(c));
}
}
*sp = '\0';
if (sp > buf) /* only change option if something has been typed */
strucpy(opt, buf, (int) strlen(buf));
mvwprintw(win, oy, ox, "%s\n", opt);
wrefresh(win);
if (win == stdscr)
mpos += (int)(sp - buf);
if (c == '-')
return MINUS;
else if (c == ESCAPE)
return QUIT;
else
return NORM;
}
static void
test_redraw(WINDOW *win)
{
static const char *help[] =
{
"Commands:",
" ^Q/ESC/q - quit",
" w - recur in a new window",
" ! - overwrite current line using stdio outside curses.",
#ifdef NCURSES_VERSION
" @ - run \"date\" command, to put its output on screen.",
#endif
" ^L - call redrawwin() for current window.",
" ^W - call wredrawln() for current line/current window.",
" arrow-keys - move cursor on the screen",
"",
"Other control characters are added to the screen in printable form.",
"Other printable characters are added to the screen as is.",
0
};
WINDOW *win1;
WINDOW *win2;
bool done = FALSE;
int ch, y, x;
int max_y, max_x;
int beg_y, beg_x;
assert(win != 0);
scrollok(win, TRUE);
keypad(win, TRUE);
getmaxyx(win, max_y, max_x);
getbegyx(win, beg_y, beg_x);
while (!done) {
ch = wgetch(win);
getyx(win, y, x);
switch (ch) {
case 'q':
/* FALLTHRU */
case QUIT:
case ESCAPE:
done = TRUE;
break;
case 'w':
win1 = newwin(max_y, max_x,
beg_y, beg_x);
win2 = newwin(max_y - 2, max_x - 2,
beg_y + 1, beg_x + 1);
box(win1, 0, 0);
wrefresh(win1);
test_redraw(win2);
delwin(win2);
delwin(win1);
touchwin(win);
break;
case '!':
/*
* redrawwin() and wredrawln() do not take into account the
* possibility that the cursor may have moved. That makes them
* cumbersome for using with a shell command. So we simply
* trash the current line of the window using backspace/overwrite.
*/
trash(beg_x, max_x, x + beg_x);
break;
#ifdef NCURSES_VERSION
case '@':
/*
* For a shell command, we can work around the problem noted above
* using mvcur(). It is ifdef'd for NCURSES, since X/Open does
* not define the case where the old location is unknown.
*/
IGNORE_RC(system("date"));
mvcur(-1, -1, y, x);
break;
#endif
case CTRL('W'):
redrawwin(win);
break;
case CTRL('L'):
wredrawln(win, y, 1);
break;
case KEY_UP:
if (y > 0)
wmove(win, y - 1, x);
break;
case KEY_DOWN:
if (y < max_y)
wmove(win, y + 1, x);
break;
case KEY_LEFT:
if (x > 0)
wmove(win, y, x - 1);
break;
case KEY_RIGHT:
if (x < max_x)
wmove(win, y, x + 1);
break;
case HELP_KEY_1:
popup_msg(win, help);
break;
default:
if (ch > KEY_MIN) {
waddstr(win, keyname(ch));
waddch(win, '\n');
} else {
waddstr(win, unctrl(UChar(ch)));
}
break;
}
wnoutrefresh(win);
doupdate();
}
}
void display_calibration()
{
char line[COLS];
s_mouse_cal* mcal = cal_get_mouse(current_mouse, current_conf);
if(current_cal == NONE)
{
mvaddstr(CAL_Y_P, CAL_X_P + 1, _("Mouse calibration (Ctrl+F1 to edit)"));
}
else
{
mvaddstr(CAL_Y_P, CAL_X_P + 1, _("Mouse calibration (Ctrl+F1 to save)(mouse wheel to change values)"));
}
clrtoeol();
wmove(wcal, 1, 1);
if(GE_GetMKMode() == GE_MK_MODE_MULTIPLE_INPUTS)
{
waddstr(wcal, "Mouse:");
if(current_cal == MC)
{
wattron(wcal, COLOR_PAIR(4));
}
snprintf(line, COLS, " %s (%d) (F1) ", GE_MouseName(current_mouse), GE_MouseVirtualId(current_mouse));
waddstr(wcal, line);
if(current_cal == MC)
{
wattron(wcal, COLOR_PAIR(1));
}
}
waddstr(wcal, _("Profile:"));
if(current_cal == CC)
{
wattron(wcal, COLOR_PAIR(4));
}
snprintf(line, COLS, " %d (F2)", current_conf + 1);
waddstr(wcal, line);
if(current_cal == CC)
{
wattron(wcal, COLOR_PAIR(1));
}
wclrtoeol(wcal);
mvwaddstr(wcal, 2, 1, _("Dead zone:"));
if(current_cal == DZX)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, " x=");
if(mcal->dzx)
{
snprintf(line, COLS, "%d", *mcal->dzx);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _("N/A"));
}
waddstr(wcal, " (F3)");
if(current_cal == DZX)
{
wattron(wcal, COLOR_PAIR(1));
}
if(current_cal == DZY)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, " y=");
if(mcal->dzy)
{
snprintf(line, COLS, "%d", *mcal->dzy);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _("N/A"));
}
waddstr(wcal, " (F4)");
if(current_cal == DZY)
{
wattron(wcal, COLOR_PAIR(1));
}
if(current_cal == DZS)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, _(" shape="));
if(mcal->dzs)
{
if (*mcal->dzs == E_SHAPE_CIRCLE)
{
waddstr(wcal, _("circle"));
}
else
{
waddstr(wcal, _("rectangle"));
}
}
else
{
waddstr(wcal, _(" N/A"));
}
waddstr(wcal, " (F5)");
if(current_cal == DZS)
{
wattron(wcal, COLOR_PAIR(1));
}
wclrtoeol(wcal);
mvwaddstr(wcal, 3, 1, _("Acceleration:"));
if(current_cal == TEST)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, _(" test (F6)"));
if(current_cal == TEST)
{
wattron(wcal, COLOR_PAIR(1));
}
if(current_cal == EX)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, " x=");
if(mcal->ex)
{
snprintf(line, COLS, "%.2f", *mcal->ex);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _("N/A"));
}
waddstr(wcal, " (F7)");
if(current_cal == EX)
{
wattron(wcal, COLOR_PAIR(1));
}
if(current_cal == EY)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, " y=");
if(mcal->ey)
{
snprintf(line, COLS, "%.2f", *mcal->ey);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _("N/A"));
}
waddstr(wcal, " (F8)");
if(current_cal == EY)
{
wattron(wcal, COLOR_PAIR(1));
}
wclrtoeol(wcal);
mvwaddstr(wcal, 4, 1, _("Sensitivity:"));
if(current_cal == MX)
{
wattron(wcal, COLOR_PAIR(4));
}
if(mcal->mx)
{
snprintf(line, COLS, " %.2f", *mcal->mx);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _(" N/A"));
}
waddstr(wcal, " (F9)");
if(current_cal == MX)
{
wattron(wcal, COLOR_PAIR(1));
}
wclrtoeol(wcal);
mvwaddstr(wcal, 5, 1, "X/Y:");
if(current_cal == RD || current_cal == VEL)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, _(" circle test"));
if(current_cal == RD || current_cal == VEL)
{
wattron(wcal, COLOR_PAIR(1));
}
waddstr(wcal, ", ");
if(current_cal == RD)
{
wattron(wcal, COLOR_PAIR(4));
}
snprintf(line, COLS, _("radius=%d (F10)"), mcal->rd);
waddstr(wcal, line);
if(current_cal == RD)
{
wattron(wcal, COLOR_PAIR(1));
}
waddstr(wcal, ", ");
if(current_cal == VEL)
{
wattron(wcal, COLOR_PAIR(4));
}
snprintf(line, COLS, _("velocity=%d (F11)"), mcal->vel);
waddstr(wcal, line);
if(current_cal == VEL)
{
wattron(wcal, COLOR_PAIR(1));
}
if(current_cal == MY)
{
wattron(wcal, COLOR_PAIR(4));
}
waddstr(wcal, _(" ratio="));
if(mcal->mx && mcal->my)
{
snprintf(line, COLS, "%.2f", *mcal->my / *mcal->mx);
waddstr(wcal, line);
}
else
{
waddstr(wcal, _("N/A"));
}
waddstr(wcal, " (F12)");
if(current_cal == MY)
{
wattron(wcal, COLOR_PAIR(1));
}
wclrtoeol(wcal);
box(wcal, 0 , 0);
wnoutrefresh(wcal);
}
/*
* inventory:
* list what is in the pack
*/
int
inventory(struct linked_list *list, int type)
{
struct object *obj;
int ch;
int n_objs;
char inv_temp[80];
n_objs = 0;
for (ch = 'a'; list != NULL; ch++, list = next(list))
{
obj = (struct object *) ldata(list);
if (type && type != obj->o_type && !(type == CALLABLE &&
(obj->o_type == SCROLL || obj->o_type == POTION ||
obj->o_type == RING || obj->o_type == STICK)))
continue;
switch (n_objs++)
{
/*
* For the first thing in the inventory, just save the string
* in case there is only one.
*/
case 0:
sprintf(inv_temp, "%c) %s", ch, inv_name(obj, FALSE));
break;
/*
* If there is more than one, clear the screen, print the
* saved message and fall through to ...
*/
case 1:
if (slow_invent)
msg(inv_temp);
else
{
wclear(hw);
waddstr(hw, inv_temp);
waddch(hw, '\n');
}
/*
* Print the line for this object
*/
default:
if (slow_invent)
msg("%c) %s", ch, inv_name(obj, FALSE));
else
wprintw(hw, "%c) %s\n", ch, inv_name(obj, FALSE));
}
}
if (n_objs == 0)
{
if (terse)
msg(type == 0 ? "Empty handed." :
"Nothing appropriate");
else
msg(type == 0 ? "You are empty handed." :
"You don't have anything appropriate");
return FALSE;
}
if (n_objs == 1)
{
msg(inv_temp);
return TRUE;
}
if (!slow_invent)
{
mvwaddstr(hw, LINES-1, 0, "--Press space to continue--");
draw(hw);
wait_for(hw,' ');
clearok(cw, TRUE);
touchwin(cw);
}
return TRUE;
}
void
redraw_attr_dialog(void)
{
const char *title;
int x, y;
size_t title_len;
int need_ellipsis;
werase(change_win);
if(file_is_dir)
wresize(change_win, 22, 30);
else
wresize(change_win, 20, 30);
mvwaddstr(change_win, 3, 2, "Owner [ ] Read");
if(perms[0])
mvwaddch(change_win, 3, 9, (perms[0] < 0) ? 'X' : '*');
mvwaddstr(change_win, 4, 6, " [ ] Write");
if(perms[1])
mvwaddch(change_win, 4, 9, (perms[1] < 0) ? 'X' : '*');
mvwaddstr(change_win, 5, 6, " [ ] Execute");
if(perms[2])
mvwaddch(change_win, 5, 9, (perms[2] < 0) ? 'X' : '*');
mvwaddstr(change_win, 6, 6, " [ ] SetUID");
if(perms[3])
mvwaddch(change_win, 6, 9, (perms[3] < 0) ? 'X' : '*');
mvwaddstr(change_win, 8, 2, "Group [ ] Read");
if(perms[4])
mvwaddch(change_win, 8, 9, (perms[4] < 0) ? 'X' : '*');
mvwaddstr(change_win, 9, 6, " [ ] Write");
if(perms[5])
mvwaddch(change_win, 9, 9, (perms[5] < 0) ? 'X' : '*');
mvwaddstr(change_win, 10, 6, " [ ] Execute");
if(perms[6])
mvwaddch(change_win, 10, 9, (perms[6] < 0) ? 'X' : '*');
mvwaddstr(change_win, 11, 6, " [ ] SetGID");
if(perms[7])
mvwaddch(change_win, 11, 9, (perms[7] < 0) ? 'X' : '*');
mvwaddstr(change_win, 13, 2, "Other [ ] Read");
if(perms[8])
mvwaddch(change_win, 13, 9, (perms[8] < 0) ? 'X' : '*');
mvwaddstr(change_win, 14, 6, " [ ] Write");
if(perms[9])
mvwaddch(change_win, 14, 9, (perms[9] < 0) ? 'X' : '*');
mvwaddstr(change_win, 15, 6, " [ ] Execute");
if(perms[10])
mvwaddch(change_win, 15, 9, (perms[10] < 0) ? 'X' : '*');
mvwaddstr(change_win, 16, 6, " [ ] Sticky");
if(perms[11])
mvwaddch(change_win, 16, 9, (perms[11] < 0) ? 'X' : '*');
if(file_is_dir)
mvwaddstr(change_win, 18, 6, " [ ] Set Recursively");
getmaxyx(stdscr, y, x);
mvwin(change_win, (y - (20 + (file_is_dir != 0)*2))/2, (x - 30)/2);
box(change_win, 0, 0);
x = getmaxx(change_win);
title = get_title();
title_len = strlen(title);
need_ellipsis = (title_len > (size_t)x - 2);
if(need_ellipsis)
{
x -= 3;
title_len = x;
}
mvwaddnstr(change_win, 0, (getmaxx(change_win) - title_len)/2, title, x - 2);
if(need_ellipsis)
{
waddstr(change_win, "...");
}
curs_set(1);
checked_wmove(change_win, curr, col);
wrefresh(change_win);
}
void menu_photorec(struct ph_param *params, struct ph_options *options, alloc_data_t*list_search_space)
{
list_part_t *list_part;
#ifdef HAVE_NCURSES
list_part_t *current_element;
unsigned int current_element_num;
int done=0;
int command;
unsigned int offset=0;
unsigned int menu=0;
static const struct MenuItem menuMain[]=
{
{'S',"Search","Start file recovery"},
{'O',"Options","Modify options"},
{'F',"File Opt","Modify file options"},
{'G',"Geometry", "Change disk geometry" },
{'Q',"Quit","Return to disk selection"},
{0,NULL,NULL}
};
#endif
params->blocksize=0;
list_part=init_list_part(params->disk, options);
if(list_part==NULL)
return;
log_all_partitions(params->disk, list_part);
if(params->cmd_run!=NULL)
{
if(menu_photorec_cli(list_part, params, options, list_search_space) > 0)
{
if(params->recup_dir==NULL)
{
char *res;
#ifdef HAVE_NCURSES
res=ask_location("Please select a destination to save the recovered files.\nDo not choose to write the files to the same partition they were stored on.", "", NULL);
#else
res=get_default_location();
#endif
if(res!=NULL)
{
params->recup_dir=(char *)MALLOC(strlen(res)+1+strlen(DEFAULT_RECUP_DIR)+1);
strcpy(params->recup_dir,res);
strcat(params->recup_dir,"/");
strcat(params->recup_dir,DEFAULT_RECUP_DIR);
free(res);
}
}
if(params->recup_dir!=NULL)
photorec(params, options, list_search_space);
}
}
if(params->cmd_run!=NULL)
{
part_free_list(list_part);
return;
}
#ifdef HAVE_NCURSES
if(list_part->next!=NULL)
{
current_element_num=1;
current_element=list_part->next;
}
else
{
current_element_num=0;
current_element=list_part;
}
while(done==0)
{ /* ncurses interface */
list_part_t *element;
unsigned int i;
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",params->disk->description_short(params->disk));
mvwaddstr(stdscr,6,0,msg_PART_HEADER_LONG);
#if defined(KEY_MOUSE) && defined(ENABLE_MOUSE)
mousemask(ALL_MOUSE_EVENTS, NULL);
#endif
for(i=0,element=list_part; element!=NULL && i<offset+INTER_SELECT;element=element->next,i++)
{
if(i<offset)
continue;
wmove(stdscr,7+i-offset,0);
wclrtoeol(stdscr); /* before addstr for BSD compatibility */
if(element==current_element)
{
wattrset(stdscr, A_REVERSE);
waddstr(stdscr, ">");
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,params->disk,element->part);
wattroff(stdscr, A_REVERSE);
} else
{
waddstr(stdscr, " ");
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,params->disk,element->part);
}
}
wmove(stdscr,7+INTER_SELECT,5);
wclrtoeol(stdscr);
if(element!=NULL)
wprintw(stdscr, "Next");
command = wmenuSelect(stdscr, INTER_SELECT_Y+1, INTER_SELECT_Y, INTER_SELECT_X, menuMain, 8,
(options->expert==0?"SOFQ":"SOFGQ"), MENU_HORIZ | MENU_BUTTON | MENU_ACCEPT_OTHERS, menu);
#if defined(KEY_MOUSE) && defined(ENABLE_MOUSE)
if(command == KEY_MOUSE)
{
MEVENT event;
if(getmouse(&event) == OK)
{ /* When the user clicks left mouse button */
if((event.bstate & BUTTON1_CLICKED) || (event.bstate & BUTTON1_DOUBLE_CLICKED))
{
if(event.y >=7 && event.y<7+INTER_SELECT)
{
/* Disk selection */
while(current_element_num > event.y-(7-offset) && current_element->prev!=NULL)
{
current_element=current_element->prev;
current_element_num--;
}
while(current_element_num < event.y-(7-offset) && current_element->next!=NULL)
{
current_element=current_element->next;
current_element_num++;
}
if(event.bstate & BUTTON1_DOUBLE_CLICKED)
command='S';
}
else
command = menu_to_command(INTER_SELECT_Y+1, INTER_SELECT_Y, INTER_SELECT_X, menuMain, 8,
(options->expert==0?"SOFQ":"SOFGQ"), MENU_HORIZ | MENU_BUTTON | MENU_ACCEPT_OTHERS, event.y, event.x);
}
}
}
#endif
switch(command)
{
case KEY_UP:
if(current_element!=NULL && current_element->prev!=NULL)
{
current_element=current_element->prev;
current_element_num--;
}
break;
case KEY_PPAGE:
for(i=0; (signed)i<INTER_SELECT && current_element->prev!=NULL; i++)
{
current_element=current_element->prev;
current_element_num--;
}
break;
case KEY_DOWN:
if(current_element->next!=NULL)
{
current_element=current_element->next;
current_element_num++;
}
break;
case KEY_NPAGE:
for(i=0; (signed)i<INTER_SELECT && current_element->next!=NULL; i++)
{
current_element=current_element->next;
current_element_num++;
}
break;
case 's':
case 'S':
if(current_element!=NULL)
{
params->partition=current_element->part;
ask_mode_ext2(params->disk, params->partition, &options->mode_ext2, ¶ms->carve_free_space_only);
menu=0;
if(params->recup_dir==NULL)
{
char *res;
res=ask_location("Please select a destination to save the recovered files.\nDo not choose to write the files to the same partition they were stored on.", "", NULL);
if(res!=NULL)
{
params->recup_dir=(char *)MALLOC(strlen(res)+1+strlen(DEFAULT_RECUP_DIR)+1);
strcpy(params->recup_dir,res);
strcat(params->recup_dir,"/");
strcat(params->recup_dir,DEFAULT_RECUP_DIR);
free(res);
}
}
if(params->recup_dir!=NULL)
{
if(td_list_empty(&list_search_space->list))
{
init_search_space(list_search_space, params->disk, params->partition);
}
if(params->carve_free_space_only>0)
{
aff_copy(stdscr);
wmove(stdscr,5,0);
wprintw(stdscr, "Filesystem analysis, please wait...\n");
wrefresh(stdscr);
params->blocksize=remove_used_space(params->disk, params->partition, list_search_space);
/* Only free space is carved, list_search_space is modified.
* To carve the whole space, need to quit and reselect the params->partition */
done = 1;
}
photorec(params, options, list_search_space);
}
}
break;
case 'o':
case 'O':
{
interface_options_photorec_ncurses(options);
menu=1;
}
break;
case 'f':
case 'F':
interface_file_select_ncurses(options->list_file_format);
menu=2;
break;
case 'g':
case 'G':
if(options->expert!=0)
if(change_geometry_ncurses(params->disk))
done=1;
break;
case 'a':
case 'A':
if(params->disk->arch != &arch_none)
{
list_part=add_partition_ncurses(params->disk, list_part);
current_element=list_part;
current_element_num=0;
}
break;
case 'q':
case 'Q':
done = 1;
break;
}
if(current_element_num<offset)
offset=current_element_num;
if(current_element_num>=offset+INTER_SELECT)
offset=current_element_num-INTER_SELECT+1;
}
#endif
log_info("\n");
part_free_list(list_part);
}
void Screen::PrintFront(WINDOW * const window) const {
const int dir=player->Dir();
if ( UP==dir || DOWN==dir ) {
wstandend(window);
werase(window);
box(window, 0, 0);
mvwaddstr(window, 0, 1, "No view");
wnoutrefresh(window);
return;
}
short x_step, z_step,
x_end, z_end,
* x, * z,
i, j, k;
const ushort pX=player->X();
const ushort pY=player->Y();
const ushort pZ=player->Z();
const ushort begin_x = ( pX/SHRED_WIDTH )*SHRED_WIDTH +
( SHRED_WIDTH-SCREEN_SIZE )/2;
const ushort begin_y = ( pY/SHRED_WIDTH )*SHRED_WIDTH +
( SHRED_WIDTH-SCREEN_SIZE )/2;
ushort x_start, z_start, k_start;
ushort arrow_Y, arrow_X;
switch ( dir ) {
case NORTH:
x=&i;
x_step=1;
x_start=begin_x;
x_end=x_start+SCREEN_SIZE;
z=&j;
z_step=-1;
z_start=pY-1;
z_end=pY-SHRED_WIDTH-1;
arrow_X=(pX-begin_x)*2+1;
break;
case SOUTH:
x=&i;
x_step=-1;
x_start=SCREEN_SIZE-1+begin_x;
x_end=begin_x-1;
z=&j;
z_step=1;
z_start=pY+1;
z_end=pY+SHRED_WIDTH+1;
arrow_X=(SCREEN_SIZE-pX+begin_x)*2-1;
break;
case WEST:
x=&j;
x_step=-1;
x_start=SCREEN_SIZE-1+begin_y;
x_end=begin_y-1;
z=&i;
z_step=-1;
z_start=pX-1;
z_end=pX-SHRED_WIDTH-1;
arrow_X=(SCREEN_SIZE-pY+begin_y)*2-1;
break;
case EAST:
x=&j;
x_step=1;
x_start=begin_y;
x_end=SCREEN_SIZE+begin_y;
z=&i;
z_step=1;
z_start=pX+1;
z_end=pX+SHRED_WIDTH+1;
arrow_X=(pY-begin_y)*2+1;
break;
default:
fprintf(stderr,
"Screen::PrintFront(WINDOW *): \
unlisted dir: %d\n",
(int)dir);
return;
}
if ( pZ+SCREEN_SIZE/2>=HEIGHT ) {
k_start=HEIGHT-2;
arrow_Y=HEIGHT-pZ;
} else if ( pZ-SCREEN_SIZE/2<0 ) {
k_start=SCREEN_SIZE-1;
arrow_Y=SCREEN_SIZE-pZ;
} else {
k_start=pZ+SCREEN_SIZE/2;
arrow_Y=SCREEN_SIZE/2+1;
}
const int block_side=w->Anti(dir);
(void)wmove(window, 1, 1);
for (k=k_start; k_start-k<SCREEN_SIZE; --k, waddstr(window, "\n_")) {
for (*x=x_start; *x!=x_end; *x+=x_step) {
for (*z=z_start; *z!=z_end; *z+=z_step)
if ( w->Transparent(i, j, k) != INVISIBLE ) {
if ( (w->Enlightened(i, j, k,
block_side) &&
player->
Visible(i, j, k)) ||
player->
GetCreativeMode() )
{
PrintBlock(i, j, k, window);
waddch(window,
CharNumberFront(i, j));
} else {
wstandend(window);
waddch(window, OBSCURE_BLOCK);
waddch(window, ' ');
}
break;
}
if ( *z==z_end ) { //far decorations
*z-=z_step;
if ( player->Visible(i, j, k ) ) {
wcolor_set(window, Color(BLOCK, SKY),
NULL);
waddch(window, CharName(BLOCK, SKY));
} else {
wstandend(window);
waddch(window, OBSCURE_BLOCK);
}
waddch(window, ' ');
}
}
}
wstandend(window);
box(window, 0, 0);
switch ( dir ) {
case NORTH: mvwaddstr(window, 0, 1, "North view"); break;
case SOUTH: mvwaddstr(window, 0, 1, "South view"); break;
case EAST: mvwaddstr(window, 0, 1, "East view"); break;
case WEST: mvwaddstr(window, 0, 1, "West view"); break;
}
Arrows(window, arrow_X, arrow_Y);
if ( shiftFocus ) {
HorizontalArrows(window, arrow_Y-=shiftFocus, WHITE_BLUE);
}
wnoutrefresh(window);
}
void
redraw_file_info_dialog(void)
{
const dir_entry_t *entry;
char perm_buf[26];
char size_buf[56];
char buf[256];
#ifndef _WIN32
char id_buf[26];
#endif
int curr_y;
uint64_t size;
int size_not_precise;
assert(view != NULL);
if(resize_for_menu_like() != 0)
{
return;
}
werase(menu_win);
entry = &view->dir_entry[view->list_pos];
size = DCACHE_UNKNOWN;
if(entry->type == FT_DIR)
{
dcache_get_of(entry, &size, NULL);
}
if(size == DCACHE_UNKNOWN)
{
size = entry->size;
}
size_not_precise = friendly_size_notation(size, sizeof(size_buf), size_buf);
curr_y = 2;
curr_y += print_item("Path: ", entry->origin, curr_y);
curr_y += print_item("Name: ", entry->name, curr_y);
mvwaddstr(menu_win, curr_y, 2, "Size: ");
mvwaddstr(menu_win, curr_y, 8, size_buf);
if(size_not_precise)
{
snprintf(size_buf, sizeof(size_buf), " (%" PRId64 " bytes)", size);
waddstr(menu_win, size_buf);
}
curr_y += 2;
curr_y += show_file_type(view, curr_y);
curr_y += show_mime_type(view, curr_y);
#ifndef _WIN32
get_perm_string(perm_buf, sizeof(perm_buf), entry->mode);
curr_y += print_item("Permissions: ", perm_buf, curr_y);
#else
copy_str(perm_buf, sizeof(perm_buf), attr_str_long(entry->attrs));
curr_y += print_item("Attributes: ", perm_buf, curr_y);
#endif
format_time(entry->mtime, buf, sizeof(buf));
curr_y += print_item("Modified: ", buf, curr_y);
format_time(entry->atime, buf, sizeof(buf));
curr_y += print_item("Accessed: ", buf, curr_y);
format_time(entry->ctime, buf, sizeof(buf));
#ifndef _WIN32
curr_y += print_item("Changed: ", buf, curr_y);
#else
curr_y += print_item("Created: ", buf, curr_y);
#endif
#ifndef _WIN32
get_uid_string(entry, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Owner: ", id_buf, curr_y);
get_gid_string(entry, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Group: ", id_buf, curr_y);
#endif
/* Fake use after last assignment. */
(void)curr_y;
box(menu_win, 0, 0);
checked_wmove(menu_win, 0, 3);
wprint(menu_win, " File Information ");
wrefresh(menu_win);
was_redraw = 1;
}
int
mvaddstr(int y, int x, char *str)
{
return (wmove(stdscr, y, x) == ERR ? ERR : waddstr(stdscr, str));
}
/*
* Display text from a file in a dialog box.
*/
int
dialog_textbox (const char *title, const char *file, int height, int width)
{
int i, x, y, cur_x, cur_y, fpos, key = 0, dir, temp, temp1;
#ifdef HAVE_LIBNCURSES
int passed_end;
#endif
char search_term[MAX_LEN + 1], *tempptr, *found;
WINDOW *dialog, *text;
search_term[0] = '\0'; /* no search term entered yet */
/* Open input file for reading */
if ((fd = open (file, O_RDONLY)) == -1) {
endwin ();
fprintf (stderr,
"\nCan't open input file in dialog_textbox().\n");
exit (-1);
}
/* Get file size. Actually, 'file_size' is the real file size - 1,
since it's only the last byte offset from the beginning */
if ((file_size = lseek (fd, 0, SEEK_END)) == -1) {
endwin ();
fprintf (stderr, "\nError getting file size in dialog_textbox().\n");
exit (-1);
}
/* Restore file pointer to beginning of file after getting file size */
if (lseek (fd, 0, SEEK_SET) == -1) {
endwin ();
fprintf (stderr, "\nError moving file pointer in dialog_textbox().\n");
exit (-1);
}
/* Allocate space for read buffer */
if ((buf = malloc (BUF_SIZE + 1)) == NULL) {
endwin ();
fprintf (stderr, "\nCan't allocate memory in dialog_textbox().\n");
exit (-1);
}
if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
endwin ();
fprintf (stderr, "\nError reading file in dialog_textbox().\n");
exit (-1);
}
buf[bytes_read] = '\0'; /* mark end of valid data */
page = buf; /* page is pointer to start of page to be displayed */
/* center dialog box on screen */
x = (COLS - width) / 2;
y = (LINES - height) / 2;
#ifdef HAVE_LIBNCURSES
if (use_shadow)
draw_shadow (stdscr, y, x, height, width);
#endif
dialog = newwin (height, width, y, x);
mouse_setbase (x, y);
keypad (dialog, TRUE);
/* Create window for text region, used for scrolling text */
text = subwin (dialog, height - 4, width - 2, y + 1, x + 1);
keypad (text, TRUE);
/* register the new window, along with its borders */
mouse_mkbigregion (0, 0, height - 2, width, 1, 0, 2 /* not normal */ );
draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr);
wattrset (dialog, border_attr);
wmove (dialog, height - 3, 0);
waddch (dialog, ACS_LTEE);
for (i = 0; i < width - 2; i++)
waddch (dialog, ACS_HLINE);
wattrset (dialog, dialog_attr);
waddch (dialog, ACS_RTEE);
wmove (dialog, height - 2, 1);
for (i = 0; i < width - 2; i++)
waddch (dialog, ' ');
if (title != NULL) {
wattrset (dialog, title_attr);
wmove (dialog, 0, (width - strlen (title)) / 2 - 1);
waddch (dialog, ' ');
waddstr (dialog, title);
waddch (dialog, ' ');
}
print_button (dialog, " EXIT ", height - 2, width / 2 - 4, TRUE);
wnoutrefresh (dialog);
getyx (dialog, cur_y, cur_x); /* Save cursor position */
/* Print first page of text */
attr_clear (text, height - 4, width - 2, dialog_attr);
print_page (text, height - 4, width - 2);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
while ((key != ESC) && (key != '\n')) {
key = mouse_wgetch (dialog);
switch (key) {
case M_EVENT + 'E':
case 'E': /* Exit */
case 'e':
delwin (dialog);
free (buf);
close (fd);
return 0;
case 'g': /* First page */
case KEY_HOME:
if (!begin_reached) {
begin_reached = 1;
/* First page not in buffer? */
if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
endwin ();
fprintf (stderr,
"\nError moving file pointer in dialog_textbox().\n");
exit (-1);
}
if (fpos > bytes_read) { /* Yes, we have to read it in */
if (lseek (fd, 0, SEEK_SET) == -1) {
endwin ();
fprintf (stderr, "\nError moving file pointer in "
"dialog_textbox().\n");
exit (-1);
}
if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
endwin ();
fprintf (stderr,
"\nError reading file in dialog_textbox().\n");
exit (-1);
}
buf[bytes_read] = '\0';
}
page = buf;
print_page (text, height - 4, width - 2);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
}
break;
case 'G': /* Last page */
#ifdef HAVE_LIBNCURSES
case KEY_END:
#endif
end_reached = 1;
/* Last page not in buffer? */
if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
endwin ();
fprintf (stderr,
"\nError moving file pointer in dialog_textbox().\n");
exit (-1);
}
if (fpos < file_size) { /* Yes, we have to read it in */
if (lseek (fd, -BUF_SIZE, SEEK_END) == -1) {
endwin ();
fprintf (stderr,
"\nError moving file pointer in dialog_textbox().\n");
exit (-1);
}
if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
endwin ();
fprintf (stderr,
"\nError reading file in dialog_textbox().\n");
exit (-1);
}
buf[bytes_read] = '\0';
}
page = buf + bytes_read;
back_lines (height - 4);
print_page (text, height - 4, width - 2);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
break;
case 'K': /* Previous line */
case 'k':
case KEY_UP:
if (!begin_reached) {
back_lines (page_length + 1);
#ifdef HAVE_LIBNCURSES
/* We don't call print_page() here but use scrolling to ensure
faster screen update. However, 'end_reached' and
'page_length' should still be updated, and 'page' should
point to start of next page. This is done by calling
get_line() in the following 'for' loop. */
scrollok (text, TRUE);
wscrl (text, -1); /* Scroll text region down one line */
scrollok (text, FALSE);
page_length = 0;
passed_end = 0;
for (i = 0; i < height - 4; i++) {
if (!i) {
/* print first line of page */
print_line (text, 0, width - 2);
wnoutrefresh (text);
} else
/* Called to update 'end_reached' and 'page' */
get_line ();
if (!passed_end)
page_length++;
if (end_reached && !passed_end)
passed_end = 1;
}
#else
print_page (text, height - 4, width - 2);
#endif
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
}
break;
case 'B': /* Previous page */
case 'b':
case KEY_PPAGE:
if (begin_reached)
break;
back_lines (page_length + height - 4);
print_page (text, height - 4, width - 2);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x);
wrefresh (dialog);
break;
case 'J': /* Next line */
case 'j':
case KEY_DOWN:
if (!end_reached) {
begin_reached = 0;
scrollok (text, TRUE);
scroll (text); /* Scroll text region up one line */
scrollok (text, FALSE);
print_line (text, height - 5, width - 2);
#ifndef HAVE_LIBNCURSES
wmove (text, height - 5, 0);
waddch (text, ' ');
wmove (text, height - 5, width - 3);
waddch (text, ' ');
#endif
wnoutrefresh (text);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
}
break;
case ' ': /* Next page */
case KEY_NPAGE:
if (end_reached)
break;
begin_reached = 0;
print_page (text, height - 4, width - 2);
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x);
wrefresh (dialog);
break;
case '0': /* Beginning of line */
case 'H': /* Scroll left */
case 'h':
case KEY_LEFT:
if (hscroll <= 0)
break;
if (key == '0')
hscroll = 0;
else
hscroll--;
/* Reprint current page to scroll horizontally */
back_lines (page_length);
print_page (text, height - 4, width - 2);
wmove (dialog, cur_y, cur_x);
wrefresh (dialog);
break;
case 'L': /* Scroll right */
case 'l':
case KEY_RIGHT:
if (hscroll >= MAX_LEN)
break;
hscroll++;
/* Reprint current page to scroll horizontally */
back_lines (page_length);
print_page (text, height - 4, width - 2);
wmove (dialog, cur_y, cur_x);
wrefresh (dialog);
break;
case '/': /* Forward search */
case 'n': /* Repeat forward search */
case '?': /* Backward search */
case 'N': /* Repeat backward search */
/* set search direction */
dir = (key == '/' || key == 'n') ? 1 : 0;
if (dir ? !end_reached : !begin_reached) {
if (key == 'n' || key == 'N') {
if (search_term[0] == '\0') { /* No search term yet */
fprintf (stderr, "\a"); /* beep */
break;
}
} else
/* Get search term from user */
if (get_search_term (text, search_term, height - 4,
width - 2) == -1) {
/* ESC pressed in get_search_term().
Reprint page to clear box */
wattrset (text, dialog_attr);
back_lines (page_length);
print_page (text, height - 4, width - 2);
wmove (dialog, cur_y, cur_x);
wrefresh (dialog);
break;
}
/* Save variables for restoring in case search term
can't be found */
tempptr = page;
temp = begin_reached;
temp1 = end_reached;
if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
endwin ();
fprintf (stderr, "\nError moving file pointer in "
"dialog_textbox().\n");
exit (-1);
}
fpos -= bytes_read;
/* update 'page' to point to next (previous) line before
forward (backward) searching */
back_lines (dir ? page_length - 1 : page_length + 1);
found = NULL;
if (dir) /* Forward search */
while ((found = strstr (get_line (), search_term))
== NULL) {
if (end_reached)
break;
} else /* Backward search */
while ((found = strstr (get_line (), search_term))
== NULL) {
if (begin_reached)
break;
back_lines (2);
}
if (found == NULL) { /* not found */
fprintf (stderr, "\a"); /* beep */
/* Restore program state to that before searching */
if (lseek (fd, fpos, SEEK_SET) == -1) {
endwin ();
fprintf (stderr, "\nError moving file pointer in "
"dialog_textbox().\n");
exit (-1);
}
if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
endwin ();
fprintf (stderr, "\nError reading file in "
"dialog_textbox().\n");
exit (-1);
}
buf[bytes_read] = '\0';
page = tempptr;
begin_reached = temp;
end_reached = temp1;
/* move 'page' to point to start of current page in order to
re-print current page. Note that 'page' always points to
start of next page, so this is necessary */
back_lines (page_length);
} else /* Search term found */
back_lines (1);
/* Reprint page */
wattrset (text, dialog_attr);
print_page (text, height - 4, width - 2);
if (found != NULL)
print_position (dialog, height, width);
wmove (dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh (dialog);
} else /* no need to find */
fprintf (stderr, "\a"); /* beep */
break;
case ESC:
break;
}
}
delwin (dialog);
free (buf);
close (fd);
return -1; /* ESC pressed */
}
