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