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