[ViewVC] Diff of: cvs/rxvt-unicode/src/screen.C

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.29 by pcg, Wed Feb 11 08:13:45 2004 UTC vs.
Revision 1.41 by pcg, Sun Feb 29 15:31:56 2004 UTC

 /*--------------------------------*-C-*--------------------------------------*
  * File:        screen.c
  *---------------------------------------------------------------------------*
  *
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
+ * Copyright (c) 2003-2004 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
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *--------------------------------------------------------------------------*/
 /*
- * We handle _all_ screen updates and selections
+ * This file handles _all_ screen updates and selections
  */
 #include "../config.h"          /* NECESSARY */
 #define INTERN_SCREEN
 #include "rxvt.h"               /* NECESSARY */
 #include <X11/Xmd.h>            /* get the typedef for CARD32 */
 #include <stdint.h>
 #include <wchar.h>
-#include "salloc.C" // HACK!!
+#include "salloc.C" // HACK, should be a seperate compile!
 inline void fill_text (text_t *start, text_t value, int len)
 {
   while (len--)
     *start++ = value;
 #define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D)                     \
     (((A) == (C)) && ((B) <= (D)))
 /* these must be row_col_t */
 #define ROWCOL_IS_AFTER(X, Y)                                           \
-    ROW_AND_COL_IS_AFTER((X).row, (X).col, (Y).row, (Y).col)
+    ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)
 #define ROWCOL_IS_BEFORE(X, Y)                                          \
-    ROW_AND_COL_IS_BEFORE((X).row, (X).col, (Y).row, (Y).col)
+    ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
 #define ROWCOL_IN_ROW_AFTER(X, Y)                                       \
-    ROW_AND_COL_IN_ROW_AFTER((X).row, (X).col, (Y).row, (Y).col)
+    ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)
 #define ROWCOL_IN_ROW_BEFORE(X, Y)                                      \
-    ROW_AND_COL_IN_ROW_BEFORE((X).row, (X).col, (Y).row, (Y).col)
+    ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
 #define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y)                                 \
-    ROW_AND_COL_IN_ROW_AT_OR_AFTER((X).row, (X).col, (Y).row, (Y).col)
+    ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)
 #define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y)                                \
-    ROW_AND_COL_IN_ROW_AT_OR_BEFORE((X).row, (X).col, (Y).row, (Y).col)
+    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      TermWin.vt
 #define CLEAR_ROWS(row, num)                                            \
     if (TermWin.mapped)                                              \
         XClearArea (display->display, drawBuffer, TermWin.int_bwidth,      \
-                    Row2Pixel(row), (unsigned int)TermWin.width,      \
+                    Row2Pixel (row), (unsigned int)TermWin.width,      \
-                    (unsigned int)Height2Pixel(num), False)
+                    (unsigned int)Height2Pixel (num), False)
 #define CLEAR_CHARS(x, y, num)                                          \
     if (TermWin.mapped)                                              \
         XClearArea (display->display, drawBuffer, x, y,                       \
-                    (unsigned int)Width2Pixel(num),                      \
+                    (unsigned int)Width2Pixel (num),                      \
-                    (unsigned int)Height2Pixel(1), False)
+                    (unsigned int)Height2Pixel (1), False)
 #define ERASE_ROWS(row, num)                                            \
     XFillRectangle (display->display, drawBuffer, TermWin.gc,              \
-                    TermWin.int_bwidth, Row2Pixel(row),               \
+                    TermWin.int_bwidth, Row2Pixel (row),               \
                     (unsigned int)TermWin.width,                      \
-                    (unsigned int)Height2Pixel(num))
+                    (unsigned int)Height2Pixel (num))
 /* ------------------------------------------------------------------------- *
  *                        SCREEN `COMMON' ROUTINES                           *
  * ------------------------------------------------------------------------- */
 /* Fill part/all of a line with blanks. */
 /* Fill a full line with blanks - make sure it is allocated first */
 void
 rxvt_term::scr_blank_screen_mem (text_t **tp, rend_t **rp, unsigned int row, rend_t efs)
 {
 #ifdef DEBUG_STRICT
-  assert((tp[row] && rp[row]) || (tp[row] == NULL && rp[row] == NULL));
+  assert ((tp[row] && rp[row]) || (tp[row] == NULL && rp[row] == NULL));
 #endif
   if (tp[row] == NULL)
     {
       tp[row] = (text_t *)talloc->alloc ();
       rp[row] = (rend_t *)ralloc->alloc ();
   unsigned int ncol, nrow, total_rows, prev_total_rows;
   unsigned int p, q;
   int k;
   rend_t setrstyle;
-  D_SCREEN((stderr, "rxvt_scr_reset()"));
+  D_SCREEN ((stderr, "rxvt_scr_reset ()"));
   TermWin.view_start = 0;
   num_scr = 0;
   if (TermWin.ncol == 0)
     {
       /*
        * 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
        */
-      screen.text = (text_t **)rxvt_calloc(total_rows, sizeof(text_t *));
+      screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
-      buf_text = (text_t **)rxvt_calloc(total_rows, sizeof(text_t *));
+      buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
-      drawn_text = (text_t **)rxvt_calloc(nrow, sizeof(text_t *));
+      drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
-      swap.text = (text_t **)rxvt_calloc(nrow, sizeof(text_t *));
+      swap.text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
-      screen.tlen = (int16_t *)rxvt_calloc(total_rows, sizeof(int16_t));
+      screen.tlen = (int16_t *)rxvt_calloc (total_rows, sizeof (int16_t));
-      swap.tlen = (int16_t *)rxvt_calloc(nrow, sizeof(int16_t));
+      swap.tlen = (int16_t *)rxvt_calloc (nrow, sizeof (int16_t));
-      screen.rend = (rend_t **)rxvt_calloc(total_rows, sizeof(rend_t *));
+      screen.rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
-      buf_rend = (rend_t **)rxvt_calloc(total_rows, sizeof(rend_t *));
+      buf_rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
-      drawn_rend = (rend_t **)rxvt_calloc(nrow, sizeof(rend_t *));
+      drawn_rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
-      swap.rend = (rend_t **)rxvt_calloc(nrow, sizeof(rend_t *));
+      swap.rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
       for (p = 0; p < nrow; p++)
         {
           q = p + TermWin.saveLines;
           scr_blank_screen_mem (screen.text, screen.rend, q, DEFAULT_RSTYLE);
           scr_blank_screen_mem (swap.text, swap.rend, p, DEFAULT_RSTYLE);
           screen.tlen[q] = swap.tlen[p] = 0;
           scr_blank_screen_mem (drawn_text, drawn_rend, p, DEFAULT_RSTYLE);
         }
-      MEMSET(charsets, 'B', sizeof(charsets));
+      MEMSET (charsets, 'B', sizeof (charsets));
       TermWin.nscrolled = 0;       /* no saved lines */
       rstyle = DEFAULT_RSTYLE;
       screen.flags = Screen_DefaultFlags;
       screen.cur.row = screen.cur.col = 0;
       screen.charset = 0;
               screen.cur.row += k;
               screen.s_cur.row += k;
               TermWin.nscrolled -= k;
             }
 #ifdef DEBUG_STRICT
-          assert(screen.cur.row < TermWin.nrow);
+          assert (screen.cur.row < TermWin.nrow);
-          assert(swap.cur.row < TermWin.nrow);
+          assert (swap.cur.row < TermWin.nrow);
 #else                           /* drive with your eyes closed */
-          MIN_IT(screen.cur.row, nrow - 1);
+          MIN_IT (screen.cur.row, nrow - 1);
-          MIN_IT(swap.cur.row, nrow - 1);
+          MIN_IT (swap.cur.row, nrow - 1);
 #endif
           TermWin.ncol =  ncol; // save b/c scr_blank_screen_mem uses this
         }
       /* resize columns */
               if (screen.text[p])
                 {
                   text_t *t = (text_t *)ta->alloc (); memcpy (t, screen.text[p], common * sizeof (text_t)); screen.text[p] = t;
                   rend_t *r = (rend_t *)ra->alloc (); memcpy (r, screen.rend[p], common * sizeof (rend_t)); screen.rend[p] = r;
-                  MIN_IT(screen.tlen[p], (int16_t)ncol);
+                  MIN_IT (screen.tlen[p], (int16_t)ncol);
                   if (ncol > prev_ncol)
-                    scr_blank_line (&(screen.text[p][prev_ncol]),
+                    scr_blank_line (& (screen.text[p][prev_ncol]),
-                                    &(screen.rend[p][prev_ncol]),
+                                    & (screen.rend[p][prev_ncol]),
                                     ncol - prev_ncol,
                                     setrstyle);
                 }
             }
             {
               text_t *t = (text_t *)ta->alloc (); memcpy (t, drawn_text[p], common * sizeof (text_t)); drawn_text[p] = t;
               rend_t *r = (rend_t *)ra->alloc (); memcpy (r, drawn_rend[p], common * sizeof (rend_t)); drawn_rend[p] = r;
               if (ncol > prev_ncol)
-                scr_blank_line (&(drawn_text[p][prev_ncol]),
+                scr_blank_line (& (drawn_text[p][prev_ncol]),
-                                &(drawn_rend[p][prev_ncol]),
+                                & (drawn_rend[p][prev_ncol]),
                                 ncol - prev_ncol, setrstyle);
               if (swap.text[p])
                 {
                   text_t *t = (text_t *)ta->alloc (); memcpy (t, swap.text[p], common * sizeof (text_t)); swap.text[p] = t;
                   rend_t *r = (rend_t *)ra->alloc (); memcpy (r, swap.rend[p], common * sizeof (rend_t)); swap.rend[p] = r;
-                  MIN_IT(swap.tlen[p], (int16_t)ncol);
+                  MIN_IT (swap.tlen[p], (int16_t)ncol);
                   if (ncol > prev_ncol)
-                    scr_blank_line (&(swap.text[p][prev_ncol]),
+                    scr_blank_line (& (swap.text[p][prev_ncol]),
-                                    &(swap.rend[p][prev_ncol]),
+                                    & (swap.rend[p][prev_ncol]),
                                     ncol - prev_ncol, setrstyle);
                 }
             }
           delete talloc; talloc = ta;
           delete ralloc; ralloc = ra;
         }
       if (tabs)
-        free(tabs);
+        free (tabs);
     }
   prev_nrow = nrow;
   prev_ncol = ncol;
-  tabs = (char *)rxvt_malloc (ncol * sizeof(char));
+  tabs = (char *)rxvt_malloc (ncol * sizeof (char));
   for (p = 0; p < ncol; p++)
     tabs[p] = (p % TABSIZE == 0) ? 1 : 0;
   tt_winch ();
 }
 void
