--- rxvt-unicode/src/screen.C	2005/12/26 21:30:04	1.194
+++ rxvt-unicode/src/screen.C	2011/07/08 00:23:22	1.389
@@ -1,9 +1,9 @@
-/*--------------------------------*-C-*--------------------------------------*
+/*---------------------------------------------------------------------------*
  * File:        screen.C
  *---------------------------------------------------------------------------*
  *
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
- * Copyright (c) 2003-2004 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
@@ -26,29 +26,27 @@
 
 #include "../config.h"          /* NECESSARY */
 #include "rxvt.h"               /* NECESSARY */
-
-#include <X11/Xmd.h>            /* get the typedef for CARD32 */
+#include "rxvtperl.h"           /* NECESSARY */
 
 #include <inttypes.h>
 
-#include "salloc.C" // HACK, should be a seperate compile!
+#include "salloc.C" // HACK, should be a separate compile!
 
-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 */
 
 /* ------------------------------------------------------------------------- *
  *             GENERAL SCREEN AND SELECTION UPDATE ROUTINES                  *
  * ------------------------------------------------------------------------- */
 #define ZERO_SCROLLBACK()                                              \
-    if (options & Opt_scrollTtyOutput)                                 \
+    if (option (Opt_scrollTtyOutput))                                  \
         view_start = 0
 #define CLEAR_SELECTION()                                              \
     selection.beg.row = selection.beg.col                              \
@@ -86,37 +84,21 @@
     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 (display->display, drawBuffer, 0,                   \
-                    Row2Pixel (row), (unsigned int)width,      \
-                    (unsigned int)Height2Pixel (num), False)
-
 #define CLEAR_CHARS(x, y, num)                                         \
-    if (mapped)                                                \
-        XClearArea (display->display, 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 (display->display, drawBuffer, gc,          \
-                    0, Row2Pixel (row),                                \
-                    (unsigned int)width,                       \
-                    (unsigned int)Height2Pixel (num))
-
 /* ------------------------------------------------------------------------- *
  *                        SCREEN `COMMON' ROUTINES                           *
  * ------------------------------------------------------------------------- */
 
 /* Fill part/all of a line with blanks. */
 void
-rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs)
+rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
 {
   if (!l.t)
     {
@@ -125,7 +107,9 @@
       width = ncol;
     }
 
-  efs &= ~RS_baseattrMask;
+  l.touch ();
+
+  efs &= ~RS_baseattrMask; // remove italic etc. fontstyles
   efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
 
   text_t *et = l.t + col;
@@ -141,9 +125,33 @@
 /* ------------------------------------------------------------------------- */
 /* Fill a full line with blanks - make sure it is allocated first */
 void
-rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs)
+rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs) const NOTHROW
 {
   scr_blank_line (l, 0, ncol, efs);
+
+  l.l = 0;
+  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);
 }
 
 /* ------------------------------------------------------------------------- *
@@ -170,12 +178,12 @@
     return;
 
   // we need at least two lines for wrapping to work correctly
-  if (nrow + saveLines < 2)
+  while (nrow + saveLines < 2)
     {
       //TODO//FIXME
       saveLines++;
       prev_nrow--;
-      nsaved++;
+      top_row--;
     }
 
   want_refresh = 1;
@@ -190,18 +198,16 @@
     {
       /*
        * first time called so just malloc everything: don't rely on realloc
-       * Note: this is still needed so that all the scrollback lines are NULL
        */
-      nsaved = 0;       /* no saved lines */
+      top_row    = 0;
       term_start = 0;
 
       talloc = new rxvt_salloc (ncol * sizeof (text_t));
       ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
 
-      row_buf   = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
-      temp_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));
+      row_buf   = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
+      drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
+      swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
 
       for (int row = nrow; row--; )
         {
@@ -232,8 +238,8 @@
       selection.op = SELECTION_CLEAR;
       selection.screen = PRIMARY;
       selection.clicks = 0;
-      CLEAR_ALL_SELECTION ();
-      rvideo = 0;
+      selection.clip_text = NULL;
+      selection.clip_len = 0;
     }
   else
     {
@@ -256,7 +262,6 @@
 #endif
 
       drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
-      temp_buf  = (line_t *)rxvt_realloc (temp_buf , nrow * sizeof (line_t));
       swap_buf  = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
 
       for (int row = min (nrow, prev_nrow); row--; )
@@ -271,16 +276,18 @@
           drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
         }
 
-      line_t *old_buf = row_buf; row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
-        
+      line_t *old_buf = row_buf;
+      row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
+
       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
-      int pend = MOD (term_start - nsaved   , prev_total_rows);
+      int pend = MOD (term_start + top_row  , prev_total_rows);
       int q    = total_rows; // rewrapped row
 
-      if (nsaved)
+      if (top_row)
         {
-          // re-wrap lines, this is rather ugly, possibly because I am too dumb
+          // 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);
@@ -288,10 +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;
 
@@ -319,10 +323,15 @@
                 {
                   qline = row_buf + qrow;
                   lalloc (*qline);
-                  qline->set_is_longer ();
+                  qline->l = ncol;
+                  qline->is_longer (1);
 
                   int qcol = 0;
 
+                  // see below for cursor adjustment rationale
+                  if (p == ocur.row)
+                    screen.cur.row = q - (total_rows - nrow);
+
                   // fill a single destination line
                   while (lofs < llen && qcol < ncol)
                     {
@@ -342,9 +351,6 @@
 
                       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));
 
@@ -353,23 +359,23 @@
                     }
                 }
 
-              qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1;
+              qline->l = llen ? MOD (llen - 1, ncol) + 1 : 0;
+              qline->is_longer (0);
               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);
+          top_row = q - term_start;
 
+          // make sure all terminal lines exist
+          while (top_row > 0)
+            scr_blank_screen_mem (ROW (--top_row), 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)];
@@ -387,31 +393,28 @@
           term_start = 0;
         }
 
-#ifdef DEBUG_STRICT //TODO: remove
-      for (int i = -nsaved; i < nrow; i++)
-        assert (ROW (i).t);
-#endif
-
       free (old_buf);
       delete old_ta;
       delete old_ra;
 
       clamp_it (screen.cur.row, 0, nrow - 1);
       clamp_it (screen.cur.col, 0, ncol - 1);
-
-      if (tabs)
-        free (tabs);
     }
 
-  prev_nrow = nrow;
-  prev_ncol = ncol;
-
-  tabs = (char *)rxvt_malloc (ncol * sizeof (char));
+  free (tabs);
+  tabs = (char *)rxvt_malloc (ncol);
 
   for (int col = ncol; col--; )
     tabs [col] = col % TABSIZE == 0;
 
+  CLEAR_ALL_SELECTION ();
+
+  prev_nrow = nrow;
+  prev_ncol = ncol;
+
   tt_winch ();
+
+  HOOK_INVOKE ((this, HOOK_RESET, DT_END));
 }
 
 /* ------------------------------------------------------------------------- */
@@ -419,33 +422,54 @@
  * Free everything.  That way malloc debugging can find leakage.
  */
 void
-rxvt_term::scr_release ()
+rxvt_term::scr_release () NOTHROW
 {
-  delete talloc; talloc = 0;
-  delete ralloc; ralloc = 0;
+  if (row_buf)
+    {
+      delete talloc; talloc = 0;
+      delete ralloc; ralloc = 0;
 
-  free (row_buf);
-  free (swap_buf);
-  free (drawn_buf);
-  free (temp_buf);
-  free (tabs);
+      free (row_buf);
+      free (swap_buf);
+      free (drawn_buf);
+      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 (SLOW_REFRESH);
+  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);
 }
 
 /* ------------------------------------------------------------------------- *
@@ -457,7 +481,7 @@
  * XTERM_SEQ: Restore cursor: ESC 8
  */
 void
