/*
* Go back 'target' lines in text file. BUFSIZ has to be in 'size_t' range.
*/
static void
last_lines(MY_OBJ * obj, int target)
{
FILE *fp = obj->obj.input;
size_t inx;
int count = 0;
char buf[BUFSIZ + 1];
size_t size_to_read;
size_t size_as_read;
long offset = 0;
long fpos = 0;
if (fseek(fp, 0L, SEEK_END) == -1
|| (fpos = ftell(fp)) < 0)
dlg_exiterr("Error moving file pointer in last_lines().");
if (fpos != 0) {
++target;
for (;;) {
if (fpos >= BUFSIZ) {
size_to_read = BUFSIZ;
} else {
size_to_read = (size_t) fpos;
}
fpos = fpos - (long) size_to_read;
if (fseek(fp, fpos, SEEK_SET) == -1)
dlg_exiterr("Error moving file pointer in last_lines().");
size_as_read = fread(buf, sizeof(char), size_to_read, fp);
if (ferror(fp))
dlg_exiterr("Error reading file in last_lines().");
if (size_as_read == 0) {
fpos = 0;
offset = 0;
break;
}
offset += (long) size_as_read;
for (inx = size_as_read - 1; inx != 0; --inx) {
if (buf[inx] == '\n') {
if (++count > target)
break;
offset = (long) (inx + 1);
}
}
if (count > target) {
break;
} else if (fpos == 0) {
offset = 0;
break;
}
}
if (fseek(fp, fpos + offset, SEEK_SET) == -1)
dlg_exiterr("Error moving file pointer in last_lines().");
}
}
/*
* Return current line of text.
*/
static char *
get_line(MY_OBJ * obj)
{
FILE *fp = obj->obj.input;
int col = -(obj->hscroll);
int j, tmpint, ch;
do {
if (((ch = getc(fp)) == EOF) && !feof(fp))
dlg_exiterr("Error moving file pointer in get_line().");
else if (!feof(fp) && (ch != '\n')) {
if ((ch == TAB) && (dialog_vars.tab_correct)) {
tmpint = dialog_state.tab_len
- ((col + obj->hscroll) % dialog_state.tab_len);
for (j = 0; j < tmpint; j++) {
if (col >= 0 && col < MAX_LEN)
obj->line[col] = ' ';
++col;
}
} else {
if (col >= 0)
obj->line[col] = (char) ch;
++col;
}
if (col >= MAX_LEN)
break;
}
} while (!feof(fp) && (ch != '\n'));
if (col < 0)
col = 0;
obj->line[col] = '\0';
return obj->line;
}
static long
lseek_obj(MY_OBJ * obj, long offset, int mode)
{
long fpos;
if ((fpos = (long) lseek(obj->fd, (off_t) offset, mode)) == -1) {
switch (mode) {
case SEEK_CUR:
dlg_exiterr("Cannot get file position");
break;
case SEEK_END:
dlg_exiterr("Cannot seek to end of file");
break;
case SEEK_SET:
dlg_exiterr("Cannot set file position to %ld", offset);
break;
}
}
return fpos;
}
static void
lseek_set(MY_OBJ * obj, long offset)
{
long actual = lseek_obj(obj, offset, SEEK_SET);
if (actual != offset) {
dlg_exiterr("Cannot set file position to %ld (actual %ld)\n",
offset, actual);
}
}
static long
tabize(MY_OBJ * obj, long val, long *first_pos)
{
long fpos;
long i, count, begin_line;
char *buftab;
if (!dialog_vars.tab_correct)
return val;
fpos = ftell_obj(obj);
lseek_set(obj, fpos - obj->fd_bytes_read);
/* Allocate space for read buffer */
buftab = xalloc((size_t) val + 1);
if ((read(obj->fd, buftab, (size_t) val)) == -1)
dlg_exiterr("Error reading file in tabize().");
begin_line = count = 0;
if (first_pos != 0)
*first_pos = 0;
for (i = 0; i < val; i++) {
if ((first_pos != 0) && (count >= val)) {
*first_pos = find_first(obj, buftab, i);
break;
}
if (buftab[i] == TAB)
count += dialog_state.tab_len
- ((count - begin_line) % dialog_state.tab_len);
else if (buftab[i] == '\n') {
count++;
begin_line = count;
} else
count++;
}
lseek_set(obj, fpos);
free(buftab);
return count;
}
/*
* Display text from a pipe in a scrolling window.
*/
int
dialog_prgbox(const char *title,
const char *cprompt,
const char *command,
int height,
int width,
int pauseopt)
{
int code;
FILE *fp;
fp = dlg_popen(command, "r");
if (fp == NULL)
dlg_exiterr("pipe open failed: %s", command);
code = dlg_progressbox(title, cprompt, height, width, pauseopt, fp);
pclose(fp);
return code;
}
/*
* Display text from a file in a dialog box, like in a "tail -f".
*/
int
dialog_tailbox(const char *title, const char *file, int height, int width, int bg_task)
{
/* *INDENT-OFF* */
static DLG_KEYS_BINDING binding[] = {
HELPKEY_BINDINGS,
ENTERKEY_BINDINGS,
DLG_KEYS_DATA( DLGK_BEGIN, '0' ),
DLG_KEYS_DATA( DLGK_BEGIN, KEY_BEG ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, 'H' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, 'h' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, KEY_LEFT ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'L' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'l' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, KEY_RIGHT ),
END_KEYS_BINDING
};
/* *INDENT-ON* */
#ifdef KEY_RESIZE
int old_height = height;
int old_width = width;
#endif
int fkey;
int x, y, result, thigh;
WINDOW *dialog, *text;
const char **buttons = 0;
MY_OBJ *obj;
FILE *fd;
int min_width = 12;
/* Open input file for reading */
if ((fd = fopen(file, "rb")) == NULL)
dlg_exiterr("Can't open input file in dialog_tailbox().");
#ifdef KEY_RESIZE
retry:
#endif
dlg_auto_sizefile(title, file, &height, &width, 2, min_width);
dlg_print_size(height, width);
dlg_ctl_size(height, width);
x = dlg_box_x_ordinate(width);
y = dlg_box_y_ordinate(height);
thigh = height - ((2 * MARGIN) + (bg_task ? 0 : 2));
dialog = dlg_new_window(height, width, y, x);
dlg_mouse_setbase(x, y);
/* Create window for text region, used for scrolling text */
text = dlg_sub_window(dialog,
thigh,
width - (2 * MARGIN),
y + MARGIN,
x + MARGIN);
dlg_draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr);
dlg_draw_bottom_box(dialog);
dlg_draw_title(dialog, title);
dlg_draw_helpline(dialog, FALSE);
if (!bg_task) {
buttons = dlg_exit_label();
dlg_button_layout(buttons, &min_width);
dlg_draw_buttons(dialog, height - (2 * MARGIN), 0, buttons, FALSE,
FALSE, width);
}
(void) wmove(dialog, thigh, (MARGIN + 1));
(void) wnoutrefresh(dialog);
obj = dlg_calloc(MY_OBJ, 1);
assert_ptr(obj, "dialog_tailbox");
obj->obj.input = fd;
obj->obj.win = dialog;
obj->obj.handle_getc = handle_my_getc;
obj->obj.handle_input = bg_task ? handle_input : 0;
obj->obj.keep_bg = bg_task && dialog_vars.cant_kill;
obj->obj.bg_task = bg_task;
obj->text = text;
obj->buttons = buttons;
dlg_add_callback(&(obj->obj));
dlg_register_window(dialog, "tailbox", binding);
dlg_register_buttons(dialog, "tailbox", buttons);
/* Print last page of text */
dlg_attr_clear(text, thigh, getmaxx(text), dialog_attr);
repaint_text(obj);
if (bg_task) {
result = DLG_EXIT_OK;
} else {
int ch;
do {
ch = dlg_getc(dialog, &fkey);
#ifdef KEY_RESIZE
if (fkey && ch == KEY_RESIZE) {
/* reset data */
height = old_height;
width = old_width;
/* repaint */
dlg_clear();
dlg_del_window(dialog);
refresh();
dlg_mouse_free_regions();
dlg_button_layout(buttons, &min_width);
goto retry;
}
#endif
}
while (handle_my_getc(&(obj->obj), ch, fkey, &result));
}
dlg_mouse_free_regions();
return result;
}
/*
* Display text from a file in a dialog box.
*/
int
dialog_textbox(const char *title, const char *file, int height, int width)
{
/* *INDENT-OFF* */
static DLG_KEYS_BINDING binding[] = {
HELPKEY_BINDINGS,
ENTERKEY_BINDINGS,
DLG_KEYS_DATA( DLGK_GRID_DOWN, 'J' ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, 'j' ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, KEY_DOWN ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, 'H' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, 'h' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, KEY_LEFT ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'L' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'l' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, KEY_RIGHT ),
DLG_KEYS_DATA( DLGK_GRID_UP, 'K' ),
DLG_KEYS_DATA( DLGK_GRID_UP, 'k' ),
DLG_KEYS_DATA( DLGK_GRID_UP, KEY_UP ),
DLG_KEYS_DATA( DLGK_PAGE_FIRST, 'g' ),
DLG_KEYS_DATA( DLGK_PAGE_FIRST, KEY_HOME ),
DLG_KEYS_DATA( DLGK_PAGE_LAST, 'G' ),
DLG_KEYS_DATA( DLGK_PAGE_LAST, KEY_END ),
DLG_KEYS_DATA( DLGK_PAGE_LAST, KEY_LL ),
DLG_KEYS_DATA( DLGK_PAGE_NEXT, ' ' ),
DLG_KEYS_DATA( DLGK_PAGE_NEXT, KEY_NPAGE ),
DLG_KEYS_DATA( DLGK_PAGE_PREV, 'B' ),
DLG_KEYS_DATA( DLGK_PAGE_PREV, 'b' ),
DLG_KEYS_DATA( DLGK_PAGE_PREV, KEY_PPAGE ),
DLG_KEYS_DATA( DLGK_BEGIN, '0' ),
DLG_KEYS_DATA( DLGK_BEGIN, KEY_BEG ),
DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ),
DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ),
END_KEYS_BINDING
};
/* *INDENT-ON* */
#ifdef KEY_RESIZE
int old_height = height;
int old_width = width;
#endif
long fpos;
int x, y, cur_x, cur_y;
int key = 0, fkey;
int next = 0;
int i, code, passed_end;
char search_term[MAX_LEN + 1];
MY_OBJ obj;
WINDOW *dialog;
bool moved;
int result = DLG_EXIT_UNKNOWN;
int button = dlg_default_button();
int min_width = 12;
search_term[0] = '\0'; /* no search term entered yet */
memset(&obj, 0, sizeof(obj));
obj.begin_reached = TRUE;
obj.buffer_first = TRUE;
obj.end_reached = FALSE;
obj.buttons = dlg_exit_label();
/* Open input file for reading */
if ((obj.fd = open(file, O_RDONLY)) == -1)
dlg_exiterr("Can't open input file %s", file);
/* Get file size. Actually, 'file_size' is the real file size - 1,
since it's only the last byte offset from the beginning */
lseek_end(&obj, 0L);
/* Restore file pointer to beginning of file after getting file size */
lseek_set(&obj, 0L);
read_high(&obj, BUF_SIZE);
dlg_button_layout(obj.buttons, &min_width);
#ifdef KEY_RESIZE
retry:
#endif
moved = TRUE;
dlg_auto_sizefile(title, file, &height, &width, 2, min_width);
dlg_print_size(height, width);
dlg_ctl_size(height, width);
x = dlg_box_x_ordinate(width);
y = dlg_box_y_ordinate(height);
dialog = dlg_new_window(height, width, y, x);
dlg_register_window(dialog, "textbox", binding);
dlg_register_buttons(dialog, "textbox", obj.buttons);
dlg_mouse_setbase(x, y);
/* Create window for text region, used for scrolling text */
obj.text = dlg_sub_window(dialog, PAGE_LENGTH, PAGE_WIDTH, y + 1, x + 1);
/* register the new window, along with its borders */
dlg_mouse_mkbigregion(0, 0, PAGE_LENGTH + 2, width, KEY_MAX, 1, 1, 1 /* lines */ );
dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr);
dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr);
dlg_draw_title(dialog, title);
dlg_draw_buttons(dialog, PAGE_LENGTH + 2, 0, obj.buttons, button, FALSE, width);
(void) wnoutrefresh(dialog);
getyx(dialog, cur_y, cur_x); /* Save cursor position */
dlg_attr_clear(obj.text, PAGE_LENGTH, PAGE_WIDTH, dialog_attr);
while (result == DLG_EXIT_UNKNOWN) {
/*
* Update the screen according to whether we shifted up/down by a line
* or not.
*/
if (moved) {
if (next < 0) {
(void) scrollok(obj.text, TRUE);
(void) scroll(obj.text); /* Scroll text region up one line */
(void) scrollok(obj.text, FALSE);
print_line(&obj, PAGE_LENGTH - 1, PAGE_WIDTH);
(void) wnoutrefresh(obj.text);
} else if (next > 0) {
/*
* 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 'in_buf' should
* point to start of next page. This is done by calling
* get_line() in the following 'for' loop.
*/
(void) scrollok(obj.text, TRUE);
(void) wscrl(obj.text, -1); /* Scroll text region down one line */
(void) scrollok(obj.text, FALSE);
obj.page_length = 0;
passed_end = 0;
for (i = 0; i < PAGE_LENGTH; i++) {
if (!i) {
print_line(&obj, 0, PAGE_WIDTH); /* print first line of page */
(void) wnoutrefresh(obj.text);
} else
(void) get_line(&obj); /* Called to update 'end_reached' and 'in_buf' */
if (!passed_end)
obj.page_length++;
if (obj.end_reached && !passed_end)
passed_end = 1;
}
} else {
print_page(&obj, PAGE_LENGTH, PAGE_WIDTH);
}
print_position(&obj, dialog, height, width);
(void) wmove(dialog, cur_y, cur_x); /* Restore cursor position */
wrefresh(dialog);
}
moved = FALSE; /* assume we'll not move */
next = 0; /* ...but not scroll by a line */
key = dlg_mouse_wgetch(dialog, &fkey);
if (dlg_result_key(key, fkey, &result))
break;
if (!fkey && (code = dlg_char_to_button(key, obj.buttons)) >= 0) {
result = dlg_ok_buttoncode(code);
break;
}
if (fkey) {
switch (key) {
default:
if (is_DLGK_MOUSE(key)) {
result = dlg_exit_buttoncode(key - M_EVENT);
if (result < 0)
result = DLG_EXIT_OK;
} else {
beep();
}
break;
case DLGK_FIELD_NEXT:
button = dlg_next_button(obj.buttons, button);
if (button < 0)
button = 0;
dlg_draw_buttons(dialog,
height - 2, 0,
obj.buttons, button,
FALSE, width);
break;
case DLGK_FIELD_PREV:
button = dlg_prev_button(obj.buttons, button);
if (button < 0)
button = 0;
dlg_draw_buttons(dialog,
height - 2, 0,
obj.buttons, button,
FALSE, width);
break;
case DLGK_ENTER:
if (dialog_vars.nook)
result = DLG_EXIT_OK;
else
result = dlg_exit_buttoncode(button);
break;
case DLGK_PAGE_FIRST:
if (!obj.begin_reached) {
obj.begin_reached = 1;
/* First page not in buffer? */
fpos = ftell_obj(&obj);
if (fpos > obj.fd_bytes_read) {
/* Yes, we have to read it in */
lseek_set(&obj, 0L);
read_high(&obj, BUF_SIZE);
}
obj.in_buf = 0;
moved = TRUE;
}
break;
case DLGK_PAGE_LAST:
obj.end_reached = TRUE;
/* Last page not in buffer? */
fpos = ftell_obj(&obj);
if (fpos < obj.file_size) {
/* Yes, we have to read it in */
lseek_end(&obj, -BUF_SIZE);
read_high(&obj, BUF_SIZE);
}
obj.in_buf = obj.bytes_read;
back_lines(&obj, (long) PAGE_LENGTH);
moved = TRUE;
break;
case DLGK_GRID_UP: /* Previous line */
if (!obj.begin_reached) {
back_lines(&obj, obj.page_length + 1);
next = 1;
moved = TRUE;
}
break;
case DLGK_PAGE_PREV: /* Previous page */
case DLGK_MOUSE(KEY_PPAGE):
if (!obj.begin_reached) {
back_lines(&obj, obj.page_length + PAGE_LENGTH);
moved = TRUE;
}
break;
case DLGK_GRID_DOWN: /* Next line */
if (!obj.end_reached) {
obj.begin_reached = 0;
next = -1;
moved = TRUE;
}
break;
case DLGK_PAGE_NEXT: /* Next page */
case DLGK_MOUSE(KEY_NPAGE):
if (!obj.end_reached) {
obj.begin_reached = 0;
moved = TRUE;
}
break;
case DLGK_BEGIN: /* Beginning of line */
if (obj.hscroll > 0) {
obj.hscroll = 0;
/* Reprint current page to scroll horizontally */
back_lines(&obj, obj.page_length);
moved = TRUE;
}
break;
case DLGK_GRID_LEFT: /* Scroll left */
if (obj.hscroll > 0) {
obj.hscroll--;
/* Reprint current page to scroll horizontally */
back_lines(&obj, obj.page_length);
moved = TRUE;
}
break;
case DLGK_GRID_RIGHT: /* Scroll right */
if (obj.hscroll < MAX_LEN) {
obj.hscroll++;
/* Reprint current page to scroll horizontally */
back_lines(&obj, obj.page_length);
moved = TRUE;
}
break;
#ifdef KEY_RESIZE
case KEY_RESIZE:
/* reset data */
height = old_height;
width = old_width;
back_lines(&obj, obj.page_length);
/* repaint */
dlg_clear();
dlg_del_window(dialog);
refresh();
dlg_mouse_free_regions();
goto retry;
#endif
}
} else {
switch (key) {
case '/': /* Forward search */
case 'n': /* Repeat forward search */
case '?': /* Backward search */
case 'N': /* Repeat backward search */
moved = perform_search(&obj, height, width, key, search_term);
fkey = FALSE;
break;
default:
beep();
break;
}
}
}
dlg_del_window(dialog);
free(obj.buf);
(void) close(obj.fd);
dlg_mouse_free_regions();
return result;
}
/*
* Go back 'n' lines in text file. Called by dialog_textbox().
* 'in_buf' will be updated to point to the desired line in 'buf'.
*/
static void
back_lines(MY_OBJ * obj, long n)
{
int i;
long fpos;
long val_to_tabize;
obj->begin_reached = FALSE;
/* We have to distinguish between end_reached and !end_reached since at end
* of file, the line is not ended by a '\n'. The code inside 'if'
* basically does a '--in_buf' to move one character backward so as to
* skip '\n' of the previous line */
if (!obj->end_reached) {
/* Either beginning of buffer or beginning of file reached? */
if (obj->in_buf == 0) {
fpos = ftell_obj(obj);
if (fpos > obj->fd_bytes_read) { /* Not beginning of file yet */
/* We've reached beginning of buffer, but not beginning of file
* yet, so read previous part of file into buffer. Note that
* we only move backward for BUF_SIZE/2 bytes, but not BUF_SIZE
* bytes to avoid re-reading again in print_page() later
*/
/* Really possible to move backward BUF_SIZE/2 bytes? */
if (fpos < BUF_SIZE / 2 + obj->fd_bytes_read) {
/* No, move less than */
lseek_set(obj, 0L);
val_to_tabize = fpos - obj->fd_bytes_read;
} else { /* Move backward BUF_SIZE/2 bytes */
lseek_cur(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read));
val_to_tabize = BUF_SIZE / 2;
}
read_high(obj, BUF_SIZE);
obj->in_buf = tabize(obj, val_to_tabize, (long *) 0);
} else { /* Beginning of file reached */
obj->begin_reached = TRUE;
return;
}
}
obj->in_buf--;
if (obj->buf[obj->in_buf] != '\n')
/* Something's wrong... */
dlg_exiterr("Internal error in back_lines().");
}
/* Go back 'n' lines */
for (i = 0; i < n; i++) {
do {
if (obj->in_buf == 0) {
fpos = ftell_obj(obj);
if (fpos > obj->fd_bytes_read) {
/* Really possible to move backward BUF_SIZE/2 bytes? */
if (fpos < BUF_SIZE / 2 + obj->fd_bytes_read) {
/* No, move less than */
lseek_set(obj, 0L);
val_to_tabize = fpos - obj->fd_bytes_read;
} else { /* Move backward BUF_SIZE/2 bytes */
lseek_cur(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read));
val_to_tabize = BUF_SIZE / 2;
}
read_high(obj, BUF_SIZE);
obj->in_buf = tabize(obj, val_to_tabize, (long *) 0);
} else { /* Beginning of file reached */
obj->begin_reached = TRUE;
return;
}
}
} while (obj->buf[--(obj->in_buf)] != '\n');
}
obj->in_buf++;
}
/*
* read_high() substitutes read() for tab->spaces conversion
*
* buffer_len, fd_bytes_read, bytes_read are modified
* buf is allocated
*
* fd_bytes_read is the effective number of bytes read from file
* bytes_read is the length of buf, that can be different if tab_correct
*/
static void
read_high(MY_OBJ * obj, size_t size_read)
{
char *buftab, ch;
int i = 0, j, n, tmpint;
long begin_line;
/* Allocate space for read buffer */
buftab = xalloc(size_read + 1);
if ((obj->fd_bytes_read = read(obj->fd, buftab, size_read)) != -1) {
buftab[obj->fd_bytes_read] = '\0'; /* mark end of valid data */
if (dialog_vars.tab_correct) {
/* calculate bytes_read by buftab and fd_bytes_read */
obj->bytes_read = begin_line = 0;
for (j = 0; j < obj->fd_bytes_read; j++)
if (buftab[j] == TAB)
obj->bytes_read += dialog_state.tab_len
- ((obj->bytes_read - begin_line)
% dialog_state.tab_len);
else if (buftab[j] == '\n') {
obj->bytes_read++;
begin_line = obj->bytes_read;
} else
obj->bytes_read++;
if (obj->bytes_read > obj->buffer_len) {
if (obj->buffer_first)
obj->buffer_first = FALSE; /* disp = 0 */
else {
free(obj->buf);
}
obj->buffer_len = obj->bytes_read;
/* Allocate space for read buffer */
obj->buf = xalloc((size_t) obj->buffer_len + 1);
}
} else {
if (obj->buffer_first) {
obj->buffer_first = FALSE;
/* Allocate space for read buffer */
obj->buf = xalloc(size_read + 1);
}
obj->bytes_read = obj->fd_bytes_read;
}
j = 0;
begin_line = 0;
while (j < obj->fd_bytes_read)
if (((ch = buftab[j++]) == TAB) && (dialog_vars.tab_correct != 0)) {
tmpint = (dialog_state.tab_len
- ((int) ((long) i - begin_line) % dialog_state.tab_len));
for (n = 0; n < tmpint; n++)
obj->buf[i++] = ' ';
} else {
if (ch == '\n')
begin_line = i + 1;
obj->buf[i++] = ch;
}
obj->buf[i] = '\0'; /* mark end of valid data */
}
if (obj->bytes_read == -1)
dlg_exiterr("Error reading file");
free(buftab);
}
/*
* Create the configuration file
*/
void
dlg_create_rc(const char *filename)
{
unsigned i;
FILE *rc_file;
if ((rc_file = fopen(filename, "wt")) == NULL)
dlg_exiterr("Error opening file for writing in dlg_create_rc().");
fprintf(rc_file, "#\n\
# Run-time configuration file for dialog\n\
#\n\
# Automatically generated by \"dialog --create-rc <file>\"\n\
#\n\
#\n\
# Types of values:\n\
#\n\
# Number - <number>\n\
# String - \"string\"\n\
# Boolean - <ON|OFF>\n"
#ifdef HAVE_COLOR
"\
# Attribute - (foreground,background,highlight?)\n"
#endif
);
/* Print an entry for each configuration variable */
for (i = 0; i < VAR_COUNT; i++) {
fprintf(rc_file, "\n# %s\n", vars[i].comment);
switch (vars[i].type) {
case VAL_INT:
fprintf(rc_file, "%s = %d\n", vars[i].name,
*((int *) vars[i].var));
break;
case VAL_STR:
fprintf(rc_file, "%s = \"%s\"\n", vars[i].name,
(char *) vars[i].var);
break;
case VAL_BOOL:
fprintf(rc_file, "%s = %s\n", vars[i].name,
*((bool *) vars[i].var) ? "ON" : "OFF");
break;
}
}
#ifdef HAVE_COLOR
for (i = 0; i < (unsigned) dlg_color_count(); ++i) {
char buffer[MAX_LEN + 1];
unsigned j;
bool repeat = FALSE;
fprintf(rc_file, "\n# %s\n", dlg_color_table[i].comment);
for (j = 0; j != i; ++j) {
if (dlg_color_table[i].fg == dlg_color_table[j].fg
&& dlg_color_table[i].bg == dlg_color_table[j].bg
&& dlg_color_table[i].hilite == dlg_color_table[j].hilite) {
fprintf(rc_file, "%s = %s\n",
dlg_color_table[i].name,
dlg_color_table[j].name);
repeat = TRUE;
break;
}
}
if (!repeat) {
fprintf(rc_file, "%s = %s\n", dlg_color_table[i].name,
attr_to_str(buffer,
dlg_color_table[i].fg,
dlg_color_table[i].bg,
dlg_color_table[i].hilite));
}
}
#endif /* HAVE_COLOR */
dlg_dump_keys(rc_file);
(void) fclose(rc_file);
}
/*
* Read a character from the given window. Handle repainting here (to simplify
* things in the calling application). Also, if input-callback(s) are set up,
* poll the corresponding files and handle the updates, e.g., for displaying a
* tailbox.
*/
int
dlg_getc(WINDOW *win, int *fkey)
{
WINDOW *save_win = win;
int ch = ERR;
int before_chr;
int before_fkey;
int result;
bool done = FALSE;
bool literal = FALSE;
DIALOG_CALLBACK *p = 0;
int interval = (dialog_vars.timeout_secs * 1000);
time_t expired = time((time_t *) 0) + dialog_vars.timeout_secs;
time_t current;
if (may_handle_inputs())
wtimeout(win, WTIMEOUT_VAL);
else if (interval > 0)
wtimeout(win, interval);
while (!done) {
bool handle_others = FALSE;
/*
* If there was no pending file-input, check the keyboard.
*/
ch = really_getch(win, fkey);
if (literal) {
done = TRUE;
continue;
}
before_chr = ch;
before_fkey = *fkey;
ch = dlg_lookup_key(win, ch, fkey);
dlg_trace_chr(ch, *fkey);
current = time((time_t *) 0);
/*
* If we acquired a fkey value, then it is one of dialog's builtin
* codes such as DLGK_HELPFILE.
*/
if (!*fkey || *fkey != before_fkey) {
switch (ch) {
case CHR_LITERAL:
literal = TRUE;
keypad(win, FALSE);
continue;
case CHR_REPAINT:
(void) touchwin(win);
(void) wrefresh(curscr);
break;
case ERR: /* wtimeout() in effect; check for file I/O */
if (interval > 0
&& current >= expired) {
dlg_exiterr("timeout");
}
if (!valid_file(stdin)
|| !valid_file(dialog_state.screen_output)) {
ch = ESC;
done = TRUE;
} else if (check_inputs()) {
if (handle_inputs(win))
dlg_raise_window(win);
else
done = TRUE;
} else {
done = (interval <= 0);
}
break;
case DLGK_HELPFILE:
if (dialog_vars.help_file) {
int yold, xold;
getyx(win, yold, xold);
dialog_helpfile("HELP", dialog_vars.help_file, 0, 0);
dlg_raise_window(win);
wmove(win, yold, xold);
}
continue;
case DLGK_FIELD_PREV:
/* FALLTHRU */
case KEY_BTAB:
/* FALLTHRU */
case DLGK_FIELD_NEXT:
/* FALLTHRU */
case TAB:
/* Handle tab/backtab as a special case for traversing between
* the nominal "current" window, and other windows having
* callbacks. If the nominal (control) window closes, we'll
* close the windows with callbacks.
*/
if (dialog_state.getc_callbacks != 0 &&
(isBeforeChr(TAB) ||
isBeforeFkey(KEY_BTAB))) {
p = (isBeforeChr(TAB)
? next_callback(p)
: prev_callback(p));
if ((dialog_state.getc_redirect = p) != 0) {
win = p->win;
} else {
win = save_win;
}
dlg_raise_window(win);
break;
}
/* FALLTHRU */
default:
#ifdef NO_LEAKS
if (isBeforeChr(DLG_CTRL('P'))) {
/* for testing, ^P closes the connection */
close(0);
close(1);
close(2);
break;
}
#endif
handle_others = TRUE;
break;
#ifdef HAVE_DLG_TRACE
case CHR_TRACE:
dlg_trace_win(win);
break;
#endif
}
} else {
handle_others = TRUE;
}
if (handle_others) {
if ((p = dialog_state.getc_redirect) != 0) {
if (!(p->handle_getc(p, ch, *fkey, &result))) {
done = (p->win == save_win) && (!p->keep_win);
dlg_remove_callback(p);
dialog_state.getc_redirect = 0;
win = save_win;
}
} else {
done = TRUE;
}
}
}
if (literal)
keypad(win, TRUE);
return ch;
}