-rxvt_term::scr_reset_realloc()
+rxvt_term::scr_reset_realloc ()
 {
   uint16_t total_rows, nrow;
   nrow = TermWin.nrow;
   total_rows = nrow + TermWin.saveLines;
   /* *INDENT-OFF* */
-  screen.text = (text_t **)rxvt_realloc(screen.text, total_rows * sizeof(text_t *));
+  screen.text = (text_t **)rxvt_realloc (screen.text, total_rows * sizeof (text_t *));
-  buf_text    = (text_t **)rxvt_realloc(buf_text   , total_rows * sizeof(text_t *));
+  buf_text    = (text_t **)rxvt_realloc (buf_text   , total_rows * sizeof (text_t *));
-  drawn_text  = (text_t **)rxvt_realloc(drawn_text , nrow       * sizeof(text_t *));
+  drawn_text  = (text_t **)rxvt_realloc (drawn_text , nrow       * sizeof (text_t *));
-  swap.text   = (text_t **)rxvt_realloc(swap.text  , nrow       * sizeof(text_t *));
+  swap.text   = (text_t **)rxvt_realloc (swap.text  , nrow       * sizeof (text_t *));
-  screen.tlen = (int16_t *)rxvt_realloc(screen.tlen, total_rows * sizeof(int16_t));
+  screen.tlen = (int16_t *)rxvt_realloc (screen.tlen, total_rows * sizeof (int16_t));
-  swap.tlen   = (int16_t *)rxvt_realloc(swap.tlen  , total_rows * sizeof(int16_t));
+  swap.tlen   = (int16_t *)rxvt_realloc (swap.tlen  , total_rows * sizeof (int16_t));
-  screen.rend = (rend_t **)rxvt_realloc(screen.rend, total_rows * sizeof(rend_t *));
+  screen.rend = (rend_t **)rxvt_realloc (screen.rend, total_rows * sizeof (rend_t *));
-  buf_rend    = (rend_t **)rxvt_realloc(buf_rend   , total_rows * sizeof(rend_t *));
+  buf_rend    = (rend_t **)rxvt_realloc (buf_rend   , total_rows * sizeof (rend_t *));
-  drawn_rend  = (rend_t **)rxvt_realloc(drawn_rend , nrow       * sizeof(rend_t *));
+  drawn_rend  = (rend_t **)rxvt_realloc (drawn_rend , nrow       * sizeof (rend_t *));
-  swap.rend   = (rend_t **)rxvt_realloc(swap.rend  , nrow       * sizeof(rend_t *));
+  swap.rend   = (rend_t **)rxvt_realloc (swap.rend  , nrow       * sizeof (rend_t *));
   /* *INDENT-ON* */
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Free everything.  That way malloc debugging can find leakage.
  */
 void
-rxvt_term::scr_release()
+rxvt_term::scr_release ()
 {
   uint16_t total_rows;
   int i;
   total_rows = TermWin.nrow + TermWin.saveLines;
 #ifdef DEBUG_STRICT
   for (i = 0; i < total_rows; i++)
     {
       if (screen.text[i])
         /* then so is screen.rend[i] */
-        assert(screen.rend[i]);
+        assert (screen.rend[i]);
     }
 #endif
   delete talloc; talloc = 0;
   delete ralloc; ralloc = 0;
  * Hard reset
  */
 void
 rxvt_term::scr_poweron ()
 {
-  D_SCREEN((stderr, "rxvt_scr_poweron()"));
+  D_SCREEN ((stderr, "rxvt_scr_poweron ()"));
   scr_release ();
   prev_nrow = prev_ncol = 0;
   scr_reset ();
   scr_clear ();
   scr_refresh (SLOW_REFRESH);
-#ifdef RXVT_GRAPHICS
-  Gr_reset ();
-#endif
 }
 /* ------------------------------------------------------------------------- *
  *                         PROCESS SCREEN COMMANDS                           *
  * ------------------------------------------------------------------------- */
 void
 rxvt_term::scr_cursor (int mode)
 {
   screen_t       *s;
-  D_SCREEN((stderr, "rxvt_scr_cursor(%c)", mode));
+  D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));
 #if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
   if (current_screen == SECONDARY)
-    s = &(swap);
+    s = & (swap);
   else
 #endif
-    s = &(screen);
+    s = & (screen);
   switch (mode)
     {
       case SAVE:
         s->s_cur.row = s->cur.row;
         s->s_cur.col = s->cur.col;
         charsets[s->charset] = s->s_charset_char;
         set_font_style ();
         break;
     }
   /* boundary check in case screen size changed between SAVE and RESTORE */
-  MIN_IT(s->cur.row, TermWin.nrow - 1);
+  MIN_IT (s->cur.row, TermWin.nrow - 1);
-  MIN_IT(s->cur.col, TermWin.ncol - 1);
+  MIN_IT (s->cur.col, TermWin.ncol - 1);
 #ifdef DEBUG_STRICT
-  assert(s->cur.row >= 0);
+  assert (s->cur.row >= 0);
-  assert(s->cur.col >= 0);
+  assert (s->cur.col >= 0);
 #else                           /* drive with your eyes closed */
-  MAX_IT(s->cur.row, 0);
+  MAX_IT (s->cur.row, 0);
-  MAX_IT(s->cur.col, 0);
+  MAX_IT (s->cur.col, 0);
 #endif
 }
 /* ------------------------------------------------------------------------- */
 /*
   int             offset;
 #endif
   want_refresh = 1;
-  D_SCREEN((stderr, "rxvt_scr_change_screen(%d)", scrn));
+  D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));
   TermWin.view_start = 0;
   if (current_screen == scrn)
     return current_screen;
   selection_check (2);        /* check for boundary cross */
-  SWAP_IT(current_screen, scrn, int);
+  SWAP_IT (current_screen, scrn, int);
 #if NSCREENS
   num_scr = 0;
   offset = TermWin.saveLines;
   for (i = prev_nrow; i--;)
     {
-      SWAP_IT(screen.text[i + offset], swap.text[i], text_t *);
+      SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);
-      SWAP_IT(screen.tlen[i + offset], swap.tlen[i], int16_t);
+      SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);
-      SWAP_IT(screen.rend[i + offset], swap.rend[i], rend_t *);
+      SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);
     }
-  SWAP_IT(screen.cur.row, swap.cur.row, int16_t);
+  SWAP_IT (screen.cur.row, swap.cur.row, int16_t);
-  SWAP_IT(screen.cur.col, swap.cur.col, int16_t);
+  SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
 # ifdef DEBUG_STRICT
-  assert((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));
+  assert ((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));
-  assert((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));
+  assert ((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));
 # else                          /* drive with your eyes closed */
-  MAX_IT(screen.cur.row, 0);
+  MAX_IT (screen.cur.row, 0);
-  MIN_IT(screen.cur.row, (int32_t)prev_nrow - 1);
+  MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
-  MAX_IT(screen.cur.col, 0);
+  MAX_IT (screen.cur.col, 0);
-  MIN_IT(screen.cur.col, (int32_t)prev_ncol - 1);
+  MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
 # endif
-  SWAP_IT(screen.charset, swap.charset, int16_t);
+  SWAP_IT (screen.charset, swap.charset, int16_t);
-  SWAP_IT(screen.flags, swap.flags, int);
+  SWAP_IT (screen.flags, swap.flags, int);
   screen.flags |= Screen_VisibleCursor;
   swap.flags |= Screen_VisibleCursor;
-# ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    {
-      Gr_scroll (0);
-      Gr_ChangeScreen ();
-    }
-# endif
 #else
 # ifdef SCROLL_ON_NO_SECONDARY
