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

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.202 by root, Sat Mar 12 23:35:14 2005 UTC vs.
Revision 1.246 by root, Fri Jan 6 18:36:21 2006 UTC

  * 				- extensive modifications
  * Copyright (c) 1998      Alfredo K. Kojima <kojima@windowmaker.org>
  * Copyright (c) 2001      Marius Gedminas
  *				- Ctrl/Mod4+Tab works like Meta+Tab (options)
  * Copyright (c) 2003      Rob McMullen <robm@flipturn.org>
- * Copyright (c) 2003-2005 Marc Lehmann <pcg@goof.com>
+ * Copyright (c) 2003-2006 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.
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *----------------------------------------------------------------------*/
 /*{{{ includes: */
-#include "../config.h"		/* NECESSARY */
+#include "../config.h"
-#include "rxvt.h"		/* NECESSARY */
+#include "rxvt.h"
+#include "rxvtperl.h"
 #include "version.h"
 #include "command.h"
+#if HAVE_SCHED_YIELD
+#undef HAVE_SCHED_YIELD // disabled for the time being
+//# include <sched.h>
+#endif
 #ifdef KEYSYM_RESOURCE
 # include "keyboard.h"
 #endif
 rxvt_term::iso14755_54 (int x, int y)
 {
   x = Pixel2Col (x);
   y = Pixel2Row (y);
-  if (x < 0 || x >= TermWin.ncol
+  if (!IN_RANGE_EXC (x, 0, ncol)
-      || y < 0 || y >= TermWin.nrow)
+      || !IN_RANGE_EXC (y, 0, nrow))
     return;
   for (;;)
     {
-      text_t t = screen.text[y + TermWin.saveLines - TermWin.view_start][x];
+      const line_t &l = ROW(y - view_start);
+      text_t t = l.t[x];
       if (t != NOCHAR || !x)
         {
-          iso14755_51 (screen.text[y + TermWin.saveLines - TermWin.view_start][x],
+          iso14755_51 (l.t[x], l.r[x], x, y);
-                       screen.rend[y + TermWin.saveLines - TermWin.view_start][x]);
           iso14755buf = ISO_14755_54;
           break;
         }
       x--;
     }
 }
-#endif
-#if ENABLE_OVERLAY
 void
-rxvt_term::iso14755_51 (unicode_t ch, rend_t r)
+rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)
 {
   rxvt_fontset *fs = FONTSET (r);
   rxvt_font *f = (*fs)[fs->find_font (ch)];
-  wchar_t *chr, *alloc, ch2;
+  wchar_t *chr, *alloc, ch2, *fname;
   int len;
+  fname = rxvt_utf8towcs (f->name);
-#if ENABLE_COMBINING
+# if ENABLE_COMBINING
   if (IS_COMPOSE (ch))
     {
       len = rxvt_composite.expand (ch, 0);
       alloc = chr = new wchar_t[len];
       rxvt_composite.expand (ch, chr);
     }
   else
-#endif
+# endif
     {
       ch2 = ch;
       alloc = 0;
       chr = &ch2;
       len = 1;
     }
-  int width = strlen (f->name);
+  char attr[80]; // plenty
-  scr_overlay_new (0, -1, width < 8+5 ? 8+5 : width, len + 1);
+  sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
+           (int)r,
+           fgcolor_of (r), bgcolor_of (r),
+           r & RS_Bold    ? " bold"    : "",
+           r & RS_Italic  ? " italic"  : "",
+           r & RS_Blink   ? " blink"   : "",
+           r & RS_RVid    ? " rvid"    : "",
+           r & RS_Uline   ? " uline"   : "",
+           r & RS_Careful ? " careful" : "");
+  int width = wcswidth (fname, wcslen (fname));
+  max_it (width, 8+5); // for char + hey
+  max_it (width, strlen (attr));
+  if (y >= 0)
+    {
+      y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;
+      x = 0;
+    }
+  scr_overlay_new (x, y, width, len + 2);
   r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
   for (int y = 0; y < len; y++)
     {
       ch = *chr++;
       sprintf (buf, "%8x", ch);
       scr_overlay_set (0, y, buf);
       scr_overlay_set (9, y, '=');
-#if !UNICODE3
+# if !UNICODE3
       if (ch >= 0x10000)
         ch = 0xfffd;
-#endif
+# endif
       scr_overlay_set (11, y, ch, r);
       scr_overlay_set (12, y, NOCHAR, r);
     }
+  scr_overlay_set (0, len    , attr);
-  scr_overlay_set (0, len, f->name);
+  scr_overlay_set (0, len + 1, fname);
+  free (fname);
-#if ENABLE_COMBINING
+# if ENABLE_COMBINING
   if (alloc)
     delete [] alloc;
-#endif
+# endif
 }
 #endif
 void
 rxvt_term::commit_iso14755 ()
           mb[0] = ch[0];
           len = 1;
         }
       if (len > 0)
-        tt_write ((unsigned char *)mb, len);
+        tt_write (mb, len);
       else
         scr_bell ();
     }
   iso14755buf = 0;
   KeySym keysym;
 #ifdef DEBUG_CMD
   static int debug_key = 1;	/* accessible by a debugger only */
 #endif
   int valid_keysym;
-  unsigned char kbuf[KBUFSZ];
+  char kbuf[KBUFSZ];
   /*
    * use Num_Lock to toggle Keypad on/off.  If Num_Lock is off, allow an
    * escape sequence to toggle the Keypad.
    *
       Status status_return;
 #if 0
 #ifdef X_HAVE_UTF8_STRING
       if (enc_utf8 && 0) // currently disabled, doesn't seem to work, nor is useful
-        len = Xutf8LookupString (Input_Context, &ev, (char *)kbuf,
+        len = Xutf8LookupString (Input_Context, &ev, kbuf,
                                  KBUFSZ, &keysym, &status_return);
       else
 #endif
 #endif
         {
                      || status_return == XLookupBoth;
     }
   else
 #endif
     {
-      len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);
+      len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);
       valid_keysym = keysym != NoSymbol;
     }
   if (valid_keysym)
     {
 #ifdef KEYSYM_RESOURCE
       if (keyboard->dispatch (this, keysym, ev.state))
         return;
 #endif
-      if (TermWin.saveLines)
+      if (saveLines)
         {
 #ifdef UNSHIFTED_SCROLLKEYS
           if (!ctrl && !meta)
 #else
           if (IS_SCROLL_MOD)
 #endif
             {
               int lnsppg;
 #ifdef PAGING_CONTEXT_LINES
-              lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
+              lnsppg = nrow - PAGING_CONTEXT_LINES;
 #else
-              lnsppg = TermWin.nrow * 4 / 5;
+              lnsppg = nrow * 4 / 5;
 #endif
               if (keysym == XK_Prior)
                 {
                   scr_page (UP, lnsppg);
                   return;
         {
 #ifdef META8_OPTION
           /* set 8-bit on */
           if (meta && (meta_char == 0x80))
             {
-              unsigned char  *ch;
+              char *ch;
               for (ch = kbuf; ch < kbuf + len; ch++)
                 *ch |= 0x80;
               meta = 0;
 #endif
           /* nil */ ;
         }
     }
