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