--- rxvt-unicode/src/screen.C	2006/01/16 08:57:02	1.234
+++ rxvt-unicode/src/screen.C	2010/10/09 22:33:45	1.348
@@ -1,9 +1,9 @@
-/*--------------------------------*-C-*--------------------------------------*
+/*---------------------------------------------------------------------------*
  * File:        screen.C
  *---------------------------------------------------------------------------*
  *
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
- * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
+ * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
  *
  * 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
@@ -28,13 +28,12 @@
 #include "rxvt.h"               /* NECESSARY */
 #include "rxvtperl.h"           /* NECESSARY */
 
-#include <X11/Xmd.h>            /* get the typedef for CARD32 */
-
 #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;
@@ -49,7 +48,7 @@
  *             GENERAL SCREEN AND SELECTION UPDATE ROUTINES                  *
  * ------------------------------------------------------------------------- */
 #define ZERO_SCROLLBACK()                                              \
-    if (OPTION (Opt_scrollTtyOutput))                                  \
+    if (option (Opt_scrollTtyOutput))                                  \
         view_start = 0
 #define CLEAR_SELECTION()                                              \
     selection.beg.row = selection.beg.col                              \
@@ -87,37 +86,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) const
+rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
 {
   if (!l.t)
     {
@@ -128,7 +111,7 @@
 
   l.touch ();
 
-  efs &= ~RS_baseattrMask;
+  efs &= ~RS_baseattrMask; // remove italic etc. fontstyles
   efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
 
   text_t *et = l.t + col;
@@ -144,7 +127,7 @@
 /* ------------------------------------------------------------------------- */
 /* 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) const
+rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs) const NOTHROW
 {
   scr_blank_line (l, 0, ncol, efs);
 
@@ -152,6 +135,25 @@
   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 (' '));
+
+  // found start, nuke
+  do {
+    l.t[col] = ' ';
+    l.r[col] = rend;
+    col++;
+  } while (col < ncol && l.t[col] == NOCHAR);
+}
+
 /* ------------------------------------------------------------------------- *
  *                          SCREEN INITIALISATION                            *
  * ------------------------------------------------------------------------- */
@@ -159,10 +161,6 @@
 void
 rxvt_term::scr_reset ()
 {
-#if ENABLE_OVERLAY
-  scr_overlay_off ();
-#endif
-
   view_start = 0;
   num_scr = 0;
 
@@ -176,7 +174,7 @@
     return;
 
   // we need at least two lines for wrapping to work correctly
-  if (nrow + saveLines < 2)
+  while (nrow + saveLines < 2)
     {
       //TODO//FIXME
       saveLines++;
@@ -197,7 +195,7 @@
       /*
        * first time called so just malloc everything: don't rely on realloc
        */
-      top_row = 0;       /* no saved lines */
+      top_row    = 0;
       term_start = 0;
 
       talloc = new rxvt_salloc (ncol * sizeof (text_t));
@@ -236,8 +234,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
     {
@@ -276,15 +274,16 @@
 
       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 + top_row  , prev_total_rows);
       int q    = total_rows; // rewrapped row
 
       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);
@@ -292,9 +291,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;
 
@@ -327,6 +324,10 @@
 
                   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)
                     {
@@ -346,9 +347,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));
 
@@ -365,7 +363,7 @@
 
           term_start = total_rows - nrow;
           top_row = q - term_start;
- 
+
           // make sure all terminal lines exist
           while (top_row > 0)
             scr_blank_screen_mem (ROW (--top_row), DEFAULT_RSTYLE);
@@ -373,7 +371,7 @@
       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)];
@@ -391,30 +389,25 @@
           term_start = 0;
         }
 