+  if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_STR_LEN, kbuf, len, DT_END)))
+    return;
   if (len <= 0)
     return;			/* not mapped */
-  if (options & Opt_scrollTtyKeypress)
+  if (OPTION (Opt_scrollTtyKeypress))
-    if (TermWin.view_start)
+    if (view_start)
       {
-        TermWin.view_start = 0;
+        view_start = 0;
         want_refresh = 1;
       }
   /*
    * these modifications only affect the static keybuffer
 #ifdef META8_OPTION
       && meta_char == C0_ESC
 #endif
      )
     {
-      const unsigned char ch = C0_ESC;
+      const char ch = C0_ESC;
       tt_write (&ch, 1);
     }
 #if defined(DEBUG_CMD)
   /* Display keyboard buffer contents */
 #if MENUBAR_MAX || defined (KEYSYM_RESOURCE)
 /*{{{ rxvt_cmd_write (), rxvt_cmd_getc () */
 /* attempt to `write' count to the input buffer */
 unsigned int
-rxvt_term::cmd_write (const unsigned char *str, unsigned int count)
+rxvt_term::cmd_write (const char *str, unsigned int count)
 {
   unsigned int n, s;
   n = cmdbuf_ptr - cmdbuf_base;
   s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
     }
 #endif
   if (want_refresh)
     {
+      if (SHOULD_INVOKE (HOOK_LINE_UPDATE))
+        {
+          int row = -view_start;
+          while (row > -nsaved && ROW (row - 1).is_longer ())
+            --row;
+          while (row < -view_start + nrow)
+            {
+              int start_row = row;
+              line_t *l;
+              do
+                {
+                  l = &ROW (row);
+                  if (!(l->f & LINE_FILTERED))
+                    {
+                      // line not filtered, mark it as filtered
+                      l->f |= LINE_FILTERED;
+                      while (l->is_longer ())
+                        {
+                          l = &ROW (++row);
+                          l->f |= LINE_FILTERED;
+                        }
+                      // and filter it
+                      HOOK_INVOKE ((this, HOOK_LINE_UPDATE, DT_INT, start_row, DT_END));
+                      break;
+                    }
+                }
+              while (l->is_longer ());
+              row++;
+            }
+        }
       scr_refresh (refresh_type);
       scrollbar_show (1);
 #ifdef USE_XIM
       IMSendSpot ();
 #endif
   SET_LOCALE (locale);
   display->flush ();
   if (want_refresh && !flush_ev.active)
-    flush_ev.start (NOW + 0.01);
+    flush_ev.start (NOW + 1. / 60.); // refresh at max. 60 hz normally
 }
 void
 rxvt_term::flush_cb (time_watcher &w)
 {
 {
   if (mouse_slip_wheel_speed == 0
       || mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
                                     : scr_page (UP,  mouse_slip_wheel_speed))
     {
-      if (TermWin.view_start == TermWin.nscrolled ||
+      if (view_start == nsaved ||
-          TermWin.view_start == 0)
+          view_start == 0)
         mouse_slip_wheel_speed = 0;
       refresh_type |= SMOOTH_REFRESH;
       want_refresh = 1;
       w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
     }
 }
 #endif
+#if HAVE_SCHED_YIELD
+static struct event_handler
+{
+  check_watcher cw_yield;
+  void yield (check_watcher &w)
+  {
+    sched_yield ();
+    w.stop ();
+  }
+  event_handler ()
+  : cw_yield (this, &event_handler::yield)
+  {
+  }
+} event_handler;
+#endif
 bool
 rxvt_term::pty_fill ()
 {
   ssize_t n = cmdbuf_endp - cmdbuf_ptr;
   if (CBUFSIZ == n)
     {
-      rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");
+      rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
       n = 0;
     }
   memmove (cmdbuf_base, cmdbuf_ptr, n);
   cmdbuf_ptr = cmdbuf_base;
   cmdbuf_endp = cmdbuf_ptr + n;
-  n = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
+  ssize_t r = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
-  if (n > 0)
+  if (r > 0)
     {
-      cmdbuf_endp += n;
+      cmdbuf_endp += r;
       return true;
     }
-  else if (n < 0 && errno != EAGAIN)
+  else if (r < 0 && (errno == EAGAIN || errno == EINTR))
+    {
+#if HAVE_SCHED_YIELD
+      if (display->is_local)
+        event_handler.cw_yield.start ();
+#endif
+    }
+  else
+    {
+      pty_ev.stop ();
+      if (!OPTION (Opt_hold))
-    destroy ();
+        destroy ();
+    }
   return false;
 }
 void
 }
 void
 rxvt_term::pointer_unblank ()
 {
-  XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
+  XDefineCursor (display->display, vt, TermWin_cursor);
   recolour_cursor ();
 #ifdef POINTER_BLANK
   hidden_pointer = 0;
-  if (options & Opt_pointerBlank)
+  if (OPTION (Opt_pointerBlank))
     pointer_ev.start (NOW + pointerBlankDelay);
 #endif
 }
 #ifdef POINTER_BLANK
 void
 rxvt_term::pointer_blank ()
 {
-  if (! (options & Opt_pointerBlank))
+  if (!OPTION (Opt_pointerBlank))
     return;
-  XDefineCursor (display->display, TermWin.vt, display->blank_cursor);
+  XDefineCursor (display->display, vt, display->blank_cursor);
   XFlush (display->display);
   hidden_pointer = 1;
 }
   SET_R (this);
   SET_LOCALE (locale);
 #if defined(CURSOR_BLINK)