-#  ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_ClearScreen ();
-#  endif
-  if (current_screen == PRIMARY
+  if (current_screen == PRIMARY)
-#  ifdef RXVT_GRAPHICS
-      && !Gr_Displayed ()
-#  endif
-     )
-    scr_scroll_text(0, (prev_nrow - 1), prev_nrow, 0);
+    scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);
 # endif
 #endif
   return scrn;
 }
 void
 rxvt_term::scr_color (unsigned int color, int fgbg)
 {
   color &= RS_fgMask;
   if (fgbg == Color_fg)
-    rstyle = SET_FGCOLOR(rstyle, color);
+    rstyle = SET_FGCOLOR (rstyle, color);
   else
-    rstyle = SET_BGCOLOR(rstyle, color);
+    rstyle = SET_BGCOLOR (rstyle, color);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Change the rendition style for following text
   if (count == 0 || (row1 > row2))
     return 0;
   want_refresh = 1;
-  D_SCREEN((stderr, "rxvt_scroll_text(%d,%d,%d,%d): %s", row1, row2, count, spec, (current_screen == PRIMARY) ? "Primary" : "Secondary"));
+  D_SCREEN ((stderr, "rxvt_scroll_text (%d,%d,%d,%d): %s", row1, row2, count, spec, (current_screen == PRIMARY) ? "Primary" : "Secondary"));
   if ((count > 0) && (row1 == 0) && (current_screen == PRIMARY))
     {
       nscrolled = (long)TermWin.nscrolled + (long)count;
   if (count < 0)
     count = -count;
   i = row2 - row1 + 1;
-  MIN_IT(count, i);
+  MIN_IT (count, i);
   if (j > 0)
     {
       /* A: scroll up */
       if (!spec)              /* line length may not equal TermWin.ncol */
         scr_blank_screen_mem (screen.text, screen.rend,
                               (unsigned int)j, rstyle);
     }
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (count);
-#endif
   return count;
 }
 /* ------------------------------------------------------------------------- */
     return;
   want_refresh = 1;
   last_col = TermWin.ncol;
-  D_SCREEN((stderr, "rxvt_scr_add_lines(%d,%d)", nlines, len));
+  D_SCREEN ((stderr, "rxvt_scr_add_lines (%d,%d)", nlines, len));
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
   if (nlines > 0)
     {
       nlines += (screen.cur.row - screen.bscroll);
       if ((nlines > 0)
           && (screen.tscroll == 0)
           && (screen.bscroll == (TermWin.nrow - 1)))
         {
           /* _at least_ this many lines need to be scrolled */
-          scr_scroll_text(screen.tscroll, screen.bscroll, nlines, 0);
+          scr_scroll_text (screen.tscroll, screen.bscroll, nlines, 0);
           screen.cur.row -= nlines;
         }
     }
 #ifdef DEBUG_STRICT
-  assert(screen.cur.col < last_col);
+  assert (screen.cur.col < last_col);
-  assert((screen.cur.row < TermWin.nrow)
+  assert ((screen.cur.row < TermWin.nrow)
-         && (screen.cur.row >= -(int32_t)TermWin.nscrolled));
+         && (screen.cur.row >= - (int32_t)TermWin.nscrolled));
 #else                           /* drive with your eyes closed */
-  MIN_IT(screen.cur.col, last_col - 1);
+  MIN_IT (screen.cur.col, last_col - 1);
-  MIN_IT(screen.cur.row, (int32_t)TermWin.nrow - 1);
+  MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
-  MAX_IT(screen.cur.row, -(int32_t)TermWin.nscrolled);
+  MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
 #endif
   row = screen.cur.row + TermWin.saveLines;
   checksel = (selection.op
               && current_screen == selection.screen) ? 1 : 0;
           case '\t':
             scr_tab (1);
             continue;
           case '\n':
             if (screen.tlen[row] != -1)      /* XXX: think about this */
-              MAX_IT(screen.tlen[row], screen.cur.col);
+              MAX_IT (screen.tlen[row], screen.cur.col);
             screen.flags &= ~Screen_WrapNext;
             if (screen.cur.row == screen.bscroll)
               scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
             else if (screen.cur.row < (TermWin.nrow - 1))
               row = (++screen.cur.row) + TermWin.saveLines;
             stp = screen.text[row];  /* _must_ refresh */
             srp = screen.rend[row];  /* _must_ refresh */
             continue;
           case '\r':
             if (screen.tlen[row] != -1)      /* XXX: think about this */
-              MAX_IT(screen.tlen[row], screen.cur.col);
+              MAX_IT (screen.tlen[row], screen.cur.col);
             screen.flags &= ~Screen_WrapNext;
             screen.cur.col = 0;
             continue;
           default:
             if (c == 127)
               continue;       /* yummmm..... */
             break;
         }
       if (checksel            /* see if we're writing within selection */
-          && !ROWCOL_IS_BEFORE(screen.cur, selection.beg)
+          && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
-          && ROWCOL_IS_BEFORE(screen.cur, selection.end))
+          && ROWCOL_IS_BEFORE (screen.cur, selection.end))
         {
           checksel = 0;
           clearsel = 1;
         }
       if (screen.flags & Screen_WrapNext)
         {
           screen.tlen[row] = -1;
           if (screen.cur.row == screen.bscroll)
-            scr_scroll_text(screen.tscroll, screen.bscroll, 1, 0);
+            scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
           else if (screen.cur.row < (TermWin.nrow - 1))
             row = (++screen.cur.row) + TermWin.saveLines;
           stp = screen.text[row];  /* _must_ refresh */
           srp = screen.rend[row];  /* _must_ refresh */
           screen.cur.col = 0;
         scr_insdel_chars (1, INSERT);
       if (charsets[screen.charset] == '0') // DEC SPECIAL
         switch (c)
           {
+            // dunno where these come from
+#if 0
             case '+': c = 0x2192; break; case ',': c = 0x2190; break; case '-': c = 0x2191; break;
-            case '.': c = 0x2193; break; case '0': c = 0x25ae; break; case '`': c = 0x25c6; break;
+            case '.': c = 0x2193; break; case '0': c = 0x25ae; break;
+#endif
+            // vt100 special graphics and line drawing
+            case '`': c = 0x25c6; break; case '_': c = 0x0020; break;
-            case 'a': c = 0x2592; break; case 'f': c = 0x00b0; break; case 'g': c = 0x00b1; break;
+            case 'a': c = 0x2592; break; case 'b': c = 0x2409; break; case 'c': c = 0x240c; break;
-            case 'h': c = 0x2592; break; case 'i': c = 0x2603; break; case 'j': c = 0x2518; break;
-            case 'k': c = 0x2510; break; case 'l': c = 0x250c; break; case 'm': c = 0x2514; break;
+            case 'd': c = 0x240d; break; case 'e': c = 0x240a; break; case 'f': c = 0x00b0; break;
+            case 'g': c = 0x00b1; break; case 'h': c = 0x2424; break; case 'i': c = 0x240b; break;
-            case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break; case 'p': c = 0x23bb; break;
+            case 'j': c = 0x2518; break; case 'k': c = 0x2510; break; case 'l': c = 0x250c; break;
-            case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break; case 's': c = 0x23bd; break;
+            case 'm': c = 0x2514; break; case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break;
-            case 't': c = 0x251c; break; case 'u': c = 0x2524; break; case 'v': c = 0x2534; break;
+            case 'p': c = 0x23bb; break; case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break;
-            case 'w': c = 0x252c; break; case 'x': c = 0x2502; break; case 'y': c = 0x2264; break;
+            case 's': c = 0x23bd; break; case 't': c = 0x251c; break; case 'u': c = 0x2524; break;
-            case 'z': c = 0x2265; break; case '{': c = 0x03c0; break; case '|': c = 0x2260; break;
+            case 'v': c = 0x2534; break; case 'w': c = 0x252c; break; case 'x': c = 0x2502; break;
+            case 'y': c = 0x2264; break; case 'z': c = 0x2265; break; case '{': c = 0x03c0; break;
-            case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
+            case '|': c = 0x2260; break; case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
           }
       rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));
       // rely on wcwidth to tell us the character width, at least for non-ascii
       int width = c <= 128 ? 1 : wcwidth (c);
       else
         (void)0; /* handle combining character etc. here. */
     }
   if (screen.tlen[row] != -1)      /* XXX: think about this */
-    MAX_IT(screen.tlen[row], screen.cur.col);
+    MAX_IT (screen.tlen[row], screen.cur.col);
   /*
    * If we wrote anywhere in the selected area, kill the selection
    * XXX: should we kill the mark too?  Possibly, but maybe that
    *      should be a similar check.
    */
   if (clearsel)
-    CLEAR_SELECTION();
+    CLEAR_SELECTION ();
 #ifdef DEBUG_STRICT
-  assert(screen.cur.row >= 0);
+  assert (screen.cur.row >= 0);
 #else                           /* drive with your eyes closed */
-  MAX_IT(screen.cur.row, 0);
+  MAX_IT (screen.cur.row, 0);
 #endif
 }
 /* ------------------------------------------------------------------------- */
 /*
 void
 rxvt_term::scr_tab (int count)
 {
   int             i, x;
-  D_SCREEN((stderr, "rxvt_scr_tab(%d)", count));
+  D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));
   want_refresh = 1;
   i = x = screen.cur.col;
   if (count == 0)
     return;
   else if (count > 0)
  */
 void
 rxvt_term::scr_gotorc (int row, int col, int relative)
 {
   want_refresh = 1;
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (0);
-#endif
-  D_SCREEN((stderr, "rxvt_scr_gotorc(r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));
+  D_SCREEN ((stderr, "rxvt_scr_gotorc (r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));
   screen.cur.col = ((relative & C_RELATIVE) ? (screen.cur.col + col)
                     : col);
-  MAX_IT(screen.cur.col, 0);
+  MAX_IT (screen.cur.col, 0);
-  MIN_IT(screen.cur.col, (int32_t)TermWin.ncol - 1);
+  MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);
   screen.flags &= ~Screen_WrapNext;
   if (relative & R_RELATIVE)
     {
       if (row > 0)
   else
     {
       if (screen.flags & Screen_Relative)
         {        /* relative origin mode */
           screen.cur.row = row + screen.tscroll;
-          MIN_IT(screen.cur.row, screen.bscroll);
+          MIN_IT (screen.cur.row, screen.bscroll);
         }
       else
         screen.cur.row = row;
     }
-  MAX_IT(screen.cur.row, 0);
+  MAX_IT (screen.cur.row, 0);
-  MIN_IT(screen.cur.row, (int32_t)TermWin.nrow - 1);
+  MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * direction  should be UP or DN
 {
   int             dirn;
   want_refresh = 1;
   dirn = ((direction == UP) ? 1 : -1);
-  D_SCREEN((stderr, "rxvt_scr_index(%d)", dirn));
+  D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (0);
-#endif
   screen.flags &= ~Screen_WrapNext;
   if ((screen.cur.row == screen.bscroll && direction == UP)
       || (screen.cur.row == screen.tscroll && direction == DN))
-    scr_scroll_text(screen.tscroll, screen.bscroll, dirn, 0);
+    scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);
   else
     screen.cur.row += dirn;
-  MAX_IT(screen.cur.row, 0);
+  MAX_IT (screen.cur.row, 0);
-  MIN_IT(screen.cur.row, (int32_t)TermWin.nrow - 1);
+  MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
   selection_check (0);
 }
 /* ------------------------------------------------------------------------- */
 /*
 rxvt_term::scr_erase_line (int mode)
 {
   unsigned int row, col, num;
   want_refresh = 1;
-  D_SCREEN((stderr, "rxvt_scr_erase_line(%d) at screen row: %d", mode, screen.cur.row));
+  D_SCREEN ((stderr, "rxvt_scr_erase_line (%d) at screen row: %d", mode, screen.cur.row));
   ZERO_SCROLLBACK ();
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (0);
-#endif
   selection_check (1);
   screen.flags &= ~Screen_WrapNext;
   switch (mode)
     {
       case 0:                     /* erase to end of line */
         col = screen.cur.col;
         num = TermWin.ncol - col;
-        MIN_IT(screen.tlen[row], (int16_t)col);
+        MIN_IT (screen.tlen[row], (int16_t)col);
-        if (ROWCOL_IN_ROW_AT_OR_AFTER(selection.beg, screen.cur)
+        if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
-            || ROWCOL_IN_ROW_AT_OR_AFTER(selection.end, screen.cur))
+            || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
-          CLEAR_SELECTION();
+          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)
+        if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
-            || ROWCOL_IN_ROW_AT_OR_BEFORE(selection.end, screen.cur))
+            || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
-          CLEAR_SELECTION();
+          CLEAR_SELECTION ();
         break;
       case 2:                     /* erase whole line */
         col = 0;
         num = TermWin.ncol;
         screen.tlen[row] = 0;
         if (selection.beg.row <= screen.cur.row
             && selection.end.row >= screen.cur.row)
-          CLEAR_SELECTION();
+          CLEAR_SELECTION ();
         break;
       default:
         return;
     }
   if (screen.text[row])
-    scr_blank_line (&(screen.text[row][col]),
+    scr_blank_line (& (screen.text[row][col]),
-                    &(screen.rend[row][col]), num, rstyle);
+                    & (screen.rend[row][col]), num, rstyle);
   else
     scr_blank_screen_mem (screen.text, screen.rend, row, rstyle);
 }
 /* ------------------------------------------------------------------------- */
   int32_t         row, row_offset;
   rend_t          ren;
   XGCValues       gcvalue;
   want_refresh = 1;
-  D_SCREEN((stderr, "rxvt_scr_erase_screen(%d) at screen row: %d", mode, screen.cur.row));
+  D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));
   ZERO_SCROLLBACK ();
   row_offset = (int32_t)TermWin.saveLines;
   switch (mode)
     {
         row = 0;
         num = screen.cur.row;
         break;
       case 2:                     /* erase whole screen */
         selection_check (3);
-#ifdef RXVT_GRAPHICS
-        Gr_ClearScreen ();
-#endif
         row = 0;
         num = TermWin.nrow;
         break;
       default:
         return;
           || (selection.end.row >= row
               && selection.end.row <= row + num)))
     CLEAR_SELECTION ();
   if (row >= TermWin.nrow) /* Out Of Bounds */
     return;
-  MIN_IT(num, (TermWin.nrow - row));
+  MIN_IT (num, (TermWin.nrow - row));
   if (rstyle & (RS_RVid | RS_Uline))
     ren = (rend_t) ~RS_None;
