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