src/command.C

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