summaryrefslogtreecommitdiff
path: root/Build/source/utils/dialog/dialog-1.1-20080819/textbox.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/dialog/dialog-1.1-20080819/textbox.c')
-rw-r--r--Build/source/utils/dialog/dialog-1.1-20080819/textbox.c961
1 files changed, 961 insertions, 0 deletions
diff --git a/Build/source/utils/dialog/dialog-1.1-20080819/textbox.c b/Build/source/utils/dialog/dialog-1.1-20080819/textbox.c
new file mode 100644
index 00000000000..fa60aa714eb
--- /dev/null
+++ b/Build/source/utils/dialog/dialog-1.1-20080819/textbox.c
@@ -0,0 +1,961 @@
+/*
+ * $Id: textbox.c,v 1.92 2007/07/04 20:28:07 tom Exp $
+ *
+ * textbox.c -- implements the text box
+ *
+ * Copyright 2000-2006,2007 Thomas E. Dickey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License, version 2.1
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to
+ * Free Software Foundation, Inc.
+ * 51 Franklin St., Fifth Floor
+ * Boston, MA 02110, USA.
+ *
+ * An earlier version of this program lists as authors:
+ * Savio Lam (lam836@cs.cuhk.hk)
+ */
+
+#include <dialog.h>
+#include <dlg_keys.h>
+
+#define PAGE_LENGTH (height - 4)
+#define PAGE_WIDTH (width - 2)
+
+typedef struct {
+ DIALOG_CALLBACK obj;
+ WINDOW *text;
+ const char **buttons;
+ int hscroll;
+ char line[MAX_LEN + 1];
+ int fd;
+ long file_size;
+ long fd_bytes_read;
+ long bytes_read;
+ long buffer_len;
+ bool begin_reached;
+ bool buffer_first;
+ bool end_reached;
+ long page_length; /* lines on the page which is shown */
+ long in_buf; /* ending index into buf[] for page */
+ char *buf;
+} MY_OBJ;
+
+static long
+lseek_obj(MY_OBJ * obj, long offset, int mode)
+{
+ long fpos;
+ if ((fpos = lseek(obj->fd, 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 long
+ftell_obj(MY_OBJ * obj)
+{
+ return lseek_obj(obj, 0, SEEK_CUR);
+}
+
+static char *
+xalloc(long size)
+{
+ char *result = dlg_malloc(char, size);
+ assert_ptr(result, "xalloc");
+ return result;
+}
+
+/*
+ * 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(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);
+}
+
+static long
+find_first(MY_OBJ * obj, char *buffer, long length)
+{
+ long recount = obj->page_length;
+ long result = 0;
+
+ while (length > 0) {
+ if (buffer[length] == '\n') {
+ if (--recount < 0) {
+ result = length;
+ break;
+ }
+ }
+ --length;
+ }
+ return result;
+}
+
+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_obj(obj, fpos - obj->fd_bytes_read, SEEK_SET);
+
+ /* Allocate space for read buffer */
+ buftab = xalloc(val + 1);
+
+ if ((read(obj->fd, buftab, 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_obj(obj, fpos, SEEK_SET);
+ free(buftab);
+ return count;
+}
+/*
+ * Return current line of text.
+ * 'page' should point to start of current line before calling, and will be
+ * updated to point to start of next line.
+ */
+static char *
+get_line(MY_OBJ * obj)
+{
+ int i = 0;
+ long fpos;
+
+ obj->end_reached = FALSE;
+ while (obj->buf[obj->in_buf] != '\n') {
+ if (obj->buf[obj->in_buf] == '\0') { /* Either end of file or end of buffer reached */
+ fpos = ftell_obj(obj);
+
+ if (fpos < obj->file_size) { /* Not end of file yet */
+ /* We've reached end of buffer, but not end of file yet, so
+ * read next part of file into buffer
+ */
+ read_high(obj, BUF_SIZE);
+ obj->in_buf = 0;
+ } else {
+ if (!obj->end_reached)
+ obj->end_reached = TRUE;
+ break;
+ }
+ } else if (i < MAX_LEN)
+ obj->line[i++] = obj->buf[obj->in_buf++];
+ else {
+ if (i == MAX_LEN) /* Truncate lines longer than MAX_LEN characters */
+ obj->line[i++] = '\0';
+ obj->in_buf++;
+ }
+ }
+ if (i <= MAX_LEN)
+ obj->line[i] = '\0';
+ if (!obj->end_reached)
+ obj->in_buf++; /* move past '\n' */
+
+ return obj->line;
+}
+
+static bool
+match_string(MY_OBJ * obj, char *string)
+{
+ char *match = get_line(obj);
+ return strstr(match, string) != 0;
+}
+
+/*
+ * 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_obj(obj, 0, SEEK_SET);
+ val_to_tabize = fpos - obj->fd_bytes_read;
+ } else { /* Move backward BUF_SIZE/2 bytes */
+ lseek_obj(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read), SEEK_CUR);
+ 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_obj(obj, 0, SEEK_SET);
+ val_to_tabize = fpos - obj->fd_bytes_read;
+ } else { /* Move backward BUF_SIZE/2 bytes */
+ lseek_obj(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read), SEEK_CUR);
+ 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++;
+}
+
+/*
+ * Print a new line of text.
+ */
+static void
+print_line(MY_OBJ * obj, int row, int width)
+{
+ if (wmove(obj->text, row, 0) != ERR) {
+ int i, y, x;
+ char *line = get_line(obj);
+ const int *cols = dlg_index_columns(line);
+ const int *indx = dlg_index_wchars(line);
+ int limit = dlg_count_wchars(line);
+ int first = 0;
+ int last = limit;
+
+ if (width > getmaxx(obj->text))
+ width = getmaxx(obj->text);
+ --width; /* for the leading ' ' */
+
+ for (i = 0; i <= limit && cols[i] < obj->hscroll; ++i)
+ first = i;
+
+ for (i = first; (i <= limit) && ((cols[i] - cols[first]) < width); ++i)
+ last = i;
+
+ (void) waddch(obj->text, ' ');
+ (void) waddnstr(obj->text, line + indx[first], indx[last] - indx[first]);
+
+ getyx(obj->text, y, x);
+ if (y == row) { /* Clear 'residue' of previous line */
+ for (i = 0; i <= width - x; i++) {
+ (void) waddch(obj->text, ' ');
+ }
+ }
+ }
+}
+
+/*
+ * Print a new page of text.
+ */
+static void
+print_page(MY_OBJ * obj, int height, int width)
+{
+ int i, passed_end = 0;
+
+ obj->page_length = 0;
+ for (i = 0; i < height; i++) {
+ print_line(obj, i, width);
+ if (!passed_end)
+ obj->page_length++;
+ if (obj->end_reached && !passed_end)
+ passed_end = 1;
+ }
+ (void) wnoutrefresh(obj->text);
+}
+
+/*
+ * Print current position
+ */
+static void
+print_position(MY_OBJ * obj, WINDOW *win, int height, int width)
+{
+ chtype save = getattrs(win);
+ long fpos;
+ long size;
+ int percent;
+ int len;
+ long first = -1;
+ char buffer[80];
+
+ fpos = ftell_obj(obj);
+ if (dialog_vars.tab_correct)
+ size = tabize(obj, obj->in_buf, &first);
+ else
+ first = find_first(obj, obj->buf, size = obj->in_buf);
+
+ wattrset(win, position_indicator_attr);
+ percent = (!obj->file_size
+ ? 100
+ : (int) (((fpos - obj->fd_bytes_read + size) * 100)
+ / obj->file_size));
+
+ if (percent < 0)
+ percent = 0;
+ if (percent > 100)
+ percent = 100;
+
+ (void) sprintf(buffer, "%d%%", percent);
+ (void) wmove(win, PAGE_LENGTH + 1, PAGE_WIDTH - 7);
+ (void) waddstr(win, buffer);
+ if ((len = dlg_count_columns(buffer)) < 4) {
+ wattrset(win, border_attr);
+ whline(win, dlg_boxchar(ACS_HLINE), 4 - len);
+ }
+
+ wattrset(win, save);
+ dlg_draw_arrows2(win,
+ first != 0,
+ size < obj->fd_bytes_read,
+ ARROWS_COL, 0, PAGE_LENGTH + 1,
+ border_attr,
+ border_attr);
+}
+
+/*
+ * Display a dialog box and get the search term from user.
+ */
+static int
+get_search_term(WINDOW *dialog, char *input, int height, int width)
+{
+ /* *INDENT-OFF* */
+ static DLG_KEYS_BINDING binding[] = {
+ INPUTSTR_BINDINGS,
+ ENTERKEY_BINDINGS,
+ END_KEYS_BINDING
+ };
+ /* *INDENT-ON* */
+
+ int old_x, old_y;
+ int box_x, box_y;
+ int box_height, box_width;
+ int offset = 0;
+ int key = 0;
+ int fkey = 0;
+ bool first = TRUE;
+ int result = DLG_EXIT_UNKNOWN;
+ char *caption = _("Search");
+ int len_caption = dlg_count_columns(caption);
+ const int *indx;
+ int limit;
+ WINDOW *widget;
+
+ getbegyx(dialog, old_y, old_x);
+
+ box_height = 1 + (2 * MARGIN);
+ box_width = len_caption + (2 * (MARGIN + 2));
+ box_width = MAX(box_width, 30);
+ box_width = MIN(box_width, getmaxx(dialog) - 2 * MARGIN);
+ len_caption = MIN(len_caption, box_width - (2 * (MARGIN + 1)));
+
+ box_x = (width - box_width) / 2;
+ box_y = (height - box_height) / 2;
+ widget = dlg_new_modal_window(dialog,
+ box_height, box_width,
+ old_y + box_y, old_x + box_x);
+ keypad(widget, TRUE);
+ dlg_register_window(widget, "searchbox", binding);
+
+ dlg_draw_box(widget, 0, 0, box_height, box_width,
+ searchbox_attr,
+ searchbox_border_attr);
+ wattrset(widget, searchbox_title_attr);
+ (void) wmove(widget, 0, (box_width - len_caption) / 2);
+
+ indx = dlg_index_wchars(caption);
+ limit = dlg_limit_columns(caption, len_caption, 0);
+ (void) waddnstr(widget, caption + indx[0], indx[limit] - indx[0]);
+
+ box_y++;
+ box_x++;
+ box_width -= 2;
+ offset = dlg_count_columns(input);
+
+ while (result == DLG_EXIT_UNKNOWN) {
+ if (!first) {
+ key = dlg_getc(widget, &fkey);
+ if (fkey) {
+ switch (fkey) {
+#ifdef KEY_RESIZE
+ case KEY_RESIZE:
+ result = DLG_EXIT_CANCEL;
+ continue;
+#endif
+ case DLGK_ENTER:
+ result = DLG_EXIT_OK;
+ continue;
+ }
+ } else if (key == ESC) {
+ result = DLG_EXIT_ESC;
+ continue;
+ } else if (key == ERR) {
+ napms(50);
+ continue;
+ }
+ }
+ if (dlg_edit_string(input, &offset, key, fkey, first)) {
+ dlg_show_string(widget, input, offset, searchbox_attr,
+ 1, 1, box_width, FALSE, first);
+ first = FALSE;
+ }
+ }
+ dlg_del_window(widget);
+ return result;
+}
+
+static bool
+perform_search(MY_OBJ * obj, int height, int width, int key, char *search_term)
+{
+ int dir;
+ long tempinx;
+ long fpos;
+ int result;
+ bool found;
+ bool temp, temp1;
+ bool moved = FALSE;
+
+ /* set search direction */
+ dir = (key == '/' || key == 'n') ? 1 : 0;
+ if (dir ? !obj->end_reached : !obj->begin_reached) {
+ if (key == 'n' || key == 'N') {
+ if (search_term[0] == '\0') { /* No search term yet */
+ (void) beep();
+ return FALSE;
+ }
+ /* Get search term from user */
+ } else if ((result = get_search_term(obj->text, search_term,
+ PAGE_LENGTH,
+ PAGE_WIDTH)) != DLG_EXIT_OK
+ || search_term[0] == '\0') {
+#ifdef KEY_RESIZE
+ if (result == DLG_EXIT_CANCEL) {
+ ungetch(key);
+ ungetch(KEY_RESIZE);
+ /* FALLTHRU */
+ }
+#endif
+ /* ESC pressed, or no search term, reprint page to clear box */
+ wattrset(obj->text, dialog_attr);
+ back_lines(obj, obj->page_length);
+ return TRUE;
+ }
+ /* Save variables for restoring in case search term can't be found */
+ tempinx = obj->in_buf;
+ temp = obj->begin_reached;
+ temp1 = obj->end_reached;
+ fpos = ftell_obj(obj) - obj->fd_bytes_read;
+ /* update 'in_buf' to point to next (previous) line before
+ forward (backward) searching */
+ back_lines(obj, (dir
+ ? obj->page_length - 1
+ : obj->page_length + 1));
+ found = FALSE;
+ if (dir) { /* Forward search */
+ while ((found = match_string(obj, search_term)) == FALSE) {
+ if (obj->end_reached)
+ break;
+ }
+ } else { /* Backward search */
+ while ((found = match_string(obj, search_term)) == FALSE) {
+ if (obj->begin_reached)
+ break;
+ back_lines(obj, 2);
+ }
+ }
+ if (found == FALSE) { /* not found */
+ (void) beep();
+ /* Restore program state to that before searching */
+ lseek_obj(obj, fpos, SEEK_SET);
+
+ read_high(obj, BUF_SIZE);
+
+ obj->in_buf = tempinx;
+ obj->begin_reached = temp;
+ obj->end_reached = temp1;
+ /* move 'in_buf' to point to start of current page to
+ * re-print current page. Note that 'in_buf' always points
+ * to start of next page, so this is necessary
+ */
+ back_lines(obj, obj->page_length);
+ } else { /* Search term found */
+ back_lines(obj, 1);
+ }
+ /* Reprint page */
+ wattrset(obj->text, dialog_attr);
+ moved = TRUE;
+ } else { /* no need to find */
+ (void) beep();
+ }
+ return moved;
+}
+
+/*
+ * 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[] = {
+ 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 = dialog_vars.extra_button ? dlg_defaultno_button() : 0;
+
+ 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 */
+ obj.file_size = lseek_obj(&obj, 0, SEEK_END);
+
+ /* Restore file pointer to beginning of file after getting file size */
+ lseek_obj(&obj, 0, SEEK_SET);
+
+ read_high(&obj, BUF_SIZE);
+
+#ifdef KEY_RESIZE
+ retry:
+#endif
+ moved = TRUE;
+
+ dlg_auto_sizefile(title, file, &height, &width, 2, 12);
+ 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_box(dialog, 0, 0, height, width, dialog_attr, border_attr);
+ dlg_draw_bottom_box(dialog);
+ 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:
+ 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_obj(&obj, 0, SEEK_SET);
+
+ 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_obj(&obj, -BUF_SIZE, SEEK_END);
+
+ read_high(&obj, BUF_SIZE);
+ }
+ obj.in_buf = obj.bytes_read;
+ back_lines(&obj, 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);
+ moved = TRUE;
+ /* 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;
+}