[Emacs-diffs] /srv/bzr/emacs/trunk r106534: Truncate scroll runs that copy to where we copied to.

[YAMAMOTO Mitsuharu]

------------------------------------------------------------
revno: 106534
committer: YAMAMOTO Mitsuharu <address@hidden>
branch nick: trunk
timestamp: Mon 2011-11-28 10:07:01 +0900
message:
  Truncate scroll runs that copy to where we copied to.
  
  * dispnew.c (scrolling_window): Truncate overlaps in copy destination
  of scroll runs so as to avoid assigning disabled bogus rows and
  unnecessary graphics copy operations.
modified:
  src/ChangeLog
  src/dispnew.c

=== modified file 'src/ChangeLog'
--- a/src/ChangeLog     2011-11-27 18:52:53 +0000
+++ b/src/ChangeLog     2011-11-28 01:07:01 +0000
@@ -1,3 +1,9 @@
+2011-11-28  YAMAMOTO Mitsuharu  <address@hidden>
+
+       * dispnew.c (scrolling_window): Truncate overlaps in copy destination
+       of scroll runs so as to avoid assigning disabled bogus rows and
+       unnecessary graphics copy operations.
+
 2011-11-27  Eli Zaretskii  <address@hidden>
 
        * s/ms-w32.h (utimbuf) [_MSC_VER]: Don't define.

=== modified file 'src/dispnew.c'
--- a/src/dispnew.c     2011-11-26 13:11:03 +0000
+++ b/src/dispnew.c     2011-11-28 01:07:01 +0000
@@ -4554,18 +4554,69 @@
          {
            rif->clear_window_mouse_face (w);
            rif->scroll_run_hook (w, r);
-
-           /* Invalidate runs that copy from where we copied to.  */
-           for (j = i + 1; j < nruns; ++j)
+         }
+
+       /* Truncate runs that copy to where we copied to, and
+          invalidate runs that copy from where we copied to.  */
+       for (j = nruns - 1; j > i; --j)
+         {
+           struct run *p = runs[j];
+           int truncated_p = 0;
+
+           if (p->nrows > 0
+               && p->desired_y < r->desired_y + r->height
+               && p->desired_y + p->height > r->desired_y)
              {
-               struct run *p = runs[j];
-
-               if ((p->current_y >= r->desired_y
+               if (p->desired_y < r->desired_y)
+                 {
+                   p->nrows = r->desired_vpos - p->desired_vpos;
+                   p->height = r->desired_y - p->desired_y;
+                   truncated_p = 1;
+                 }
+               else
+                 {
+                   int nrows_copied = (r->desired_vpos + r->nrows
+                                       - p->desired_vpos);
+
+                   if (p->nrows <= nrows_copied)
+                     p->nrows = 0;
+                   else
+                     {
+                       int height_copied = (r->desired_y + r->height
+                                            - p->desired_y);
+
+                       p->current_vpos += nrows_copied;
+                       p->desired_vpos += nrows_copied;
+                       p->nrows -= nrows_copied;
+                       p->current_y += height_copied;
+                       p->desired_y += height_copied;
+                       p->height -= height_copied;
+                       truncated_p = 1;
+                     }
+                 }
+             }
+
+           if (r->current_y != r->desired_y
+               /* The condition below is equivalent to
+                  ((p->current_y >= r->desired_y
                     && p->current_y < r->desired_y + r->height)
-                   || (p->current_y + p->height >= r->desired_y
+                   || (p->current_y + p->height > r->desired_y
                        && (p->current_y + p->height
-                           < r->desired_y + r->height)))
-                 p->nrows = 0;
+                           <= r->desired_y + r->height)))
+                  because we have 0 < p->height <= r->height.  */
+               && p->current_y < r->desired_y + r->height
+               && p->current_y + p->height > r->desired_y)
+             p->nrows = 0;
+
+           /* Reorder runs by copied pixel lines if truncated.  */
+           if (truncated_p && p->nrows > 0)
+             {
+               int k = nruns - 1;
+
+               while (runs[k]->nrows == 0 || runs[k]->height < p->height)
+                 k--;
+               memmove (runs + j, runs + j + 1, (k - j) * sizeof (*runs));
+               runs[k] = p;
              }
          }
 
@@ -4580,7 +4631,14 @@
            to_overlapped_p = to->overlapped_p;
            from->redraw_fringe_bitmaps_p = from->fringe_bitmap_periodic_p;
            assign_row (to, from);
-           to->enabled_p = 1, from->enabled_p = 0;
+           /* The above `assign_row' actually does swap, so if we had
+              an overlap in the copy destination of two runs, then
+              the second run would assign a previously disabled bogus
+              row.  But thanks to the truncation code in the
+              preceding for-loop, we no longer have such an overlap,
+              and thus the assigned row should always be enabled.  */
+           xassert (to->enabled_p);
+           from->enabled_p = 0;
            to->overlapped_p = to_overlapped_p;
          }
       }