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;
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;
/* 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;
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));
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.
}
}
while (queue > queue_start);
-
+
}
for (k = 0; k < window_size; ++k)
/* Some sanity checks if GLYPH_DEBUG != 0. */
CHECK_MATRIX (current_matrix);
-
+
if (terminal_window_p)
set_terminal_window (0);
}
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;
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;
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
{
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)
{
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
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))
queue->window = i;
queue->pos = i - p->insertcount;
++queue;
-
+
i -= p->insertcount;
write_follows_p = 0;
}
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)
{
{
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);
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;
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;
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
{
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,
FRAME_DELETE_COST (frame), FRAME_DELETEN_COST (frame),
coefficient);
}
+
+/* arch-tag: cdb7149c-48e7-4793-a948-2786c8e45485
+ (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff