--- rxvt-unicode/src/screen.C	2007/12/14 05:52:34	1.290
+++ rxvt-unicode/src/screen.C	2011/11/16 18:26:47	1.406
@@ -3,7 +3,7 @@
  *---------------------------------------------------------------------------*
  *
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
- * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
+ * Copyright (c) 2003-2007 Marc Lehmann <schmorp@schmorp.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -30,17 +30,16 @@
 
 #include <inttypes.h>
 
-#include "salloc.C" // HACK, should be a seperate compile!
+#include "salloc.C" // HACK, should be a separate compile!
 
-static inline void fill_text (text_t *start, text_t value, int len)
+static inline void
+fill_text (text_t *start, text_t value, int len)
 {
   while (len--)
     *start++ = value;
 }
 
 /* ------------------------------------------------------------------------- */
-#define PROP_SIZE               256*1024
-#define PASTE_SIZE		32768
 #define TABSIZE                 8       /* default tab size */
 
 /* ------------------------------------------------------------------------- *
@@ -85,30 +84,14 @@
     ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
 
 /*
- * CLEAR_ROWS : clear <num> rows starting from row <row>
  * CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
- * ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour
  */
-#define drawBuffer      vt
-
-#define CLEAR_ROWS(row, num)                                           \
-    if (mapped)                                                \
-        XClearArea (dpy, drawBuffer, 0,                   \
-                    Row2Pixel (row), (unsigned int)width,      \
-                    (unsigned int)Height2Pixel (num), False)
-
 #define CLEAR_CHARS(x, y, num)                                         \
-    if (mapped)                                                \
-        XClearArea (dpy, drawBuffer, x, y,                \
+    if (mapped)                                                        \
+        XClearArea (dpy, vt, x, y,                                     \
                     (unsigned int)Width2Pixel (num),                   \
                     (unsigned int)Height2Pixel (1), False)
 
-#define ERASE_ROWS(row, num)                                           \
-    XFillRectangle (dpy, drawBuffer, gc,          \
-                    0, Row2Pixel (row),                                \
-                    (unsigned int)width,                       \
-                    (unsigned int)Height2Pixel (num))
-
 /* ------------------------------------------------------------------------- *
  *                        SCREEN `COMMON' ROUTINES                           *
  * ------------------------------------------------------------------------- */
@@ -150,6 +133,27 @@
   l.f = 0;
 }
 
+// nuke a single wide character at the given column
+void
+rxvt_term::scr_kill_char (line_t &l, int col) const NOTHROW
+{
+  // find begin
+  while (col > 0 && l.t[col] == NOCHAR)
+    col--;
+
+  rend_t rend = l.r[col] & ~RS_baseattrMask;
+  rend = SET_FONT (rend, FONTSET (rend)->find_font (' '));
+
+  l.touch ();
+
+  // found start, nuke
+  do {
+    l.t[col] = ' ';
+    l.r[col] = rend;
+    col++;
+  } while (col < ncol && l.t[col] == NOCHAR);
+}
+
 /* ------------------------------------------------------------------------- *
  *                          SCREEN INITIALISATION                            *
  * ------------------------------------------------------------------------- */
@@ -161,7 +165,6 @@
   scr_overlay_off ();
 #endif
 
-  rvideo_mode = false;
   view_start = 0;
   num_scr = 0;
 
@@ -174,9 +177,6 @@
   if (ncol == prev_ncol && nrow == prev_nrow)
     return;
 
-  if (current_screen != PRIMARY)
-    scr_swap_screen ();
-
   // we need at least two lines for wrapping to work correctly
   while (nrow + saveLines < 2)
     {
@@ -205,7 +205,7 @@
       talloc = new rxvt_salloc (ncol * sizeof (text_t));
       ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
 
-      row_buf   = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
+      row_buf   = (line_t *)rxvt_calloc (total_rows       , sizeof (line_t));
       drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
       swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
 
@@ -238,6 +238,8 @@
       selection.op = SELECTION_CLEAR;
       selection.screen = PRIMARY;
       selection.clicks = 0;
+      selection.clip_text = NULL;
+      selection.clip_len = 0;
     }
   else
     {
@@ -275,7 +277,7 @@
         }
 
       line_t *old_buf = row_buf;
-      row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
+      row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
 
       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
       int pend = MOD (term_start + top_row  , prev_total_rows);
@@ -285,6 +287,7 @@
         {
           // Re-wrap lines. This is rather ugly, possibly because I am too dumb
           // to come up with a lean and mean algorithm.
+          // TODO: maybe optimise when width didn't change
 
           row_col_t ocur = screen.cur;
           ocur.row = MOD (term_start + ocur.row, prev_total_rows);
@@ -292,9 +295,7 @@
           do
             {
               p = MOD (p - 1, prev_total_rows);
-#ifdef DEBUG_STRICT
               assert (old_buf [MOD (p, prev_total_rows)].t);
-#endif
               int plines = 1;
               int llen = old_buf [MOD (p, prev_total_rows)].l;
 
@@ -398,22 +399,18 @@
 
       clamp_it (screen.cur.row, 0, nrow - 1);
       clamp_it (screen.cur.col, 0, ncol - 1);
-
-      free (tabs);
     }
 
-  CLEAR_ALL_SELECTION ();
-
-  prev_nrow = nrow;
-  prev_ncol = ncol;
-
+  free (tabs);
   tabs = (char *)rxvt_malloc (ncol);
 
-  for (int col = ncol; --col; )
+  for (int col = ncol; col--; )
     tabs [col] = col % TABSIZE == 0;
 
-  if (current_screen != PRIMARY)
-    scr_swap_screen ();
+  CLEAR_ALL_SELECTION ();
+
+  prev_nrow = nrow;
+  prev_ncol = ncol;
 
   tt_winch ();
 
@@ -435,27 +432,46 @@
       free (row_buf);
       free (swap_buf);
       free (drawn_buf);
-      free (tabs);
+      row_buf = 0; // signal that we freed all the arrays above
 
-      row_buf = 0; // signal that we freed all the arrays
+      free (tabs);
+      tabs = 0;
     }
 }
 
 /* ------------------------------------------------------------------------- */
 /*
- * Hard reset
+ * Hard/Soft reset
  */
 void
 rxvt_term::scr_poweron ()
 {
   scr_release ();
   prev_nrow = prev_ncol = 0;
+  rvideo_mode = false;
+  scr_soft_reset ();
   scr_reset ();
 
   scr_clear (true);
   scr_refresh ();
 }
 
+void
+rxvt_term::scr_soft_reset ()
+{
+  /* only affects modes, nothing drastic such as clearing the screen */
+#if ENABLE_OVERLAY
+  scr_overlay_off ();
+#endif
+
+  if (current_screen != PRIMARY)
+    scr_swap_screen ();
+
+  scr_scroll_region (0, MAX_ROWS - 1);
+  scr_rendition (0, ~RS_None);
+  scr_insert_mode (0);
+}
+
 /* ------------------------------------------------------------------------- *
  *                         PROCESS SCREEN COMMANDS                           *
  * ------------------------------------------------------------------------- */
