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