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-2006 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 + hey
 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 void
1047 rxvt_term::prepare_cb (ev::prepare &w, int revents)
1048 {
1049   make_current ();
1050
1051   display->flush ();
1052
1053   if (want_refresh && !flush_ev.active)
1054     flush_ev.start (1. / 60.); // refresh at max. 60 hz normally
1055 }
1056
1057 void
1058 rxvt_term::flush_cb (ev::timer &w, int revents)
1059 {
1060   make_current ();
1061
1062   refresh_count = 0;
1063   flush ();
1064 }
1065
1066 #ifdef CURSOR_BLINK
1067 void
1068 rxvt_term::cursor_blink_cb (ev::timer &w, int revents)
1069 {
1070   hidden_cursor = !hidden_cursor;
1071   want_refresh = 1;
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     }
1084 }
1085 #endif
1086
1087 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1088 void
1089 rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
1090 {
1091   if ((scrollbar_isUp() || scrollbar_isDn()) &&
1092       scr_page (scrollbar_isUp() ? UP : DN, 1))
1093     want_refresh = 1;
1094   else
1095     w.stop ();
1096 }
1097 #endif
1098
1099 #ifdef SELECTION_SCROLLING
1100 void
1101 rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
1102 {
1103   if (scr_page (scroll_selection_dir, scroll_selection_lines))
1104     {
1105       selection_extend (selection_save_x, selection_save_y, selection_save_state);
1106       want_refresh = 1;
1107     }
1108   else
1109     w.stop ();
1110 }
1111 #endif
1112
1113 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1114 void
1115 rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
1116 {
1117   if (mouse_slip_wheel_speed == 0
1118       || mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
1119                                     : scr_page (UP,  mouse_slip_wheel_speed))
1120     {
1121       if (view_start == top_row || view_start == 0)
1122         mouse_slip_wheel_speed = 0;
1123
1124       want_refresh = 1;
1125     }
1126   else
1127     w.stop ();
1128 }
1129 #endif
1130
1131 #if LINUX_YIELD_HACK
1132 static struct event_handler
1133 {
1134   ev::prepare yield_ev;
1135
1136   void yield_cb (ev::prepare &w, int revents)
1137   {
1138     // this should really be sched_yield(), but the linux guys thought
1139     // that giving a process calling sched_yield () less cpu time than
1140     // ones with high nice levels is a useful thing to do. It surely is is
1141     // allowed by the sus... as is returning ENOSYS.
1142
1143     struct timespec ts = { 0, 0 };
1144     nanosleep (&ts, 0);
1145
1146     w.stop ();
1147   }
1148
1149   event_handler ()
1150   : yield_ev (this, &event_handler::yield_cb)
1151   {
1152   }
1153 } event_handler;
1154 #endif
1155
1156 bool
1157 rxvt_term::pty_fill ()
1158 {
1159   ssize_t n = cmdbuf_endp - cmdbuf_ptr;
1160
1161   if (CBUFSIZ == n)
1162     {
1163       rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
1164       n = 0;
1165     }
1166
1167   memmove (cmdbuf_base, cmdbuf_ptr, n);
1168   cmdbuf_ptr = cmdbuf_base;
1169   cmdbuf_endp = cmdbuf_ptr + n;
1170
1171   ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
1172
1173   if (r > 0)
1174     {
1175       cmdbuf_endp += r;
1176       return true;
1177     }
1178   else if (r < 0 && (errno == EAGAIN || errno == EINTR))
1179     {
1180 #if LINUX_YIELD_HACK
1181       if (display->is_local)
1182         event_handler.yield_ev.start ();
1183 #endif
1184     }
1185   else
1186     {
1187       pty_ev.stop ();
1188
1189       if (!option (Opt_hold))
1190         destroy ();
1191     }
1192
1193   return false;
1194 }
1195
1196 void
1197 rxvt_term::pty_cb (ev::io &w, int revents)
1198 {
1199   make_current ();
1200
1201   if (revents & ev::READ)
1202     // loop, but don't allow a single term to monopolize us
1203     while (pty_fill ())
1204       if (cmd_parse ())
1205         break;
1206
1207   if (revents & ev::WRITE)
1208     pty_write ();
1209 }
1210
1211 void
1212 rxvt_term::pointer_unblank ()
1213 {
1214   XDefineCursor (dpy, vt, TermWin_cursor);
1215   recolour_cursor ();
1216
1217 #ifdef POINTER_BLANK
1218   hidden_pointer = 0;
1219
1220   if (option (Opt_pointerBlank))
1221     pointer_ev.start (pointerBlankDelay);
1222 #endif
1223 }
1224
1225 #ifdef POINTER_BLANK
1226 void
1227 rxvt_term::pointer_blank ()
1228 {
1229   if (!option (Opt_pointerBlank))
1230     return;
1231
1232   XDefineCursor (dpy, vt, display->blank_cursor);
1233   XFlush (dpy);
1234
1235   hidden_pointer = 1;
1236 }
1237
1238 void
1239 rxvt_term::pointer_cb (ev::timer &w, int revents)
1240 {
1241   make_current ();
1242
1243   pointer_blank ();
1244 }
1245 #endif
1246
1247 void
1248 rxvt_term::mouse_report (XButtonEvent &ev)
1249 {
1250   int button_number, key_state = 0;
1251   int x, y;
1252   int code = 32;
1253
1254   x = Pixel2Col (ev.x);
1255   y = Pixel2Row (ev.y);
1256   if (ev.type == MotionNotify)
1257     {
1258       if (x == mouse_row && y == mouse_col)
1259         return;
1260       mouse_row = x;
1261       mouse_col = y;
1262       code += 32;
1263     }
1264
1265   if (MEvent.button == AnyButton)
1266     button_number = 3;
1267   else
1268     {
1269       button_number = MEvent.button - Button1;
1270       /* add 0x3D for wheel events, like xterm does */
1271       if (button_number >= 3)
1272         button_number += (64 - 3);
1273     }
1274
1275   if (priv_modes & PrivMode_MouseX10)
1276     {
1277       /*
1278        * do not report ButtonRelease
1279        * no state info allowed
1280        */
1281       key_state = 0;
1282       if (button_number == 3)
1283         return;
1284     }
1285   else
1286     {
1287       /* XTerm mouse reporting needs these values:
1288        *   4 = Shift
1289        *   8 = Meta
1290        *  16 = Control
1291        * plus will add in our own Double-Click reporting
1292        *  32 = Double Click
1293        */
1294       key_state = ((MEvent.state & ShiftMask) ? 4 : 0)
1295                   + ((MEvent.state & ModMetaMask) ? 8 : 0)
1296                   + ((MEvent.state & ControlMask) ? 16 : 0);
1297 #ifdef MOUSE_REPORT_DOUBLECLICK
1298       key_state += ((MEvent.clicks > 1) ? 32 : 0);
1299 #endif
1300     }
1301
1302 #if DEBUG_MOUSEREPORT
1303   fprintf (stderr, "Mouse [");
1304   if (key_state & 16)
1305     fputc ('C', stderr);
1306   if (key_state & 4)
1307     fputc ('S', stderr);
1308   if (key_state & 8)
1309     fputc ('A', stderr);
1310   if (key_state & 32)
1311     fputc ('2', stderr);
1312   fprintf (stderr, "]: <%d>, %d/%d\n",
1313           button_number,
1314           x + 1,
1315           y + 1);
1316 #endif
1317
1318   tt_printf ("\033[M%c%c%c",
1319             (code + button_number + key_state),
1320             (32 + x + 1),
1321             (32 + y + 1));
1322 }
1323
1324 /*{{{ process an X event */
1325 void
1326 rxvt_term::x_cb (XEvent &ev)
1327 {
1328   make_current ();
1329
1330   dLocal (Display *, dpy);
1331
1332   if (ev.xany.window == vt
1333       && SHOULD_INVOKE (HOOK_X_EVENT)
1334       && HOOK_INVOKE ((this, HOOK_X_EVENT, DT_XEVENT, &ev, DT_END)))
1335     return;
1336
1337   // for XQueryPointer
1338   Window unused_root, unused_child;
1339   int unused_root_x, unused_root_y;
1340   unsigned int unused_mask;
1341
1342   switch (ev.type)
1343     {
1344       case KeyPress:
1345         key_press (ev.xkey);
1346         break;
1347
1348       case KeyRelease:
1349         key_release (ev.xkey);
1350         break;
1351
1352       case ButtonPress:
1353         button_press (ev.xbutton);
1354         break;
1355
1356       case ButtonRelease:
1357         button_release (ev.xbutton);
1358         break;
1359
1360       case ClientMessage:
1361         if (ev.xclient.format == 32
1362             && !HOOK_INVOKE ((this, HOOK_CLIENT_MESSAGE, DT_XEVENT, &ev, DT_END)))
1363           {
1364             if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1365               {
1366                 if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1367                   {
1368                     if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1369                       {
1370                         if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1371                           destroy ();
1372                       }
1373 #if ENABLE_EWMH
1374                     else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1375                       XSendEvent (dpy, ev.xclient.window = display->root,
1376                                   False, SubstructureRedirectMask | SubstructureNotifyMask,
1377                                   &ev);
1378 #endif
1379                   }
1380               }
1381 #if ENABLE_XEMBED
1382             else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1383               {
1384                 if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
1385                   focus_in ();
1386                 else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
1387                   focus_out ();
1388               }
1389 #endif
1390           }
1391         break;
1392
1393         /*
1394          * XXX: this is not the _current_ arrangement
1395          * Here's my conclusion:
1396          * If the window is completely unobscured, use bitblt's
1397          * to scroll. Even then, they're only used when doing partial
1398          * screen scrolling. When partially obscured, we have to fill
1399          * in the GraphicsExpose parts, which means that after each refresh,
1400          * we need to wait for the graphics expose or Noexpose events,
1401          * which ought to make things real slow!
1402          */
1403       case VisibilityNotify:
1404         switch (ev.xvisibility.state)
1405           {
1406             case VisibilityUnobscured:
1407               refresh_type = FAST_REFRESH;
1408               break;
1409             case VisibilityPartiallyObscured:
1410               refresh_type = SLOW_REFRESH;
1411               break;
1412             default:
1413               refresh_type = NO_REFRESH;
1414               break;
1415           }
1416         break;
1417
1418       case FocusIn:
1419         if (ev.xfocus.detail != NotifyInferior
1420             && ev.xfocus.detail != NotifyPointer
1421             && ev.xfocus.mode != NotifyGrab)
1422           focus_in ();
1423         break;
1424
1425       case FocusOut:
1426         if (ev.xfocus.detail != NotifyInferior
1427             && ev.xfocus.detail != NotifyPointer
1428             && ev.xfocus.mode != NotifyGrab)
1429           focus_out ();
1430         break;
1431
1432       case ConfigureNotify:
1433       /* fprintf (stderr, "ConfigureNotify for %X, parent is %X, geom is %dx%d%+d%+d, old geom was %dx%d\n",
1434               ev.xconfigure.window, parent[0], ev.xconfigure.width, ev.xconfigure.height, ev.xconfigure.x, ev.xconfigure.y,
1435               szHint.width, szHint.height); */
1436         if (ev.xconfigure.window == parent[0])
1437           {
1438             while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1439               ;
1440
1441             if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1442               {
1443                 seen_resize = 1;
1444                 resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1445               }
1446             else
1447               {
1448 #ifdef HAVE_BG_PIXMAP
1449                 if (bgPixmap.window_position_sensitive ())
1450                   update_background ();
1451 #endif
1452               }
1453             HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1454           }
1455         break;
1456
1457       case PropertyNotify:
1458         if (!HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END)))
1459           if (ev.xproperty.atom == xa[XA_VT_SELECTION]
1460               && ev.xproperty.state == PropertyNewValue)
1461             selection_property (ev.xproperty.window, ev.xproperty.atom);
1462
1463         break;
1464
1465       case SelectionClear:
1466         selection_clear ();
1467         break;
1468
1469       case SelectionNotify:
1470         if (selection_wait == Sel_normal)
1471           selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1472         break;
1473
1474       case SelectionRequest:
1475         selection_send (ev.xselectionrequest);
1476         break;
1477
1478       case MapNotify:
1479         mapped = 1;
1480 #ifdef TEXT_BLINK
1481         text_blink_ev.start (TEXT_BLINK_INTERVAL);
1482 #endif
1483         HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1484         break;
1485
1486       case UnmapNotify:
1487         mapped = 0;
1488 #ifdef TEXT_BLINK
1489         text_blink_ev.stop ();
1490 #endif
1491         HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1492         break;
1493
1494       case GraphicsExpose:
1495       case Expose:
1496         if (ev.xany.window == vt)
1497           {
1498             do
1499               {
1500                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1501                             ev.xexpose.width, ev.xexpose.height, False);
1502               }
1503             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev));
1504
1505             ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1506
1507             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev))
1508               {
1509                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1510                             ev.xexpose.width, ev.xexpose.height, False);
1511               }
1512             want_refresh = 1;
1513           }
1514         else
1515           {
1516             XEvent unused_event;
1517
1518             while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1519               ;
1520             while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1521               ;
1522
1523             if (isScrollbarWindow (ev.xany.window))
1524               {
1525                 scrollBar.setIdle ();
1526                 scrollbar_show (0);
1527               }
1528           }
1529         break;
1530
1531       case MotionNotify:
1532 #ifdef POINTER_BLANK
1533         if (hidden_pointer)
1534           pointer_unblank ();
1535 #endif
1536         if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1537             || priv_modes & PrivMode_MouseAnyEvent)
1538           mouse_report (ev.xbutton);
1539         if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1540           break;
1541
1542         if (ev.xany.window == vt)
1543           {
1544             if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1545                 && HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1546               ; // nop
1547             else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1548               {
1549                 while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1550                   ;
1551
1552                 XQueryPointer (dpy, vt,
1553                                &unused_root, &unused_child,
1554                                &unused_root_x, &unused_root_y,
1555                                &ev.xbutton.x, &ev.xbutton.y,
1556                                &ev.xbutton.state);
1557 #ifdef MOUSE_THRESHOLD
1558                 /* deal with a `jumpy' mouse */
1559                 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1560                   {
1561 #endif
1562 #if ISO_14755
1563                     // 5.4
1564                     if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1565                       {
1566                         iso14755_54 (ev.xbutton.x, ev.xbutton.y);
1567                         break;
1568                       }
1569 #endif
1570                     selection_extend (ev.xbutton.x, ev.xbutton.y,
1571                                       ev.xbutton.state & Button3Mask ? 2 : 0);
1572
1573 #ifdef SELECTION_SCROLLING
1574                     if (ev.xbutton.y < int_bwidth
1575                         || Pixel2Row (ev.xbutton.y) > (nrow-1))
1576                       {
1577                         int dist;
1578
1579                         /* don't clobber the current delay if we are
1580                          * already in the middle of scrolling.
1581                          */
1582                         if (!sel_scroll_ev.active)
1583                           sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1584
1585                         /* save the event params so we can highlight
1586                          * the selection in the pending-scroll loop
1587                          */
1588                         selection_save_x = ev.xbutton.x;
1589                         selection_save_y = ev.xbutton.y;
1590                         selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1591
1592                         /* calc number of lines to scroll */
1593                         if (ev.xbutton.y < int_bwidth)
1594                           {
1595                             scroll_selection_dir = UP;
1596                             dist = int_bwidth - ev.xbutton.y;
1597                           }
1598                         else
1599                           {
1600                             scroll_selection_dir = DN;
1601                             dist = ev.xbutton.y - (int_bwidth + height);
1602                           }
1603
1604                         scroll_selection_lines = Pixel2Height (dist)
1605                                                  / SELECTION_SCROLL_LINE_SPEEDUP
1606                                                  + 1;
1607                         min_it (scroll_selection_lines,
1608                                 SELECTION_SCROLL_MAX_LINES);
1609                       }
1610                     else
1611                       {
1612                         /* we are within the text window, so we
1613                          * shouldn't be scrolling
1614                          */
1615                         if (sel_scroll_ev.active)
1616                           sel_scroll_ev.stop();
1617                       }
1618 #endif
1619 #ifdef MOUSE_THRESHOLD
1620                   }
1621 #endif
1622               }
1623           }
1624         else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1625           {
1626             while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1627                                            MotionNotify, &ev))
1628               ;
1629
1630             XQueryPointer (dpy, scrollBar.win,
1631                           &unused_root, &unused_child,
1632                           &unused_root_x, &unused_root_y,
1633                           &ev.xbutton.x, &ev.xbutton.y,
1634                           &unused_mask);
1635             scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1636                          scrollbar_size ());
1637             want_refresh = 1;
1638             scrollbar_show (1);
1639           }
1640         break;
1641     }
1642
1643 #if defined(CURSOR_BLINK)
1644   if (option (Opt_cursorBlink) && ev.type == KeyPress)
1645     {
1646       if (hidden_cursor)
1647         {
1648           hidden_cursor = 0;
1649           want_refresh = 1;
1650         }
1651
1652       cursor_blink_ev.again ();
1653     }
1654 #endif
1655
1656 #if defined(POINTER_BLANK)
1657   if (option (Opt_pointerBlank) && pointerBlankDelay > 0)
1658     {
1659       if (ev.type == MotionNotify
1660           || ev.type == ButtonPress
1661           || ev.type == ButtonRelease)
1662         if (hidden_pointer)
1663           pointer_unblank ();
1664
1665       if (ev.type == KeyPress && hidden_pointer == 0)
1666         pointer_blank ();
1667     }
1668 #endif
1669 }
1670
1671 void
1672 rxvt_term::focus_in ()
1673 {
1674   if (!focus)
1675     {
1676       focus = 1;
1677       want_refresh = 1;
1678
1679       HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1680
1681 #if USE_XIM
1682       if (Input_Context != NULL)
1683         {
1684           IMSetPosition ();
1685           XSetICFocus (Input_Context);
1686         }
1687 #endif
1688 #if CURSOR_BLINK
1689       if (option (Opt_cursorBlink))
1690         cursor_blink_ev.start (CURSOR_BLINK_INTERVAL, CURSOR_BLINK_INTERVAL);
1691 #endif
1692 #if OFF_FOCUS_FADING
1693       if (rs[Rs_fade])
1694         {
1695           pix_colors = pix_colors_focused;
1696           scr_recolour ();
1697         }
1698 #endif
1699 #if ENABLE_FRILLS
1700       if (option (Opt_urgentOnBell))
1701         {
1702           if (XWMHints *h = XGetWMHints(dpy, parent[0]))
1703             {
1704               h->flags &= ~XUrgencyHint;
1705               XSetWMHints (dpy, parent[0], h);
1706             }
1707         }
1708 #endif
1709     }
1710 }
1711
1712 void
1713 rxvt_term::focus_out ()
1714 {
1715   if (focus)
1716     {
1717       focus = 0;
1718       want_refresh = 1;
1719
1720       HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1721
1722 #if ENABLE_FRILLS || ISO_14755
1723       if (iso14755buf)
1724         {
1725           iso14755buf = 0;
1726 # if ISO_14755
1727           scr_overlay_off ();
1728 # endif
1729         }
1730 #endif
1731 #if USE_XIM
1732       if (Input_Context != NULL)
1733         XUnsetICFocus (Input_Context);
1734 #endif
1735 #if CURSOR_BLINK
1736       if (option (Opt_cursorBlink))
1737         cursor_blink_ev.stop ();
1738
1739       hidden_cursor = 0;
1740 #endif
1741 #if OFF_FOCUS_FADING
1742       if (rs[Rs_fade])
1743         {
1744           pix_colors = pix_colors_unfocused;
1745           scr_recolour ();
1746         }
1747 #endif
1748     }
1749 }
1750
1751 void
1752 rxvt_term::update_fade_color (unsigned int idx)
1753 {
1754 #if OFF_FOCUS_FADING
1755   if (rs[Rs_fade])
1756     {
1757       rgba c;
1758       pix_colors [Color_fade].get (c);
1759       pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
1760     }
1761 #endif
1762 }
1763
1764 #if ENABLE_TRANSPARENCY || ENABLE_PERL
1765 void
1766 rxvt_term::rootwin_cb (XEvent &ev)
1767 {
1768   make_current ();
1769
1770   if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
1771       && HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
1772     return;
1773
1774 # if ENABLE_TRANSPARENCY
1775   switch (ev.type)
1776     {
1777       case PropertyNotify:
1778         /*
1779          * if user used some Esetroot compatible prog to set the root bg,
1780          * use the property to determine the pixmap.  We use it later on.
1781          */
1782         if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1783             || ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1784           {
1785             bgPixmap.set_root_pixmap ();
1786             update_background ();
1787           }
1788         break;
1789     }
1790 # endif
1791 }
1792 #endif
1793
1794 void
1795 rxvt_term::button_press (XButtonEvent &ev)
1796 {
1797   int reportmode = 0, clickintime;
1798
1799   bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1800
1801   if (!bypass_keystate)
1802     reportmode = !! (priv_modes & PrivMode_mouse_report);
1803
1804   /*
1805    * VT window processing of button press
1806    */
1807   if (ev.window == vt)
1808     {
1809       if (HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
1810         return;
1811
1812 #if ISO_14755
1813       // 5.4
1814       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1815         {
1816           iso14755_54 (ev.x, ev.y);
1817           return;
1818         }
1819 #endif
1820
1821       clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1822
1823       if (reportmode)
1824         {
1825           /* mouse report from vt window */
1826           /* save the xbutton state (for ButtonRelease) */
1827           MEvent.state = ev.state;
1828 #ifdef MOUSE_REPORT_DOUBLECLICK
1829           if (ev.button == MEvent.button && clickintime)
1830             {
1831               /* same button, within alloted time */
1832               MEvent.clicks++;
1833
1834               if (MEvent.clicks > 1)
1835                 {
1836                   /* only report double clicks */
1837                   MEvent.clicks = 2;
1838                   mouse_report (ev);
1839
1840                   /* don't report the release */
1841                   MEvent.clicks = 0;
1842                   MEvent.button = AnyButton;
1843                 }
1844             }
1845           else
1846             {
1847               /* different button, or time expired */
1848               MEvent.clicks = 1;
1849               MEvent.button = ev.button;
1850               mouse_report (ev);
1851             }
1852 #else
1853           MEvent.button = ev.button;
1854           mouse_report (ev);
1855 #endif                          /* MOUSE_REPORT_DOUBLECLICK */
1856
1857         }
1858       else
1859         {
1860           if (ev.button != MEvent.button)
1861             MEvent.clicks = 0;
1862
1863           switch (ev.button)
1864             {
1865               case Button1:
1866                 /* allow meta + click to select rectangular areas */
1867                 /* should be done in screen.C */
1868 #if ENABLE_FRILLS
1869                 selection.rect = !!(ev.state & ModMetaMask);
1870 #else
1871                 selection.rect = false;
1872 #endif
1873
1874                 /* allow shift+left click to extend selection */
1875                 if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1876                   {
1877                     if (MEvent.button == Button1 && clickintime)
1878                       selection_rotate (ev.x, ev.y);
1879                     else
1880                       selection_extend (ev.x, ev.y, 1);
1881                   }
1882                 else
1883                   {
1884                     if (MEvent.button == Button1 && clickintime)
1885                       MEvent.clicks++;
1886                     else
1887                       MEvent.clicks = 1;
1888
1889                     selection_click (MEvent.clicks, ev.x, ev.y);
1890                   }
1891
1892                 MEvent.button = Button1;
1893                 break;
1894
1895               case Button3:
1896                 if (MEvent.button == Button3 && clickintime)
1897                   selection_rotate (ev.x, ev.y);
1898                 else
1899                   selection_extend (ev.x, ev.y, 1);
1900
1901                 MEvent.button = Button3;
1902                 break;
1903             }
1904         }
1905
1906       MEvent.time = ev.time;
1907       return;
1908     }
1909
1910   /*
1911    * Scrollbar window processing of button press
1912    */
1913   if (isScrollbarWindow (ev.window))
1914     {
1915       scrollBar.setIdle ();
1916       /*
1917        * Rxvt-style scrollbar:
1918        * move up if mouse is above slider
1919        * move dn if mouse is below slider
1920        *
1921        * XTerm-style scrollbar:
1922        * Move display proportional to pointer location
1923        * pointer near top -> scroll one line
1924        * pointer near bot -> scroll full page
1925        */
1926 #ifndef NO_SCROLLBAR_REPORT
1927       if (reportmode)
1928         {
1929           /*
1930            * Mouse report disabled scrollbar:
1931            * arrow buttons - send up/down
1932            * click on scrollbar - send pageup/down
1933            */
1934           if ((scrollBar.style == R_SB_NEXT
1935                && scrollbarnext_upButton (ev.y))
1936               || (scrollBar.style == R_SB_RXVT
1937                   && scrollbarrxvt_upButton (ev.y)))
1938             tt_printf ("\033[A");
1939           else if ((scrollBar.style == R_SB_NEXT
1940                     && scrollbarnext_dnButton (ev.y))
1941                    || (scrollBar.style == R_SB_RXVT
1942                        && scrollbarrxvt_dnButton (ev.y)))
1943             tt_printf ("\033[B");
1944           else
1945             switch (ev.button)
1946               {
1947                 case Button2:
1948                   tt_printf ("\014");
1949                   break;
1950                 case Button1:
1951                   tt_printf ("\033[6~");
1952                   break;
1953                 case Button3:
1954                   tt_printf ("\033[5~");
1955                   break;
1956               }
1957         }
1958       else
1959 #endif                          /* NO_SCROLLBAR_REPORT */
1960
1961         {
1962           char            upordown = 0;
1963
1964           if (scrollBar.style == R_SB_NEXT)
1965             {
1966               if (scrollbarnext_upButton (ev.y))
1967                 upordown = -1;  /* up */
1968               else if (scrollbarnext_dnButton (ev.y))
1969                 upordown = 1;   /* down */
1970             }
1971           else if (scrollBar.style == R_SB_RXVT)
1972             {
1973               if (scrollbarrxvt_upButton (ev.y))
1974                 upordown = -1;  /* up */
1975               else if (scrollbarrxvt_dnButton (ev.y))
1976                 upordown = 1;   /* down */
1977             }
1978           if (upordown)
1979             {
1980 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1981               cont_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1982 #endif
1983               if (scr_page (upordown < 0 ? UP : DN, 1))
1984                 {
1985                   if (upordown < 0)
1986                     scrollBar.setUp ();
1987                   else
1988                     scrollBar.setDn ();
1989                 }
1990             }
1991           else
1992             switch (ev.button)
1993               {
1994                 case Button2:
1995                   switch (scrollbar_align)
1996                     {
1997                       case R_SB_ALIGN_TOP:
1998                         csrO = 0;
1999                         break;
2000                       case R_SB_ALIGN_CENTRE:
2001                         csrO = (scrollBar.bot - scrollBar.top) / 2;
2002                         break;
2003                       case R_SB_ALIGN_BOTTOM:
2004                         csrO = scrollBar.bot - scrollBar.top;
2005                         break;
2006                     }
2007
2008                   if (scrollBar.style == R_SB_XTERM
2009                       || scrollbar_above_slider (ev.y)
2010                       || scrollbar_below_slider (ev.y))
2011                     scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
2012
2013                   scrollBar.setMotion ();
2014                   break;
2015
2016                 case Button1:
2017                   if (scrollbar_align == R_SB_ALIGN_CENTRE)
2018                     csrO = ev.y - scrollBar.top;
2019                   /* FALLTHROUGH */
2020
2021                 case Button3:
2022                   if (scrollBar.style != R_SB_XTERM)
2023                     {
2024                       if (scrollbar_above_slider (ev.y))
2025 # ifdef RXVT_SCROLL_FULL
2026                         scr_page (UP, nrow - 1);
2027 # else
2028                         scr_page (UP, nrow / 4);
2029 # endif
2030                       else if (scrollbar_below_slider (ev.y))
2031 # ifdef RXVT_SCROLL_FULL
2032                         scr_page (DN, nrow - 1);
2033 # else
2034                         scr_page (DN, nrow / 4);
2035 # endif
2036                       else
2037                         scrollBar.setMotion ();
2038                     }
2039                   else
2040                     {
2041                       scr_page ((ev.button == Button1 ? DN : UP),
2042                                 (nrow
2043                                  * scrollbar_position (ev.y)
2044                                  / scrollbar_size ()));
2045                     }
2046
2047                   break;
2048               }
2049         }
2050
2051       return;
2052     }
2053 }
2054
2055 void
2056 rxvt_term::button_release (XButtonEvent &ev)
2057 {
2058   int reportmode = 0;
2059
2060   csrO = 0;             /* reset csr Offset */
2061   if (!bypass_keystate)
2062     reportmode = !! (priv_modes & PrivMode_mouse_report);
2063
2064   if (scrollbar_isUpDn ())
2065     {
2066       scrollBar.setIdle ();
2067       scrollbar_show (0);
2068     }
2069
2070 #ifdef SELECTION_SCROLLING
2071   if (sel_scroll_ev.active)
2072     sel_scroll_ev.stop();
2073 #endif
2074
2075   if (ev.window == vt)
2076     {
2077       if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
2078         return;
2079
2080 #if ISO_14755
2081       // 5.4
2082       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
2083         return;
2084 #endif
2085
2086       if (reportmode)
2087         {
2088           /* mouse report from vt window */
2089           /* don't report release of wheel "buttons" */
2090           if (ev.button >= 4)
2091             return;
2092 #ifdef MOUSE_REPORT_DOUBLECLICK
2093           /* only report the release of 'slow' single clicks */
2094           if (MEvent.button != AnyButton
2095               && (ev.button != MEvent.button
2096                   || (ev.time - MEvent.time
2097                       > MULTICLICK_TIME / 2)))
2098             {
2099               MEvent.clicks = 0;
2100               MEvent.button = AnyButton;
2101               mouse_report (ev);
2102             }
2103 #else                           /* MOUSE_REPORT_DOUBLECLICK */
2104           MEvent.button = AnyButton;
2105           mouse_report (ev);
2106 #endif                          /* MOUSE_REPORT_DOUBLECLICK */
2107           return;
2108         }
2109
2110       /*
2111        * dumb hack to compensate for the failure of click-and-drag
2112        * when overriding mouse reporting
2113        */
2114       if (priv_modes & PrivMode_mouse_report
2115           && bypass_keystate
2116           && ev.button == Button1 && MEvent.clicks <= 1)
2117         selection_extend (ev.x, ev.y, 0);
2118
2119       switch (ev.button)
2120         {
2121           case Button1:
2122           case Button3:
2123             selection_make (ev.time);
2124             break;
2125
2126           case Button2:
2127             if (IN_RANGE_EXC (ev.x, 0, width) && IN_RANGE_EXC (ev.y, 0, height)) // inside window?
2128               selection_request (ev.time, ev.state & ModMetaMask ? Sel_Clipboard : Sel_Primary);
2129             break;
2130
2131 #ifdef MOUSE_WHEEL
2132           case Button4:
2133           case Button5:
2134             {
2135               int i;
2136               page_dirn v;
2137
2138               v = ev.button == Button4 ? UP : DN;
2139
2140               if (ev.state & ShiftMask)
2141                 i = 1;
2142               else if (option (Opt_mouseWheelScrollPage))
2143                 i = nrow - 1;
2144               else
2145                 i = 5;
2146
2147 # ifdef MOUSE_SLIP_WHEELING
2148               if (ev.state & ControlMask)
2149                 {
2150                   mouse_slip_wheel_speed += v ? -1 : 1;
2151                   if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
2152                   if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
2153
2154                   slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
2155                 }
2156               else
2157                 {
2158 # endif
2159                   scr_page (v, i);
2160                   scrollbar_show (1);
2161 # ifdef MOUSE_SLIP_WHEELING
2162                 }
2163 # endif
2164             }
2165             break;
2166 #endif
2167         }
2168     }
2169 }
2170
2171 /*}}} */
2172
2173 bool
2174 rxvt_term::cmd_parse ()
2175 {
2176   bool flag = false;
2177   wchar_t ch = NOCHAR;
2178   char *seq_begin; // remember start of esc-sequence here
2179
2180   for (;;)
2181     {
2182       if (ch == NOCHAR)
2183         {
2184           seq_begin = cmdbuf_ptr;
2185           ch = next_char ();
2186
2187           if (ch == NOCHAR)
2188             break;
2189         }
2190
2191       if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2192         {
2193           if (!seen_input)
2194             {
2195               seen_input = 1;
2196               // many badly-written programs (e.g. jed) contain a race condition:
2197               // they first read the screensize and then install a SIGWINCH handler.
2198               // some window managers resize the window early, and these programs
2199               // then sometimes get the size wrong.
2200               // unfortunately other programs are even more buggy and dislike
2201               // being sent SIGWINCH, so only do it when we were in fact being
2202               // resized.
2203               if (seen_resize && cmd_pid)
2204                 kill (-cmd_pid, SIGWINCH);
2205             }
2206
2207           /* Read a text string from the input buffer */
2208           wchar_t buf[UBUFSIZ];
2209           bool refreshnow = false;
2210           int nlines = 0;
2211           wchar_t *str = buf;
2212           wchar_t *eol = str + min (ncol, UBUFSIZ);
2213
2214           for (;;)
2215             {
2216               if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2217                 break;
2218
2219               *str++ = ch;
2220
2221               if (ch == C0_LF || str >= eol)
2222                 {
2223                   if (ch == C0_LF)
2224                     nlines++;
2225
2226                   refresh_count++;
2227
2228                   if (!option (Opt_jumpScroll) || refresh_count >= nrow - 1)
2229                     {
2230                       refresh_count = 0;
2231
2232                       if (!option (Opt_skipScroll) || ev::ev_time () > ev::now () + 1. / 60.)
2233                         {
2234                           refreshnow = true;
2235                           ch = NOCHAR;
2236                           break;
2237                         }
2238                     }
2239
2240                   // scr_add_lines only works for nlines <= nrow - 1.
2241                   if (nlines >= nrow - 1)
2242                     {
2243                       if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
2244                             && HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2245                         scr_add_lines (buf, str - buf, nlines);
2246
2247                       nlines = 0;
2248                       str = buf;
2249                       eol = str + min (ncol, UBUFSIZ);
2250                     }
2251
2252                   if (str >= eol)
2253                     {
2254                       if (eol >= buf + UBUFSIZ)
2255                         {
2256                           ch = NOCHAR;
2257                           break;
2258                         }
2259                       else
2260                         eol = min (eol + ncol, buf + UBUFSIZ);
2261                     }
2262
2263                 }
2264
2265               seq_begin = cmdbuf_ptr;
2266               ch = next_char ();
2267             }
2268
2269           if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
2270                 && HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2271             scr_add_lines (buf, str - buf, nlines);
2272
2273           /*
2274            * If there have been a lot of new lines, then update the screen
2275            * What the heck we'll cheat and only refresh less than every page-full.
2276            * if skipScroll is enabled.
2277            */
2278           if (refreshnow)
2279             {
2280               flag = true;
2281               scr_refresh ();
2282               want_refresh = 1;
2283             }
2284
2285         }
2286       else
2287         {
2288           try
2289             {
2290               process_nonprinting (ch);
2291             }
2292           catch (const class out_of_input &o)
2293             {
2294               // we ran out of input, retry later
2295               cmdbuf_ptr = seq_begin;
2296               break;
2297             }
2298
2299           ch = NOCHAR;
2300         }
2301     }
2302
2303   return flag;
2304 }
2305
2306 // read the next character
2307 wchar_t
2308 rxvt_term::next_char () NOTHROW
2309 {
2310   while (cmdbuf_ptr < cmdbuf_endp)
2311     {
2312       // assume 7-bit to be ascii ALWAYS
2313       if ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)
2314         return *cmdbuf_ptr++;
2315
2316       wchar_t wc;
2317       size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2318
2319       if (len == (size_t)-2)
2320         {
2321           // the mbstate stores incomplete sequences. didn't know this :/
2322           cmdbuf_ptr = cmdbuf_endp;
2323           break;
2324         }
2325
2326       if (len == (size_t)-1)
2327         return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2328
2329       // assume wchar == unicode
2330       cmdbuf_ptr += len;
2331       return wc & UNICODE_MASK;
2332     }
2333
2334   return NOCHAR;
2335 }
2336
2337 // read the next octet
2338 uint32_t
2339 rxvt_term::next_octet () NOTHROW
2340 {
2341   return cmdbuf_ptr < cmdbuf_endp
2342          ? (unsigned char)*cmdbuf_ptr++
2343          : NOCHAR;
2344 }
2345
2346 static class out_of_input out_of_input;
2347
2348 /* rxvt_cmd_getc () - Return next input character */
2349 /*
2350  * Return the next input character after first passing any keyboard input
2351  * to the command.
2352  */
2353 wchar_t
2354 rxvt_term::cmd_getc () THROW ((class out_of_input))
2355 {
2356   wchar_t c = next_char ();
2357
2358   if (c == NOCHAR)
2359     throw out_of_input;
2360
2361   return c;
2362 }
2363
2364 uint32_t
2365 rxvt_term::cmd_get8 () THROW ((class out_of_input))
2366 {
2367   uint32_t c = next_octet ();
2368
2369   if (c == NOCHAR)
2370     throw out_of_input;
2371
2372   return c;
2373 }
2374
2375 /*{{{ print pipe */
2376 /*----------------------------------------------------------------------*/
2377 #ifdef PRINTPIPE
2378 FILE *
2379 rxvt_term::popen_printer ()
2380 {
2381   FILE *stream = popen (rs[Rs_print_pipe], "w");
2382
2383   if (stream == NULL)
2384     rxvt_warn ("can't open printer pipe, not printing.\n");
2385
2386   return stream;
2387 }
2388
2389 int
2390 rxvt_term::pclose_printer (FILE *stream)
2391 {
2392   fflush (stream);
2393   return pclose (stream);
2394 }
2395
2396 /*
2397  * simulate attached vt100 printer
2398  */
2399 void
2400 rxvt_term::process_print_pipe ()
2401 {
2402   int done;
2403   FILE *fd;
2404
2405   if ((fd = popen_printer ()) == NULL)
2406     return;
2407
2408   /*
2409    * Send all input to the printer until either ESC[4i or ESC[?4i
2410    * is received.
2411    */
2412   for (done = 0; !done;)
2413     {
2414       unsigned char buf[8];
2415       unicode_t ch;
2416       unsigned int i, len;
2417
2418       if ((ch = cmd_getc ()) != C0_ESC)
2419         {
2420           if (putc (ch, fd) == EOF)
2421             break;              /* done = 1 */
2422         }
2423       else
2424         {
2425           len = 0;
2426           buf[len++] = ch;
2427
2428           if ((buf[len++] = cmd_getc ()) == '[')
2429             {
2430               if ((ch = cmd_getc ()) == '?')
2431                 {
2432                   buf[len++] = '?';
2433                   ch = cmd_getc ();
2434                 }
2435               if ((buf[len++] = ch) == '4')
2436                 {
2437                   if ((buf[len++] = cmd_getc ()) == 'i')
2438                     break;      /* done = 1 */
2439                 }
2440             }
2441
2442           for (i = 0; i < len; i++)
2443             if (putc (buf[i], fd) == EOF)
2444               {
2445                 done = 1;
2446                 break;
2447               }
2448         }
2449     }
2450
2451   pclose_printer (fd);
2452 }
2453 #endif                          /* PRINTPIPE */
2454 /*}}} */
2455
2456 /* *INDENT-OFF* */
2457 enum {
2458   C1_40 = 0x40,
2459           C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,
2460   C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,
2461   C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2462   C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,
2463 };
2464 /* *INDENT-ON* */
2465
2466 /*{{{ process non-printing single characters */
2467 void
2468 rxvt_term::process_nonprinting (unicode_t ch)
2469 {
2470   switch (ch)
2471     {
2472       case C0_ESC:
2473         process_escape_seq ();
2474         break;
2475       case C0_ENQ:      /* terminal Status */
2476         if (rs[Rs_answerbackstring])
2477           tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
2478         else
2479           tt_write (VT100_ANS, strlen (VT100_ANS));
2480         break;
2481       case C0_BEL:      /* bell */
2482         scr_bell ();
2483         break;
2484       case C0_BS:               /* backspace */
2485         scr_backspace ();
2486         break;
2487       case C0_HT:               /* tab */
2488         scr_tab (1);
2489         break;
2490       case C0_CR:               /* carriage return */
2491         scr_gotorc (0, 0, R_RELATIVE);
2492         break;
2493       case C0_VT:               /* vertical tab, form feed */
2494       case C0_FF:
2495       case C0_LF:               /* line feed */
2496         scr_index (UP);
2497         break;
2498       case C0_SO:               /* shift out - acs */
2499         scr_charset_choose (1);
2500         break;
2501       case C0_SI:               /* shift in - acs */
2502         scr_charset_choose (0);
2503         break;
2504
2505 #ifdef EIGHT_BIT_CONTROLS
2506       // 8-bit controls
2507       case 0x90:        /* DCS */
2508         process_dcs_seq ();
2509         break;
2510       case 0x9b:        /* CSI */
2511         process_csi_seq ();
2512         break;
2513       case 0x9d:        /* OSC */
2514         process_osc_seq ();
2515         break;
2516 #endif
2517     }
2518 }
2519 /*}}} */
2520
2521
2522 /*{{{ process VT52 escape sequences */
2523 void
2524 rxvt_term::process_escape_vt52 (unicode_t ch)
2525 {
2526   int row, col;
2527
2528   switch (ch)
2529     {
2530       case 'A':         /* cursor up */
2531         scr_gotorc (-1, 0, R_RELATIVE | C_RELATIVE);
2532         break;
2533       case 'B':         /* cursor down */
2534         scr_gotorc (1, 0, R_RELATIVE | C_RELATIVE);
2535         break;
2536       case 'C':         /* cursor right */
2537         scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
2538         break;
2539       case 'D':         /* cursor left */
2540         scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
2541         break;
2542       case 'H':         /* cursor home */
2543         scr_gotorc (0, 0, 0);
2544         break;
2545       case 'I':         /* cursor up and scroll down if needed */
2546         scr_index (DN);
2547         break;
2548       case 'J':         /* erase to end of screen */
2549         scr_erase_screen (0);
2550         break;
2551       case 'K':         /* erase to end of line */
2552         scr_erase_line (0);
2553         break;
2554       case 'Y':                 /* move to specified row and col */
2555         /* full command is 'ESC Y row col' where row and col
2556          * are encoded by adding 32 and sending the ascii
2557          * character.  eg. SPACE = 0, '+' = 13, '0' = 18,
2558          * etc. */
2559         row = cmd_getc () - ' ';
2560         col = cmd_getc () - ' ';
2561         scr_gotorc (row, col, 0);
2562         break;
2563       case 'Z':         /* identify the terminal type */
2564         tt_printf ("\033/Z");   /* I am a VT100 emulating a VT52 */
2565         break;
2566       case '<':         /* turn off VT52 mode */
2567         PrivMode (0, PrivMode_vt52);
2568         break;
2569       case 'F':         /* use special graphics character set */
2570       case 'G':           /* use regular character set */
2571         /* unimplemented */
2572         break;
2573       case '=':         /* use alternate keypad mode */
2574       case '>':           /* use regular keypad mode */
2575         /* unimplemented */
2576         break;
2577     }
2578 }
2579 /*}}} */
2580
2581
2582 /*{{{ process escape sequences */
2583 void
2584 rxvt_term::process_escape_seq ()
2585 {
2586   unicode_t ch = cmd_getc ();
2587
2588   if (priv_modes & PrivMode_vt52)
2589     {
2590       process_escape_vt52 (ch);
2591       return;
2592     }
2593
2594   switch (ch)
2595     {
2596         /* case 1:        do_tek_mode (); break; */
2597       case '#':
2598         if (cmd_getc () == '8')
2599           scr_E ();
2600         break;
2601       case '(':
2602         scr_charset_set (0, (unsigned int)cmd_getc ());
2603         break;
2604       case ')':
2605         scr_charset_set (1, (unsigned int)cmd_getc ());
2606         break;
2607       case '*':
2608         scr_charset_set (2, (unsigned int)cmd_getc ());
2609         break;
2610       case '+':
2611         scr_charset_set (3, (unsigned int)cmd_getc ());
2612         break;
2613 #if !ENABLE_MINIMAL
2614       case '6':
2615         scr_backindex ();
2616         break;
2617 #endif
2618       case '7':
2619         scr_cursor (SAVE);
2620         break;
2621       case '8':
2622         scr_cursor (RESTORE);
2623         break;
2624 #if !ENABLE_MINIMAL
2625       case '9':
2626         scr_forwardindex ();
2627         break;
2628 #endif
2629       case '=':
2630       case '>':
2631         PrivMode ((ch == '='), PrivMode_aplKP);
2632         break;
2633
2634       case C1_40:
2635         cmd_getc ();
2636         break;
2637       case C1_44:
2638         scr_index (UP);
2639         break;
2640
2641         /* 8.3.87: NEXT LINE */
2642       case C1_NEL:              /* ESC E */
2643         {
2644           wchar_t nlcr[] = { C0_LF, C0_CR };
2645           scr_add_lines (nlcr, sizeof (nlcr) / sizeof (nlcr [0]), 1);
2646         }
2647         break;
2648
2649         /* kidnapped escape sequence: Should be 8.3.48 */
2650       case C1_ESA:              /* ESC G */
2651         process_graphics ();
2652         break;
2653
2654         /* 8.3.63: CHARACTER TABULATION SET */
2655       case C1_HTS:              /* ESC H */
2656         scr_set_tab (1);
2657         break;
2658
2659         /* 8.3.105: REVERSE LINE FEED */
2660       case C1_RI:                       /* ESC M */
2661         scr_index (DN);
2662         break;
2663
2664         /* 8.3.142: SINGLE-SHIFT TWO */
2665       /*case C1_SS2: scr_single_shift (2);   break; */
2666
2667         /* 8.3.143: SINGLE-SHIFT THREE */
2668       /*case C1_SS3: scr_single_shift (3);   break; */
2669
2670         /* 8.3.27: DEVICE CONTROL STRING */
2671       case C1_DCS:              /* ESC P */
2672         process_dcs_seq ();
2673         break;
2674
2675         /* 8.3.110: SINGLE CHARACTER INTRODUCER */
2676       case C1_SCI:              /* ESC Z */
2677         tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
2678         break;                  /* steal obsolete ESC [ c */
2679
2680         /* 8.3.16: CONTROL SEQUENCE INTRODUCER */
2681       case C1_CSI:              /* ESC [ */
2682         process_csi_seq ();
2683         break;
2684
2685         /* 8.3.90: OPERATING SYSTEM COMMAND */
2686       case C1_OSC:              /* ESC ] */
2687         process_osc_seq ();
2688         break;
2689
2690         /* 8.3.106: RESET TO INITIAL STATE */
2691       case 'c':
2692         mbstate.reset ();
2693         scr_poweron ();
2694         scrollbar_show (1);
2695         break;
2696
2697         /* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2698       case 'n':
2699         scr_charset_choose (2);
2700         break;
2701
2702         /* 8.3.81: LOCKING-SHIFT THREE (see ISO2022) */
2703       case 'o':
2704         scr_charset_choose (3);
2705         break;
2706     }
2707 }
2708 /*}}} */
2709
2710 /*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
2711 /* *INDENT-OFF* */
2712 enum {
2713   CSI_ICH = 0x40,
2714            CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
2715   CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
2716   CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
2717   CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
2718   CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
2719   CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
2720   CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,
2721   CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F
2722 };
2723
2724 #define make_byte(b7,b6,b5,b4,b3,b2,b1,b0)                      \
2725     (((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4)      \
2726      | ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2727 #define get_byte_array_bit(array, bit)                          \
2728     (!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))
2729
2730 const unsigned char csi_defaults[] =
2731   {
2732     make_byte (1,1,1,1,1,1,1,1),        /* @, A, B, C, D, E, F, G, */
2733     make_byte (1,1,0,0,1,1,0,0),        /* H, I, J, K, L, M, N, O, */
2734     make_byte (1,0,1,1,1,1,1,0),        /* P, Q, R, S, T, U, V, W, */
2735     make_byte (1,1,1,0,0,0,1,0),        /* X, Y, Z, [, \, ], ^, _, */
2736     make_byte (1,1,1,0,1,1,1,0),        /* `, a, b, c, d, e, f, g, */
2737     make_byte (0,0,1,1,0,0,0,0),        /* h, i, j, k, l, m, n, o, */
2738     make_byte (0,0,0,0,0,0,0,0),        /* p, q, r, s, t, u, v, w, */
2739     make_byte (0,0,0,0,0,0,0,0),        /* x, y, z, {, |, }, ~,    */
2740   };
2741 /* *INDENT-ON* */
2742
2743 void
2744 rxvt_term::process_csi_seq ()
2745 {
2746   unicode_t ch, priv, i;
2747   unsigned int nargs, p;
2748   int n, ndef;
2749   int arg[ESC_ARGS] = { };
2750
2751   nargs = 0;
2752
2753   priv = 0;
2754   ch = cmd_getc ();
2755   if (ch >= '<' && ch <= '?')
2756     {   /* '<' '=' '>' '?' */
2757       priv = ch;
2758       ch = cmd_getc ();
2759     }
2760
2761   /* read any numerical arguments */
2762   for (n = -1; ch < CSI_ICH; )
2763     {
2764       if (isdigit (ch))
2765         {
2766           if (n < 0)
2767             n = ch - '0';
2768           else
2769             n = n * 10 + ch - '0';
2770         }
2771       else if (ch == ';')
2772         {
2773           if (nargs < ESC_ARGS)
2774             arg[nargs++] = n;
2775           n = -1;
2776         }
2777       else if (IS_CONTROL (ch))
2778         process_nonprinting (ch);
2779
2780       ch = cmd_getc ();
2781     }
2782
2783   if (ch > CSI_7F)
2784     return;
2785
2786   if (nargs < ESC_ARGS)
2787     arg[nargs++] = n;
2788
2789   i = ch - CSI_ICH;
2790   ndef = get_byte_array_bit (csi_defaults, i);
2791   for (p = 0; p < nargs; p++)
2792     if (arg[p] == -1)
2793       arg[p] = ndef;
2794
2795   /*
2796    * private mode handling
2797    */
2798   if (priv)
2799     {
2800       switch (priv)
2801         {
2802           case '>':
2803             if (ch == CSI_DA)   /* secondary device attributes */
2804               {
2805                 // first parameter is normally 0 for vt100, 1 for vt220, 'R' for rxvt,
2806                 // 'U' for rxvt-unicode != 7.[34] (where it was broken).
2807                 //
2808                 // second parameter is xterm patch level for xterm, MMmmpp (e.g. 20703) for rxvt
2809                 // and Mm (e.g. 72 for 7.2) for urxvt <= 7.2, 94 for urxvt <= 8.3, and 95 for later
2810                 // versions.
2811                 //
2812                 tt_printf ("\033[>%d;95;0c", 'U');
2813               }
2814             break;
2815           case '?':
2816             if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2817               process_terminal_mode (ch, priv, nargs, arg);
2818             break;
2819         }
2820       return;
2821     }
2822
2823   switch (ch)
2824     {
2825         /*
2826          * ISO/IEC 6429:1992 (E) CSI sequences (defaults in parentheses)
2827          */
2828 #ifdef PRINTPIPE
2829       case CSI_MC:              /* 8.3.83: (0) MEDIA COPY */
2830         switch (arg[0])
2831           {
2832             case 0:                     /* initiate transfer to primary aux device */
2833               scr_printscreen (0);
2834               break;
2835             case 5:                     /* start relay to primary aux device */
2836               process_print_pipe ();
2837               break;
2838           }
2839         break;
2840 #endif
2841
2842       case CSI_CUU:             /* 8.3.22: (1) CURSOR UP */
2843       case CSI_VPR:             /* 8.3.161: (1) LINE POSITION FORWARD */
2844         arg[0] = -arg[0];
2845         /* FALLTHROUGH */
2846       case CSI_CUD:             /* 8.3.19: (1) CURSOR DOWN */
2847       case CSI_VPB:             /* 8.3.160: (1) LINE POSITION BACKWARD */
2848         scr_gotorc (arg[0], 0, RELATIVE);
2849         break;
2850
2851       case CSI_CUB:             /* 8.3.18: (1) CURSOR LEFT */
2852       case CSI_HPB:             /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2853 #ifdef ISO6429
2854         arg[0] = -arg[0];
2855 #else                           /* emulate common DEC VTs */
2856         arg[0] = arg[0] ? -arg[0] : -1;
2857 #endif
2858         /* FALLTHROUGH */
2859       case CSI_CUF:             /* 8.3.20: (1) CURSOR RIGHT */
2860       case CSI_HPR:             /* 8.3.60: (1) CHARACTER POSITION FORWARD */
2861 #ifdef ISO6429
2862         scr_gotorc (0, arg[0], RELATIVE);
2863 #else                           /* emulate common DEC VTs */
2864         scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);
2865 #endif
2866         break;
2867
2868       case CSI_CPL:             /* 8.3.13: (1) CURSOR PRECEDING LINE */
2869         arg[0] = -arg[0];
2870         /* FALLTHROUGH */
2871       case CSI_CNL:             /* 8.3.12: (1) CURSOR NEXT LINE */
2872         scr_gotorc (arg[0], 0, R_RELATIVE);
2873         break;
2874
2875       case CSI_CHA:             /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */
2876       case CSI_HPA:             /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */
2877         scr_gotorc (0, arg[0] - 1, R_RELATIVE);
2878         break;
2879
2880       case CSI_VPA:             /* 8.3.159: (1) LINE POSITION ABSOLUTE */
2881         scr_gotorc (arg[0] - 1, 0, C_RELATIVE);
2882         break;
2883
2884       case CSI_CUP:             /* 8.3.21: (1,1) CURSOR POSITION */
2885       case CSI_HVP:             /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */
2886         scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);
2887         break;
2888
2889       case CSI_CBT:             /* 8.3.7: (1) CURSOR BACKWARD TABULATION */
2890         arg[0] = -arg[0];
2891         /* FALLTHROUGH */
2892       case CSI_CHT:             /* 8.3.10: (1) CURSOR FORWARD TABULATION */
2893         scr_tab (arg[0]);
2894         break;
2895
2896       case CSI_ED:              /* 8.3.40: (0) ERASE IN PAGE */
2897         scr_erase_screen (arg[0]);
2898         break;
2899
2900       case CSI_EL:              /* 8.3.42: (0) ERASE IN LINE */
2901         scr_erase_line (arg[0]);
2902         break;
2903
2904       case CSI_ICH:             /* 8.3.65: (1) INSERT CHARACTER */
2905         scr_insdel_chars (arg[0], INSERT);
2906         break;
2907
2908       case CSI_IL:              /* 8.3.68: (1) INSERT LINE */
2909         scr_insdel_lines (arg[0], INSERT);
2910         break;
2911
2912       case CSI_DL:              /* 8.3.33: (1) DELETE LINE */
2913         scr_insdel_lines (arg[0], DELETE);
2914         break;
2915
2916       case CSI_ECH:             /* 8.3.39: (1) ERASE CHARACTER */
2917         scr_insdel_chars (arg[0], ERASE);
2918         break;
2919
2920       case CSI_DCH:             /* 8.3.26: (1) DELETE CHARACTER */
2921         scr_insdel_chars (arg[0], DELETE);
2922         break;
2923
2924       case CSI_SD:              /* 8.3.114: (1) SCROLL DOWN */
2925         arg[0] = -arg[0];
2926         /* FALLTHROUGH */
2927       case CSI_SU:              /* 8.3.148: (1) SCROLL UP */
2928         scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2929         break;
2930
2931       case CSI_DA:              /* 8.3.24: (0) DEVICE ATTRIBUTES */
2932         tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2933         break;
2934
2935       case CSI_SGR:             /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2936         process_sgr_mode (nargs, arg);
2937         break;
2938
2939       case CSI_DSR:             /* 8.3.36: (0) DEVICE STATUS REPORT */
2940         switch (arg[0])
2941           {
2942             case 5:                     /* DSR requested */
2943               tt_printf ("\033[0n");
2944               break;
2945             case 6:                     /* CPR requested */
2946               scr_report_position ();
2947               break;
2948             case 7:                     /* unofficial extension */
2949               if (option (Opt_insecure))
2950                 tt_printf ("%-.250s\012", rs[Rs_display_name]);
2951               break;
2952             case 8:                     /* unofficial extension */
2953               process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2954               break;
2955           }
2956         break;
2957
2958       case CSI_TBC:             /* 8.3.155: (0) TABULATION CLEAR */
2959         switch (arg[0])
2960           {
2961             case 0:                     /* char tab stop cleared at active position */
2962               scr_set_tab (0);
2963               break;
2964               /* case 1: */             /* line tab stop cleared in active line */
2965               /* case 2: */             /* char tab stops cleared in active line */
2966             case 3:                     /* all char tab stops are cleared */
2967               /* case 4: */             /* all line tab stops are cleared */
2968             case 5:                     /* all tab stops are cleared */
2969               scr_set_tab (-1);
2970               break;
2971           }
2972         break;
2973
2974       case CSI_CTC:             /* 8.3.17: (0) CURSOR TABULATION CONTROL */
2975         switch (arg[0])
2976           {
2977             case 0:                     /* char tab stop set at active position */
2978               scr_set_tab (1);
2979               break;            /* = ESC H */
2980               /* case 1: */             /* line tab stop set at active line */
2981             case 2:                     /* char tab stop cleared at active position */
2982               scr_set_tab (0);
2983               break;            /* = ESC [ 0 g */
2984               /* case 3: */             /* line tab stop cleared at active line */
2985               /* case 4: */             /* char tab stops cleared at active line */
2986             case 5:                     /* all char tab stops are cleared */
2987               scr_set_tab (-1);
2988               break;            /* = ESC [ 3 g */
2989               /* case 6: */             /* all line tab stops are cleared */
2990           }
2991         break;
2992
2993       case CSI_RM:              /* 8.3.107: RESET MODE */
2994         if (arg[0] == 4)
2995           scr_insert_mode (0);
2996         else if (arg[0] == 20)
2997           priv_modes &= ~PrivMode_LFNL;
2998         break;
2999
3000       case CSI_SM:              /* 8.3.126: SET MODE */
3001         if (arg[0] == 4)
3002           scr_insert_mode (1);
3003         else if (arg[0] == 20)
3004           priv_modes |= PrivMode_LFNL;
3005         break;
3006
3007         /*
3008          * PRIVATE USE beyond this point.  All CSI_7? sequences here
3009          */
3010       case CSI_72:              /* DECSTBM: set top and bottom margins */
3011         if (nargs == 1)
3012           scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);
3013         else if (nargs == 0 || arg[0] >= arg[1])
3014           scr_scroll_region (0, MAX_ROWS - 1);
3015         else
3016           scr_scroll_region (arg[0] - 1, arg[1] - 1);
3017         break;
3018
3019       case CSI_73:
3020         scr_cursor (SAVE);
3021         break;
3022       case CSI_75:
3023         scr_cursor (RESTORE);
3024         break;
3025
3026 #if !ENABLE_MINIMAL
3027       case CSI_74:
3028         process_window_ops (arg, nargs);
3029         break;
3030 #endif
3031
3032       case CSI_78:              /* DECREQTPARM */
3033         if (arg[0] == 0 || arg[0] == 1)
3034           tt_printf ("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
3035         break;
3036
3037       default:
3038         break;
3039     }
3040 }
3041 /*}}} */
3042
3043 #if !ENABLE_MINIMAL
3044 /* ARGSUSED */
3045 void
3046 rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3047 {
3048   int x, y;
3049   XWindowAttributes wattr;
3050   Window wdummy;
3051
3052   dLocal (Display *, dpy);
3053
3054   if (nargs == 0)
3055     return;
3056
3057   switch (args[0])
3058     {
3059       /*
3060        * commands
3061        */
3062       case 1:                   /* deiconify window */
3063         XMapWindow (dpy, parent[0]);
3064         break;
3065       case 2:                   /* iconify window */
3066         XIconifyWindow (dpy, parent[0], display->screen);
3067         break;
3068       case 3:                   /* set position (pixels) */
3069         XMoveWindow (dpy, parent[0], args[1], args[2]);
3070         break;
3071       case 4:                   /* set size (pixels) */
3072         set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3073         break;
3074       case 5:                   /* raise window */
3075         XRaiseWindow (dpy, parent[0]);
3076         break;
3077       case 6:                   /* lower window */
3078         XLowerWindow (dpy, parent[0]);
3079         break;
3080       case 7:                   /* refresh window */
3081         scr_touch (true);
3082         break;
3083       case 8:                   /* set size (chars) */
3084         set_widthheight ((unsigned int) (args[2] * fwidth),
3085                          (unsigned int) (args[1] * fheight));
3086         break;
3087
3088       //case 9: NYI, TODO, restore maximized window or maximize window
3089       default:
3090         if (args[0] >= 24)      /* set height (chars) */
3091           set_widthheight ((unsigned int)width,
3092                            (unsigned int) (args[1] * fheight));
3093         break;
3094
3095       /*
3096        * reports - some output format copied from XTerm
3097        */
3098       case 11:                  /* report window state */
3099         XGetWindowAttributes (dpy, parent[0], &wattr);
3100         tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3101         break;
3102       case 13:                  /* report window position */
3103         XGetWindowAttributes (dpy, parent[0], &wattr);
3104         XTranslateCoordinates (dpy, parent[0], wattr.root,
3105                                -wattr.border_width, -wattr.border_width,
3106                                &x, &y, &wdummy);
3107         tt_printf ("\033[3;%d;%dt", x, y);
3108         break;
3109       case 14:                  /* report window size (pixels) */
3110         XGetWindowAttributes (dpy, parent[0], &wattr);
3111         tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3112         break;
3113       case 18:                  /* report text area size (chars) */
3114         tt_printf ("\033[8;%d;%dt", nrow, ncol);
3115         break;
3116       case 19:                  /* report window size (chars) */
3117         tt_printf ("\033[9;%d;%dt", nrow, ncol);
3118         break;
3119       case 20:                  /* report icon label */
3120         {
3121           char *s;
3122           XGetIconName (dpy, parent[0], &s);
3123           tt_printf ("\033]L%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3124           XFree (s);
3125         }
3126         break;
3127       case 21:                  /* report window title */
3128         {
3129           char *s;
3130           XFetchName (dpy, parent[0], &s);
3131           tt_printf ("\033]l%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3132           XFree (s);
3133         }
3134         break;
3135     }
3136 }
3137 #endif
3138
3139 /*----------------------------------------------------------------------*/
3140 /*
3141  * get input up until STRING TERMINATOR (or BEL)
3142  * ends_how is terminator used. returned input must be free()'d
3143  */
3144 char *
3145 rxvt_term::get_to_st (unicode_t &ends_how)
3146 {
3147   unicode_t ch;
3148   bool seen_esc = false;
3149   unsigned int n = 0;
3150   wchar_t string[STRING_MAX];
3151
3152   while ((ch = cmd_getc ()) != NOCHAR)
3153     {
3154       if (seen_esc)
3155         {
3156           if (ch == 0x5c)       /* 7bit ST */
3157             break;
3158           else
3159             return NULL;
3160         }
3161       else if (ch == C0_ESC)
3162         {
3163           seen_esc = true;
3164           continue;
3165         }
3166       else if (ch == C0_BEL || ch == CHAR_ST)
3167         break;
3168       else if (ch == C0_SYN)
3169         ch = cmd_get8 ();
3170       else if (ch < 0x20)
3171         return NULL;    /* other control character - exit */
3172
3173       seen_esc = false;
3174
3175       if (n >= STRING_MAX - 1)
3176         // stop at some sane length
3177         return NULL;
3178
3179       string[n++] = ch;
3180     }
3181
3182   string[n++] = '\0';
3183
3184   ends_how = (ch == 0x5c ? C0_ESC : ch);
3185
3186   return rxvt_wcstombs (string);
3187 }
3188
3189 /*----------------------------------------------------------------------*/
3190 /*
3191  * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
3192  */
3193 void
3194 rxvt_term::process_dcs_seq ()
3195 {
3196   char *s;
3197   unicode_t eh;
3198
3199   /*
3200    * Not handled yet
3201    */
3202   s = get_to_st (eh);
3203   if (s)
3204     free (s);
3205
3206   return;
3207 }
3208
3209 /*----------------------------------------------------------------------*/
3210 /*
3211  * process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3212  */
3213 void
3214 rxvt_term::process_osc_seq ()
3215 {
3216   unicode_t ch, eh;
3217   int arg;
3218
3219   ch = cmd_getc ();
3220   for (arg = 0; isdigit (ch); ch = cmd_getc ())
3221     arg = arg * 10 + (ch - '0');
3222
3223   if (ch == ';')
3224     {
3225       char *s = get_to_st (eh);
3226
3227       if (s)
3228         {
3229           process_xterm_seq (arg, s, eh);
3230           free (s);
3231         }
3232     }
3233 }
3234
3235 void
3236 rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3237 {
3238   if (str[0] == '?' && !str[1])
3239     {
3240       rgba c;
3241       pix_colors_focused[color].get (c);
3242
3243 #if XFT
3244       if (c.a != rgba::MAX_CC)
3245         tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);
3246       else
3247 #endif
3248         tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);
3249     }
3250   else
3251     set_window_color (color, str);
3252 }
3253
3254 /*
3255  * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3256  */
3257 void
3258 rxvt_term::process_xterm_seq (int op, const char *str, char resp)
3259 {
3260   int color;
3261   char *buf, *name;
3262   bool query = str[0] == '?' && !str[1];
3263   int saveop = op;
3264
3265   dLocal (Display *, dpy);
3266
3267   assert (str != NULL);
3268
3269   if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_INT, op, DT_STR, str, DT_END)))
3270     return;
3271
3272   switch (op)
3273     {
3274       case XTerm_name:
3275         set_title (str);
3276         /* FALLTHROUGH */
3277       case XTerm_iconName:
3278         set_icon_name (str);
3279         break;
3280       case XTerm_title:
3281         set_title (str);
3282         break;
3283       case XTerm_property:
3284         if (str[0] == '?')
3285           {
3286             Atom prop = display->atom (str + 1);
3287             Atom actual_type;
3288             int actual_format;
3289             unsigned long nitems;
3290             unsigned long bytes_after;
3291             unsigned char *value = 0;
3292             const char *str = "";
3293
3294             if (prop
3295                 && XGetWindowProperty (dpy, parent[0],
3296                                        prop, 0, 1<<16, 0, AnyPropertyType,
3297                                        &actual_type, &actual_format,
3298                                        &nitems, &bytes_after, &value) == Success
3299                 && actual_type != None
3300                 && actual_format == 8)
3301               str = (const char *)(value);
3302
3303             tt_printf ("\033]%d;%s%c", op, str, resp);
3304
3305             XFree (value);
3306           }
3307         else
3308           {
3309             char *eq = strchr (str, '='); // constness lost, but verified to be ok
3310
3311             if (eq)
3312               {
3313                 *eq = 0;
3314                 set_utf8_property (display->atom (str), eq + 1);
3315               }
3316             else
3317               XDeleteProperty (dpy, parent[0],
3318                                display->atom (str));
3319           }
3320         break;
3321
3322       case XTerm_Color:
3323         for (buf = (char *)str; buf && *buf;)
3324           {
3325             if ((name = strchr (buf, ';')) == NULL)
3326               break;
3327
3328             *name++ = '\0';
3329             color = atoi (buf) + minCOLOR;
3330
3331             if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3332               break;
3333
3334             if ((buf = strchr (name, ';')) != NULL)
3335               *buf++ = '\0';
3336
3337             process_color_seq (op, color, name, resp);
3338           }
3339         break;
3340       case XTerm_Color00:
3341         process_color_seq (op, Color_fg, str, resp);
3342         break;
3343       case XTerm_Color01:
3344         process_color_seq (op, Color_bg, str, resp);
3345         break;
3346 #ifndef NO_CURSORCOLOR
3347       case XTerm_Color_cursor:
3348         process_color_seq (op, Color_cursor, str, resp);
3349         break;
3350 #endif
3351       case XTerm_Color_pointer_fg:
3352         process_color_seq (op, Color_pointer_fg, str, resp);
3353         break;
3354       case XTerm_Color_pointer_bg:
3355         process_color_seq (op, Color_pointer_bg, str, resp);
3356         break;
3357 #ifndef NO_BOLD_UNDERLINE_REVERSE
3358       case XTerm_Color_RV:
3359         process_color_seq (op, Color_RV, str, resp);
3360         break;
3361       case Rxvt_Color_BD:
3362       case URxvt_Color_BD:
3363         process_color_seq (op, Color_BD, str, resp);
3364         break;
3365       case Rxvt_Color_UL:
3366       case URxvt_Color_UL:
3367         process_color_seq (op, Color_UL, str, resp);
3368         break;
3369       case URxvt_Color_IT:
3370         process_color_seq (op, Color_IT, str, resp);
3371         break;
3372 #endif
3373 #if ENABLE_TRANSPARENCY
3374       case URxvt_Color_tint:
3375         process_color_seq (op, Color_tint, str, resp);
3376         {
3377           bool changed = false;
3378           if (ISSET_PIXCOLOR (Color_tint))
3379             changed = bgPixmap.set_tint (pix_colors_focused [Color_tint]);
3380           else
3381             changed = bgPixmap.unset_tint ();
3382           if (changed)
3383             update_background ();
3384         }
3385
3386         break;
3387 #endif
3388
3389 #if BG_IMAGE_FROM_FILE
3390       case Rxvt_Pixmap:
3391         if (!strcmp (str, "?"))
3392           {
3393             char str[256];
3394
3395             sprintf (str, "[%dx%d+%d+%d]",      /* can't presume snprintf () ! */
3396                      min (bgPixmap.h_scale, 32767), min (bgPixmap.v_scale, 32767),
3397                      min (bgPixmap.h_align, 32767), min (bgPixmap.v_align, 32767));
3398             process_xterm_seq (XTerm_title, str, CHAR_ST);
3399           }
3400         else
3401           {
3402             int changed = 0;
3403
3404             if (*str != ';')
3405               {
3406                 /* reset to default scaling :*/
3407                 bgPixmap.unset_geometry ();
3408                 if (bgPixmap.set_file (str))    /* change pixmap */
3409                   changed++;
3410                 str = strchr (str, ';');
3411                 if (str == NULL)
3412                   bgPixmap.set_defaultGeometry ();
3413               }
3414             while (str)
3415               {
3416                 str++;
3417                 if (bgPixmap.set_geometry (str))
3418                   changed++;
3419                 str = strchr (str, ';');
3420               }
3421             if (changed)
3422                 update_background ();
3423           }
3424         break;
3425 #endif
3426
3427       case Rxvt_restoreFG:
3428         set_window_color (Color_fg, str);
3429         break;
3430       case Rxvt_restoreBG:
3431         set_window_color (Color_bg, str);
3432         break;
3433
3434       case XTerm_logfile:
3435         // TODO, when secure mode?
3436         break;
3437
3438 #if 0
3439       case Rxvt_dumpscreen:     /* no error notices */
3440         {
3441           int fd;
3442           if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3443             {
3444               scr_dump (fd);
3445               close (fd);
3446             }
3447         }
3448         break;
3449 #endif
3450       case XTerm_font:
3451         op = URxvt_font;
3452       case URxvt_font:
3453 #if ENABLE_STYLES
3454       case URxvt_boldFont:
3455       case URxvt_italicFont:
3456       case URxvt_boldItalicFont:
3457 #endif
3458         if (query)
3459           tt_printf ("\33]%d;%-.250s%c", saveop,
3460                      option (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
3461                        ? fontset[op - URxvt_font]->fontdesc : "",
3462                      resp);
3463         else
3464           {
3465             const char *&res = rs[Rs_font + (op - URxvt_font)];
3466
3467             res = strdup (str);
3468             allocated.push_back ((void *)res);
3469             set_fonts ();
3470           }
3471         break;
3472
3473       case URxvt_version:
3474         if (query)
3475           tt_printf ("\33]%d;rxvt-unicode;%-.20s;%c;%c%c",
3476                      op,
3477                      rs[Rs_name], VERSION[0], VERSION[2],
3478                      resp);
3479         break;
3480
3481 #if !ENABLE_MINIMAL
3482       case URxvt_locale:
3483         if (query)
3484           tt_printf ("\33]%d;%-.250s%c", op, option (Opt_insecure) ? locale : "", resp);
3485         else
3486           {
3487             set_locale (str);
3488             pty->set_utf8_mode (enc_utf8);
3489             init_xlocale ();
3490           }
3491         break;
3492
3493       case URxvt_view_up:
3494       case URxvt_view_down:
3495         {
3496           int lines = atoi (str);
3497
3498           if (lines)
3499             scr_page (op == URxvt_view_up ? UP : DN, lines);
3500           else
3501             scr_erase_savelines ();
3502         }
3503
3504         break;
3505 #endif
3506
3507 #if ENABLE_PERL
3508       case URxvt_perl:
3509         if (HOOK_INVOKE ((this, HOOK_OSC_SEQ_PERL, DT_STR, str, DT_END)))
3510           ; // no responses yet
3511         break;
3512 #endif
3513     }
3514 }
3515 /*----------------------------------------------------------------------*/
3516
3517 /*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */
3518 /*
3519  * mode can only have the following values:
3520  *      'l' = low
3521  *      'h' = high
3522  *      's' = save
3523  *      'r' = restore
3524  *      't' = toggle
3525  * so no need for fancy checking
3526  */
3527 int
3528 rxvt_term::privcases (int mode, unsigned long bit)
3529 {
3530   int state;
3531
3532   if (mode == 's')
3533     {
3534       SavedModes |= (priv_modes & bit);
3535       return -1;
3536     }
3537   else
3538     {
3539       if (mode == 'r')
3540         state = (SavedModes & bit) ? 1 : 0;     /* no overlapping */
3541       else
3542         state = (mode == 't') ? ! (priv_modes & bit) : mode;
3543       PrivMode (state, bit);
3544     }
3545
3546   return state;
3547 }
3548
3549 /* we're not using priv _yet_ */
3550 void
3551 rxvt_term::process_terminal_mode (int mode, int priv UNUSED, unsigned int nargs, const int *arg)
3552 {
3553   unsigned int i, j;
3554   int state;
3555
3556   static const struct
3557   {
3558     const int       argval;
3559     const unsigned long bit;
3560   } argtopriv[] = {
3561                   { 1, PrivMode_aplCUR },
3562                   { 2, PrivMode_vt52 },
3563                   { 3, PrivMode_132 },
3564                   { 4, PrivMode_smoothScroll },
3565                   { 5, PrivMode_rVideo },
3566                   { 6, PrivMode_relOrigin },
3567                   { 7, PrivMode_Autowrap },
3568                  // 8, bi-directional support mode
3569                   { 9, PrivMode_MouseX10 },
3570                  // 18, 19 printing-related
3571                   { 25, PrivMode_VisibleCursor },
3572 #ifdef scrollBar_esc
3573                   { scrollBar_esc, PrivMode_scrollBar },
3574 #endif
3575                   { 35, PrivMode_ShiftKeys }, // rxvt extension
3576                   { 40, PrivMode_132OK },
3577                  // 41 xterm more fixes NYI
3578                  // 45 margin bell NYI
3579                  // 46 start logging
3580                   { 47, PrivMode_Screen },
3581                   { 66, PrivMode_aplKP },
3582 #ifndef NO_BACKSPACE_KEY
3583                   { 67, PrivMode_BackSpace },
3584 #endif
3585                   { 1000, PrivMode_MouseX11 },
3586                  // 1001 Use Hilite Mouse Tracking. NYI, TODO
3587                   { 1002, PrivMode_MouseBtnEvent },
3588                   { 1003, PrivMode_MouseAnyEvent },
3589                   { 1010, PrivMode_TtyOutputInh }, // rxvt extension
3590                   { 1011, PrivMode_Keypress }, // rxvt extension
3591                  // 1035 enable modifiers for alt, numlock NYI
3592                  // 1036 send ESC for meta keys NYI
3593                  // 1037 send DEL for keypad delete NYI
3594                   { 1047, PrivMode_Screen },
3595                  // 1048 save and restore cursor
3596                   { 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3597                  // 1051, 1052, 1060, 1061 keyboard emulation NYI
3598                 };
3599
3600   if (nargs == 0)
3601     return;
3602
3603   /* make lo/hi boolean */
3604   if (mode == 'l')
3605     mode = 0;           /* reset */
3606   else if (mode == 'h')
3607     mode = 1;           /* set */
3608
3609   for (i = 0; i < nargs; i++)
3610     {
3611       state = -1;
3612
3613       /* basic handling */
3614       for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)
3615         if (argtopriv[j].argval == arg[i])
3616           {
3617             state = privcases (mode, argtopriv[j].bit);
3618             break;
3619           }
3620
3621       /* extra handling for values with state unkept  */
3622       switch (arg[i])
3623         {
3624 #if ENABLE_STYLES
3625           case 1021:
3626             set_option (Opt_intensityStyles, mode);
3627
3628             scr_touch (true);
3629             break;
3630 #endif
3631           case 1048:            /* alternative cursor save */
3632           case 1049:
3633             if (option (Opt_secondaryScreen))
3634               if (mode == 0)
3635                 scr_cursor (RESTORE);
3636               else if (mode == 1)
3637                 scr_cursor (SAVE);
3638             break;
3639         }
3640
3641       if (state >= 0)
3642         /* extra handling for values with valid 0 or 1 state */
3643         switch (arg[i])
3644           {
3645               /* case 1:        - application cursor keys */
3646             case 2:                     /* VT52 mode */
3647               /* oddball mode.  should be set regardless of set/reset
3648                * parameter.  Return from VT52 mode with an ESC < from
3649                * within VT52 mode
3650                */
3651               PrivMode (1, PrivMode_vt52);
3652               break;
3653             case 3:                     /* 80/132 */
3654               if (priv_modes & PrivMode_132OK)
3655                 set_widthheight (((state ? 132 : 80) * fwidth), height);
3656               break;
3657             case 4:                     /* smooth scrolling */
3658               set_option (Opt_jumpScroll, !state);
3659               break;
3660             case 5:                     /* reverse video */
3661               scr_rvideo_mode (state);
3662               break;
3663             case 6:                     /* relative/absolute origins  */
3664               scr_relative_origin (state);
3665               break;
3666             case 7:                     /* autowrap */
3667               scr_autowrap (state);
3668               break;
3669             /* case 8:  - auto repeat, can't do on a per window basis */
3670             case 9:                     /* X10 mouse reporting */
3671               if (state)                /* orthogonal */
3672                 priv_modes &= ~(PrivMode_MouseX11|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3673               break;
3674 #ifdef scrollBar_esc
3675             case scrollBar_esc:
3676               if (scrollbar_mapping (state))
3677                 {
3678                   resize_all_windows (0, 0, 0);
3679                   scr_touch (true);
3680                 }
3681               break;
3682 #endif
3683             case 25:            /* visible/invisible cursor */
3684               scr_cursor_visible (state);
3685               break;
3686             /* case 35: - shift keys */
3687             /* case 40: - 80 <--> 132 mode */
3688             case 47:            /* secondary screen */
3689               scr_change_screen (state);
3690               break;
3691             /* case 66: - application key pad */
3692             /* case 67: - backspace key */
3693             case 1000:          /* X11 mouse reporting */
3694               if (state)                /* orthogonal */
3695                 priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3696               break;
3697 #if 0
3698             case 1001:
3699               break;            /* X11 mouse highlighting */
3700 #endif
3701             case 1002:
3702             case 1003:
3703               if (state)
3704                 {
3705                   priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseX11);
3706                   priv_modes &= arg[i] == 1003 ? ~PrivMode_MouseBtnEvent : ~PrivMode_MouseAnyEvent;
3707                   vt_emask_mouse = PointerMotionMask;
3708                 }
3709               else
3710                 vt_emask_mouse = NoEventMask;
3711               vt_select_input ();
3712               break;
3713             case 1010:          /* scroll to bottom on TTY output inhibit */
3714               set_option (Opt_scrollTtyOutput, !state);
3715               break;
3716             case 1011:          /* scroll to bottom on key press */
3717               set_option (Opt_scrollTtyKeypress, state);
3718               break;
3719             case 1047:          /* secondary screen w/ clearing last */
3720               if (option (Opt_secondaryScreen))
3721                 if (current_screen != PRIMARY)
3722                   scr_erase_screen (2);
3723               scr_change_screen (state);
3724               break;
3725             case 1049:          /* secondary screen w/ clearing first */
3726               scr_change_screen (state);
3727               if (option (Opt_secondaryScreen))
3728                 if (current_screen != PRIMARY)
3729                   scr_erase_screen (2);
3730               break;
3731             default:
3732               break;
3733           }
3734     }
3735 }
3736 /*}}} */
3737
3738 /*{{{ process sgr sequences */
3739 void
3740 rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
3741 {
3742   unsigned int i;
3743   short rendset;
3744   int rendstyle;
3745
3746   if (nargs == 0)
3747     {
3748       scr_rendition (0, ~RS_None);
3749       return;
3750     }
3751
3752   for (i = 0; i < nargs; i++)
3753     {
3754       rendset = -1;
3755       switch (arg[i])
3756         {
3757           case 0:
3758             rendset = 0, rendstyle = ~RS_None;
3759             break;
3760           case 1:
3761             rendset = 1, rendstyle = RS_Bold;
3762             break;
3763           //case 2: // low intensity
3764           case 3:
3765             rendset = 1, rendstyle = RS_Italic;
3766             break;
3767           case 4:
3768             rendset = 1, rendstyle = RS_Uline;
3769             break;
3770           case 5: // slowly blinking
3771           case 6: // rapidly blinking
3772             rendset = 1, rendstyle = RS_Blink;
3773             break;
3774           //case 6: // scoansi light background
3775           case 7:
3776             rendset = 1, rendstyle = RS_RVid;
3777             break;
3778           case 8:
3779             // invisible. NYI
3780             break;
3781           //case 9: // crossed out
3782           //case 10: // scoansi acs off, primary font
3783           //case 11: // scoansi acs on, first alt font
3784           //case 12: // scoansi acs on, |0x80, second alt font
3785           //...
3786           //case 19: // ninth alt font
3787           //case 20: // gothic
3788           case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3789             rendset = 0, rendstyle = RS_Bold;
3790             break;
3791           case 22: // normal intensity
3792             rendset = 0, rendstyle = RS_Bold;
3793             break;
3794           case 23: // disable italic
3795             rendset = 0, rendstyle = RS_Italic;
3796             break;
3797           case 24:
3798             rendset = 0, rendstyle = RS_Uline;
3799             break;
3800           case 25:
3801             rendset = 0, rendstyle = RS_Blink;
3802             break;
3803           case 26: // variable spacing (iso 8613)
3804             rendset = 0, rendstyle = RS_Blink;
3805             break;
3806           case 27:
3807             rendset = 0, rendstyle = RS_RVid;
3808             break;
3809           //case 28: // visible. NYI
3810           //case 29: // not crossed-out
3811         }
3812
3813       if (rendset != -1)
3814         {
3815           scr_rendition (rendset, rendstyle);
3816           continue;             /* for (;i;) */
3817         }
3818
3819       switch (arg[i])
3820         {
3821           case 30:
3822           case 31:              /* set fg color */
3823           case 32:
3824           case 33:
3825           case 34:
3826           case 35:
3827           case 36:
3828           case 37:
3829             scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3830             break;
3831           case 38: // set fg color, ISO 8613-6
3832             if (nargs > i + 2 && arg[i + 1] == 5)
3833               {
3834                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3835                 i += 2;
3836               }
3837             break;
3838           case 39:              /* default fg */
3839             scr_color (Color_fg, Color_fg);
3840             break;
3841
3842           case 40:
3843           case 41:              /* set bg color */
3844           case 42:
3845           case 43:
3846           case 44:
3847           case 45:
3848           case 46:
3849           case 47:
3850             scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3851             break;
3852           case 48: // set bg color, ISO 8613-6
3853             if (nargs > i + 2 && arg[i + 1] == 5)
3854               {
3855                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3856                 i += 2;
3857               }
3858             break;
3859           case 49:              /* default bg */
3860             scr_color (Color_bg, Color_bg);
3861             break;
3862
3863           //case 50: // not variable spacing
3864
3865 #if !ENABLE_MINIMAL
3866           case 90:
3867           case 91:              /* set bright fg color */
3868           case 92:
3869           case 93:
3870           case 94:
3871           case 95:
3872           case 96:
3873           case 97:
3874             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3875             break;
3876           case 100:
3877           case 101:             /* set bright bg color */
3878           case 102:
3879           case 103:
3880           case 104:
3881           case 105:
3882           case 106:
3883           case 107:
3884             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3885             break;
3886 #endif
3887         }
3888     }
3889 }
3890 /*}}} */
3891
3892 /*{{{ (do not) process Rob Nation's own graphics mode sequences */
3893 void
3894 rxvt_term::process_graphics ()
3895 {
3896   unicode_t ch, cmd = cmd_getc ();
3897
3898   if (cmd == 'Q')
3899     {           /* query graphics */
3900       tt_printf ("\033G0\012"); /* no graphics */
3901       return;
3902     }
3903   /* swallow other graphics sequences until terminating ':' */
3904   do
3905     ch = cmd_getc ();
3906   while (ch != ':');
3907 }
3908 /*}}} */
3909
3910 /* ------------------------------------------------------------------------- */
3911
3912 /*
3913  * Send printf () formatted output to the command.
3914  * Only use for small amounts of data.
3915  */
3916 void
3917 rxvt_term::tt_printf (const char *fmt,...)
3918 {
3919   va_list arg_ptr;
3920   char buf[256];
3921
3922   va_start (arg_ptr, fmt);
3923   vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3924   va_end (arg_ptr);
3925   tt_write (buf, strlen (buf));
3926 }
3927
3928 /* ---------------------------------------------------------------------- */
3929 /* Write data to the pty as typed by the user, pasted with the mouse,
3930  * or generated by us in response to a query ESC sequence.
3931  */
3932 const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
3933
3934 void
3935 rxvt_term::tt_write (const char *data, unsigned int len)
3936 {
3937   if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
3938     return;
3939
3940   if (pty->pty < 0)
3941     return;
3942
3943   if (v_buflen == 0)
3944     {
3945       ssize_t written = write (pty->pty, data, min (len, MAX_PTY_WRITE));
3946
3947       if ((unsigned int)written == len)
3948         return;
3949
3950       data += written;
3951       len  -= written;
3952     }
3953
3954   v_buffer = (char *)realloc (v_buffer, v_buflen + len);
3955
3956   memcpy (v_buffer + v_buflen, data, len);
3957   v_buflen += len;
3958
3959   pty_ev.set (ev::READ | ev::WRITE);
3960 }
3961
3962 void rxvt_term::pty_write ()
3963 {
3964   int written = write (pty->pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
3965
3966   if (written > 0)
3967     {
3968       v_buflen -= written;
3969
3970       if (v_buflen == 0)
3971         {
3972           free (v_buffer);
3973           v_buffer = 0;
3974
3975           pty_ev.set (ev::READ);
3976           return;
3977         }
3978
3979       memmove (v_buffer, v_buffer + written, v_buflen);
3980     }
3981   else if (written != -1 || (errno != EAGAIN && errno != EINTR))
3982     pty_ev.set (ev::READ);
3983 }
3984
3985 /*----------------------- end-of-file (C source) -----------------------*/
3986