src/command.C

   1 /*----------------------------------------------------------------------*
   2  * File:        command.C
   3  *----------------------------------------------------------------------*
   4  *
   5  * All portions of code are copyright by their respective author/s.
   6  * Copyright (c) 1992      John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
   7  *                              - original version
   8  * Copyright (c) 1994      Robert Nation <nation@rocket.sanders.lockheed.com>
   9  *                              - extensive modifications
  10  * Copyright (c) 1995      Garrett D'Amore <garrett@netcom.com>
  11  *                              - vt100 printing
  12  * Copyright (c) 1995      Steven Hirsch <hirsch@emba.uvm.edu>
  13  *                              - X11 mouse report mode and support for
  14  *                                DEC "private mode" save/restore functions.
  15  * Copyright (c) 1995      Jakub Jelinek <jj@gnu.ai.mit.edu>
  16  *                              - key-related changes to handle Shift+function
  17  *                                keys properly.
  18  * Copyright (c) 1997      MJ Olesen <olesen@me.queensu.ca>
  19  *                              - extensive modifications
  20  * Copyright (c) 1997      Raul Garcia Garcia <rgg@tid.es>
  21  *                              - modification and cleanups for Solaris 2.x
  22  *                                and Linux 1.2.x
  23  * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
  24  * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  25  *                              - extensive modifications
  26  * Copyright (c) 1998      Alfredo K. Kojima <kojima@windowmaker.org>
  27  * Copyright (c) 2001      Marius Gedminas
  28  *                              - Ctrl/Mod4+Tab works like Meta+Tab (options)
  29  * Copyright (c) 2003      Rob McMullen <robm@flipturn.org>
  30  * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
  31  *
  32  * This program is free software; you can redistribute it and/or modify
  33  * it under the terms of the GNU General Public License as published by
  34  * the Free Software Foundation; either version 2 of the License, or
  35  * (at your option) any later version.
  36  *
  37  * This program is distributed in the hope that it will be useful,
  38  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  39  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  40  * GNU General Public License for more details.
  41  *
  42  * You should have received a copy of the GNU General Public License
  43  * along with this program; if not, write to the Free Software
  44  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  45  *----------------------------------------------------------------------*/
  46
  47 /*{{{ includes: */
  48 #include "../config.h"
  49 #include "rxvt.h"
  50 #include "rxvtperl.h"
  51 #include "version.h"
  52 #include "command.h"
  53
  54 #ifdef KEYSYM_RESOURCE
  55 # include "keyboard.h"
  56 #endif
  57
  58 #include <csignal>
  59
  60 #if LINUX_YIELD_HACK
  61 # include <ctime>
  62 #endif
  63
  64 /*----------------------------------------------------------------------*/
  65
  66 #define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
  67
  68 #if ENABLE_FRILLS || ISO_14755
  69
  70 #define ISO_14755_STARTED       0x80000000UL
  71 #define ISO_14755_51            0x40000000UL // basic (section 5.1)
  72 #define ISO_14755_52            0x20000000UL // keycap (section 5.2)
  73 #define ISO_14755_54            0x10000000UL // code feedback (section 5.4)
  74 #define ISO_14755_MASK          0x0fffffffUL
  75
  76 #if ISO_14755
  77 static unsigned short iso14755_symtab[] = {
  78   // keysym,            unicode
  79   XK_Left,              0x2190,
  80   XK_KP_Left,           0x2190,
  81   XK_Up,                0x2191,
  82   XK_KP_Up,             0x2191,
  83   XK_Right,             0x2192,
  84   XK_KP_Right,          0x2192,
  85   XK_Down,              0x2193,
  86   XK_KP_Down,           0x2193,
  87   XK_Linefeed,          0x21b4,
  88   XK_Return,            0x21b5,
  89   XK_KP_Enter,          0x21b5,
  90
  91   XK_Prior,             0x21de,
  92   XK_Next,              0x21df,
  93   XK_Tab,               0x21e5,
  94   XK_ISO_Left_Tab,      0x21e6,
  95   XK_Shift_L,           0x21e7,
  96   XK_Shift_R,           0x21e7,
  97
  98   XK_Shift_Lock,        0x21eb,
  99   XK_ISO_Lock,          0x21eb,
 100   XK_Caps_Lock,         0x21ec,
 101   XK_Num_Lock,          0x21ed,
 102   XK_ISO_Level3_Shift,  0x21ee,
 103   XK_ISO_Level3_Lock,   0x21ef,
 104   XK_ISO_Group_Lock,    0x21f0,
 105   XK_Home,              0x21f1,
 106   XK_End,               0x21f2,
 107
 108   XK_Execute,           0x2318,
 109   XK_Begin,             0x2320,
 110   XK_Delete,            0x2326,
 111   XK_Clear,             0x2327,
 112   XK_BackSpace,         0x232b,
 113   XK_Insert,            0x2380,
 114   XK_Control_L,         0x2388,
 115   XK_Control_R,         0x2388,
 116   XK_Pause,             0x2389,
 117   XK_Break,             0x238a,
 118   XK_Escape,            0x238b,
 119   XK_Undo,              0x238c,
 120   XK_Print,             0x2399,
 121
 122   XK_space,             0x2423,
 123
 124 #ifdef XK_KP_Begin
 125   XK_KP_Prior,          0x21de,
 126   XK_KP_Next,           0x21df,
 127   XK_KP_Begin,          0x2320,
 128   XK_KP_Insert,         0x2380,
 129   XK_KP_Delete,         0x2326,
 130   XK_KP_Space,          0x2422,
 131 #endif
 132   0,
 133 };
 134
 135 void
 136 rxvt_term::iso14755_54 (int x, int y)
 137 {
 138   x = Pixel2Col (x);
 139   y = Pixel2Row (y);
 140
 141   if (!IN_RANGE_EXC (x, 0, ncol)
 142       || !IN_RANGE_EXC (y, 0, nrow))
 143     return;
 144
 145   for (;;)
 146     {
 147       const line_t &l = ROW(y + view_start);
 148
 149       text_t t = l.t[x];
 150
 151       if (t != NOCHAR || !x)
 152         {
 153           iso14755_51 (l.t[x], l.r[x], x, y);
 154           iso14755buf = ISO_14755_54;
 155           break;
 156         }
 157
 158       x--;
 159     }
 160 }
 161
 162 void
 163 rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)
 164 {
 165   rxvt_fontset *fs = FONTSET (r);
 166   rxvt_font *f = (*fs)[fs->find_font (ch)];
 167   wchar_t *chr, *alloc, ch2, *fname;
 168   int len;
 169
 170   fname = rxvt_utf8towcs (f->name);
 171
 172 # if ENABLE_COMBINING
 173   if (IS_COMPOSE (ch))
 174     {
 175       len = rxvt_composite.expand (ch, 0);
 176       alloc = chr = new wchar_t[len];
 177       rxvt_composite.expand (ch, chr);
 178     }
 179   else
 180 # endif
 181     {
 182       ch2 = ch;
 183
 184       alloc = 0;
 185       chr = &ch2;
 186       len = 1;
 187     }
 188
 189   char attr[80]; // plenty
 190
 191   sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
 192            (int)r,
 193            fgcolor_of (r), bgcolor_of (r),
 194            r & RS_Bold    ? " bold"    : "",
 195            r & RS_Italic  ? " italic"  : "",
 196            r & RS_Blink   ? " blink"   : "",
 197            r & RS_RVid    ? " rvid"    : "",
 198            r & RS_Uline   ? " uline"   : "",
 199            r & RS_Careful ? " careful" : "");
 200
 201   int width = wcswidth (fname, wcslen (fname));
 202
 203   max_it (width, 8+5); // for char + 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.is_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   else
