src/command.C

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