src/command.C

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