comparison src/scroll.c @ 49600:23a1cea22d13

Trailing whitespace deleted.

49599:5ade352e8d1c


/* 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).  

   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 matrix_elt *matrix;
     int window_size;

  /* A queue for line insertions to be done.  */
  struct queue { int count, pos; };
  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));

  /* Zero means line is empty.  */
  bzero (retained_p, window_size * sizeof (char));

     When i is advanced, this corresponds to inserted lines.  */
  i = j = window_size;
  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.
	     Queue the screen operation to be performed.  */
	  queue->count = p->insertcount;

		 glyph row j.  */
	      copy_from[k + j] = next;
	    }
	}
      while (queue > queue_start);
	  
    }

  for (k = 0; k < window_size; ++k)
    xassert (copy_from[k] >= 0 && copy_from[k] < window_size);

  mirrored_line_dance (current_matrix, unchanged_at_top, window_size,
		       copy_from, retained_p);

  /* Some sanity checks if GLYPH_DEBUG != 0.  */
  CHECK_MATRIX (current_matrix);
  
  if (terminal_window_p)
    set_terminal_window (0);
}



		   rate of change of these two parameters.  Each of these
		   growth rates can be determined by a simple difference.
		   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]); 
	      }
	    else
	      {
		delta = j - 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]); 
	      }
	    if (cost1 < cost)
	      {
		cost = cost1;
		p->writecount = p1->writecount + 1;

   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.
 
   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
   is described in more detail in calculate_direct_scrolling, where
   the cost matrix for this approach is constructed. */

     If i is decremented without also decrementing j, this corresponds
     to inserting empty lines in the result.  If j is decremented
     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))
	{
	  /* Insert is cheaper than deleting or writing lines.  Leave

	     empty lines when the queue is emptied.  */
	  queue->count = 0;
	  queue->window = i;
	  queue->pos = i - p->insertcount;
	  ++queue;
	  
	  i -= p->insertcount;
	  write_follows_p = 0;
	}
      else if (p->deletecost < p->writecost
	       && (write_follows_p || i > j))

	  /* One or more lines should be written.  In the direct
	     scrolling method we do this by scrolling the lines to the
	     place they belong.  */
	  int n_to_write = p->writecount;
	  write_follows_p = 1;
	  xassert (n_to_write > 0); 

	  if (i > j)
	    {
	      /* Immediately insert lines */
	      set_terminal_window (i + unchanged_at_top);

  if (scroll_region_ok)
    {
      calculate_direct_scrolling (frame, matrix, window_size,
				  unchanged_at_bottom,
				  draw_cost, old_draw_cost, 
				  old_hash, new_hash, free_at_end);
      do_direct_scrolling (frame->current_matrix,
			   matrix, window_size, unchanged_at_top);
    }
  else

	(int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int));
      FRAME_DELETEN_COST (frame) =
	(int *) xmalloc (FRAME_HEIGHT (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));
    }

  ins_del_costs (frame,
		 ins_line_string, multi_ins_string,

49600:23a1cea22d13


/* 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).

   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 matrix_elt *matrix;
     int window_size;

  /* A queue for line insertions to be done.  */
  struct queue { int count, pos; };
  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));

  /* Zero means line is empty.  */
  bzero (retained_p, window_size * sizeof (char));

     When i is advanced, this corresponds to inserted lines.  */
  i = j = window_size;
  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.
	     Queue the screen operation to be performed.  */
	  queue->count = p->insertcount;

		 glyph row j.  */
	      copy_from[k + j] = next;
	    }
	}
      while (queue > queue_start);

    }

  for (k = 0; k < window_size; ++k)
    xassert (copy_from[k] >= 0 && copy_from[k] < window_size);

  mirrored_line_dance (current_matrix, unchanged_at_top, window_size,
		       copy_from, retained_p);

  /* Some sanity checks if GLYPH_DEBUG != 0.  */
  CHECK_MATRIX (current_matrix);

  if (terminal_window_p)
    set_terminal_window (0);
}



		   rate of change of these two parameters.  Each of these
		   growth rates can be determined by a simple difference.
		   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]);
	      }
	    else
	      {
		delta = j - 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]);
	      }
	    if (cost1 < cost)
	      {
		cost = cost1;
		p->writecount = p1->writecount + 1;

   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.

   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
   is described in more detail in calculate_direct_scrolling, where
   the cost matrix for this approach is constructed. */

     If i is decremented without also decrementing j, this corresponds
     to inserting empty lines in the result.  If j is decremented
     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))
	{
	  /* Insert is cheaper than deleting or writing lines.  Leave

	     empty lines when the queue is emptied.  */
	  queue->count = 0;
	  queue->window = i;
	  queue->pos = i - p->insertcount;
	  ++queue;

	  i -= p->insertcount;
	  write_follows_p = 0;
	}
      else if (p->deletecost < p->writecost
	       && (write_follows_p || i > j))

	  /* One or more lines should be written.  In the direct
	     scrolling method we do this by scrolling the lines to the
	     place they belong.  */
	  int n_to_write = p->writecount;
	  write_follows_p = 1;
	  xassert (n_to_write > 0);

	  if (i > j)
	    {
	      /* Immediately insert lines */
	      set_terminal_window (i + unchanged_at_top);

  if (scroll_region_ok)
    {
      calculate_direct_scrolling (frame, matrix, window_size,
				  unchanged_at_bottom,
				  draw_cost, old_draw_cost,
				  old_hash, new_hash, free_at_end);
      do_direct_scrolling (frame->current_matrix,
			   matrix, window_size, unchanged_at_top);
    }
  else

	(int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int));
      FRAME_DELETEN_COST (frame) =
	(int *) xmalloc (FRAME_HEIGHT (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));
    }

  ins_del_costs (frame,
		 ins_line_string, multi_ins_string,