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