-  else if (GET_BASEBG(rstyle) == Color_bg)
+  else if (GET_BASEBG (rstyle) == Color_bg)
     {
       ren = DEFAULT_RSTYLE;
-      CLEAR_ROWS(row, num);
+      CLEAR_ROWS (row, num);
     }
   else
     {
       ren = (rstyle & (RS_fgMask | RS_bgMask));
-      gcvalue.foreground = PixColors[GET_BGCOLOR(rstyle)];
+      gcvalue.foreground = PixColors[GET_BGCOLOR (rstyle)];
-      XChangeGC(display->display, TermWin.gc, GCForeground, &gcvalue);
+      XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
-      ERASE_ROWS(row, num);
+      ERASE_ROWS (row, num);
       gcvalue.foreground = PixColors[Color_fg];
-      XChangeGC(display->display, TermWin.gc, GCForeground, &gcvalue);
+      XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
     }
   for (; num--; row++)
     {
       scr_blank_screen_mem (screen.text, screen.rend,
-                            (unsigned int)(row + row_offset), rstyle);
+                            (unsigned int) (row + row_offset), rstyle);
       screen.tlen[row + row_offset] = 0;
       scr_blank_line (drawn_text[row], drawn_rend[row],
                       (unsigned int)TermWin.ncol, ren);
     }
 }
   int             i, j, k;
   rend_t         *r1, fs;
   want_refresh = 1;
   num_scr_allow = 0;
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
   selection_check (3);
   fs = SET_FONT (rstyle, TermWin.fontset->find_font ('E'));
   for (k = TermWin.saveLines, i = TermWin.nrow; i--; k++)
     {
 void
 rxvt_term::scr_insdel_lines (int count, int insdel)
 {
   int             end;
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (0);
-#endif
   selection_check (1);
   if (screen.cur.row > screen.bscroll)
     return;
       else if (insdel == INSERT)
         count = end;
     }
   screen.flags &= ~Screen_WrapNext;
-  scr_scroll_text(screen.cur.row, screen.bscroll, insdel * count, 0);
+  scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count, 0);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Insert/Delete <count> characters from the current position
   text_t         *stp;
   rend_t         *srp;
   int16_t        *slp;
   want_refresh = 1;
-  ZERO_SCROLLBACK();
+  ZERO_SCROLLBACK ();
-#ifdef RXVT_GRAPHICS
-  if (Gr_Displayed ())
-    Gr_scroll (0);
-#endif
   if (count <= 0)
     return;
   selection_check (1);
-  MIN_IT(count, (TermWin.ncol - screen.cur.col));
+  MIN_IT (count, (TermWin.ncol - screen.cur.col));
   row = screen.cur.row + TermWin.saveLines;
   screen.flags &= ~Screen_WrapNext;
   stp = screen.text[row];
   srp = screen.rend[row];
-  slp = &(screen.tlen[row]);
+  slp = & (screen.tlen[row]);
   switch (insdel)
     {
       case INSERT:
         for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
              col--)
             srp[col] = srp[col - count];
           }
         if (*slp != -1)
           {
             *slp += count;
-            MIN_IT(*slp, TermWin.ncol);
+            MIN_IT (*slp, TermWin.ncol);
           }
         if (selection.op && current_screen == selection.screen
-            && ROWCOL_IN_ROW_AT_OR_AFTER(selection.beg, screen.cur))
+            && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
             if (selection.end.row != screen.cur.row
                 || (selection.end.col + count >= TermWin.ncol))
-              CLEAR_SELECTION();
+              CLEAR_SELECTION ();
             else
               {              /* shift selection */
                 selection.beg.col += count;
                 selection.mark.col += count; /* XXX: yes? */
                 selection.end.col += count;
               }
           }
-        scr_blank_line (&(stp[screen.cur.col]), &(srp[screen.cur.col]),
+        scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
                         (unsigned int)count, rstyle);
         break;
       case ERASE:
         screen.cur.col += count;     /* don't worry if > TermWin.ncol */
         selection_check (1);
         screen.cur.col -= count;
-        scr_blank_line (&(stp[screen.cur.col]), &(srp[screen.cur.col]),
+        scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
                         (unsigned int)count, rstyle);
         break;
       case DELETE:
         tr = srp[TermWin.ncol - 1]
              & (RS_fgMask | RS_bgMask | RS_baseattrMask);
         for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
           {
             stp[col] = stp[col + count];
             srp[col] = srp[col + count];
           }
-        scr_blank_line (&(stp[TermWin.ncol - count]),
+        scr_blank_line (& (stp[TermWin.ncol - count]),
-                        &(srp[TermWin.ncol - count]),
+                        & (srp[TermWin.ncol - count]),
                         (unsigned int)count, tr);
         if (*slp == -1) /* break line continuation */
           *slp = TermWin.ncol;
         *slp -= count;
-        MAX_IT(*slp, 0);
+        MAX_IT (*slp, 0);
         if (selection.op && current_screen == selection.screen
-            && ROWCOL_IN_ROW_AT_OR_AFTER(selection.beg, screen.cur))
+            && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
             if (selection.end.row != screen.cur.row
                 || (screen.cur.col >= selection.beg.col - count)
                 || selection.end.col >= TermWin.ncol)
-              CLEAR_SELECTION();
+              CLEAR_SELECTION ();
             else
               {
                 /* shift selection */
                 selection.beg.col -= count;
                 selection.mark.col -= count; /* XXX: yes? */
  * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
  */
 void
 rxvt_term::scr_scroll_region (int top, int bot)
 {
-  MAX_IT(top, 0);
+  MAX_IT (top, 0);
-  MIN_IT(bot, (int)TermWin.nrow - 1);
+  MIN_IT (bot, (int)TermWin.nrow - 1);
   if (top > bot)
     return;
   screen.tscroll = top;
   screen.bscroll = bot;
   scr_gotorc (0, 0, 0);
 rxvt_term::scr_autowrap (int mode)
 {
   if (mode)
     screen.flags |= Screen_Autowrap;
   else
-    screen.flags &= ~(Screen_Autowrap | Screen_WrapNext);
+    screen.flags &= ~ (Screen_Autowrap | Screen_WrapNext);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Set/unset margin origin mode
  */
 void
 rxvt_term::scr_set_tab (int mode)
 {
   if (mode < 0)
-    MEMSET(tabs, 0, TermWin.ncol * sizeof(char));
+    MEMSET (tabs, 0, TermWin.ncol * sizeof (char));
   else if (screen.cur.col < TermWin.ncol)
     tabs[screen.cur.col] = (mode ? 1 : 0);
 }
 /* ------------------------------------------------------------------------- */
   XGCValues       gcvalue;
   if (rvideo != mode)
     {
       rvideo = mode;
-      SWAP_IT(PixColors[Color_fg], PixColors[Color_bg], rxvt_color);
+      SWAP_IT (PixColors[Color_fg], PixColors[Color_bg], rxvt_color);
 #if defined(XPM_BACKGROUND)
       if (bgPixmap.pixmap == None)
 #endif
 #if defined(TRANSPARENT)
-        if (!(Options & Opt_transparent) || am_transparent == 0)
+        if (! (Options & Opt_transparent) || am_transparent == 0)
 #endif
-          XSetWindowBackground(display->display, TermWin.vt,
+          XSetWindowBackground (display->display, TermWin.vt,
                                PixColors[Color_bg]);
       gcvalue.foreground = PixColors[Color_fg];
       gcvalue.background = PixColors[Color_bg];
-      XChangeGC(display->display, TermWin.gc, GCBackground | GCForeground,
+      XChangeGC (display->display, TermWin.gc, GCBackground | GCForeground,
                 &gcvalue);
       scr_clear ();
       scr_touch (true);
     }
 }
  * XTERM_SEQ: Report position: ESC [ 6 n
  */
 void
 rxvt_term::scr_report_position ()
 {
-  tt_printf("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
+  tt_printf ("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
 }
 /* ------------------------------------------------------------------------- *
  *                                  FONTS                                    *
  * ------------------------------------------------------------------------- */
   if (drawn_text == NULL)  /* sanity check */
     return;
 #ifdef DEBUG_STRICT
-  x = max(x, (int)TermWin.int_bwidth);
+  x = max (x, (int)TermWin.int_bwidth);
-  x = min(x, (int)TermWin.width);
+  x = min (x, (int)TermWin.width);
-  y = max(y, (int)TermWin.int_bwidth);
+  y = max (y, (int)TermWin.int_bwidth);
-  y = min(y, (int)TermWin.height);
+  y = min (y, (int)TermWin.height);
 #endif
   /* round down */
-  rc[PART_BEG].col = Pixel2Col(x);
+  rc[PART_BEG].col = Pixel2Col (x);
-  rc[PART_BEG].row = Pixel2Row(y);
+  rc[PART_BEG].row = Pixel2Row (y);
   /* round up */
-  rc[PART_END].col = Pixel2Width(x + width + TermWin.fwidth - 1);
+  rc[PART_END].col = Pixel2Width (x + width + TermWin.fwidth - 1);
-  rc[PART_END].row = Pixel2Row(y + height + TermWin.fheight - 1);
+  rc[PART_END].row = Pixel2Row (y + height + TermWin.fheight - 1);
   /* sanity checks */
   for (i = PART_BEG; i < RC_COUNT; i++)
     {
-      MIN_IT(rc[i].col, TermWin.ncol - 1);
+      MIN_IT (rc[i].col, TermWin.ncol - 1);
-      MIN_IT(rc[i].row, TermWin.nrow - 1);
+      MIN_IT (rc[i].row, TermWin.nrow - 1);
     }
-  D_SCREEN((stderr, "rxvt_scr_expose(x:%d, y:%d, w:%d, h:%d) area (c:%d,r:%d)-(c:%d,r:%d)", x, y, width, height, rc[PART_BEG].col, rc[PART_BEG].row, rc[PART_END].col, rc[PART_END].row));
+  D_SCREEN ((stderr, "rxvt_scr_expose (x:%d, y:%d, w:%d, h:%d) area (c:%d,r:%d)- (c:%d,r:%d)", x, y, width, height, rc[PART_BEG].col, rc[PART_BEG].row, rc[PART_END].col, rc[PART_END].row));
   for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
-    fill_text (&(drawn_text[i][rc[PART_BEG].col]), 0,
+    fill_text (& (drawn_text[i][rc[PART_BEG].col]), 0,
                (rc[PART_END].col - rc[PART_BEG].col + 1));
   if (refresh)
     scr_refresh (SLOW_REFRESH | REFRESH_BOUNDS);
 }
   oldviewstart = TermWin.view_start;
   if (y < len)
     {
       p = (TermWin.nrow + TermWin.nscrolled) * (len - y) / len;
-      p -= (long)(TermWin.nrow - 1);
+      p -= (long) (TermWin.nrow - 1);
-      p = max(p, 0);
+      p = max (p, 0);
     }
-  TermWin.view_start = (uint16_t)min(p, TermWin.nscrolled);
+  TermWin.view_start = (uint16_t)min (p, TermWin.nscrolled);
-  D_SCREEN((stderr, "rxvt_scr_move_to(%d, %d) view_start:%d", y, len, TermWin.view_start));
+  D_SCREEN ((stderr, "rxvt_scr_move_to (%d, %d) view_start:%d", y, len, TermWin.view_start));
   return scr_changeview (oldviewstart);
 }
 /* ------------------------------------------------------------------------- */
 rxvt_term::scr_page (enum page_dirn direction, int nlines)
 {
   int             n;
   uint16_t       oldviewstart;
-  D_SCREEN((stderr, "rxvt_scr_page(%s, %d) view_start:%d", ((direction == UP) ? "UP" : "DN"), nlines, TermWin.view_start));
+  D_SCREEN ((stderr, "rxvt_scr_page (%s, %d) view_start:%d", ((direction == UP) ? "UP" : "DN"), nlines, TermWin.view_start));
 #ifdef DEBUG_STRICT
-  assert((nlines >= 0) && (nlines <= TermWin.nrow));
+  assert ((nlines >= 0) && (nlines <= TermWin.nrow));
 #endif
   oldviewstart = TermWin.view_start;
   if (direction == UP)
     {
       n = TermWin.view_start + nlines;
-      TermWin.view_start = min(n, TermWin.nscrolled);
+      TermWin.view_start = min (n, TermWin.nscrolled);
     }
   else
     {
       n = TermWin.view_start - nlines;
-      TermWin.view_start = max(n, 0);
+      TermWin.view_start = max (n, 0);
     }
   return scr_changeview (oldviewstart);
 }
 int
 rxvt_term::scr_changeview (uint16_t oldviewstart)
 {
   if (TermWin.view_start != oldviewstart)
     {
       want_refresh = 1;
-#ifdef RXVT_GRAPHICS
-      if (Gr_Displayed ())
-        Gr_scroll (0);
-#endif
       num_scr -= (TermWin.view_start - oldviewstart);
     }
-  return (int)(TermWin.view_start - oldviewstart);
+  return (int) (TermWin.view_start - oldviewstart);
 }
 /* ------------------------------------------------------------------------- */
 void
 rxvt_term::scr_bell ()
 #ifndef NO_BELL
 # ifndef NO_MAPALERT
 #  ifdef MAPALERT_OPTION
   if (Options & Opt_mapAlert)
 #  endif
-    XMapWindow(display->display, TermWin.parent[0]);
+    XMapWindow (display->display, TermWin.parent[0]);
 # endif
   if (Options & Opt_visualBell)
     {
       scr_rvideo_mode (!rvideo); /* refresh also done */
       scr_rvideo_mode (!rvideo); /* refresh also done */
     }
   else
-    XBell(display->display, 0);
+    XBell (display->display, 0);
 #endif
 }
 /* ------------------------------------------------------------------------- */
 /* ARGSUSED */
   for (r1 = 0; r1 < nrows; r1++)
     {
       t = screen.text[r1 + row_offset];
       for (i = TermWin.ncol - 1; i >= 0; i--)
-        if (!isspace(t[i]))
+        if (!isspace (t[i]))
           break;
-      fprintf(fd, "%.*s\n", (i + 1), t);
+      fprintf (fd, "%.*s\n", (i + 1), t);
     }
   pclose_printer (fd);
 #endif
 }
  * drawn_text/drawn_rend contain the screen information before the update.
  * screen.text/screen.rend contain what the screen will change to.
  */
 #define FONT_WIDTH(X, Y)                                                \
-    (X)->per_char[(Y) - (X)->min_char_or_byte2].width
+    (X)->per_char[ (Y) - (X)->min_char_or_byte2].width
 #define FONT_RBEAR(X, Y)                                                \
-    (X)->per_char[(Y) - (X)->min_char_or_byte2].rbearing
+    (X)->per_char[ (Y) - (X)->min_char_or_byte2].rbearing
 #define FONT_LBEAR(X, Y)                                                \
-    (X)->per_char[(Y) - (X)->min_char_or_byte2].lbearing
+    (X)->per_char[ (Y) - (X)->min_char_or_byte2].lbearing
 #define IS_FONT_CHAR(X, Y)                                              \
     ((Y) >= (X)->min_char_or_byte2 && (Y) <= (X)->max_char_or_byte2)
 void
 rxvt_term::scr_refresh (unsigned char refresh_type)
 {
-  unsigned char   clearfirst, /* first character writes before cell        */
+  unsigned char clearfirst, /* first character writes before cell        */
-  clearlast,  /* last character writes beyond cell         */
+                clearlast,  /* last character writes beyond cell         */
-  must_clear, /* use draw_string not draw_image_string     */
+                must_clear, /* use draw_string not draw_image_string     */
-  rvid,       /* reverse video this position               */
+                rvid,       /* reverse video this position               */
-  showcursor; /* show the cursor                           */
+                showcursor; /* show the cursor                           */
-  int16_t         col, row,   /* column/row we're processing               */
+  int16_t col, row,   /* column/row we're processing               */
-  ocrow;      /* old cursor row                            */
+          ocrow;      /* old cursor row                            */
-  int             cursorwidth;
-  int             i,          /* tmp                                       */
+  int i,              /* tmp                                       */
-  row_offset; /* basic offset in screen structure          */
+  row_offset;         /* basic offset in screen structure          */
 #ifndef NO_CURSORCOLOR
-  rend_t          cc1;        /* store colours at cursor position(s)       */
+  rend_t cc1;         /* store colours at cursor position (s)      */
 #endif
-  rend_t         *drp, *srp;  /* drawn-rend-pointer, screen-rend-pointer   */
+  rend_t *drp, *srp;  /* drawn-rend-pointer, screen-rend-pointer   */
-  text_t         *dtp, *stp;  /* drawn-text-pointer, screen-text-pointer   */
+  text_t *dtp, *stp;  /* drawn-text-pointer, screen-text-pointer   */
   if (refresh_type == NO_REFRESH || !TermWin.mapped)
     return;
   /*
    * B: reverse any characters which are selected
    */
   scr_reverse_selection ();
   /*
-   * C: set the cursor character(s)
+   * C: set the cursor character (s)
    */
   {
     unsigned char   setoldcursor;
     rend_t          ccol1,  /* Cursor colour       */
     ccol2;  /* Cursor colour2      */
     showcursor = (screen.flags & Screen_VisibleCursor);
-    cursorwidth = 0;
 #ifdef CURSOR_BLINK
     if (hidden_cursor)
       showcursor = 0;
 #endif
-    cursorwidth = 0;
     if (showcursor)
       {
-        cursorwidth++;
-        srp = &(screen.rend[screen.cur.row + TermWin.saveLines]
+        srp = & (screen.rend[screen.cur.row + TermWin.saveLines]
                 [screen.cur.col]);
         if (showcursor && TermWin.focus)
           {
             *srp ^= RS_RVid;
             cc1 = *srp & (RS_fgMask | RS_bgMask);
             if (ISSET_PIXCOLOR (Color_cursor))
               ccol1 = Color_cursor;
             else
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-              ccol1 = GET_FGCOLOR(rstyle);
+              ccol1 = GET_FGCOLOR (rstyle);
 #else
               ccol1 = Color_fg;
 #endif
             if (ISSET_PIXCOLOR (Color_cursor2))
               ccol2 = Color_cursor2;
             else
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-              ccol2 = GET_BGCOLOR(rstyle);
+              ccol2 = GET_BGCOLOR (rstyle);
 #else
               ccol2 = Color_bg;
 #endif
-            *srp = SET_FGCOLOR(*srp, ccol1);
+            *srp = SET_FGCOLOR (*srp, ccol1);
-            *srp = SET_BGCOLOR(*srp, ccol2);
+            *srp = SET_BGCOLOR (*srp, ccol2);
 #endif
           }
       }
     /* make sure no outline cursor is left around */
     setoldcursor = 0;
    * D: CopyArea pass - very useful for slower links
    *    This has been deliberately kept simple.
    */
   i = num_scr;
   if (refresh_type == FAST_REFRESH && num_scr_allow && i
-      && abs(i) < TermWin.nrow && !must_clear)
+      && abs (i) < TermWin.nrow && !must_clear)
     {
       int16_t         nits;
       int             j;
       rend_t         *drp2;
       text_t         *dtp2;
           if (len != -1)
             {
               /* also comes here at end if needed because of >= above */
               if (wlen < len)
-                SWAP_IT(wlen, len, int);
+                SWAP_IT (wlen, len, int);
-              D_SCREEN((stderr, "rxvt_scr_refresh(): XCopyArea: %d -> %d (height: %d)", len + i, len, wlen - len + 1));
+              D_SCREEN ((stderr, "rxvt_scr_refresh (): XCopyArea: %d -> %d (height: %d)", len + i, len, wlen - len + 1));
               XCopyArea (display->display, TermWin.vt, TermWin.vt,
                          TermWin.gc, 0, Row2Pixel (len + i),
                          (unsigned int)TermWin_TotalWidth (),
                          (unsigned int)Height2Pixel (wlen - len + 1),
                          0, Row2Pixel (len));
       drp = drawn_rend[row];
       /*
        * E2: OK, now the real pass
        */
-      int ypixel = (int)Row2Pixel(row);
+      int ypixel = (int)Row2Pixel (row);
       for (col = 0; col < TermWin.ncol; col++)
         {
           /* compare new text with old - if exactly the same then continue */
           rend_t rend = srp[col];     /* screen rendition (target rendtion) */
           if (stp[col] == dtp[col]    /* Must match characters to skip. */
               && (rend == drp[col]    /* Either rendition the same or   */
                   || (stp[col] == ' ' /* space w/ no background change  */
-                      && GET_BGATTR(rend) == GET_BGATTR(drp[col]))))
+                      && GET_BGATTR (rend) == GET_BGATTR (drp[col]))))
             continue;
           text_t *text = stp + col;
           int count = 1;
           drp[col] = rend;
           if (*text == NOCHAR) // never start redrawing at invisible characters. */
             continue;
-          int xpixel = Col2Pixel(col);
+          int xpixel = Col2Pixel (col);
           // this loop looks very messy, it can probably be optimized
           // and cleaned a bit by you?
           for (i = 0; ++col < TermWin.ncol; )
             {
           int back = GET_BGCOLOR (rend); // desired background
           rend = GET_ATTR (rend);
           rvid = !!(rend & RS_RVid);
+#ifndef NO_BOLD_UNDERLINE_REVERSE
+          if (rend & RS_Bold && fore == Color_fg)
+            {
+              if (ISSET_PIXCOLOR (Color_BD))
+                fore = Color_BD;
+              else
+                rvid = !rvid;
+            }
+          if (rend & RS_Uline)
+            {
+              if (ISSET_PIXCOLOR (Color_UL))
+                fore = Color_UL;
+            }
+#endif
           if (rvid)
             {
-              SWAP_IT(fore, back, int);
+              SWAP_IT (fore, back, int);
 #ifndef NO_BOLD_UNDERLINE_REVERSE
               if (ISSET_PIXCOLOR (Color_RV)
 # ifndef NO_CURSORCOLOR
                   && !ISSET_PIXCOLOR (Color_cursor)
 # endif
                  )
                 back = Color_RV;
 #endif
             }
 #ifdef TEXT_BLINK
-          if (rend & RS_Blink)
+          if (rend & RS_Blink && back == Color_bg)
             {
               if (!text_blink_ev.active)
                 {
                   text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
                   hidden_text = 0;
                 }
               else if (hidden_text)
                 fore = back;
             }
 #endif
-#ifndef NO_BOLD_UNDERLINE_REVERSE
-          else if (rend & RS_Bold)
-            {
-              if (ISSET_PIXCOLOR (Color_BD))
-                fore = Color_BD;
-              else if (fore == Color_fg)
-                fore = Color_White;
-            }
-          else if (rend & RS_Uline)
-            {
-              if (ISSET_PIXCOLOR (Color_UL))
-                fore = Color_UL;
-            }
-#endif
           /*
            * Actually do the drawing of the string here
            */
           rxvt_font *font = (*TermWin.fontset)[fid];
           if (back == fore)
-            font->clear_rect (xpixel, ypixel,
+            font->clear_rect (*TermWin.drawable, xpixel, ypixel,
                               TermWin.fwidth * count, TermWin.fheight,
                               back);
           else if (back == Color_bg)
             {
               if (must_clear)
                   CLEAR_CHARS (xpixel, ypixel, count);
                   for (i = 0; i < count; i++) /* don't draw empty strings */
                     if (text[i] != ' ')
                       {
-                        font->draw (xpixel, ypixel, text, count, fore, -1);
+                        font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, -1);
                         break;
                       }
                 }
               else
-                font->draw (xpixel, ypixel, text, count, fore, Color_bg);
+                font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, Color_bg);
             }
           else
-            font->draw (xpixel, ypixel, text, count, fore, back);
+            font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
           if ((rend & RS_Uline) && (font->descent > 1))
-            XDrawLine(display->display, drawBuffer, TermWin.gc,
+            XDrawLine (display->display, drawBuffer, TermWin.gc,
                       xpixel, ypixel + font->ascent + 1,
-                      xpixel + Width2Pixel(count) - 1, ypixel + font->ascent + 1);
+                      xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
         }                     /* for (col....) */
     }                         /* for (row....) */
   /*
    * G: cleanup cursor and display outline cursor if necessary
    */
   if (showcursor)
     {
       if (TermWin.focus)
         {
-          srp = &(screen.rend[screen.cur.row + TermWin.saveLines]
+          srp = & (screen.rend[screen.cur.row + TermWin.saveLines]
                   [screen.cur.col]);
           *srp ^= RS_RVid;
 #ifndef NO_CURSORCOLOR
-          *srp = (*srp & ~(RS_fgMask | RS_bgMask)) | cc1;
+          *srp = (*srp & ~ (RS_fgMask | RS_bgMask)) | cc1;
 #endif
         }
       else if (oldcursor.row >= 0)
         {
 #ifndef NO_CURSORCOLOR
           if (ISSET_PIXCOLOR (Color_cursor))
             XSetForeground (display->display, TermWin.gc, PixColors[Color_cursor]);
 #endif
+          int cursorwidth = 1;
+          while (oldcursor.col + cursorwidth < TermWin.ncol
+                 && drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
+            cursorwidth++;
-          XDrawRectangle(display->display, drawBuffer, TermWin.gc,
+          XDrawRectangle (display->display, drawBuffer, TermWin.gc,
-                         Col2Pixel(oldcursor.col),
+                         Col2Pixel (oldcursor.col),
-                         Row2Pixel(oldcursor.row),
+                         Row2Pixel (oldcursor.row),
-                         (unsigned int)(Width2Pixel(cursorwidth) - 1),
+                         (unsigned int) (Width2Pixel (cursorwidth) - 1),
-                         (unsigned int)(Height2Pixel(1) - TermWin.lineSpace - 1));
+                         (unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
         }
     }
   /*
    * H: cleanup selection
   if (clearfirst && TermWin.int_bwidth)
     /*
      * clear the whole screen height, note that width == 0 is treated
      * specially by XClearArea
      */
-    XClearArea(display->display, TermWin.vt, 0, 0,
+    XClearArea (display->display, TermWin.vt, 0, 0,
                (unsigned int)TermWin.int_bwidth,
-               (unsigned int)TermWin_TotalHeight(), False);
+               (unsigned int)TermWin_TotalHeight (), False);
   if (clearlast && TermWin.int_bwidth)
     /*
      * clear the whole screen height, note that width == 0 is treated
      * specially by XClearArea
      */
-    XClearArea(display->display, TermWin.vt,
+    XClearArea (display->display, TermWin.vt,
                TermWin.width + TermWin.int_bwidth, 0,
                (unsigned int)TermWin.int_bwidth,
-               (unsigned int)TermWin_TotalHeight(), False);
+               (unsigned int)TermWin_TotalHeight (), False);
   if (refresh_type & SMOOTH_REFRESH)
-    XSync(display->display, False);
+    XSync (display->display, False);
   num_scr = 0;
   num_scr_allow = 1;
   want_refresh = 0;        /* screen is current */
 }
-/* ------------------------------------------------------------------------- */
 void
+rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)
+{
+  if (!rp || !tp)
+    return;
+  for (int i = TermWin.ncol; i; i--, rp++, tp++)
+    *rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
+}
+void
+rxvt_term::scr_remap_chars ()
+{
+  for (int i = TermWin.nrow + TermWin.saveLines; i--; )
+    scr_remap_chars (screen.text[i], screen.rend[i]);
+  for (int i = TermWin.nrow; i--; )
+    {
+      scr_remap_chars (drawn_text[i], drawn_rend[i]);
+      scr_remap_chars (swap.text[i], swap.rend[i]);
+    }
+}
+/* ------------------------------------------------------------------------- */
+void
-rxvt_term::scr_clear()
+rxvt_term::scr_clear ()
 {
   if (!TermWin.mapped)
     return;
   num_scr_allow = 0;
 #ifdef TRANSPARENT
   if ((Options & Opt_transparent) && (am_pixmap_trans == 0))
     {
       int i;
-      if (!(Options & Opt_transparent_all))
+      if (! (Options & Opt_transparent_all))
         i = 0;
       else
-        i = (int)(sizeof(TermWin.parent) / sizeof(Window));
+        i = (int) (sizeof (TermWin.parent) / sizeof (Window));
       while (i--)
         if (TermWin.parent[i] != None)
-          XClearWindow(display->display, TermWin.parent[i]);
+          XClearWindow (display->display, TermWin.parent[i]);
     }
 #endif
   XClearWindow (display->display, TermWin.vt);
 }
     {
       width = screen.tlen[row] >= 0 ? screen.tlen[row]
               : TermWin.ncol;
       for (towrite = width; towrite; towrite -= wrote)
         {
-          wrote = write(fd, &(screen.text[row][width - towrite]),
+          wrote = write (fd, & (screen.text[row][width - towrite]),
                         towrite);
           if (wrote < 0)
             return;         /* XXX: death, no report */
         }
       if (screen.tlen[row] >= 0)
-        if (write(fd, r1, 1) <= 0)
+        if (write (fd, r1, 1) <= 0)
           return; /* XXX: death, no report */
     }
 }
 #endif
   if (!selection.op)
     return;
   pos.row = pos.col = 0;
-  if ((selection.beg.row < -(int32_t)TermWin.nscrolled)
+  if ((selection.beg.row < - (int32_t)TermWin.nscrolled)
       || (selection.beg.row >= TermWin.nrow)
-      || (selection.mark.row < -(int32_t)TermWin.nscrolled)
+      || (selection.mark.row < - (int32_t)TermWin.nscrolled)
       || (selection.mark.row >= TermWin.nrow)
-      || (selection.end.row < -(int32_t)TermWin.nscrolled)
+      || (selection.end.row < - (int32_t)TermWin.nscrolled)
       || (selection.end.row >= TermWin.nrow)
       || (check_more == 1
           && current_screen == selection.screen
-          && !ROWCOL_IS_BEFORE(screen.cur, selection.beg)
+          && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
-          && ROWCOL_IS_BEFORE(screen.cur, selection.end))
+          && ROWCOL_IS_BEFORE (screen.cur, selection.end))
       || (check_more == 2
-          && ROWCOL_IS_BEFORE(selection.beg, pos)
+          && ROWCOL_IS_BEFORE (selection.beg, pos)
-          && ROWCOL_IS_AFTER(selection.end, pos))
+          && ROWCOL_IS_AFTER (selection.end, pos))
       || (check_more == 3
-          && ROWCOL_IS_AFTER(selection.end, pos))
+          && ROWCOL_IS_AFTER (selection.end, pos))
       || (check_more == 4     /* screen width change */
           && (selection.beg.row != selection.end.row
               || selection.end.col > TermWin.ncol)))
-    CLEAR_SELECTION();
+    CLEAR_SELECTION ();
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Paste a selection direct to the command fd
           ds[j] = '\r';
       tt_write (ds, (int)n);
     }
-  free(ds);
+  free (ds);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Respond to a notification that a primary selection has been sent
 {
   long nread = 0;
   unsigned long bytes_after;
   XTextProperty ct;
-  D_SELECT((stderr, "rxvt_selection_paste(%08lx, %lu, %d), wait=%2x", win, (unsigned long)prop, (int)delete_prop, selection_wait));
+  D_SELECT ((stderr, "rxvt_selection_paste (%08lx, %lu, %d), wait=%2x", win, (unsigned long)prop, (int)delete_prop, selection_wait));
   if (prop == None)         /* check for failed XConvertSelection */
     {
       if ((selection_type & Sel_CompoundText))
         {
       return 0;
     }
   for (;;)
     {
-      if (XGetWindowProperty(display->display, win, prop, (long)(nread / 4),
+      if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),
-                             (long)(PROP_SIZE / 4), delete_prop,
+                              (long) (PROP_SIZE / 4), delete_prop,
-                             AnyPropertyType, &ct.encoding, &ct.format,
+                              AnyPropertyType, &ct.encoding, &ct.format,
-                             &ct.nitems, &bytes_after,
+                              &ct.nitems, &bytes_after,
-                             &ct.value) != Success)
+                              &ct.value) != Success)
         break;
       if (ct.encoding == 0)
         {
-          D_SELECT((stderr, "rxvt_selection_paste: property didn't exist!"));
+          D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));
           break;
         }
       if (ct.value == NULL)
         {
-          D_SELECT((stderr, "rxvt_selection_paste: property shooting blanks!"));
+          D_SELECT ((stderr, "rxvt_selection_paste: property shooting blanks!"));
           continue;
         }
       if (ct.nitems == 0)
         {
-          D_SELECT((stderr, "rxvt_selection_paste: property empty - also INCR end"));
+          D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));
-          if (selection_wait == Sel_normal && nread == 0)
+          if (selection_wait == Sel_normal && nread == 0
+              && (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
+               * XConvertSelection () but nothing was presented
                */
-              D_SELECT((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
+              D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
               selection_paste (display->root, XA_CUT_BUFFER0, False);
             }
           nread = -1;         /* discount any previous stuff */
           break;
     XFree (ct.value);
   if (selection_wait == Sel_normal)
     selection_wait = Sel_none;
-  D_SELECT((stderr, "rxvt_selection_paste: bytes written: %ld", nread));
+  D_SELECT ((stderr, "rxvt_selection_paste: bytes written: %ld", nread));
   return (int)nread;
 }
 void
 rxvt_term::incr_cb (time_watcher &w)
 {
   int             reget_time = 0;
   if (prop == None)
     return;
-  D_SELECT((stderr, "rxvt_selection_property(%08lx, %lu)", win, (unsigned long)prop));
+  D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));
   if (selection_wait == Sel_normal)
     {
       int             a, afmt;
       Atom            atype;
       unsigned long   bytes_after, nitems;
       unsigned char  *s = NULL;
-      a = XGetWindowProperty(display->display, win, prop, 0L, 1L, False,
+      a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,
                              xa[XA_INCR], &atype, &afmt, &nitems,
                              &bytes_after, &s);
       if (s)
-        XFree(s);
+        XFree (s);
       if (a != Success)
         return;
 #ifndef __CYGWIN32__
       if (atype == xa[XA_INCR])
         {  /* start an INCR transfer */
-          D_SELECT((stderr, "rxvt_selection_property: INCR: starting transfer"));
+          D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));
-          XDeleteProperty(display->display, win, prop);
+          XDeleteProperty (display->display, win, prop);
-          XFlush(display->display);
+          XFlush (display->display);
           reget_time = 1;
           selection_wait = Sel_incr;
         }
 #endif
   else if (selection_wait == Sel_incr)
     {
       reget_time = 1;
       if (selection_paste (win, prop, True) == -1)
         {
-          D_SELECT((stderr, "rxvt_selection_property: INCR: clean end"));
+          D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));
           selection_wait = Sel_none;
           incr_ev.stop ();
         }
     }
   if (reget_time) /* received more data so reget time */
 /*
  * 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()
+ * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
  *     will auto fallback to CUT_BUFFER0
  * EXT: button 2 release
  */
 void
 rxvt_term::selection_request (Time tm, int x, int y)
 {
-  D_SELECT((stderr, "rxvt_selection_request(%lu, %d, %d)", tm, x, y));
+  D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));
   if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
     return;                 /* outside window */
   if (selection.text != NULL)
     {    /* internal selection */
-      D_SELECT((stderr, "rxvt_selection_request: pasting internal"));
+      D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));
       paste (selection.text, selection.len);
       return;
     }
   else
     {
             return;
 #endif
         }
     }
-  selection_wait = Sel_none;       /* don't loop in rxvt_selection_paste() */
+  selection_wait = Sel_none;       /* don't loop in rxvt_selection_paste () */
-  D_SELECT((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
+  D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
   selection_paste (display->root, XA_CUT_BUFFER0, False);
 }
 int
 rxvt_term::selection_request_other (Atom target, int selnum)
     sel = XA_PRIMARY;
   else if (selnum == Sel_Secondary)
     sel = XA_SECONDARY;
   else
     sel = xa[XA_CLIPBOARD];
-  if (XGetSelectionOwner(display->display, sel) != None)
+  if (XGetSelectionOwner (display->display, sel) != None)
     {
-      D_SELECT((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));
+      D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));
-      XConvertSelection(display->display, sel, target, xa[XA_VT_SELECTION],
+      XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
                         TermWin.vt, selection_request_time);
       return 1;
     }
   return 0;
 }
  * EXT: SelectionClear
  */
 void
 rxvt_term::selection_clear ()
 {
-  D_SELECT((stderr, "rxvt_selection_clear()"));
+  D_SELECT ((stderr, "rxvt_selection_clear ()"));
   want_refresh = 1;
-  if (selection.text)
-    free(selection.text);
+  free (selection.text);
   selection.text = NULL;
   selection.len = 0;
-  CLEAR_SELECTION();
+  CLEAR_SELECTION ();
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Copy a selection into the cut buffer
   text_t         *t;
 #ifdef ACS_ASCII
   rend_t         *re;
 #endif
-  D_SELECT((stderr, "rxvt_selection_make(): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));
+  D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));
   switch (selection.op)
     {
       case SELECTION_CONT:
         break;
       case SELECTION_INIT:
-        CLEAR_SELECTION();
+        CLEAR_SELECTION ();
         /* FALLTHROUGH */
       case SELECTION_BEGIN:
         selection.op = SELECTION_DONE;
         /* FALLTHROUGH */
       default:
         return;
     }
   selection.op = SELECTION_DONE;
   if (selection.clicks == 4)
     return;                 /* nothing selected, go away */
   i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1) + 1;