1085     w.stop ();
1086 }
1087 #endif
1088
1089 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1090 void
1091 rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
1092 {
1093   if ((scrollbar_isUp() || scrollbar_isDn()) &&
1094       scr_page (scrollbar_isUp() ? UP : DN, 1))
1095     want_refresh = 1;
1096   else
1097     w.stop ();
1098 }
1099 #endif
1100
1101 #ifdef SELECTION_SCROLLING
1102 void
1103 rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
1104 {
1105   if (scr_page (scroll_selection_dir, scroll_selection_lines))
1106     {
1107       selection_extend (selection_save_x, selection_save_y, selection_save_state);
1108       want_refresh = 1;
1109     }
1110   else
1111     w.stop ();
1112 }
1113 #endif
1114
1115 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1116 void
1117 rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
1118 {
1119   if (scr_page (mouse_slip_wheel_speed < 0 ? DN : UP, abs (mouse_slip_wheel_speed)))
1120     want_refresh = 1;
1121
1122   if (view_start == top_row || view_start == 0 || mouse_slip_wheel_speed == 0)
1123     {
1124       mouse_slip_wheel_speed = 0;
1125       w.stop ();
1126     }
1127 }
1128 #endif
1129
1130 #if LINUX_YIELD_HACK
1131 static struct event_handler
1132 {
1133   ev::prepare yield_ev;
1134
1135   void yield_cb (ev::prepare &w, int revents)
1136   {
1137     // this should really be sched_yield(), but the linux guys thought
1138     // that giving a process calling sched_yield () less cpu time than
1139     // ones with high nice levels is a useful thing to do. It surely is is
1140     // allowed by the sus... as is returning ENOSYS.
1141
1142     struct timespec ts = { 0, 0 };
1143     nanosleep (&ts, 0);
1144
1145     w.stop ();
1146   }
1147
1148   event_handler ()
1149   : yield_ev (this, &event_handler::yield_cb)
1150   {
1151   }
1152 } event_handler;
1153 #endif
1154
1155 bool
1156 rxvt_term::pty_fill ()
1157 {
1158   ssize_t n = cmdbuf_endp - cmdbuf_ptr;
1159
1160   if (CBUFSIZ == n)
1161     {
1162       rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
1163       n = 0;
1164     }
1165
1166   memmove (cmdbuf_base, cmdbuf_ptr, n);
1167   cmdbuf_ptr = cmdbuf_base;
1168   cmdbuf_endp = cmdbuf_ptr + n;
1169
1170   ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
1171
1172   if (r > 0)
1173     {
1174       cmdbuf_endp += r;
1175       return true;
1176     }
1177   else if (r < 0 && (errno == EAGAIN || errno == EINTR))
1178     {
1179 #if LINUX_YIELD_HACK
1180       if (display->is_local)
1181         event_handler.yield_ev.start ();
1182 #endif
1183     }
1184   else
1185     {
1186       pty_ev.stop ();
1187
1188       if (!option (Opt_hold))
1189         destroy ();
1190     }
1191
1192   return false;
1193 }
1194
1195 void
1196 rxvt_term::pty_cb (ev::io &w, int revents)
1197 {
1198   make_current ();
1199
1200   if (revents & ev::READ)
1201     // loop, but don't allow a single term to monopolize us
1202     while (pty_fill ())
1203       if (cmd_parse ())
1204         break;
1205
1206   if (revents & ev::WRITE)
1207     pty_write ();
1208 }
1209
1210 void
1211 rxvt_term::pointer_unblank ()
1212 {
1213   XDefineCursor (dpy, vt, TermWin_cursor);
1214   recolour_cursor ();
1215
1216 #ifdef POINTER_BLANK
1217   hidden_pointer = 0;
1218
1219   if (option (Opt_pointerBlank))
1220     pointer_ev.start (pointerBlankDelay);
1221 #endif
1222 }
1223
1224 #ifdef POINTER_BLANK
1225 void
1226 rxvt_term::pointer_blank ()
1227 {
1228   if (!option (Opt_pointerBlank))
1229     return;
1230
1231   XDefineCursor (dpy, vt, display->blank_cursor);
1232   XFlush (dpy);
1233
1234   hidden_pointer = 1;
1235 }
1236
1237 void
1238 rxvt_term::pointer_cb (ev::timer &w, int revents)
1239 {
1240   make_current ();
1241
1242   pointer_blank ();
1243 }
1244 #endif
1245
1246 void
1247 rxvt_term::mouse_report (XButtonEvent &ev)
1248 {
1249   int button_number, key_state = 0;
1250   int x, y;
1251   int code = 32;
1252
1253   x = Pixel2Col (ev.x);
1254   y = Pixel2Row (ev.y);
1255   if (ev.type == MotionNotify)
1256     {
1257       if (x == mouse_row && y == mouse_col)
1258         return;
1259       mouse_row = x;
1260       mouse_col = y;
1261       code += 32;
1262     }
1263
1264   if (MEvent.button == AnyButton)
1265     button_number = 3;
1266   else
1267     {
1268       button_number = MEvent.button - Button1;
1269       /* add 0x3D for wheel events, like xterm does */
1270       if (button_number >= 3)
1271         button_number += (64 - 3);
1272     }
1273
1274   if (priv_modes & PrivMode_MouseX10)
1275     {
1276       /*
1277        * do not report ButtonRelease
1278        * no state info allowed
1279        */
1280       key_state = 0;
1281       if (button_number == 3)
1282         return;
1283     }
1284   else
1285     {
1286       /* XTerm mouse reporting needs these values:
1287        *   4 = Shift
1288        *   8 = Meta
1289        *  16 = Control
1290        * plus will add in our own Double-Click reporting
1291        *  32 = Double Click
1292        */
1293       key_state = ((MEvent.state & ShiftMask) ? 4 : 0)
1294                   + ((MEvent.state & ModMetaMask) ? 8 : 0)
1295                   + ((MEvent.state & ControlMask) ? 16 : 0);
1296 #ifdef MOUSE_REPORT_DOUBLECLICK
1297       key_state += ((MEvent.clicks > 1) ? 32 : 0);
1298 #endif
1299     }
1300
1301 #if DEBUG_MOUSEREPORT
1302   fprintf (stderr, "Mouse [");
1303   if (key_state & 16)
1304     fputc ('C', stderr);
1305   if (key_state & 4)
1306     fputc ('S', stderr);
1307   if (key_state & 8)
1308     fputc ('A', stderr);
1309   if (key_state & 32)
1310     fputc ('2', stderr);
1311   fprintf (stderr, "]: <%d>, %d/%d\n",
1312           button_number,
1313           x + 1,
1314           y + 1);
1315 #endif
1316
1317   tt_printf ("\033[M%c%c%c",
1318             (code + button_number + key_state),
1319             (32 + x + 1),
1320             (32 + y + 1));
1321 }
1322
1323 /*{{{ process an X event */
1324 void
1325 rxvt_term::x_cb (XEvent &ev)
1326 {
1327   make_current ();
1328
1329   dLocal (Display *, dpy);
1330
1331   if (ev.xany.window == vt
1332       && SHOULD_INVOKE (HOOK_X_EVENT)
1333       && HOOK_INVOKE ((this, HOOK_X_EVENT, DT_XEVENT, &ev, DT_END)))
1334     return;
1335
1336   // for XQueryPointer
1337   Window unused_root, unused_child;
1338   int unused_root_x, unused_root_y;
1339   unsigned int unused_mask;
1340
1341   switch (ev.type)
1342     {
1343       case KeyPress:
1344         key_press (ev.xkey);
1345         break;
1346
1347       case KeyRelease:
1348         key_release (ev.xkey);
1349         break;
1350
1351       case ButtonPress:
1352         button_press (ev.xbutton);
1353         break;
1354
1355       case ButtonRelease:
1356         button_release (ev.xbutton);
1357         break;
1358
1359       case ClientMessage:
1360         if (ev.xclient.format == 32
1361             && !HOOK_INVOKE ((this, HOOK_CLIENT_MESSAGE, DT_XEVENT, &ev, DT_END)))
1362           {
1363             if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1364               {
1365                 if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1366                   {
1367                     if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1368                       {
1369                         if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1370                           destroy ();
1371                       }
1372 #if ENABLE_EWMH
1373                     else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1374                       XSendEvent (dpy, ev.xclient.window = display->root,
1375                                   False, SubstructureRedirectMask | SubstructureNotifyMask,
1376                                   &ev);
1377 #endif
1378                   }
1379               }
1380 #if ENABLE_XEMBED
1381             else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1382               {
1383                 if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
1384                   focus_in ();
1385                 else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
1386                   focus_out ();
1387               }
1388 #endif
1389           }
1390         break;
1391
1392         /*
1393          * XXX: this is not the _current_ arrangement
1394          * Here's my conclusion:
1395          * If the window is completely unobscured, use bitblt's
1396          * to scroll. Even then, they're only used when doing partial
1397          * screen scrolling. When partially obscured, we have to fill
1398          * in the GraphicsExpose parts, which means that after each refresh,
1399          * we need to wait for the graphics expose or Noexpose events,
1400          * which ought to make things real slow!
1401          */
1402       case VisibilityNotify:
1403         switch (ev.xvisibility.state)
1404           {
1405             case VisibilityUnobscured:
1406               refresh_type = FAST_REFRESH;
1407               break;
1408             case VisibilityPartiallyObscured:
1409               refresh_type = SLOW_REFRESH;
1410               break;
1411             default:
1412               refresh_type = NO_REFRESH;
1413               break;
1414           }
1415         break;
1416
1417       case FocusIn:
1418         if (ev.xfocus.detail != NotifyInferior
1419             && ev.xfocus.detail != NotifyPointer
1420             && ev.xfocus.mode != NotifyGrab)
1421           focus_in ();
1422         break;
1423
1424       case FocusOut:
1425         if (ev.xfocus.detail != NotifyInferior
1426             && ev.xfocus.detail != NotifyPointer
1427             && ev.xfocus.mode != NotifyGrab)
1428           focus_out ();
1429         break;
1430
1431       case ConfigureNotify:
1432       /* fprintf (stderr, "ConfigureNotify for %X, parent is %X, geom is %dx%d%+d%+d, old geom was %dx%d\n",
1433               ev.xconfigure.window, parent[0], ev.xconfigure.width, ev.xconfigure.height, ev.xconfigure.x, ev.xconfigure.y,
1434               szHint.width, szHint.height); */
1435         if (ev.xconfigure.window == parent[0])
1436           {
1437             while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1438               ;
1439
1440             if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1441               {
1442                 seen_resize = 1;
1443                 resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1444               }
1445             else
1446               {
1447 #ifdef HAVE_BG_PIXMAP
1448                 if (bgPixmap.window_position_sensitive ())
1449                   update_background ();
1450 #endif
1451               }
1452             HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1453           }
1454         break;
1455
1456       case PropertyNotify:
1457         if (!HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END)))
1458           if (ev.xproperty.atom == xa[XA_VT_SELECTION]
1459               && ev.xproperty.state == PropertyNewValue)
1460             selection_property (ev.xproperty.window, ev.xproperty.atom);
1461
1462         break;
1463
1464       case SelectionClear:
1465         selection_clear ();
1466         break;
1467
1468       case SelectionNotify:
1469         if (selection_wait == Sel_normal)
1470           selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1471         break;
1472
1473       case SelectionRequest:
1474         selection_send (ev.xselectionrequest);
1475         break;
1476
1477       case MapNotify:
1478         mapped = 1;
1479 #ifdef TEXT_BLINK
1480         text_blink_ev.start ();
1481 #endif
1482         HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1483         break;
1484
1485       case UnmapNotify:
1486         mapped = 0;
1487 #ifdef TEXT_BLINK
1488         text_blink_ev.stop ();
1489 #endif
1490         HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1491         break;
1492
1493       case GraphicsExpose:
1494       case Expose:
1495         if (ev.xany.window == vt)
1496           {
1497             do
1498               {
1499                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1500                             ev.xexpose.width, ev.xexpose.height, False);
1501               }
1502             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev));
1503
1504             ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1505
1506             while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev))
1507               {
1508                 scr_expose (ev.xexpose.x, ev.xexpose.y,
1509                             ev.xexpose.width, ev.xexpose.height, False);
1510               }
1511             want_refresh = 1;
1512           }
1513         else
1514           {
1515             XEvent unused_event;
1516
1517             while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1518               ;
1519             while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1520               ;
1521
1522             if (isScrollbarWindow (ev.xany.window))
1523               {
1524                 scrollBar.setIdle ();
1525                 scrollbar_show (0);
1526               }
1527           }
1528         break;
1529
1530       case MotionNotify:
1531 #ifdef POINTER_BLANK
1532         if (hidden_pointer)
1533           pointer_unblank ();
1534 #endif
1535         if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1536             || priv_modes & PrivMode_MouseAnyEvent)
1537           mouse_report (ev.xbutton);
1538         if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1539           break;
1540
1541         if (ev.xany.window == vt)
1542           {
1543             if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1544                 && HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1545               ; // nop
1546             else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1547               {
1548                 while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1549                   ;
1550
1551                 XQueryPointer (dpy, vt,
1552                                &unused_root, &unused_child,
1553                                &unused_root_x, &unused_root_y,
1554                                &ev.xbutton.x, &ev.xbutton.y,
1555                                &ev.xbutton.state);
1556 #ifdef MOUSE_THRESHOLD
1557                 /* deal with a `jumpy' mouse */
1558                 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1559                   {
1560 #endif
1561 #if ISO_14755
1562                     // 5.4
1563                     if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1564                       {
1565                         iso14755_54 (ev.xbutton.x, ev.xbutton.y);
1566                         break;
1567                       }
1568 #endif
1569                     selection_extend (ev.xbutton.x, ev.xbutton.y,
1570                                       ev.xbutton.state & Button3Mask ? 2 : 0);
1571
1572 #ifdef SELECTION_SCROLLING
1573                     if (ev.xbutton.y < int_bwidth
1574                         || Pixel2Row (ev.xbutton.y) > (nrow-1))
1575                       {
1576                         int dist;
1577
1578                         /* don't clobber the current delay if we are
1579                          * already in the middle of scrolling.
1580                          */
1581                         if (!sel_scroll_ev.is_active ())
1582                           sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1583
1584                         /* save the event params so we can highlight
1585                          * the selection in the pending-scroll loop
1586                          */
1587                         selection_save_x = ev.xbutton.x;
1588                         selection_save_y = ev.xbutton.y;
1589                         selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1590
1591                         /* calc number of lines to scroll */
1592                         if (ev.xbutton.y < int_bwidth)
1593                           {
1594                             scroll_selection_dir = UP;
1595                             dist = int_bwidth - ev.xbutton.y;
1596                           }
1597                         else
1598                           {
1599                             scroll_selection_dir = DN;
1600                             dist = ev.xbutton.y - (int_bwidth + height);
1601                           }
1602
1603                         scroll_selection_lines = Pixel2Height (dist)
1604                                                  / SELECTION_SCROLL_LINE_SPEEDUP
1605                                                  + 1;
1606                         min_it (scroll_selection_lines,
1607                                 SELECTION_SCROLL_MAX_LINES);
1608                       }
1609                     else
1610                       {
1611                         /* we are within the text window, so we
1612                          * shouldn't be scrolling
1613                          */
1614                         sel_scroll_ev.stop();
1615                       }
1616 #endif
1617 #ifdef MOUSE_THRESHOLD
1618                   }
1619 #endif
1620               }
1621           }
1622         else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1623           {
1624             while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1625                                            MotionNotify, &ev))
1626               ;
1627
1628             XQueryPointer (dpy, scrollBar.win,
1629                           &unused_root, &unused_child,
1630                           &unused_root_x, &unused_root_y,
1631                           &ev.xbutton.x, &ev.xbutton.y,
1632                           &unused_mask);
1633             scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1634                          scrollbar_size ());
1635             want_refresh = 1;
1636             scrollbar_show (1);
1637           }
1638         break;
1639     }
1640
1641 #if defined(CURSOR_BLINK)
1642   if (option (Opt_cursorBlink) && ev.type == KeyPress)
1643     {
1644       if (hidden_cursor)
1645         {
1646           hidden_cursor = 0;
1647           want_refresh = 1;
1648         }
1649
1650       cursor_blink_ev.again ();
1651     }
1652 #endif
1653
1654 #if defined(POINTER_BLANK)
1655   if (option (Opt_pointerBlank) && pointerBlankDelay > 0)
1656     {
1657       if (ev.type == MotionNotify
1658           || ev.type == ButtonPress
1659           || ev.type == ButtonRelease)
1660         if (hidden_pointer)
1661           pointer_unblank ();
1662
1663       if (ev.type == KeyPress && hidden_pointer == 0)
1664         pointer_blank ();
1665     }
1666 #endif
1667 }
1668
1669 void
1670 rxvt_term::focus_in ()
1671 {
1672   if (!focus)
1673     {
1674       focus = 1;
1675       want_refresh = 1;
1676
1677       HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1678
1679 #if USE_XIM
1680       if (Input_Context != NULL)
1681         {
1682           IMSetPosition ();
1683           XSetICFocus (Input_Context);
1684         }
1685 #endif
1686 #if CURSOR_BLINK
1687       if (option (Opt_cursorBlink))
1688         cursor_blink_ev.again ();
1689 #endif
1690 #if OFF_FOCUS_FADING
1691       if (rs[Rs_fade])
1692         {
1693           pix_colors = pix_colors_focused;
1694           scr_recolour ();
1695         }
1696 #endif
1697 #if ENABLE_FRILLS
1698       if (option (Opt_urgentOnBell))
1699         {
1700           if (XWMHints *h = XGetWMHints(dpy, parent[0]))
1701             {
1702               h->flags &= ~XUrgencyHint;
1703               XSetWMHints (dpy, parent[0], h);
1704             }
1705         }
1706 #endif
1707     }
1708 }
1709
1710 void
1711 rxvt_term::focus_out ()
1712 {
1713   if (focus)
1714     {
1715       focus = 0;
1716       want_refresh = 1;
1717
1718       HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1719
1720 #if ENABLE_FRILLS || ISO_14755
1721       if (iso14755buf)
1722         {
1723           iso14755buf = 0;
1724 # if ISO_14755
1725           scr_overlay_off ();
1726 # endif
1727         }
1728 #endif
1729 #if USE_XIM
1730       if (Input_Context != NULL)
1731         XUnsetICFocus (Input_Context);
1732 #endif
1733 #if CURSOR_BLINK
1734       if (option (Opt_cursorBlink))
1735         cursor_blink_ev.stop ();
1736
1737       hidden_cursor = 0;
1738 #endif
1739 #if OFF_FOCUS_FADING
1740       if (rs[Rs_fade])
1741         {
1742           pix_colors = pix_colors_unfocused;
1743           scr_recolour ();
1744         }
1745 #endif
1746     }
1747 }
1748
1749 void
1750 rxvt_term::update_fade_color (unsigned int idx)
1751 {
1752 #if OFF_FOCUS_FADING
1753   if (rs[Rs_fade])
1754     {
1755       rgba c;
1756       pix_colors [Color_fade].get (c);
1757       pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
1758     }
1759 #endif
1760 }
1761
1762 #if ENABLE_TRANSPARENCY || ENABLE_PERL
1763 void
1764 rxvt_term::rootwin_cb (XEvent &ev)
1765 {
1766   make_current ();
1767
1768   if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
1769       && HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
1770     return;
1771
1772 # if ENABLE_TRANSPARENCY
1773   switch (ev.type)
1774     {
1775       case PropertyNotify:
1776         /*
1777          * if user used some Esetroot compatible prog to set the root bg,
1778          * use the property to determine the pixmap.  We use it later on.
1779          */
1780         if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1781             || ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1782           {
1783             bgPixmap.set_root_pixmap ();
1784             update_background ();
1785           }
1786         break;
1787     }
1788 # endif
1789 }
1790 #endif
1791
1792 void
1793 rxvt_term::button_press (XButtonEvent &ev)
1794 {
1795   int reportmode = 0, clickintime;
1796
1797   bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1798
1799   if (!bypass_keystate)
1800     reportmode = !! (priv_modes & PrivMode_mouse_report);
1801
1802   /*
1803    * VT window processing of button press
1804    */
1805   if (ev.window == vt)
1806     {
1807       if (HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
1808         return;
1809
1810 #if ISO_14755
1811       // 5.4
1812       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1813         {
1814           iso14755_54 (ev.x, ev.y);
1815           return;
1816         }
1817 #endif
1818
1819       clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1820
1821       if (reportmode)
1822         {
1823           /* mouse report from vt window */
1824           /* save the xbutton state (for ButtonRelease) */
1825           MEvent.state = ev.state;
1826 #ifdef MOUSE_REPORT_DOUBLECLICK
1827           if (ev.button == MEvent.button && clickintime)
1828             {
1829               /* same button, within alloted time */
1830               MEvent.clicks++;
1831
1832               if (MEvent.clicks > 1)
1833                 {
1834                   /* only report double clicks */
1835                   MEvent.clicks = 2;
1836                   mouse_report (ev);
1837
1838                   /* don't report the release */
1839                   MEvent.clicks = 0;
1840                   MEvent.button = AnyButton;
1841                 }
1842             }
1843           else
1844             {
1845               /* different button, or time expired */
1846               MEvent.clicks = 1;
1847               MEvent.button = ev.button;
1848               mouse_report (ev);
1849             }
1850 #else
1851           MEvent.button = ev.button;
1852           mouse_report (ev);
1853 #endif /* MOUSE_REPORT_DOUBLECLICK */
1854
1855         }
1856       else
1857         {
1858           if (ev.button != MEvent.button)
1859             MEvent.clicks = 0;
1860
1861           switch (ev.button)
1862             {
1863               case Button1:
1864                 /* allow meta + click to select rectangular areas */
1865                 /* should be done in screen.C */
1866 #if ENABLE_FRILLS
1867                 selection.rect = !!(ev.state & ModMetaMask);
1868 #else
1869                 selection.rect = false;
1870 #endif
1871
1872                 /* allow shift+left click to extend selection */
1873                 if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1874                   {
1875                     if (MEvent.button == Button1 && clickintime)
1876                       selection_rotate (ev.x, ev.y);
1877                     else
1878                       selection_extend (ev.x, ev.y, 1);
1879                   }
1880                 else
1881                   {
1882                     if (MEvent.button == Button1 && clickintime)
1883                       MEvent.clicks++;
1884                     else
1885                       MEvent.clicks = 1;
1886
1887                     selection_click (MEvent.clicks, ev.x, ev.y);
1888                   }
1889
1890                 MEvent.button = Button1;
1891                 break;
1892
1893               case Button3:
1894                 if (MEvent.button == Button3 && clickintime)
1895                   selection_rotate (ev.x, ev.y);
1896                 else
1897                   selection_extend (ev.x, ev.y, 1);
1898
1899                 MEvent.button = Button3;
1900                 break;
1901             }
1902         }
1903
1904       MEvent.time = ev.time;
1905       return;
1906     }
1907
1908   /*
1909    * Scrollbar window processing of button press
1910    */
1911   if (isScrollbarWindow (ev.window))
1912     {
1913       scrollBar.setIdle ();
1914       /*
1915        * Rxvt-style scrollbar:
1916        * move up if mouse is above slider
1917        * move dn if mouse is below slider
1918        *
1919        * XTerm-style scrollbar:
1920        * Move display proportional to pointer location
1921        * pointer near top -> scroll one line
1922        * pointer near bot -> scroll full page
1923        */
1924 #ifndef NO_SCROLLBAR_REPORT
1925       if (reportmode)
1926         {
1927           /*
1928            * Mouse report disabled scrollbar:
1929            * arrow buttons - send up/down
1930            * click on scrollbar - send pageup/down
1931            */
1932           if ((scrollBar.style == R_SB_NEXT
1933                && scrollbarnext_upButton (ev.y))
1934               || (scrollBar.style == R_SB_RXVT
1935                   && scrollbarrxvt_upButton (ev.y)))
1936             tt_printf ("\033[A");
1937           else if ((scrollBar.style == R_SB_NEXT
1938                     && scrollbarnext_dnButton (ev.y))
1939                    || (scrollBar.style == R_SB_RXVT
1940                        && scrollbarrxvt_dnButton (ev.y)))
1941             tt_printf ("\033[B");
1942           else
1943             switch (ev.button)
1944               {
1945                 case Button2:
1946                   tt_printf ("\014");
1947                   break;
1948                 case Button1:
1949                   tt_printf ("\033[6~");
1950                   break;
1951                 case Button3:
1952                   tt_printf ("\033[5~");
1953                   break;
1954               }
1955         }
1956       else
1957 #endif /* NO_SCROLLBAR_REPORT */
1958
1959         {
1960           char upordown = 0;
1961
1962           if (scrollBar.style == R_SB_NEXT)
1963             {
1964               if (scrollbarnext_upButton (ev.y))
1965                 upordown = -1;  /* up */
1966               else if (scrollbarnext_dnButton (ev.y))
1967                 upordown = 1;   /* down */
1968             }
1969           else if (scrollBar.style == R_SB_RXVT)
1970             {
1971               if (scrollbarrxvt_upButton (ev.y))
1972                 upordown = -1;  /* up */
1973               else if (scrollbarrxvt_dnButton (ev.y))
1974                 upordown = 1;   /* down */
1975             }
1976
1977           if (upordown)
1978             {
1979 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1980               if (!cont_scroll_ev.is_active ())
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   sel_scroll_ev.stop();
2072 #endif
2073
2074   if (ev.window == vt)
2075     {
2076       if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
2077         return;
2078
2079 #if ISO_14755
2080       // 5.4
2081       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
2082         return;
2083 #endif
2084
2085       if (reportmode)
2086         {
2087           /* mouse report from vt window */
2088           /* don't report release of wheel "buttons" */
2089           if (ev.button >= 4)
2090             return;
2091 #ifdef MOUSE_REPORT_DOUBLECLICK
2092           /* only report the release of 'slow' single clicks */
2093           if (MEvent.button != AnyButton
2094               && (ev.button != MEvent.button
2095                   || (ev.time - MEvent.time
2096                       > MULTICLICK_TIME / 2)))
2097             {
2098               MEvent.clicks = 0;
2099               MEvent.button = AnyButton;
2100               mouse_report (ev);
2101             }
2102 #else                           /* MOUSE_REPORT_DOUBLECLICK */
2103           MEvent.button = AnyButton;
2104           mouse_report (ev);
2105 #endif /* MOUSE_REPORT_DOUBLECLICK */
2106           return;
2107         }
2108
2109       /*
2110        * dumb hack to compensate for the failure of click-and-drag
2111        * when overriding mouse reporting
2112        */
2113       if (priv_modes & PrivMode_mouse_report
2114           && bypass_keystate
2115           && ev.button == Button1 && MEvent.clicks <= 1)
2116         selection_extend (ev.x, ev.y, 0);
2117
2118       switch (ev.button)
2119         {
2120           case Button1:
2121           case Button3:
2122             selection_make (ev.time);
2123             break;
2124
2125           case Button2:
2126             if (IN_RANGE_EXC (ev.x, 0, width) && IN_RANGE_EXC (ev.y, 0, height)) // inside window?
2127               selection_request (ev.time, ev.state & ModMetaMask ? Sel_Clipboard : Sel_Primary);
2128             break;
2129
2130 #ifdef MOUSE_WHEEL
2131           case Button4:
2132           case Button5:
2133             {
2134               int i;
2135               page_dirn v;
2136
2137               v = ev.button == Button4 ? UP : DN;
2138
2139               if (ev.state & ShiftMask)
2140                 i = 1;
2141               else if (option (Opt_mouseWheelScrollPage))
2142                 i = nrow - 1;
2143               else
2144                 i = 5;
2145
2146 # ifdef MOUSE_SLIP_WHEELING
2147               if (ev.state & ControlMask)
2148                 {
2149                   mouse_slip_wheel_speed += v ? -1 : 1;
2150                   if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
2151                   if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
2152
2153                   if (!slip_wheel_ev.is_active ())
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_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       /* '<' '=' '>' '?' */
2758       priv = ch;
2759       ch = cmd_getc ();
2760     }
2761
2762   /* read any numerical arguments */
2763   for (n = -1; ch < CSI_ICH; )
2764     {
2765       if (isdigit (ch))
2766         {
2767           if (n < 0)
2768             n = ch - '0';
2769           else
2770             n = n * 10 + ch - '0';
2771         }
2772       else if (ch == ';')
2773         {
2774           if (nargs < ESC_ARGS)
2775             arg[nargs++] = n;
2776           n = -1;
2777         }
2778       else if (IS_CONTROL (ch))
2779         process_nonprinting (ch);
2780
2781       ch = cmd_getc ();
2782     }
2783
2784   if (ch > CSI_7F)
2785     return;
2786
2787   if (nargs < ESC_ARGS)
2788     arg[nargs++] = n;
2789
2790   i = ch - CSI_ICH;
2791   ndef = get_byte_array_bit (csi_defaults, i);
2792   for (p = 0; p < nargs; p++)
2793     if (arg[p] == -1)
2794       arg[p] = ndef;
2795
2796   /*
2797    * private mode handling
2798    */
2799   if (priv)
2800     {
2801       switch (priv)
2802         {
2803           case '>':
2804             if (ch == CSI_DA)   /* secondary device attributes */
2805               {
2806                 // first parameter is normally 0 for vt100, 1 for vt220, 'R' for rxvt,
2807                 // 'U' for rxvt-unicode != 7.[34] (where it was broken).
2808                 //
2809                 // second parameter is xterm patch level for xterm, MMmmpp (e.g. 20703) for rxvt
2810                 // and Mm (e.g. 72 for 7.2) for urxvt <= 7.2, 94 for urxvt <= 8.3, and 95 for later
2811                 // versions.
2812                 //
2813                 tt_printf ("\033[>%d;95;0c", 'U');
2814               }
2815             break;
2816           case '?':
2817             if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2818               process_terminal_mode (ch, priv, nargs, arg);
2819             break;
2820         }
2821       return;
2822     }
2823
2824   switch (ch)
2825     {
2826         /*
2827          * ISO/IEC 6429:1992 (E) CSI sequences (defaults in parentheses)
2828          */
2829 #ifdef PRINTPIPE
2830       case CSI_MC:              /* 8.3.83: (0) MEDIA COPY */
2831         switch (arg[0])
2832           {
2833             case 0:                     /* initiate transfer to primary aux device */
2834               scr_printscreen (0);
2835               break;
2836             case 5:                     /* start relay to primary aux device */
2837               process_print_pipe ();
2838               break;
2839           }
2840         break;
2841 #endif
2842
2843       case CSI_CUU:             /* 8.3.22: (1) CURSOR UP */
2844       case CSI_VPR:             /* 8.3.161: (1) LINE POSITION FORWARD */
2845         arg[0] = -arg[0];
2846         /* FALLTHROUGH */
2847       case CSI_CUD:             /* 8.3.19: (1) CURSOR DOWN */
2848       case CSI_VPB:             /* 8.3.160: (1) LINE POSITION BACKWARD */
2849         scr_gotorc (arg[0], 0, RELATIVE);
2850         break;
2851
2852       case CSI_CUB:             /* 8.3.18: (1) CURSOR LEFT */
2853       case CSI_HPB:             /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2854 #ifdef ISO6429
2855         arg[0] = -arg[0];
2856 #else                           /* emulate common DEC VTs */
2857         arg[0] = arg[0] ? -arg[0] : -1;
2858 #endif
2859         /* FALLTHROUGH */
2860       case CSI_CUF:             /* 8.3.20: (1) CURSOR RIGHT */
2861       case CSI_HPR:             /* 8.3.60: (1) CHARACTER POSITION FORWARD */
2862 #ifdef ISO6429
2863         scr_gotorc (0, arg[0], RELATIVE);
2864 #else                           /* emulate common DEC VTs */
2865         scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);
2866 #endif
2867         break;
2868
2869       case CSI_CPL:             /* 8.3.13: (1) CURSOR PRECEDING LINE */
2870         arg[0] = -arg[0];
2871         /* FALLTHROUGH */
2872       case CSI_CNL:             /* 8.3.12: (1) CURSOR NEXT LINE */
2873         scr_gotorc (arg[0], 0, R_RELATIVE);
2874         break;
2875
2876       case CSI_CHA:             /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */
2877       case CSI_HPA:             /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */
2878         scr_gotorc (0, arg[0] - 1, R_RELATIVE);
2879         break;
2880
2881       case CSI_VPA:             /* 8.3.159: (1) LINE POSITION ABSOLUTE */
2882         scr_gotorc (arg[0] - 1, 0, C_RELATIVE);
2883         break;
2884
2885       case CSI_CUP:             /* 8.3.21: (1,1) CURSOR POSITION */
2886       case CSI_HVP:             /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */
2887         scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);
2888         break;
2889
2890       case CSI_CBT:             /* 8.3.7: (1) CURSOR BACKWARD TABULATION */
2891         arg[0] = -arg[0];
2892         /* FALLTHROUGH */
2893       case CSI_CHT:             /* 8.3.10: (1) CURSOR FORWARD TABULATION */
2894         scr_tab (arg[0]);
2895         break;
2896
2897       case CSI_ED:              /* 8.3.40: (0) ERASE IN PAGE */
2898         scr_erase_screen (arg[0]);
2899         break;
2900
2901       case CSI_EL:              /* 8.3.42: (0) ERASE IN LINE */
2902         scr_erase_line (arg[0]);
2903         break;
2904
2905       case CSI_ICH:             /* 8.3.65: (1) INSERT CHARACTER */
2906         scr_insdel_chars (arg[0], INSERT);
2907         break;
2908
2909       case CSI_IL:              /* 8.3.68: (1) INSERT LINE */
2910         scr_insdel_lines (arg[0], INSERT);
2911         break;
2912
2913       case CSI_DL:              /* 8.3.33: (1) DELETE LINE */
2914         scr_insdel_lines (arg[0], DELETE);
2915         break;
2916
2917       case CSI_ECH:             /* 8.3.39: (1) ERASE CHARACTER */
2918         scr_insdel_chars (arg[0], ERASE);
2919         break;
2920
2921       case CSI_DCH:             /* 8.3.26: (1) DELETE CHARACTER */
2922         scr_insdel_chars (arg[0], DELETE);
2923         break;
2924
2925       case CSI_SD:              /* 8.3.114: (1) SCROLL DOWN */
2926         arg[0] = -arg[0];
2927         /* FALLTHROUGH */
2928       case CSI_SU:              /* 8.3.148: (1) SCROLL UP */
2929         scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2930         break;
2931
2932       case CSI_DA:              /* 8.3.24: (0) DEVICE ATTRIBUTES */
2933         tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2934         break;
2935
2936       case CSI_SGR:             /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2937         process_sgr_mode (nargs, arg);
2938         break;
2939
2940       case CSI_DSR:             /* 8.3.36: (0) DEVICE STATUS REPORT */
2941         switch (arg[0])
2942           {
2943             case 5:                     /* DSR requested */
2944               tt_printf ("\033[0n");
2945               break;
2946             case 6:                     /* CPR requested */
2947               scr_report_position ();
2948               break;
2949             case 7:                     /* unofficial extension */
2950               if (option (Opt_insecure))
2951                 tt_printf ("%-.250s\012", rs[Rs_display_name]);
2952               break;
2953             case 8:                     /* unofficial extension */
2954               process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2955               break;
2956           }
2957         break;
2958
2959       case CSI_TBC:             /* 8.3.155: (0) TABULATION CLEAR */
2960         switch (arg[0])
2961           {
2962             case 0:                     /* char tab stop cleared at active position */
2963               scr_set_tab (0);
2964               break;
2965               /* case 1: */             /* line tab stop cleared in active line */
2966               /* case 2: */             /* char tab stops cleared in active line */
2967             case 3:                     /* all char tab stops are cleared */
2968               /* case 4: */             /* all line tab stops are cleared */
2969             case 5:                     /* all tab stops are cleared */
2970               scr_set_tab (-1);
2971               break;
2972           }
2973         break;
2974
2975       case CSI_CTC:             /* 8.3.17: (0) CURSOR TABULATION CONTROL */
2976         switch (arg[0])
2977           {
2978             case 0:                     /* char tab stop set at active position */
2979               scr_set_tab (1);
2980               break;            /* = ESC H */
2981               /* case 1: */             /* line tab stop set at active line */
2982             case 2:                     /* char tab stop cleared at active position */
2983               scr_set_tab (0);
2984               break;            /* = ESC [ 0 g */
2985               /* case 3: */             /* line tab stop cleared at active line */
2986               /* case 4: */             /* char tab stops cleared at active line */
2987             case 5:                     /* all char tab stops are cleared */
2988               scr_set_tab (-1);
2989               break;            /* = ESC [ 3 g */
2990               /* case 6: */             /* all line tab stops are cleared */
2991           }
2992         break;
2993
2994       case CSI_RM:              /* 8.3.107: RESET MODE */
2995         if (arg[0] == 4)
2996           scr_insert_mode (0);
2997         else if (arg[0] == 20)
2998           priv_modes &= ~PrivMode_LFNL;
2999         break;
3000
3001       case CSI_SM:              /* 8.3.126: SET MODE */
3002         if (arg[0] == 4)
3003           scr_insert_mode (1);
3004         else if (arg[0] == 20)
3005           priv_modes |= PrivMode_LFNL;
3006         break;
3007
3008         /*
3009          * PRIVATE USE beyond this point.  All CSI_7? sequences here
3010          */
3011       case CSI_72:              /* DECSTBM: set top and bottom margins */
3012         if (nargs == 1)
3013           scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);
3014         else if (nargs == 0 || arg[0] >= arg[1])
3015           scr_scroll_region (0, MAX_ROWS - 1);
3016         else
3017           scr_scroll_region (arg[0] - 1, arg[1] - 1);
3018         break;
3019
3020       case CSI_73:
3021         scr_cursor (SAVE);
3022         break;
3023       case CSI_75:
3024         scr_cursor (RESTORE);
3025         break;
3026
3027 #if !ENABLE_MINIMAL
3028       case CSI_74:
3029         process_window_ops (arg, nargs);
3030         break;
3031 #endif
3032
3033       case CSI_78:              /* DECREQTPARM */
3034         if (arg[0] == 0 || arg[0] == 1)
3035           tt_printf ("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
3036         break;
3037
3038       default:
3039         break;
3040     }
3041 }
3042 /*}}} */
3043
3044 #if !ENABLE_MINIMAL
3045 /* ARGSUSED */
3046 void
3047 rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3048 {
3049   int x, y;
3050   XWindowAttributes wattr;
3051   Window wdummy;
3052
3053   dLocal (Display *, dpy);
3054
3055   if (nargs == 0)
3056     return;
3057
3058   switch (args[0])
3059     {
3060       /*
3061        * commands
3062        */
3063       case 1:                   /* deiconify window */
3064         XMapWindow (dpy, parent[0]);
3065         break;
3066       case 2:                   /* iconify window */
3067         XIconifyWindow (dpy, parent[0], display->screen);
3068         break;
3069       case 3:                   /* set position (pixels) */
3070         XMoveWindow (dpy, parent[0], args[1], args[2]);
3071         break;
3072       case 4:                   /* set size (pixels) */
3073         set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3074         break;
3075       case 5:                   /* raise window */
3076         XRaiseWindow (dpy, parent[0]);
3077         break;
3078       case 6:                   /* lower window */
3079         XLowerWindow (dpy, parent[0]);
3080         break;
3081       case 7:                   /* refresh window */
3082         scr_touch (true);
3083         break;
3084       case 8:                   /* set size (chars) */
3085         set_widthheight ((unsigned int) (args[2] * fwidth),
3086                          (unsigned int) (args[1] * fheight));
3087         break;
3088
3089       //case 9: NYI, TODO, restore maximized window or maximize window
3090       default:
3091         if (args[0] >= 24)      /* set height (chars) */
3092           set_widthheight ((unsigned int)width,
3093                            (unsigned int) (args[1] * fheight));
3094         break;
3095
3096       /*
3097        * reports - some output format copied from XTerm
3098        */
3099       case 11:                  /* report window state */
3100         XGetWindowAttributes (dpy, parent[0], &wattr);
3101         tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3102         break;
3103       case 13:                  /* report window position */
3104         XGetWindowAttributes (dpy, parent[0], &wattr);
3105         XTranslateCoordinates (dpy, parent[0], wattr.root,
3106                                -wattr.border_width, -wattr.border_width,
3107                                &x, &y, &wdummy);
3108         tt_printf ("\033[3;%d;%dt", x, y);
3109         break;
3110       case 14:                  /* report window size (pixels) */
3111         XGetWindowAttributes (dpy, parent[0], &wattr);
3112         tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3113         break;
3114       case 18:                  /* report text area size (chars) */
3115         tt_printf ("\033[8;%d;%dt", nrow, ncol);
3116         break;
3117       case 19:                  /* report window size (chars) */
3118         tt_printf ("\033[9;%d;%dt", nrow, ncol);
3119         break;
3120       case 20:                  /* report icon label */
3121         {
3122           char *s;
3123           XGetIconName (dpy, parent[0], &s);
3124           tt_printf ("\033]L%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3125           XFree (s);
3126         }
3127         break;
3128       case 21:                  /* report window title */
3129         {
3130           char *s;
3131           XFetchName (dpy, parent[0], &s);
3132           tt_printf ("\033]l%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
3133           XFree (s);
3134         }
3135         break;
3136     }
3137 }
3138 #endif
3139
3140 /*----------------------------------------------------------------------*/
3141 /*
3142  * get input up until STRING TERMINATOR (or BEL)
3143  * ends_how is terminator used. returned input must be free()'d
3144  */
3145 char *
3146 rxvt_term::get_to_st (unicode_t &ends_how)
3147 {
3148   unicode_t ch;
3149   bool seen_esc = false;
3150   unsigned int n = 0;
3151   wchar_t string[STRING_MAX];
3152
3153   while ((ch = cmd_getc ()) != NOCHAR)
3154     {
3155       if (seen_esc)
3156         {
3157           if (ch == 0x5c)       /* 7bit ST */
3158             break;
3159           else
3160             return NULL;
3161         }
3162       else if (ch == C0_ESC)
3163         {
3164           seen_esc = true;
3165           continue;
3166         }
3167       else if (ch == C0_BEL || ch == CHAR_ST)
3168         break;
3169       else if (ch == C0_SYN)
3170         ch = cmd_get8 ();
3171       else if (ch < 0x20)
3172         return NULL;    /* other control character - exit */
3173
3174       seen_esc = false;
3175
3176       if (n >= STRING_MAX - 1)
3177         // stop at some sane length
3178         return NULL;
3179
3180       string[n++] = ch;
3181     }
3182
3183   string[n++] = '\0';
3184
3185   ends_how = (ch == 0x5c ? C0_ESC : ch);
3186
3187   return rxvt_wcstombs (string);
3188 }
3189
3190 /*----------------------------------------------------------------------*/
3191 /*
3192  * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
3193  */
3194 void
3195 rxvt_term::process_dcs_seq ()
3196 {
3197   char *s;
3198   unicode_t eh;
3199
3200   /*
3201    * Not handled yet
3202    */
3203   s = get_to_st (eh);
3204   if (s)
3205     free (s);
3206
3207   return;
3208 }
3209
3210 /*----------------------------------------------------------------------*/
3211 /*
3212  * process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3213  */
3214 void
3215 rxvt_term::process_osc_seq ()
3216 {
3217   unicode_t ch, eh;
3218   int arg;
3219
3220   ch = cmd_getc ();
3221   for (arg = 0; isdigit (ch); ch = cmd_getc ())
3222     arg = arg * 10 + (ch - '0');
3223
3224   if (ch == ';')
3225     {
3226       char *s = get_to_st (eh);
3227
3228       if (s)
3229         {
3230           process_xterm_seq (arg, s, eh);
3231           free (s);
3232         }
3233     }
3234 }
3235
3236 void
3237 rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3238 {
3239   if (str[0] == '?' && !str[1])
3240     {
3241       rgba c;
3242       pix_colors_focused[color].get (c);
3243
3244 #if XFT
3245       if (c.a != rgba::MAX_CC)
3246         tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);
3247       else
3248 #endif
3249         tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);
3250     }
3251   else
3252     set_window_color (color, str);
3253 }
3254
3255 /*
3256  * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3257  */
3258 void
3259 rxvt_term::process_xterm_seq (int op, const char *str, char resp)
3260 {
3261   int color;
3262   char *buf, *name;
3263   bool query = str[0] == '?' && !str[1];
3264   int saveop = op;
3265
3266   dLocal (Display *, dpy);
3267
3268   assert (str != NULL);
3269
3270   if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_INT, op, DT_STR, str, DT_END)))
3271     return;
3272
3273   switch (op)
3274     {
3275       case XTerm_name:
3276         set_title (str);
3277         /* FALLTHROUGH */
3278       case XTerm_iconName:
3279         set_icon_name (str);
3280         break;
3281       case XTerm_title:
3282         set_title (str);
3283         break;
3284       case XTerm_property:
3285         if (str[0] == '?')
3286           {
3287             Atom prop = display->atom (str + 1);
3288             Atom actual_type;
3289             int actual_format;
3290             unsigned long nitems;
3291             unsigned long bytes_after;
3292             unsigned char *value = 0;
3293             const char *str = "";
3294
3295             if (prop
3296                 && XGetWindowProperty (dpy, parent[0],
3297                                        prop, 0, 1<<16, 0, AnyPropertyType,
3298                                        &actual_type, &actual_format,
3299                                        &nitems, &bytes_after, &value) == Success
3300                 && actual_type != None
3301                 && actual_format == 8)
3302               str = (const char *)(value);
3303
3304             tt_printf ("\033]%d;%s%c", op, str, resp);
3305
3306             XFree (value);
3307           }
3308         else
3309           {
3310             char *eq = strchr (str, '='); // constness lost, but verified to be ok
3311
3312             if (eq)
3313               {
3314                 *eq = 0;
3315                 set_utf8_property (display->atom (str), eq + 1);
3316               }
3317             else
3318               XDeleteProperty (dpy, parent[0],
3319                                display->atom (str));
3320           }
3321         break;
3322
3323       case XTerm_Color:
3324         for (buf = (char *)str; buf && *buf;)
3325           {
3326             if ((name = strchr (buf, ';')) == NULL)
3327               break;
3328
3329             *name++ = '\0';
3330             color = atoi (buf) + minCOLOR;
3331
3332             if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3333               break;
3334
3335             if ((buf = strchr (name, ';')) != NULL)
3336               *buf++ = '\0';
3337
3338             process_color_seq (op, color, name, resp);
3339           }
3340         break;
3341       case XTerm_Color00:
3342         process_color_seq (op, Color_fg, str, resp);
3343         break;
3344       case XTerm_Color01:
3345         process_color_seq (op, Color_bg, str, resp);
3346         break;
3347 #ifndef NO_CURSORCOLOR
3348       case XTerm_Color_cursor:
3349         process_color_seq (op, Color_cursor, str, resp);
3350         break;
3351 #endif
3352       case XTerm_Color_pointer_fg:
3353         process_color_seq (op, Color_pointer_fg, str, resp);
3354         break;
3355       case XTerm_Color_pointer_bg:
3356         process_color_seq (op, Color_pointer_bg, str, resp);
3357         break;
3358 #ifndef NO_BOLD_UNDERLINE_REVERSE
3359       case XTerm_Color_RV:
3360         process_color_seq (op, Color_RV, str, resp);
3361         break;
3362       case Rxvt_Color_BD:
3363       case URxvt_Color_BD:
3364         process_color_seq (op, Color_BD, str, resp);
3365         break;
3366       case Rxvt_Color_UL:
3367       case URxvt_Color_UL:
3368         process_color_seq (op, Color_UL, str, resp);
3369         break;
3370       case URxvt_Color_IT:
3371         process_color_seq (op, Color_IT, str, resp);
3372         break;
3373 #endif
3374 #if ENABLE_TRANSPARENCY
3375       case URxvt_Color_tint:
3376         process_color_seq (op, Color_tint, str, resp);
3377         {
3378           bool changed = false;
3379           if (ISSET_PIXCOLOR (Color_tint))
3380             changed = bgPixmap.set_tint (pix_colors_focused [Color_tint]);
3381           else
3382             changed = bgPixmap.unset_tint ();
3383           if (changed)
3384             update_background ();
3385         }
3386
3387         break;
3388 #endif
3389
3390 #if BG_IMAGE_FROM_FILE
3391       case Rxvt_Pixmap:
3392         if (!strcmp (str, "?"))
3393           {
3394             char str[256];
3395
3396             sprintf (str, "[%dx%d+%d+%d]",      /* can't presume snprintf () ! */
3397                      min (bgPixmap.h_scale, 32767), min (bgPixmap.v_scale, 32767),
3398                      min (bgPixmap.h_align, 32767), min (bgPixmap.v_align, 32767));
3399             process_xterm_seq (XTerm_title, str, CHAR_ST);
3400           }
3401         else
3402           {
3403             int changed = 0;
3404
3405             if (*str != ';')
3406               {
3407                 /* reset to default scaling :*/
3408                 bgPixmap.unset_geometry ();
3409                 if (bgPixmap.set_file (str))    /* change pixmap */
3410                   changed++;
3411                 str = strchr (str, ';');
3412                 if (str == NULL)
3413                   bgPixmap.set_defaultGeometry ();
3414               }
3415             while (str)
3416               {
3417                 str++;
3418                 if (bgPixmap.set_geometry (str))
3419                   changed++;
3420                 str = strchr (str, ';');
3421               }
3422             if (changed)
3423                 update_background ();
3424           }
3425         break;
3426 #endif
3427
3428       case Rxvt_restoreFG:
3429         set_window_color (Color_fg, str);
3430         break;
3431       case Rxvt_restoreBG:
3432         set_window_color (Color_bg, str);
3433         break;
3434
3435       case XTerm_logfile:
3436         // TODO, when secure mode?
3437         break;
3438
3439 #if 0
3440       case Rxvt_dumpscreen:     /* no error notices */
3441         {
3442           int fd;
3443           if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3444             {
3445               scr_dump (fd);
3446               close (fd);
3447             }
3448         }
3449         break;
3450 #endif
3451       case XTerm_font:
3452         op = URxvt_font;
3453       case URxvt_font:
3454 #if ENABLE_STYLES
3455       case URxvt_boldFont:
3456       case URxvt_italicFont:
3457       case URxvt_boldItalicFont:
3458 #endif
3459         if (query)
3460           tt_printf ("\33]%d;%-.250s%c", saveop,
3461                      option (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
3462                        ? fontset[op - URxvt_font]->fontdesc : "",
3463                      resp);
3464         else
3465           {
3466             const char *&res = rs[Rs_font + (op - URxvt_font)];
3467
3468             res = strdup (str);
3469             allocated.push_back ((void *)res);
3470             set_fonts ();
3471           }
3472         break;
3473
3474       case URxvt_version:
3475         if (query)
3476           tt_printf ("\33]%d;rxvt-unicode;%-.20s;%c;%c%c",
3477                      op,
3478                      rs[Rs_name], VERSION[0], VERSION[2],
3479                      resp);
3480         break;
3481
3482 #if !ENABLE_MINIMAL
3483       case URxvt_locale:
3484         if (query)
3485           tt_printf ("\33]%d;%-.250s%c", op, option (Opt_insecure) ? locale : "", resp);
3486         else
3487           {
3488             set_locale (str);
3489             pty->set_utf8_mode (enc_utf8);
3490             init_xlocale ();
3491           }
3492         break;
3493
3494       case URxvt_view_up:
3495       case URxvt_view_down:
3496         {
3497           int lines = atoi (str);
3498
3499           if (lines)
3500             scr_page (op == URxvt_view_up ? UP : DN, lines);
3501           else
3502             scr_erase_savelines ();
3503         }
3504
3505         break;
3506 #endif
3507
3508 #if ENABLE_PERL
3509       case URxvt_perl:
3510         if (HOOK_INVOKE ((this, HOOK_OSC_SEQ_PERL, DT_STR, str, DT_END)))
3511           ; // no responses yet
3512         break;
3513 #endif
3514     }
3515 }
3516 /*----------------------------------------------------------------------*/
3517
3518 /*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */
3519 /*
3520  * mode can only have the following values:
3521  *      'l' = low
3522  *      'h' = high
3523  *      's' = save
3524  *      'r' = restore
3525  *      't' = toggle
3526  * so no need for fancy checking
3527  */
3528 int
3529 rxvt_term::privcases (int mode, unsigned long bit)
3530 {
3531   int state;
3532
3533   if (mode == 's')
3534     {
3535       SavedModes |= (priv_modes & bit);
3536       return -1;
3537     }
3538   else
3539     {
3540       if (mode == 'r')
3541         state = (SavedModes & bit) ? 1 : 0;     /* no overlapping */
3542       else
3543         state = (mode == 't') ? ! (priv_modes & bit) : mode;
3544       PrivMode (state, bit);
3545     }
3546
3547   return state;
3548 }
3549
3550 /* we're not using priv _yet_ */
3551 void
3552 rxvt_term::process_terminal_mode (int mode, int priv UNUSED, unsigned int nargs, const int *arg)
3553 {
3554   unsigned int i, j;
3555   int state;
3556
3557   static const struct
3558   {
3559     const int       argval;
3560     const unsigned long bit;
3561   } argtopriv[] = {
3562                   { 1, PrivMode_aplCUR },
3563                   { 2, PrivMode_vt52 },
3564                   { 3, PrivMode_132 },
3565                   { 4, PrivMode_smoothScroll },
3566                   { 5, PrivMode_rVideo },
3567                   { 6, PrivMode_relOrigin },
3568                   { 7, PrivMode_Autowrap },
3569                  // 8, bi-directional support mode
3570                   { 9, PrivMode_MouseX10 },
3571                  // 18, 19 printing-related
3572                   { 25, PrivMode_VisibleCursor },
3573 #ifdef scrollBar_esc
3574                   { scrollBar_esc, PrivMode_scrollBar },
3575 #endif
3576                   { 35, PrivMode_ShiftKeys }, // rxvt extension
3577                   { 40, PrivMode_132OK },
3578                  // 41 xterm more fixes NYI
3579                  // 45 margin bell NYI
3580                  // 46 start logging
3581                   { 47, PrivMode_Screen },
3582                   { 66, PrivMode_aplKP },
3583 #ifndef NO_BACKSPACE_KEY
3584                   { 67, PrivMode_BackSpace },
3585 #endif
3586                   { 1000, PrivMode_MouseX11 },
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             case 1002:
3698             case 1003:
3699               if (state)
3700                 {
3701                   priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseX11);
3702                   priv_modes &= arg[i] == 1003 ? ~PrivMode_MouseBtnEvent : ~PrivMode_MouseAnyEvent;
3703                   vt_emask_mouse = PointerMotionMask;
3704                 }
3705               else
3706                 vt_emask_mouse = NoEventMask;
3707               vt_select_input ();
3708               break;
3709             case 1010:          /* scroll to bottom on TTY output inhibit */
3710               set_option (Opt_scrollTtyOutput, !state);
3711               break;
3712             case 1011:          /* scroll to bottom on key press */
3713               set_option (Opt_scrollTtyKeypress, state);
3714               break;
3715             case 1047:          /* secondary screen w/ clearing last */
3716               if (option (Opt_secondaryScreen))
3717                 if (current_screen != PRIMARY)
3718                   scr_erase_screen (2);
3719               scr_change_screen (state);
3720               break;
3721             case 1049:          /* secondary screen w/ clearing first */
3722               scr_change_screen (state);
3723               if (option (Opt_secondaryScreen))
3724                 if (current_screen != PRIMARY)
3725                   scr_erase_screen (2);
3726               break;
3727             default:
3728               break;
3729           }
3730     }
3731 }
3732 /*}}} */
3733
3734 /*{{{ process sgr sequences */
3735 void
3736 rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
3737 {
3738   unsigned int i;
3739   short rendset;
3740   int rendstyle;
3741
3742   if (nargs == 0)
3743     {
3744       scr_rendition (0, ~RS_None);
3745       return;
3746     }
3747
3748   for (i = 0; i < nargs; i++)
3749     {
3750       rendset = -1;
3751       switch (arg[i])
3752         {
3753           case 0:
3754             rendset = 0, rendstyle = ~RS_None;
3755             break;
3756           case 1:
3757             rendset = 1, rendstyle = RS_Bold;
3758             break;
3759           //case 2: // low intensity
3760           case 3:
3761             rendset = 1, rendstyle = RS_Italic;
3762             break;
3763           case 4:
3764             rendset = 1, rendstyle = RS_Uline;
3765             break;
3766           case 5: // slowly blinking
3767           case 6: // rapidly blinking
3768             rendset = 1, rendstyle = RS_Blink;
3769             break;
3770           //case 6: // scoansi light background
3771           case 7:
3772             rendset = 1, rendstyle = RS_RVid;
3773             break;
3774           case 8:
3775             // invisible. NYI
3776             break;
3777           //case 9: // crossed out
3778           //case 10: // scoansi acs off, primary font
3779           //case 11: // scoansi acs on, first alt font
3780           //case 12: // scoansi acs on, |0x80, second alt font
3781           //...
3782           //case 19: // ninth alt font
3783           //case 20: // gothic
3784           case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3785             rendset = 0, rendstyle = RS_Bold;
3786             break;
3787           case 22: // normal intensity
3788             rendset = 0, rendstyle = RS_Bold;
3789             break;
3790           case 23: // disable italic
3791             rendset = 0, rendstyle = RS_Italic;
3792             break;
3793           case 24:
3794             rendset = 0, rendstyle = RS_Uline;
3795             break;
3796           case 25:
3797             rendset = 0, rendstyle = RS_Blink;
3798             break;
3799           case 26: // variable spacing (iso 8613)
3800             rendset = 0, rendstyle = RS_Blink;
3801             break;
3802           case 27:
3803             rendset = 0, rendstyle = RS_RVid;
3804             break;
3805           //case 28: // visible. NYI
3806           //case 29: // not crossed-out
3807         }
3808
3809       if (rendset != -1)
3810         {
3811           scr_rendition (rendset, rendstyle);
3812           continue;             /* for (;i;) */
3813         }
3814
3815       switch (arg[i])
3816         {
3817           case 30:
3818           case 31:              /* set fg color */
3819           case 32:
3820           case 33:
3821           case 34:
3822           case 35:
3823           case 36:
3824           case 37:
3825             scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3826             break;
3827           case 38: // set fg color, ISO 8613-6
3828             if (nargs > i + 2 && arg[i + 1] == 5)
3829               {
3830                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3831                 i += 2;
3832               }
3833             break;
3834           case 39:              /* default fg */
3835             scr_color (Color_fg, Color_fg);
3836             break;
3837
3838           case 40:
3839           case 41:              /* set bg color */
3840           case 42:
3841           case 43:
3842           case 44:
3843           case 45:
3844           case 46:
3845           case 47:
3846             scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3847             break;
3848           case 48: // set bg color, ISO 8613-6
3849             if (nargs > i + 2 && arg[i + 1] == 5)
3850               {
3851                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3852                 i += 2;
3853               }
3854             break;
3855           case 49:              /* default bg */
3856             scr_color (Color_bg, Color_bg);
3857             break;
3858
3859           //case 50: // not variable spacing
3860
3861 #if !ENABLE_MINIMAL
3862           case 90:
3863           case 91:              /* set bright fg color */
3864           case 92:
3865           case 93:
3866           case 94:
3867           case 95:
3868           case 96:
3869           case 97:
3870             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3871             break;
3872           case 100:
3873           case 101:             /* set bright bg color */
3874           case 102:
3875           case 103:
3876           case 104:
3877           case 105:
3878           case 106:
3879           case 107:
3880             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3881             break;
3882 #endif
3883         }
3884     }
3885 }
3886 /*}}} */
3887
3888 /*{{{ (do not) process Rob Nation's own graphics mode sequences */
3889 void
3890 rxvt_term::process_graphics ()
3891 {
3892   unicode_t ch, cmd = cmd_getc ();
3893
3894   if (cmd == 'Q')
3895     {
3896       /* query graphics */
3897       tt_printf ("\033G0\012"); /* no graphics */
3898       return;
3899     }
3900   /* swallow other graphics sequences until terminating ':' */
3901   do
3902     ch = cmd_getc ();
3903   while (ch != ':');
3904 }
3905 /*}}} */
3906
3907 /* ------------------------------------------------------------------------- */
3908
3909 /*
3910  * Send printf () formatted output to the command.
3911  * Only use for small amounts of data.
3912  */
3913 void
3914 rxvt_term::tt_printf (const char *fmt,...)
3915 {
3916   va_list arg_ptr;
3917   char buf[256];
3918
3919   va_start (arg_ptr, fmt);
3920   vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3921   va_end (arg_ptr);
3922   tt_write (buf, strlen (buf));
3923 }
3924
3925 /* ---------------------------------------------------------------------- */
3926 /* Write data to the pty as typed by the user, pasted with the mouse,
3927  * or generated by us in response to a query ESC sequence.
3928  */
3929 const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
3930
3931 void
3932 rxvt_term::tt_write (const char *data, unsigned int len)
3933 {
3934   if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
3935     return;
3936
3937   if (pty->pty < 0)
3938     return;
3939
3940   if (v_buflen == 0)
3941     {
3942       ssize_t written = write (pty->pty, data, min (len, MAX_PTY_WRITE));
3943
3944       if ((unsigned int)written == len)
3945         return;
3946
3947       data += written;
3948       len  -= written;
3949     }
3950
3951   v_buffer = (char *)realloc (v_buffer, v_buflen + len);
3952
3953   memcpy (v_buffer + v_buflen, data, len);
3954   v_buflen += len;
3955
3956   pty_ev.set (ev::READ | ev::WRITE);
3957 }
3958
3959 void rxvt_term::pty_write ()
3960 {
3961   int written = write (pty->pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
3962
3963   if (written > 0)
3964     {
3965       v_buflen -= written;
3966
3967       if (v_buflen == 0)
3968         {
3969           free (v_buffer);
3970           v_buffer = 0;
3971
3972           pty_ev.set (ev::READ);
3973           return;
3974         }
3975
3976       memmove (v_buffer, v_buffer + written, v_buflen);
3977     }
3978   else if (written != -1 || (errno != EAGAIN && errno != EINTR))
3979     pty_ev.set (ev::READ);
3980 }
3981
3982 /*----------------------- end-of-file (C source) -----------------------*/
3983