src/command.C

   1 /*----------------------------------------------------------------------*
   2  * File:        command.C
   3  *----------------------------------------------------------------------*
   4  *
   5  * All portions of code are copyright by their respective author/s.
   6  * Copyright (c) 1992      John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
   7  *                              - original version
   8  * Copyright (c) 1994      Robert Nation <nation@rocket.sanders.lockheed.com>
   9  *                              - extensive modifications
  10  * Copyright (c) 1995      Garrett D'Amore <garrett@netcom.com>
  11  *                              - vt100 printing
  12  * Copyright (c) 1995      Steven Hirsch <hirsch@emba.uvm.edu>
  13  *                              - X11 mouse report mode and support for
  14  *                                DEC "private mode" save/restore functions.
  15  * Copyright (c) 1995      Jakub Jelinek <jj@gnu.ai.mit.edu>
  16  *                              - key-related changes to handle Shift+function
  17  *                                keys properly.
  18  * Copyright (c) 1997      MJ Olesen <olesen@me.queensu.ca>
  19  *                              - extensive modifications
  20  * Copyright (c) 1997      Raul Garcia Garcia <rgg@tid.es>
  21  *                              - modification and cleanups for Solaris 2.x
  22  *                                and Linux 1.2.x
  23  * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
  24  * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  25  *                              - extensive modifications
  26  * Copyright (c) 1998      Alfredo K. Kojima <kojima@windowmaker.org>
  27  * Copyright (c) 2001      Marius Gedminas
  28  *                              - Ctrl/Mod4+Tab works like Meta+Tab (options)
  29  * Copyright (c) 2003      Rob McMullen <robm@flipturn.org>
  30  * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
  31  * Copyright (c) 2007      Emanuele Giaquinta <e.giaquinta@glauco.it>
  32  *
  33  * This program is free software; you can redistribute it and/or modify
  34  * it under the terms of the GNU General Public License as published by
  35  * the Free Software Foundation; either version 2 of the License, or
  36  * (at your option) any later version.
  37  *
  38  * This program is distributed in the hope that it will be useful,
  39  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  41  * GNU General Public License for more details.
  42  *
  43  * You should have received a copy of the GNU General Public License
  44  * along with this program; if not, write to the Free Software
  45  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  46  *----------------------------------------------------------------------*/
  47
  48 /*{{{ includes: */
  49 #include "../config.h"
  50 #include "rxvt.h"
  51 #include "rxvtperl.h"
  52 #include "version.h"
  53 #include "command.h"
  54
  55 #ifdef KEYSYM_RESOURCE
  56 # include "keyboard.h"
  57 #endif
  58
  59 #include <csignal>
  60
  61 #if LINUX_YIELD_HACK
  62 # include <ctime>
  63 #endif
  64
  65 /*----------------------------------------------------------------------*/
  66
  67 #define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
  68
  69 #if ENABLE_FRILLS || ISO_14755
  70
  71 #define ISO_14755_STARTED       0x80000000UL
  72 #define ISO_14755_51            0x40000000UL // basic (section 5.1)
  73 #define ISO_14755_52            0x20000000UL // keycap (section 5.2)
  74 #define ISO_14755_54            0x10000000UL // code feedback (section 5.4)
  75 #define ISO_14755_MASK          0x0fffffffUL
  76
  77 #if ISO_14755
  78 static unsigned short iso14755_symtab[] = {
  79   // keysym,            unicode
  80   XK_Left,              0x2190,
  81   XK_KP_Left,           0x2190,
  82   XK_Up,                0x2191,
  83   XK_KP_Up,             0x2191,
  84   XK_Right,             0x2192,
  85   XK_KP_Right,          0x2192,
  86   XK_Down,              0x2193,
  87   XK_KP_Down,           0x2193,
  88   XK_Linefeed,          0x21b4,
  89   XK_Return,            0x21b5,
  90   XK_KP_Enter,          0x21b5,
  91
  92   XK_Prior,             0x21de,
  93   XK_Next,              0x21df,
  94   XK_Tab,               0x21e5,
  95   XK_ISO_Left_Tab,      0x21e6,
  96   XK_Shift_L,           0x21e7,
  97   XK_Shift_R,           0x21e7,
  98
  99   XK_Shift_Lock,        0x21eb,
 100   XK_ISO_Lock,          0x21eb,
 101   XK_Caps_Lock,         0x21ec,
 102   XK_Num_Lock,          0x21ed,
 103   XK_ISO_Level3_Shift,  0x21ee,
 104   XK_ISO_Level3_Lock,   0x21ef,
 105   XK_ISO_Group_Lock,    0x21f0,
 106   XK_Home,              0x21f1,
 107   XK_End,               0x21f2,
 108
 109   XK_Execute,           0x2318,
 110   XK_Begin,             0x2320,
 111   XK_Delete,            0x2326,
 112   XK_Clear,             0x2327,
 113   XK_BackSpace,         0x232b,
 114   XK_Insert,            0x2380,
 115   XK_Control_L,         0x2388,
 116   XK_Control_R,         0x2388,
 117   XK_Pause,             0x2389,
 118   XK_Break,             0x238a,
 119   XK_Escape,            0x238b,
 120   XK_Undo,              0x238c,
 121   XK_Print,             0x2399,
 122
 123   XK_space,             0x2423,
 124
 125 #ifdef XK_KP_Begin
 126   XK_KP_Prior,          0x21de,
 127   XK_KP_Next,           0x21df,
 128   XK_KP_Begin,          0x2320,
 129   XK_KP_Insert,         0x2380,
 130   XK_KP_Delete,         0x2326,
 131   XK_KP_Space,          0x2422,
 132 #endif
 133   0,
 134 };
 135
 136 void
 137 rxvt_term::iso14755_54 (int x, int y)
 138 {
 139   x = Pixel2Col (x);
 140   y = Pixel2Row (y);
 141
 142   if (!IN_RANGE_EXC (x, 0, ncol)
 143       || !IN_RANGE_EXC (y, 0, nrow))
 144     return;
 145
 146   for (;;)
 147     {
 148       const line_t &l = ROW(y + view_start);
 149
 150       text_t t = l.t[x];
 151
 152       if (t != NOCHAR || !x)
 153         {
 154           iso14755_51 (l.t[x], l.r[x], x, y);
 155           iso14755buf = ISO_14755_54;
 156           break;
 157         }
 158
 159       x--;
 160     }
 161 }
 162
 163 void
 164 rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)
 165 {
 166   rxvt_fontset *fs = FONTSET (r);
 167   rxvt_font *f = (*fs)[fs->find_font (ch)];
 168   wchar_t *chr, *alloc, ch2, *fname;
 169   int len;
 170
 171   fname = rxvt_utf8towcs (f->name);
 172
 173 # if ENABLE_COMBINING
 174   if (IS_COMPOSE (ch))
 175     {
 176       len = rxvt_composite.expand (ch, 0);
 177       alloc = chr = new wchar_t[len];
 178       rxvt_composite.expand (ch, chr);
 179     }
 180   else
 181 # endif
 182     {
 183       ch2 = ch;
 184
 185       alloc = 0;
 186       chr = &ch2;
 187       len = 1;
 188     }
 189
 190   char attr[80]; // plenty
 191
 192   sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
 193            (int)r,
 194            fgcolor_of (r), bgcolor_of (r),
 195            r & RS_Bold    ? " bold"    : "",
 196            r & RS_Italic  ? " italic"  : "",
 197            r & RS_Blink   ? " blink"   : "",
 198            r & RS_RVid    ? " rvid"    : "",
 199            r & RS_Uline   ? " uline"   : "",
 200            r & RS_Careful ? " careful" : "");
 201
 202   int width = wcswidth (fname, wcslen (fname));
 203
 204   max_it (width, 8+5); // for char + hex
 205   max_it (width, strlen (attr));
 206
 207   if (y >= 0)
 208     {
 209       y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;
 210       x = 0;
 211     }
 212
 213   scr_overlay_new (x, y, width, len + 2);
 214
 215   r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
 216
 217   for (int y = 0; y < len; y++)
 218     {
 219       char buf[9];
 220
 221       ch = *chr++;
 222
 223       sprintf (buf, "%8x", ch);
 224       scr_overlay_set (0, y, buf);
 225       scr_overlay_set (9, y, '=');
 226 # if !UNICODE_3
 227       if (ch >= 0x10000)
 228         ch = 0xfffd;
 229 # endif
 230       scr_overlay_set (11, y, ch, r);
 231
 232       if (WCWIDTH (ch) >= 2)
 233         scr_overlay_set (12, y, NOCHAR, r);
 234     }
 235
 236 //  {
 237 //    char buf[4+4+3+1];
 238 //    snprintf (buf, sizeof (buf), "(%.4d|%.4d)", x, y);
 239 //    scr_overlay_set (0, 0, buf);
 240 //  }
 241   scr_overlay_set (0, len    , attr);
 242   scr_overlay_set (0, len + 1, fname);
 243
 244   free (fname);
 245
 246 # if ENABLE_COMBINING
 247   if (alloc)
 248     delete [] alloc;
 249 # endif
 250 }
 251 #endif
 252
 253 void
 254 rxvt_term::commit_iso14755 ()
 255 {
 256   wchar_t ch[2];
 257
 258   ch[0] = iso14755buf & ISO_14755_MASK;
 259   ch[1] = 0;
 260
 261   if (iso14755buf & ISO_14755_51)
 262     {
 263       char mb[16];
 264       int len;
 265
 266       // allow verbatim 0-bytes and control-bytes to be entered
 267       if (ch[0] >= 0x20)
 268         len = wcstombs (mb, ch, 16);
 269       else
 270         {
 271           mb[0] = ch[0];
 272           len = 1;
 273         }
 274
 275       if (len > 0)
 276         tt_write (mb, len);
 277       else
 278         scr_bell ();
 279     }
 280
 281   iso14755buf = 0;
 282 }
 283
 284 static int
 285 hex_keyval (XKeyEvent &ev)
 286 {
 287   // check wether this event corresponds to a hex digit
 288   // if the modifiers had not been pressed.
 289   for (int index = 0; index < 8; index++)
 290     {
 291       KeySym k = XLookupKeysym (&ev, index);
 292
 293       if (k >= XK_KP_0 && k <= XK_KP_9) return k - XK_KP_0;
 294       else if (k >= XK_0 && k <= XK_9)  return k - XK_0;
 295       else if (k >= XK_a && k <= XK_f)  return k - XK_a + 10;
 296       else if (k >= XK_A && k <= XK_F)  return k - XK_A + 10;
 297     }
 298
 299   return -1;
 300 }
 301 #endif
 302
 303 static inline KeySym
 304 translate_keypad (KeySym keysym, bool kp)
 305 {
 306 #ifdef XK_KP_Home
 307   static const KeySym keypadtrans[] = {
 308     XK_KP_7, // XK_KP_Home
 309     XK_KP_4, // XK_KP_Left
 310     XK_KP_8, // XK_KP_Up
 311     XK_KP_6, // XK_KP_Right
 312     XK_KP_2, // XK_KP_Down
 313 # ifndef UNSHIFTED_SCROLLKEYS
 314     XK_KP_9, // XK_KP_Prior
 315     XK_KP_3, // XK_KP_Next
 316 # else
 317     XK_Prior,
 318     XK_Next,
 319 # endif
 320     XK_KP_1, // XK_KP_End
 321     XK_KP_5, // XK_KP_Begin
 322   };
 323
 324   if (IN_RANGE_INC (keysym, XK_KP_Home, XK_KP_Begin))
 325     {
 326       unsigned int index = keysym - XK_KP_Home;
 327       keysym = kp ? keypadtrans[index] : XK_Home + index;
 328     }
 329   else if (keysym == XK_KP_Insert)
 330     keysym = kp ? XK_KP_0 : XK_Insert;
 331 # ifndef NO_DELETE_KEY
 332   else if (keysym == XK_KP_Delete)
 333     keysym = kp ? XK_KP_Decimal : XK_Delete;
 334 # endif
 335 #endif
 336   return keysym;
 337 }
 338
 339 static inline int
 340 map_function_key (KeySym keysym)
 341 {
 342   int param = 0;
 343
 344   if (IN_RANGE_INC (keysym, XK_F1, XK_F35))
 345     {
 346       param = 11 + keysym - XK_F1;
 347       if (keysym >= XK_F17)
 348         param += 4;
 349       else if (keysym >= XK_F15)
 350         param += 3;
 351       else if (keysym >= XK_F11)
 352         param += 2;
 353       else if (keysym >= XK_F6)
 354         param += 1;
 355     }
 356   else
 357     switch (keysym)
 358       {
 359         case XK_Find:
 360           param = 1;
 361           break;
 362         case XK_Insert:
 363           param = 2;
 364           break;
 365 #ifdef DXK_Remove
 366         case DXK_Remove:
 367 #endif
 368         case XK_Execute:
 369           param = 3;
 370           break;
 371         case XK_Select:
 372           param = 4;
 373           break;
 374 #ifndef UNSHIFTED_SCROLLKEYS
 375         case XK_Prior:
 376           param = 5;
 377           break;
 378         case XK_Next:
 379           param = 6;
 380           break;
 381 #endif
 382         case XK_Help:
 383           param = 28;
 384           break;
 385         case XK_Menu:
 386           param = 29;
 387           break;
 388       }
 389   return param;
 390 }
 391
 392 void
 393 rxvt_term::key_press (XKeyEvent &ev)
 394 {
 395   int ctrl, meta, shft, len;
 396   KeySym keysym;
 397   int valid_keysym;
 398   char kbuf[KBUFSZ];
 399
 400 #if ISO_14755
 401   if (iso14755buf & ISO_14755_52)
 402     return;
 403 #endif
 404
 405   /*
 406    * use Num_Lock to toggle Keypad on/off.  If Num_Lock is off, allow an
 407    * escape sequence to toggle the Keypad.
 408    *
 409    * Always permit `shift' to override the current setting
 410    */
 411   shft = ev.state & ShiftMask;
 412   ctrl = ev.state & ControlMask;
 413   meta = ev.state & ModMetaMask;
 414
 415   if (numlock_state || (ev.state & ModNumLockMask))
 416     {
 417       numlock_state = (ev.state & ModNumLockMask);
 418       PrivMode ((!numlock_state), PrivMode_aplKP);
 419     }
 420
 421   kbuf[0] = 0;
 422
 423 #ifdef USE_XIM
 424   if (Input_Context)
 425     {
 426       Status status_return;
 427
 428 #if 0
 429 #ifdef X_HAVE_UTF8_STRING
 430       if (enc_utf8 && 0) // currently disabled, doesn't seem to work, nor is useful
 431         len = Xutf8LookupString (Input_Context, &ev, kbuf,
 432                                  KBUFSZ, &keysym, &status_return);
 433       else
 434 #endif
 435 #endif
 436         {
 437           wchar_t wkbuf[KBUFSZ + 1];
 438
 439           // the XOpenIM manpage lies about hardcoding the locale
 440           // at the point of XOpenIM, so temporarily switch locales
 441           if (rs[Rs_imLocale])
 442             SET_LOCALE (rs[Rs_imLocale]);
 443
 444           // assume wchar_t == unicode or better
 445           len = XwcLookupString (Input_Context, &ev, wkbuf,
 446                                  KBUFSZ, &keysym, &status_return);
 447
 448           if (rs[Rs_imLocale])
 449             SET_LOCALE (locale);
 450
 451           if (status_return == XLookupChars
 452               || status_return == XLookupBoth)
 453             {
 454               /* make sure the user can type ctrl-@, i.e. NUL */
 455               if (len == 1 && *wkbuf == 0)
 456                 {
 457                   kbuf[0] = 0;
 458                   len = 1;
 459                 }
 460               else
 461                 {
 462                   wkbuf[len] = 0;
 463                   len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);
 464                   if (len < 0)
 465                     len = 0;
 466                 }
 467             }
 468           else
 469             len = 0;
 470         }
 471
 472       valid_keysym = status_return == XLookupKeySym
 473                      || status_return == XLookupBoth;
 474     }
 475   else
 476 #endif
 477     {
 478       len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);
 479       valid_keysym = keysym != NoSymbol;
 480     }
 481
 482   if (valid_keysym)
 483     {
 484 #ifdef KEYSYM_RESOURCE
 485       if (keyboard->dispatch (this, keysym, ev.state))
 486         return;
 487 #endif
 488
 489       if (saveLines)
 490         {
 491 #ifdef UNSHIFTED_SCROLLKEYS
 492           if (!ctrl && !meta)
 493 #else
 494           if (IS_SCROLL_MOD)
 495 #endif
 496             {
 497               int lnsppg;
 498
 499 #ifdef PAGING_CONTEXT_LINES
 500               lnsppg = nrow - PAGING_CONTEXT_LINES;
 501 #else
 502               lnsppg = nrow * 4 / 5;
 503 #endif
 504               if (keysym == XK_Prior)
 505                 {
 506                   scr_page (UP, lnsppg);
 507                   return;
 508                 }
 509               else if (keysym == XK_Next)
 510                 {
 511                   scr_page (DN, lnsppg);
 512                   return;
 513                 }
 514             }
 515 #ifdef SCROLL_ON_UPDOWN_KEYS
 516           if (IS_SCROLL_MOD)
 517             {
 518               if (keysym == XK_Up)
 519                 {
 520                   scr_page (UP, 1);
 521                   return;
 522                 }
 523               else if (keysym == XK_Down)
 524                 {
 525                   scr_page (DN, 1);
 526                   return;
 527                 }
 528             }
 529 #endif
 530 #ifdef SCROLL_ON_HOMEEND_KEYS
 531           if (IS_SCROLL_MOD)
 532             {
 533               if (keysym == XK_Home)
 534                 {
 535                   scr_move_to (0, 1);
 536                   return;
 537                 }
 538               else if (keysym == XK_End)
 539                 {
 540                   scr_move_to (1, 1);
 541                   return;
 542                 }
 543             }
 544 #endif
 545         }
 546
 547       if (shft)
 548         {
 549           /* Shift + F1 - F10 generates F11 - F20 */
 550           if (keysym >= XK_F1 && keysym <= XK_F10)
 551             {
 552               keysym += (XK_F11 - XK_F1);
 553               shft = 0; /* turn off Shift */
 554             }
 555           else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
 556             {
 557               switch (keysym)
 558                 {
 559                     /* normal XTerm key bindings */
 560                   case XK_Insert:       /* Shift+Insert = paste mouse selection */
 561                     selection_request (ev.time);
 562                     return;
 563 #if TODO
 564                     /* rxvt extras */
 565                   case XK_KP_Add:       /* Shift+KP_Add = bigger font */
 566                     change_font (FONT_UP);
 567                     return;
 568                   case XK_KP_Subtract:  /* Shift+KP_Subtract = smaller font */
 569                     change_font (FONT_DN);
 570                     return;
 571 #endif
 572                 }
 573             }
 574         }
 575
 576 #if ENABLE_FRILLS || ISO_14755
 577       // ISO 14755 support
 578       if (shft && ctrl)
 579         {
 580           int hv;
 581
 582           if (iso14755buf & ISO_14755_51
 583               && (keysym == XK_space || keysym == XK_KP_Space
 584                   || keysym == XK_Return || keysym == XK_KP_Enter))
 585             {
 586               commit_iso14755 ();
 587               iso14755buf = ISO_14755_51;
 588 # if ISO_14755
 589               iso14755_51 (0);
 590 # endif
 591               return;
 592             }
 593           else if (keysym == XK_BackSpace)
 594             {
 595               iso14755buf = ((iso14755buf & ISO_14755_MASK) >> 4) | ISO_14755_51;
 596 # if ISO_14755
 597               iso14755_51 (iso14755buf & ISO_14755_MASK);
 598 # endif
 599               return;
 600             }
 601           else if ((hv = hex_keyval (ev)) >= 0)
 602             {
 603               iso14755buf = ((iso14755buf << 4) & ISO_14755_MASK)
 604                           | hv | ISO_14755_51;
 605 # if ISO_14755
 606               iso14755_51 (iso14755buf & ISO_14755_MASK);
 607 # endif
 608               return;
 609             }
 610           else
 611             {
 612 # if ISO_14755
 613               scr_overlay_off ();
 614 # endif
 615               iso14755buf = 0;
 616             }
 617         }
 618       else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
 619                || (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))
 620         if (!(iso14755buf & ISO_14755_STARTED))
 621           {
 622             iso14755buf |= ISO_14755_STARTED;
 623 # if ISO_14755
 624             scr_overlay_new (0, -1, sizeof ("ISO 14755 mode") - 1, 1);
 625             scr_overlay_set (0, 0, "ISO 14755 mode");
 626 # endif
 627           }
 628 #endif
 629
 630 #ifdef PRINTPIPE
 631       if (keysym == XK_Print)
 632         {
 633           scr_printscreen (ctrl | shft);
 634           return;
 635         }
 636 #endif
 637
 638       if (keysym >= 0xFF00 && keysym <= 0xFFFF)
 639         {
 640               bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
 641               unsigned int newlen = 1;
 642
 643               switch (translate_keypad (keysym, kp))
 644                 {
 645 #ifndef NO_BACKSPACE_KEY
 646                   case XK_BackSpace:
 647                     if (priv_modes & PrivMode_HaveBackSpace)
 648                       {
 649                         kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
 650                                    ^ !!ctrl) ? '\b' : '\177';
 651                         kbuf[1] = '\0';
 652                       }
 653                     else
 654                       strcpy (kbuf, rs[Rs_backspace_key]);
 655                     break;
 656 #endif
 657 #ifndef NO_DELETE_KEY
 658                   case XK_Delete:
 659                     strcpy (kbuf, rs[Rs_delete_key]);
 660                     break;
 661 #endif
 662                   case XK_Tab:
 663                     if (shft)
 664                       strcpy (kbuf, "\033[Z");
 665                     else
 666                       {
 667 #ifdef CTRL_TAB_MAKES_META
 668                         if (ctrl)
 669                           meta = 1;
 670 #endif
 671 #ifdef MOD4_TAB_MAKES_META
 672                         if (ev.state & Mod4Mask)
 673                           meta = 1;
 674 #endif
 675                         newlen = 0;
 676                       }
 677                     break;
 678
 679                   case XK_Up:   /* "\033[A" */
 680                   case XK_Down: /* "\033[B" */
 681                   case XK_Right:        /* "\033[C" */
 682                   case XK_Left: /* "\033[D" */
 683                     strcpy (kbuf, "\033[Z");
 684                     kbuf[2] = "DACB"[keysym - XK_Left];
 685                     /* do Shift first */
 686                     if (shft)
 687                       kbuf[2] = "dacb"[keysym - XK_Left];
 688                     else if (ctrl)
 689                       {
 690                         kbuf[1] = 'O';
 691                         kbuf[2] = "dacb"[keysym - XK_Left];
 692                       }
 693                     else if (priv_modes & PrivMode_aplCUR)
 694                       kbuf[1] = 'O';
 695                     break;
 696
 697                   case XK_KP_Enter:
 698                     /* allow shift to override */
 699                     if (kp)
 700                       {
 701                         strcpy (kbuf, "\033OM");
 702                         break;
 703                       }
 704
 705                     /* FALLTHROUGH */
 706
 707                   case XK_Return:
 708                     if (priv_modes & PrivMode_LFNL)
 709                       {
 710                         kbuf[0] = '\015';
 711                         kbuf[1] = '\012';
 712                         kbuf[2] = '\0';
 713                       }
 714                     else
 715                       {
 716                         kbuf[0] = '\015';
 717                         kbuf[1] = '\0';
 718                       }
 719                     break;
 720
 721                   case XK_KP_F1:        /* "\033OP" */
 722                   case XK_KP_F2:        /* "\033OQ" */
 723                   case XK_KP_F3:        /* "\033OR" */
 724                   case XK_KP_F4:        /* "\033OS" */
 725                     strcpy (kbuf, "\033OP");
 726                     kbuf[2] += (keysym - XK_KP_F1);
 727                     break;
 728
 729                   case XK_KP_Multiply:  /* "\033Oj" : "*" */
 730                   case XK_KP_Add:       /* "\033Ok" : "+" */
 731                   case XK_KP_Separator: /* "\033Ol" : "," */
 732                   case XK_KP_Subtract:  /* "\033Om" : "-" */
 733                   case XK_KP_Decimal:   /* "\033On" : "." */
 734                   case XK_KP_Divide:    /* "\033Oo" : "/" */
 735                   case XK_KP_0:         /* "\033Op" : "0" */
 736                   case XK_KP_1:         /* "\033Oq" : "1" */
 737                   case XK_KP_2:         /* "\033Or" : "2" */
 738                   case XK_KP_3:         /* "\033Os" : "3" */
 739                   case XK_KP_4:         /* "\033Ot" : "4" */
 740                   case XK_KP_5:         /* "\033Ou" : "5" */
 741                   case XK_KP_6:         /* "\033Ov" : "6" */
 742                   case XK_KP_7:         /* "\033Ow" : "7" */
 743                   case XK_KP_8:         /* "\033Ox" : "8" */
 744                   case XK_KP_9:         /* "\033Oy" : "9" */
 745                     /* allow shift to override */
 746                     if (kp)
 747                       {
 748                         strcpy (kbuf, "\033Oj");
 749                         kbuf[2] += (keysym - XK_KP_Multiply);
 750                       }
 751                     else
 752                       {
 753                         kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
 754                         kbuf[1] = '\0';
 755                       }
 756                     break;
 757
 758                   case XK_End:
 759                     strcpy (kbuf, KS_END);
 760                     break;
 761                   case XK_Home:
 762                     strcpy (kbuf, KS_HOME);
 763                     break;
 764
 765                   default:
 766                     {
 767                       int param = map_function_key (keysym);
 768                       if (param > 0)
 769                         sprintf (kbuf,"\033[%d~", param);
 770                       else
 771                         newlen = 0;
 772                     }
 773                     break;
 774                 }
 775
 776               if (newlen)
 777                 len = strlen (kbuf);
 778
 779           /*
 780            * Pass meta for all function keys, if 'meta' option set
 781            */
 782 #ifdef META8_OPTION
 783           if (meta && (meta_char == 0x80) && len > 0)
 784             kbuf[len - 1] |= 0x80;
 785 #endif
 786
 787         }
 788       else if (ctrl && keysym == XK_minus)
 789         {
 790           len = 1;
 791           kbuf[0] = '\037';     /* Ctrl-Minus generates ^_ (31) */
 792         }
 793       else if (keysym == XK_ISO_Left_Tab)
 794         {
 795           strcpy (kbuf, "\033[Z");
 796           len = 3;
 797         }
 798       else
 799         {
 800 #ifdef META8_OPTION
 801           /* set 8-bit on */
 802           if (meta && (meta_char == 0x80))
 803             {
 804               char *ch;
 805
 806               for (ch = kbuf; ch < kbuf + len; ch++)
 807                 *ch |= 0x80;
 808
 809               meta = 0;
 810             }
 811 #endif
 812           /* nil */ ;
 813         }
 814     }
 815
 816   if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
 817     return;
 818
 819   if (len <= 0)
 820     return;                     /* not mapped */
 821
 822   if (option (Opt_scrollTtyKeypress))
 823     if (view_start)
 824       {
 825         view_start = 0;
 826         want_refresh = 1;
 827       }
 828
 829   /*
 830    * these modifications only affect the static keybuffer
 831    * pass Shift/Control indicators for function keys ending with `~'
 832    *
 833    * eg,
 834    *   Prior = "ESC[5~"
 835    *   Shift+Prior = "ESC[5$"
 836    *   Ctrl+Prior = "ESC[5^"
 837    *   Ctrl+Shift+Prior = "ESC[5@"
 838    * Meta adds an Escape prefix (with META8_OPTION, if meta == <escape>).
 839    */
 840   if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
 841     kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
 842
 843   /* escape prefix */
 844   if (meta
 845 #ifdef META8_OPTION
 846       && meta_char == C0_ESC
 847 #endif
 848      )
 849     {
 850       const char ch = C0_ESC;
 851       tt_write (&ch, 1);
 852     }
 853
 854   tt_write (kbuf, (unsigned int)len);
 855 }
 856
 857 void
 858 rxvt_term::key_release (XKeyEvent &ev)
 859 {
 860 #if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755 || ENABLE_PERL
 861   KeySym keysym;
 862
 863   keysym = XLookupKeysym (&ev, ev.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
 864 #endif
 865
 866 #if ENABLE_FRILLS || ISO_14755
 867   // ISO 14755 support
 868   if (iso14755buf)
 869     if (iso14755buf & ISO_14755_52)
 870       {
 871 # if ISO_14755
 872         scr_overlay_off ();
 873 # endif
 874 # if ISO_14755
 875         // iso14755 part 5.2 handling: release time
 876         // first: controls
 877         if ((ev.state & ControlMask)
 878              && ((keysym >= 0x40 && keysym <= 0x5f)
 879                  || (keysym >= 0x61 && keysym <= 0x7f)))
 880           {
 881             iso14755buf = ISO_14755_51 | 0x2400 | (keysym & 0x1f);
 882             commit_iso14755 ();
 883
 884             return;
 885           }
 886
 887         for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
 888           if (i[0] == keysym)
 889             {
 890               iso14755buf = ISO_14755_51 | i[1];
 891               commit_iso14755 ();
 892
 893               return;
 894             }
 895
 896         scr_bell ();
 897 # endif
 898         iso14755buf = 0;
 899
 900         return;
 901       }
 902     else if ((ev.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
 903       {
 904 # if ISO_14755
 905         scr_overlay_off ();
 906 # endif
 907         if (iso14755buf & ISO_14755_51)
 908           commit_iso14755 ();
 909 #if ISO_14755
 910         else if (option (Opt_iso14755_52) && iso14755buf & ISO_14755_STARTED)
 911           {
 912             iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
 913
 914             scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
 915             scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
 916           }
 917 # endif
 918         else
 919           iso14755buf = 0;
 920       }
 921 #endif
 922
 923   if (HOOK_INVOKE ((this, HOOK_KEY_RELEASE, DT_XEVENT, &ev, DT_INT, keysym, DT_END)))
 924     return;
 925
 926 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
 927   if (!(ev.state & ControlMask))
 928     slip_wheel_ev.stop ();
 929   else if (keysym == XK_Control_L || keysym == XK_Control_R)
 930     mouse_slip_wheel_speed = 0;
 931 #endif
 932 }
 933
 934 #if defined (KEYSYM_RESOURCE)
 935 unsigned int
 936 rxvt_term::cmd_write (const char *str, unsigned int count)
 937 {
 938   unsigned int n, s;
 939
 940   n = cmdbuf_ptr - cmdbuf_base;
 941   s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
 942
 943   if (n > 0 && s < count)
 944     {
 945       memmove (cmdbuf_base, cmdbuf_ptr,
 946               (unsigned int) (cmdbuf_endp - cmdbuf_ptr));
 947       cmdbuf_ptr = cmdbuf_base;
 948       cmdbuf_endp -= n;
 949       s += n;
 950     }
 951
 952   if (count > s)
 953     {
 954       rxvt_warn ("data loss: cmd_write too large, continuing.\n");
 955       count = s;
 956     }
 957
 958   for (; count--;)
 959     *cmdbuf_endp++ = *str++;
 960
 961   cmd_parse ();
 962
 963   return 0;
 964 }
 965 #endif
 966
 967 void
 968 rxvt_term::flush ()
 969 {
 970   flush_ev.stop ();
 971
 972 #ifdef HAVE_BG_PIXMAP
 973   if (bgPixmap.check_clearChanged ())
 974     {
 975 //      scr_clear (true); This needs to be researched further!
 976       scr_touch (false);
 977     }
 978 #endif
 979
 980   if (want_refresh)
 981     {
 982       if (SHOULD_INVOKE (HOOK_LINE_UPDATE))
 983         {
 984           int row = view_start;
 985           int end_row = row + nrow;
 986
 987           while (row > top_row && ROW (row - 1).is_longer ())
 988             --row;
 989
 990           do
 991             {
 992               int start_row = row;
 993               line_t *l;
 994
 995               do
 996                 {
 997                   l = &ROW (row++);
 998
 999                   if (!(l->f & LINE_FILTERED))
1000                     {
1001                       // line not filtered, mark it as filtered
1002                       l->f |= LINE_FILTERED;
1003                       while (l->is_longer ())
1004                         {
1005                           l = &ROW (row++);
1006                           l->f |= LINE_FILTERED;
1007                         }
1008
1009                       // and filter it
1010                       HOOK_INVOKE ((this, HOOK_LINE_UPDATE, DT_INT, start_row, DT_END));
1011
1012                       break;
1013                     }
1014                 }
1015               while (l->is_longer () && row < end_row);
1016             }
1017           while (row < end_row);
1018         }
1019
1020       scr_refresh ();
1021       scrollbar_show (1);
1022 #ifdef USE_XIM
1023       IMSendSpot ();
1024 #endif
1025     }
1026
1027   display->flush ();
1028 }
1029
1030 /* checks wether a refresh is requested and starts the refresh timer */
1031 void
1032 rxvt_term::refresh_check ()
1033 {
1034   if (want_refresh && !flush_ev.is_active ())
1035     flush_ev.start (1. / 60.); // refresh at max. 60 Hz normally
1036
1037   display->flush ();
1038 }
1039
1040 void
1041 rxvt_term::flush_cb (ev::timer &w, int revents)
1042 {
1043   make_current ();
1044
1045   refresh_count = 0;
1046   flush ();
1047 }
1048
1049 #ifdef CURSOR_BLINK
1050 void
1051 rxvt_term::cursor_blink_cb (ev::timer &w, int revents)
1052 {
1053   hidden_cursor = !hidden_cursor;
1054   want_refresh = 1;
1055   refresh_check ();
1056 }
1057 #endif
1058
1059 #ifdef TEXT_BLINK
1060 void
1061 rxvt_term::text_blink_cb (ev::timer &w, int revents)
1062 {
1063   if (scr_refresh_rend (RS_Blink, RS_Blink))
1064     {
1065       hidden_text = !hidden_text;
1066       want_refresh = 1;
1067       refresh_check ();
1068     }
1069   else
1070     w.stop ();
1071 }
1072 #endif
1073
1074 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1075 void
1076 rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
1077 {
1078   if ((scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
1079       && scr_page (scrollBar.state == STATE_UP ? UP : DN, 1))
1080     {
1081       want_refresh = 1;
1082       refresh_check ();
1083     }
1084   else
1085     w.stop ();
1086 }
1087 #endif
1088
1089 #ifdef SELECTION_SCROLLING
1090 void
1091 rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
1092 {
1093   if (scr_page (scroll_selection_dir, scroll_selection_lines))
1094     {
1095       selection_extend (selection_save_x, selection_save_y, selection_save_state);
1096       want_refresh = 1;
1097       refresh_check ();
1098     }
1099   else
1100     w.stop ();
1101 }
1102 #endif
1103
1104 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1105 void
1106 rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
1107 {
1108   if (scr_changeview (view_start - mouse_slip_wheel_speed))
1109     {
1110       want_refresh = 1;
1111       refresh_check ();
1112     }
1113
1114   if (view_start == top_row || view_start == 0 || mouse_slip_wheel_speed == 0)
1115     {
1116       mouse_slip_wheel_speed = 0;
1117       w.stop ();
1118     }
1119 }
1120 #endif
1121
1122 #if LINUX_YIELD_HACK
1123 static struct event_handler
1124 {
1125   ev::prepare yield_ev;
1126
1127   void yield_cb (ev::prepare &w, int revents)
1128   {
1129     // this should really be sched_yield(), but the linux guys thought
1130     // that giving a process calling sched_yield () less cpu time than
1131     // ones with high nice levels is a useful thing to do. It surely is is
1132     // allowed by the sus... as is returning ENOSYS.
1133
1134     struct timespec ts = { 0, 0 };
1135     nanosleep (&ts, 0);
1136
1137     w.stop ();
1138   }
1139
1140   event_handler ()
1141   : yield_ev (this, &event_handler::yield_cb)
1142   {
1143   }
1144 } event_handler;
1145 #endif
1146
1147 bool
1148 rxvt_term::pty_fill ()
1149 {
1150   ssize_t n = cmdbuf_endp - cmdbuf_ptr;
1151
1152   if (CBUFSIZ == n)
1153     {
1154       rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
1155       n = 0;
1156     }
1157
1158   memmove (cmdbuf_base, cmdbuf_ptr, n);
1159   cmdbuf_ptr = cmdbuf_base;
1160   cmdbuf_endp = cmdbuf_ptr + n;
1161
1162   ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
1163
1164   if (r > 0)
1165     {
1166       cmdbuf_endp += r;
1167       return true;
1168     }
1169   else if (r < 0 && (errno == EAGAIN || errno == EINTR))
1170     {
1171 #if LINUX_YIELD_HACK
1172       if (display->is_local)
1173         event_handler.yield_ev.start ();
1174 #endif
1175     }
1176   else
1177     {
1178       pty_ev.stop ();
1179
1180       if (!option (Opt_hold))
1181         destroy ();
1182     }
1183
1184   return false;
1185 }
1186
1187 void
1188 rxvt_term::pty_cb (ev::io &w, int revents)
1189 {
1190   make_current ();
1191
1192   if (revents & ev::READ)
1193     // loop, but don't allow a single term to monopolize us
1194     while (pty_fill ())
1195       if (cmd_parse ())
1196         break;
1197
1198   if (revents & ev::WRITE)
1199     pty_write ();
1200
1201   refresh_check ();
1202 }
1203
1204 void
1205 rxvt_term::pointer_unblank ()
1206 {
1207   XDefineCursor (dpy, vt, TermWin_cursor);
1208   recolour_cursor ();
1209
1210 #ifdef POINTER_BLANK
1211   hidden_pointer = 0;
1212
1213   if (option (Opt_pointerBlank))
1214     pointer_ev.start (pointerBlankDelay);
1215 #endif
1216 }
1217
1218 #ifdef POINTER_BLANK
1219 void
1220 rxvt_term::pointer_blank ()
1221 {
1222   if (!option (Opt_pointerBlank))
1223     return;
1224
1225   XDefineCursor (dpy, vt, display->blank_cursor);
1226   XFlush (dpy);
1227
1228   hidden_pointer = 1;
1229 }
1230
1231 void
1232 rxvt_term::pointer_cb (ev::timer &w, int revents)
1233 {
1234   make_current ();
1235
1236   pointer_blank ();
1237 }
1238 #endif
1239
1240 void
1241 rxvt_term::mouse_report (XButtonEvent &ev)
1242 {
1243   int button_number, key_state = 0;
1244   int x, y;
1245   int code = 32;
1246
1247   x = Pixel2Col (ev.x);
1248   y = Pixel2Row (ev.y);
1249   if (ev.type == MotionNotify)
1250     {
1251       if (x == mouse_row && y == mouse_col)
1252         return;
1253       mouse_row = x;
1254       mouse_col = y;
1255       code += 32;
1256     }
1257
1258   if (MEvent.button == AnyButton)
1259     button_number = 3;
1260   else
1261     {
1262       button_number = MEvent.button - Button1;
1263       /* add 0x3D for wheel events, like xterm does */
1264       if (button_number >= 3)
1265         button_number += (64 - 3);
1266     }
1267
1268   if (priv_modes & PrivMode_MouseX10)
1269     {
1270       /*
1271        * do not report ButtonRelease
1272        * no state info allowed
1273        */
1274       key_state = 0;
1275       if (button_number == 3)
1276         return;
1277     }
1278   else
1279     {
1280       /* XTerm mouse reporting needs these values:
1281        *   4 = Shift
1282        *   8 = Meta
1283        *  16 = Control
1284        * plus will add in our own Double-Click reporting
1285        *  32 = Double Click
1286        */
1287       key_state = ((MEvent.state & ShiftMask) ? 4 : 0)
1288                   + ((MEvent.state & ModMetaMask) ? 8 : 0)
1289                   + ((MEvent.state & ControlMask) ? 16 : 0);
1290 #ifdef MOUSE_REPORT_DOUBLECLICK
1291       key_state += ((MEvent.clicks > 1) ? 32 : 0);
1292 #endif
1293     }
1294
1295 #if DEBUG_MOUSEREPORT
1296   fprintf (stderr, "Mouse [");
1297   if (key_state & 16)
1298     fputc ('C', stderr);
1299   if (key_state & 4)
1300     fputc ('S', stderr);
1301   if (key_state & 8)
1302     fputc ('A', stderr);
1303   if (key_state & 32)
1304     fputc ('2', stderr);
1305   fprintf (stderr, "]: <%d>, %d/%d\n",
1306           button_number,
1307           x + 1,
1308           y + 1);
1309 #endif
1310
1311   tt_printf ("\033[M%c%c%c",
1312             (code + button_number + key_state),
1313             (32 + x + 1),
1314             (32 + y + 1));
1315 }
1316
1317 /*{{{ process an X event */
1318 void
1319 rxvt_term::x_cb (XEvent &ev)
1320 {
1321   make_current ();
1322
1323   dLocal (Display *, dpy);
1324
1325   if (ev.xany.window == vt
1326       && SHOULD_INVOKE (HOOK_X_EVENT)
1327       && HOOK_INVOKE ((this, HOOK_X_EVENT, DT_XEVENT, &ev, DT_END)))
1328     return;
1329
1330   // for XQueryPointer
1331   Window unused_root, unused_child;
1332   int unused_root_x, unused_root_y;
1333   unsigned int unused_mask;
1334
1335   switch (ev.type)
1336     {
1337       case KeyPress:
1338         key_press (ev.xkey);
1339         break;
1340
1341       case KeyRelease:
1342         key_release (ev.xkey);
1343         break;
1344
1345       case ButtonPress:
1346         button_press (ev.xbutton);
1347         break;
1348
1349       case ButtonRelease:
1350         button_release (ev.xbutton);
1351         break;
1352
1353       case ClientMessage:
1354         if (ev.xclient.format == 32
1355             && !HOOK_INVOKE ((this, HOOK_CLIENT_MESSAGE, DT_XEVENT, &ev, DT_END)))
1356           {
1357             if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1358               {
1359                 if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1360                   {
1361                     if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1362                       {
1363                         if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1364                           destroy ();
1365                       }
1366 #if ENABLE_EWMH
1367                     else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1368                       XSendEvent (dpy, ev.xclient.window = display->root,
1369                                   False, SubstructureRedirectMask | SubstructureNotifyMask,
1370                                   &ev);
1371 #endif
1372                   }
1373               }
1374 #if ENABLE_XEMBED
1375             else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1376               {
1377                 if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
1378                   focus_in ();
1379                 else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
1380                   focus_out ();
1381               }
1382 #endif
1383           }
1384         break;
1385
1386         /*
1387          * XXX: this is not the _current_ arrangement
1388          * Here's my conclusion:
1389          * If the window is completely unobscured, use bitblt's
1390          * to scroll. Even then, they're only used when doing partial
1391          * screen scrolling. When partially obscured, we have to fill
1392          * in the GraphicsExpose parts, which means that after each refresh,
1393          * we need to wait for the graphics expose or Noexpose events,
1394          * which ought to make things real slow!
1395          */
1396       case VisibilityNotify:
1397         switch (ev.xvisibility.state)
1398           {
1399             case VisibilityUnobscured:
1400               refresh_type = FAST_REFRESH;
1401               break;
1402             case VisibilityPartiallyObscured:
1403               refresh_type = SLOW_REFRESH;
1404               break;
1405             default:
1406               refresh_type = NO_REFRESH;
1407               break;
1408           }
1409         break;
1410
1411       case FocusIn:
1412         if (ev.xfocus.detail != NotifyInferior
1413             && ev.xfocus.detail != NotifyPointer
1414             && ev.xfocus.mode != NotifyGrab)
1415           focus_in ();
1416         break;
1417
1418       case FocusOut:
1419         if (ev.xfocus.detail != NotifyInferior
1420             && ev.xfocus.detail != NotifyPointer
1421             && ev.xfocus.mode != NotifyGrab)
1422           focus_out ();
1423         break;
1424
1425       case ConfigureNotify:
1426         /*fprintf (stderr, "ConfigureNotify for %X, parent is %X, geom is %dx%d%+d%+d, old geom was %dx%d\n",
1427               ev.xconfigure.window, parent[0], ev.xconfigure.width, ev.xconfigure.height, ev.xconfigure.x, ev.xconfigure.y,
1428               szHint.width, szHint.height);*/
1429         if (ev.xconfigure.window == parent[0])
1430           {
1431             while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1432               ;
1433
1434             if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1435               {
1436                 seen_resize = 1;
1437                 resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1438               }
1439             else
1440               {
1441 #ifdef HAVE_BG_PIXMAP
1442                 if (bgPixmap.window_position_sensitive ())
1443                   {
1444                     if (mapped)
1445                       update_background ();
1446                     else
1447                       bgPixmap.invalidate ();
1448                   }
1449 #endif
1450               }
1451
1452             HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1453           }
1454         break;
1455
1456       case PropertyNotify:
1457         if (!HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END)))
1458           if (ev.xproperty.atom == xa[XA_VT_SELECTION]
1459               && ev.xproperty.state == PropertyNewValue)
1460             selection_property (ev.xproperty.window, ev.xproperty.atom);
1461
1462         break;
1463
1464       case SelectionClear:
1465         selection_clear ();
1466         break;
1467
1468       case SelectionNotify:
1469         if (selection_wait == Sel_normal)
1470           selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1471         break;
1472
1473       case SelectionRequest:
1474         selection_send (ev.xselectionrequest);
1475         break;
1476
1477       case MapNotify:
1478 #ifdef HAVE_BG_PIXMAP
1479         /* This is needed spcifically to fix the case of no window manager or a
1480          * non-reparenting window manager. In those cases we never get first
1481          * ConfigureNotify. Also that speeds startup under normal WM, by taking
1482          * care of multiplicity of ConfigureNotify events arriwing while WM does
1483          * reparenting.
1484          * We should not render background immidiately, as there could be several
1485          * ConfigureNotify's to follow. Lets take care of all of them in one scoop
1486          * by scheduling background redraw as soon as we can, but giving a short
1487          * bit of time for ConfigureNotifies to arrive.
1488          * We should render background PRIOR to drawing any text, but AFTER all
1489          * of ConfigureNotifys for the best results.
1490          */
1491         if (bgPixmap.flags & bgPixmap_t::isInvalid)
1492           update_background_ev.start (0.025);
1493 #endif
1494         mapped = 1;
1495 #ifdef TEXT_BLINK
1496         text_blink_ev.start ();
1497 #endif
1498         HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1499         break;
1500
1501       case UnmapNotify:
1502         mapped = 0;
1503 #ifdef TEXT_BLINK
1504         text_blink_ev.stop ();
1505 #endif
1506         HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1507         break;
1508
1509       case GraphicsExpose:
1510       case Expose:
1511         if (ev.xany.window == vt)
1512           {
1513             do
1514               {
1515                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1516                             ev.xexpose.width, ev.xexpose.height, False);
1517               }
1518             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev));
1519
1520             ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1521
1522             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev))
1523               {
1524                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1525                             ev.xexpose.width, ev.xexpose.height, False);
1526               }
1527
1528             want_refresh = 1;
1529           }
1530         else
1531           {
1532             XEvent unused_event;
1533
1534             while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1535               ;
1536             while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1537               ;
1538
1539             if (scrollBar.state && ev.xany.window == scrollBar.win)
1540               {
1541                 scrollBar.state = STATE_IDLE;
1542                 scrollbar_show (0);
1543               }
1544           }
1545         break;
1546
1547       case MotionNotify:
1548 #ifdef POINTER_BLANK
1549         if (hidden_pointer)
1550           pointer_unblank ();
1551 #endif
1552         if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1553             || priv_modes & PrivMode_MouseAnyEvent)
1554           mouse_report (ev.xbutton);
1555         if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1556           break;
1557
1558         if (ev.xany.window == vt)
1559           {
1560             if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1561                 && HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1562               ; // nop
1563             else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1564               {
1565                 while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1566                   ;
1567
1568                 XQueryPointer (dpy, vt,
1569                                &unused_root, &unused_child,
1570                                &unused_root_x, &unused_root_y,
1571                                &ev.xbutton.x, &ev.xbutton.y,
1572                                &ev.xbutton.state);
1573 #ifdef MOUSE_THRESHOLD
1574                 /* deal with a `jumpy' mouse */
1575                 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1576                   {
1577 #endif
1578 #if ISO_14755
1579                     // 5.4
1580                     if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1581                       {
1582                         iso14755_54 (ev.xbutton.x, ev.xbutton.y);
1583                         break;
1584                       }
1585 #endif
1586                     selection_extend (ev.xbutton.x, ev.xbutton.y,
1587                                       ev.xbutton.state & Button3Mask ? 2 : 0);
1588
1589 #ifdef SELECTION_SCROLLING
1590                     if (ev.xbutton.y < int_bwidth
1591                         || Pixel2Row (ev.xbutton.y) > (nrow-1))
1592                       {
1593                         int dist;
1594
1595                         /* don't clobber the current delay if we are
1596                          * already in the middle of scrolling.
1597                          */
1598                         if (!sel_scroll_ev.is_active ())
1599                           sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1600
1601                         /* save the event params so we can highlight
1602                          * the selection in the pending-scroll loop
1603                          */
1604                         selection_save_x = ev.xbutton.x;
1605                         selection_save_y = ev.xbutton.y;
1606                         selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1607
1608                         /* calc number of lines to scroll */
1609                         if (ev.xbutton.y < int_bwidth)
1610                           {
1611                             scroll_selection_dir = UP;
1612                             dist = int_bwidth - ev.xbutton.y;
1613                           }
1614                         else
1615                           {
1616                             scroll_selection_dir = DN;
1617                             dist = ev.xbutton.y - (int_bwidth + height);
1618                           }
1619
1620                         scroll_selection_lines = Pixel2Height (dist)
1621                                                  / SELECTION_SCROLL_LINE_SPEEDUP
1622                                                  + 1;
1623                         min_it (scroll_selection_lines,
1624                                 SELECTION_SCROLL_MAX_LINES);
1625                       }
1626                     else
1627                       {
1628                         /* we are within the text window, so we
1629                          * shouldn't be scrolling
1630                          */
1631                         sel_scroll_ev.stop();
1632                       }
1633 #endif
1634 #ifdef MOUSE_THRESHOLD
1635                   }
1636 #endif
1637               }
1638           }
1639         else if (scrollBar.state == STATE_MOTION && ev.xany.window == scrollBar.win)
1640           {
1641             while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1642                                            MotionNotify, &ev))
1643               ;
1644
1645             XQueryPointer (dpy, scrollBar.win,
1646                           &unused_root, &unused_child,
1647                           &unused_root_x, &unused_root_y,
1648                           &ev.xbutton.x, &ev.xbutton.y,
1649                           &unused_mask);
1650             scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1651                          scrollbar_size ());
1652             want_refresh = 1;
1653             scrollbar_show (1);
1654           }
1655         break;
1656     }
1657
1658 #if defined(CURSOR_BLINK)
1659   if (option (Opt_cursorBlink) && ev.type == KeyPress)
1660     {
1661       if (hidden_cursor)
1662         {
1663           hidden_cursor = 0;
1664           want_refresh = 1;
1665         }
1666
1667       cursor_blink_ev.again ();
1668     }
1669 #endif
1670
1671 #if defined(POINTER_BLANK)
1672   if (option (Opt_pointerBlank) && pointerBlankDelay > 0)
1673     {
1674       if (ev.type == MotionNotify
1675           || ev.type == ButtonPress
1676           || ev.type == ButtonRelease)
1677         if (hidden_pointer)
1678           pointer_unblank ();
1679
1680       if (ev.type == KeyPress && hidden_pointer == 0)
1681         pointer_blank ();
1682     }
1683 #endif
1684
1685   refresh_check ();
1686 }
1687
1688 void
1689 rxvt_term::focus_in ()
1690 {
1691   if (!focus)
1692     {
1693       focus = 1;
1694       want_refresh = 1;
1695
1696       HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1697
1698 #if USE_XIM
1699       if (Input_Context != NULL)
1700         {
1701           IMSetPosition ();
1702           XSetICFocus (Input_Context);
1703         }
1704 #endif
1705 #if CURSOR_BLINK
1706       if (option (Opt_cursorBlink))
1707         cursor_blink_ev.again ();
1708 #endif
1709 #if OFF_FOCUS_FADING
1710       if (rs[Rs_fade])
1711         {
1712           pix_colors = pix_colors_focused;
1713           scr_recolour ();
1714         }
1715 #endif
1716 #if ENABLE_FRILLS
1717       if (option (Opt_urgentOnBell))
1718         {
1719           if (XWMHints *h = XGetWMHints(dpy, parent[0]))
1720             {
1721               h->flags &= ~XUrgencyHint;
1722               XSetWMHints (dpy, parent[0], h);
1723             }
1724         }
1725 #endif
1726     }
1727 }
1728
1729 void
1730 rxvt_term::focus_out ()
1731 {
1732   if (focus)
1733     {
1734       focus = 0;
1735       want_refresh = 1;
1736
1737       HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1738
1739 #if ENABLE_FRILLS || ISO_14755
1740       if (iso14755buf)
1741         {
1742           iso14755buf = 0;
1743 # if ISO_14755
1744           scr_overlay_off ();
1745 # endif
1746         }
1747 #endif
1748 #if USE_XIM
1749       if (Input_Context != NULL)
1750         XUnsetICFocus (Input_Context);
1751 #endif
1752 #if CURSOR_BLINK
1753       if (option (Opt_cursorBlink))
1754         cursor_blink_ev.stop ();
1755
1756       hidden_cursor = 0;
1757 #endif
1758 #if OFF_FOCUS_FADING
1759       if (rs[Rs_fade])
1760         {
1761           pix_colors = pix_colors_unfocused;
1762           scr_recolour ();
1763         }
1764 #endif
1765     }
1766 }
1767
1768 void
1769 rxvt_term::update_fade_color (unsigned int idx)
1770 {
1771 #if OFF_FOCUS_FADING
1772   if (rs[Rs_fade])
1773     {
1774       rgba c;
1775       pix_colors [Color_fade].get (c);
1776       pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
1777     }
1778 #endif
1779 }
1780
1781 #if ENABLE_TRANSPARENCY || ENABLE_PERL
1782 void
1783 rxvt_term::rootwin_cb (XEvent &ev)
1784 {
1785   make_current ();
1786
1787   if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
1788       && HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
1789     return;
1790
1791 # if ENABLE_TRANSPARENCY
1792   switch (ev.type)
1793     {
1794       case PropertyNotify:
1795         /*
1796          * if user used some Esetroot compatible prog to set the root bg,
1797          * use the property to determine the pixmap.  We use it later on.
1798          */
1799         if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1800             || ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1801           {
1802             bgPixmap.set_root_pixmap ();
1803             update_background ();
1804           }
1805
1806         break;
1807     }
1808 # endif
1809
1810   refresh_check ();
1811 }
1812 #endif
1813
1814 void
1815 rxvt_term::button_press (XButtonEvent &ev)
1816 {
1817   int reportmode = 0, clickintime;
1818
1819   bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1820
1821   if (!bypass_keystate)
1822     reportmode = !! (priv_modes & PrivMode_mouse_report);
1823
1824   /*
1825    * VT window processing of button press
1826    */
1827   if (ev.window == vt)
1828     {
1829       if (HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
1830         return;
1831
1832 #if ISO_14755
1833       // 5.4
1834       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1835         {
1836           iso14755_54 (ev.x, ev.y);
1837           return;
1838         }
1839 #endif
1840
1841       clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1842
1843       if (reportmode)
1844         {
1845           /* mouse report from vt window */
1846           /* save the xbutton state (for ButtonRelease) */
1847           MEvent.state = ev.state;
1848 #ifdef MOUSE_REPORT_DOUBLECLICK
1849           if (ev.button == MEvent.button && clickintime)
1850             {
1851               /* same button, within alloted time */
1852               MEvent.clicks++;
1853
1854               if (MEvent.clicks > 1)
1855                 {
1856                   /* only report double clicks */
1857                   MEvent.clicks = 2;
1858                   mouse_report (ev);
1859
1860                   /* don't report the release */
1861                   MEvent.clicks = 0;
1862                   MEvent.button = AnyButton;
1863                 }
1864             }
1865           else
1866             {
1867               /* different button, or time expired */
1868               MEvent.clicks = 1;
1869               MEvent.button = ev.button;
1870               mouse_report (ev);
1871             }
1872 #else
1873           MEvent.button = ev.button;
1874           mouse_report (ev);
1875 #endif /* MOUSE_REPORT_DOUBLECLICK */
1876
1877         }
1878       else
1879         {
1880           if (ev.button != MEvent.button)
1881             MEvent.clicks = 0;
1882
1883           switch (ev.button)
1884             {
1885               case Button1:
1886                 /* allow meta + click to select rectangular areas */
1887                 /* should be done in screen.C */
1888 #if ENABLE_FRILLS
1889                 selection.rect = !!(ev.state & ModMetaMask);
1890 #else
1891                 selection.rect = false;
1892 #endif
1893
1894                 /* allow shift+left click to extend selection */
1895                 if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1896                   {
1897                     if (MEvent.button == Button1 && clickintime)
1898                       selection_rotate (ev.x, ev.y);
1899                     else
1900                       selection_extend (ev.x, ev.y, 1);
1901                   }
1902                 else
1903                   {
1904                     if (MEvent.button == Button1 && clickintime)
1905                       MEvent.clicks++;
1906                     else
1907                       MEvent.clicks = 1;
1908
1909                     selection_click (MEvent.clicks, ev.x, ev.y);
1910                   }
1911
1912                 MEvent.button = Button1;
1913                 break;
1914
1915               case Button3:
1916                 if (MEvent.button == Button3 && clickintime)
1917                   selection_rotate (ev.x, ev.y);
1918                 else
1919                   selection_extend (ev.x, ev.y, 1);
1920
1921                 MEvent.button = Button3;
1922                 break;
1923             }
1924         }
1925
1926       MEvent.time = ev.time;
1927       return;
1928     }
1929
1930   /*
1931    * Scrollbar window processing of button press
1932    */
1933   if (scrollBar.state && ev.window == scrollBar.win)
1934     {
1935       page_dirn direction = NO_DIR;
1936
1937       if (scrollBar.upButton (ev.y))
1938         direction = UP; /* up */
1939       else if (scrollBar.dnButton (ev.y))
1940         direction = DN;  /* down */
1941
1942       scrollBar.state = STATE_IDLE;
1943       /*
1944        * Rxvt-style scrollbar:
1945        * move up if mouse is above slider
1946        * move dn if mouse is below slider
1947        *
1948        * XTerm-style scrollbar:
1949        * Move display proportional to pointer location
1950        * pointer near top -> scroll one line
1951        * pointer near bot -> scroll full page
1952        */
1953 #ifndef NO_SCROLLBAR_REPORT
1954       if (reportmode)
1955         {
1956           /*
1957            * Mouse report disabled scrollbar:
1958            * arrow buttons - send up/down
1959            * click on scrollbar - send pageup/down
1960            */
1961           if (direction == UP)
1962             tt_printf ("\033[A");
1963           else if (direction == DN)
1964             tt_printf ("\033[B");
1965           else
1966             switch (ev.button)
1967               {
1968                 case Button2:
1969                   tt_printf ("\014");
1970                   break;
1971                 case Button1:
1972                   tt_printf ("\033[6~");
1973                   break;
1974                 case Button3:
1975                   tt_printf ("\033[5~");
1976                   break;
1977               }
1978         }
1979       else
1980 #endif /* NO_SCROLLBAR_REPORT */
1981         {
1982           if (direction != NO_DIR)
1983             {
1984 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1985               if (!cont_scroll_ev.is_active ())
1986                 cont_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1987 #endif
1988               if (scr_page (direction, 1))
1989                 {
1990                   if (direction == UP)
1991                     scrollBar.state = STATE_UP;
1992                   else
1993                     scrollBar.state = STATE_DOWN;
1994                 }
1995             }
1996           else
1997             switch (ev.button)
1998               {
1999                 case Button2:
2000                   switch (scrollBar.align)
2001                     {
2002                       case R_SB_ALIGN_TOP:
2003                         csrO = 0;
2004                         break;
2005                       case R_SB_ALIGN_CENTRE:
2006                         csrO = (scrollBar.bot - scrollBar.top) / 2;
2007                         break;
2008                       case R_SB_ALIGN_BOTTOM:
2009                         csrO = scrollBar.bot - scrollBar.top;
2010                         break;
2011                     }
2012
2013                   if (scrollBar.style == R_SB_XTERM
2014                       || scrollbar_above_slider (ev.y)
2015                       || scrollbar_below_slider (ev.y))
2016                     scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
2017
2018                   scrollBar.state = STATE_MOTION;
2019                   break;
2020
2021                 case Button1:
2022                   if (scrollBar.align == R_SB_ALIGN_CENTRE)
2023                     csrO = ev.y - scrollBar.top;
2024                   /* FALLTHROUGH */
2025
2026                 case Button3:
2027                   if (scrollBar.style != R_SB_XTERM)
2028                     {
2029                       if (scrollbar_above_slider (ev.y))
2030 # ifdef RXVT_SCROLL_FULL
2031                         scr_page (UP, nrow - 1);
2032 # else
2033                         scr_page (UP, nrow / 4);
2034 # endif
2035                       else if (scrollbar_below_slider (ev.y))
2036 # ifdef RXVT_SCROLL_FULL
2037                         scr_page (DN, nrow - 1);
2038 # else
2039                         scr_page (DN, nrow / 4);
2040 # endif
2041                       else
2042                         scrollBar.state = STATE_MOTION;
2043                     }
2044                   else
2045                     {
2046                       scr_page ((ev.button == Button1 ? DN : UP),
2047                                 (nrow
2048                                  * scrollbar_position (ev.y)
2049                                  / scrollbar_size ()));
2050                     }
2051
2052                   break;
2053               }
2054         }
2055
2056       return;
2057     }
2058 }
2059
2060 void
2061 rxvt_term::button_release (XButtonEvent &ev)
2062 {
2063   int reportmode = 0;
2064
2065   csrO = 0;             /* reset csr Offset */
2066   if (!bypass_keystate)
2067     reportmode = !! (priv_modes & PrivMode_mouse_report);
2068
2069   if (scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
2070     {
2071       scrollBar.state = STATE_IDLE;
2072       scrollbar_show (0);
2073     }
2074
2075 #ifdef SELECTION_SCROLLING
2076   sel_scroll_ev.stop();
2077 #endif
2078
2079   if (ev.window == vt)
2080     {
2081       if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
2082         return;
2083
2084 #if ISO_14755
2085       // 5.4
2086       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
2087         return;
2088 #endif
2089
2090       if (reportmode)
2091         {
2092           /* mouse report from vt window */
2093           /* don't report release of wheel "buttons" */
2094           if (ev.button >= 4)
2095             return;
2096 #ifdef MOUSE_REPORT_DOUBLECLICK
2097           /* only report the release of 'slow' single clicks */
2098           if (MEvent.button != AnyButton
2099               && (ev.button != MEvent.button
2100                   || (ev.time - MEvent.time
2101                       > MULTICLICK_TIME / 2)))
2102             {
2103               MEvent.clicks = 0;
2104               MEvent.button = AnyButton;
2105               mouse_report (ev);
2106             }
2107 #else                           /* MOUSE_REPORT_DOUBLECLICK */
2108           MEvent.button = AnyButton;
2109           mouse_report (ev);
2110 #endif /* MOUSE_REPORT_DOUBLECLICK */
2111           return;
2112         }
2113
2114       /*
2115        * dumb hack to compensate for the failure of click-and-drag
2116        * when overriding mouse reporting
2117        */
2118       if (priv_modes & PrivMode_mouse_report
2119           && bypass_keystate
2120           && ev.button == Button1 && MEvent.clicks <= 1)
2121         selection_extend (ev.x, ev.y, 0);
2122
2123       switch (ev.button)
2124         {
2125           case Button1:
2126           case Button3:
2127             selection_make (ev.time);
2128             break;
2129
2130           case Button2:
2131             if (IN_RANGE_EXC (ev.x, 0, width) && IN_RANGE_EXC (ev.y, 0, height)) // inside window?
2132               selection_request (ev.time, ev.state & ModMetaMask ? Sel_Clipboard : Sel_Primary);
2133             break;
2134
2135 #ifdef MOUSE_WHEEL
2136           case Button4:
2137           case Button5:
2138             {
2139               int i;
2140               page_dirn v;
2141
2142               v = ev.button == Button4 ? UP : DN;
2143
2144               if (ev.state & ShiftMask)
2145                 i = 1;
2146               else if (option (Opt_mouseWheelScrollPage))
2147                 i = nrow - 1;
2148               else
2149                 i = 5;
2150
2151 # ifdef MOUSE_SLIP_WHEELING
2152               if (ev.state & ControlMask)
2153                 {
2154                   mouse_slip_wheel_speed += v ? -1 : 1;
2155                   if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
2156                   if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
2157
2158                   if (!slip_wheel_ev.is_active ())
2159                     slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
2160                 }
2161               else
2162 # endif
2163                 {
2164                   scr_page (v, i);
2165                   scrollbar_show (1);
2166                 }
2167             }
2168             break;
2169 #endif
2170         }
2171     }
2172 }
2173
2174 /*}}} */
2175
2176 bool
2177 rxvt_term::cmd_parse ()
2178 {
2179   bool flag = false;
2180   wchar_t ch = NOCHAR;
2181   char *seq_begin; // remember start of esc-sequence here
2182
2183   for (;;)
2184     {
2185       if (ch == NOCHAR)
2186         {
2187           seq_begin = cmdbuf_ptr;
2188           ch = next_char ();
2189
2190           if (ch == NOCHAR)
2191             break;
2192         }
2193
2194       if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2195         {
2196           if (!seen_input)
2197             {
2198               seen_input = 1;
2199               // many badly-written programs (e.g. jed) contain a race condition:
2200               // they first read the screensize and then install a SIGWINCH handler.
2201               // some window managers resize the window early, and these programs
2202               // then sometimes get the size wrong.
2203               // unfortunately other programs are even more buggy and dislike
2204               // being sent SIGWINCH, so only do it when we were in fact being
2205               // resized.
2206               if (seen_resize && cmd_pid)
2207                 kill (-cmd_pid, SIGWINCH);
2208             }
2209
2210           /* Read a text string from the input buffer */
2211           wchar_t buf[UBUFSIZ];
2212           bool refreshnow = false;
2213           int nlines = 0;
2214           wchar_t *str = buf;
2215           wchar_t *eol = str + min (ncol, UBUFSIZ);
2216
2217           for (;;)
2218             {
2219               if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2220                 break;
2221
2222               *str++ = ch;
2223
2224               if (ch == C0_LF || str >= eol)
2225                 {
2226                   if (ch == C0_LF)
2227                     nlines++;
2228
2229                   refresh_count++;
2230
2231                   if (!option (Opt_jumpScroll) || refresh_count >= nrow - 1)
2232                     {
2233                       refresh_count = 0;
2234
2235                       if (!option (Opt_skipScroll) || ev_time () > ev::now () + 1. / 60.)
2236                         {
2237                           refreshnow = true;
2238                           ch = NOCHAR;
2239                           break;
2240                         }
2241                     }
2242
2243                   // scr_add_lines only works for nlines <= nrow - 1.
2244                   if (nlines >= nrow - 1)
2245                     {
2246                       if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
2247                             && HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2248                         scr_add_lines (buf, str - buf, nlines);
2249
2250                       nlines = 0;
2251                       str = buf;
2252                       eol = str + min (ncol, UBUFSIZ);
2253                     }
2254
2255                   if (str >= eol)
2256                     {
2257                       if (eol >= buf + UBUFSIZ)
2258                         {
2259                           ch = NOCHAR;
2260                           break;
2261                         }
2262                       else
2263                         eol = min (eol + ncol, buf + UBUFSIZ);
2264                     }
2265
2266                 }
2267
2268               seq_begin = cmdbuf_ptr;
2269               ch = next_char ();
2270             }
2271
2272           if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
2273                 && HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2274             scr_add_lines (buf, str - buf, nlines);
2275
2276           /*
2277            * If there have been a lot of new lines, then update the screen
2278            * What the heck we'll cheat and only refresh less than every page-full.
2279            * if skipScroll is enabled.
2280            */
2281           if (refreshnow)
2282             {
2283               flag = true;
2284               scr_refresh ();
2285               want_refresh = 1;
2286             }
2287
2288         }
2289       else
2290         {
2291           try
2292             {
2293               process_nonprinting (ch);
2294             }
2295           catch (const class out_of_input &o)
2296             {
2297               // we ran out of input, retry later
2298               cmdbuf_ptr = seq_begin;
2299               break;
2300             }
2301
2302           ch = NOCHAR;
2303         }
2304     }
2305
2306   return flag;
2307 }
2308
2309 // read the next character
2310 wchar_t
2311 rxvt_term::next_char () NOTHROW
2312 {
2313   while (cmdbuf_ptr < cmdbuf_endp)
2314     {
2315       // assume 7-bit to be ascii ALWAYS
2316       if ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)
2317         return *cmdbuf_ptr++;
2318
2319       wchar_t wc;
2320       size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2321
2322       if (len == (size_t)-2)
2323         {
2324           // the mbstate stores incomplete sequences. didn't know this :/
2325           cmdbuf_ptr = cmdbuf_endp;
2326           break;
2327         }
2328
2329       if (len == (size_t)-1)
2330         return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2331
2332       // assume wchar == unicode
2333       cmdbuf_ptr += len;
2334       return wc & UNICODE_MASK;
2335     }
2336
2337   return NOCHAR;
2338 }
2339
2340 // read the next octet
2341 uint32_t
2342 rxvt_term::next_octet () NOTHROW
2343 {
2344   return cmdbuf_ptr < cmdbuf_endp
2345          ? (unsigned char)*cmdbuf_ptr++
2346          : NOCHAR;
2347 }
2348
2349 static class out_of_input out_of_input;
2350
2351 /* rxvt_cmd_getc () - Return next input character */
2352 /*
2353  * Return the next input character after first passing any keyboard input
2354  * to the command.
2355  */
2356 wchar_t
2357 rxvt_term::cmd_getc () THROW ((class out_of_input))
2358 {
2359   wchar_t c = next_char ();
2360
2361   if (c == NOCHAR)
2362     throw out_of_input;
2363
2364   return c;
2365 }
2366
2367 uint32_t
2368 rxvt_term::cmd_get8 () THROW ((class out_of_input))
2369 {
2370   uint32_t c = next_octet ();
2371
2372   if (c == NOCHAR)
2373     throw out_of_input;
2374
2375   return c;
2376 }
2377
2378 /*{{{ print pipe */
2379 /*----------------------------------------------------------------------*/
2380 #ifdef PRINTPIPE
2381 FILE *
2382 rxvt_term::popen_printer ()
2383 {
2384   FILE *stream = popen (rs[Rs_print_pipe], "w");
2385
2386   if (stream == NULL)
2387     rxvt_warn ("can't open printer pipe, not printing.\n");
2388
2389   return stream;
2390 }
2391
2392 int
2393 rxvt_term::pclose_printer (FILE *stream)
2394 {
2395   fflush (stream);
2396   return pclose (stream);
2397 }
2398
2399 /*
2400  * simulate attached vt100 printer
2401  */
2402 void
2403 rxvt_term::process_print_pipe ()
2404 {
2405   int done;
2406   FILE *fd;
2407
2408   if ((fd = popen_printer ()) == NULL)
2409     return;
2410
2411   /*
2412    * Send all input to the printer until either ESC[4i or ESC[?4i
2413    * is received.
2414    */
2415   for (done = 0; !done;)
2416     {
2417       unsigned char buf[8];
2418       unicode_t ch;
2419       unsigned int i, len;
2420
2421       if ((ch = cmd_getc ()) != C0_ESC)
2422         {
2423           if (putc (ch, fd) == EOF)
2424             break;              /* done = 1 */
2425         }
2426       else
2427         {
2428           len = 0;
2429           buf[len++] = ch;
2430
2431           if ((buf[len++] = cmd_getc ()) == '[')
2432             {
2433               if ((ch = cmd_getc ()) == '?')
2434                 {
2435                   buf[len++] = '?';
2436                   ch = cmd_getc ();
2437                 }
2438               if ((buf[len++] = ch) == '4')
2439                 {
2440                   if ((buf[len++] = cmd_getc ()) == 'i')
2441                     break;      /* done = 1 */
2442                 }
2443             }
2444
2445           for (i = 0; i < len; i++)
2446             if (putc (buf[i], fd) == EOF)
2447               {
2448                 done = 1;
2449                 break;
2450               }
2451         }
2452     }
2453
2454   pclose_printer (fd);
2455 }
2456 #endif /* PRINTPIPE */
2457 /*}}} */
2458
2459 /* *INDENT-OFF* */
2460 enum {
2461   C1_40 = 0x40,
2462           C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,
2463   C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,
2464   C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2465   C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,
2466 };
2467 /* *INDENT-ON* */
2468
2469 /*{{{ process non-printing single characters */
2470 void
2471 rxvt_term::process_nonprinting (unicode_t ch)
2472 {
2473   switch (ch)
2474     {
2475       case C0_ESC:
2476         process_escape_seq ();
2477         break;
2478       case C0_ENQ:      /* terminal Status */
2479         if (rs[Rs_answerbackstring])
2480           tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
2481         else
2482           tt_write (VT100_ANS, strlen (VT100_ANS));
2483         break;
2484       case C0_BEL:      /* bell */
2485         scr_bell ();
2486         break;
2487       case C0_BS:               /* backspace */
2488         scr_backspace ();
2489         break;
2490       case C0_HT:               /* tab */
2491         scr_tab (1);
2492         break;
2493       case C0_CR:               /* carriage return */
2494         scr_gotorc (0, 0, R_RELATIVE);
2495         break;
2496       case C0_VT:               /* vertical tab, form feed */
2497       case C0_FF:
2498       case C0_LF:               /* line feed */
2499         scr_index (UP);
2500         break;
2501       case C0_SO:               /* shift out - acs */
2502         scr_charset_choose (1);
2503         break;
2504       case C0_SI:               /* shift in - acs */
2505         scr_charset_choose (0);
2506         break;
2507
2508 #ifdef EIGHT_BIT_CONTROLS
2509       // 8-bit controls
2510       case 0x90:        /* DCS */
2511         process_dcs_seq ();
2512         break;
2513       case 0x9b:        /* CSI */
2514         process_csi_seq ();
2515         break;
2516       case 0x9d:        /* OSC */
2517         process_osc_seq ();
2518         break;
2519 #endif
2520     }
2521 }
2522 /*}}} */
2523
2524
2525 /*{{{ process VT52 escape sequences */
2526 void
2527 rxvt_term::process_escape_vt52 (unicode_t ch)
2528 {
2529   int row, col;
2530
2531   switch (ch)
2532     {
2533       case 'A':         /* cursor up */
2534         scr_gotorc (-1, 0, R_RELATIVE | C_RELATIVE);
2535         break;
2536       case 'B':         /* cursor down */
2537         scr_gotorc (1, 0, R_RELATIVE | C_RELATIVE);
2538         break;
2539       case 'C':         /* cursor right */
2540         scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
2541         break;
2542       case 'D':         /* cursor left */
2543         scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
2544         break;
2545       case 'H':         /* cursor home */
2546         scr_gotorc (0, 0, 0);
2547         break;
2548       case 'I':         /* cursor up and scroll down if needed */
2549         scr_index (DN);
2550         break;
2551       case 'J':         /* erase to end of screen */
2552         scr_erase_screen (0);
2553         break;
2554       case 'K':         /* erase to end of line */
2555         scr_erase_line (0);
2556         break;
2557       case 'Y':                 /* move to specified row and col */
2558         /* full command is 'ESC Y row col' where row and col
2559          * are encoded by adding 32 and sending the ascii
2560          * character.  eg. SPACE = 0, '+' = 13, '0' = 18,
2561          * etc. */
2562         row = cmd_getc () - ' ';
2563         col = cmd_getc () - ' ';
2564         scr_gotorc (row, col, 0);
2565         break;
2566       case 'Z':         /* identify the terminal type */
2567         tt_printf ("\033/Z");   /* I am a VT100 emulating a VT52 */
2568         break;
2569       case '<':         /* turn off VT52 mode */
2570         PrivMode (0, PrivMode_vt52);
2571         break;
2572       case 'F':         /* use special graphics character set */
2573       case 'G':           /* use regular character set */
2574         /* unimplemented */
2575         break;
2576       case '=':         /* use alternate keypad mode */
2577       case '>':           /* use regular keypad mode */
2578         /* unimplemented */
2579         break;
2580     }
2581 }
2582 /*}}} */
2583
2584
2585 /*{{{ process escape sequences */
2586 void
2587 rxvt_term::process_escape_seq ()
2588 {
2589   unicode_t ch = cmd_getc ();
2590
2591   if (priv_modes & PrivMode_vt52)
2592     {
2593       process_escape_vt52 (ch);
2594       return;
2595     }
2596
2597   switch (ch)
2598     {
2599         /* case 1:        do_tek_mode (); break; */
2600       case '#':
2601         if (cmd_getc () == '8')
2602           scr_E ();
2603         break;
2604       case '(':
2605         scr_charset_set (0, (unsigned int)cmd_getc ());
2606         break;
2607       case ')':
2608         scr_charset_set (1, (unsigned int)cmd_getc ());
2609         break;
2610       case '*':
2611         scr_charset_set (2, (unsigned int)cmd_getc ());
2612         break;
2613       case '+':
2614         scr_charset_set (3, (unsigned int)cmd_getc ());
2615         break;
2616 #if !ENABLE_MINIMAL
2617       case '6':
2618         scr_backindex ();
2619         break;
2620 #endif
2621       case '7':
2622         scr_cursor (SAVE);
2623         break;
2624       case '8':
2625         scr_cursor (RESTORE);
2626         break;
2627 #if !ENABLE_MINIMAL
2628       case '9':
2629         scr_forwardindex ();
2630         break;
2631 #endif
2632       case '=':
2633       case '>':
2634         PrivMode ((ch == '='), PrivMode_aplKP);
2635         break;
2636
2637       case C1_40:
2638         cmd_getc ();
2639         break;
2640       case C1_44:
2641         scr_index (UP);
2642         break;
2643
2644         /* 8.3.87: NEXT LINE */
2645       case C1_NEL:              /* ESC E */
2646         {
2647           wchar_t nlcr[] = { C0_LF, C0_CR };
2648           scr_add_lines (nlcr, sizeof (nlcr) / sizeof (nlcr [0]), 1);
2649         }
2650         break;
2651
2652         /* kidnapped escape sequence: Should be 8.3.48 */
2653       case C1_ESA:              /* ESC G */
2654         process_graphics ();
2655         break;
2656
2657         /* 8.3.63: CHARACTER TABULATION SET */
2658       case C1_HTS:              /* ESC H */
2659         scr_set_tab (1);
2660         break;
2661
2662         /* 8.3.105: REVERSE LINE FEED */
2663       case C1_RI:                       /* ESC M */
2664         scr_index (DN);
2665         break;
2666
2667         /* 8.3.142: SINGLE-SHIFT TWO */
2668       /*case C1_SS2: scr_single_shift (2);   break; */
2669
2670         /* 8.3.143: SINGLE-SHIFT THREE */
2671       /*case C1_SS3: scr_single_shift (3);   break; */
2672
2673         /* 8.3.27: DEVICE CONTROL STRING */
2674       case C1_DCS:              /* ESC P */
2675         process_dcs_seq ();
2676         break;
2677
2678         /* 8.3.110: SINGLE CHARACTER INTRODUCER */
2679       case C1_SCI:              /* ESC Z */
2680         tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
2681         break;                  /* steal obsolete ESC [ c */
2682
2683         /* 8.3.16: CONTROL SEQUENCE INTRODUCER */
2684       case C1_CSI:              /* ESC [ */
2685         process_csi_seq ();
2686         break;
2687
2688         /* 8.3.90: OPERATING SYSTEM COMMAND */
2689       case C1_OSC:              /* ESC ] */
2690         process_osc_seq ();
2691         break;
2692
2693         /* 8.3.106: RESET TO INITIAL STATE */
2694       case 'c':
2695         mbstate.reset ();
2696         scr_poweron ();
2697         scrollbar_show (1);
2698         break;
2699
2700         /* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2701       case 'n':
2702         scr_charset_choose (2);
2703         break;
2704
2705         /* 8.3.81: LOCKING-SHIFT THREE (see ISO2022) */
2706       case 'o':
2707         scr_charset_choose (3);
2708         break;
2709     }
2710 }
2711 /*}}} */
2712
2713 /*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
2714 /* *INDENT-OFF* */
2715 enum {
2716   CSI_ICH = 0x40,
2717            CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
2718   CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
2719   CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
2720   CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
2721   CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
2722   CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
2723   CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,
2724   CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F
2725 };
2726
2727 #define make_byte(b7,b6,b5,b4,b3,b2,b1,b0)                      \
2728     (((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4)      \
2729      | ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2730 #define get_byte_array_bit(array, bit)                          \
2731     (!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))
2732
2733 const unsigned char csi_defaults[] =
2734   {
2735     make_byte (1,1,1,1,1,1,1,1),        /* @, A, B, C, D, E, F, G, */
2736     make_byte (1,1,0,0,1,1,0,0),        /* H, I, J, K, L, M, N, O, */
2737     make_byte (1,0,1,1,1,1,1,0),        /* P, Q, R, S, T, U, V, W, */
2738     make_byte (1,1,1,0,0,0,1,0),        /* X, Y, Z, [, \, ], ^, _, */
2739     make_byte (1,1,1,0,1,1,1,0),        /* `, a, b, c, d, e, f, g, */
2740     make_byte (0,0,1,1,0,0,0,0),        /* h, i, j, k, l, m, n, o, */
2741     make_byte (0,0,0,0,0,0,0,0),        /* p, q, r, s, t, u, v, w, */
2742     make_byte (0,0,0,0,0,0,0,0),        /* x, y, z, {, |, }, ~,    */
2743   };
2744 /* *INDENT-ON* */
2745
2746 void
2747 rxvt_term::process_csi_seq ()
2748 {
2749   unicode_t ch, priv, i;
2750   unsigned int nargs, p;
2751   int n, ndef;
2752   int arg[ESC_ARGS] = { };
2753
2754   nargs = 0;
2755
2756   priv = 0;
2757   ch = cmd_getc ();
2758   if (ch >= '<' && ch <= '?')
2759     {
2760       /* '<' '=' '>' '?' */
2761       priv = ch;
2762       ch = cmd_getc ();
2763     }
2764
2765   /* read any numerical arguments */
2766   for (n = -1; ch < CSI_ICH; )
2767     {
2768       if (isdigit (ch))
2769         {
2770           if (n < 0)
2771             n = ch - '0';
2772           else
2773             n = n * 10 + ch - '0';
2774         }
2775       else if (ch == ';')
2776         {
2777           if (nargs < ESC_ARGS)
2778             arg[nargs++] = n;
2779           n = -1;
2780         }
2781       else if (IS_CONTROL (ch))
2782         process_nonprinting (ch);
2783
2784       ch = cmd_getc ();
2785     }
2786
2787   if (ch > CSI_7F)
2788     return;
2789
2790   if (nargs < ESC_ARGS)
2791     arg[nargs++] = n;
2792
2793   i = ch - CSI_ICH;
2794   ndef = get_byte_array_bit (csi_defaults, i);
2795   for (p = 0; p < nargs; p++)
2796     if (arg[p] == -1)
2797       arg[p] = ndef;
2798
2799   /*
2800    * private mode handling
2801    */
2802   if (priv)
2803     {
2804       switch (priv)
2805         {
2806           case '>':
2807             if (ch == CSI_DA)   /* secondary device attributes */
2808               {
2809                 // first parameter is normally 0 for vt100, 1 for vt220, 'R' for rxvt,
2810                 // 'U' for rxvt-unicode != 7.[34] (where it was broken).
2811                 //
2812                 // second parameter is xterm patch level for xterm, MMmmpp (e.g. 20703) for rxvt
2813                 // and Mm (e.g. 72 for 7.2) for urxvt <= 7.2, 94 for urxvt <= 8.3, and 95 for later
2814                 // versions.
2815                 //
2816                 tt_printf ("\033[>%d;95;0c", 'U');
2817               }
2818             break;
2819
2820           case '?':
2821             if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2822               process_terminal_mode (ch, priv, nargs, arg);
2823             break;
2824         }
2825       return;
2826     }
2827
2828   switch (ch)
2829     {
2830         /*
2831          * ISO/IEC 6429:1992 (E) CSI sequences (defaults in parentheses)
2832          */
2833 #ifdef PRINTPIPE
2834       case CSI_MC:              /* 8.3.83: (0) MEDIA COPY */
2835         switch (arg[0])
2836           {
2837             case 0:                     /* initiate transfer to primary aux device */
2838               scr_printscreen (0);
2839               break;
2840             case 5:                     /* start relay to primary aux device */
2841               process_print_pipe ();
2842               break;
2843           }
2844         break;
2845 #endif
2846
2847       case CSI_CUU:             /* 8.3.22: (1) CURSOR UP */
2848       case CSI_VPR:             /* 8.3.161: (1) LINE POSITION FORWARD */
2849         arg[0] = -arg[0];
2850         /* FALLTHROUGH */
2851       case CSI_CUD:             /* 8.3.19: (1) CURSOR DOWN */
2852       case CSI_VPB:             /* 8.3.160: (1) LINE POSITION BACKWARD */
2853         scr_gotorc (arg[0], 0, RELATIVE);
2854         break;
2855
2856       case CSI_CUB:             /* 8.3.18: (1) CURSOR LEFT */
2857       case CSI_HPB:             /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2858 #ifdef ISO6429
2859         arg[0] = -arg[0];
2860 #else                           /* emulate common DEC VTs */
2861         arg[0] = arg[0] ? -arg[0] : -1;
2862 #endif
2863         /* FALLTHROUGH */
2864       case CSI_CUF:             /* 8.3.20: (1) CURSOR RIGHT */
2865       case CSI_HPR:             /* 8.3.60: (1) CHARACTER POSITION FORWARD */
2866 #ifdef ISO6429
2867         scr_gotorc (0, arg[0], RELATIVE);
2868 #else                           /* emulate common DEC VTs */
2869         scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);
2870 #endif
2871         break;
2872
2873       case CSI_CPL:             /* 8.3.13: (1) CURSOR PRECEDING LINE */
2874         arg[0] = -arg[0];
2875         /* FALLTHROUGH */
2876       case CSI_CNL:             /* 8.3.12: (1) CURSOR NEXT LINE */
2877         scr_gotorc (arg[0], 0, R_RELATIVE);
2878         break;
2879
2880       case CSI_CHA:             /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */
2881       case CSI_HPA:             /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */
2882         scr_gotorc (0, arg[0] - 1, R_RELATIVE);
2883         break;
2884
2885       case CSI_VPA:             /* 8.3.159: (1) LINE POSITION ABSOLUTE */
2886         scr_gotorc (arg[0] - 1, 0, C_RELATIVE);
2887         break;
2888
2889       case CSI_CUP:             /* 8.3.21: (1,1) CURSOR POSITION */
2890       case CSI_HVP:             /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */
2891         scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);
2892         break;
2893
2894       case CSI_CBT:             /* 8.3.7: (1) CURSOR BACKWARD TABULATION */
2895         arg[0] = -arg[0];
2896         /* FALLTHROUGH */
2897       case CSI_CHT:             /* 8.3.10: (1) CURSOR FORWARD TABULATION */
2898         scr_tab (arg[0]);
2899         break;
2900
2901       case CSI_ED:              /* 8.3.40: (0) ERASE IN PAGE */
2902         scr_erase_screen (arg[0]);
2903         break;
2904
2905       case CSI_EL:              /* 8.3.42: (0) ERASE IN LINE */
2906         scr_erase_line (arg[0]);
2907         break;
2908
2909       case CSI_ICH:             /* 8.3.65: (1) INSERT CHARACTER */
2910         scr_insdel_chars (arg[0], INSERT);
2911         break;
2912
2913       case CSI_IL:              /* 8.3.68: (1) INSERT LINE */
2914         scr_insdel_lines (arg[0], INSERT);
2915         break;
2916
2917       case CSI_DL:              /* 8.3.33: (1) DELETE LINE */
2918         scr_insdel_lines (arg[0], DELETE);
2919         break;
2920
2921       case CSI_ECH:             /* 8.3.39: (1) ERASE CHARACTER */
2922         scr_insdel_chars (arg[0], ERASE);
2923         break;
2924
2925       case CSI_DCH:             /* 8.3.26: (1) DELETE CHARACTER */
2926         scr_insdel_chars (arg[0], DELETE);
2927         break;
2928
2929       case CSI_SD:              /* 8.3.114: (1) SCROLL DOWN */
2930         arg[0] = -arg[0];
2931         /* FALLTHROUGH */
2932       case CSI_SU:              /* 8.3.148: (1) SCROLL UP */
2933         scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2934         break;
2935
2936       case CSI_DA:              /* 8.3.24: (0) DEVICE ATTRIBUTES */
2937         tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2938         break;
2939
2940       case CSI_SGR:             /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2941         process_sgr_mode (nargs, arg);
2942         break;
2943
2944       case CSI_DSR:             /* 8.3.36: (0) DEVICE STATUS REPORT */
2945         switch (arg[0])
2946           {
2947             case 5:                     /* DSR requested */
2948               tt_printf ("\033[0n");
2949               break;
2950             case 6:                     /* CPR requested */
2951               scr_report_position ();
2952               break;
2953             case 7:                     /* unofficial extension */
2954               if (option (Opt_insecure))
2955                 tt_printf ("%-.250s\012", rs[Rs_display_name]);
2956               break;
2957             case 8:                     /* unofficial extension */
2958               process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2959               break;
2960           }
2961         break;
2962
2963       case CSI_TBC:             /* 8.3.155: (0) TABULATION CLEAR */
2964         switch (arg[0])
2965           {
2966             case 0:                     /* char tab stop cleared at active position */
2967               scr_set_tab (0);
2968               break;
2969               /* case 1: */             /* line tab stop cleared in active line */
2970               /* case 2: */             /* char tab stops cleared in active line */
2971             case 3:                     /* all char tab stops are cleared */
2972               /* case 4: */             /* all line tab stops are cleared */
2973             case 5:                     /* all tab stops are cleared */
2974               scr_set_tab (-1);
2975               break;
2976           }
2977         break;
2978
2979       case CSI_CTC:             /* 8.3.17: (0) CURSOR TABULATION CONTROL */
2980         switch (arg[0])
2981           {
2982             case 0:                     /* char tab stop set at active position */
2983               scr_set_tab (1);
2984               break;            /* = ESC H */
2985               /* case 1: */             /* line tab stop set at active line */
2986             case 2:                     /* char tab stop cleared at active position */
2987               scr_set_tab (0);
2988               break;            /* = ESC [ 0 g */
2989               /* case 3: */             /* line tab stop cleared at active line */
2990               /* case 4: */             /* char tab stops cleared at active line */
2991             case 5:                     /* all char tab stops are cleared */
2992               scr_set_tab (-1);
2993               break;            /* = ESC [ 3 g */
2994               /* case 6: */             /* all line tab stops are cleared */
2995           }
2996         break;
2997
2998       case CSI_RM:              /* 8.3.107: RESET MODE */
2999         if (arg[0] == 4)
3000           scr_insert_mode (0);
3001         else if (arg[0] == 20)
3002           priv_modes &= ~PrivMode_LFNL;
3003         break;
3004
3005       case CSI_SM:              /* 8.3.126: SET MODE */
3006         if (arg[0] == 4)
3007           scr_insert_mode (1);
3008         else if (arg[0] == 20)
3009           priv_modes |= PrivMode_LFNL;
3010         break;
3011
3012         /*
3013          * PRIVATE USE beyond this point.  All CSI_7? sequences here
3014          */
3015       case CSI_72:              /* DECSTBM: set top and bottom margins */
3016         if (nargs == 1)
3017           scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);
3018         else if (nargs == 0 || arg[0] >= arg[1])
3019           scr_scroll_region (0, MAX_ROWS - 1);
3020         else
3021           scr_scroll_region (arg[0] - 1, arg[1] - 1);
3022         break;
3023
3024       case CSI_73:
3025         scr_cursor (SAVE);
3026         break;
3027       case CSI_75:
3028         scr_cursor (RESTORE);
3029         break;
3030
3031 #if !ENABLE_MINIMAL
3032       case CSI_74:
3033         process_window_ops (arg, nargs);
3034         break;
3035 #endif
3036
3037       case CSI_78:              /* DECREQTPARM */
3038         if (arg[0] == 0 || arg[0] == 1)
3039           tt_printf ("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
3040         break;
3041
3042       default:
3043         break;
3044     }
3045 }
3046 /*}}} */
3047
3048 #if !ENABLE_MINIMAL
3049 /* ARGSUSED */
3050 void
3051 rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3052 {
3053   int x, y;
3054   XWindowAttributes wattr;
3055   Window wdummy;
3056
3057   dLocal (Display *, dpy);
3058
3059   if (nargs == 0)
3060     return;
3061
3062   switch (args[0])
3063     {
3064       /*
3065        * commands
3066        */
3067       case 1:                   /* deiconify window */
3068         XMapWindow (dpy, parent[0]);
3069         break;
3070       case 2:                   /* iconify window */
3071         XIconifyWindow (dpy, parent[0], display->screen);
3072         break;
3073       case 3:                   /* set position (pixels) */
3074         XMoveWindow (dpy, parent[0], args[1], args[2]);
3075         break;
3076       case 4:                   /* set size (pixels) */
3077         set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3078         break;
3079       case 5:                   /* raise window */
3080         XRaiseWindow (dpy, parent[0]);
3081         break;
3082       case 6:                   /* lower window */
3083         XLowerWindow (dpy, parent[0]);
3084         break;
3085       case 7:                   /* refresh window */
3086         scr_touch (true);
3087         break;
3088       case 8:                   /* set size (chars) */
3089         set_widthheight ((unsigned int) (args[2] * fwidth),
3090                          (unsigned int) (args[1] * fheight));
3091         break;
3092
3093       //case 9: NYI, TODO, restore maximized window or maximize window
3094       default:
3095         if (args[0] >= 24)      /* set height (chars) */
3096           set_widthheight ((unsigned int)width,
3097                            (unsigned int) (args[1] * fheight));
3098         break;
3099
3100       /*
3101        * reports - some output format copied from XTerm
3102        */
3103       case 11:                  /* report window state */
3104         XGetWindowAttributes (dpy, parent[0], &wattr);
3105         tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3106         break;
3107       case 13:                  /* report window position */
3108         XGetWindowAttributes (dpy, parent[0], &wattr);
3109         XTranslateCoordinates (dpy, parent[0], wattr.root,
3110                                -wattr.border_width, -wattr.border_width,
3111                                &x, &y, &wdummy);
3112         tt_printf ("\033[3;%d;%dt", x, y);
3113         break;
3114       case 14:                  /* report window size (pixels) */
3115         XGetWindowAttributes (dpy, parent[0], &wattr);
3116         tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3117         break;
3118       case 18:                  /* report text area size (chars) */
3119         tt_printf ("\033[8;%d;%dt", nrow, ncol);
3120         break;
3121       case 19:                  /* report window size (chars) */
3122         tt_printf ("\033[9;%d;%dt", nrow, ncol);
3123         break;
3124       case 20:                  /* report icon label */
3125         {
3126           char *s;
3127           XGetIconName (dpy, parent[0], &s);
3128           tt_printf ("\033]L%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3129           XFree (s);
3130         }
3131         break;
3132       case 21:                  /* report window title */
3133         {
3134           char *s;
3135           XFetchName (dpy, parent[0], &s);
3136           tt_printf ("\033]l%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3137           XFree (s);
3138         }
3139         break;
3140     }
3141 }
3142 #endif
3143
3144 /*----------------------------------------------------------------------*/
3145 /*
3146  * get input up until STRING TERMINATOR (or BEL)
3147  * ends_how is terminator used. returned input must be free()'d
3148  */
3149 char *
3150 rxvt_term::get_to_st (unicode_t &ends_how)
3151 {
3152   unicode_t ch;
3153   bool seen_esc = false;
3154   unsigned int n = 0;
3155   wchar_t string[STRING_MAX];
3156
3157   while ((ch = cmd_getc ()) != NOCHAR)
3158     {
3159       if (seen_esc)
3160         {
3161           if (ch == 0x5c)       /* 7bit ST */
3162             break;
3163           else
3164             return NULL;
3165         }
3166       else if (ch == C0_ESC)
3167         {
3168           seen_esc = true;
3169           continue;
3170         }
3171       else if (ch == C0_BEL || ch == CHAR_ST)
3172         break;
3173       else if (ch == C0_SYN)
3174         ch = cmd_get8 ();
3175       else if (ch < 0x20)
3176         return NULL;    /* other control character - exit */
3177
3178       seen_esc = false;
3179
3180       if (n >= STRING_MAX - 1)
3181         // stop at some sane length
3182         return NULL;
3183
3184       string[n++] = ch;
3185     }
3186
3187   string[n++] = '\0';
3188
3189   ends_how = (ch == 0x5c ? C0_ESC : ch);
3190
3191   return rxvt_wcstombs (string);
3192 }
3193
3194 /*----------------------------------------------------------------------*/
3195 /*
3196  * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
3197  */
3198 void
3199 rxvt_term::process_dcs_seq ()
3200 {
3201   char *s;
3202   unicode_t eh;
3203
3204   /*
3205    * Not handled yet
3206    */
3207   s = get_to_st (eh);
3208   if (s)
3209     free (s);
3210
3211   return;
3212 }
3213
3214 /*----------------------------------------------------------------------*/
3215 /*
3216  * process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3217  */
3218 void
3219 rxvt_term::process_osc_seq ()
3220 {
3221   unicode_t ch, eh;
3222   int arg;
3223
3224   ch = cmd_getc ();
3225   for (arg = 0; isdigit (ch); ch = cmd_getc ())
3226     arg = arg * 10 + (ch - '0');
3227
3228   if (ch == ';')
3229     {
3230       char *s = get_to_st (eh);
3231
3232       if (s)
3233         {
3234           process_xterm_seq (arg, s, eh);
3235           free (s);
3236         }
3237     }
3238 }
3239
3240 void
3241 rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3242 {
3243   if (str[0] == '?' && !str[1])
3244     {
3245       rgba c;
3246       pix_colors_focused[color].get (c);
3247
3248 #if XFT
3249       if (c.a != rgba::MAX_CC)
3250         tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);
3251       else
3252 #endif
3253         tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);
3254     }
3255   else
3256     set_window_color (color, str);
3257 }
3258
3259 /*
3260  * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3261  */
3262 void
3263 rxvt_term::process_xterm_seq (int op, const char *str, char resp)
3264 {
3265   int color;
3266   char *buf, *name;
3267   bool query = str[0] == '?' && !str[1];
3268   int saveop = op;
3269
3270   dLocal (Display *, dpy);
3271
3272   assert (str != NULL);
3273
3274   if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_INT, op, DT_STR, str, DT_END)))
3275     return;
3276
3277   switch (op)
3278     {
3279       case XTerm_name:
3280         set_title (str);
3281         /* FALLTHROUGH */
3282       case XTerm_iconName:
3283         set_icon_name (str);
3284         break;
3285       case XTerm_title:
3286         set_title (str);
3287         break;
3288       case XTerm_property:
3289         if (str[0] == '?')
3290           {
3291             Atom prop = display->atom (str + 1);
3292             Atom actual_type;
3293             int actual_format;
3294             unsigned long nitems;
3295             unsigned long bytes_after;
3296             unsigned char *value = 0;
3297             const char *str = "";
3298
3299             if (prop
3300                 && XGetWindowProperty (dpy, parent[0],
3301                                        prop, 0, 1<<16, 0, AnyPropertyType,
3302                                        &actual_type, &actual_format,
3303                                        &nitems, &bytes_after, &value) == Success
3304                 && actual_type != None
3305                 && actual_format == 8)
3306               str = (const char *)(value);
3307
3308             tt_printf ("\033]%d;%s%c", op, str, resp);
3309
3310             XFree (value);
3311           }
3312         else
3313           {
3314             char *eq = strchr (str, '='); // constness lost, but verified to be ok
3315
3316             if (eq)
3317               {
3318                 *eq = 0;
3319                 set_utf8_property (display->atom (str), eq + 1);
3320               }
3321             else
3322               XDeleteProperty (dpy, parent[0],
3323                                display->atom (str));
3324           }
3325         break;
3326
3327       case XTerm_Color:
3328         for (buf = (char *)str; buf && *buf;)
3329           {
3330             if ((name = strchr (buf, ';')) == NULL)
3331               break;
3332
3333             *name++ = '\0';
3334             color = atoi (buf) + minCOLOR;
3335
3336             if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3337               break;
3338
3339             if ((buf = strchr (name, ';')) != NULL)
3340               *buf++ = '\0';
3341
3342             process_color_seq (op, color, name, resp);
3343           }
3344         break;
3345       case Rxvt_restoreFG:
3346       case XTerm_Color00:
3347         process_color_seq (op, Color_fg, str, resp);
3348         break;
3349       case Rxvt_restoreBG:
3350       case XTerm_Color01:
3351         process_color_seq (op, Color_bg, str, resp);
3352         break;
3353 #ifndef NO_CURSORCOLOR
3354       case XTerm_Color_cursor:
3355         process_color_seq (op, Color_cursor, str, resp);
3356         break;
3357 #endif
3358       case XTerm_Color_pointer_fg:
3359         process_color_seq (op, Color_pointer_fg, str, resp);
3360         break;
3361       case XTerm_Color_pointer_bg:
3362         process_color_seq (op, Color_pointer_bg, str, resp);
3363         break;
3364 #ifndef NO_BOLD_UNDERLINE_REVERSE
3365       case XTerm_Color_RV:
3366         process_color_seq (op, Color_RV, str, resp);
3367         break;
3368       case Rxvt_Color_BD:
3369       case URxvt_Color_BD:
3370         process_color_seq (op, Color_BD, str, resp);
3371         break;
3372       case Rxvt_Color_UL:
3373       case URxvt_Color_UL:
3374         process_color_seq (op, Color_UL, str, resp);
3375         break;
3376       case URxvt_Color_IT:
3377         process_color_seq (op, Color_IT, str, resp);
3378         break;
3379 #endif
3380 #if ENABLE_TRANSPARENCY
3381       case URxvt_Color_tint:
3382         process_color_seq (op, Color_tint, str, resp);
3383         {
3384           bool changed = false;
3385
3386           if (ISSET_PIXCOLOR (Color_tint))
3387             changed = bgPixmap.set_tint (pix_colors_focused [Color_tint]);
3388           else
3389             changed = bgPixmap.unset_tint ();
3390
3391           if (changed)
3392             update_background ();
3393         }
3394
3395         break;
3396 #endif
3397
3398 #if BG_IMAGE_FROM_FILE
3399       case Rxvt_Pixmap:
3400         if (!strcmp (str, "?"))
3401           {
3402             char str[256];
3403
3404             sprintf (str, "[%dx%d+%d+%d]",      /* can't presume snprintf () ! */
3405                      min (bgPixmap.h_scale, 32767), min (bgPixmap.v_scale, 32767),
3406                      min (bgPixmap.h_align, 32767), min (bgPixmap.v_align, 32767));
3407             process_xterm_seq (XTerm_title, str, CHAR_ST);
3408           }
3409         else
3410           {
3411             int changed = 0;
3412
3413             if (*str != ';')
3414               {
3415                 /* reset to default scaling :*/
3416                 bgPixmap.unset_geometry ();
3417                 if (bgPixmap.set_file (str))    /* change pixmap */
3418                   changed++;
3419                 str = strchr (str, ';');
3420                 if (str == NULL)
3421                   bgPixmap.set_defaultGeometry ();
3422               }
3423
3424             while (str)
3425               {
3426                 str++;
3427                 if (bgPixmap.set_geometry (str))
3428                   changed++;
3429                 str = strchr (str, ';');
3430               }
3431
3432             if (changed)
3433               update_background ();
3434           }
3435         break;
3436 #endif
3437
3438       case XTerm_logfile:
3439         // TODO, when secure mode?
3440         break;
3441
3442 #if 0
3443       case Rxvt_dumpscreen:     /* no error notices */
3444         {
3445           int fd;
3446           if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3447             {
3448               scr_dump (fd);
3449               close (fd);
3450             }
3451         }
3452         break;
3453 #endif
3454       case XTerm_font:
3455         op = URxvt_font;
3456       case URxvt_font:
3457 #if ENABLE_STYLES
3458       case URxvt_boldFont:
3459       case URxvt_italicFont:
3460       case URxvt_boldItalicFont:
3461 #endif
3462         if (query)
3463           tt_printf ("\33]%d;%-.250s%c", saveop,
3464                      option (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
3465                        ? fontset[op - URxvt_font]->fontdesc : "",
3466                      resp);
3467         else
3468           {
3469             const char *&res = rs[Rs_font + (op - URxvt_font)];
3470
3471             res = strdup (str);
3472             allocated.push_back ((void *)res);
3473             set_fonts ();
3474           }
3475         break;
3476
3477       case URxvt_version:
3478         if (query)
3479           tt_printf ("\33]%d;rxvt-unicode;%-.20s;%c;%c%c",
3480                      op,
3481                      rs[Rs_name], VERSION[0], VERSION[2],
3482                      resp);
3483         break;
3484
3485 #if !ENABLE_MINIMAL
3486       case URxvt_locale:
3487         if (query)
3488           tt_printf ("\33]%d;%-.250s%c", op, option (Opt_insecure) ? locale : "", resp);
3489         else
3490           {
3491             set_locale (str);
3492             pty->set_utf8_mode (enc_utf8);
3493             init_xlocale ();
3494           }
3495         break;
3496
3497       case URxvt_view_up:
3498       case URxvt_view_down:
3499         {
3500           int lines = atoi (str);
3501
3502           if (lines)
3503             scr_page (op == URxvt_view_up ? UP : DN, lines);
3504           else
3505             scr_erase_savelines ();
3506         }
3507
3508         break;
3509 #endif
3510
3511 #if ENABLE_PERL
3512       case URxvt_perl:
3513         if (HOOK_INVOKE ((this, HOOK_OSC_SEQ_PERL, DT_STR, str, DT_END)))
3514           ; // no responses yet
3515         break;
3516 #endif
3517     }
3518 }
3519 /*----------------------------------------------------------------------*/
3520
3521 /*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */
3522 /*
3523  * mode can only have the following values:
3524  *      'l' = low
3525  *      'h' = high
3526  *      's' = save
3527  *      'r' = restore
3528  *      't' = toggle
3529  * so no need for fancy checking
3530  */
3531 int
3532 rxvt_term::privcases (int mode, unsigned long bit)
3533 {
3534   int state;
3535
3536   if (mode == 's')
3537     {
3538       SavedModes |= (priv_modes & bit);
3539       return -1;
3540     }
3541   else
3542     {
3543       if (mode == 'r')
3544         state = (SavedModes & bit) ? 1 : 0;     /* no overlapping */
3545       else
3546         state = (mode == 't') ? ! (priv_modes & bit) : mode;
3547       PrivMode (state, bit);
3548     }
3549
3550   return state;
3551 }
3552
3553 /* we're not using priv _yet_ */
3554 void
3555 rxvt_term::process_terminal_mode (int mode, int priv UNUSED, unsigned int nargs, const int *arg)
3556 {
3557   unsigned int i, j;
3558   int state;
3559
3560   static const struct
3561   {
3562     const int       argval;
3563     const unsigned long bit;
3564   } argtopriv[] = {
3565                   { 1, PrivMode_aplCUR },
3566                   { 2, PrivMode_vt52 },
3567                   { 3, PrivMode_132 },
3568                   { 4, PrivMode_smoothScroll },
3569                   { 5, PrivMode_rVideo },
3570                   { 6, PrivMode_relOrigin },
3571                   { 7, PrivMode_Autowrap },
3572                  // 8, bi-directional support mode
3573                   { 9, PrivMode_MouseX10 },
3574                  // 18, 19 printing-related
3575                   { 25, PrivMode_VisibleCursor },
3576 #ifdef scrollBar_esc
3577                   { scrollBar_esc, PrivMode_scrollBar },
3578 #endif
3579                   { 35, PrivMode_ShiftKeys }, // rxvt extension
3580                   { 40, PrivMode_132OK },
3581                  // 41 xterm more fixes NYI
3582                  // 45 margin bell NYI
3583                  // 46 start logging
3584                   { 47, PrivMode_Screen },
3585                   { 66, PrivMode_aplKP },
3586 #ifndef NO_BACKSPACE_KEY
3587                   { 67, PrivMode_BackSpace },
3588 #endif
3589                   { 1000, PrivMode_MouseX11 },
3590                   { 1002, PrivMode_MouseBtnEvent },
3591                   { 1003, PrivMode_MouseAnyEvent },
3592                   { 1010, PrivMode_TtyOutputInh }, // rxvt extension
3593                   { 1011, PrivMode_Keypress }, // rxvt extension
3594                  // 1035 enable modifiers for alt, numlock NYI
3595                  // 1036 send ESC for meta keys NYI
3596                  // 1037 send DEL for keypad delete NYI
3597                   { 1047, PrivMode_Screen },
3598                  // 1048 save and restore cursor
3599                   { 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3600                  // 1051, 1052, 1060, 1061 keyboard emulation NYI
3601                   { 2004, PrivMode_BracketPaste },
3602                 };
3603
3604   if (nargs == 0)
3605     return;
3606
3607   /* make lo/hi boolean */
3608   if (mode == 'l')
3609     mode = 0;           /* reset */
3610   else if (mode == 'h')
3611     mode = 1;           /* set */
3612
3613   for (i = 0; i < nargs; i++)
3614     {
3615       state = -1;
3616
3617       /* basic handling */
3618       for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)
3619         if (argtopriv[j].argval == arg[i])
3620           {
3621             state = privcases (mode, argtopriv[j].bit);
3622             break;
3623           }
3624
3625       /* extra handling for values with state unkept  */
3626       switch (arg[i])
3627         {
3628 #if ENABLE_STYLES
3629           case 1021:
3630             set_option (Opt_intensityStyles, mode);
3631
3632             scr_touch (true);
3633             break;
3634 #endif
3635           case 1048:            /* alternative cursor save */
3636           case 1049:
3637             if (option (Opt_secondaryScreen))
3638               if (mode == 0)
3639                 scr_cursor (RESTORE);
3640               else if (mode == 1)
3641                 scr_cursor (SAVE);
3642             break;
3643         }
3644
3645       if (state >= 0)
3646         /* extra handling for values with valid 0 or 1 state */
3647         switch (arg[i])
3648           {
3649               /* case 1:        - application cursor keys */
3650             case 2:                     /* VT52 mode */
3651               /* oddball mode.  should be set regardless of set/reset
3652                * parameter.  Return from VT52 mode with an ESC < from
3653                * within VT52 mode
3654                */
3655               PrivMode (1, PrivMode_vt52);
3656               break;
3657             case 3:                     /* 80/132 */
3658               if (priv_modes & PrivMode_132OK)
3659                 {
3660                   scr_poweron ();
3661                   set_widthheight (((state ? 132 : 80) * fwidth), 24 * fheight);
3662                 }
3663               break;
3664             case 4:                     /* smooth scrolling */
3665               set_option (Opt_jumpScroll, !state);
3666               break;
3667             case 5:                     /* reverse video */
3668               scr_rvideo_mode (state);
3669               break;
3670             case 6:                     /* relative/absolute origins  */
3671               scr_relative_origin (state);
3672               break;
3673             case 7:                     /* autowrap */
3674               scr_autowrap (state);
3675               break;
3676             /* case 8:  - auto repeat, can't do on a per window basis */
3677             case 9:                     /* X10 mouse reporting */
3678               if (state)                /* orthogonal */
3679                 priv_modes &= ~(PrivMode_MouseX11|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3680               break;
3681 #ifdef scrollBar_esc
3682             case scrollBar_esc:
3683               if (scrollbar_mapping (state))
3684                 {
3685                   resize_all_windows (0, 0, 0);
3686                   scr_touch (true);
3687                 }
3688               break;
3689 #endif
3690             case 25:            /* visible/invisible cursor */
3691               scr_cursor_visible (state);
3692               break;
3693             /* case 35: - shift keys */
3694             /* case 40: - 80 <--> 132 mode */
3695             case 47:            /* secondary screen */
3696               scr_change_screen (state);
3697               break;
3698             /* case 66: - application key pad */
3699             /* case 67: - backspace key */
3700             case 1000:          /* X11 mouse reporting */
3701               if (state)                /* orthogonal */
3702                 priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3703               break;
3704             case 1002:
3705             case 1003:
3706               if (state)
3707                 {
3708                   priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseX11);
3709                   priv_modes &= arg[i] == 1003 ? ~PrivMode_MouseBtnEvent : ~PrivMode_MouseAnyEvent;
3710                   vt_emask_mouse = PointerMotionMask;
3711                 }
3712               else
3713                 vt_emask_mouse = NoEventMask;
3714               vt_select_input ();
3715               break;
3716             case 1010:          /* scroll to bottom on TTY output inhibit */
3717               set_option (Opt_scrollTtyOutput, !state);
3718               break;
3719             case 1011:          /* scroll to bottom on key press */
3720               set_option (Opt_scrollTtyKeypress, state);
3721               break;
3722             case 1047:          /* secondary screen w/ clearing last */
3723               if (option (Opt_secondaryScreen))
3724                 if (current_screen != PRIMARY)
3725                   scr_erase_screen (2);
3726               scr_change_screen (state);
3727               break;
3728             case 1049:          /* secondary screen w/ clearing first */
3729               scr_change_screen (state);
3730               if (option (Opt_secondaryScreen))
3731                 if (current_screen != PRIMARY)
3732                   scr_erase_screen (2);
3733               break;
3734             default:
3735               break;
3736           }
3737     }
3738 }
3739 /*}}} */
3740
3741 /*{{{ process sgr sequences */
3742 void
3743 rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
3744 {
3745   unsigned int i;
3746   short rendset;
3747   int rendstyle;
3748
3749   if (nargs == 0)
3750     {
3751       scr_rendition (0, ~RS_None);
3752       return;
3753     }
3754
3755   for (i = 0; i < nargs; i++)
3756     {
3757       rendset = -1;
3758       switch (arg[i])
3759         {
3760           case 0:
3761             rendset = 0, rendstyle = ~RS_None;
3762             break;
3763           case 1:
3764             rendset = 1, rendstyle = RS_Bold;
3765             break;
3766           //case 2: // low intensity
3767           case 3:
3768             rendset = 1, rendstyle = RS_Italic;
3769             break;
3770           case 4:
3771             rendset = 1, rendstyle = RS_Uline;
3772             break;
3773           case 5: // slowly blinking
3774           case 6: // rapidly blinking
3775             rendset = 1, rendstyle = RS_Blink;
3776             break;
3777           //case 6: // scoansi light background
3778           case 7:
3779             rendset = 1, rendstyle = RS_RVid;
3780             break;
3781           case 8:
3782             // invisible. NYI
3783             break;
3784           //case 9: // crossed out
3785           //case 10: // scoansi acs off, primary font
3786           //case 11: // scoansi acs on, first alt font
3787           //case 12: // scoansi acs on, |0x80, second alt font
3788           //...
3789           //case 19: // ninth alt font
3790           //case 20: // gothic
3791           case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3792             rendset = 0, rendstyle = RS_Bold;
3793             break;
3794           case 22: // normal intensity
3795             rendset = 0, rendstyle = RS_Bold;
3796             break;
3797           case 23: // disable italic
3798             rendset = 0, rendstyle = RS_Italic;
3799             break;
3800           case 24:
3801             rendset = 0, rendstyle = RS_Uline;
3802             break;
3803           case 25:
3804             rendset = 0, rendstyle = RS_Blink;
3805             break;
3806           case 26: // variable spacing (iso 8613)
3807             rendset = 0, rendstyle = RS_Blink;
3808             break;
3809           case 27:
3810             rendset = 0, rendstyle = RS_RVid;
3811             break;
3812           //case 28: // visible. NYI
3813           //case 29: // not crossed-out
3814         }
3815
3816       if (rendset != -1)
3817         {
3818           scr_rendition (rendset, rendstyle);
3819           continue;             /* for (;i;) */
3820         }
3821
3822       switch (arg[i])
3823         {
3824           case 30:
3825           case 31:              /* set fg color */
3826           case 32:
3827           case 33:
3828           case 34:
3829           case 35:
3830           case 36:
3831           case 37:
3832             scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3833             break;
3834           case 38: // set fg color, ISO 8613-6
3835             if (nargs > i + 2 && arg[i + 1] == 5)
3836               {
3837                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3838                 i += 2;
3839               }
3840             break;
3841           case 39:              /* default fg */
3842             scr_color (Color_fg, Color_fg);
3843             break;
3844
3845           case 40:
3846           case 41:              /* set bg color */
3847           case 42:
3848           case 43:
3849           case 44:
3850           case 45:
3851           case 46:
3852           case 47:
3853             scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3854             break;
3855           case 48: // set bg color, ISO 8613-6
3856             if (nargs > i + 2 && arg[i + 1] == 5)
3857               {
3858                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3859                 i += 2;
3860               }
3861             break;
3862           case 49:              /* default bg */
3863             scr_color (Color_bg, Color_bg);
3864             break;
3865
3866           //case 50: // not variable spacing
3867
3868 #if !ENABLE_MINIMAL
3869           case 90:
3870           case 91:              /* set bright fg color */
3871           case 92:
3872           case 93:
3873           case 94:
3874           case 95:
3875           case 96:
3876           case 97:
3877             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3878             break;
3879           case 100:
3880           case 101:             /* set bright bg color */
3881           case 102:
3882           case 103:
3883           case 104:
3884           case 105:
3885           case 106:
3886           case 107:
3887             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3888             break;
3889 #endif
3890         }
3891     }
3892 }
3893 /*}}} */
3894
3895 /*{{{ (do not) process Rob Nation's own graphics mode sequences */
3896 void
3897 rxvt_term::process_graphics ()
3898 {
3899   unicode_t ch, cmd = cmd_getc ();
3900
3901   if (cmd == 'Q')
3902     {
3903       /* query graphics */
3904       tt_printf ("\033G0\012"); /* no graphics */
3905       return;
3906     }
3907   /* swallow other graphics sequences until terminating ':' */
3908   do
3909     ch = cmd_getc ();
3910   while (ch != ':');
3911 }
3912 /*}}} */
3913
3914 /* ------------------------------------------------------------------------- */
3915
3916 /*
3917  * Send printf () formatted output to the command.
3918  * Only use for small amounts of data.
3919  */
3920 void
3921 rxvt_term::tt_printf (const char *fmt,...)
3922 {
3923   va_list arg_ptr;
3924   char buf[256];
3925
3926   va_start (arg_ptr, fmt);
3927   vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3928   va_end (arg_ptr);
3929   tt_write (buf, strlen (buf));
3930 }
3931
3932 /* ---------------------------------------------------------------------- */
3933 /* Write data to the pty as typed by the user, pasted with the mouse,
3934  * or generated by us in response to a query ESC sequence.
3935  */
3936 const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
3937
3938 void
3939 rxvt_term::tt_write (const char *data, unsigned int len)
3940 {
3941   if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
3942     return;
3943
3944   if (pty->pty < 0)
3945     return;
3946
3947   if (v_buflen == 0)
3948     {
3949       ssize_t written = write (pty->pty, data, min (len, MAX_PTY_WRITE));
3950
3951       if ((unsigned int)written == len)
3952         return;
3953
3954       data += written;
3955       len  -= written;
3956     }
3957
3958   v_buffer = (char *)realloc (v_buffer, v_buflen + len);
3959
3960   memcpy (v_buffer + v_buflen, data, len);
3961   v_buflen += len;
3962
3963   pty_ev.set (ev::READ | ev::WRITE);
3964 }
3965
3966 void rxvt_term::pty_write ()
3967 {
3968   int written = write (pty->pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
3969
3970   if (written > 0)
3971     {
3972       v_buflen -= written;
3973
3974       if (v_buflen == 0)
3975         {
3976           free (v_buffer);
3977           v_buffer = 0;
3978
3979           pty_ev.set (ev::READ);
3980           return;
3981         }
3982
3983       memmove (v_buffer, v_buffer + written, v_buflen);
3984     }
3985   else if (written != -1 || (errno != EAGAIN && errno != EINTR))
3986     pty_ev.set (ev::READ);
3987 }
3988
3989 /*----------------------- end-of-file (C source) -----------------------*/
3990