-  str = (char *)rxvt_malloc(i * MB_CUR_MAX + 1);
+  str = (char *)rxvt_malloc (i * MB_CUR_MAX + 1);
   new_selection_text = (unsigned char *)str;
   col = selection.beg.col;
-  MAX_IT(col, 0);
+  MAX_IT (col, 0);
   row = selection.beg.row + TermWin.saveLines;
   end_row = selection.end.row + TermWin.saveLines;
   for (; row <= end_row; row++, col = 0)
     {
-      t = &(screen.text[row][col]);
+      t = & (screen.text[row][col]);
       end_col = screen.tlen[row];
       if (end_col == -1)
         end_col = TermWin.ncol;
     {
       free (new_selection_text);
       return;
     }
-  // due to MB_MAX_CUR, selection wastage is usually high, so realloc
+  // due to MB_CUR_MAX, selection wastage is usually high, so realloc
   if (str - (char *)new_selection_text > 1024)
     new_selection_text = (unsigned char *)rxvt_realloc (new_selection_text, i + 1);
   selection.len = i;
   XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
   if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
     display->set_selection_owner (this);
   else
-    rxvt_print_error("can't get primary selection");
+    rxvt_print_error ("can't get primary selection");
   {
     XTextProperty ct;
     char *cl = (char *)selection.text;
-    if (XmbTextListToTextProperty(display->display, &cl, 1, XStringStyle, &ct) >= 0)
+    if (XmbTextListToTextProperty (display->display, &cl, 1, XStringStyle, &ct) >= 0)
       {
-        XChangeProperty(display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
+        XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
-                        PropModeReplace, ct.value, ct.nitems);
+                         PropModeReplace, ct.value, ct.nitems);
         XFree (ct.value);
       }
     else
-      XChangeProperty(display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
+      XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
-                      PropModeReplace, selection.text, (int)selection.len);
+                       PropModeReplace, selection.text, (int)selection.len);
   }
   selection_time = tm;