@@ -501,10 +517,8 @@
   /* boundary check in case screen size changed between SAVE and RESTORE */
   min_it (s->cur.row, nrow - 1);
   min_it (s->cur.col, ncol - 1);
-#ifdef DEBUG_STRICT
   assert (s->cur.row >= 0);
   assert (s->cur.col >= 0);
-#endif
 }
 
 void
@@ -539,7 +553,7 @@
 
   selection_check (2);        /* check for boundary cross */
 
-  int i = current_screen; current_screen = scrn; scrn = i;
+  current_screen = scrn;
 
 #if NSCREENS
   if (option (Opt_secondaryScreen))
@@ -626,24 +640,38 @@
       && row1 == 0
       && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
     {
-      top_row = max (top_row - count, -saveLines);
+      min_it (count, total_rows - (nrow - (row2 + 1)));
 
-      // scroll everything up 'count' lines
-      term_start = (term_start + count) % total_rows;
+      top_row = max (top_row - count, -saveLines);
 
       // sever bottommost line
       {
-        line_t &l = ROW(row2 - count);
+        line_t &l = ROW(row2);
         l.is_longer (0);
         l.touch ();
       }
 
+      // scroll everything up 'count' lines
+      term_start = (term_start + count) % total_rows;
+
+      // now copy lines below the scroll region bottom to the
+      // bottom of the screen again, so they look as if they
+      // hadn't moved.
+      for (int i = nrow; --i > row2; )
+        {
+          line_t &l1 = ROW(i - count);
+          line_t &l2 = ROW(i);
+
+          ::swap (l1, l2);
+          l2.touch ();
+        }
+
       // erase newly scrolled-in lines
       for (int i = count; i--; )
         {
-          line_t &l = ROW(nrow - 1 - i);
+          line_t &l = ROW(row2 - i);
 
-          // optimize if already cleared, can be significant on slow machines
+          // optimise if already cleared, can be significant on slow machines
           // could be rolled into scr_blank_screen_mem
           if (l.r && l.l < ncol - 1 && !((l.r[l.l + 1] ^ rstyle) & (RS_fgMask | RS_bgMask)))
             {
@@ -655,32 +683,15 @@
             scr_blank_screen_mem (l, rstyle);
         }
 
-      // now copy lines below the scroll region bottom to the
-      // bottom of the screen again, so they look as if they
-      // hadn't moved.
-      for (int i = nrow; --i > row2; )
-        {
-          line_t &l1 = ROW(i - count);
-          line_t &l2 = ROW(i);
-
-          ::swap (l1, l2);
-          l2.touch ();
-        }
-
       // move and/or clear selection, if any
-      if (selection.op && current_screen == selection.screen)
+      if (selection.op && current_screen == selection.screen
+          && selection.beg.row <= row2)
         {
           selection.beg.row  -= count;
           selection.end.row  -= count;
           selection.mark.row -= count;
 
-          if (selection.beg.row < top_row
-              || selection.end.row < top_row
-              || selection.mark.row < top_row)
-            {
-              CLEAR_ALL_SELECTION ();
-              selection.op = SELECTION_CLEAR;
-            }
+          selection_check (0);
         }
 
       // finally move the view window, if desired
@@ -720,11 +731,19 @@
       // use a simple and robust scrolling algorithm, this
       // part of scr_scroll_text is not time-critical.
 
+      // sever line above scroll region
+      if (row1)
+        {
+          line_t &l = ROW(row1 - 1);
+          l.is_longer (0);
+          l.touch ();
+        }
+
       int rows = row2 - row1 + 1;
 
       min_it (count, rows);
 
-      line_t *temp_buf = row_buf + total_rows;
+      line_t *temp_buf = rxvt_temp_buf<line_t> (rows);
 
       for (int row = 0; row < rows; row++)
         {
@@ -736,6 +755,13 @@
 
       for (int row = 0; row < rows; row++)
         ROW(row1 + row) = temp_buf [row];
+
+      // sever bottommost line
+      {
+        line_t &l = ROW(row2);
+        l.is_longer (0);
+        l.touch ();
+      }
     }
 
   return count;
@@ -751,7 +777,7 @@
   if (len <= 0)               /* sanity */
     return;
 
-  unsigned char checksel;
+  bool checksel;
   unicode_t c;
   int ncol = this->ncol;
   const wchar_t *strend = str + len;
@@ -774,11 +800,9 @@
         }
     }
 
-#ifdef DEBUG_STRICT
   assert (screen.cur.col < ncol);
   assert (screen.cur.row < nrow
           && screen.cur.row >= top_row);
-#endif
   int row = screen.cur.row;
 
   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
@@ -789,7 +813,7 @@
     {
       c = (unicode_t)*str++; // convert to rxvt-unicodes representation
 
-      if (c < 0x20)
+      if (ecb_unlikely (c < 0x20))
         if (c == C0_LF)
           {
             max_it (line->l, screen.cur.col);
@@ -818,9 +842,11 @@
             continue;
           }
 
-      if (checksel            /* see if we're writing within selection */
-          && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
-          && ROWCOL_IS_BEFORE (screen.cur, selection.end))
+      if (ecb_unlikely (
+            checksel            /* see if we're writing within selection */
+            && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
+            && ROWCOL_IS_BEFORE (screen.cur, selection.end)
+         ))
         {
           checksel = 0;
           /*
@@ -831,7 +857,7 @@
           CLEAR_SELECTION ();
         }
 
-      if (screen.flags & Screen_WrapNext)
+      if (ecb_unlikely (screen.flags & Screen_WrapNext))
         {
           scr_do_wrap ();
 
@@ -843,7 +869,7 @@
         }
 
       // some utf-8 decoders "decode" surrogate characters: let's fix this.
-      if (IN_RANGE_INC (c, 0xd800, 0xdfff))
+      if (ecb_unlikely (IN_RANGE_INC (c, 0xd800, 0xdfff)))
         c = 0xfffd;
 
       // rely on wcwidth to tell us the character width, do wcwidth before
@@ -852,7 +878,7 @@
       // locale.
       int width = WCWIDTH (c);
 
-      if (charsets [screen.charset] == '0') // DEC SPECIAL
+      if (ecb_unlikely (charsets [screen.charset] == '0')) // DEC SPECIAL
         {
           // vt100 special graphics and line drawing
           // 5f-7e standard vt100
@@ -875,7 +901,7 @@
             }
         }
 
-      if (screen.flags & Screen_Insert)
+      if (ecb_unlikely (screen.flags & Screen_Insert))
         scr_insdel_chars (width, INSERT);
 
       if (width != 0)
@@ -890,38 +916,29 @@
 # endif
 #endif
 
-          // nuke the character at this position, if required
-          if (line->t[screen.cur.col] == NOCHAR
-              || (screen.cur.col < ncol - 1
-                  && line->t[screen.cur.col + 1] == NOCHAR))
-            {
-              int col = screen.cur.col;
-
-              // find begin
-              while (col > 0 && line->t[col] == NOCHAR)
-                col--;
-
-              rend_t rend = SET_FONT (line->r[col], FONTSET (line->r[col])->find_font (' '));
-
-              // found begin, nuke
-              do {
-                line->t[col] = ' ';
-                line->r[col] = rend;
-                col++;
-              } while (col < ncol && line->t[col] == NOCHAR);
-            }
-
           rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
 
           // if the character doesn't fit into the remaining columns...
-          if (screen.cur.col > ncol - width && ncol >= width)
+          if (ecb_unlikely (screen.cur.col > ncol - width && ncol >= width))
             {
-              // ...output spaces
-              c = ' ';
-              // and try the same character next loop iteration
-              --str;
+              if (screen.flags & Screen_Autowrap)
+                {
+                  // ... artificially enlargen the previous one
+                  c = NOCHAR;
+                  // and try the same character next loop iteration
+                  --str;
+                }
+              else
+                screen.cur.col = ncol - width;
             }
 
+          // nuke the character at this position, if required
+          // due to wonderful coincidences everywhere else in this loop
+          // we never have to check for overwriting a wide char itself,
+          // only its tail.
+          if (ecb_unlikely (line->t[screen.cur.col] == NOCHAR))
+            scr_kill_char (*line, screen.cur.col);
+
           line->touch ();
 
           do
@@ -929,80 +946,80 @@
               line->t[screen.cur.col] = c;
               line->r[screen.cur.col] = rend;
 
-              if (screen.cur.col < ncol - 1)
+              if (ecb_likely (screen.cur.col < ncol - 1))
                 screen.cur.col++;
               else
                 {
                   line->l = ncol;
                   if (screen.flags & Screen_Autowrap)
                     screen.flags |= Screen_WrapNext;
-                  break;
+
+                  goto end_of_line;
                 }
 
               c = NOCHAR;
             }
-          while (--width > 0);
+          while (ecb_unlikely (--width > 0));
 
           // pad with spaces when overwriting wide character with smaller one
-          if (!width)
+          for (int c = screen.cur.col; ecb_unlikely (c < ncol && line->t[c] == NOCHAR); c++)
             {
-              line->touch ();
-
-              for (int c = screen.cur.col; c < ncol && line->t[c] == NOCHAR; c++)
-                {
-                  line->t[c] = ' ';
-                  line->r[c] = rend;
-                }
+              line->t[c] = ' ';
+              line->r[c] = rend;
             }
+
+end_of_line:
+          ;
         }
+#if ENABLE_COMBINING
       else // width == 0
         {
-#if ENABLE_COMBINING
-          // handle combining characters
-          // we just tag the accent on the previous on-screen character.
-          // this is arguably not correct, but also arguably not wrong.
-          // we don't handle double-width characters nicely yet.
-          line_t *linep;
-          text_t *tp;
-          rend_t *rp;
-
-          if (screen.cur.col > 0)
-            {
-              linep = line;
-              tp = line->t + screen.cur.col - 1;
-              rp = line->r + screen.cur.col - 1;
-            }
-          else if (screen.cur.row > 0
-                   && ROW(screen.cur.row - 1).is_longer ())
-            {
-              linep = &ROW(screen.cur.row - 1);
-              tp = line->t + ncol - 1;
-              rp = line->r + ncol - 1;
-            }
-          else
-            continue;
+          if (c != 0xfeff) // ignore BOM
+            {
+              // handle combining characters
+              // we just tag the accent on the previous on-screen character.
+              // this is arguably not correct, but also arguably not wrong.
+              // we don't handle double-width characters nicely yet.
+              line_t *linep;
+              text_t *tp;
+              rend_t *rp;
 
-          linep->touch ();
+              if (screen.cur.col > 0)
+                {
+                  linep = line;
+                  tp = line->t + screen.cur.col - 1;
+                  rp = line->r + screen.cur.col - 1;
+                }
+              else if (screen.cur.row > 0
+                       && ROW(screen.cur.row - 1).is_longer ())
+                {
+                  linep = &ROW(screen.cur.row - 1);
+                  tp = line->t + ncol - 1;
+                  rp = line->r + ncol - 1;
+                }
+              else
+                continue;
 
-          while (*tp == NOCHAR && tp > linep->t)
-            tp--, rp--;
+              linep->touch ();
 
-          // first try to find a precomposed character
-          unicode_t n = rxvt_compose (*tp, c);
-          if (n == NOCHAR)
-            n = rxvt_composite.compose (*tp, c);
+              while (*tp == NOCHAR && tp > linep->t)
+                tp--, rp--;
 
-          *tp = n;
-          *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
-#endif
+              // first try to find a precomposed character
+              unicode_t n = rxvt_compose (*tp, c);
+              if (n == NOCHAR)
+                n = rxvt_composite.compose (*tp, c);
+
+              *tp = n;
+              *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
+            }
         }
+#endif
     }
 
   max_it (line->l, screen.cur.col);
 
-#ifdef DEBUG_STRICT
   assert (screen.cur.row >= 0);
-#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1013,23 +1030,22 @@
 void
 rxvt_term::scr_backspace () NOTHROW
 {
-  want_refresh = 1;
-
   if (screen.cur.col == 0)
     {
       if (screen.cur.row > 0)
         {
 #ifdef TERMCAP_HAS_BW
           screen.cur.col = ncol - 1;
-          screen.cur.row--;
-          return;
+          --screen.cur.row;
+
+          want_refresh = 1;
 #endif
         }
     }
-  else if (!(screen.flags & Screen_WrapNext))
+  else if (screen.flags & Screen_WrapNext)
+    screen.flags &= ~Screen_WrapNext;
+  else
     scr_gotorc (0, -1, RELATIVE);
-
-  screen.flags &= ~Screen_WrapNext;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1232,6 +1248,7 @@
  * XTERM_SEQ: Clear line to right: ESC [ 0 K
  * XTERM_SEQ: Clear line to left : ESC [ 1 K
  * XTERM_SEQ: Clear whole line   : ESC [ 2 K
+ * extension: clear to right unless wrapped: ESC [ 3 K
  */
 void
 rxvt_term::scr_erase_line (int mode) NOTHROW
@@ -1250,21 +1267,31 @@
 
   switch (mode)
     {
+      case 3:
+        if (screen.flags & Screen_WrapNext)
+          return;
+
+        /* fall through */
+
       case 0:                     /* erase to end of line */
         col = screen.cur.col;
         num = ncol - 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 ();
         break;
+
       case 1:                     /* erase to beginning of line */
         col = 0;
         num = screen.cur.col + 1;
+
         if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
             || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
           CLEAR_SELECTION ();
         break;
+
       case 2:                     /* erase whole line */
         col = 0;
         num = ncol;
@@ -1301,19 +1328,16 @@
   switch (mode)
     {
       case 0:                     /* erase to end of screen */
-        selection_check (1);
         scr_erase_line (0);
         row = screen.cur.row + 1;    /* possible OOB */
         num = nrow - row;
         break;
       case 1:                     /* erase to beginning of screen */
-        selection_check (3);
         scr_erase_line (1);
         row = 0;
         num = screen.cur.row;
         break;
       case 2:                     /* erase whole screen */
-        selection_check (3);
         row = 0;
         num = nrow;
         break;
@@ -1332,27 +1356,40 @@
 
   min_it (num, nrow - row);
 
-  if (rstyle & (RS_RVid | RS_Uline))
+  if (rstyle & (RS_Blink | RS_RVid | RS_Uline))
     ren = (rend_t) ~RS_None;
   else if (GET_BASEBG (rstyle) == Color_bg)
     {
       ren = DEFAULT_RSTYLE;
-      CLEAR_ROWS (row, num);
+
+      if (mapped)
+        XClearArea (dpy, vt, 0,
+                    Row2Pixel (row - view_start), (unsigned int)width,
+                    (unsigned int)Height2Pixel (num), False);
     }
   else
     {
       ren = rstyle & (RS_fgMask | RS_bgMask);
-      gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
-      XChangeGC (dpy, gc, GCForeground, &gcvalue);
-      ERASE_ROWS (row, num);
-      gcvalue.foreground = pix_colors[Color_fg];
-      XChangeGC (dpy, gc, GCForeground, &gcvalue);
+
+      if (mapped)
+        {
+          gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
+          XChangeGC (dpy, gc, GCForeground, &gcvalue);
+          XFillRectangle (dpy, vt, gc,
+                          0, Row2Pixel (row - view_start),
+                          (unsigned int)width,
+                          (unsigned int)Height2Pixel (num));
+          gcvalue.foreground = pix_colors[Color_fg];
+          XChangeGC (dpy, gc, GCForeground, &gcvalue);
+        }
     }
 
   for (; num--; row++)
     {
       scr_blank_screen_mem (ROW(row), rstyle);
-      scr_blank_line (drawn_buf [row], 0, ncol, ren);
+
+      if (row - view_start < nrow)
+        scr_blank_line (drawn_buf [row - view_start], 0, ncol, ren);
     }
 }
 
@@ -1436,9 +1473,6 @@
 void
 rxvt_term::scr_insdel_chars (int count, int insdel) NOTHROW
 {
-  int col, row;
-  rend_t tr;
-
   want_refresh = 1;
   ZERO_SCROLLBACK ();
 
@@ -1450,24 +1484,31 @@
   selection_check (1);
   min_it (count, ncol - screen.cur.col);
 
-  row = screen.cur.row;
+  int row = screen.cur.row;
 
   line_t *line = &ROW(row);
 
   line->touch ();
   line->is_longer (0);
 
+  // nuke wide spanning the start
+  if (line->t[screen.cur.col] == NOCHAR)
+    scr_kill_char (*line, screen.cur.col);
+
   switch (insdel)
     {
       case INSERT:
-        for (col = ncol - 1; (col - count) >= screen.cur.col; col--)
+        line->l = min (line->l + count, ncol);
+
+        if (line->t[screen.cur.col] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col);
+
+        for (int col = ncol - 1; (col - count) >= screen.cur.col; col--)
           {
             line->t[col] = line->t[col - count];
             line->r[col] = line->r[col - count];
           }
 
-        line->l = min (line->l + count, ncol);
-
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
@@ -1491,21 +1532,27 @@
         selection_check (1);
         screen.cur.col -= count;
 
-        line->l = max (line->l - count, 0);
+        // nuke wide char after the end
+        if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col + count);
+
         scr_blank_line (*line, screen.cur.col, count, rstyle);
         break;
 
       case DELETE:
-        tr = line->r[ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
+        line->l = max (line->l - count, 0);
 
-        for (col = screen.cur.col; (col + count) < ncol; col++)
+        // nuke wide char spanning the end
+        if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col + count);
+
+        for (int col = screen.cur.col; (col + count) < ncol; col++)
           {
             line->t[col] = line->t[col + count];
             line->r[col] = line->r[col + count];
           }
 
-        line->l = max (line->l - count, 0);
-        scr_blank_line (*line, ncol - count, count, tr);
+        scr_blank_line (*line, ncol - count, count, rstyle);
 
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
@@ -1651,7 +1698,7 @@
 
       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
 #ifdef HAVE_BG_PIXMAP
-      if (bgPixmap.pixmap == None)
+      if (bg_pixmap == None)
 #endif
           XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
 
@@ -1805,7 +1852,7 @@
       min_it (rc[i].col, ncol - 1);
       min_it (rc[i].row, nrow - 1);
     }
-// TODO: this line somehow causes segfault if scr_expose() is called just after resize
+
   for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
     fill_text (&drawn_buf[i].t[rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
 
@@ -1874,6 +1921,7 @@
 {
   rvideo_bell = false;
   scr_rvideo_mode (rvideo_mode);
+  refresh_check ();
 }
 #endif
 
@@ -1887,18 +1935,12 @@
 #  ifdef MAPALERT_OPTION
   if (option (Opt_mapAlert))
 #  endif
-    XMapWindow (dpy, parent[0]);
+    XMapWindow (dpy, parent);
 # endif
 
 # if ENABLE_FRILLS
   if (option (Opt_urgentOnBell))
-    {
-      if (XWMHints *h = XGetWMHints(dpy, parent[0]))
-        {
-          h->flags |= XUrgencyHint;
-          XSetWMHints (dpy, parent[0], h);
-        }
-    }
+    set_urgency (1);
 # endif
 
   if (option (Opt_visualBell))
@@ -1911,19 +1953,19 @@
     }
   else
     XBell (dpy, 0);
+  HOOK_INVOKE ((this, HOOK_BELL, DT_END));
 #endif
 }
 
 /* ------------------------------------------------------------------------- */
-/* ARGSUSED */
 void
 rxvt_term::scr_printscreen (int fullhist) NOTHROW
 {
 #ifdef PRINTPIPE
   int nrows, row_start;
-  FILE *fd;
+  FILE *fd = popen_printer ();
 
-  if ((fd = popen_printer ()) == NULL)
+  if (!fd)
     return;
 
   if (fullhist)
@@ -1939,7 +1981,7 @@
 
   wctomb (0, 0);
 
-  for (int r1 = 0; r1 < nrows; r1++)
+  for (int r1 = row_start; r1 < row_start + nrows; r1++)
     {
       text_t *tp = ROW(r1).t;
       int len    = ROW(r1).l;
@@ -1978,8 +2020,6 @@
 void
 rxvt_term::scr_refresh () NOTHROW
 {
-  unsigned char have_bg,
-                showcursor; /* show the cursor                           */
   int16_t col, row,   /* column/row we're processing               */
           ocrow;      /* old cursor row                            */
   int i;              /* tmp                                       */
@@ -1998,11 +2038,12 @@
   /*
    * A: set up vars
    */
-  have_bg = 0;
   refresh_count = 0;
 
+  unsigned int old_screen_flags = screen.flags;
+  bool have_bg = 0;
 #ifdef HAVE_BG_PIXMAP
-  have_bg |= bgPixmap.pixmap != None;
+  have_bg = bg_pixmap != None;
 #endif
   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
 
@@ -2011,13 +2052,19 @@
    */
   scr_reverse_selection ();
 
+  HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
+#if ENABLE_OVERLAY
+  scr_swap_overlay ();
+#endif
+
+  bool showcursor = screen.flags & Screen_VisibleCursor;
+
   /*
    * C: set the cursor character (s)
    */
   {
-    unsigned char setoldcursor;
+    bool setoldcursor;
 
-    showcursor = (screen.flags & Screen_VisibleCursor);
 #ifdef CURSOR_BLINK
     if (hidden_cursor)
       showcursor = 0;
@@ -2055,7 +2102,7 @@
           ccol2 = Color_bg;
 #endif
 
-        if (showcursor && focus)
+        if (focus)
           {
             if (option (Opt_cursorUnderline))
               *crp ^= RS_Uline;
@@ -2100,11 +2147,6 @@
       }
   }
 
-  HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
-#if ENABLE_OVERLAY
-  scr_swap_overlay ();
-#endif
-
 #ifndef NO_SLOW_LINK_SUPPORT
   /*
    * D: CopyArea pass - very useful for slower links
@@ -2203,10 +2245,10 @@
           // redraw one or more characters
 
           // seek to the beginning of wide characters
-          while (stp[col] == NOCHAR && col > 0)
+          while (ecb_unlikely (stp[col] == NOCHAR && col > 0))
             --col;
 
-          rend_t rend = srp[col];     /* screen rendition (target rendtion) */
+          rend_t rend = srp[col];     /* screen rendition (target rendition) */
           text_t *text = stp + col;
           int count = 1;
 
@@ -2220,7 +2262,8 @@
               if (stp[col] == NOCHAR)
                 {
                   dtp[col] = stp[col];
-                  drp[col] = rend;
+                  drp[col] = srp[col];
+
                   count++;
                   i++;
 
@@ -2250,7 +2293,7 @@
           count -= i; /* dump any matching trailing chars */
 
           // sometimes we optimize away the trailing NOCHAR's, add them back
-          while (i && text[count] == NOCHAR)
+          while (ecb_unlikely (i && text[count] == NOCHAR))
             count++, i--;
 
           /*
@@ -2260,7 +2303,7 @@
           int back = bgcolor_of (rend); // desired background
 
           // only do special processing if any attributes are set, which is unlikely
-          if (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful))
+          if (ecb_unlikely (rend & (RS_baseattrMask | RS_Careful | RS_Sel)))
             {
               bool invert = rend & RS_RVid;
 
@@ -2289,25 +2332,31 @@
                 fore = Color_UL;
 #endif
 
-              if (invert)
-                {
 #ifdef OPTION_HC
-                  if ((showcursor && row == screen.cur.row && text - stp == screen.cur.col)
-                      || !ISSET_PIXCOLOR (Color_HC))
+              if (rend & RS_Sel)
+                {
+                  /* invert the column if no highlightColor is set or it is the
+                   * current cursor column */
+                  if (!(showcursor && row == screen.cur.row && text - stp == screen.cur.col)
+                      && ISSET_PIXCOLOR (Color_HC))
+                    {
+                      if (ISSET_PIXCOLOR (Color_HTC))
+                        fore = Color_HTC;
+                      // if invert is 0 reverse video is set so we use bg color as fg color
+                      else if (!invert)
+                        fore = back;
+
+                      back = Color_HC;
+                      invert = 0;
+                    }
+                }
 #endif
-                    /* invert the column if no highlightColor is set or it is the
-                     * current cursor column */
+
+              if (invert)
+                {
                     ::swap (fore, back);
-#ifdef OPTION_HC
-                  else if (ISSET_PIXCOLOR (Color_HC))
-                    back = Color_HC;
-#endif
 
 #ifndef NO_BOLD_UNDERLINE_REVERSE
-# ifndef OPTION_HC
-                  if (ISSET_PIXCOLOR (Color_RV))
-                    back = Color_RV;
-# endif
                   if (fore == back)
                     {
                       fore = Color_bg;
@@ -2353,7 +2402,7 @@
            */
           rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
 
-          if (have_bg && back == Color_bg)
+          if (ecb_likely (have_bg && back == Color_bg))
             {
               // this is very ugly, maybe push it into ->draw?
 
@@ -2370,7 +2419,7 @@
           else
             font->draw (*drawable, xpixel, ypixel, text, count, fore, back);
 
-          if (rend & RS_Uline && font->descent > 1 && fore != back)
+          if (ecb_unlikely (rend & RS_Uline && font->descent > 1 && fore != back))
             {
 #if ENABLE_FRILLS
               if (ISSET_PIXCOLOR (Color_underline))
@@ -2379,18 +2428,13 @@
 #endif
                 XSetForeground (dpy, gc, pix_colors[fore]);
 
-              XDrawLine (dpy, drawBuffer, gc,
+              XDrawLine (dpy, vt, gc,
                          xpixel, ypixel + font->ascent + 1,
                          xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
             }
         }                     /* for (col....) */
     }                         /* for (row....) */
 
-#if ENABLE_OVERLAY
-  scr_swap_overlay ();
-#endif
-  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
-
   /*
    * G: cleanup cursor and display outline cursor if necessary
    */
@@ -2427,7 +2471,7 @@
 #endif
             XSetForeground (dpy, gc, pix_colors[ccol1]);
 
-          XDrawRectangle (dpy, drawBuffer, gc,
+          XDrawRectangle (dpy, vt, gc,
                           Col2Pixel (col),
                           Row2Pixel (oldcursor.row),
                           (unsigned int) (Width2Pixel (cursorwidth) - 1),
@@ -2438,8 +2482,14 @@
   /*
    * H: cleanup selection
    */
+#if ENABLE_OVERLAY
+  scr_swap_overlay ();
+#endif
+  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
+
   scr_reverse_selection ();
 
+  screen.flags = old_screen_flags;
   num_scr = 0;
   num_scr_allow = 1;
 }
@@ -2470,30 +2520,53 @@
 }
 
 void
-rxvt_term::scr_recolour () NOTHROW
+rxvt_term::scr_recolour (bool refresh) NOTHROW
 {
+  bool transparent = false;
+
 #ifdef HAVE_BG_PIXMAP
-  bgPixmap.apply ();
-#else
+  if (bg_pixmap != None)
+    {
+# ifdef ENABLE_TRANSPARENCY
+      if (bg_flags & BG_IS_TRANSPARENT)
+        {
+          XSetWindowBackgroundPixmap (dpy, parent, bg_pixmap);
+          XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
 
-  XSetWindowBackground (dpy, parent[0], pix_colors[Color_border]);
-  XClearWindow (dpy, parent[0]);
-  XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
+          transparent = true;
+        }
+      else
+# endif
+        {
+          XSetWindowBackground (dpy, parent, pix_colors[Color_border]);
+          XSetWindowBackgroundPixmap (dpy, vt, bg_pixmap);
+        }
+    }
+  else
+#endif
+    {
+      XSetWindowBackground (dpy, parent, pix_colors[Color_border]);
+      XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
+    }
+
+  XClearWindow (dpy, parent);
 
-# if HAVE_SCROLLBARS
   if (scrollBar.win)
-   {
-     XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
-     scrollBar.setIdle ();
-     scrollbar_show (0);
-   }
-# endif
+    {
+      if (transparent)
+        XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
+      else
+        XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
+      scrollBar.state = SB_STATE_IDLE;
+      scrollBar.show (0);
+    }
 
-  scr_clear ();
-  scr_touch (true);
+  if (refresh)
+    {
+      scr_clear ();
+      scr_touch (true);
+    }
   want_refresh = 1;
-
-#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2570,12 +2643,12 @@
       if (selection.rect)
         scr_xor_rect (selection.beg.row, selection.beg.col,
                       selection.end.row, selection.end.col,
-                      RS_RVid, RS_RVid | RS_Uline);
+                      RS_Sel | RS_RVid, RS_Sel | RS_RVid | RS_Uline);
       else
 #endif
         scr_xor_span (selection.beg.row, selection.beg.col,
                       selection.end.row, selection.end.col,
-                      RS_RVid);
+                      RS_Sel | RS_RVid);
     }
 }
 
@@ -2590,9 +2663,9 @@
 {
   int             row, wrote;
   unsigned int    width, towrite;
-  char            r1[] = "\n";
+  const char      r1[] = "\n";
 
-  for (row = saveLines - nsaved;
+  for (row = saveLines + top_row;
        row < saveLines + nrow - 1; row++)
     {
       width = row_buf[row].l >= 0 ? row_buf[row].l
@@ -2617,12 +2690,12 @@
 void
 rxvt_term::selection_check (int check_more) NOTHROW
 {
-  row_col_t pos;
-
   if (!selection.op)
     return;
 
+  row_col_t pos;
   pos.row = pos.col = 0;
+
   if (!IN_RANGE_EXC (selection.beg.row, top_row, nrow)
       || !IN_RANGE_EXC (selection.mark.row, top_row, nrow)
       || !IN_RANGE_EXC (selection.end.row, top_row, nrow)
@@ -2634,11 +2707,8 @@
           && ROWCOL_IS_BEFORE (selection.beg, pos)
           && ROWCOL_IS_AFTER (selection.end, pos))
       || (check_more == 3
-          && ROWCOL_IS_AFTER (selection.end, pos))
-      || (check_more == 4     /* screen width change */
-          && (selection.beg.row != selection.end.row
-              || selection.end.col > ncol)))
-    CLEAR_SELECTION ();
+          && ROWCOL_IS_AFTER (selection.end, pos)))
+    CLEAR_ALL_SELECTION ();
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2646,266 +2716,46 @@
  * Paste a selection direct to the command fd
  */
 void
-rxvt_term::paste (char *data, unsigned int len) NOTHROW
+rxvt_term::tt_paste (char *data, unsigned int len) NOTHROW
 {
   /* convert normal newline chars into common keyboard Return key sequence */
   for (unsigned int i = 0; i < len; i++)
     if (data[i] == C0_LF)
       data[i] = C0_CR;
 
-  tt_write (data, len);
-}
-
-/* ------------------------------------------------------------------------- */
-/*
- * Respond to a notification that a primary selection has been sent
- * EXT: SelectionNotify
- */
-void
-rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop) NOTHROW
-{
-  if (prop == None)         /* check for failed XConvertSelection */
-    {
-      if ((selection_type & Sel_CompoundText))
-        {
-          int selnum = selection_type & Sel_whereMask;
-
-          selection_type = 0;
-          if (selnum != Sel_direct)
-            selection_request_other (XA_STRING, selnum);
-        }
-
-      if ((selection_type & Sel_UTF8String))
-        {
-          int selnum = selection_type & Sel_whereMask;
-
-          selection_type = Sel_CompoundText;
-          if (selnum != Sel_direct)
-            selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
-          else
-            selection_type = 0;
-        }
-
-      return;
-    }
-
-  unsigned long bytes_after;
-  XTextProperty ct;
-
-  if (XGetWindowProperty (dpy, win, prop,
-                          0, PROP_SIZE / 4,
-                          delete_prop, AnyPropertyType,
-                          &ct.encoding, &ct.format,
-                          &ct.nitems, &bytes_after,
-                          &ct.value) != Success)
-    {
-      ct.value = 0;
-      goto bailout;
-    }
-
-  if (ct.encoding == None)
-    goto bailout;
-
-  if (bytes_after)
-    {
-      // fetch and append remaining data
-      XTextProperty ct2;
-
-      if (XGetWindowProperty (dpy, win, prop,
-                              ct.nitems / 4, (bytes_after + 3) / 4,
-                              delete_prop, AnyPropertyType,
-                              &ct2.encoding, &ct2.format,
-                              &ct2.nitems, &bytes_after,
-                              &ct2.value) != Success)
-        goto bailout;
-
-      // realloc should be compatible to XFree, here, and elsewhere, too
-      ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
-      memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
-      ct.nitems += ct2.nitems;
-
-      XFree (ct2.value);
-    }
-
-  if (ct.value == 0)
-    goto bailout;
-
-  if (ct.encoding == xa[XA_INCR])
-    {
-      // INCR selection, start handshake
-      if (!delete_prop)
-        XDeleteProperty (dpy, win, prop);
-
-      selection_wait = Sel_incr;
-      incr_buf_fill = 0;
-      incr_ev.start (10);
-
-      goto bailout;
-    }
-
-  if (ct.nitems == 0)
-    {
-      if (selection_wait == Sel_incr)
-        {
-          XFree (ct.value);
-
-          // finally complete, now paste the whole thing
-          selection_wait = Sel_normal;
-          ct.value = (unsigned char *)incr_buf;
-          ct.nitems = incr_buf_fill;
-          incr_buf = 0;
-          incr_buf_size = 0;
-          incr_ev.stop ();
-        }
-      else
-        {
-          if (selection_wait == Sel_normal
-              && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
-            {
-              /*
-               * pass through again trying CUT_BUFFER0 if we've come from
-               * XConvertSelection () but nothing was presented
-               */
-              selection_paste (display->root, XA_CUT_BUFFER0, False);
-            }
+  if (priv_modes & PrivMode_BracketPaste)
+    tt_printf ("\e[200~");
 
-          goto bailout;
-        }
-    }
-  else if (selection_wait == Sel_incr)
-    {
-      incr_ev.start (10);
-
-      while (incr_buf_fill + ct.nitems > incr_buf_size)
-        {
-          incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
-          incr_buf = (char *)realloc (incr_buf, incr_buf_size);
-        }
-
-      memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
-      incr_buf_fill += ct.nitems;
-
-      goto bailout;
-    }
-
-  char **cl;
-  int cr;
-
-#if !ENABLE_MINIMAL
-  // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
-  // so recode it manually
-  if (ct.encoding == xa[XA_UTF8_STRING])
-    {
-      wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
-      char *s = rxvt_wcstombs (w);
-      free (w);
-      // TODO: strlen == only the first element will be converted. well...
-      paste (s, strlen (s));
-      free (s);
-    }
-  else
-#endif
-  if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
-      && cl)
-    {
-      for (int i = 0; i < cr; i++)
-        paste (cl[i], strlen (cl[i]));
-
-      XFreeStringList (cl);
-    }
-  else
-    paste ((char *)ct.value, ct.nitems); // paste raw
-
-bailout:
-  XFree (ct.value);
-
-  if (selection_wait == Sel_normal)
-    selection_wait = Sel_none;
-}
-
-void
-rxvt_term::incr_cb (ev::timer &w, int revents) NOTHROW
-{
-  selection_wait = Sel_none;
-
-  incr_buf_size = 0;
-  free (incr_buf);
+  tt_write (data, len);
 
-  rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
+  if (priv_modes & PrivMode_BracketPaste)
+    tt_printf ("\e[201~");
 }
 
 void
-rxvt_term::selection_property (Window win, Atom prop) NOTHROW
+rxvt_term::paste (char *data, unsigned int len) NOTHROW
 {
-  if (prop == None || selection_wait != Sel_incr)
+  if (HOOK_INVOKE ((this, HOOK_TT_PASTE, DT_STR_LEN, data, len, DT_END)))
     return;
 
-  selection_paste (win, prop, true);
+  tt_paste (data, len);
 }
 
 /* ------------------------------------------------------------------------- */
 /*
- * Request the current selection:
- * Order: > internal selection if available
- *        > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
- *        > CUT_BUFFER0
- * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
- *     will auto fallback to CUT_BUFFER0
+ * Request PRIMARY, SECONDARY or CLIPBOARD selection.
+ * if the requested selection has no owner or is empty CUT_BUFFER0 is used
+ * as fallback
  * EXT: button 2 release
  */
 void
 rxvt_term::selection_request (Time tm, int selnum) NOTHROW
 {
-  if (selection.text && selnum == Sel_Primary)
+  if (!selection_req)
     {
-      /* internal selection */
-      char *str = rxvt_wcstombs (selection.text, selection.len);
-      paste (str, strlen (str));
-      free (str);
-      return;
+      selection_req = new rxvt_selection (display, selnum, tm, vt, xa[XA_VT_SELECTION], this);
+      selection_req->run ();
     }
-  else
-    {
-      selection_request_time = tm;
-      selection_wait = Sel_normal;
-
-#if X_HAVE_UTF8_STRING
-      selection_type = Sel_UTF8String;
-      if (selection_request_other (xa[XA_UTF8_STRING], selnum))
-	return;
-#else
-      selection_type = Sel_CompoundText;
-      if (selection_request_other (xa[XA_COMPOUND_TEXT], selnum))
-	return;
-#endif
-    }
-
-  selection_wait = Sel_none;       /* don't loop in selection_paste () */
-  selection_paste (display->root, XA_CUT_BUFFER0, false);
-}
-
-int
-rxvt_term::selection_request_other (Atom target, int selnum) NOTHROW
-{
-  Atom sel;
-
-  selection_type |= selnum;
-
-  if (selnum == Sel_Primary)
-    sel = XA_PRIMARY;
-  else if (selnum == Sel_Secondary)
-    sel = XA_SECONDARY;
-  else
-    sel = xa[XA_CLIPBOARD];
-
-  if (XGetSelectionOwner (dpy, sel) != None)
-    {
-      XConvertSelection (dpy, sel, target, xa[XA_VT_SELECTION],
-                         vt, selection_request_time);
-      return 1;
-    }
-
-  return 0;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2914,16 +2764,28 @@
  * EXT: SelectionClear
  */
 void
-rxvt_term::selection_clear () NOTHROW
+rxvt_term::selection_clear (bool clipboard) NOTHROW
 {
-  want_refresh = 1;
-  free (selection.text);
-  selection.text = NULL;
-  selection.len = 0;
-  CLEAR_SELECTION ();
+  if (!clipboard)
+    {
+      want_refresh = 1;
+      free (selection.text);
+      selection.text = NULL;
+      selection.len = 0;
+      CLEAR_SELECTION ();
+
+      if (display->selection_owner == this)
+        display->selection_owner = 0;
+    }
+  else
+    {
+      free (selection.clip_text);
+      selection.clip_text = NULL;
+      selection.clip_len = 0;
 
-  if (display->selection_owner == this)
-    display->selection_owner = 0;
+      if (display->clipboard_owner == this)
+        display->clipboard_owner = 0;
+    }
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2934,7 +2796,7 @@
 void
 rxvt_term::selection_make (Time tm)
 {
-  int i;
+  int size;
   wchar_t *new_selection_text;
   text_t *t;
 
@@ -2960,8 +2822,8 @@
   if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
     return;
 
-  i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
-  new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
+  size = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
+  new_selection_text = (wchar_t *)rxvt_malloc ((size + 4) * sizeof (wchar_t));
 
   int ofs = 0;
   int extra = 0;
@@ -2977,7 +2839,7 @@
       if (selection.rect)
         {
           col = selection.beg.col;
-          end_col = ncol + 1;
+          end_col = selection.end.col;
         }
       else
 #endif
@@ -2985,11 +2847,7 @@
 
       col = max (col, 0);
 
-      if (row == selection.end.row
-#if !ENABLE_MINIMAL
-          || selection.rect
-#endif
-          )
+      if (row == selection.end.row)
         min_it (end_col, selection.end.col);
 
       t = ROW(row).t + col;
@@ -3007,9 +2865,9 @@
 
               if (extra < 0)
                 {
-                  extra += i;
-                  i += i;
-                  new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
+                  extra += size;
+                  size += size;
+                  new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (size + 4) * sizeof (wchar_t));
                 }
 
               ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
@@ -3031,13 +2889,12 @@
         }
       else
 #endif
-        if (!ROW(row).is_longer () && row != selection.end.row)
+        if (!ROW(row).is_longer ()
+            && (row != selection.end.row || end_col != selection.end.col)
+            && (row != selection.beg.row || selection.beg.col < ncol))
           new_selection_text[ofs++] = C0_LF;
     }
 
-  if (end_col != selection.end.col)
-    new_selection_text[ofs++] = C0_LF;
-
   new_selection_text[ofs] = 0;
 
   if (ofs == 0)
@@ -3059,19 +2916,30 @@
 }
 
 bool
-rxvt_term::selection_grab (Time tm) NOTHROW
+rxvt_term::selection_grab (Time tm, bool clipboard) NOTHROW
 {
-  selection_time = tm;
+  Atom sel;
+
+  if (!clipboard)
+    {
+      selection_time = tm;
+      sel = XA_PRIMARY;
+    }
+  else
+    {
+      clipboard_time = tm;
+      sel = xa[XA_CLIPBOARD];
+    }
 
-  XSetSelectionOwner (dpy, XA_PRIMARY, vt, tm);
-  if (XGetSelectionOwner (dpy, XA_PRIMARY) == vt)
+  XSetSelectionOwner (dpy, sel, vt, tm);
+  if (XGetSelectionOwner (dpy, sel) == vt)
     {
-      display->set_selection_owner (this);
+      display->set_selection_owner (this, clipboard);
       return true;
     }
   else
     {
-      selection_clear ();
+      selection_clear (clipboard);
       return false;
     }
 
@@ -3541,6 +3409,7 @@
 void
 rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
 {
+  Atom property = rq.property == None ? rq.target : rq.property;
   XSelectionEvent ev;
 
   ev.type = SelectionNotify;
@@ -3565,10 +3434,10 @@
       *target++ = xa[XA_UTF8_STRING];
 #endif
 
-      XChangeProperty (dpy, rq.requestor, rq.property, XA_ATOM,
+      XChangeProperty (dpy, rq.requestor, property, XA_ATOM,
                        32, PropModeReplace,
                        (unsigned char *)target_list, target - target_list);
-      ev.property = rq.property;
+      ev.property = property;
     }
 #if TODO // TODO
   else if (rq.target == xa[XA_MULTIPLE])
@@ -3576,11 +3445,17 @@
       /* TODO: Handle MULTIPLE */
     }
 #endif
-  else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
+  else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == XA_PRIMARY && selection.text)
     {
-      XChangeProperty (dpy, rq.requestor, rq.property, rq.target,
+      XChangeProperty (dpy, rq.requestor, property, rq.target,
                        32, PropModeReplace, (unsigned char *)&selection_time, 1);
-      ev.property = rq.property;
+      ev.property = property;
+    }
+  else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == xa[XA_CLIPBOARD] && selection.clip_text)
+    {
+      XChangeProperty (dpy, rq.requestor, property, rq.target,
+                       32, PropModeReplace, (unsigned char *)&clipboard_time, 1);
+      ev.property = property;
     }
   else if (rq.target == XA_STRING
            || rq.target == xa[XA_TEXT]
@@ -3622,11 +3497,16 @@
           style = enc_compound_text;
         }
 
-      if (selection.text)
+      if (rq.selection == XA_PRIMARY && selection.text)
         {
           cl = selection.text;
           selectlen = selection.len;
         }
+      else if (rq.selection == xa[XA_CLIPBOARD] && selection.clip_text)
+        {
+          cl = selection.clip_text;
+          selectlen = selection.clip_len;
+        }
       else
         {
           cl = L"";
@@ -3656,10 +3536,10 @@
           ct.encoding = target;
         }
 
-      XChangeProperty (dpy, rq.requestor, rq.property,
+      XChangeProperty (dpy, rq.requestor, property,
                        ct.encoding, 8, PropModeReplace,
                        ct.value, (int)ct.nitems);
-      ev.property = rq.property;
+      ev.property = property;
 
       if (freect)
         XFree (ct.value);
@@ -3703,16 +3583,16 @@
   x -= 1; clamp_it (x, 0, ncol - w);
   y -= 1; clamp_it (y, 0, nrow - h);
 
-  ov_x = x; ov_y = y;
-  ov_w = w; ov_h = h;
+  ov.x = x; ov.y = y;
+  ov.w = w; ov.h = h;
 
-  ov_text = new text_t *[h];
-  ov_rend = new rend_t *[h];
+  ov.text = new text_t *[h];
+  ov.rend = new rend_t *[h];
 
   for (y = 0; y < h; y++)
     {
-      text_t *tp = ov_text[y] = new text_t[w];
-      rend_t *rp = ov_rend[y] = new rend_t[w];
+      text_t *tp = ov.text[y] = new text_t[w];
+      rend_t *rp = ov.rend[y] = new rend_t[w];
 
       text_t t0, t1, t2;
       rend_t r = OVERLAY_RSTYLE;
@@ -3741,31 +3621,31 @@
 void
 rxvt_term::scr_overlay_off () NOTHROW
 {
-  if (!ov_text)
+  if (!ov.text)
     return;
 
   want_refresh = 1;
 
-  for (int y = 0; y < ov_h; y++)
+  for (int y = 0; y < ov.h; y++)
     {
-      delete [] ov_text[y];
-      delete [] ov_rend[y];
+      delete [] ov.text[y];
+      delete [] ov.rend[y];
     }
 
-  delete [] ov_text; ov_text = 0;
-  delete [] ov_rend; ov_rend = 0;
+  delete [] ov.text; ov.text = 0;
+  delete [] ov.rend; ov.rend = 0;
 }
 
 void
 rxvt_term::scr_overlay_set (int x, int y, text_t text, rend_t rend) NOTHROW
 {
-  if (!ov_text || x >= ov_w - 2 || y >= ov_h - 2)
+  if (!ov.text || x >= ov.w - 2 || y >= ov.h - 2)
     return;
 
   x++, y++;
 
-  ov_text[y][x] = text;
-  ov_rend[y][x] = rend;
+  ov.text[y][x] = text;
+  ov.rend[y][x] = rend;
 }
 
 void
@@ -3794,19 +3674,24 @@
 void
 rxvt_term::scr_swap_overlay () NOTHROW
 {
-  if (!ov_text)
+  if (!ov.text)
     return;
 
+  // hide cursor if it is within the overlay area
+  if (IN_RANGE_EXC (screen.cur.col - ov.x, 0, ov.w)
+      && IN_RANGE_EXC (screen.cur.row - ov.y, 0, ov.h))
+    screen.flags &= ~Screen_VisibleCursor;
+
   // swap screen mem with overlay
-  for (int y = ov_h; y--; )
+  for (int y = ov.h; y--; )
     {
-      text_t *t1 = ov_text[y];
-      rend_t *r1 = ov_rend[y];
+      text_t *t1 = ov.text[y];
+      rend_t *r1 = ov.rend[y];
 
-      text_t *t2 = ROW(y + ov_y + view_start).t + ov_x;
-      rend_t *r2 = ROW(y + ov_y + view_start).r + ov_x;
+      text_t *t2 = ROW(y + ov.y + view_start).t + ov.x;
+      rend_t *r2 = ROW(y + ov.y + view_start).r + ov.x;
 
-      for (int x = ov_w; x--; )
+      for (int x = ov.w; x--; )
         {
           text_t t = *t1; *t1++ = *t2; *t2++ = t;
           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, FONTSET (r)->find_font (t));