-  if ((options & Opt_cursorBlink) && ev.type == KeyPress)
+  if (OPTION (Opt_cursorBlink) && ev.type == KeyPress)
     {
       if (hidden_cursor)
         {
           hidden_cursor = 0;
           want_refresh = 1;
       cursor_blink_ev.start (NOW + BLINK_INTERVAL);
     }
 #endif
 #if defined(POINTER_BLANK)
-  if ((options & Opt_pointerBlank) && pointerBlankDelay > 0)
+  if (OPTION (Opt_pointerBlank) && pointerBlankDelay > 0)
     {
       if (ev.type == MotionNotify
           || ev.type == ButtonPress
           || ev.type == ButtonRelease)
         if (hidden_pointer)
 # endif
                 else
                   iso14755buf = 0;
               }
 #endif
+          if (ev.xany.window == vt
+              && HOOK_INVOKE ((this, HOOK_KEY_RELEASE, DT_XEVENT, &ev, DT_END)))
+            break;
 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
           if (!(ev.xkey.state & ControlMask))
             slip_wheel_ev.stop ();
           else if (ks == XK_Control_L || ks == XK_Control_R)
       case FocusOut:
         focus_out ();
         break;
       case ConfigureNotify:
-        if (ev.xconfigure.window == TermWin.parent[0])
+        if (ev.xconfigure.window == parent[0])
           {
-            int height, width;
-            do
-              {	/* Wrap lots of configures into one */
-                width = ev.xconfigure.width;
-                height = ev.xconfigure.height;
-                D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
-              }
-            while (XCheckTypedWindowEvent (disp, ev.xconfigure.window, ConfigureNotify, &ev));
+            while (XCheckTypedWindowEvent (disp, ev.xconfigure.window, ConfigureNotify, &ev))
+              ;
-            if (szHint.width != width || szHint.height != height)
+            if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
               {
                 seen_resize = 1;
-                resize_all_windows (width, height, 1);
+                resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
               }
 #ifdef TRANSPARENT		/* XXX: maybe not needed - leave in for now */
-            if (options & Opt_transparent)
+            if (OPTION (Opt_transparent))
               check_our_parents ();
 #endif
           }
         break;
       case SelectionRequest:
         selection_send (ev.xselectionrequest);
         break;
       case UnmapNotify:
-        TermWin.mapped = 0;
+        mapped = 0;
 #ifdef TEXT_BLINK
         text_blink_ev.stop ();
 #endif
         break;
       case MapNotify:
-        TermWin.mapped = 1;
+        mapped = 1;
 #ifdef TEXT_BLINK
         text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
 #endif
         break;
         break;
 #endif				/* TRANSPARENT */
       case GraphicsExpose:
       case Expose:
-        if (ev.xany.window == TermWin.vt)
+        if (ev.xany.window == vt)
           {
             do
               scr_expose (ev.xexpose.x, ev.xexpose.y,
                           ev.xexpose.width, ev.xexpose.height, False);
-            while (XCheckTypedWindowEvent (disp, TermWin.vt, ev.xany.type, &ev));
+            while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev));
             ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
-            while (XCheckTypedWindowEvent (disp, TermWin.vt, ev.xany.type, &ev))
+            while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev))
               scr_expose (ev.xexpose.x, ev.xexpose.y,
                           ev.xexpose.width, ev.xexpose.height, False);
             scr_refresh (refresh_type);
           }
             if (menubar_visible () && isMenuBarWindow (ev.xany.window))
               menubar_expose ();
 #endif
 #ifdef TRANSPARENT
-            if (am_transparent && ev.xany.window == TermWin.parent[0])
+            if (am_transparent && ev.xany.window == parent[0])
               XClearWindow (disp, ev.xany.window);
 #endif
           }
         break;
           }
 #endif
         if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
           break;
