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