-#ifdef DEBUG_STRICT //TODO: remove
-      for (int i = top_row; 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--; )
+  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));
@@ -425,32 +418,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 (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);
 }
 
 /* ------------------------------------------------------------------------- *
@@ -462,7 +477,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;
 
@@ -498,10 +513,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);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -510,49 +538,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 (OPTION (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 (OPTION (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;
@@ -572,7 +591,7 @@
  * 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 (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
     color = fgbg;
@@ -588,15 +607,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;
+}
 
 /* ------------------------------------------------------------------------- */
 /*
@@ -605,7 +624,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;
@@ -615,31 +634,35 @@
 
   if (count > 0
       && row1 == 0
-      && (current_screen == PRIMARY || OPTION (Opt_secondaryScroll)))
+      && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
     {
       top_row = max (top_row - count, -saveLines);
 
       // scroll everything up 'count' lines
       term_start = (term_start + count) % total_rows;
 
+      // sever bottommost line
       {
-        // severe bottommost scrolled line
         line_t &l = ROW(row2 - count);
-        l.touch ();
         l.is_longer (0);
+        l.touch ();
       }
 
-      // erase newly scorlled-in lines
-      for (int i = count; i; --i )
+      // erase newly scrolled-in lines
+      for (int i = count; i--; )
         {
-          // basically this is a slightly optimized scr_blank_screen_mem
-          // it is worth the effort on slower machines
-          line_t &l = ROW(nrow - i);
+          line_t &l = ROW(nrow - 1 - i);
 
-          scr_blank_line (l, 0, l.l, rstyle);
-
-          l.l = 0;
-          l.f = 0;
+          // optimize 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);
         }
 
       // now copy lines below the scroll region bottom to the
@@ -653,7 +676,7 @@
           ::swap (l1, l2);
           l2.touch ();
         }
-      
+
       // move and/or clear selection, if any
       if (selection.op && current_screen == selection.screen)
         {
@@ -671,7 +694,7 @@
         }
 
       // finally move the view window, if desired
-      if (OPTION (Opt_scrollWithBuffer)
+      if (option (Opt_scrollWithBuffer)
           && view_start != 0
           && view_start != -saveLines)
         scr_page (UP, count);
@@ -699,7 +722,7 @@
               selection.beg.row  -= count;
               selection.end.row  -= count;
               selection.mark.row -= count;
-              
+
               selection_check (0);
             }
         }
@@ -733,7 +756,7 @@
  * Add text given in <str> of length <len> to screen struct
  */
 void
-rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines)
+rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW
 {
   if (len <= 0)               /* sanity */
     return;
@@ -749,6 +772,7 @@
   if (minlines > 0)
     {
       minlines += screen.cur.row - screen.bscroll;
+      min_it (minlines, screen.cur.row - top_row);
 
       if (minlines > 0
           && screen.tscroll == 0
@@ -760,11 +784,9 @@
         }
     }
 
-#ifdef DEBUG_STRICT
   assert (screen.cur.col < ncol);
   assert (screen.cur.row < nrow
           && screen.cur.row >= top_row);
-#endif
   int row = screen.cur.row;
 
   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
@@ -775,7 +797,7 @@
     {
       c = (unicode_t)*str++; // convert to rxvt-unicodes representation
 
-      if (c < 0x20)
+      if (expect_false (c < 0x20))
         if (c == C0_LF)
           {
             max_it (line->l, screen.cur.col);
@@ -804,9 +826,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 (expect_false (
+            checksel            /* see if we're writing within selection */
+            && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
+            && ROWCOL_IS_BEFORE (screen.cur, selection.end)
+         ))
         {
           checksel = 0;
           /*
@@ -817,28 +841,28 @@
           CLEAR_SELECTION ();
         }
 
-      if (screen.flags & Screen_WrapNext)
+      if (expect_false (screen.flags & Screen_WrapNext))
         {
-          max_it (line->l, ncol);
+          scr_do_wrap ();
+
+          line->l = ncol;
           line->is_longer (1);
 
-          scr_do_wrap ();
-          
           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 (expect_false (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 (expect_false (charsets [screen.charset] == '0')) // DEC SPECIAL
         {
           // vt100 special graphics and line drawing
           // 5f-7e standard vt100
@@ -861,7 +885,7 @@
             }
         }
 
-      if (screen.flags & Screen_Insert)
+      if (expect_false (screen.flags & Screen_Insert))
         scr_insdel_chars (width, INSERT);
 
       if (width != 0)
@@ -877,35 +901,27 @@
 #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);
-            }
+          if (expect_false (
+                line->t[screen.cur.col] == NOCHAR
+                || (screen.cur.col < ncol - 1
+                    && line->t[screen.cur.col + 1] == NOCHAR)
+             ))
+            scr_kill_char (*line, screen.cur.col);
 
           rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
 
           // if the character doesn't fit into the remaining columns...
-          if (screen.cur.col > ncol - width && ncol >= width)
+          if (expect_false (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;
             }
 
           line->touch ();
@@ -915,7 +931,7 @@
               line->t[screen.cur.col] = c;
               line->r[screen.cur.col] = rend;
 
-              if (screen.cur.col < ncol - 1)
+              if (expect_true (screen.cur.col < ncol - 1))
                 screen.cur.col++;
               else
                 {
@@ -927,10 +943,10 @@
 
               c = NOCHAR;
             }
-          while (--width > 0);
+          while (expect_false (--width > 0));
 
           // pad with spaces when overwriting wide character with smaller one
-          if (!width)
+          if (expect_false (!width))
             {
               line->touch ();
 
@@ -941,54 +957,55 @@
                 }
             }
         }
+#if ENABLE_COMBINING
       else // width == 0
         {
-#if ENABLE_COMBINING
-          // handle combining characters
-          // we just tag the accent on the previous on-screen character.
-          // this is arguably not correct, but also arguably not wrong.
-          // we don't handle double-width characters nicely yet.
-          line_t *linep;
-          text_t *tp;
-          rend_t *rp;
-
-          if (screen.cur.col > 0)
-            {
-              linep = line;
-              tp = line->t + screen.cur.col - 1;
-              rp = line->r + screen.cur.col - 1;
-            }
-          else if (screen.cur.row > 0
-                   && ROW(screen.cur.row - 1).is_longer ())
-            {
-              linep = &ROW(screen.cur.row - 1);
-              tp = line->t + ncol - 1;
-              rp = line->r + ncol - 1;
-            }
-          else
-            continue;
+          if (c != 0xfeff) // ignore BOM
+            {
+              // handle combining characters
+              // we just tag the accent on the previous on-screen character.
+              // this is arguably not correct, but also arguably not wrong.
+              // we don't handle double-width characters nicely yet.
+              line_t *linep;
+              text_t *tp;
+              rend_t *rp;
+
+              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;
 
-          linep->touch ();
+              linep->touch ();
 
-          while (*tp == NOCHAR && tp > linep->t)
-            tp--, rp--;
+              while (*tp == NOCHAR && tp > linep->t)
+                tp--, rp--;
 
-          // 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
     }
 
   max_it (line->l, screen.cur.col);
 
-#ifdef DEBUG_STRICT
   assert (screen.cur.row >= 0);
-#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -997,25 +1014,22 @@
  * 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
     scr_gotorc (0, -1, RELATIVE);
-
-  screen.flags &= ~Screen_WrapNext;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1025,7 +1039,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;
 
@@ -1048,7 +1062,7 @@
             if (!--count)
               break;
           }
-        else 
+        else
           ht &= l.t[i] == ' '
                 && RS_SAME (l.r[i], base_rend);
 
@@ -1057,7 +1071,7 @@
 
       // store horizontal tab commands as characters inside the text
       // buffer so they can be selected and pasted.
-      if (ht && OPTION (Opt_pastableTabs))
+      if (ht && option (Opt_pastableTabs))
         {
           base_rend = SET_FONT (base_rend, 0);
 
@@ -1100,9 +1114,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);
@@ -1117,9 +1131,9 @@
  * 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);
@@ -1142,7 +1156,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 ();
@@ -1174,7 +1188,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);
         }
@@ -1190,7 +1205,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;
 
@@ -1217,9 +1232,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;
 
@@ -1235,21 +1251,31 @@
 
   switch (mode)
     {
+      case 3:
+        if (screen.flags & Screen_WrapNext)
+          return;
+
+        /* fall through */
+
       case 0:                     /* erase to end of line */
         col = screen.cur.col;
         num = ncol - col;
         min_it (line.l, col);
+
         if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
             || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
           CLEAR_SELECTION ();
         break;
+
       case 1:                     /* erase to beginning of line */
         col = 0;
         num = screen.cur.col + 1;
+
         if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
             || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
           CLEAR_SELECTION ();
         break;
+
       case 2:                     /* erase whole line */
         col = 0;
         num = ncol;
@@ -1273,7 +1299,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;
@@ -1317,33 +1343,46 @@
 
   min_it (num, nrow - row);
 
-  if (rstyle & (RS_RVid | RS_Uline))
+  if (rstyle & (RS_Blink | RS_RVid | RS_Uline))
     ren = (rend_t) ~RS_None;
   else if (GET_BASEBG (rstyle) == Color_bg)
     {
       ren = DEFAULT_RSTYLE;
-      CLEAR_ROWS (row, num);
+
+      if (mapped)
+        XClearArea (dpy, vt, 0,
+                    Row2Pixel (row - view_start), (unsigned int)width,
+                    (unsigned int)Height2Pixel (num), False);
     }
   else
     {
       ren = rstyle & (RS_fgMask | RS_bgMask);
-      gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
-      XChangeGC (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);
-      scr_blank_line (drawn_buf [row], 0, ncol, ren);
+
+      if (row - view_start < nrow)
+        scr_blank_line (drawn_buf [row - view_start], 0, ncol, ren);
     }
 }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
 void
-rxvt_term::scr_erase_savelines ()
+rxvt_term::scr_erase_savelines () NOTHROW
 {
   want_refresh = 1;
   ZERO_SCROLLBACK ();
@@ -1358,7 +1397,7 @@
  * XTERM_SEQ: Screen Alignment Test: ESC # 8
  */
 void
-rxvt_term::scr_E ()
+rxvt_term::scr_E () NOTHROW
 {
   rend_t fs;
 
@@ -1389,7 +1428,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;
 
@@ -1419,11 +1458,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 ();
 
@@ -1435,24 +1471,31 @@
   selection_check (1);
   min_it (count, ncol - screen.cur.col);
 
-  row = screen.cur.row;
+  int row = screen.cur.row;
 
   line_t *line = &ROW(row);
 
   line->touch ();
   line->is_longer (0);
 
+  // nuke wide spanning the start
+  if (line->t[screen.cur.col] == NOCHAR)
+    scr_kill_char (*line, screen.cur.col);
+
   switch (insdel)
     {
       case INSERT:
-        for (col = ncol - 1; (col - count) >= screen.cur.col; col--)
+        line->l = min (line->l + count, ncol);
+
+        if (line->t[screen.cur.col] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col);
+
+        for (int col = ncol - 1; (col - count) >= screen.cur.col; col--)
           {
             line->t[col] = line->t[col - count];
             line->r[col] = line->r[col - count];
           }
 
-        line->l = min (line->l + count, ncol);
-
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
@@ -1460,7 +1503,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;
@@ -1475,21 +1519,27 @@
         selection_check (1);
         screen.cur.col -= count;
 
-        line->l = max (line->l - count, 0);
+        // nuke wide char after the end
+        if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col + count);
+
         scr_blank_line (*line, screen.cur.col, count, rstyle);
         break;
 
       case DELETE:
-        tr = line->r[ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
+        line->l = max (line->l - count, 0);
 
-        for (col = screen.cur.col; (col + count) < ncol; col++)
+        // nuke wide char spanning the end
+        if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
+          scr_kill_char (*line, screen.cur.col + count);
+
+        for (int col = screen.cur.col; (col + count) < ncol; col++)
           {
             line->t[col] = line->t[col + count];
             line->r[col] = line->r[col + count];
           }
 
-        line->l = max (line->l - count, 0);
-        scr_blank_line (*line, ncol - count, count, tr);
+        scr_blank_line (*line, ncol - count, count, rstyle);
 
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
@@ -1517,7 +1567,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);
@@ -1537,7 +1587,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;
 
@@ -1554,7 +1604,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;
@@ -1573,7 +1623,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;
@@ -1590,7 +1640,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;
@@ -1606,10 +1656,10 @@
  * 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;
 }
@@ -1621,27 +1671,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;
+
+#ifndef NO_BELL
+  on ^= rvideo_bell;
+#endif
 
-  if (rvideo != mode)
+  if (rvideo_state != on)
     {
-      rvideo = mode;
+      rvideo_state = on;
+
       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
-#if XPM_BACKGROUND
+#ifdef HAVE_BG_PIXMAP
       if (bgPixmap.pixmap == None)
 #endif
-#if TRANSPARENT
-        if (! OPTION (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);
     }
@@ -1653,7 +1705,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);
 }
@@ -1666,7 +1718,7 @@
  * Set font style
  */
 void
-rxvt_term::set_font_style ()
+rxvt_term::set_font_style () NOTHROW
 {
 #if 0
   switch (charsets [screen.charset])
@@ -1698,7 +1750,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 ();
@@ -1714,7 +1766,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 ();
@@ -1729,16 +1781,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;
@@ -1759,7 +1810,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];
@@ -1792,8 +1843,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 ();
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1801,7 +1854,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);
 }
@@ -1812,7 +1865,7 @@
  * the top of the screen
  */
 void
-rxvt_term::scr_move_to (int y, int len)
+rxvt_term::scr_move_to (int y, int len) NOTHROW
 {
   scr_changeview ((top_row - nrow) * (len - y) / len + (nrow - 1));
 }
@@ -1823,7 +1876,7 @@
  * direction should be UP or DN
  */
 bool
-rxvt_term::scr_page (enum page_dirn direction, int nlines)
+rxvt_term::scr_page (enum page_dirn direction, int nlines) NOTHROW
 {
   int new_view_start =
     direction == UP ? view_start - nlines
@@ -1833,7 +1886,7 @@
 }
 
 bool
-rxvt_term::scr_changeview (int new_view_start)
+rxvt_term::scr_changeview (int new_view_start) NOTHROW
 {
   clamp_it (new_view_start, top_row, 0);
 
@@ -1849,42 +1902,58 @@
   return true;
 }
 
+#ifndef NO_BELL
+void
+rxvt_term::bell_cb (ev::timer &w, int revents)
+{
+  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 (OPTION (Opt_mapAlert))
+  if (option (Opt_mapAlert))
 #  endif
-    XMapWindow (display->display, parent[0]);
+    XMapWindow (dpy, parent[0]);
+# endif
+
+# if ENABLE_FRILLS
+  if (option (Opt_urgentOnBell))
+    set_urgency (1);
 # endif
 
-  if (OPTION (Opt_visualBell))
+  if (option (Opt_visualBell))
     {
-      scr_rvideo_mode (!rvideo); /* refresh also done */
-      display->flush ();
-      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)
@@ -1900,7 +1969,7 @@
 
   wctomb (0, 0);
 
-  for (int r1 = 0; r1 < nrows; r1++)
+  for (int r1 = row_start; r1 < row_start + nrows; r1++)
     {
       text_t *tp = ROW(r1).t;
       int len    = ROW(r1).l;
@@ -1937,10 +2006,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                                       */
@@ -1948,6 +2015,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 */
 
@@ -1957,14 +2026,12 @@
   /*
    * A: set up vars
    */
-  must_clear = 0;
   refresh_count = 0;
 
-#if XPM_BACKGROUND
-  must_clear |= bgPixmap.pixmap != None;
-#endif
-#if TRANSPARENT
-  must_clear |= OPTION (Opt_transparent) && am_transparent;
+  unsigned int old_screen_flags = screen.flags;
+  char have_bg = 0;
+#ifdef HAVE_BG_PIXMAP
+  have_bg = bgPixmap.pixmap != None;
 #endif
   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
 
@@ -1973,15 +2040,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;
@@ -1996,35 +2067,38 @@
 
         crp = &ROW(screen.cur.row).r[col];
 
-        if (showcursor && focus)
-          {
-            if (OPTION (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 = fgcolor_of (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 = bgcolor_of (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
               }
           }
       }
@@ -2061,28 +2135,25 @@
       }
   }
 
-  HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
-#if ENABLE_OVERLAY
-  scr_swap_overlay ();
-#endif
-
 #ifndef NO_SLOW_LINK_SUPPORT
   /*
    * D: CopyArea pass - very useful for slower links
    *    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)
@@ -2113,17 +2184,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)this->width,
                          (unsigned int)Height2Pixel (wlen - len + 1),
                          0, Row2Pixel (len));
+              gcv.graphics_exposures = 0; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
+
               len = -1;
             }
         }
@@ -2157,10 +2233,10 @@
           // redraw one or more characters
 
           // seek to the beginning of wide characters
-          while (stp[col] == NOCHAR && col > 0)
+          while (expect_false (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;
 
@@ -2174,7 +2250,8 @@
               if (stp[col] == NOCHAR)
                 {
                   dtp[col] = stp[col];
-                  drp[col] = rend;
+                  drp[col] = srp[col];
+
                   count++;
                   i++;
 
@@ -2189,14 +2266,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;
             }
 
@@ -2204,7 +2281,7 @@
           count -= i; /* dump any matching trailing chars */
 
           // sometimes we optimize away the trailing NOCHAR's, add them back
-          while (i && text[count] == NOCHAR)
+          while (expect_false (i && text[count] == NOCHAR))
             count++, i--;
 
           /*
@@ -2214,25 +2291,12 @@
           int back = bgcolor_of (rend); // desired background
 
           // only do special processing if any attributes are set, which is unlikely
-          if (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful))
+          if (expect_false (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;
@@ -2242,8 +2306,7 @@
 # endif
                 }
 
-              if (rend & RS_Italic
-                  && fore == Color_fg)
+              if (rend & RS_Italic && fore == Color_fg)
                 {
                   if (ISSET_PIXCOLOR (Color_IT))
                     fore = Color_IT;
@@ -2253,18 +2316,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;
@@ -2276,15 +2356,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
             }
 
           /*
@@ -2292,50 +2390,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 (expect_true (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 (expect_false (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
-  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
-
   /*
    * G: cleanup cursor and display outline cursor if necessary
    */
@@ -2343,7 +2430,7 @@
     {
       if (focus)
         {
-          if (OPTION (Opt_cursorUnderline))
+          if (option (Opt_cursorUnderline))
             *crp ^= RS_Uline;
           else
             {
@@ -2367,10 +2454,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),
@@ -2381,14 +2470,20 @@
   /*
    * H: cleanup selection
    */
+#if ENABLE_OVERLAY
+  scr_swap_overlay ();
+#endif
+  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
+
   scr_reverse_selection ();
 
+  screen.flags = old_screen_flags;
   num_scr = 0;
   num_scr_allow = 1;
 }
 
 void
-rxvt_term::scr_remap_chars (line_t &l)
+rxvt_term::scr_remap_chars (line_t &l) NOTHROW
 {
   if (!l.t)
     return;
@@ -2400,7 +2495,7 @@
 }
 
 void
-rxvt_term::scr_remap_chars ()
+rxvt_term::scr_remap_chars () NOTHROW
 {
   for (int i = total_rows; i--; )
     scr_remap_chars (row_buf [i]);
@@ -2413,30 +2508,26 @@
 }
 
 void
-rxvt_term::scr_recolour ()
+rxvt_term::scr_recolour () NOTHROW
 {
-  if (1
-#if TRANSPARENT
-      && !am_transparent
-#endif
-#if XPM_BACKGROUND
-      && !bgPixmap.pixmap
-#endif
-      )
-    {
-      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)
-        {
-          XSetWindowBackground (display->display, scrollBar.win, pix_colors[Color_border]);
-          scrollBar.setIdle ();
-          scrollbar_show (0);
-        }
+#ifdef HAVE_BG_PIXMAP
+  bgPixmap.apply ();
+#else
+
+  XSetWindowBackground (dpy, parent[0], pix_colors[Color_border]);
+  XClearWindow (dpy, parent[0]);
+  XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
+
+  if (scrollBar.win)
+   {
+     XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
+     scrollBar.state = STATE_IDLE;
+     scrollBar.show (0);
+   }
+
 #endif
-    }
 
+  /* bgPixmap.apply () does not do the following : */
   scr_clear ();
   scr_touch (true);
   want_refresh = 1;
@@ -2444,7 +2535,7 @@
 
 /* ------------------------------------------------------------------------- */
 void
-rxvt_term::scr_clear (bool really)
+rxvt_term::scr_clear (bool really) NOTHROW
 {
   if (!mapped)
     return;
@@ -2453,11 +2544,11 @@
   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)
+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;
@@ -2479,7 +2570,7 @@
 }
 
 void
-rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle)
+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;
@@ -2506,22 +2597,22 @@
 
 /* ------------------------------------------------------------------------- */
 void
-rxvt_term::scr_reverse_selection ()
+rxvt_term::scr_reverse_selection () NOTHROW
 {
   if (selection.op
       && current_screen == selection.screen
       && selection.end.row >= view_start)
     {
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       if (selection.rect)
         scr_xor_rect (selection.beg.row, selection.beg.col,
                       selection.end.row, selection.end.col,
-                      RS_RVid, RS_RVid | RS_Uline);
+                      RS_Sel | RS_RVid, RS_Sel | RS_RVid | RS_Uline);
       else
 #endif
         scr_xor_span (selection.beg.row, selection.beg.col,
                       selection.end.row, selection.end.col,
-                      RS_RVid);
+                      RS_Sel | RS_RVid);
     }
 }
 
