src/command.C

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