-        if (ev.xany.window == TermWin.vt)
+        if (ev.xany.window == vt)
           {
+            if (HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
+              ; // nop
-            if (ev.xbutton.state & (Button1Mask | Button3Mask))
+            else if (ev.xbutton.state & (Button1Mask | Button3Mask))
               {
-                while (XCheckTypedWindowEvent (disp, TermWin.vt, MotionNotify, &ev))
+                while (XCheckTypedWindowEvent (disp, vt, MotionNotify, &ev))
                   ;
-                XQueryPointer (disp, TermWin.vt,
+                XQueryPointer (disp, vt,
                                &unused_root, &unused_child,
                                &unused_root_x, &unused_root_y,
                                &ev.xbutton.x, &ev.xbutton.y,
                                &ev.xbutton.state);
 #ifdef MOUSE_THRESHOLD
 #endif
                     selection_extend (ev.xbutton.x, ev.xbutton.y,
                                       ev.xbutton.state & Button3Mask ? 2 : 0);
 #ifdef SELECTION_SCROLLING
-                    if (ev.xbutton.y < TermWin.int_bwidth
+                    if (ev.xbutton.y < int_bwidth
-                        || Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
+                        || Pixel2Row (ev.xbutton.y) > (nrow-1))
                       {
                         int dist;
                         /* don't clobber the current delay if we are
                          * already in the middle of scrolling.
                         selection_save_x = ev.xbutton.x;
                         selection_save_y = ev.xbutton.y;
                         selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
                         /* calc number of lines to scroll */
-                        if (ev.xbutton.y < TermWin.int_bwidth)
+                        if (ev.xbutton.y < int_bwidth)
                           {
                             scroll_selection_dir = UP;
-                            dist = TermWin.int_bwidth - ev.xbutton.y;
+                            dist = int_bwidth - ev.xbutton.y;
                           }
                         else
                           {
                             scroll_selection_dir = DN;
-                            dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
+                            dist = ev.xbutton.y - (int_bwidth + height);
                           }
                         scroll_selection_lines = Pixel2Height (dist)
                                                  / SELECTION_SCROLL_LINE_SPEEDUP
                                                  + 1;
-                        MIN_IT (scroll_selection_lines,
+                        min_it (scroll_selection_lines,
                                 SELECTION_SCROLL_MAX_LINES);
                       }
                     else
                       {
                         /* we are within the text window, so we
 }
 void
 rxvt_term::focus_in ()
 {
-  if (!TermWin.focus)
+  if (!focus)
     {
-      TermWin.focus = 1;
+      focus = 1;
       want_refresh = 1;
+      HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
-#ifdef USE_XIM
+#if USE_XIM
       if (Input_Context != NULL)
         {
           IMSetStatusPosition ();
           XSetICFocus (Input_Context);
         }
 #endif
-#ifdef CURSOR_BLINK
+#if CURSOR_BLINK
-      if (options & Opt_cursorBlink)
+      if (OPTION (Opt_cursorBlink))
         cursor_blink_ev.start (NOW + BLINK_INTERVAL);
 #endif
-#ifdef OFF_FOCUS_FADING
+#if OFF_FOCUS_FADING
       if (rs[Rs_fade])
         {
           pix_colors = pix_colors_focused;
           scr_recolour ();
         }
 }
 void
 rxvt_term::focus_out ()
 {
-  if (TermWin.focus)
+  if (focus)
     {
-      TermWin.focus = 0;
+      focus = 0;
       want_refresh = 1;
+      HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
 #if ENABLE_FRILLS || ISO_14755
+      if (iso14755buf)
+        {
-      iso14755buf = 0;
+          iso14755buf = 0;
-#endif
-#if ENABLE_OVERLAY
+# if ENABLE_OVERLAY
-      scr_overlay_off ();
+          scr_overlay_off ();
-#endif
+# endif
+        }
+#endif
-#ifdef USE_XIM
+#if USE_XIM
       if (Input_Context != NULL)
         XUnsetICFocus (Input_Context);
 #endif
-#ifdef CURSOR_BLINK
+#if CURSOR_BLINK
-      if (options & Opt_cursorBlink)
+      if (OPTION (Opt_cursorBlink))
         cursor_blink_ev.stop ();
       hidden_cursor = 0;
 #endif
-#ifdef OFF_FOCUS_FADING
+#if OFF_FOCUS_FADING
       if (rs[Rs_fade])
         {
           pix_colors = pix_colors_unfocused;
           scr_recolour ();
         }
             && ev.xproperty.atom != xa[XA_ESETROOT_PMAP_ID])
           return;
         /* FALLTHROUGH */
       case ReparentNotify:
-        if ((options & Opt_transparent) && check_our_parents () && am_transparent)
+        if (OPTION (Opt_transparent) && check_our_parents () && am_transparent)
           want_refresh = want_full_refresh = 1;
         break;
     }
 }
 #endif
 rxvt_term::button_press (XButtonEvent &ev)
 {
   int reportmode = 0, clickintime;
   bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
   if (!bypass_keystate)
     reportmode = !! (priv_modes & PrivMode_mouse_report);
   /*
    * VT window processing of button press
    */
-  if (ev.window == TermWin.vt)
+  if (ev.window == vt)
     {
 #if ISO_14755
       // 5.4
       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
         {
 #ifdef MOUSE_REPORT_DOUBLECLICK
           if (ev.button == MEvent.button && clickintime)
             {
               /* same button, within alloted time */
               MEvent.clicks++;
               if (MEvent.clicks > 1)
                 {
                   /* only report double clicks */
                   MEvent.clicks = 2;
                   mouse_report (ev);
       else
         {
           if (ev.button != MEvent.button)
             MEvent.clicks = 0;
+          if (!HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
-          switch (ev.button)
+            switch (ev.button)
-            {
+              {
-              case Button1:
+                case Button1:
-                /* allow meta + click to select rectangular areas */
+                  /* allow meta + click to select rectangular areas */
-                /* should be done in screen.C */
+                  /* should be done in screen.C */
 #if ENABLE_FRILLS
-                selection.rect = !!(ev.state & ModMetaMask);
+                  selection.rect = !!(ev.state & ModMetaMask);
 #else
-                selection.rect = false;
+                  selection.rect = false;
 #endif
-                /* allow shift+left click to extend selection */
+                  /* allow shift+left click to extend selection */
-                if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
+                  if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
-                  {
+                    {
-                    if (MEvent.button == Button1 && clickintime)
+                      if (MEvent.button == Button1 && clickintime)
-                      selection_rotate (ev.x, ev.y);
+                        selection_rotate (ev.x, ev.y);
-                    else
+                      else
-                      selection_extend (ev.x, ev.y, 1);
+                        selection_extend (ev.x, ev.y, 1);
-                  }
+                    }
-                else
+                  else
-                  {
+                    {
-                    if (MEvent.button == Button1 && clickintime)
+                      if (MEvent.button == Button1 && clickintime)
-                      MEvent.clicks++;
+                        MEvent.clicks++;
-                    else
+                      else
-                      MEvent.clicks = 1;
+                        MEvent.clicks = 1;
-                    selection_click (MEvent.clicks, ev.x, ev.y);
+                      selection_click (MEvent.clicks, ev.x, ev.y);
-                  }
+                    }
-                MEvent.button = Button1;
+                  MEvent.button = Button1;
-                break;
+                  break;
-              case Button3:
+                case Button3:
-                if (MEvent.button == Button3 && clickintime)
+                  if (MEvent.button == Button3 && clickintime)
-                  selection_rotate (ev.x, ev.y);
+                    selection_rotate (ev.x, ev.y);
-                else
+                  else
-                  selection_extend (ev.x, ev.y, 1);
+                    selection_extend (ev.x, ev.y, 1);
-                MEvent.button = Button3;
+                  MEvent.button = Button3;
-                break;
+                  break;
-            }
+              }
-        }
+          }
       MEvent.time = ev.time;
       return;
     }
                 case Button3:
                   if (scrollBar.style != R_SB_XTERM)
                     {
                       if (scrollbar_above_slider (ev.y))
 # ifdef RXVT_SCROLL_FULL
-                        scr_page (UP, TermWin.nrow - 1);
+                        scr_page (UP, nrow - 1);
 # else
-                        scr_page (UP, TermWin.nrow / 4);
+                        scr_page (UP, nrow / 4);
 # endif
                       else if (scrollbar_below_slider (ev.y))
 # ifdef RXVT_SCROLL_FULL
-                        scr_page (DN, TermWin.nrow - 1);
+                        scr_page (DN, nrow - 1);
 # else
-                        scr_page (DN, TermWin.nrow / 4);
+                        scr_page (DN, nrow / 4);
 # endif
                       else
                         scrollBar.setMotion ();
                     }
                   else
                     {
                       scr_page ((ev.button == Button1 ? DN : UP),
-                                (TermWin.nrow
+                                (nrow
                                  * scrollbar_position (ev.y)
                                  / scrollbar_size ()));
                     }
                   break;
               }
         }
       return;
     }
 #if MENUBAR
   /*
    * Menubar window processing of button press
    */
   if (isMenuBarWindow (ev.window))
 #ifdef SELECTION_SCROLLING
   if (sel_scroll_ev.active)
     sel_scroll_ev.stop();
 #endif
-  if (ev.window == TermWin.vt)
+  if (ev.window == vt)
     {
 #if ISO_14755
       // 5.4
       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
         return;
       if (priv_modes & PrivMode_mouse_report
           && bypass_keystate
           && ev.button == Button1 && MEvent.clicks <= 1)
         selection_extend (ev.x, ev.y, 0);
+      if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
+        return;
       switch (ev.button)
         {
           case Button1:
           case Button3:
             selection_make (ev.time);
               v = ev.button == Button4 ? UP : DN;
               if (ev.state & ShiftMask)
                 i = 1;
-              else if (options & Opt_mouseWheelScrollPage)
+              else if (OPTION (Opt_mouseWheelScrollPage))
-                i = TermWin.nrow - 1;
+                i = nrow - 1;
               else
                 i = 5;
 # ifdef MOUSE_SLIP_WHEELING
               if (ev.state & ControlMask)
                 {
                   mouse_slip_wheel_speed += v ? -1 : 1;
-                  if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
+                  if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
-                  if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
+                  if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
                   if (slip_wheel_ev.at < NOW)
                     slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
                   slip_wheel_ev.start ();
   XWindowAttributes wattr, wrootattr;
   dDisp;
   pchanged = 0;
-  if (!(options & Opt_transparent))
+  if (!OPTION (Opt_transparent))
     return pchanged;	/* Don't try any more */
   XGetWindowAttributes (disp, display->root, &wrootattr);
   rootdepth = wrootattr.depth;
-  XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+  XGetWindowAttributes (disp, parent[0], &wattr);
   if (rootdepth != wattr.depth)
     {
       if (am_transparent)
         {
           pchanged = 1;
-          XSetWindowBackground (disp, TermWin.vt, pix_colors_focused[Color_bg]);
+          XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
           am_transparent = am_pixmap_trans = 0;
         }
       return pchanged;	/* Don't try any more */
     }
       Window cr;
       XImage *image;
       GC gc;
       XGCValues gcvalue;
-      XTranslateCoordinates (disp, TermWin.parent[0], display->root,
+      XTranslateCoordinates (disp, parent[0], display->root,
                              0, 0, &sx, &sy, &cr);
       nw = (unsigned int)szHint.width;
       nh = (unsigned int)szHint.height;
       nx = ny = 0;
           nh += sy;
           ny = -sy;
           sy = 0;
         }
-      MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
+      min_it (nw, (unsigned int) (wrootattr.width - sx));
-      MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
+      min_it (nh, (unsigned int) (wrootattr.height - sy));
       XSync (disp, False);
       allowedxerror = -1;
       image = XGetImage (disp, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
       if (image == NULL)
         {
           if (am_transparent && am_pixmap_trans)
             {
               pchanged = 1;
-              if (TermWin.pixmap != None)
+              if (pixmap != None)
                 {
-                  XFreePixmap (disp, TermWin.pixmap);
+                  XFreePixmap (disp, pixmap);
-                  TermWin.pixmap = None;
+                  pixmap = None;
                 }
             }
           am_pixmap_trans = 0;
         }
       else
         {
-          if (TermWin.pixmap != None)
+          if (pixmap != None)
-            XFreePixmap (disp, TermWin.pixmap);
+            XFreePixmap (disp, pixmap);
 #if TINTING
           if (ISSET_PIXCOLOR (Color_tint))
             {
               unsigned short rm, gm, bm;
               ShadeXImage (display, image, shade, rm, gm, bm);
             }
 #endif
-          TermWin.pixmap = XCreatePixmap (disp, TermWin.vt,
+          pixmap = XCreatePixmap (disp, vt,
                                           szHint.width, szHint.height, image->depth);
-          gc = XCreateGC (disp, TermWin.vt, 0UL, &gcvalue);
+          gc = XCreateGC (disp, vt, 0UL, &gcvalue);
-          XPutImage (disp, TermWin.pixmap, gc, image, 0, 0,
+          XPutImage (disp, pixmap, gc, image, 0, 0,
                      nx, ny, image->width, image->height);
           XFreeGC (disp, gc);
           XDestroyImage (image);
-          XSetWindowBackgroundPixmap (disp, TermWin.parent[0], TermWin.pixmap);
+          XSetWindowBackgroundPixmap (disp, parent[0], pixmap);
-          XClearWindow (disp, TermWin.parent[0]);
+          XClearWindow (disp, parent[0]);
           if (!am_transparent || !am_pixmap_trans)
             pchanged = 1;
           am_transparent = am_pixmap_trans = 1;
         }
     }
   if (am_pixmap_trans)
-    XSetWindowBackgroundPixmap (disp, TermWin.vt, ParentRelative);
+    XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
   else
     {
       unsigned int n;
       /*
        * InheritPixmap transparency
        */
-      for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
+      for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
         {
-          oldp = TermWin.parent[i];
+          oldp = parent[i];
-          XQueryTree (disp, TermWin.parent[i - 1], &root,
+          XQueryTree (disp, parent[i - 1], &root,
-                      &TermWin.parent[i], &list, &n);
+                      &parent[i], &list, &n);
           XFree (list);
-          if (TermWin.parent[i] == display->root)
+          if (parent[i] == display->root)
             {
               if (oldp != None)
                 pchanged = 1;
               break;
             }
-          if (oldp != TermWin.parent[i])
+          if (oldp != parent[i])
             pchanged = 1;
         }
       n = 0;
       if (pchanged)
         {
           for (; n < (unsigned int)i; n++)
             {
-              XGetWindowAttributes (disp, TermWin.parent[n], &wattr);
+              XGetWindowAttributes (disp, parent[n], &wattr);
               if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
                 {
-                  n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
+                  n = (int) (sizeof (parent) / sizeof (Window)) + 1;
                   break;
                 }
             }
         }
-      if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
+      if (n > (int) (sizeof (parent) / sizeof (parent[0])))
         {
-          XSetWindowBackground (disp, TermWin.parent[0], pix_colors_focused[Color_fg]);
+          XSetWindowBackground (disp, parent[0], pix_colors_focused[Color_border]);
-          XSetWindowBackground (disp, TermWin.vt, pix_colors_focused[Color_bg]);
+          XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
           am_transparent = 0;
           /* XXX: also turn off Opt_transparent? */
         }
       else
         {
            * needed for fvwm2.2.2 (and before?) */
           sleep (1);
 #endif
           for (n = 0; n < (unsigned int)i; n++)
             {
-              XSetWindowBackgroundPixmap (disp, TermWin.parent[n], ParentRelative);
+              XSetWindowBackgroundPixmap (disp, parent[n], ParentRelative);
-              XClearWindow (disp, TermWin.parent[n]);
+              XClearWindow (disp, parent[n]);
             }
-          XSetWindowBackgroundPixmap (disp, TermWin.vt, ParentRelative);
+          XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
           am_transparent = 1;
         }
-      for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
+      for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
-        TermWin.parent[i] = None;
+        parent[i] = None;
     }
   if (scrollBar.win)
     {
       XSetWindowBackgroundPixmap (disp, scrollBar.win, ParentRelative);
 bool
 rxvt_term::cmd_parse ()
 {
   bool flag = false;
-  unicode_t ch = NOCHAR;
+  wchar_t ch = NOCHAR;
-  unsigned char *seq_begin; // remember start of esc-sequence here
+  char *seq_begin; // remember start of esc-sequence here
   for (;;)
     {
       if (ch == NOCHAR)
         {
           seq_begin = cmdbuf_ptr;
           ch = next_char ();
-        }
-      if (ch == NOCHAR) // TODO: improve
+          if (ch == NOCHAR)
-        break;
+            break;
+        }
       if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
         {
           if (!seen_input)
             {
               if (seen_resize && cmd_pid)
                 kill (-cmd_pid, SIGWINCH);
             }
           /* Read a text string from the input buffer */
-          unicode_t buf[UBUFSIZ];
+          wchar_t buf[UBUFSIZ];
           bool refreshnow = false;
           int nlines = 0;
-          unicode_t *str = buf;
+          wchar_t *str = buf;
+          wchar_t *eol = str + min (ncol, UBUFSIZ);
           for (;;)
             {
               if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
                 break;
               *str++ = ch;
-              if (ch == C0_LF)
+              if (ch == C0_LF || str >= eol)
                 {
+                  if (ch == C0_LF)
-                  nlines++;
+                    nlines++;
                   refresh_count++;
-                  if (!(options & Opt_jumpScroll)
+                  if (!OPTION (Opt_jumpScroll)
-                      || (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
+                      || (refresh_count >= refresh_limit * (nrow - 1)))
                     {
                       refreshnow = true;
+                      refresh_count = 0;
                       ch = NOCHAR;
                       break;
                     }
-                  // scr_add_lines only works for nlines <= TermWin.nrow - 1.
+                  // scr_add_lines only works for nlines <= nrow - 1.
-                  if (nlines >= TermWin.nrow - 1)
+                  if (nlines >= nrow - 1)
                     {
+                      if (!HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END)))
-                      scr_add_lines (buf, nlines, str - buf);
+                        scr_add_lines (buf, str - buf, nlines);
                       nlines = 0;
                       str = buf;
+                      eol = str + min (ncol, UBUFSIZ);
                     }
-                }
-              if (str >= buf + UBUFSIZ)
+                  if (str >= eol)
-                {
+                    {
+                      if (eol >= buf + UBUFSIZ)
+                        {
-                  ch = NOCHAR;
+                          ch = NOCHAR;
-                  break;
+                          break;
+                        }
+                      else
+                        eol = min (eol + ncol, buf + UBUFSIZ);
+                    }
                 }
               seq_begin = cmdbuf_ptr;
               ch = next_char ();
             }
+          if (!HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END)))
-          scr_add_lines (buf, nlines, str - buf);
+            scr_add_lines (buf, str - buf, nlines);
           /*
            * If there have been a lot of new lines, then update the screen
            * What the heck I'll cheat and only refresh less than every page-full.
            * the number of pages between refreshes is refresh_limit, which
            * is incremented here because we must be doing flat-out scrolling.
            */
           if (refreshnow)
             {
-              if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
+              if (OPTION (Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
                 refresh_limit++;
               else
                 {
                   flag = true;
                   scr_refresh (refresh_type);
+                  flush_ev.stop ();
                 }
             }
         }
       else
     }
   return flag;
 }
-// read the next octet
-unicode_t
-rxvt_term::next_octet ()
-{
-  return cmdbuf_ptr < cmdbuf_endp
-         ? *cmdbuf_ptr++
-         : NOCHAR;
-}
 // read the next character
-unicode_t
+wchar_t
 rxvt_term::next_char ()
 {
   while (cmdbuf_ptr < cmdbuf_endp)
     {
       // assume 7-bit to be ascii ALWAYS
-      if (*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)
+      if ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)
         return *cmdbuf_ptr++;
       wchar_t wc;
-      size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
+      size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
       if (len == (size_t)-2)
         {
           // the mbstate stores incomplete sequences. didn't know this :/
           cmdbuf_ptr = cmdbuf_endp;
           break;
         }
       if (len == (size_t)-1)
-        return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
+        return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
       // assume wchar == unicode
       cmdbuf_ptr += len;
       return wc & UNICODE_MASK;
     }
   return NOCHAR;
+}
+// read the next octet
+uint32_t
+rxvt_term::next_octet ()
+{
+  return cmdbuf_ptr < cmdbuf_endp
+         ? (unsigned char)*cmdbuf_ptr++
+         : NOCHAR;
 }
 /* rxvt_cmd_getc () - Return next input character */
 /*
  * Return the next input character after first passing any keyboard input
  * to the command.
  */
-unicode_t
+wchar_t
 rxvt_term::cmd_getc ()
 {
-  unicode_t c = next_char ();
+  wchar_t c = next_char ();
   if (c == NOCHAR)
     throw out_of_input;
   return c;
 }
-unicode_t
+uint32_t
 rxvt_term::cmd_get8 ()
 {
-  unicode_t c = next_octet ();
+  uint32_t c = next_octet ();
   if (c == NOCHAR)
     throw out_of_input;
   return c;
       case C0_ESC:
         process_escape_seq ();
         break;
       case C0_ENQ:	/* terminal Status */
         if (rs[Rs_answerbackstring])
-          tt_write ((const unsigned char *)rs[Rs_answerbackstring],
+          tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
-                    (unsigned int)strlen (rs[Rs_answerbackstring]));
         else
-          tt_write ((unsigned char *)VT100_ANS,
+          tt_write (VT100_ANS, strlen (VT100_ANS));
-                    (unsigned int)strlen (VT100_ANS));
         break;
       case C0_BEL:	/* bell */
         scr_bell ();
         break;
       case C0_BS:		/* backspace */
         break;
         /* 8.3.87: NEXT LINE */
       case C1_NEL:		/* ESC E */
         {
-          unicode_t nlcr[] = { C0_LF, C0_CR };
+          wchar_t nlcr[] = { C0_LF, C0_CR };
-          scr_add_lines (nlcr, 1, 2);
+          scr_add_lines (nlcr, sizeof (nlcr) / sizeof (nlcr [0]), 1);
         }
         break;
         /* kidnapped escape sequence: Should be 8.3.48 */
       case C1_ESA:		/* ESC G */
         process_dcs_seq ();
         break;
         /* 8.3.110: SINGLE CHARACTER INTRODUCER */
       case C1_SCI:		/* ESC Z */
-        tt_write ((const unsigned char *)ESCZ_ANSWER,
+        tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
-                 (unsigned int) (sizeof (ESCZ_ANSWER) - 1));
         break;			/* steal obsolete ESC [ c */
         /* 8.3.16: CONTROL SEQUENCE INTRODUCER */
       case C1_CSI:		/* ESC [ */
         process_csi_seq ();
       case CSI_SD:		/* 8.3.114: (1) SCROLL DOWN */
         arg[0] = -arg[0];
         /* FALLTHROUGH */
       case CSI_SU:		/* 8.3.148: (1) SCROLL UP */
-        scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
+        scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
         break;
       case CSI_DA:		/* 8.3.24: (0) DEVICE ATTRIBUTES */
-        tt_write ((const unsigned char *)VT100_ANS,
+        tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
-                  (unsigned int) (sizeof (VT100_ANS) - 1));
         break;
       case CSI_SGR:		/* 8.3.118: (0) SELECT GRAPHIC RENDITION */
         process_sgr_mode (nargs, arg);
         break;
               break;
             case 6:			/* CPR requested */
               scr_report_position ();
               break;
             case 7:			/* unofficial extension */
-              if (options & Opt_insecure)
+              if (OPTION (Opt_insecure))
                 tt_printf ("%-.250s\012", rs[Rs_display_name]);
               break;
             case 8:			/* unofficial extension */
               process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
               break;
     {
       /*
        * commands
        */
       case 1:			/* deiconify window */
-        XMapWindow (disp, TermWin.parent[0]);
+        XMapWindow (disp, parent[0]);
         break;
       case 2:			/* iconify window */
-        XIconifyWindow (disp, TermWin.parent[0], display->screen);
+        XIconifyWindow (disp, parent[0], display->screen);
         break;
       case 3:			/* set position (pixels) */
-        XMoveWindow (disp, TermWin.parent[0], args[1], args[2]);
+        XMoveWindow (disp, parent[0], args[1], args[2]);
         break;
       case 4:			/* set size (pixels) */
         set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
         break;
       case 5:			/* raise window */
-        XRaiseWindow (disp, TermWin.parent[0]);
+        XRaiseWindow (disp, parent[0]);
         break;
       case 6:			/* lower window */
-        XLowerWindow (disp, TermWin.parent[0]);
+        XLowerWindow (disp, parent[0]);
         break;
       case 7:			/* refresh window */
         scr_touch (true);
         break;
       case 8:			/* set size (chars) */
-        set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),
+        set_widthheight ((unsigned int) (args[2] * fwidth),
-                         (unsigned int) (args[1] * TermWin.fheight));
+                         (unsigned int) (args[1] * fheight));
         break;
       //case 9: NYI, TODO, restore maximized window or maximize window
       default:
         if (args[0] >= 24)	/* set height (chars) */
-          set_widthheight ((unsigned int)TermWin.width,
+          set_widthheight ((unsigned int)width,
-                           (unsigned int) (args[1] * TermWin.fheight));
+                           (unsigned int) (args[1] * fheight));
         break;
       /*
        * reports - some output format copied from XTerm
        */
       case 11:			/* report window state */
-        XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+        XGetWindowAttributes (disp, parent[0], &wattr);
         tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
         break;
       case 13:			/* report window position */
-        XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+        XGetWindowAttributes (disp, parent[0], &wattr);
-        XTranslateCoordinates (disp, TermWin.parent[0], wattr.root,
+        XTranslateCoordinates (disp, parent[0], wattr.root,
                                -wattr.border_width, -wattr.border_width,
                                &x, &y, &wdummy);
         tt_printf ("\033[3;%d;%dt", x, y);
         break;
       case 14:			/* report window size (pixels) */
-        XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+        XGetWindowAttributes (disp, parent[0], &wattr);
         tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
         break;
       case 18:			/* report text area size (chars) */
-        tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
+        tt_printf ("\033[8;%d;%dt", nrow, ncol);
         break;
       case 19:			/* report window size (chars) */
-        tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
+        tt_printf ("\033[9;%d;%dt", nrow, ncol);
         break;
       case 20:			/* report icon label */
         {
           char *s;
-          XGetIconName (disp, TermWin.parent[0], &s);
+          XGetIconName (disp, parent[0], &s);
-          tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : "");	/* 8bit ST */
+          tt_printf ("\033]L%-.250s\234", OPTION (Opt_insecure) && s ? s : "");	/* 8bit ST */
           XFree (s);
         }
         break;
       case 21:			/* report window title */
         {
           char *s;
-          XFetchName (disp, TermWin.parent[0], &s);
+          XFetchName (disp, parent[0], &s);
-          tt_printf ("\033]l%-.250s\234", (options & Opt_insecure) && s ? s : "");	/* 8bit ST */
+          tt_printf ("\033]l%-.250s\234", OPTION (Opt_insecure) && s ? s : "");	/* 8bit ST */
           XFree (s);
         }
         break;
     }
 }
 /*----------------------------------------------------------------------*/
 /*
  * get input up until STRING TERMINATOR (or BEL)
  * ends_how is terminator used. returned input must be free()'d
  */
-unsigned char *
+char *
 rxvt_term::get_to_st (unicode_t &ends_how)
 {
   unicode_t ch;
   bool seen_esc = false;
   unsigned int n = 0;
   string[n++] = '\0';
   ends_how = (ch == 0x5c ? C0_ESC : ch);
-  return (unsigned char *)rxvt_wcstombs (string);
+  return rxvt_wcstombs (string);
 }
 /*----------------------------------------------------------------------*/
 /*
  * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
  */
 void
 rxvt_term::process_dcs_seq ()
 {
-  unsigned char *s;
+  char *s;
   unicode_t eh;
   /*
    * Not handled yet
    */
   for (arg = 0; isdigit (ch); ch = cmd_getc ())
     arg = arg * 10 + (ch - '0');
   if (ch == ';')
     {
-      unsigned char *s = get_to_st (eh);
+      char *s = get_to_st (eh);
       if (s)
         {
-          process_xterm_seq (arg, (char *)s, eh);
+          process_xterm_seq (arg, s, eh);
           free (s);
         }
     }
 }
 void
-rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
+rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
 {
   if (str[0] == '?' && !str[1])
     {
       unsigned short r, g, b;
       pix_colors_focused[color].get (display, r, g, b);
 /*
  * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
  */
 void
-rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp)
+rxvt_term::process_xterm_seq (int op, const char *str, char resp)
 {
   int changed = 0;
   int color;
   char *buf, *name;
   bool query = str[0] == '?' && !str[1];
             unsigned long bytes_after;
             unsigned char *value = 0;
             const char *str = "";
             if (prop
-                && XGetWindowProperty (disp, TermWin.parent[0],
+                && XGetWindowProperty (disp, parent[0],
                                        prop, 0, 1<<16, 0, AnyPropertyType,
                                        &actual_type, &actual_format,
                                        &nitems, &bytes_after, &value) == Success
                 && actual_type != None
                 && actual_format == 8)
               {
                 *eq = 0;
                 set_utf8_property (display->atom (str), eq + 1);
               }
             else
-              XDeleteProperty (disp, TermWin.parent[0],
+              XDeleteProperty (disp, parent[0],
                                display->atom (str));
           }
         break;
       case XTerm_Color:
         // TODO, when secure mode?
         break;
 #ifdef MENUBAR
      case URxvt_Menu:
-       if (options & Opt_insecure)
+       if (OPTION (Opt_insecure))
          menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
        break;
 #endif
 #if 0
       case XTerm_dumpscreen:	/* no error notices */
       case URxvt_italicFont:
       case URxvt_boldItalicFont:
 #endif
         if (query)
           tt_printf ("\33]%d;%-.250s%c", saveop,
-                     (options & Opt_insecure) && TermWin.fontset[op - URxvt_font]->fontdesc
+                     OPTION (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
-                       ? TermWin.fontset[op - URxvt_font]->fontdesc : "",
+                       ? fontset[op - URxvt_font]->fontdesc : "",
                      resp);
         else
           {
             const char *&res = rs[Rs_font + (op - URxvt_font)];
         break;
 #if ENABLE_FRILLS
       case URxvt_locale:
         if (query)
-          tt_printf ("\33]%d;%-.250s%c", URxvt_locale, (options & Opt_insecure) ? locale : "", resp);
+          tt_printf ("\33]%d;%-.250s%c", URxvt_locale, OPTION (Opt_insecure) ? locale : "", resp);
         else
           {
             set_locale (str);
             pty.set_utf8_mode (enc_utf8);
             init_xlocale ();
           }
         break;
       case URxvt_view_up:
       case URxvt_view_down:
+        {
-        int lines = atoi (str);
+          int lines = atoi (str);
-        if (lines)
+          if (lines)
-          scr_page (op == URxvt_view_up ? UP : DN, lines);
+            scr_page (op == URxvt_view_up ? UP : DN, lines);
-        else
+          else
-          {
             scr_erase_savelines ();
-          }
+        }
+        break;
+#endif
+#if ENABLE_PERL
+      case URxvt_perl:
+        if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_STR, str, DT_END)))
+          ; // no responses yet
         break;
 #endif
     }
 }
 /*----------------------------------------------------------------------*/
           }
       /* extra handling for values with state unkept  */
       switch (arg[i])
         {
+#if ENABLE_STYLES
+          case 1021:
+            if (mode)
+              SET_OPTION (Opt_intensityStyles);
+            else
+              CLR_OPTION (Opt_intensityStyles);
+            scr_touch (true);
+            break;
+#endif
           case 1048:		/* alternative cursor save */
           case 1049:
-            if (options & Opt_secondaryScreen)
+            if (OPTION (Opt_secondaryScreen))
               if (mode == 0)
                 scr_cursor (RESTORE);
               else if (mode == 1)
                 scr_cursor (SAVE);
             break;
                */
               PrivMode (1, PrivMode_vt52);
               break;
             case 3:			/* 80/132 */
               if (priv_modes & PrivMode_132OK)
-                set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
+                set_widthheight (((state ? 132 : 80) * fwidth), height);
               break;
             case 4:			/* smooth scrolling */
-              if (state)
+              if (!state)
-                options &= ~Opt_jumpScroll;
+                SET_OPTION (Opt_jumpScroll);
               else
-                options |= Opt_jumpScroll;
+                CLR_OPTION (Opt_jumpScroll);
               break;
             case 5:			/* reverse video */
               scr_rvideo_mode (state);
               break;
             case 6:			/* relative/absolute origins  */
 #if 0
             case 1001:
               break;		/* X11 mouse highlighting */
 #endif
             case 1010:		/* scroll to bottom on TTY output inhibit */
-              if (state)
+              if (!state)
-                options &= ~Opt_scrollTtyOutput;
+                SET_OPTION (Opt_scrollTtyOutput);
               else
-                options |= Opt_scrollTtyOutput;
+                CLR_OPTION (Opt_scrollTtyOutput);
               break;
             case 1011:		/* scroll to bottom on key press */
               if (state)
-                options |= Opt_scrollTtyKeypress;
+                SET_OPTION (Opt_scrollTtyKeypress);
               else
-                options &= ~Opt_scrollTtyKeypress;
+                CLR_OPTION (Opt_scrollTtyKeypress);
               break;
             case 1047:		/* secondary screen w/ clearing last */
-              if (options & Opt_secondaryScreen)
+              if (OPTION (Opt_secondaryScreen))
                 if (current_screen != PRIMARY)
                   scr_erase_screen (2);
               scr_change_screen (state);
               break;
             case 1049:		/* secondary screen w/ clearing first */
               scr_change_screen (state);
-              if (options & Opt_secondaryScreen)
+              if (OPTION (Opt_secondaryScreen))
                 if (current_screen != PRIMARY)
                   scr_erase_screen (2);
               break;
             default:
               break;
             scr_color (Color_bg, Color_bg);
             break;
           //case 50: // not variable spacing
-#ifndef NO_BRIGHTCOLOR
+#if ENABLE_FRILLS
           case 90:
           case 91:		/* set bright fg color */
           case 92:
           case 93:
           case 94:
           case 106:
           case 107:
             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
             break;
 #endif
         }
     }
 }
 /*}}} */
  */
 void
 rxvt_term::tt_printf (const char *fmt,...)
 {
   va_list arg_ptr;
-  unsigned char buf[256];
+  char buf[256];
   va_start (arg_ptr, fmt);
   vsnprintf ((char *)buf, 256, fmt, arg_ptr);
   va_end (arg_ptr);
   tt_write (buf, strlen (buf));
  * or generated by us in response to a query ESC sequence.
  */
 const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
 void
-rxvt_term::tt_write (const unsigned char *data, unsigned int len)
+rxvt_term::tt_write (const char *data, unsigned int len)
 {
+  if (pty.pty < 0)
+    return;
   if (v_buflen == 0)
     {
       ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
       if ((unsigned int)written == len)
       data += written;
       len  -= written;
     }
-  v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
+  v_buffer = (char *)realloc (v_buffer, v_buflen + len);
   memcpy (v_buffer + v_buflen, data, len);
   v_buflen += len;
   pty_ev.set (EVENT_READ | EVENT_WRITE);
         }
       memmove (v_buffer, v_buffer + written, v_buflen);
     }
   else if (written != -1 || (errno != EAGAIN && errno != EINTR))
-    // original code just ignores this...
+    pty_ev.set (EVENT_READ);
-    destroy ();
 }
 /*----------------------- end-of-file (C source) -----------------------*/

Diff Legend

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

Comparing rxvt-unicode/src/command.C (file contents): Revision 1.202 by root, Sat Mar 12 23:35:14 2005 UTC vs. Revision 1.246 by root, Fri Jan 6 18:36:21 2006 UTC

Diff Legend

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.202 by root, Sat Mar 12 23:35:14 2005 UTC vs.
Revision 1.246 by root, Fri Jan 6 18:36:21 2006 UTC