@@ -2532,13 +2623,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";
 
-  for (row = saveLines - nsaved;
+  for (row = saveLines + top_row;
        row < saveLines + nrow - 1; row++)
     {
       width = row_buf[row].l >= 0 ? row_buf[row].l
@@ -2561,7 +2652,7 @@
  *                           CHARACTER SELECTION                             *
  * ------------------------------------------------------------------------- */
 void
-rxvt_term::selection_check (int check_more)
+rxvt_term::selection_check (int check_more) NOTHROW
 {
   row_col_t pos;
 
@@ -2592,14 +2683,29 @@
  * Paste a selection direct to the command fd
  */
 void
-rxvt_term::paste (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;
 
+  if (priv_modes & PrivMode_BracketPaste)
+    tt_printf ("\e[200~");
+
   tt_write (data, len);
+
+  if (priv_modes & PrivMode_BracketPaste)
+    tt_printf ("\e[201~");
+}
+
+void
+rxvt_term::paste (char *data, unsigned int len) NOTHROW
+{
+  if (HOOK_INVOKE ((this, HOOK_TT_PASTE, DT_STR_LEN, data, len, DT_END)))
+    return;
+
+  tt_paste (data, len);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2608,7 +2714,7 @@
  * EXT: SelectionNotify
  */
 void
-rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
+rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop) NOTHROW
 {
   if (prop == None)         /* check for failed XConvertSelection */
     {
@@ -2638,7 +2744,7 @@
   unsigned long bytes_after;
   XTextProperty ct;
 
-  if (XGetWindowProperty (display->display, win, prop,
+  if (XGetWindowProperty (dpy, win, prop,
                           0, PROP_SIZE / 4,
                           delete_prop, AnyPropertyType,
                           &ct.encoding, &ct.format,
@@ -2657,7 +2763,7 @@
       // fetch and append remaining data
       XTextProperty ct2;
 
-      if (XGetWindowProperty (display->display, win, prop,
+      if (XGetWindowProperty (dpy, win, prop,
                               ct.nitems / 4, (bytes_after + 3) / 4,
                               delete_prop, AnyPropertyType,
                               &ct2.encoding, &ct2.format,
@@ -2680,11 +2786,11 @@
     {
       // INCR selection, start handshake
       if (!delete_prop)
-        XDeleteProperty (display->display, win, prop);
+        XDeleteProperty (dpy, win, prop);
 
       selection_wait = Sel_incr;
       incr_buf_fill = 0;
-      incr_ev.start (NOW + 10);
+      incr_ev.start (10);
 
       goto bailout;
     }
@@ -2703,7 +2809,7 @@
           incr_buf_size = 0;
           incr_ev.stop ();
         }
-      else 
+      else
         {
           if (selection_wait == Sel_normal
               && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
@@ -2720,7 +2826,7 @@
     }
   else if (selection_wait == Sel_incr)
     {
-      incr_ev.start (NOW + 10);
+      incr_ev.start (10);
 
       while (incr_buf_fill + ct.nitems > incr_buf_size)
         {
@@ -2737,7 +2843,7 @@
   char **cl;
   int cr;
 
-#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 (ct.encoding == xa[XA_UTF8_STRING])
@@ -2751,7 +2857,7 @@
     }
   else
 #endif
-  if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
+  if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
       && cl)
     {
       for (int i = 0; i < cr; i++)
@@ -2770,7 +2876,7 @@
 }
 
 void
-rxvt_term::incr_cb (time_watcher &w)
+rxvt_term::incr_cb (ev::timer &w, int revents) NOTHROW
 {
   selection_wait = Sel_none;
 
@@ -2781,7 +2887,7 @@
 }
 
 void
-rxvt_term::selection_property (Window win, Atom prop)
+rxvt_term::selection_property (Window win, Atom prop) NOTHROW
 {
   if (prop == None || selection_wait != Sel_incr)
     return;
@@ -2791,7 +2897,7 @@
 
 /* ------------------------------------------------------------------------- */
 /*
- * Request the current selection: 
+ * Request the current selection:
  * Order: > internal selection if available
  *        > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
  *        > CUT_BUFFER0
@@ -2800,13 +2906,11 @@
  * EXT: button 2 release
  */
 void
-rxvt_term::selection_request (Time tm, int x, int y)
+rxvt_term::selection_request (Time tm, int selnum) NOTHROW
 {
-  if (x < 0 || x >= width || y < 0 || y >= height)
-    return;                 /* outside window */
-
-  if (selection.text)
-    { /* internal selection */
+  if (selection.text && selnum == Sel_Primary)
+    {
+      /* internal selection */
       char *str = rxvt_wcstombs (selection.text, selection.len);
       paste (str, strlen (str));
       free (str);
@@ -2814,23 +2918,18 @@
     }
   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;
+      selection_type = Sel_UTF8String;
+      if (selection_request_other (xa[XA_UTF8_STRING], selnum))
+        return;
 #else
-          selection_type = Sel_CompoundText;
-          if (selection_request_other (xa[XA_COMPOUND_TEXT], i))
-            return;
+      selection_type = Sel_CompoundText;
+      if (selection_request_other (xa[XA_COMPOUND_TEXT], selnum))
+        return;
 #endif
-        }
     }
 
   selection_wait = Sel_none;       /* don't loop in selection_paste () */
@@ -2838,7 +2937,7 @@
 }
 
 int
-rxvt_term::selection_request_other (Atom target, int selnum)
+rxvt_term::selection_request_other (Atom target, int selnum) NOTHROW
 {
   Atom sel;
 
@@ -2851,9 +2950,9 @@
   else
     sel = xa[XA_CLIPBOARD];
 
-  if (XGetSelectionOwner (display->display, sel) != None)
+  if (XGetSelectionOwner (dpy, sel) != None)
     {
-      XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
+      XConvertSelection (dpy, sel, target, xa[XA_VT_SELECTION],
                          vt, selection_request_time);
       return 1;
     }
@@ -2867,16 +2966,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;
+    }
+  else
+    {
+      free (selection.clip_text);
+      selection.clip_text = NULL;
+      selection.clip_len = 0;
 
-  if (display->selection_owner == this)
-    display->selection_owner = 0;
+      if (display->clipboard_owner == this)
+        display->clipboard_owner = 0;
+    }
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2926,7 +3037,7 @@
 
   for (; row <= selection.end.row; row++, col = 0)
     {
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       if (selection.rect)
         {
           col = selection.beg.col;
@@ -2939,7 +3050,7 @@
       col = max (col, 0);
 
       if (row == selection.end.row
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
           || selection.rect
 #endif
           )
@@ -2972,7 +3083,7 @@
             new_selection_text[ofs++] = *t++;
         }
 
-#if ENABLE_FRILLS
+#if !ENABLE_MINIMAL
       if (selection.rect)
         {
           while (ofs
@@ -3012,26 +3123,37 @@
 }
 
 bool
-rxvt_term::selection_grab (Time tm)
+rxvt_term::selection_grab (Time tm, bool clipboard) NOTHROW
 {
-  selection_time = tm;
+  Atom sel;
+
+  if (!clipboard)
+    {
+      selection_time = tm;
+      sel = XA_PRIMARY;
+    }
+  else
+    {
+      clipboard_time = tm;
+      sel = xa[XA_CLIPBOARD];
+    }
 
-  XSetSelectionOwner (display->display, XA_PRIMARY, vt, tm);
-  if (XGetSelectionOwner (display->display, XA_PRIMARY) == vt)
+  XSetSelectionOwner (dpy, sel, vt, tm);
+  if (XGetSelectionOwner (dpy, sel) == vt)
     {
-      display->set_selection_owner (this);
+      display->set_selection_owner (this, clipboard);
       return true;
     }
   else
     {
-      selection_clear ();
+      selection_clear (clipboard);
       return false;
     }
 
 #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);
@@ -3045,7 +3167,7 @@
  * 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 */
@@ -3074,7 +3196,7 @@
  * 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;
 
@@ -3087,9 +3209,10 @@
   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;
     }
@@ -3110,7 +3233,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;
@@ -3194,7 +3317,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);
@@ -3230,7 +3353,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 {
@@ -3288,7 +3411,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
        */
@@ -3316,7 +3440,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
@@ -3343,7 +3468,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
          )
@@ -3352,7 +3477,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
          )
@@ -3369,7 +3494,7 @@
   else if (selection.clicks == 3)
     {
 #if ENABLE_FRILLS
-      if (OPTION (Opt_tripleclickwords))
+      if (option (Opt_tripleclickwords))
         {
           selection_delimit_word (UP, &selection.beg, &selection.beg);
 
@@ -3379,7 +3504,9 @@
                 {
                   selection.end.row = end_row;
                   selection.end.col = ROW(end_row).l;
+# if !ENABLE_MINIMAL
                   selection_remove_trailing_spaces ();
+# endif
                   break;
                 }
             }
@@ -3405,7 +3532,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;
@@ -3418,15 +3546,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;
@@ -3474,7 +3602,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);
@@ -3486,10 +3614,9 @@
  * EXT: SelectionRequest
  */
 void
-rxvt_term::selection_send (const XSelectionRequestEvent &rq)
+rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
 {
   XSelectionEvent ev;
-  dDisp;
 
   ev.type = SelectionNotify;
   ev.property = None;
@@ -3513,7 +3640,7 @@
       *target++ = xa[XA_UTF8_STRING];
 #endif
 
-      XChangeProperty (disp, rq.requestor, rq.property, XA_ATOM,
+      XChangeProperty (dpy, rq.requestor, rq.property, XA_ATOM,
                        32, PropModeReplace,
                        (unsigned char *)target_list, target - target_list);
       ev.property = rq.property;
@@ -3524,12 +3651,18 @@
       /* 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, rq.property, rq.target,
                        32, PropModeReplace, (unsigned char *)&selection_time, 1);
       ev.property = rq.property;
     }
+  else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == xa[XA_CLIPBOARD] && selection.clip_text)
+    {
+      XChangeProperty (dpy, rq.requestor, rq.property, rq.target,
+                       32, PropModeReplace, (unsigned char *)&clipboard_time, 1);
+      ev.property = rq.property;
+    }
   else if (rq.target == XA_STRING
            || rq.target == xa[XA_TEXT]
            || rq.target == xa[XA_COMPOUND_TEXT]
@@ -3560,7 +3693,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
@@ -3570,18 +3703,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)
@@ -3594,7 +3732,7 @@
         }
       else
 #endif
-      if (XwcTextListToTextProperty (disp, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
+      if (XwcTextListToTextProperty (dpy, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
         freect = 1;
       else
         {
@@ -3604,7 +3742,7 @@
           ct.encoding = target;
         }
 
-      XChangeProperty (disp, rq.requestor, rq.property,
+      XChangeProperty (dpy, rq.requestor, rq.property,
                        ct.encoding, 8, PropModeReplace,
                        ct.value, (int)ct.nitems);
       ev.property = rq.property;
@@ -3613,33 +3751,17 @@
         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;
@@ -3648,7 +3770,7 @@
 
 #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 < 1 || ncol < 1)
     return;
@@ -3667,16 +3789,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;
@@ -3703,49 +3825,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--)
         {
@@ -3756,21 +3878,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 + ov_y + view_start).t + ov_x;
-      rend_t *r2 = ROW(y + ov_y + view_start).r + ov_x;
+      text_t *t2 = ROW(y + ov.y + view_start).t + ov.x;
+      rend_t *r2 = ROW(y + ov.y + view_start).r + ov.x;
 
-      for (int x = ov_w; x--; )
+      for (int x = ov.w; x--; )
         {
           text_t t = *t1; *t1++ = *t2; *t2++ = t;
           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, FONTSET (r)->find_font (t));