-  D_SELECT((stderr, "rxvt_selection_make(): selection.len=%d", selection.len));
+  D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Mark or select text based upon number of clicks: 1, 2, or 3
  * EXT: button 1 press
  */
 void
 rxvt_term::selection_click (int clicks, int x, int y)
 {
-  D_SELECT((stderr, "rxvt_selection_click(%d, %d, %d)", clicks, x, y));
+  D_SELECT ((stderr, "rxvt_selection_click (%d, %d, %d)", clicks, x, y));
   clicks = ((clicks - 1) % 3) + 1;
   selection.clicks = clicks;       /* save clicks so extend will work */
-  selection_start_colrow (Pixel2Col(x), Pixel2Row(y));
+  selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
   if (clicks == 2 || clicks == 3)
     selection_extend_colrow (selection.mark.col,
                              selection.mark.row + TermWin.view_start,
                              0, /* button 3     */
 rxvt_term::selection_start_colrow (int col, int row)
 {
   want_refresh = 1;
   selection.mark.col = col;
   selection.mark.row = row - TermWin.view_start;
-  MAX_IT(selection.mark.row, -(int32_t)TermWin.nscrolled);
+  MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
-  MIN_IT(selection.mark.row, (int32_t)TermWin.nrow - 1);
+  MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
-  MAX_IT(selection.mark.col, 0);
+  MAX_IT (selection.mark.col, 0);
-  MIN_IT(selection.mark.col, (int32_t)TermWin.ncol - 1);
+  MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
   if (selection.op)
     {      /* clear the old selection */
       selection.beg.row = selection.end.row = selection.mark.row;
       selection.beg.col = selection.end.col = selection.mark.col;
  * We now only find out the boundary in one direction
  */
 /* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
 #define DELIMIT_TEXT(x) \
-    (((x) == ' ' || (x) == '\t') ? 2 : (STRCHR(rs[Rs_cutchars], (x)) != NULL))
+    (((x) == ' ' || (x) == '\t') ? 2 : (STRCHR (rs[Rs_cutchars], (x)) != NULL))
 #define DELIMIT_REND(x)        1
 void
 rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
 {
       bound.col = TermWin.ncol - 1;
       dirnadd = 1;
     }
   row = mark->row + TermWin.saveLines;
   col = mark->col;
-  MAX_IT(col, 0);
+  MAX_IT (col, 0);
   /* find the edge of a word */
-  stp = &(screen.text[row][col]);
+  stp = & (screen.text[row][col]);
-  w1 = DELIMIT_TEXT(*stp);
+  w1 = DELIMIT_TEXT (*stp);
   if (selection_style != NEW_SELECT)
     {
       if (w1 == 1)
         {
           stp += dirnadd;
-          if (DELIMIT_TEXT(*stp) == 1)
+          if (DELIMIT_TEXT (*stp) == 1)
             goto Old_Word_Selection_You_Die;
           col += dirnadd;
         }
       w1 = 0;
     }
   srp = (&screen.rend[row][col]);
-  w2 = DELIMIT_REND(*srp);
+  w2 = DELIMIT_REND (*srp);
   for (;;)
     {
       for (; col != bound.col; col += dirnadd)
         {
           stp += dirnadd;
-          if (DELIMIT_TEXT(*stp) != w1)
+          if (DELIMIT_TEXT (*stp) != w1)
             break;
           srp += dirnadd;
-          if (DELIMIT_REND(*srp) != w2)
+          if (DELIMIT_REND (*srp) != w2)
             break;
         }
       if ((col == bound.col) && (row != bound.row))
         {
-          if (screen.tlen[(row - (dirn == UP ? 1 : 0))] == -1)
+          if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
             {
               trow = row + dirnadd;
               tcol = dirn == UP ? TermWin.ncol - 1 : 0;
               if (screen.text[trow] == NULL)
                 break;
-              stp = &(screen.text[trow][tcol]);
+              stp = & (screen.text[trow][tcol]);
-              srp = &(screen.rend[trow][tcol]);
+              srp = & (screen.rend[trow][tcol]);
-              if (DELIMIT_TEXT(*stp) != w1 || DELIMIT_REND(*srp) != w2)
+              if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
                 break;
               row = trow;
               col = tcol;
               continue;
             }
         }
       break;
     }
 Old_Word_Selection_You_Die:
-  D_SELECT((stderr, "rxvt_selection_delimit_word(%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up     " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));
+  D_SELECT ((stderr, "rxvt_selection_delimit_word (%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up     " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));
   if (dirn == DN)
     col++;                  /* put us on one past the end */
   /* Poke the values back in */
 void
 rxvt_term::selection_extend (int x, int y, int flag)
 {
   int col, row;
-  col = Pixel2Col(x);
+  col = Pixel2Col (x);
-  row = Pixel2Row(y);
+  row = Pixel2Row (y);
-  MAX_IT(row, 0);
+  MAX_IT (row, 0);
-  MIN_IT(row, (int)TermWin.nrow - 1);
+  MIN_IT (row, (int)TermWin.nrow - 1);
-  MAX_IT(col, 0);
+  MAX_IT (col, 0);
-  MIN_IT(col, (int)TermWin.ncol);
+  MIN_IT (col, (int)TermWin.ncol);
 #ifndef NO_NEW_SELECTION
   /*
   * If we're selecting characters (single click) then we must check first
   * if we are at the same place as the original mark.  If we are then
           /* select nothing */
           selection.beg.row = selection.end.row = 0;
           selection.beg.col = selection.end.col = 0;
           selection.clicks = 4;
           want_refresh = 1;
-          D_SELECT((stderr, "rxvt_selection_extend() selection.clicks = 4"));
+          D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));
           return;
         }
     }
 #endif
   if (selection.clicks == 4)
   row_col_t       pos;
   enum {
     LEFT, RIGHT
   } closeto = RIGHT;
-  D_SELECT((stderr, "rxvt_selection_extend_colrow(c:%d, r:%d, %d, %d) clicks:%d, op:%d", col, row, button3, buttonpress, selection.clicks, selection.op));
+  D_SELECT ((stderr, "rxvt_selection_extend_colrow (c:%d, r:%d, %d, %d) clicks:%d, op:%d", col, row, button3, buttonpress, selection.clicks, selection.op));
-  D_SELECT((stderr, "rxvt_selection_extend_colrow() ENT  b:(r:%d,c:%d) m:(r:%d,c:%d), e:(r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
+  D_SELECT ((stderr, "rxvt_selection_extend_colrow () ENT  b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
   want_refresh = 1;
   switch (selection.op)
     {
       case SELECTION_INIT:
-        CLEAR_SELECTION();
+        CLEAR_SELECTION ();
         selection.op = SELECTION_BEGIN;
         /* FALLTHROUGH */
       case SELECTION_BEGIN:
         if (row != selection.mark.row || col != selection.mark.col
             || (!button3 && buttonpress))
       && selection.beg.row == selection.end.row
       && selection.beg.row != selection.mark.row)
     {
       selection.beg.col = selection.end.col = selection.mark.col;
       selection.beg.row = selection.end.row = selection.mark.row;
-      D_SELECT((stderr, "rxvt_selection_extend_colrow() ENT2 b:(r:%d,c:%d) m:(r:%d,c:%d), e:(r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
+      D_SELECT ((stderr, "rxvt_selection_extend_colrow () ENT2 b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
     }
   pos.col = col;
   pos.row = row;
                 {
                   selection.mark.row = selection.beg.row;
                   selection.mark.col = selection.beg.col;
                 }
             }
-          if (ROWCOL_IS_BEFORE(pos, selection.mark))
+          if (ROWCOL_IS_BEFORE (pos, selection.mark))
             {
               selection.end.row = selection.mark.row;
               selection.end.col = selection.mark.col + 1;
               selection.beg.row = pos.row;
               selection.beg.col = pos.col;
               selection.end.col = pos.col + 1;
             }
         }
       else if (selection.clicks == 2)
         {
-          selection_delimit_word (UP, &(selection.mark),
+          selection_delimit_word (UP, & (selection.mark),
-                                  &(selection.beg));
+                                  & (selection.beg));
-          selection_delimit_word (DN, &(selection.mark),
+          selection_delimit_word (DN, & (selection.mark),
-                                  &(selection.end));
+                                  & (selection.end));
           hate_those_clicks = 1;
         }
       else if (selection.clicks == 3)
         {
           selection.beg.row = selection.end.row = selection.mark.row;
           selection.beg.col = 0;
           selection.end.col = ncol;
           hate_those_clicks = 1;
         }
-      D_SELECT((stderr, "rxvt_selection_extend_colrow() EXIT b:(r:%d,c:%d) m:(r:%d,c:%d), e:(r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
+      D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
       return;
     }
 #endif                          /* ! NO_OLD_SELECTION */
 #ifndef NO_NEW_SELECTION
   /* selection_style must not be OLD_SELECT to get here */
   if (button3 && buttonpress)
     {       /* button3 press */
       /*
        * first determine which edge of the selection we are closest to
        */
-      if (ROWCOL_IS_BEFORE(pos, selection.beg)
+      if (ROWCOL_IS_BEFORE (pos, selection.beg)
-          || (!ROWCOL_IS_AFTER(pos, selection.end)
+          || (!ROWCOL_IS_AFTER (pos, selection.end)
               && (((pos.col - selection.beg.col)
                    + ((pos.row - selection.beg.row) * ncol))
                   < ((selection.end.col - pos.col)
                      + ((selection.end.row - pos.row) * ncol)))))
         closeto = LEFT;
           selection.mark.col = selection.beg.col;
         }
     }
   else
     {                    /* button1 drag or button3 drag */
-      if (ROWCOL_IS_AFTER(selection.mark, pos))
+      if (ROWCOL_IS_AFTER (selection.mark, pos))
         {
           if ((selection.mark.row == selection.end.row)
               && (selection.mark.col == selection.end.col)
               && clickchange && selection.clicks == 2)
             selection.mark.col--;
         selection.end.col = ncol;
     }
   else if (selection.clicks == 2)
     {
-      if (ROWCOL_IS_AFTER(selection.end, selection.beg))
+      if (ROWCOL_IS_AFTER (selection.end, selection.beg))
         selection.end.col--;
-      selection_delimit_word (UP, &(selection.beg),
+      selection_delimit_word (UP, & (selection.beg),
-                              &(selection.beg));
+                              & (selection.beg));
-      selection_delimit_word (DN, &(selection.end),
+      selection_delimit_word (DN, & (selection.end),
-                              &(selection.end));
+                              & (selection.end));
     }
   else if (selection.clicks == 3)
     {
 #ifndef NO_FRILLS
       if ((Options & Opt_tripleclickwords))
         {
           int             end_row;
-          selection_delimit_word (UP, &(selection.beg),
+          selection_delimit_word (UP, & (selection.beg),
-                                  &(selection.beg));
+                                  & (selection.beg));
           end_row = screen.tlen[selection.mark.row
                                 + TermWin.saveLines];
           for (end_row = selection.mark.row; end_row < TermWin.nrow;
                end_row++)
             {
         }
       else
 #endif
         {
-          if (ROWCOL_IS_AFTER(selection.mark, selection.beg))
+          if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
             selection.mark.col++;
           selection.beg.col = 0;
           selection.end.col = ncol;
         }
     }
         {
           selection.mark.row = selection.beg.row;
           selection.mark.col = selection.beg.col;
         }
     }
-  D_SELECT((stderr, "rxvt_selection_extend_colrow() EXIT b:(r:%d,c:%d) m:(r:%d,c:%d), e:(r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
+  D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
 #endif                          /* ! NO_NEW_SELECTION */
 }
 #ifndef NO_FRILLS
 void
  */
 void
 rxvt_term::selection_rotate (int x, int y)
 {
   selection.clicks = selection.clicks % 3 + 1;
-  selection_extend_colrow (Pixel2Col(x), Pixel2Row(y), 1, 0, 1);
+  selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * On some systems, the Atom typedef is 64 bits wide.  We need to have a type
       *target++ = (Atom32) xa[XA_TEXT];
       *target++ = (Atom32) xa[XA_COMPOUND_TEXT];
 #if X_HAVE_UTF8_STRING
       *target++ = (Atom32) xa[XA_UTF8_STRING];
 #endif
-      XChangeProperty(display->display, rq.requestor, rq.property, XA_ATOM,
+      XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,
-                      (8 * sizeof(target_list[0])), PropModeReplace,
+                      (8 * sizeof (target_list[0])), PropModeReplace,
                       (unsigned char *)target_list,
                       target - target_list);
       ev.property = rq.property;
     }
   else if (rq.target == xa[XA_MULTIPLE])
     {
       /* TODO: Handle MULTIPLE */
     }
   else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
     {
-      XChangeProperty(display->display, rq.requestor, rq.property, XA_INTEGER,
+      XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
-                      (8 * sizeof(Time)), PropModeReplace,
+                      (8 * sizeof (Time)), PropModeReplace,
                       (unsigned char *)&selection_time, 1);
       ev.property = rq.property;
     }
   else if (rq.target == XA_STRING
            || rq.target == xa[XA_TEXT]
         {
           cl = "";
           selectlen = 0;
         }
-      if (XmbTextListToTextProperty(display->display, &cl, 1, style, &ct) >= 0)
+      if (XmbTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)
         freect = 1;
       else
         {
           /* if we failed to convert then send it raw */
           ct.value = (unsigned char *)cl;
  * return col/row values corresponding to x/y pixel values
  */
 void
 rxvt_term::pixel_position (int *x, int *y)
 {
-  *x = Pixel2Col(*x);
+  *x = Pixel2Col (*x);
-  /* MAX_IT(*x, 0); MIN_IT(*x, (int)TermWin.ncol - 1); */
+  /* MAX_IT (*x, 0); MIN_IT (*x, (int)TermWin.ncol - 1); */
-  *y = Pixel2Row(*y);
+  *y = Pixel2Row (*y);
-  /* MAX_IT(*y, 0); MIN_IT(*y, (int)TermWin.nrow - 1); */
+  /* MAX_IT (*y, 0); MIN_IT (*y, (int)TermWin.nrow - 1); */
 }
 /* ------------------------------------------------------------------------- */
 #ifdef USE_XIM
 void
 /* ------------------------------------------------------------------------- *
  *                              DEBUG ROUTINES                               *
  * ------------------------------------------------------------------------- */
 #if 0
 void
-rxvt_debug_colors(void)
+rxvt_debug_colors (void)
 {
   int             color;
   const char     *name[] =
     {
       "fg", "bg",
       "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"
     };
-  fprintf(stderr, "Color ( ");
+  fprintf (stderr, "Color ( ");
   if (rstyle & RS_RVid)
-    fprintf(stderr, "rvid ");
+    fprintf (stderr, "rvid ");
   if (rstyle & RS_Bold)
-    fprintf(stderr, "bold ");
+    fprintf (stderr, "bold ");
   if (rstyle & RS_Blink)
-    fprintf(stderr, "blink ");
+    fprintf (stderr, "blink ");
   if (rstyle & RS_Uline)
-    fprintf(stderr, "uline ");
+    fprintf (stderr, "uline ");
-  fprintf(stderr, "): ");
+  fprintf (stderr, "): ");
-  color = GET_FGCOLOR(rstyle);
+  color = GET_FGCOLOR (rstyle);
 #ifndef NO_BRIGHTCOLOR
   if (color >= minBrightCOLOR && color <= maxBrightCOLOR)
     {
       color -= (minBrightCOLOR - minCOLOR);
-      fprintf(stderr, "bright ");
+      fprintf (stderr, "bright ");
     }
 #endif
-  fprintf(stderr, "%s on ", name[color]);
+  fprintf (stderr, "%s on ", name[color]);
-  color = GET_BGCOLOR(rstyle);
+  color = GET_BGCOLOR (rstyle);
 #ifndef NO_BRIGHTCOLOR
   if (color >= minBrightCOLOR && color <= maxBrightCOLOR)
     {
       color -= (minBrightCOLOR - minCOLOR);
-      fprintf(stderr, "bright ");
+      fprintf (stderr, "bright ");
     }
 #endif
-  fprintf(stderr, "%s\n", name[color]);
+  fprintf (stderr, "%s\n", name[color]);
 }
 #endif

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/screen.C (file contents): Revision 1.29 by pcg, Wed Feb 11 08:13:45 2004 UTC vs. Revision 1.41 by pcg, Sun Feb 29 15:31:56 2004 UTC

Diff Legend

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.29 by pcg, Wed Feb 11 08:13:45 2004 UTC vs.
Revision 1.41 by pcg, Sun Feb 29 15:31:56 2004 UTC