src/command.C

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