X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/2538fae4f8e5e7a82449dd904d471439c9eb6345..8ccd36304db42afda019e6318696c82afed5fe85:/src/scroll.c diff --git a/src/scroll.c b/src/scroll.c index 83e029f417..6e633d4e60 100644 --- a/src/scroll.c +++ b/src/scroll.c @@ -1,5 +1,6 @@ /* Calculate what line insertion or deletion to do, and do it, - Copyright (C) 1985, 1986, 1990, 1993, 1994 Free Software Foundation, Inc. + Copyright (C) 1985, 1986, 1990, 1993, 1994, 2002, 2003, 2004, + 2005 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -15,8 +16,8 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs; see the file COPYING. If not, write to -the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ #include @@ -29,9 +30,6 @@ Boston, MA 02111-1307, USA. */ #include "frame.h" #include "window.h" -#define max(a, b) ((a) > (b) ? (a) : (b)) -#define min(a, b) ((a) < (b) ? (a) : (b)) - /* All costs measured in characters. So no cost can exceed the area of a frame, measured in characters. Let's hope this is never more than 1000000 characters. */ @@ -92,14 +90,14 @@ calculate_scrolling (frame, matrix, window_size, lines_below, FRAME_PTR frame; /* matrix is of size window_size + 1 on each side. */ struct matrix_elt *matrix; - int window_size; + int window_size, lines_below; int *draw_cost; int *old_hash; int *new_hash; int free_at_end; { register int i, j; - int frame_height = FRAME_HEIGHT (frame); + int frame_lines = FRAME_LINES (frame); register struct matrix_elt *p, *p1; register int cost, cost1; @@ -108,18 +106,18 @@ calculate_scrolling (frame, matrix, window_size, lines_below, at the i'th line of the lines we are considering, where I is origin 1 (as it is below). */ int *first_insert_cost - = &FRAME_INSERT_COST (frame)[frame_height - 1 - lines_moved]; + = &FRAME_INSERT_COST (frame)[frame_lines - 1 - lines_moved]; int *first_delete_cost - = &FRAME_DELETE_COST (frame)[frame_height - 1 - lines_moved]; + = &FRAME_DELETE_COST (frame)[frame_lines - 1 - lines_moved]; int *next_insert_cost - = &FRAME_INSERTN_COST (frame)[frame_height - 1 - lines_moved]; + = &FRAME_INSERTN_COST (frame)[frame_lines - 1 - lines_moved]; int *next_delete_cost - = &FRAME_DELETEN_COST (frame)[frame_height - 1 - lines_moved]; + = &FRAME_DELETEN_COST (frame)[frame_lines - 1 - lines_moved]; /* Discourage long scrolls on fast lines. Don't scroll nearly a full frame height unless it saves at least 1/4 second. */ - int extra_cost = baud_rate / (10 * 4 * FRAME_HEIGHT (frame)); + int extra_cost = baud_rate / (10 * 4 * FRAME_LINES (frame)); if (baud_rate <= 0) extra_cost = 1; @@ -235,13 +233,13 @@ calculate_scrolling (frame, matrix, window_size, lines_below, /* Perform insert-lines and delete-lines operations on CURRENT_MATRIX according to the costs in MATRIX, using the general scrolling method that is used if the terminal does not support the setting of - scroll windows (scroll_region_ok == 0). + scroll windows (scroll_region_ok == 0). WINDOW_SIZE is the number of lines being considered for scrolling and UNCHANGED_AT_TOP is the vpos of the first line being considered. These two arguments can specify any contiguous range of lines. */ - + static void do_scrolling (current_matrix, matrix, window_size, unchanged_at_top) struct glyph_matrix *current_matrix; @@ -261,7 +259,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top) struct queue *queue_start = (struct queue *) alloca (current_matrix->nrows * sizeof (struct queue)); struct queue *queue = queue_start; - + char *retained_p = (char *) alloca (window_size * sizeof (char)); int *copy_from = (int *) alloca (window_size * sizeof (int)); @@ -286,7 +284,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top) while (i > 0 || j > 0) { p = matrix + i * (window_size + 1) + j; - + if (p->insertcost < p->writecost && p->insertcost < p->deletecost) { /* Insert should be done at vpos i-1, plus maybe some before. @@ -368,7 +366,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top) } } while (queue > queue_start); - + } for (k = 0; k < window_size; ++k) @@ -380,7 +378,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top) /* Some sanity checks if GLYPH_DEBUG != 0. */ CHECK_MATRIX (current_matrix); - + if (terminal_window_p) set_terminal_window (0); } @@ -433,7 +431,7 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below, FRAME_PTR frame; /* matrix is of size window_size + 1 on each side. */ struct matrix_elt *matrix; - int window_size; + int window_size, lines_below; int *draw_cost; int *old_draw_cost; int *old_hash; @@ -441,27 +439,27 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below, int free_at_end; { register int i, j; - int frame_height = FRAME_HEIGHT (frame); + int frame_lines = FRAME_LINES (frame); register struct matrix_elt *p, *p1; register int cost, cost1, delta; /* first_insert_cost[-I] is the cost of doing the first insert-line at a position I lines above the bottom line in the scroll window. */ int *first_insert_cost - = &FRAME_INSERT_COST (frame)[frame_height - 1]; + = &FRAME_INSERT_COST (frame)[frame_lines - 1]; int *first_delete_cost - = &FRAME_DELETE_COST (frame)[frame_height - 1]; + = &FRAME_DELETE_COST (frame)[frame_lines - 1]; int *next_insert_cost - = &FRAME_INSERTN_COST (frame)[frame_height - 1]; + = &FRAME_INSERTN_COST (frame)[frame_lines - 1]; int *next_delete_cost - = &FRAME_DELETEN_COST (frame)[frame_height - 1]; + = &FRAME_DELETEN_COST (frame)[frame_lines - 1]; int scroll_overhead; /* Discourage long scrolls on fast lines. Don't scroll nearly a full frame height unless it saves at least 1/4 second. */ - int extra_cost = baud_rate / (10 * 4 * FRAME_HEIGHT (frame)); + int extra_cost = baud_rate / (10 * 4 * FRAME_LINES (frame)); if (baud_rate <= 0) extra_cost = 1; @@ -565,7 +563,7 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below, To reduce the cumulative effects of rounding error, we vary the position at which the difference is computed. */ cost1 += first_insert_cost[-j] - first_insert_cost[1-j] + - (delta-1) * (next_insert_cost[-j] - next_insert_cost[1-j]); + (delta-1) * (next_insert_cost[-j] - next_insert_cost[1-j]); } else { @@ -573,7 +571,7 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below, cost += scroll_overhead + first_delete_cost[-delta] + (delta-1) * (next_delete_cost[-delta] + extra_cost); cost1 += first_delete_cost[-i] - first_delete_cost[1-i] + - (delta-1) * ( next_delete_cost[-i] - next_delete_cost[1-i]); + (delta-1) * ( next_delete_cost[-i] - next_delete_cost[1-i]); } if (cost1 < cost) { @@ -644,7 +642,7 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below, and UNCHANGED_AT_TOP is the vpos of the first line being considered. These two arguments can specify any contiguous range of lines. - + In the direct scrolling method, a new scroll window is selected before each insertion or deletion, so that groups of lines can be scrolled directly to their final vertical positions. This method @@ -704,11 +702,11 @@ do_direct_scrolling (current_matrix, cost_matrix, window_size, without also decrementing i, this corresponds to omitting these lines in the new rows, i.e. rows are deleted. */ i = j = window_size; - + while (i > 0 || j > 0) { p = cost_matrix + i * (window_size + 1) + j; - + if (p->insertcost < p->writecost && p->insertcost < p->deletecost && (write_follows_p || i < j)) @@ -720,7 +718,7 @@ do_direct_scrolling (current_matrix, cost_matrix, window_size, queue->window = i; queue->pos = i - p->insertcount; ++queue; - + i -= p->insertcount; write_follows_p = 0; } @@ -739,7 +737,7 @@ do_direct_scrolling (current_matrix, cost_matrix, window_size, place they belong. */ int n_to_write = p->writecount; write_follows_p = 1; - xassert (n_to_write > 0); + xassert (n_to_write > 0); if (i > j) { @@ -825,7 +823,7 @@ scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom, { calculate_direct_scrolling (frame, matrix, window_size, unchanged_at_bottom, - draw_cost, old_draw_cost, + draw_cost, old_draw_cost, old_hash, new_hash, free_at_end); do_direct_scrolling (frame->current_matrix, matrix, window_size, unchanged_at_top); @@ -912,7 +910,7 @@ scroll_cost (frame, from, to, amount) will not be involved in actual motion. */ int limit = to; int offset; - int height = FRAME_HEIGHT (frame); + int height = FRAME_LINES (frame); if (amount == 0) return 0; @@ -950,11 +948,11 @@ line_ins_del (frame, ov1, pf1, ovn, pfn, ov, mf) register int *ov, *mf; { register int i; - register int frame_height = FRAME_HEIGHT (frame); + register int frame_lines = FRAME_LINES (frame); register int insert_overhead = ov1 * 10; register int next_insert_cost = ovn * 10; - for (i = frame_height-1; i >= 0; i--) + for (i = frame_lines-1; i >= 0; i--) { mf[i] = next_insert_cost / 10; next_insert_cost += pfn; @@ -1003,12 +1001,12 @@ ins_del_costs (frame, only) and those that must repeatedly insert one line. The cost to insert N lines at line L is - [tt.t_ILov + (frame_height + 1 - L) * tt.t_ILpf] + - N * [tt.t_ILnov + (frame_height + 1 - L) * tt.t_ILnpf] + [tt.t_ILov + (frame_lines + 1 - L) * tt.t_ILpf] + + N * [tt.t_ILnov + (frame_lines + 1 - L) * tt.t_ILnpf] ILov represents the basic insert line overhead. ILpf is the padding required to allow the terminal time to move a line: insertion at line - L changes (frame_height + 1 - L) lines. + L changes (frame_lines + 1 - L) lines. The first bracketed expression above is the overhead; the second is the multiply factor. Both are dependent only on the position at @@ -1038,27 +1036,27 @@ do_line_insertion_deletion_costs (frame, { FRAME_INSERT_COST (frame) = (int *) xrealloc (FRAME_INSERT_COST (frame), - FRAME_HEIGHT (frame) * sizeof (int)); + FRAME_LINES (frame) * sizeof (int)); FRAME_DELETEN_COST (frame) = (int *) xrealloc (FRAME_DELETEN_COST (frame), - FRAME_HEIGHT (frame) * sizeof (int)); + FRAME_LINES (frame) * sizeof (int)); FRAME_INSERTN_COST (frame) = (int *) xrealloc (FRAME_INSERTN_COST (frame), - FRAME_HEIGHT (frame) * sizeof (int)); + FRAME_LINES (frame) * sizeof (int)); FRAME_DELETE_COST (frame) = (int *) xrealloc (FRAME_DELETE_COST (frame), - FRAME_HEIGHT (frame) * sizeof (int)); + FRAME_LINES (frame) * sizeof (int)); } else { FRAME_INSERT_COST (frame) = - (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); + (int *) xmalloc (FRAME_LINES (frame) * sizeof (int)); FRAME_DELETEN_COST (frame) = - (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); + (int *) xmalloc (FRAME_LINES (frame) * sizeof (int)); FRAME_INSERTN_COST (frame) = - (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); - FRAME_DELETE_COST (frame) = - (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); + (int *) xmalloc (FRAME_LINES (frame) * sizeof (int)); + FRAME_DELETE_COST (frame) = + (int *) xmalloc (FRAME_LINES (frame) * sizeof (int)); } ins_del_costs (frame, @@ -1072,3 +1070,6 @@ do_line_insertion_deletion_costs (frame, FRAME_DELETE_COST (frame), FRAME_DELETEN_COST (frame), coefficient); } + +/* arch-tag: cdb7149c-48e7-4793-a948-2786c8e45485 + (do not change this comment) */