--- rxvt-unicode/src/screen.C	2005/12/21 23:57:12	1.187
+++ rxvt-unicode/src/screen.C	2005/12/26 23:12:59	1.196
@@ -273,91 +273,138 @@
 
       line_t *old_buf = row_buf; row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
         
-      // re-wrap lines, this is rather ugly, possibly because I am too dumb
-      // to come up with a lean and mean algorithm.
-
       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
       int pend = MOD (term_start - nsaved   , prev_total_rows);
       int q    = total_rows; // rewrapped row
 
-      while (p != pend && q > 0)
+      if (nsaved)
         {
-          p = MOD (p - 1, prev_total_rows);
-#ifdef DEBUG_STRICT
-          assert (old_buf [MOD (p, prev_total_rows)].t);
-#endif
+          // re-wrap lines, this is rather ugly, possibly because I am too dumb
+          // to come up with a lean and mean algorithm.
 
-          int llen = old_buf [MOD (p, prev_total_rows)].l;
+          row_col_t ocur = screen.cur;
+          ocur.row = MOD (term_start + ocur.row, prev_total_rows);
 
-          while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
+          do
             {
               p = MOD (p - 1, prev_total_rows);
+#ifdef DEBUG_STRICT
+              assert (old_buf [MOD (p, prev_total_rows)].t);
+#endif
 
-              llen += prev_ncol;
-            }
+              int plines = 1;
+              int llen = old_buf [MOD (p, prev_total_rows)].l;
 
-          int qlines = max (0, (llen - 1) / ncol) + 1;
+              while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
+                {
+                  p = MOD (p - 1, prev_total_rows);
 
-          // drop partial lines completely
-          if (q < qlines)
-            break;
+                  plines++;
+                  llen += prev_ncol;
+                }
 
-          q -= qlines;
+              int qlines = max (0, (llen - 1) / ncol) + 1;
 
-          int lofs = 0;
-          line_t *qline;
+              // drop partial lines completely
+              if (q < qlines)
+                break;
 
-          // re-assemble the full line by destination lines
-          for (int qrow = q; qlines--; qrow++)
-            {
-              qline = row_buf + qrow;
-              lalloc (*qline);
-              qline->set_is_longer ();
+              q -= qlines;
 
-              int qcol = 0;
+              int lofs = 0;
+              line_t *qline;
 
-              // fill a single destination line
-              while (lofs < llen && qcol < ncol)
+              // re-assemble the full line by destination lines
+              for (int qrow = q; qlines--; qrow++)
                 {
-                  int prow = lofs / prev_ncol;
-                  int pcol = lofs % prev_ncol;
+                  qline = row_buf + qrow;
+                  lalloc (*qline);
+                  qline->set_is_longer ();
 
-                  line_t &pline = old_buf [MOD (p + prow, prev_total_rows)];
+                  int qcol = 0;
 
-                  int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
+                  // fill a single destination line
+                  while (lofs < llen && qcol < ncol)
+                    {
+                      int prow = lofs / prev_ncol;
+                      int pcol = lofs % prev_ncol;
 
-                  assert (len);
-                  assert (pline.t);
+                      prow = MOD (p + prow, prev_total_rows);
 
-                  memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
-                  memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
+                      // we only adjust the cursor _row_ and put it into
+                      // the topmost line of "long line" it was in, as
+                      // this seems to upset applications/shells/readline
+                      // least.
+                      if (prow == ocur.row)
+                        screen.cur.row = q - (total_rows - nrow);
 
-                  lofs += len;
-                  qcol += len;
+                      line_t &pline = old_buf [prow];
+
+                      int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
+
+                      assert (len);
+                      assert (pline.t);
+
+                      memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
+                      memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
+
+                      lofs += len;
+                      qcol += len;
+                    }
                 }
+
+              qline->l = llen ? MOD (llen - 1, ncol) + 1 : 0;
+#ifdef DEBUG_STRICT //TODO//FIXME//TEMPORARY
+              if (qline->l < 0)
+                {
+                  fprintf (stderr, "ERROR, PLEASE REPORT to rxvt-unicode@plan9.de: qline->l %d = llen %d < ncol %d ? %d : MOD %d\n", qline->l,llen,ncol,llen,MOD (llen - 1, ncol) + 1);//D
+                  qline->l = 0;
+                }
+#endif
+              scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
             }
+          while (p != pend && q > 0);
+
+          term_start = total_rows - nrow;
+          nsaved = term_start - q;
+ 
+          // make sure all terminal lines exist
+          while (nsaved < 0)
+            scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE);
 
-          qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1;
-          scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
         }
+      else
+        {
+          // if no scrollback exists (yet), wing, instead of wrap
+          
+          for (int row = min (nrow, prev_nrow); row--; )
+            {
+              line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];
+              line_t &qline = row_buf [row];
 
-      term_start = total_rows - nrow;
-      view_start = 0;
-      nsaved = term_start - q;
+              qline = pline;
+              lresize (qline);
+            }
+
+          for (int row = prev_nrow; row < nrow; row++)
+            {
+              row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
+            }
 
-      // make sure all terminal lines exist
-      while (nsaved < 0)
-        scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE);
+          term_start = 0;
+        }
 
+#ifdef DEBUG_STRICT //TODO: remove
       for (int i = -nsaved; i < nrow; i++)
-        assert (ROW (i).t);//D
+        assert (ROW (i).t);
+#endif
 
       free (old_buf);
       delete old_ta;
       delete old_ra;
 
-      min_it (screen.cur.row, nrow - 1);
-      min_it (screen.cur.col, ncol - 1);
+      clamp_it (screen.cur.row, 0, nrow - 1);
+      clamp_it (screen.cur.col, 0, ncol - 1);
 
       if (tabs)
         free (tabs);
