(function*, case, ecase, typecase, etypecase, progv, lexical-let, lexical-let*,

[bpt/emacs.git] / src / scroll.c

diff --git a/src/scroll.c b/src/scroll.c
index 5e45725..6c6aa4a 100644 (file)
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -89,14 +89,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;
      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 *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;
 
   register struct matrix_elt *p, *p1;
   register int cost, cost1;
 


@@ -105,18 +105,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
      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
   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
   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
   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.  */
 
   /* 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;
 
   if (baud_rate <= 0)
     extra_cost = 1;


@@ -232,13 +232,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
 /* 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.  */
 
    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;
 static void
 do_scrolling (current_matrix, matrix, window_size, unchanged_at_top)
      struct glyph_matrix *current_matrix;


@@ -258,7 +258,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;
   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));
 
   char *retained_p = (char *) alloca (window_size * sizeof (char));
   int *copy_from = (int *) alloca (window_size * sizeof (int));
 


@@ -283,7 +283,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top)
   while (i > 0 || j > 0)
     {
       p = matrix + i * (window_size + 1) + j;
   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.
       if (p->insertcost < p->writecost && p->insertcost < p->deletecost)
        {
          /* Insert should be done at vpos i-1, plus maybe some before.


@@ -365,7 +365,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top)
            }
        }
       while (queue > queue_start);
            }
        }
       while (queue > queue_start);

-         
+

     }
 
   for (k = 0; k < window_size; ++k)
     }
 
   for (k = 0; k < window_size; ++k)


@@ -377,7 +377,7 @@ do_scrolling (current_matrix, matrix, window_size, unchanged_at_top)
 
   /* Some sanity checks if GLYPH_DEBUG != 0.  */
   CHECK_MATRIX (current_matrix);
 
   /* Some sanity checks if GLYPH_DEBUG != 0.  */
   CHECK_MATRIX (current_matrix);

-  
+

   if (terminal_window_p)
     set_terminal_window (0);
 }
   if (terminal_window_p)
     set_terminal_window (0);
 }


@@ -430,7 +430,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;
      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 *draw_cost;
      int *old_draw_cost;
      int *old_hash;


@@ -438,27 +438,27 @@ calculate_direct_scrolling (frame, matrix, window_size, lines_below,
      int free_at_end;
 {
   register int i, j;
      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
   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
   int *first_delete_cost

-    = &FRAME_DELETE_COST (frame)[frame_height - 1];
+    = &FRAME_DELETE_COST (frame)[frame_lines - 1];

   int *next_insert_cost
   int *next_insert_cost

-    = &FRAME_INSERTN_COST (frame)[frame_height - 1];
+    = &FRAME_INSERTN_COST (frame)[frame_lines - 1];

   int *next_delete_cost
   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 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;
 
   if (baud_rate <= 0)
     extra_cost = 1;


@@ -562,7 +562,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] +
                   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
              {
              }
            else
              {


@@ -570,7 +570,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] +
                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)
              {
              }
            if (cost1 < cost)
              {


@@ -641,7 +641,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.
    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
    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


@@ -701,11 +701,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;
      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;
   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))
       if (p->insertcost < p->writecost
          && p->insertcost < p->deletecost
          && (write_follows_p || i < j))


@@ -717,7 +717,7 @@ do_direct_scrolling (current_matrix, cost_matrix, window_size,
          queue->window = i;
          queue->pos = i - p->insertcount;
          ++queue;
          queue->window = i;
          queue->pos = i - p->insertcount;
          ++queue;

-         
+

          i -= p->insertcount;
          write_follows_p = 0;
        }
          i -= p->insertcount;
          write_follows_p = 0;
        }


@@ -736,7 +736,7 @@ do_direct_scrolling (current_matrix, cost_matrix, window_size,
             place they belong.  */
          int n_to_write = p->writecount;
          write_follows_p = 1;
             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)
            {
 
          if (i > j)
            {


@@ -822,7 +822,7 @@ scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom,
     {
       calculate_direct_scrolling (frame, matrix, window_size,
                                  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);
                                  old_hash, new_hash, free_at_end);
       do_direct_scrolling (frame->current_matrix,
                           matrix, window_size, unchanged_at_top);


@@ -909,7 +909,7 @@ scroll_cost (frame, from, to, amount)
      will not be involved in actual motion.  */
   int limit = to;
   int offset;
      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;
 
   if (amount == 0)
     return 0;


@@ -947,11 +947,11 @@ line_ins_del (frame, ov1, pf1, ovn, pfn, ov, mf)
      register int *ov, *mf;
 {
   register int i;
      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;
 
   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;
     {
       mf[i] = next_insert_cost / 10;
       next_insert_cost += pfn;


@@ -1000,12 +1000,12 @@ ins_del_costs (frame,
    only) and those that must repeatedly insert one line.
 
    The cost to insert N lines at line L is
    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
 
    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
 
    The first bracketed expression above is the overhead; the second is
    the multiply factor.  Both are dependent only on the position at


@@ -1035,27 +1035,27 @@ do_line_insertion_deletion_costs (frame,
     {
       FRAME_INSERT_COST (frame) =
        (int *) xrealloc (FRAME_INSERT_COST (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_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_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_DELETE_COST (frame) =
        (int *) xrealloc (FRAME_DELETE_COST (frame),

-                         FRAME_HEIGHT (frame) * sizeof (int));
+                         FRAME_LINES (frame) * sizeof (int));

     }
   else
     {
       FRAME_INSERT_COST (frame) =
     }
   else
     {
       FRAME_INSERT_COST (frame) =

-       (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int));
+       (int *) xmalloc (FRAME_LINES (frame) * sizeof (int));

       FRAME_DELETEN_COST (frame) =
       FRAME_DELETEN_COST (frame) =

-       (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int));
+       (int *) xmalloc (FRAME_LINES (frame) * sizeof (int));

       FRAME_INSERTN_COST (frame) =
       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,
     }
 
   ins_del_costs (frame,


@@ -1069,3 +1069,6 @@ do_line_insertion_deletion_costs (frame,
                 FRAME_DELETE_COST (frame), FRAME_DELETEN_COST (frame),
                 coefficient);
 }
                 FRAME_DELETE_COST (frame), FRAME_DELETEN_COST (frame),
                 coefficient);
 }

+
+/* arch-tag: cdb7149c-48e7-4793-a948-2786c8e45485
+   (do not change this comment) */