summaryrefslogtreecommitdiff
path: root/Build/source/utils/texinfo/info/display.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/texinfo/info/display.c')
-rw-r--r--Build/source/utils/texinfo/info/display.c654
1 files changed, 0 insertions, 654 deletions
diff --git a/Build/source/utils/texinfo/info/display.c b/Build/source/utils/texinfo/info/display.c
deleted file mode 100644
index 58f6a17a718..00000000000
--- a/Build/source/utils/texinfo/info/display.c
+++ /dev/null
@@ -1,654 +0,0 @@
-/* display.c -- How to display Info windows.
- $Id: display.c,v 1.12 2007/10/19 18:43:20 karl Exp $
-
- Copyright (C) 1993, 1997, 2003, 2004, 2006, 2007
- Free Software Foundation, Inc.
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- 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 General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
- Originally written by Brian Fox (bfox@ai.mit.edu). */
-
-#include "info.h"
-#include "display.h"
-
-extern int info_any_buffered_input_p (void); /* Found in session.c. */
-
-static void free_display (DISPLAY_LINE **display);
-static DISPLAY_LINE **make_display (int width, int height);
-
-void handle_tag (char *tag);
-void handle_tag_start (char *tag);
-void handle_tag_end (char *tag);
-
-/* An array of display lines which tell us what is currently visible on
- the display. */
-DISPLAY_LINE **the_display = (DISPLAY_LINE **)NULL;
-
-/* Non-zero means do no output. */
-int display_inhibited = 0;
-
-/* Initialize THE_DISPLAY to WIDTH and HEIGHT, with nothing in it. */
-void
-display_initialize_display (int width, int height)
-{
- free_display (the_display);
- the_display = make_display (width, height);
- display_clear_display (the_display);
-}
-
-/* Clear all of the lines in DISPLAY making the screen blank. */
-void
-display_clear_display (DISPLAY_LINE **display)
-{
- register int i;
-
- for (i = 0; display[i]; i++)
- {
- display[i]->text[0] = '\0';
- display[i]->textlen = 0;
- display[i]->inverse = 0;
- }
-}
-
-/* Non-zero if we didn't completely redisplay a window. */
-int display_was_interrupted_p = 0;
-
-/* Update the windows pointed to by WINDOW in the_display. This actually
- writes the text on the screen. */
-void
-display_update_display (WINDOW *window)
-{
- register WINDOW *win;
-
- display_was_interrupted_p = 0;
-
- /* For every window in the list, check contents against the display. */
- for (win = window; win; win = win->next)
- {
- /* Only re-display visible windows which need updating. */
- if (((win->flags & W_WindowVisible) == 0) ||
- ((win->flags & W_UpdateWindow) == 0) ||
- (win->height == 0))
- continue;
-
- display_update_one_window (win);
- if (display_was_interrupted_p)
- break;
- }
-
- /* Always update the echo area. */
- display_update_one_window (the_echo_area);
-}
-
-void
-handle_tag_start (char *tag)
-{
- /* TODO really handle this tag. */
- return;
-}
-
-void
-handle_tag_end (char *tag)
-{
- /* TODO really handle this tag. */
- return;
-}
-
-void
-handle_tag (char *tag)
-{
- if (tag[0] == '/')
- {
- tag++;
- handle_tag_end (tag);
- }
- else
- handle_tag_start (tag);
-}
-
-/* Display WIN on the_display. Unlike display_update_display (), this
- function only does one window. */
-void
-display_update_one_window (WINDOW *win)
-{
- register char *nodetext; /* Current character to display. */
- register char *last_node_char; /* Position of the last character in node. */
- register int i; /* General use index. */
- char *printed_line; /* Buffer for a printed line. */
- int pl_index = 0; /* Index into PRINTED_LINE. */
- int line_index = 0; /* Number of lines done so far. */
- int pl_ignore = 0; /* How many chars use zero width on screen. */
- int allocated_win_width;
- DISPLAY_LINE **display = the_display;
-
- /* If display is inhibited, that counts as an interrupted display. */
- if (display_inhibited)
- display_was_interrupted_p = 1;
-
- /* If the window has no height, or display is inhibited, quit now.
- Strictly speaking, it should only be necessary to test if the
- values are equal to zero, since window_new_screen_size should
- ensure that the window height/width never becomes negative, but
- since historically this has often been the culprit for crashes, do
- our best to be doubly safe. */
- if (win->height <= 0 || win->width <= 0 || display_inhibited)
- return;
-
- /* If the window's first row doesn't appear in the_screen, then it
- cannot be displayed. This can happen when the_echo_area is the
- window to be displayed, and the screen has shrunk to less than one
- line. */
- if ((win->first_row < 0) || (win->first_row > the_screen->height))
- return;
-
- /* Print each line in the window into our local buffer, and then
- check the contents of that buffer against the display. If they
- differ, update the display. */
- allocated_win_width = win->width + 1;
- printed_line = (char *)xmalloc (allocated_win_width);
-
- if (!win->node || !win->line_starts)
- goto done_with_node_display;
-
- nodetext = win->line_starts[win->pagetop];
- last_node_char = win->node->contents + win->node->nodelen;
-
- for (; nodetext < last_node_char; nodetext++)
- {
- char *rep = NULL, *rep_carried_over, rep_temp[2];
- int replen;
-
- if (isprint (*nodetext))
- {
- rep_temp[0] = *nodetext;
- replen = 1;
- rep_temp[1] = '\0';
- rep = rep_temp;
- }
- else
- {
- if (*nodetext == '\r' || *nodetext == '\n')
- {
- replen = win->width - pl_index + pl_ignore;
- }
- else if (*nodetext == '\0'
- && (nodetext + 2) < last_node_char
- && *(nodetext + 1) == '\b'
- && *(nodetext + 2) == '[')
- {
- /* Found new style tag/cookie \0\b[
- Read until the closing tag \0\b] */
- int element_len = 0;
- char *element;
-
- /* Skip the escapes. */
- nodetext += 3;
-
- while (!(*nodetext == '\0'
- && *(nodetext + 1) == '\b'
- && *(nodetext + 2) == ']'))
- {
- nodetext++;
- element_len++;
- }
-
- element = (char *) malloc (element_len + 1);
- strncpy (element, nodetext - element_len, element_len);
-
- /* Skip the escapes. */
- nodetext += 2;
- pl_ignore += element_len + 5;
- /* Append string terminator. */
- element[element_len] = '\0';
-
- handle_tag (element);
-
- /* Over and out */
- free (element);
-
- continue;
- }
- else
- {
- rep = printed_representation (*nodetext, pl_index);
- replen = strlen (rep);
- }
- }
-
- /* Support ANSI escape sequences under -R. */
- if (raw_escapes_p
- && *nodetext == '\033'
- && nodetext[1] == '['
- && isdigit (nodetext[2]))
- {
- if (nodetext[3] == 'm')
- pl_ignore += 4;
- else if (isdigit (nodetext[3]) && nodetext[4] == 'm')
- pl_ignore += 5;
- }
- while (pl_index + 2 >= allocated_win_width - 1)
- {
- allocated_win_width *= 2;
- printed_line = (char *)xrealloc (printed_line, allocated_win_width);
- }
-
- /* If this character can be printed without passing the width of
- the line, then stuff it into the line. */
- if (replen + pl_index < win->width + pl_ignore)
- {
- /* Optimize if possible. */
- if (replen == 1)
- {
- printed_line[pl_index++] = *rep;
- }
- else
- {
- for (i = 0; i < replen; i++)
- printed_line[pl_index++] = rep[i];
- }
- }
- else
- {
- DISPLAY_LINE *entry;
-
- /* If this character cannot be printed in this line, we have
- found the end of this line as it would appear on the screen.
- Carefully print the end of the line, and then compare. */
- if (*nodetext == '\n' || *nodetext == '\r' || *nodetext == '\t')
- {
- printed_line[pl_index] = '\0';
- rep_carried_over = (char *)NULL;
- }
- else
- {
- /* The printed representation of this character extends into
- the next line. Remember the offset of the last character
- printed out of REP so that we can carry the character over
- to the next line. */
- for (i = 0; pl_index < (win->width + pl_ignore - 1);)
- printed_line[pl_index++] = rep[i++];
-
- rep_carried_over = rep + i;
-
- /* If printing the last character in this window couldn't
- possibly cause the screen to scroll, place a backslash
- in the rightmost column. */
- if (1 + line_index + win->first_row < the_screen->height)
- {
- if (win->flags & W_NoWrap)
- printed_line[pl_index++] = '$';
- else
- printed_line[pl_index++] = '\\';
- }
- printed_line[pl_index] = '\0';
- }
-
- /* We have the exact line as it should appear on the screen.
- Check to see if this line matches the one already appearing
- on the screen. */
- entry = display[line_index + win->first_row];
-
- /* If the window is very small, entry might be NULL. */
- if (entry) {
- /* If the screen line is inversed, then we have to clear
- the line from the screen first. Why, I don't know.
- (But don't do this if we have no visible entries, as can
- happen if the window is shrunk very small.) */
- if (entry->inverse
- /* Need to erase the line if it has escape sequences. */
- || (raw_escapes_p && strchr (entry->text, '\033') != 0))
- {
- terminal_goto_xy (0, line_index + win->first_row);
- terminal_clear_to_eol ();
- entry->inverse = 0;
- entry->text[0] = '\0';
- entry->textlen = 0;
- }
-
- /* Find the offset where these lines differ. */
- for (i = 0; i < pl_index; i++)
- if (printed_line[i] != entry->text[i])
- break;
-
- /* If the lines are not the same length, or if they differed
- at all, we must do some redrawing. */
- if ((i != pl_index) || (pl_index != entry->textlen))
- {
- /* Move to the proper point on the terminal. */
- terminal_goto_xy (i, line_index + win->first_row);
-
- /* If there is any text to print, print it. */
- if (i != pl_index)
- terminal_put_text (printed_line + i);
-
- /* If the printed text didn't extend all the way to the edge
- of the window, and text was appearing between here and the
- edge of the window, clear from here to the end of the line. */
- if ((pl_index < win->width + pl_ignore
- && pl_index < entry->textlen)
- || (entry->inverse))
- terminal_clear_to_eol ();
-
- fflush (stdout);
-
- /* Update the display text buffer. */
- if (strlen (printed_line) > (unsigned int) screenwidth)
- /* printed_line[] can include more than screenwidth
- characters if we are under -R and there are escape
- sequences in it. However, entry->text was
- allocated (in display_initialize_display) for
- screenwidth characters only. */
- entry->text = xrealloc (entry->text, strlen (printed_line)+1);
- strcpy (entry->text + i, printed_line + i);
- entry->textlen = pl_index;
-
- /* Lines showing node text are not in inverse. Only modelines
- have that distinction. */
- entry->inverse = 0;
- }
- }
-
- /* We have done at least one line. Increment our screen line
- index, and check against the bottom of the window. */
- if (++line_index == win->height)
- break;
-
- /* A line has been displayed, and the screen reflects that state.
- If there is typeahead pending, then let that typeahead be read
- now, instead of continuing with the display. */
- if (info_any_buffered_input_p ())
- {
- free (printed_line);
- display_was_interrupted_p = 1;
- return;
- }
-
- /* Reset PL_INDEX to the start of the line. */
- pl_index = 0;
- pl_ignore = 0; /* this is computed per line */
-
- /* If there are characters from REP left to print, stuff them
- into the buffer now. */
- if (rep_carried_over)
- for (; rep[pl_index]; pl_index++)
- printed_line[pl_index] = rep[pl_index];
-
- /* If this window has chosen not to wrap lines, skip to the end
- of the physical line in the buffer, and start a new line here. */
- if (pl_index && (win->flags & W_NoWrap))
- {
- char *begin;
-
- pl_index = 0;
- printed_line[0] = '\0';
-
- begin = nodetext;
-
- while ((nodetext < last_node_char) && (*nodetext != '\n'))
- nodetext++;
- }
- }
- }
-
- done_with_node_display:
- /* We have reached the end of the node or the end of the window. If it
- is the end of the node, then clear the lines of the window from here
- to the end of the window. */
- for (; line_index < win->height; line_index++)
- {
- DISPLAY_LINE *entry = display[line_index + win->first_row];
-
- /* If this line has text on it then make it go away. */
- if (entry && entry->textlen)
- {
- entry->textlen = 0;
- entry->text[0] = '\0';
-
- terminal_goto_xy (0, line_index + win->first_row);
- terminal_clear_to_eol ();
- }
- }
-
- /* Finally, if this window has a modeline it might need to be redisplayed.
- Check the window's modeline against the one in the display, and update
- if necessary. */
- if ((win->flags & W_InhibitMode) == 0)
- {
- window_make_modeline (win);
- line_index = win->first_row + win->height;
-
- /* This display line must both be in inverse, and have the same
- contents. */
- if ((!display[line_index]->inverse) ||
- (strcmp (display[line_index]->text, win->modeline) != 0))
- {
- terminal_goto_xy (0, line_index);
- terminal_begin_inverse ();
- terminal_put_text (win->modeline);
- terminal_end_inverse ();
- strcpy (display[line_index]->text, win->modeline);
- display[line_index]->inverse = 1;
- display[line_index]->textlen = strlen (win->modeline);
- fflush (stdout);
- }
- }
-
- /* Okay, this window doesn't need updating anymore. */
- win->flags &= ~W_UpdateWindow;
- free (printed_line);
- fflush (stdout);
-}
-
-/* Scroll the region of the_display starting at START, ending at END, and
- moving the lines AMOUNT lines. If AMOUNT is less than zero, the lines
- are moved up in the screen, otherwise down. Actually, it is possible
- for no scrolling to take place in the case that the terminal doesn't
- support it. This doesn't matter to us. */
-void
-display_scroll_display (int start, int end, int amount)
-{
- register int i, last;
- DISPLAY_LINE *temp;
-
- /* If this terminal cannot do scrolling, give up now. */
- if (!terminal_can_scroll)
- return;
-
- /* If there isn't anything displayed on the screen because it is too
- small, quit now. */
- if (!the_display[0])
- return;
-
- /* If there is typeahead pending, then don't actually do any scrolling. */
- if (info_any_buffered_input_p ())
- return;
-
- /* Do it on the screen. */
- terminal_scroll_terminal (start, end, amount);
-
- /* Now do it in the display buffer so our contents match the screen. */
- if (amount > 0)
- {
- last = end + amount;
-
- /* Shift the lines to scroll right into place. */
- for (i = 0; i < (end - start); i++)
- {
- temp = the_display[last - i];
- the_display[last - i] = the_display[end - i];
- the_display[end - i] = temp;
- }
-
- /* The lines have been shifted down in the buffer. Clear all of the
- lines that were vacated. */
- for (i = start; i != (start + amount); i++)
- {
- the_display[i]->text[0] = '\0';
- the_display[i]->textlen = 0;
- the_display[i]->inverse = 0;
- }
- }
-
- if (amount < 0)
- {
- last = start + amount;
- for (i = 0; i < (end - start); i++)
- {
- temp = the_display[last + i];
- the_display[last + i] = the_display[start + i];
- the_display[start + i] = temp;
- }
-
- /* The lines have been shifted up in the buffer. Clear all of the
- lines that are left over. */
- for (i = end + amount; i != end; i++)
- {
- the_display[i]->text[0] = '\0';
- the_display[i]->textlen = 0;
- the_display[i]->inverse = 0;
- }
- }
-}
-
-/* Try to scroll lines in WINDOW. OLD_PAGETOP is the pagetop of WINDOW before
- having had its line starts recalculated. OLD_STARTS is the list of line
- starts that used to appear in this window. OLD_COUNT is the number of lines
- that appear in the OLD_STARTS array. */
-void
-display_scroll_line_starts (WINDOW *window, int old_pagetop,
- char **old_starts, int old_count)
-{
- register int i, old, new; /* Indices into the line starts arrays. */
- int last_new, last_old; /* Index of the last visible line. */
- int old_first, new_first; /* Index of the first changed line. */
- int unchanged_at_top = 0;
- int already_scrolled = 0;
-
- /* Locate the first line which was displayed on the old window. */
- old_first = old_pagetop;
- new_first = window->pagetop;
-
- /* Find the last line currently visible in this window. */
- last_new = window->pagetop + (window->height - 1);
- if (last_new > window->line_count)
- last_new = window->line_count - 1;
-
- /* Find the last line which used to be currently visible in this window. */
- last_old = old_pagetop + (window->height - 1);
- if (last_old > old_count)
- last_old = old_count - 1;
-
- for (old = old_first, new = new_first;
- old < last_old && new < last_new;
- old++, new++)
- if (old_starts[old] != window->line_starts[new])
- break;
- else
- unchanged_at_top++;
-
- /* Loop through the old lines looking for a match in the new lines. */
- for (old = old_first + unchanged_at_top; old < last_old; old++)
- {
- for (new = new_first; new < last_new; new++)
- if (old_starts[old] == window->line_starts[new])
- {
- /* Find the extent of the matching lines. */
- for (i = 0; (old + i) < last_old; i++)
- if (old_starts[old + i] != window->line_starts[new + i])
- break;
-
- /* Scroll these lines if there are enough of them. */
- {
- int start, end, amount;
-
- start = (window->first_row
- + ((old + already_scrolled) - old_pagetop));
- amount = new - (old + already_scrolled);
- end = window->first_row + window->height;
-
- /* If we are shifting the block of lines down, then the last
- AMOUNT lines will become invisible. Thus, don't bother
- scrolling them. */
- if (amount > 0)
- end -= amount;
-
- if ((end - start) > 0)
- {
- display_scroll_display (start, end, amount);
-
- /* Some lines have been scrolled. Simulate the scrolling
- by offsetting the value of the old index. */
- old += i;
- already_scrolled += amount;
- }
- }
- }
- }
-}
-
-/* Move the screen cursor to directly over the current character in WINDOW. */
-void
-display_cursor_at_point (WINDOW *window)
-{
- int vpos, hpos;
-
- vpos = window_line_of_point (window) - window->pagetop + window->first_row;
- hpos = window_get_cursor_column (window);
- terminal_goto_xy (hpos, vpos);
- fflush (stdout);
-}
-
-/* **************************************************************** */
-/* */
-/* Functions Static to this File */
-/* */
-/* **************************************************************** */
-
-/* Make a DISPLAY_LINE ** with width and height. */
-static DISPLAY_LINE **
-make_display (int width, int height)
-{
- register int i;
- DISPLAY_LINE **display;
-
- display = (DISPLAY_LINE **)xmalloc ((1 + height) * sizeof (DISPLAY_LINE *));
-
- for (i = 0; i < height; i++)
- {
- display[i] = (DISPLAY_LINE *)xmalloc (sizeof (DISPLAY_LINE));
- display[i]->text = (char *)xmalloc (1 + width);
- display[i]->textlen = 0;
- display[i]->inverse = 0;
- }
- display[i] = (DISPLAY_LINE *)NULL;
- return (display);
-}
-
-/* Free the storage allocated to DISPLAY. */
-static void
-free_display (DISPLAY_LINE **display)
-{
- register int i;
- register DISPLAY_LINE *display_line;
-
- if (!display)
- return;
-
- for (i = 0; (display_line = display[i]); i++)
- {
- free (display_line->text);
- free (display_line);
- }
- free (display);
-}