@@ -489,7 +536,7 @@
     {
       num_scr = 0;
 
-      for (int i = nrow; i--; )
+      for (int i = prev_nrow; i--; )
         ::swap (ROW(i), swap_buf [i]);
 
       ::swap (screen.charset, swap.charset);
@@ -582,11 +629,20 @@
           selection.end.row  -= count;
           selection.mark.row -= count;
 
-          selection_check (0);
+          if (selection.beg.row < -nsaved
+              || selection.end.row < -nsaved
+              || selection.mark.row < -nsaved)
+            {
+              CLEAR_ALL_SELECTION ();
+              selection.op = SELECTION_CLEAR;
+            }
         }
 
       for (int i = count; i--; )
-        scr_blank_screen_mem (ROW(row2 - i), rstyle);
+        {
+          ROW(row2 - i).l = 0;
+          scr_blank_screen_mem (ROW(row2 - i), rstyle);
+        }
       
       if ((options & Opt_scrollWithBuffer)
           && view_start != 0
@@ -597,20 +653,17 @@
     {
       if (selection.op && current_screen == selection.screen)
         {
-          int i = selection.beg.row;
-          int j = selection.end.row;
-
-          if ((i < row1 && j > row1)
-              || (i < row2 && j > row2)
-              || (i - count < row1 && i >= row1)
-              || (i - count > row2 && i <= row2)
-              || (j - count < row1 && j >= row1)
-              || (j - count > row2 && j <= row2))
+          if ((selection.beg.row < row1 && selection.end.row > row1)
+              || (selection.beg.row < row2 && selection.end.row > row2)
+              || (selection.beg.row - count < row1 && selection.beg.row >= row1)
+              || (selection.beg.row - count > row2 && selection.beg.row <= row2)
+              || (selection.end.row - count < row1 && selection.end.row >= row1)
+              || (selection.end.row - count > row2 && selection.end.row <= row2))
             {
               CLEAR_ALL_SELECTION ();
-              selection.op = SELECTION_CLEAR;  /* XXX: too aggressive? */
+              selection.op = SELECTION_CLEAR;
             }
-          else if (j >= row1 && j <= row2)
+          else if (selection.end.row >= row1 && selection.end.row <= row2)
             {
               /* move selected region too */
               selection.beg.row  -= count;
@@ -655,7 +708,7 @@
 
   unsigned char checksel;
   unicode_t c;
-  int row, last_col;
+  int last_col;
   const unicode_t *strend = str + len;
 
   want_refresh = 1;
@@ -680,7 +733,7 @@
   assert (screen.cur.row < nrow
           && screen.cur.row >= -nsaved);
 #endif
-  row = screen.cur.row;
+  int row = screen.cur.row;
 
   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
 
@@ -692,7 +745,7 @@
 
       if (c < 0x20)
         if (c == C0_LF)
-          {          
+          {
             if (!line->is_longer ())      /* XXX: think about this */
               max_it (line->l, screen.cur.col);
 
@@ -947,9 +1000,7 @@
     return;
   else if (count > 0)
     {
-      int row = screen.cur.row;
-
-      line_t &l = ROW(row);
+      line_t &l = ROW(screen.cur.row);
       rend_t base_rend = l.r[i];
       ht &= l.t[i] == ' ';
 
@@ -1034,16 +1085,12 @@
 void
 rxvt_term::scr_forwardindex ()
 {
-  int row;
-
   if (screen.cur.col < ncol - 1)
     scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
   else
     {
-      row = screen.cur.row;
-
-      if (ROW(row).is_longer ()) //TODO//FIXME//LEN
-        ROW(row).l = ncol;
+      if (ROW(screen.cur.row).is_longer ()) //TODO//FIXME//LEN
+        ROW(screen.cur.row).l = ncol;
 
       scr_gotorc (0, 0, R_RELATIVE);
       scr_insdel_chars (1, DELETE);
@@ -1136,21 +1183,21 @@
 void
 rxvt_term::scr_erase_line (int mode)
 {
-  unsigned int row, col, num;
+  unsigned int col, num;
 
   want_refresh = 1;
   ZERO_SCROLLBACK ();
 
   selection_check (1);
 
-  row = screen.cur.row;
+  line_t &line = ROW(screen.cur.row);
 
   switch (mode)
     {
       case 0:                     /* erase to end of line */
         col = screen.cur.col;
         num = ncol - col;
-        min_it (ROW(row).l, col);
+        min_it (line.l, col);
         if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
             || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
           CLEAR_SELECTION ();
@@ -1165,7 +1212,7 @@
       case 2:                     /* erase whole line */
         col = 0;
         num = ncol;
-        ROW(row).l = 0;
+        line.l = 0;
         if (selection.beg.row <= screen.cur.row
             && selection.end.row >= screen.cur.row)
           CLEAR_SELECTION ();
@@ -1174,7 +1221,7 @@
         return;
     }
 
-  scr_blank_line (ROW(row), col, num, rstyle);
+  scr_blank_line (line, col, num, rstyle);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1248,8 +1295,8 @@
 
   for (; num--; row++)
     {
-      scr_blank_screen_mem (ROW (row), rstyle);
       ROW (row).l = 0;
+      scr_blank_screen_mem (ROW (row), rstyle);
       scr_blank_line (drawn_buf [row], 0, ncol, ren);
     }
 }
@@ -2417,7 +2464,7 @@
           else
             {
               col = 0;
-              row = view_start;
+              row = -view_start;
             }
 
           for (; row < min (selection.end.row, view_end); row++, col = 0)