-rxvt_term::scr_cursor (int mode)
+rxvt_term::scr_cursor (cursor_mode mode) NOTHROW
 {
   screen_t *s;
 
@@ -493,10 +517,23 @@
   /* 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
+rxvt_term::scr_swap_screen ()
+{
+  if (!option (Opt_secondaryScreen))
+    return;
+
+  for (int i = prev_nrow; i--; )
+    ::swap (ROW(i), swap_buf [i]);
+
+  ::swap (screen.cur, swap.cur);
+
+  screen.cur.row = clamp (screen.cur.row, 0, prev_nrow - 1);
+  screen.cur.col = clamp (screen.cur.col, 0, prev_ncol - 1);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -505,49 +542,40 @@
  * XTERM_SEQ: Primary screen  : ESC [ ? 4 7 h
  * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
  */
-int
+void
 rxvt_term::scr_change_screen (int scrn)
 {
+  if (scrn == current_screen)
+    return;
+
   want_refresh = 1;
   view_start = 0;
 
-  if (current_screen == scrn)
-    return scrn;
-
   selection_check (2);        /* check for boundary cross */
 
-  int i = current_screen; current_screen = scrn; scrn = i;
-
-  ::swap (screen.cur.row, swap.cur.row);
-  ::swap (screen.cur.col, swap.cur.col);
-
-  screen.cur.row = clamp (screen.cur.row, 0, prev_nrow - 1);
-  screen.cur.col = clamp (screen.cur.col, 0, prev_ncol - 1);
+  current_screen = scrn;
 
 #if NSCREENS
-  if (options & Opt_secondaryScreen)
+  if (option (Opt_secondaryScreen))
     {
       num_scr = 0;
 
-      for (int i = prev_nrow; i--; )
-        ::swap (ROW(i), swap_buf [i]);
+      scr_swap_screen ();
 
       ::swap (screen.charset, swap.charset);
-      ::swap (screen.flags, swap.flags);
+      ::swap (screen.flags,   swap.flags);
       screen.flags |= Screen_VisibleCursor;
-      swap.flags |= Screen_VisibleCursor;
+      swap.flags   |= Screen_VisibleCursor;
     }
   else
 #endif
-    if (options & Opt_secondaryScroll)
+    if (option (Opt_secondaryScroll))
       scr_scroll_text (0, prev_nrow - 1, prev_nrow);
-
-  return scrn;
 }
 
 // clear WrapNext indicator, solidifying position on next line
 void
-rxvt_term::scr_do_wrap ()
+rxvt_term::scr_do_wrap () NOTHROW
 {
   if (!(screen.flags & Screen_WrapNext))
     return;
@@ -567,9 +595,9 @@
  * Change the colour for following text
  */
 void
-rxvt_term::scr_color (unsigned int color, int fgbg)
+rxvt_term::scr_color (unsigned int color, int fgbg) NOTHROW
 {
-  if (color > maxTermCOLOR)
+  if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
     color = fgbg;
 
   if (fgbg == Color_fg)
@@ -583,15 +611,15 @@
  * Change the rendition style for following text
  */
 void
-rxvt_term::scr_rendition (int set, int style)
-  {
-    if (set)
-      rstyle |= style;
-    else if (style == ~RS_None)
-      rstyle = DEFAULT_RSTYLE;
-    else
-      rstyle &= ~style;
-  }
+rxvt_term::scr_rendition (int set, int style) NOTHROW
+{
+  if (set)
+    rstyle |= style;
+  else if (style == ~RS_None)
+    rstyle = DEFAULT_RSTYLE;
+  else
+    rstyle &= ~style;
+}
 
 /* ------------------------------------------------------------------------- */
 /*
@@ -600,7 +628,7 @@
  * count negative ==> scroll down
  */
 int
-rxvt_term::scr_scroll_text (int row1, int row2, int count)
+rxvt_term::scr_scroll_text (int row1, int row2, int count) NOTHROW
 {
   if (count == 0 || (row1 > row2))
     return 0;
@@ -610,34 +638,75 @@
 
   if (count > 0
       && row1 == 0
-      && row2 == nrow - 1
-      && (current_screen == PRIMARY || options & Opt_secondaryScroll))
+      && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
     {
-      nsaved = min (nsaved + count, saveLines);
+      min_it (count, total_rows - (nrow - (row2 + 1)));
+
+      top_row = max (top_row - count, -saveLines);
+
+      // sever bottommost line
+      {
+        line_t &l = ROW(row2 - 1);
+        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(row2 - i);
+
+          // 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)))
+            {
+              scr_blank_line (l, 0, l.l, rstyle);
+              l.l = 0;
+              l.f = 0;
+            }
+          else
+            scr_blank_screen_mem (l, rstyle);
+        }
+
+      // move and/or clear selection, if any
       if (selection.op && current_screen == selection.screen)
         {
           selection.beg.row  -= count;
           selection.end.row  -= count;
           selection.mark.row -= count;
 
-          if (selection.beg.row < -nsaved
-              || selection.end.row < -nsaved
-              || selection.mark.row < -nsaved)
+          if (selection.beg.row < top_row
+              || selection.end.row < top_row
+              || selection.mark.row < top_row)
             {
               CLEAR_ALL_SELECTION ();
               selection.op = SELECTION_CLEAR;
             }
         }
 
-      for (int i = count; i--; )
-        scr_blank_screen_mem (ROW(row2 - i), rstyle);
-      
-      if ((options & Opt_scrollWithBuffer)
+      // finally move the view window, if desired
+      if (option (Opt_scrollWithBuffer)
           && view_start != 0
-          && view_start != saveLines)
+          && view_start != -saveLines)
         scr_page (UP, count);
+
+      if (SHOULD_INVOKE (HOOK_SCROLL_BACK))
+        HOOK_INVOKE ((this, HOOK_SCROLL_BACK, DT_INT, count, DT_INT, top_row, DT_END));
     }
   else
     {
@@ -659,7 +728,7 @@
               selection.beg.row  -= count;
               selection.end.row  -= count;
               selection.mark.row -= count;
-              
+
               selection_check (0);
             }
         }
@@ -667,10 +736,20 @@
       // 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;
+
       for (int row = 0; row < rows; row++)
         {
           temp_buf [row] = ROW(row1 + (row + count + rows) % rows);
@@ -681,6 +760,14 @@
 
       for (int row = 0; row < rows; row++)
         ROW(row1 + row) = temp_buf [row];
+
+      // sever bottommost line
+      {
+        line_t &l = ROW(row2 - 1);
+        l.is_longer (0);
+        l.touch ();
+      }
+
     }
 
   return count;
@@ -691,38 +778,37 @@
  * Add text given in <str> of length <len> to screen struct
  */
 void
-rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
+rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW
 {
   if (len <= 0)               /* sanity */
     return;
 
   unsigned char checksel;
   unicode_t c;
-  int last_col;
-  const unicode_t *strend = str + len;
+  int ncol = this->ncol;
+  const wchar_t *strend = str + len;
 
   want_refresh = 1;
   ZERO_SCROLLBACK ();
-  last_col = ncol;
 
-  if (nlines > 0)
+  if (minlines > 0)
     {
-      nlines += screen.cur.row - screen.bscroll;
-      if (nlines > 0
+      minlines += screen.cur.row - screen.bscroll;
+      min_it (minlines, screen.cur.row - top_row);
+
+      if (minlines > 0
           && screen.tscroll == 0
-          && screen.bscroll == (nrow - 1))
+          && screen.bscroll == nrow - 1)
         {
           /* _at least_ this many lines need to be scrolled */
-          scr_scroll_text (screen.tscroll, screen.bscroll, nlines);
-          screen.cur.row -= nlines;
+          scr_scroll_text (screen.tscroll, screen.bscroll, minlines);
+          screen.cur.row -= minlines;
         }
     }
 
-#ifdef DEBUG_STRICT
-  assert (screen.cur.col < last_col);
+  assert (screen.cur.col < ncol);
   assert (screen.cur.row < nrow
-          && screen.cur.row >= -nsaved);
-#endif
+          && screen.cur.row >= top_row);
   int row = screen.cur.row;
 
   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
@@ -731,13 +817,12 @@
 
   while (str < strend)
     {
-      c = *str++;
+      c = (unicode_t)*str++; // convert to rxvt-unicodes representation
 
-      if (c < 0x20)
+      if (ecb_unlikely (c < 0x20))
         if (c == C0_LF)
-          {          
-            if (!line->is_longer ())      /* XXX: think about this */
-              max_it (line->l, screen.cur.col);
+          {
+            max_it (line->l, screen.cur.col);
 
             screen.flags &= ~Screen_WrapNext;
 
@@ -751,8 +836,7 @@
           }
         else if (c == C0_CR)
           {
-            if (!line->is_longer ())      /* XXX: think about this */
-              max_it (line->l, screen.cur.col);
+            max_it (line->l, screen.cur.col);
 
             screen.flags &= ~Screen_WrapNext;
             screen.cur.col = 0;
@@ -764,9 +848,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;
           /*
@@ -777,27 +863,28 @@
           CLEAR_SELECTION ();
         }
 
-      if (screen.flags & Screen_WrapNext)
+      if (ecb_unlikely (screen.flags & Screen_WrapNext))
         {
-          line->set_is_longer ();
-
           scr_do_wrap ();
-          
+
+          line->l = ncol;
+          line->is_longer (1);
+
           row = screen.cur.row;
           line = &ROW(row);   /* _must_ refresh */
         }
 
       // 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, at least for non-latin1
-      // do wcwidth before further replacements, as wcwidth might return -1
-      // for the line drawing characters below as they might be invalid in the current
+      // rely on wcwidth to tell us the character width, do wcwidth before
+      // further replacements, as wcwidth might return -1 for the line
+      // drawing characters below as they might be invalid in the current
       // locale.
-      int width = c < 0x100 ? 1 : wcwidth (c);
+      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
@@ -820,7 +907,7 @@
             }
         }
 
-      if (screen.flags & Screen_Insert)
+      if (ecb_unlikely (screen.flags & Screen_Insert))
         scr_insdel_chars (width, INSERT);
 
       if (width != 0)
@@ -835,114 +922,110 @@
 # 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 > last_col - width && last_col >= 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
             {
               line->t[screen.cur.col] = c;
               line->r[screen.cur.col] = rend;
 
-              if (screen.cur.col < last_col - 1)
+              if (ecb_likely (screen.cur.col < ncol - 1))
                 screen.cur.col++;
               else
                 {
-                  line->l = last_col;
+                  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; c < last_col && line->t[c] == NOCHAR; c++)
-              {
-                line->t[c] = ' ';
-                line->r[c] = rend;
-              }
+          for (int c = screen.cur.col; ecb_unlikely (c < ncol && line->t[c] == NOCHAR); c++)
+            {
+              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.
-          text_t *tp;
-          rend_t *rp;
-
-          if (screen.cur.col > 0)
+          if (c != 0xfeff) // ignore BOM
             {
-              tp = line->t + screen.cur.col - 1;
-              rp = line->r + screen.cur.col - 1;
+              // 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;
 
-              while (*tp == NOCHAR && tp > line->t)
-                tp--, rp--;
-            }
-          else if (screen.cur.row > 0
-                   && ROW(screen.cur.row - 1).is_longer ())
-            {
-              line_t *line = &ROW(screen.cur.row - 1);
+              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;
 
-              tp = line->t + last_col - 1;
-              rp = line->r + last_col - 1;
+              linep->touch ();
 
-              while (*tp == NOCHAR && tp > line->t)
+              while (*tp == NOCHAR && tp > linep->t)
                 tp--, rp--;
-            }
-          else
-            continue;
 
-          // first try to find a precomposed character
-          unicode_t n = rxvt_compose (*tp, c);
-          if (n == NOCHAR)
-            n = rxvt_composite.compose (*tp, c);
+              // 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
+              *tp = n;
+              *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
+            }
         }
+#endif
     }
 
-  if (!line->is_longer ())      /* XXX: think about this */
-    max_it (line->l, screen.cur.col);
+  max_it (line->l, screen.cur.col);
 
-#ifdef DEBUG_STRICT
   assert (screen.cur.row >= 0);
-#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -951,25 +1034,24 @@
  * XTERM_SEQ: CTRL-H
  */
 void
-rxvt_term::scr_backspace ()
+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;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -979,7 +1061,7 @@
  * XTERM_SEQ: CTRL-I
  */
 void
-rxvt_term::scr_tab (int count, bool ht)
+rxvt_term::scr_tab (int count, bool ht) NOTHROW
 {
   int i, x;
 
@@ -998,10 +1080,11 @@
         if (tabs[i])
           {
             x = i;
+
             if (!--count)
               break;
           }
-        else 
+        else
           ht &= l.t[i] == ' '
                 && RS_SAME (l.r[i], base_rend);
 
@@ -1010,12 +1093,11 @@
 
       // store horizontal tab commands as characters inside the text
       // buffer so they can be selected and pasted.
-      if (ht && options & Opt_pastableTabs)
+      if (ht && option (Opt_pastableTabs))
         {
           base_rend = SET_FONT (base_rend, 0);
 
-          if (!l.is_longer ())      /* XXX: think about this */
-            max_it (l.l, x);
+          l.touch (x);
 
           i = screen.cur.col;
 
@@ -1054,9 +1136,9 @@
  * Move cursor left in row.  If we're at the left boundary, shift everything
  * in that row right.  Clear left column.
  */
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
 void
-rxvt_term::scr_backindex ()
+rxvt_term::scr_backindex () NOTHROW
 {
   if (screen.cur.col > 0)
     scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
@@ -1071,16 +1153,18 @@
  * Move cursor right in row.  If we're at the right boundary, shift everything
  * in that row left.  Clear right column.
  */
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
 void
-rxvt_term::scr_forwardindex ()
+rxvt_term::scr_forwardindex () NOTHROW
 {
   if (screen.cur.col < ncol - 1)
     scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
   else
     {
-      if (ROW(screen.cur.row).is_longer ()) //TODO//FIXME//LEN
-        ROW(screen.cur.row).l = ncol;
+      line_t &l = ROW(screen.cur.row);
+
+      l.touch ();
+      l.is_longer (0);
 
       scr_gotorc (0, 0, R_RELATIVE);
       scr_insdel_chars (1, DELETE);
@@ -1094,7 +1178,7 @@
  * Goto Row/Column
  */
 void
-rxvt_term::scr_gotorc (int row, int col, int relative)
+rxvt_term::scr_gotorc (int row, int col, int relative) NOTHROW
 {
   want_refresh = 1;
   ZERO_SCROLLBACK ();
@@ -1126,7 +1210,8 @@
   else
     {
       if (screen.flags & Screen_Relative)
-        {        /* relative origin mode */
+        {
+          /* relative origin mode */
           screen.cur.row = row + screen.tscroll;
           min_it (screen.cur.row, screen.bscroll);
         }
@@ -1142,7 +1227,7 @@
  * direction should be UP or DN
  */
 void
-rxvt_term::scr_index (enum page_dirn direction)
+rxvt_term::scr_index (enum page_dirn direction) NOTHROW
 {
   int dirn;
 
@@ -1169,9 +1254,10 @@
  * 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)
+rxvt_term::scr_erase_line (int mode) NOTHROW
 {
   unsigned int col, num;
 
@@ -1182,23 +1268,36 @@
 
   line_t &line = ROW(screen.cur.row);
 
+  line.touch ();
+  line.is_longer (0);
+
   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;
@@ -1222,7 +1321,7 @@
  * XTERM_SEQ: Clear whole screen        : ESC [ 2 J
  */
 void
-rxvt_term::scr_erase_screen (int mode)
+rxvt_term::scr_erase_screen (int mode) NOTHROW
 {
   int num;
   int32_t row;
@@ -1266,39 +1365,51 @@
 
   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[GET_BGCOLOR (rstyle)];
-      XChangeGC (display->display, gc, GCForeground, &gcvalue);
-      ERASE_ROWS (row, num);
-      gcvalue.foreground = pix_colors[Color_fg];
-      XChangeGC (display->display, 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);
-      ROW (row).l = 0;
-      scr_blank_line (drawn_buf [row], 0, ncol, ren);
+      scr_blank_screen_mem (ROW(row), rstyle);
+
+      if (row - view_start < nrow)
+        scr_blank_line (drawn_buf [row - view_start], 0, ncol, ren);
     }
 }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
 void
-rxvt_term::scr_erase_savelines ()
+rxvt_term::scr_erase_savelines () NOTHROW
 {
   want_refresh = 1;
   ZERO_SCROLLBACK ();
 
-  nsaved = 0;
+  top_row = 0;
 }
 #endif
 
@@ -1308,7 +1419,7 @@
  * XTERM_SEQ: Screen Alignment Test: ESC # 8
  */
 void
-rxvt_term::scr_E ()
+rxvt_term::scr_E () NOTHROW
 {
   rend_t fs;
 
@@ -1329,7 +1440,8 @@
       for (int j = ncol; j--; )
         *r1++ = fs;
 
-      line.l = ncol;    /* make the `E's selectable */
+      line.is_longer (0);
+      line.touch (ncol);
     }
 }
 
@@ -1338,7 +1450,7 @@
  * Insert/Delete <count> lines
  */
 void
-rxvt_term::scr_insdel_lines (int count, int insdel)
+rxvt_term::scr_insdel_lines (int count, int insdel) NOTHROW
 {
   int end;
 
@@ -1368,11 +1480,8 @@
  * Insert/Delete <count> characters from the current position
  */
 void
-rxvt_term::scr_insdel_chars (int count, int insdel)
+rxvt_term::scr_insdel_chars (int count, int insdel) NOTHROW
 {
-  int col, row;
-  rend_t tr;
-
   want_refresh = 1;
   ZERO_SCROLLBACK ();
 
@@ -1384,25 +1493,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];
           }
 
-        if (!line->is_longer ())
-          {
-            line->l += count;
-            min_it (line->l, ncol);
-          }
-
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
@@ -1410,7 +1525,8 @@
                 || (selection.end.col + count >= ncol))
               CLEAR_SELECTION ();
             else
-              {              /* shift selection */
+              {
+                /* shift selection */
                 selection.beg.col  += count;
                 selection.mark.col += count; /* XXX: yes? */
                 selection.end.col  += count;
@@ -1424,24 +1540,28 @@
         screen.cur.col += count;     /* don't worry if > ncol */
         selection_check (1);
         screen.cur.col -= count;
+
+        // 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];
           }
 
-        scr_blank_line (*line, ncol - count, count, tr);
-
-        if (line->is_longer ()) /* break line continuation */
-          line->l = ncol;
-        
-        line->l = max (line->l - count, 0);
+        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))
@@ -1469,7 +1589,7 @@
  * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
  */
 void
-rxvt_term::scr_scroll_region (int top, int bot)
+rxvt_term::scr_scroll_region (int top, int bot) NOTHROW
 {
   max_it (top, 0);
   min_it (bot, nrow - 1);
@@ -1489,7 +1609,7 @@
  * XTERM_SEQ: Make cursor invisible: ESC [ ? 25 l
  */
 void
-rxvt_term::scr_cursor_visible (int mode)
+rxvt_term::scr_cursor_visible (int mode) NOTHROW
 {
   want_refresh = 1;
 
@@ -1506,7 +1626,7 @@
  * XTERM_SEQ: Unset Wraparound: ESC [ ? 7 l
  */
 void
-rxvt_term::scr_autowrap (int mode)
+rxvt_term::scr_autowrap (int mode) NOTHROW
 {
   if (mode)
     screen.flags |= Screen_Autowrap;
@@ -1525,7 +1645,7 @@
  * XTERM_SEQ: Set Relative: ESC [ ? 6 l
  */
 void
-rxvt_term::scr_relative_origin (int mode)
+rxvt_term::scr_relative_origin (int mode) NOTHROW
 {
   if (mode)
     screen.flags |= Screen_Relative;
@@ -1542,7 +1662,7 @@
  * XTERM_SEQ: Set Replace mode: ESC [ ? 4 l
  */
 void
-rxvt_term::scr_insert_mode (int mode)
+rxvt_term::scr_insert_mode (int mode) NOTHROW
 {
   if (mode)
     screen.flags |= Screen_Insert;
@@ -1558,12 +1678,12 @@
  * XTERM_SEQ: Clear all tabs             : ESC [ 3 g
  */
 void
-rxvt_term::scr_set_tab (int mode)
+rxvt_term::scr_set_tab (int mode) NOTHROW
 {
   if (mode < 0)
-    memset (tabs, 0, ncol * sizeof (char));
+    memset (tabs, 0, ncol);
   else if (screen.cur.col < ncol)
-    tabs[screen.cur.col] = (mode ? 1 : 0);
+    tabs [screen.cur.col] = !!mode;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1573,27 +1693,29 @@
  * XTERM_SEQ: Normal video : ESC [ ? 5 l
  */
 void
-rxvt_term::scr_rvideo_mode (int mode)
+rxvt_term::scr_rvideo_mode (bool on) NOTHROW
 {
-  XGCValues gcvalue;
+  rvideo_mode = on;
 
-  if (rvideo != mode)
+#ifndef NO_BELL
+  on ^= rvideo_bell;
+#endif
+
+  if (rvideo_state != on)
     {
-      rvideo = mode;
+      rvideo_state = on;
+
       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
-#if XPM_BACKGROUND
-      if (bgPixmap.pixmap == None)
+#ifdef HAVE_BG_PIXMAP
+      if (bg_pixmap == None)
 #endif
-#if TRANSPARENT
-        if (! (options & Opt_transparent) || am_transparent == 0)
-#endif
-          XSetWindowBackground (display->display, vt,
-                               pix_colors[Color_bg]);
+          XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
 
+      XGCValues gcvalue;
       gcvalue.foreground = pix_colors[Color_fg];
       gcvalue.background = pix_colors[Color_bg];
-      XChangeGC (display->display, gc, GCBackground | GCForeground,
-                &gcvalue);
+      XChangeGC (dpy, gc, GCBackground | GCForeground, &gcvalue);
+
       scr_clear ();
       scr_touch (true);
     }
@@ -1605,7 +1727,7 @@
  * XTERM_SEQ: Report position: ESC [ 6 n
  */
 void
-rxvt_term::scr_report_position ()
+rxvt_term::scr_report_position () NOTHROW
 {
   tt_printf ("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
 }
@@ -1618,9 +1740,10 @@
  * Set font style
  */
 void
-rxvt_term::set_font_style ()
+rxvt_term::set_font_style () NOTHROW
 {
-  switch (charsets[screen.charset])
+#if 0
+  switch (charsets [screen.charset])
     {
       case '0':                   /* DEC Special Character & Line Drawing Set */
         break;
@@ -1637,6 +1760,7 @@
       case 'K':                   /* German character set */
         break;
     }
+#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1648,7 +1772,7 @@
  * XTERM_SEQ: Invoke G3 character set: ESC O
  */
 void
-rxvt_term::scr_charset_choose (int set)
+rxvt_term::scr_charset_choose (int set) NOTHROW
 {
   screen.charset = set;
   set_font_style ();
@@ -1664,7 +1788,7 @@
  * See set_font_style for possible values for <C>
  */
 void
-rxvt_term::scr_charset_set (int set, unsigned int ch)
+rxvt_term::scr_charset_set (int set, unsigned int ch) NOTHROW
 {
   charsets[set] = (unsigned char)ch;
   set_font_style ();
@@ -1679,16 +1803,15 @@
  * refresh matching text.
  */
 bool
-rxvt_term::scr_refresh_rend (rend_t mask, rend_t value)
+rxvt_term::scr_refresh_rend (rend_t mask, rend_t value) NOTHROW
 {
   bool found = false;
 
   for (int i = 0; i < nrow; i++)
     {
-      int col = 0;
       rend_t *drp = drawn_buf[i].r;
 
-      for (; col < ncol; col++, drp++)
+      for (int col = 0; col < ncol; col++, drp++)
         if ((*drp & mask) == value)
           {
             found = true;
@@ -1709,7 +1832,7 @@
 };
 
 void
-rxvt_term::scr_expose (int x, int y, int ewidth, int eheight, bool refresh)
+rxvt_term::scr_expose (int x, int y, int ewidth, int eheight, bool refresh) NOTHROW
 {
   int i;
   row_col_t rc[RC_COUNT];
@@ -1742,8 +1865,10 @@
   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);
 
+  num_scr_allow = 0;
+
   if (refresh)
-    scr_refresh (SLOW_REFRESH);
+    scr_refresh ();
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1751,7 +1876,7 @@
  * Refresh the entire screen
  */
 void
-rxvt_term::scr_touch (bool refresh)
+rxvt_term::scr_touch (bool refresh) NOTHROW
 {
   scr_expose (0, 0, width, height, refresh);
 }
@@ -1761,24 +1886,10 @@
  * Move the display so that the line represented by scrollbar value Y is at
  * the top of the screen
  */
-int
-rxvt_term::scr_move_to (int y, int len)
+void
+rxvt_term::scr_move_to (int y, int len) NOTHROW
 {
-  long p = 0;
-  unsigned int oldviewstart;
-
-  oldviewstart = view_start;
-
-  if (y < len)
-    {
-      p = (nrow + nsaved) * (len - y) / len;
-      p -= (long) (nrow - 1);
-      p = max (p, 0);
-    }
-
-  view_start = (unsigned int)min (p, nsaved);
-
-  return scr_changeview (oldviewstart);
+  scr_changeview ((top_row - nrow) * (len - y) / len + (nrow - 1));
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1786,91 +1897,100 @@
  * Page the screen up/down nlines
  * direction should be UP or DN
  */
-int
-rxvt_term::scr_page (enum page_dirn direction, int nlines)
+bool
+rxvt_term::scr_page (enum page_dirn direction, int nlines) NOTHROW
 {
-  int n;
-  unsigned int oldviewstart;
+  int new_view_start =
+    direction == UP ? view_start - nlines
+                    : view_start + nlines;
 
-  oldviewstart = view_start;
+  return scr_changeview (new_view_start);
+}
 
-  if (direction == UP)
-    {
-      n = view_start + nlines;
-      view_start = min (n, nsaved);
-    }
-  else
-    {
-      n = view_start - nlines;
-      view_start = max (n, 0);
-    }
+bool
+rxvt_term::scr_changeview (int new_view_start) NOTHROW
+{
+  clamp_it (new_view_start, top_row, 0);
+
+  if (new_view_start == view_start)
+    return false;
+
+  num_scr += new_view_start - view_start;
+  view_start = new_view_start;
+  want_refresh = 1;
 
-  return scr_changeview (oldviewstart);
+  HOOK_INVOKE ((this, HOOK_VIEW_CHANGE, DT_INT, view_start, DT_END));
+
+  return true;
 }
 
-int
-rxvt_term::scr_changeview (unsigned int oldviewstart)
+#ifndef NO_BELL
+void
+rxvt_term::bell_cb (ev::timer &w, int revents)
 {
-  if (view_start != oldviewstart)
-    {
-      want_refresh = 1;
-      num_scr -= (view_start - oldviewstart);
-    }
-
-  return (int) (view_start - oldviewstart);
+  rvideo_bell = false;
+  scr_rvideo_mode (rvideo_mode);
+  refresh_check ();
 }
+#endif
 
 /* ------------------------------------------------------------------------- */
 void
-rxvt_term::scr_bell ()
+rxvt_term::scr_bell () NOTHROW
 {
 #ifndef NO_BELL
 
 # ifndef NO_MAPALERT
 #  ifdef MAPALERT_OPTION
-  if (options & Opt_mapAlert)
+  if (option (Opt_mapAlert))
 #  endif
-    XMapWindow (display->display, parent[0]);
+    XMapWindow (dpy, parent);
 # endif
 
-  if (options & Opt_visualBell)
+# if ENABLE_FRILLS
+  if (option (Opt_urgentOnBell))
+    set_urgency (1);
+# endif
+
+  if (option (Opt_visualBell))
     {
-      scr_rvideo_mode (!rvideo); /* refresh also done */
-      rxvt_usleep (VISUAL_BELL_DURATION);
-      scr_rvideo_mode (!rvideo); /* refresh also done */
+      rvideo_bell = true;
+      scr_rvideo_mode (rvideo_mode);
+      flush ();
+
+      bell_ev.start (VISUAL_BELL_DURATION);
     }
   else
-    XBell (display->display, 0);
-
+    XBell (dpy, 0);
+  HOOK_INVOKE ((this, HOOK_BELL, DT_END));
 #endif
 }
 
 /* ------------------------------------------------------------------------- */
-/* ARGSUSED */
 void
-rxvt_term::scr_printscreen (int fullhist)
+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)
     {
-      nrows = nrow + nsaved;
-      row_start = -nsaved;
+      nrows = nrow - top_row;
+      row_start = top_row;
     }
   else
     {
       nrows = nrow;
-      row_start = -view_start;
+      row_start = view_start;
     }
 
   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;
@@ -1907,10 +2027,8 @@
  * screen.text/screen.rend contain what the screen will change to.
  */
 void
-rxvt_term::scr_refresh (unsigned char refresh_type)
+rxvt_term::scr_refresh () NOTHROW
 {
-  unsigned char must_clear, /* use draw_string not draw_image_string     */
-                showcursor; /* show the cursor                           */
   int16_t col, row,   /* column/row we're processing               */
           ocrow;      /* old cursor row                            */
   int i;              /* tmp                                       */
@@ -1918,6 +2036,8 @@
   rend_t cc1;         /* store colours at cursor position (s)      */
 #endif
   rend_t *crp;        // cursor rendition pointer
+  rend_t ccol1,  /* Cursor colour       */
+         ccol2;  /* Cursor colour2      */
 
   want_refresh = 0;        /* screen is current */
 
@@ -1927,14 +2047,12 @@
   /*
    * A: set up vars
    */
-  must_clear = 0;
   refresh_count = 0;
 
-#if XPM_BACKGROUND
-  must_clear |= bgPixmap.pixmap != None;
-#endif
-#if TRANSPARENT
-  must_clear |= (options & Opt_transparent) && am_transparent;
+  unsigned int old_screen_flags = screen.flags;
+  char have_bg = 0;
+#ifdef HAVE_BG_PIXMAP
+  have_bg = bg_pixmap != None;
 #endif
   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
 
@@ -1943,15 +2061,19 @@
    */
   scr_reverse_selection ();
 
+  HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
+#if ENABLE_OVERLAY
+  scr_swap_overlay ();
+#endif
+
+  char showcursor = screen.flags & Screen_VisibleCursor;
+
   /*
    * C: set the cursor character (s)
    */
   {
     unsigned char setoldcursor;
-    rend_t ccol1,  /* Cursor colour       */
-           ccol2;  /* Cursor colour2      */
 
-    showcursor = (screen.flags & Screen_VisibleCursor);
 #ifdef CURSOR_BLINK
     if (hidden_cursor)
       showcursor = 0;
@@ -1966,35 +2088,38 @@
 
         crp = &ROW(screen.cur.row).r[col];
 
-        if (showcursor && focus)
-          {
-            if (options & Opt_cursorUnderline)
-              *crp ^= RS_Uline;
-            else
-              {
-                *crp ^= RS_RVid;
-
 #ifndef NO_CURSORCOLOR
-                cc1 = *crp & (RS_fgMask | RS_bgMask);
-                if (ISSET_PIXCOLOR (Color_cursor))
-                  ccol1 = Color_cursor;
-                else
+        cc1 = *crp & (RS_fgMask | RS_bgMask);
+        if (ISSET_PIXCOLOR (Color_cursor))
+          ccol1 = Color_cursor;
+        else
+#endif
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-                  ccol1 = GET_FGCOLOR (rstyle);
+          ccol1 = fgcolor_of (rstyle);
 #else
-                  ccol1 = Color_fg;
+          ccol1 = Color_fg;
+#endif
+
+#ifndef NO_CURSORCOLOR
+        if (ISSET_PIXCOLOR (Color_cursor2))
+          ccol2 = Color_cursor2;
+        else
 #endif
-                if (ISSET_PIXCOLOR (Color_cursor2))
-                  ccol2 = Color_cursor2;
-                else
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-                  ccol2 = GET_BGCOLOR (rstyle);
+          ccol2 = bgcolor_of (rstyle);
 #else
-                  ccol2 = Color_bg;
+          ccol2 = Color_bg;
 #endif
+
+        if (focus)
+          {
+            if (option (Opt_cursorUnderline))
+              *crp ^= RS_Uline;
+            else
+              {
+                *crp ^= RS_RVid;
                 *crp = SET_FGCOLOR (*crp, ccol1);
                 *crp = SET_BGCOLOR (*crp, ccol2);
-#endif
               }
           }
       }
@@ -2003,7 +2128,7 @@
     setoldcursor = 0;
     if (ocrow != -1)
       {
-        if (screen.cur.row + view_start != ocrow
+        if (screen.cur.row - view_start != ocrow
             || screen.cur.col != oldcursor.col)
           {
             if (ocrow < nrow
@@ -2021,42 +2146,40 @@
 
     if (setoldcursor)
       {
-        if (screen.cur.row + view_start >= nrow)
+        if (screen.cur.row - view_start >= nrow)
           oldcursor.row = -1;
         else
           {
-            oldcursor.row = screen.cur.row + view_start;
+            oldcursor.row = screen.cur.row - view_start;
             oldcursor.col = screen.cur.col;
           }
       }
   }
 
-#if ENABLE_OVERLAY
-  scr_swap_overlay ();
-#endif
-
 #ifndef NO_SLOW_LINK_SUPPORT
   /*
    * D: CopyArea pass - very useful for slower links
    *    This has been deliberately kept simple.
    */
-  i = num_scr;
   if (!display->is_local
       && refresh_type == FAST_REFRESH && num_scr_allow && num_scr
-      && abs (num_scr) < nrow && !must_clear)
+      && abs (num_scr) < nrow && !have_bg)
     {
       int16_t nits;
+      int i = num_scr;
       int j;
       int len, wlen;
+      dLocal (int, num_scr);
 
       j = nrow;
       wlen = len = -1;
       row = i > 0 ? 0 : j - 1;
+
       for (; j-- >= 0; row += (i > 0 ? 1 : -1))
         {
           if (row + i >= 0 && row + i < nrow && row + i != ocrow)
             {
-              line_t s  = ROW(row - view_start);
+              line_t s  = ROW(view_start + row);
               line_t d  = drawn_buf[row];
               line_t d2 = drawn_buf[row + i];
 
@@ -2082,17 +2205,22 @@
                 }
             }
 
-          if (len != -1)
+          if (len >= 0)
             {
               /* also comes here at end if needed because of >= above */
               if (wlen < len)
                 ::swap (wlen, len);
 
-              XCopyArea (display->display, vt, vt,
+              XGCValues gcv;
+
+              gcv.graphics_exposures = 1; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
+              XCopyArea (dpy, vt, vt,
                          gc, 0, Row2Pixel (len + i),
-                         (unsigned int)TermWin_TotalWidth (),
+                         (unsigned int)this->width,
                          (unsigned int)Height2Pixel (wlen - len + 1),
                          0, Row2Pixel (len));
+              gcv.graphics_exposures = 0; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
+
               len = -1;
             }
         }
@@ -2104,8 +2232,8 @@
    */
   for (row = 0; row < nrow; row++)
     {
-      text_t *stp = ROW(row - view_start).t;
-      rend_t *srp = ROW(row - view_start).r;
+      text_t *stp = ROW(view_start + row).t;
+      rend_t *srp = ROW(view_start + row).r;
       text_t *dtp = drawn_buf[row].t;
       rend_t *drp = drawn_buf[row].r;
 
@@ -2126,10 +2254,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;
 
@@ -2143,7 +2271,8 @@
               if (stp[col] == NOCHAR)
                 {
                   dtp[col] = stp[col];
-                  drp[col] = rend;
+                  drp[col] = srp[col];
+
                   count++;
                   i++;
 
@@ -2158,14 +2287,14 @@
               if (stp[col] != dtp[col]
                   || !RS_SAME (srp[col], drp[col]))
                 {
-                  if (must_clear && (i++ > count / 2))
+                  if (have_bg && (i++ > count / 2))
                     break;
 
                   dtp[col] = stp[col];
                   drp[col] = rend;
                   i = 0;
                 }
-              else if (must_clear || (stp[col] != ' ' && ++i >= 16))
+              else if (have_bg || (stp[col] != ' ' && ++i >= 16))
                 break;
             }
 
@@ -2173,35 +2302,22 @@
           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--;
 
           /*
            * Determine the attributes for the string
            */
-          int fore = GET_FGCOLOR (rend); // desired foreground
-          int back = GET_BGCOLOR (rend); // desired background
+          int fore = fgcolor_of (rend); // desired foreground
+          int back = bgcolor_of (rend); // desired background
 
-          // only do special processing if any attributes are set, which is rare
-          if (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful))
+          // only do special processing if any attributes are set, which is unlikely
+          if (ecb_unlikely (rend & (RS_baseattrMask | RS_Careful | RS_Sel)))
             {
-#if ENABLE_STYLES
-              // force redraw after "careful" characters to avoid pixel droppings
-              if (srp[col] & RS_Careful && col < ncol - 1 && 0)
-                drp[col + 1] = ~srp[col + 1];
-
-              // include previous careful character(s) if possible, looks nicer (best effort...)
-              while (text > stp
-                  && srp[text - stp - 1] & RS_Careful
-                  && RS_SAME (rend, srp[text - stp - 1]))
-                text--, count++, xpixel -= fwidth;
-#endif
-
               bool invert = rend & RS_RVid;
 
 #ifndef NO_BOLD_UNDERLINE_REVERSE
-              if (rend & RS_Bold
-                  && fore == Color_fg)
+              if (rend & RS_Bold && fore == Color_fg)
                 {
                   if (ISSET_PIXCOLOR (Color_BD))
                     fore = Color_BD;
@@ -2211,8 +2327,7 @@
 # endif
                 }
 
-              if (rend & RS_Italic
-                  && fore == Color_fg)
+              if (rend & RS_Italic && fore == Color_fg)
                 {
                   if (ISSET_PIXCOLOR (Color_IT))
                     fore = Color_IT;
@@ -2222,18 +2337,35 @@
 # endif
                 }
 
-              if (rend & RS_Uline && ISSET_PIXCOLOR (Color_UL))
+              if (rend & RS_Uline && fore == Color_fg && ISSET_PIXCOLOR (Color_UL))
                 fore = Color_UL;
 #endif
 
+#ifdef OPTION_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
+
               if (invert)
                 {
-                  ::swap (fore, back);
+                    ::swap (fore, back);
 
 #ifndef NO_BOLD_UNDERLINE_REVERSE
-                  if (ISSET_PIXCOLOR (Color_RV))
-                    back = Color_RV;
-
                   if (fore == back)
                     {
                       fore = Color_bg;
@@ -2245,15 +2377,33 @@
 #ifdef TEXT_BLINK
               if (rend & RS_Blink && (back == Color_bg || fore == Color_bg))
                 {
-                  if (!text_blink_ev.active)
+                  if (!text_blink_ev.is_active ())
                     {
-                      text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
+                      text_blink_ev.again ();
                       hidden_text = 0;
                     }
                   else if (hidden_text)
                     fore = back;
                 }
 #endif
+
+#if ENABLE_STYLES
+              // "careful" (too wide) character handling
+
+              // include previous careful character(s) if possible, looks nicer (best effort...)
+              while (text > stp
+                  && srp[text - stp - 1] & RS_Careful
+                  && RS_SAME (rend, srp[text - stp - 1]))
+                text--, count++, xpixel -= fwidth;
+
+              // force redraw after "careful" characters to avoid pixel droppings
+              for (int i = 0; srp[col + i] & RS_Careful && col + i < ncol - 1; i++)
+                drp[col + i + 1] = srp[col + i + 1] ^ RS_redraw;
+
+              // force redraw before "careful" characters to avoid pixel droppings
+              for (int i = 0; srp[text - stp - i] & RS_Careful && text - i > stp; i++)
+                drp[text - stp - i - 1] = srp[text - stp - i - 1] ^ RS_redraw;
+#endif
             }
 
           /*
@@ -2261,49 +2411,39 @@
            */
           rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
 
-          if (back == fore)
-            font->clear_rect (*drawable, xpixel, ypixel,
-                              fwidth * count, fheight,
-                              back);
-          else if (back == Color_bg)
+          if (ecb_likely (have_bg && back == Color_bg))
             {
-              if (must_clear)
-                {
-                  CLEAR_CHARS (xpixel, ypixel, count);
+              // this is very ugly, maybe push it into ->draw?
 
-                  for (i = 0; i < count; i++) /* don't draw empty strings */
-                    if (text[i] != ' ')
-                      {
-                        font->draw (*drawable, xpixel, ypixel, text, count, fore, -1);
-                        break;
-                      }
-                }
-              else
-                font->draw (*drawable, xpixel, ypixel, text, count, fore, Color_bg);
+              for (i = 0; i < count; i++) /* don't draw empty strings */
+                if (text[i] != ' ')
+                  {
+                    font->draw (*drawable, xpixel, ypixel, text, count, fore, Color_transparent);
+                    goto did_clear;
+                  }
+
+              CLEAR_CHARS (xpixel, ypixel, count);
+              did_clear: ;
             }
           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))
-                XSetForeground (display->display, gc, pix_colors[Color_underline]);
+                XSetForeground (dpy, gc, pix_colors[Color_underline]);
               else
 #endif
-                XSetForeground (display->display, gc, pix_colors[fore]);
+                XSetForeground (dpy, gc, pix_colors[fore]);
 
-              XDrawLine (display->display, 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
-
   /*
    * G: cleanup cursor and display outline cursor if necessary
    */
@@ -2311,7 +2451,7 @@
     {
       if (focus)
         {
-          if (options & Opt_cursorUnderline)
+          if (option (Opt_cursorUnderline))
             *crp ^= RS_Uline;
           else
             {
@@ -2335,10 +2475,12 @@
 
 #ifndef NO_CURSORCOLOR
           if (ISSET_PIXCOLOR (Color_cursor))
-            XSetForeground (display->display, gc, pix_colors[Color_cursor]);
+            XSetForeground (dpy, gc, pix_colors[Color_cursor]);
+          else
 #endif
+            XSetForeground (dpy, gc, pix_colors[ccol1]);
 
-          XDrawRectangle (display->display, drawBuffer, gc,
+          XDrawRectangle (dpy, vt, gc,
                           Col2Pixel (col),
                           Row2Pixel (oldcursor.row),
                           (unsigned int) (Width2Pixel (cursorwidth) - 1),
@@ -2349,27 +2491,32 @@
   /*
    * H: cleanup selection
    */
-  scr_reverse_selection ();
+#if ENABLE_OVERLAY
+  scr_swap_overlay ();
+#endif
+  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
 
-  if (refresh_type & SMOOTH_REFRESH)
-    XFlush (display->display);
+  scr_reverse_selection ();
 
+  screen.flags = old_screen_flags;
   num_scr = 0;
   num_scr_allow = 1;
 }
 
 void
-rxvt_term::scr_remap_chars (const line_t &l)
+rxvt_term::scr_remap_chars (line_t &l) NOTHROW
 {
   if (!l.t)
     return;
 
+  l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
+
   for (int i = ncol; i--; )
     l.r[i] = SET_FONT (l.r[i], FONTSET (l.r[i])->find_font (l.t[i]));
 }
 
 void
-rxvt_term::scr_remap_chars ()
+rxvt_term::scr_remap_chars () NOTHROW
 {
   for (int i = total_rows; i--; )
     scr_remap_chars (row_buf [i]);
@@ -2382,38 +2529,58 @@
 }
 
 void
-rxvt_term::scr_recolour ()
+rxvt_term::scr_recolour (bool refresh) NOTHROW
 {
-  if (1
-#if TRANSPARENT
-      && !am_transparent
-#endif
-#if XPM_BACKGROUND
-      && !bgPixmap.pixmap
-#endif
-      )
+  bool transparent = false;
+
+#ifdef HAVE_BG_PIXMAP
+  if (bg_pixmap != None)
     {
-      XSetWindowBackground (display->display, parent[0], pix_colors[Color_border]);
-      XClearWindow (display->display, parent[0]);
-      XSetWindowBackground (display->display, vt, pix_colors[Color_bg]);
-#if HAVE_SCROLLBARS
-      if (scrollBar.win)
+# ifdef ENABLE_TRANSPARENCY
+      if (bg_flags & BG_IS_TRANSPARENT)
+        {
+          XSetWindowBackgroundPixmap (dpy, parent, bg_pixmap);
+          XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
+
+          transparent = true;
+        }
+      else
+# endif
         {
-          XSetWindowBackground (display->display, scrollBar.win, pix_colors[Color_border]);
-          scrollBar.setIdle ();
-          scrollbar_show (0);
+          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]);
     }
 
-  scr_clear ();
-  scr_touch (true);
+  XClearWindow (dpy, parent);
+
+  if (scrollBar.win)
+    {
+      if (transparent)
+        XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
+      else
+        XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
+      scrollBar.state = STATE_IDLE;
+      scrollBar.show (0);
+    }
+
+  if (refresh)
+    {
+      scr_clear ();
+      scr_touch (true);
+    }
   want_refresh = 1;
 }
 
 /* ------------------------------------------------------------------------- */
 void
-rxvt_term::scr_clear (bool really)
+rxvt_term::scr_clear (bool really) NOTHROW
 {
   if (!mapped)
     return;
@@ -2422,49 +2589,75 @@
   want_refresh = 1;
 
   if (really)
-    XClearWindow (display->display, vt);
+    XClearWindow (dpy, vt);
+}
+
+void
+rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle1, rend_t rstyle2) NOTHROW
+{
+  int view_end = view_start + nrow;
+  int row, col;
+
+  for (row = max (beg_row, view_start); row <= min (end_row, view_end); row++)
+    {
+      text_t *stp = ROW(row).t;
+      rend_t *srp = ROW(row).r;
+
+      for (col = beg_col; col < end_col; col++)
+        srp[col] ^= rstyle1;
+
+      while (col-- > beg_col && (stp[col] == NOCHAR || unicode::is_space (stp[col])))
+        srp[col] ^= rstyle2;
+
+      if (++col < end_col)
+        srp[col] ^= rstyle2;
+    }
+}
+
+void
+rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle) NOTHROW
+{
+  int view_end = view_start + nrow;
+  int row, col;
+
+  if (beg_row >= view_start)
+    {
+      col = beg_col;
+      row = beg_row;
+    }
+  else
+    {
+      col = 0;
+      row = view_start;
+    }
+
+  for (; row < min (end_row, view_end); row++, col = 0)
+    for (rend_t *srp = ROW(row).r; col < ncol; col++)
+      srp[col] ^= rstyle;
+
+  if (row == end_row)
+    for (rend_t *srp = ROW(row).r; col < end_col; col++)
+      srp[col] ^= rstyle;
 }
 
 /* ------------------------------------------------------------------------- */
 void
-rxvt_term::scr_reverse_selection ()
+rxvt_term::scr_reverse_selection () NOTHROW
 {
   if (selection.op
       && current_screen == selection.screen
-      && selection.end.row >= -view_start)
+      && selection.end.row >= view_start)
     {
-      int view_end = -view_start + nrow;
-      int row, col;
-
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       if (selection.rect)
-        {
-          for (row = max (selection.beg.row, -view_start); row <= min (selection.end.row, view_end); row++)
-            for (rend_t *srp = ROW(row).r, col = selection.beg.col; col < selection.end.col; col++)
-              srp[col] ^= RS_RVid;
-        }
+        scr_xor_rect (selection.beg.row, selection.beg.col,
+                      selection.end.row, selection.end.col,
+                      RS_Sel | RS_RVid, RS_Sel | RS_RVid | RS_Uline);
       else
 #endif
-        {
-          if (selection.beg.row >= -view_start)
-            {
-              col = selection.beg.col;
-              row = selection.beg.row;
-            }
-          else
-            {
-              col = 0;
-              row = view_start;
-            }
-
-          for (; row < min (selection.end.row, view_end); row++, col = 0)
-            for (rend_t *srp = ROW(row).r; col < ncol; col++)
-              srp[col] ^= RS_RVid;
-
-          if (row == selection.end.row)
-            for (rend_t *srp = ROW(row).r; col < selection.end.col; col++)
-              srp[col] ^= RS_RVid;
-        }
+        scr_xor_span (selection.beg.row, selection.beg.col,
+                      selection.end.row, selection.end.col,
+                      RS_Sel | RS_RVid);
     }
 }
 
@@ -2475,13 +2668,13 @@
  */
 #if 0
 void
-rxvt_term::scr_dump (int fd)
+rxvt_term::scr_dump (int fd) NOTHROW
 {
   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
@@ -2504,7 +2697,7 @@
  *                           CHARACTER SELECTION                             *
  * ------------------------------------------------------------------------- */
 void
-rxvt_term::selection_check (int check_more)
+rxvt_term::selection_check (int check_more) NOTHROW
 {
   row_col_t pos;
 
@@ -2512,9 +2705,9 @@
     return;
 
   pos.row = pos.col = 0;
-  if (!IN_RANGE_EXC (selection.beg.row, -nsaved, nrow)
-      || !IN_RANGE_EXC (selection.mark.row, -nsaved, nrow)
-      || !IN_RANGE_EXC (selection.end.row, -nsaved, nrow)
+  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)
       || (check_more == 1
           && current_screen == selection.screen
           && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
@@ -2535,273 +2728,46 @@
  * Paste a selection direct to the command fd
  */
 void
-rxvt_term::paste (unsigned char *data, unsigned int len)
+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)
-{
-  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 (display->display, 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 (display->display, 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 (display->display, win, prop);
-
-      selection_wait = Sel_incr;
-      incr_buf_fill = 0;
-      incr_ev.start (NOW + 10);
+  if (priv_modes & PrivMode_BracketPaste)
+    tt_printf ("\e[200~");
 
-      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);
-            }
-
-          goto bailout;
-        }
-    }
-  else if (selection_wait == Sel_incr)
-    {
-      incr_ev.start (NOW + 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_FRILLS
-  // 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 ((unsigned char *)s, strlen (s));
-      free (s);
-    }
-  else
-#endif
-  if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
-      && cl)
-    {
-      for (int i = 0; i < cr; i++)
-        paste ((unsigned char *)cl[i], strlen (cl[i]));
-
-      XFreeStringList (cl);
-    }
-  else
-    paste (ct.value, ct.nitems); // paste raw
-
-bailout:
-  XFree (ct.value);
-
-  if (selection_wait == Sel_normal)
-    selection_wait = Sel_none;
-}
-
-void
-rxvt_term::incr_cb (time_watcher &w)
-{
-  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)
+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 x, int y)
-{
-  if (x < 0 || x >= width || y < 0 || y >= height)
-    return;                 /* outside window */
-
-  if (selection.text)
-    { /* internal selection */
-      char *str = rxvt_wcstombs (selection.text, selection.len);
-      paste ((unsigned char *)str, strlen (str));
-      free (str);
-      return;
-    }
-  else
-    {
-      int i;
-
-      selection_request_time = tm;
-      selection_wait = Sel_normal;
-
-      for (i = Sel_Primary; i <= Sel_Clipboard; i++)
-        {
-#if X_HAVE_UTF8_STRING
-          selection_type = Sel_UTF8String;
-          if (selection_request_other (xa[XA_UTF8_STRING], i))
-            return;
-#else
-          selection_type = Sel_CompoundText;
-          if (selection_request_other (xa[XA_COMPOUND_TEXT], i))
-            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)
+rxvt_term::selection_request (Time tm, 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 (display->display, sel) != None)
+  if (!selection_req)
     {
-      XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
-                         vt, selection_request_time);
-      return 1;
+      selection_req = new rxvt_selection (display, selnum, tm, vt, xa[XA_VT_SELECTION], this);
+      selection_req->run ();
     }
-
-  return 0;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2810,16 +2776,28 @@
  * EXT: SelectionClear
  */
 void
-rxvt_term::selection_clear ()
+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;
+      if (display->selection_owner == this)
+        display->selection_owner = 0;
+    }
+  else
+    {
+      free (selection.clip_text);
+      selection.clip_text = NULL;
+      selection.clip_len = 0;
+
+      if (display->clipboard_owner == this)
+        display->clipboard_owner = 0;
+    }
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2830,7 +2808,7 @@
 void
 rxvt_term::selection_make (Time tm)
 {
-  int i;
+  int size;
   wchar_t *new_selection_text;
   text_t *t;
 
@@ -2853,8 +2831,11 @@
   if (selection.clicks == 4)
     return;                 /* nothing selected, go away */
 
-  i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
-  new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
+  if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
+    return;
+
+  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;
@@ -2866,22 +2847,23 @@
 
   for (; row <= selection.end.row; row++, col = 0)
     {
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       if (selection.rect)
         {
           col = selection.beg.col;
-          end_col = ncol + 1;
+          end_col = selection.end.col;
         }
       else
 #endif
-        end_col = ROW(row).is_longer () ? ncol : ROW(row).l; //TODO//FIXME//LEN
+        end_col = ROW(row).l;
 
       col = max (col, 0);
 
-      if (row == selection.end.row || selection.rect)
-        end_col = min (end_col, selection.end.col);
+      if (row == selection.end.row)
+        min_it (end_col, selection.end.col);
 
       t = ROW(row).t + col;
+
       for (; col < end_col; col++)
         {
           if (*t == NOCHAR)
@@ -2895,9 +2877,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);
@@ -2907,12 +2889,23 @@
             new_selection_text[ofs++] = *t++;
         }
 
-      if (!ROW(row).is_longer () && row != selection.end.row)
-        new_selection_text[ofs++] = C0_LF;
-    }
+#if !ENABLE_MINIMAL
+      if (selection.rect)
+        {
+          while (ofs
+                 && new_selection_text[ofs - 1] != C0_LF
+                 && unicode::is_space (new_selection_text[ofs - 1]))
+            --ofs;
 
-  if (end_col != selection.end.col)
-    new_selection_text[ofs++] = C0_LF;
+          new_selection_text[ofs++] = C0_LF;
+        }
+      else
+#endif
+        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;
+    }
 
   new_selection_text[ofs] = 0;
 
@@ -2928,23 +2921,49 @@
   selection.len = ofs;
   selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
 
-  XSetSelectionOwner (display->display, XA_PRIMARY, vt, tm);
-  if (XGetSelectionOwner (display->display, XA_PRIMARY) == vt)
-    display->set_selection_owner (this);
+  if (HOOK_INVOKE ((this, HOOK_SEL_GRAB, DT_LONG, (long)tm, DT_END)))
+    return;
+
+  selection_grab (tm);
+}
+
+bool
+rxvt_term::selection_grab (Time tm, bool clipboard) NOTHROW
+{
+  Atom sel;
+
+  if (!clipboard)
+    {
+      selection_time = tm;
+      sel = XA_PRIMARY;
+    }
   else
-    rxvt_warn ("can't get primary selection, ignoring.\n");
+    {
+      clipboard_time = tm;
+      sel = xa[XA_CLIPBOARD];
+    }
+
+  XSetSelectionOwner (dpy, sel, vt, tm);
+  if (XGetSelectionOwner (dpy, sel) == vt)
+    {
+      display->set_selection_owner (this, clipboard);
+      return true;
+    }
+  else
+    {
+      selection_clear (clipboard);
+      return false;
+    }
 
 #if 0
   XTextProperty ct;
 
-  if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
+  if (XwcTextListToTextProperty (dpy, &selection.text, 1, XStringStyle, &ct) >= 0)
     {
       set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
       XFree (ct.value);
     }
 #endif
-
-  selection_time = tm;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2953,16 +2972,25 @@
  * EXT: button 1 press
  */
 void
-rxvt_term::selection_click (int clicks, int x, int y)
+rxvt_term::selection_click (int clicks, int x, int y) NOTHROW
 {
   clicks = ((clicks - 1) % 3) + 1;
   selection.clicks = clicks;       /* save clicks so extend will work */
 
+  if (clicks == 2 && !selection.rect
+      && HOOK_INVOKE ((this, HOOK_SEL_EXTEND, DT_END)))
+    {
+      MEvent.clicks = 1; // what a mess
+      selection.screen = current_screen;
+      selection.op = SELECTION_CONT;
+      return;
+    }
+
   selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
 
   if (clicks == 2 || clicks == 3)
     selection_extend_colrow (selection.mark.col,
-                             selection.mark.row + view_start,
+                             selection.mark.row - view_start,
                              0, /* button 3     */
                              1, /* button press */
                              0);        /* click change */
@@ -2973,22 +3001,23 @@
  * Mark a selection at the specified col/row
  */
 void
-rxvt_term::selection_start_colrow (int col, int row)
+rxvt_term::selection_start_colrow (int col, int row) NOTHROW
 {
   want_refresh = 1;
 
-  selection.mark.row = row - view_start;
+  selection.mark.row = row + view_start;
   selection.mark.col = col;
 
-  selection.mark.row = clamp (selection.mark.row, -nsaved, nrow - 1);
+  selection.mark.row = clamp (selection.mark.row, top_row, nrow - 1);
   selection.mark.col = clamp (selection.mark.col,       0, ncol - 1);
 
   while (selection.mark.col > 0
          && ROW(selection.mark.row).t[selection.mark.col] == NOCHAR)
     --selection.mark.col;
-  
+
   if (selection.op)
-    {      /* clear the old selection */
+    {
+      /* clear the old selection */
       selection.beg.row = selection.end.row = selection.mark.row;
       selection.beg.col = selection.end.col = selection.mark.col;
     }
@@ -3009,7 +3038,7 @@
 #define DELIMIT_REND(x)        1
 
 void
-rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
+rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret) NOTHROW
 {
   int col, row, dirnadd, tcol, trow, w1, w2;
   row_col_t bound;
@@ -3018,7 +3047,7 @@
 
   if (dirn == UP)
     {
-      bound.row = - nsaved - 1;
+      bound.row = top_row - 1;
       bound.col = 0;
       dirnadd = -1;
     }
@@ -3076,7 +3105,6 @@
       break;
     }
 
-Old_Word_Selection_You_Die:
   if (dirn == DN)
     col++;                  /* put us on one past the end */
 
@@ -3094,7 +3122,7 @@
  * flag == 2 ==> button 3 motion
  */
 void
-rxvt_term::selection_extend (int x, int y, int flag)
+rxvt_term::selection_extend (int x, int y, int flag) NOTHROW
 {
   int col = clamp (Pixel2Col (x), 0, ncol);
   int row = clamp (Pixel2Row (y), 0, nrow - 1);
@@ -3107,7 +3135,7 @@
   */
   if (((selection.clicks % 3) == 1) && !flag
       && (col == selection.mark.col
-          && (row == selection.mark.row + view_start)))
+          && (row == selection.mark.row - view_start)))
     {
       /* select nothing */
       selection.beg.row = selection.end.row = 0;
@@ -3130,7 +3158,7 @@
  * Extend the selection to the specified col/row
  */
 void
-rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange)
+rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange) NOTHROW
 {
   row_col_t pos;
   enum {
@@ -3172,7 +3200,7 @@
     }
 
   pos.col = col;
-  pos.row = row - view_start;
+  pos.row = view_start + row;
 
   /*
    * This is mainly xterm style selection with a couple of differences, mainly
@@ -3188,7 +3216,8 @@
    *     time of the most recent button3 press
    */
   if (button3 && buttonpress)
-    { /* button3 press */
+    {
+      /* button3 press */
       /*
        * first determine which edge of the selection we are closest to
        */
@@ -3216,7 +3245,8 @@
         }
     }
   else
-    { /* button1 drag or button3 drag */
+    {
+      /* button1 drag or button3 drag */
       if (ROWCOL_IS_AFTER (selection.mark, pos))
         {
           if (selection.mark.row == selection.end.row
@@ -3243,7 +3273,7 @@
     {
       if (selection.beg.col > ROW(selection.beg.row).l //TODO//FIXME//LEN
           && !ROW(selection.beg.row).is_longer ()
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
           && !selection.rect
 #endif
          )
@@ -3252,7 +3282,7 @@
       if (
           selection.end.col > ROW(selection.end.row).l //TODO//FIXME//LEN
           && !ROW(selection.end.row).is_longer ()
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
           && !selection.rect
 #endif
          )
@@ -3269,7 +3299,7 @@
   else if (selection.clicks == 3)
     {
 #if ENABLE_FRILLS
-      if (options & Opt_tripleclickwords)
+      if (option (Opt_tripleclickwords))
         {
           selection_delimit_word (UP, &selection.beg, &selection.beg);
 
@@ -3279,7 +3309,9 @@
                 {
                   selection.end.row = end_row;
                   selection.end.col = ROW(end_row).l;
+# if !ENABLE_MINIMAL
                   selection_remove_trailing_spaces ();
+# endif
                   break;
                 }
             }
@@ -3305,7 +3337,8 @@
     }
 
   if (button3 && buttonpress)
-    { /* mark may need to be changed */
+    {
+      /* mark may need to be changed */
       if (closeto == LEFT)
         {
           selection.mark.row = selection.end.row;
@@ -3318,15 +3351,15 @@
         }
     }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
   if (selection.rect && selection.beg.col > selection.end.col)
     ::swap (selection.beg.col, selection.end.col);
 #endif
 }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
 void
-rxvt_term::selection_remove_trailing_spaces ()
+rxvt_term::selection_remove_trailing_spaces () NOTHROW
 {
   int32_t end_col, end_row;
   text_t *stp;
@@ -3340,9 +3373,8 @@
 
       while (--end_col >= 0)
         {
-          if (stp[end_col] != ' '
-              && stp[end_col] != '\t'
-              && stp[end_col] != NOCHAR)
+          if (stp[end_col] != NOCHAR
+              && !unicode::is_space (stp[end_col]))
             break;
         }
 
@@ -3375,7 +3407,7 @@
  * EXT: button 3 double click
  */
 void
-rxvt_term::selection_rotate (int x, int y)
+rxvt_term::selection_rotate (int x, int y) NOTHROW
 {
   selection.clicks = selection.clicks % 3 + 1;
   selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
@@ -3387,10 +3419,10 @@
  * EXT: SelectionRequest
  */
 void
-rxvt_term::selection_send (const XSelectionRequestEvent &rq)
+rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
 {
+  Atom property = rq.property == None ? rq.target : rq.property;
   XSelectionEvent ev;
-  dDisp;
 
   ev.type = SelectionNotify;
   ev.property = None;
@@ -3414,10 +3446,10 @@
       *target++ = xa[XA_UTF8_STRING];
 #endif
 
-      XChangeProperty (disp, 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])
@@ -3425,11 +3457,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 (disp, 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]
@@ -3461,7 +3499,7 @@
         style = enc_text;
       else if (target == xa[XA_COMPOUND_TEXT])
         style = enc_compound_text;
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       else if (target == xa[XA_UTF8_STRING])
         style = enc_utf8;
 #endif
@@ -3471,18 +3509,23 @@
           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"";
           selectlen = 0;
         }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
       // so recode it manually
       if (style == enc_utf8)
@@ -3495,7 +3538,7 @@
         }
       else
 #endif
-      if (XwcTextListToTextProperty (disp, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
+      if (XwcTextListToTextProperty (dpy, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
         freect = 1;
       else
         {
@@ -3505,42 +3548,26 @@
           ct.encoding = target;
         }
 
-      XChangeProperty (disp, 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);
     }
 
-  XSendEvent (disp, rq.requestor, False, 0L, (XEvent *)&ev);
-}
-
-/* ------------------------------------------------------------------------- *
- *                              MOUSE ROUTINES                               *
- * ------------------------------------------------------------------------- */
-
-/*
- * return col/row values corresponding to x/y pixel values
- */
-void
-rxvt_term::pixel_position (int *x, int *y)
-{
-  *x = Pixel2Col (*x);
-  /* max_it (*x, 0); min_it (*x, (int)ncol - 1); */
-  *y = Pixel2Row (*y);
-  /* max_it (*y, 0); min_it (*y, (int)nrow - 1); */
+  XSendEvent (dpy, rq.requestor, False, 0L, (XEvent *)&ev);
 }
 
 /* ------------------------------------------------------------------------- */
 #ifdef USE_XIM
 void
-rxvt_term::im_set_position (XPoint &pos)
+rxvt_term::im_set_position (XPoint &pos) NOTHROW
 {
   XWindowAttributes xwa;
 
-  XGetWindowAttributes (display->display, vt, &xwa);
+  XGetWindowAttributes (dpy, vt, &xwa);
 
   pos.x = xwa.x + Col2Pixel    (screen.cur.col);
   pos.y = xwa.y + Height2Pixel (screen.cur.row) + fbase;
@@ -3549,9 +3576,9 @@
 
 #if ENABLE_OVERLAY
 void
-rxvt_term::scr_overlay_new (int x, int y, int w, int h)
+rxvt_term::scr_overlay_new (int x, int y, int w, int h) NOTHROW
 {
-  if (nrow < 3 || ncol < 3)
+  if (nrow < 1 || ncol < 1)
     return;
 
   want_refresh = 1;
@@ -3568,16 +3595,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;
@@ -3604,49 +3631,49 @@
 }
 
 void
-rxvt_term::scr_overlay_off ()
+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)
+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
-rxvt_term::scr_overlay_set (int x, int y, const char *s)
+rxvt_term::scr_overlay_set (int x, int y, const char *s) NOTHROW
 {
   while (*s)
     scr_overlay_set (x++, y, *s++);
 }
 
 void
-rxvt_term::scr_overlay_set (int x, int y, const wchar_t *s)
+rxvt_term::scr_overlay_set (int x, int y, const wchar_t *s) NOTHROW
 {
   while (*s)
     {
       text_t t = *s++;
-      int width = wcwidth (t);
+      int width = WCWIDTH (t);
 
       while (width--)
         {
@@ -3657,21 +3684,26 @@
 }
 
 void
-rxvt_term::scr_swap_overlay ()
+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 - view_start).t + ov_x;
-      rend_t *r2 = ROW(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));