src/command.C

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