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             set_string_property (XA_CUT_BUFFER0, data);
1340             XFree (data);
1341             selection_paste (display->root, XA_CUT_BUFFER0, true);
1342             XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1343           }
1344 #endif                          /* OFFIX_DND */
1345         break;
1346
1347       case MappingNotify:
1348         XRefreshKeyboardMapping (&ev.xmapping);
1349         break;
1350
1351         /*
1352          * XXX: this is not the _current_ arrangement
1353          * Here's my conclusion:
1354          * If the window is completely unobscured, use bitblt's
1355          * to scroll. Even then, they're only used when doing partial
1356          * screen scrolling. When partially obscured, we have to fill
1357          * in the GraphicsExpose parts, which means that after each refresh,
1358          * we need to wait for the graphics expose or Noexpose events,
1359          * which ought to make things real slow!
1360          */
1361       case VisibilityNotify:
1362         switch (ev.xvisibility.state)
1363           {
1364             case VisibilityUnobscured:
1365               refresh_type = FAST_REFRESH;
1366               break;
1367             case VisibilityPartiallyObscured:
1368               refresh_type = SLOW_REFRESH;
1369               break;
1370             default:
1371               refresh_type = NO_REFRESH;
1372               break;
1373           }
1374         break;
1375
1376       case FocusIn:
1377         if (!TermWin.focus)
1378           {
1379             TermWin.focus = 1;
1380             want_refresh = 1;
1381 #ifdef USE_XIM
1382             if (Input_Context != NULL)
1383               {
1384                 IMSetStatusPosition ();
1385                 XSetICFocus (Input_Context);
1386               }
1387 #endif
1388 #ifdef CURSOR_BLINK
1389             if (options & Opt_cursorBlink)
1390               cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1391 #endif
1392 #ifdef OFF_FOCUS_FADING
1393             if (rs[Rs_fade])
1394               {
1395                 pix_colors = pix_colors_focused;
1396                 scr_recolour ();
1397               }
1398 #endif
1399
1400           }
1401         break;
1402
1403       case FocusOut:
1404         if (TermWin.focus)
1405           {
1406             TermWin.focus = 0;
1407             want_refresh = 1;
1408
1409 #if ENABLE_FRILLS || ISO_14755
1410             iso14755buf = 0;
1411 #endif
1412 #if ENABLE_OVERLAY
1413             scr_overlay_off ();
1414 #endif
1415 #ifdef USE_XIM
1416             if (Input_Context != NULL)
1417               XUnsetICFocus (Input_Context);
1418 #endif
1419 #ifdef CURSOR_BLINK
1420             if (options & Opt_cursorBlink)
1421               cursor_blink_ev.stop ();
1422             hidden_cursor = 0;
1423 #endif
1424 #ifdef OFF_FOCUS_FADING
1425             if (rs[Rs_fade])
1426               {
1427                 pix_colors = pix_colors_unfocused;
1428                 scr_recolour ();
1429               }
1430 #endif
1431           }
1432         break;
1433
1434       case ConfigureNotify:
1435         if (ev.xconfigure.window == TermWin.parent[0])
1436           {
1437             int height, width;
1438
1439             do
1440               { /* Wrap lots of configures into one */
1441                 width = ev.xconfigure.width;
1442                 height = ev.xconfigure.height;
1443                 D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1444               }
1445             while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1446
1447             if (szHint.width != width || szHint.height != height)
1448               {
1449                 seen_resize = 1;
1450                 resize_all_windows (width, height, 1);
1451               }
1452
1453 #ifdef TRANSPARENT              /* XXX: maybe not needed - leave in for now */
1454             if (options & Opt_transparent)
1455               check_our_parents ();
1456 #endif
1457           }
1458         break;
1459
1460       case PropertyNotify:
1461         if (ev.xproperty.atom == xa[XA_VT_SELECTION]
1462             && ev.xproperty.state == PropertyNewValue)
1463           selection_property (ev.xproperty.window, ev.xproperty.atom);
1464
1465         break;
1466
1467       case SelectionClear:
1468         selection_clear ();
1469         break;
1470
1471       case SelectionNotify:
1472         if (selection_wait == Sel_normal)
1473           selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1474         break;
1475
1476       case SelectionRequest:
1477         selection_send (ev.xselectionrequest);
1478         break;
1479
1480       case UnmapNotify:
1481         TermWin.mapped = 0;
1482 #ifdef TEXT_BLINK
1483         text_blink_ev.stop ();
1484 #endif
1485         break;
1486
1487       case MapNotify:
1488         TermWin.mapped = 1;
1489 #ifdef TEXT_BLINK
1490         text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
1491 #endif
1492         break;
1493
1494 #ifdef TRANSPARENT
1495       case ReparentNotify:
1496         rootwin_cb (ev);
1497         break;
1498 #endif                          /* TRANSPARENT */
1499
1500       case GraphicsExpose:
1501       case Expose:
1502         if (ev.xany.window == TermWin.vt)
1503           {
1504             do
1505               scr_expose (ev.xexpose.x, ev.xexpose.y,
1506                           ev.xexpose.width, ev.xexpose.height, False);
1507             while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev));
1508
1509             ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1510
1511             while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev))
1512               scr_expose (ev.xexpose.x, ev.xexpose.y,
1513                           ev.xexpose.width, ev.xexpose.height, False);
1514
1515             scr_refresh (refresh_type);
1516           }
1517         else
1518           {
1519             XEvent unused_event;
1520
1521             while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))
1522               ;
1523             while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))
1524               ;
1525
1526             if (isScrollbarWindow (ev.xany.window))
1527               {
1528                 scrollBar.setIdle ();
1529                 scrollbar_show (0);
1530               }
1531 #ifdef MENUBAR
1532             if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1533               menubar_expose ();
1534 #endif
1535
1536 #ifdef TRANSPARENT
1537             if (am_transparent && ev.xany.window == TermWin.parent[0])
1538               XClearWindow (display->display, ev.xany.window);
1539 #endif
1540           }
1541         break;
1542
1543       case MotionNotify:
1544 #ifdef POINTER_BLANK
1545         if (hidden_pointer)
1546           pointer_unblank ();
1547 #endif
1548 #if MENUBAR
1549         if (isMenuBarWindow (ev.xany.window))
1550           {
1551             menubar_control (ev.xbutton);
1552             break;
1553           }
1554 #endif
1555         if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1556           break;
1557
1558         if (ev.xany.window == TermWin.vt)
1559           {
1560             if (ev.xbutton.state & (Button1Mask | Button3Mask))
1561               {
1562                 while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1563                   ;
1564
1565                 XQueryPointer (display->display, TermWin.vt,
1566                                &unused_root, &unused_child,
1567                                &unused_root_x, &unused_root_y,
1568                                &ev.xbutton.x, &ev.xbutton.y,
1569                                &ev.xbutton.state);
1570 #ifdef MOUSE_THRESHOLD
1571                 /* deal with a `jumpy' mouse */
1572                 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1573                   {
1574 #endif
1575 #if ISO_14755
1576                     // 5.4
1577                     if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1578                       {
1579                         iso14755_54 (ev.xbutton.x, ev.xbutton.y);
1580                         break;
1581                       }
1582 #endif
1583                     selection_extend (ev.xbutton.x, ev.xbutton.y,
1584                                       ev.xbutton.state & Button3Mask ? 2 : 0);
1585
1586 #ifdef SELECTION_SCROLLING
1587                     if (ev.xbutton.y < TermWin.int_bwidth
1588                         || Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1589                       {
1590                         int dist;
1591
1592                         /* don't clobber the current delay if we are
1593                          * already in the middle of scrolling.
1594                          */
1595                         if (!sel_scroll_ev.active)
1596                           sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1597
1598                         /* save the event params so we can highlight
1599                          * the selection in the pending-scroll loop
1600                          */
1601                         selection_save_x = ev.xbutton.x;
1602                         selection_save_y = ev.xbutton.y;
1603                         selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1604
1605                         /* calc number of lines to scroll */
1606                         if (ev.xbutton.y < TermWin.int_bwidth)
1607                           {
1608                             scroll_selection_dir = UP;
1609                             dist = TermWin.int_bwidth - ev.xbutton.y;
1610                           }
1611                         else
1612                           {
1613                             scroll_selection_dir = DN;
1614                             dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
1615                           }
1616
1617                         scroll_selection_lines = Pixel2Height (dist)
1618                                                  / SELECTION_SCROLL_LINE_SPEEDUP
1619                                                  + 1;
1620                         MIN_IT (scroll_selection_lines,
1621                                 SELECTION_SCROLL_MAX_LINES);
1622                       }
1623                     else
1624                       {
1625                         /* we are within the text window, so we
1626                          * shouldn't be scrolling
1627                          */
1628                         if (sel_scroll_ev.active)
1629                           sel_scroll_ev.stop();
1630                       }
1631 #endif
1632 #ifdef MOUSE_THRESHOLD
1633                   }
1634 #endif
1635               }
1636           }
1637         else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1638           {
1639             while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1640                                            MotionNotify, &ev))
1641               ;
1642
1643             XQueryPointer (display->display, scrollBar.win,
1644                           &unused_root, &unused_child,
1645                           &unused_root_x, &unused_root_y,
1646                           &ev.xbutton.x, &ev.xbutton.y,
1647                           &unused_mask);
1648             scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1649                          scrollbar_size ());
1650             scr_refresh (refresh_type);
1651             refresh_limit = 0;
1652             scrollbar_show (1);
1653           }
1654         break;
1655     }
1656 }
1657
1658 #if TRANSPARENT
1659 void
1660 rxvt_term::rootwin_cb (XEvent &ev)
1661 {
1662   SET_R (this);
1663   SET_LOCALE (locale);
1664
1665   switch (ev.type)
1666     {
1667       case PropertyNotify:
1668         /*
1669          * if user used some Esetroot compatible prog to set the root bg,
1670          * use the property to determine the pixmap.  We use it later on.
1671          */
1672         if (xa[XA_XROOTPMAPID] == 0)
1673           xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1674
1675         if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1676           return;
1677
1678         /* FALLTHROUGH */
1679       case ReparentNotify:
1680         if ((options & Opt_transparent) && check_our_parents () && am_transparent)
1681           want_refresh = want_full_refresh = 1;
1682         break;
1683     }
1684 }
1685 #endif
1686
1687 void
1688 rxvt_term::button_press (XButtonEvent &ev)
1689 {
1690   int reportmode = 0, clickintime;
1691
1692   bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1693   if (!bypass_keystate)
1694     reportmode = !! (priv_modes & PrivMode_mouse_report);
1695
1696   /*
1697    * VT window processing of button press
1698    */
1699   if (ev.window == TermWin.vt)
1700     {
1701 #if ISO_14755
1702       // 5.4
1703       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1704         {
1705           iso14755_54 (ev.x, ev.y);
1706           return;
1707         }
1708 #endif
1709
1710       clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1711
1712       if (reportmode)
1713         {
1714           /* mouse report from vt window */
1715           /* save the xbutton state (for ButtonRelease) */
1716           MEvent.state = ev.state;
1717 #ifdef MOUSE_REPORT_DOUBLECLICK
1718           if (ev.button == MEvent.button && clickintime)
1719             {
1720               /* same button, within alloted time */
1721               MEvent.clicks++;
1722               if (MEvent.clicks > 1)
1723                 {
1724                   /* only report double clicks */
1725                   MEvent.clicks = 2;
1726                   mouse_report (ev);
1727
1728                   /* don't report the release */
1729                   MEvent.clicks = 0;
1730                   MEvent.button = AnyButton;
1731                 }
1732             }
1733           else
1734             {
1735               /* different button, or time expired */
1736               MEvent.clicks = 1;
1737               MEvent.button = ev.button;
1738               mouse_report (ev);
1739             }
1740 #else
1741           MEvent.button = ev.button;
1742           mouse_report (ev);
1743 #endif                          /* MOUSE_REPORT_DOUBLECLICK */
1744
1745         }
1746       else
1747         {
1748           if (ev.button != MEvent.button)
1749             MEvent.clicks = 0;
1750
1751           switch (ev.button)
1752             {
1753               case Button1:
1754                 /* allow meta + click to select rectangular areas */
1755                 /* should be done in screen.C */
1756 #if ENABLE_FRILLS
1757                 selection.rect = !! (ev.state & ModMetaMask);
1758 #else
1759                 selection.rect = false;
1760 #endif
1761
1762                 /* allow shift+left click to extend selection */
1763                 if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1764                   {
1765                     if (MEvent.button == Button1 && clickintime)
1766                       selection_rotate (ev.x, ev.y);
1767                     else
1768                       selection_extend (ev.x, ev.y, 1);
1769                   }
1770                 else
1771                   {
1772                     if (MEvent.button == Button1 && clickintime)
1773                       MEvent.clicks++;
1774                     else
1775                       MEvent.clicks = 1;
1776
1777                     selection_click (MEvent.clicks, ev.x, ev.y);
1778                   }
1779
1780                 MEvent.button = Button1;
1781                 break;
1782
1783               case Button3:
1784                 if (MEvent.button == Button3 && clickintime)
1785                   selection_rotate (ev.x, ev.y);
1786                 else
1787                   selection_extend (ev.x, ev.y, 1);
1788
1789                 MEvent.button = Button3;
1790                 break;
1791             }
1792         }
1793
1794       MEvent.time = ev.time;
1795       return;
1796     }
1797
1798   /*
1799    * Scrollbar window processing of button press
1800    */
1801   if (isScrollbarWindow (ev.window))
1802     {
1803       scrollBar.setIdle ();
1804       /*
1805        * Rxvt-style scrollbar:
1806        * move up if mouse is above slider
1807        * move dn if mouse is below slider
1808        *
1809        * XTerm-style scrollbar:
1810        * Move display proportional to pointer location
1811        * pointer near top -> scroll one line
1812        * pointer near bot -> scroll full page
1813        */
1814 #ifndef NO_SCROLLBAR_REPORT
1815       if (reportmode)
1816         {
1817           /*
1818            * Mouse report disabled scrollbar:
1819            * arrow buttons - send up/down
1820            * click on scrollbar - send pageup/down
1821            */
1822           if ((scrollBar.style == R_SB_NEXT
1823                && scrollbarnext_upButton (ev.y))
1824               || (scrollBar.style == R_SB_RXVT
1825                   && scrollbarrxvt_upButton (ev.y)))
1826             tt_printf ("\033[A");
1827           else if ((scrollBar.style == R_SB_NEXT
1828                     && scrollbarnext_dnButton (ev.y))
1829                    || (scrollBar.style == R_SB_RXVT
1830                        && scrollbarrxvt_dnButton (ev.y)))
1831             tt_printf ("\033[B");
1832           else
1833             switch (ev.button)
1834               {
1835                 case Button2:
1836                   tt_printf ("\014");
1837                   break;
1838                 case Button1:
1839                   tt_printf ("\033[6~");
1840                   break;
1841                 case Button3:
1842                   tt_printf ("\033[5~");
1843                   break;
1844               }
1845         }
1846       else
1847 #endif                          /* NO_SCROLLBAR_REPORT */
1848
1849         {
1850           char            upordown = 0;
1851
1852           if (scrollBar.style == R_SB_NEXT)
1853             {
1854               if (scrollbarnext_upButton (ev.y))
1855                 upordown = -1;  /* up */
1856               else if (scrollbarnext_dnButton (ev.y))
1857                 upordown = 1;   /* down */
1858             }
1859           else if (scrollBar.style == R_SB_RXVT)
1860             {
1861               if (scrollbarrxvt_upButton (ev.y))
1862                 upordown = -1;  /* up */
1863               else if (scrollbarrxvt_dnButton (ev.y))
1864                 upordown = 1;   /* down */
1865             }
1866           if (upordown)
1867             {
1868 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1869               cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1870 #endif
1871               if (scr_page (upordown < 0 ? UP : DN, 1))
1872                 {
1873                   if (upordown < 0)
1874                     scrollBar.setUp ();
1875                   else
1876                     scrollBar.setDn ();
1877                 }
1878             }
1879           else
1880             switch (ev.button)
1881               {
1882                 case Button2:
1883                   switch (scrollbar_align)
1884                     {
1885                       case R_SB_ALIGN_TOP:
1886                         csrO = 0;
1887                         break;
1888                       case R_SB_ALIGN_CENTRE:
1889                         csrO = (scrollBar.bot - scrollBar.top) / 2;
1890                         break;
1891                       case R_SB_ALIGN_BOTTOM:
1892                         csrO = scrollBar.bot - scrollBar.top;
1893                         break;
1894                     }
1895
1896                   if (scrollBar.style == R_SB_XTERM
1897                       || scrollbar_above_slider (ev.y)
1898                       || scrollbar_below_slider (ev.y))
1899                     scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
1900
1901                   scrollBar.setMotion ();
1902                   break;
1903
1904                 case Button1:
1905                   if (scrollbar_align == R_SB_ALIGN_CENTRE)
1906                     csrO = ev.y - scrollBar.top;
1907                   /* FALLTHROUGH */
1908
1909                 case Button3:
1910                   if (scrollBar.style != R_SB_XTERM)
1911                     {
1912                       if (scrollbar_above_slider (ev.y))
1913 # ifdef RXVT_SCROLL_FULL
1914                         scr_page (UP, TermWin.nrow - 1);
1915 # else
1916                         scr_page (UP, TermWin.nrow / 4);
1917 # endif
1918                       else if (scrollbar_below_slider (ev.y))
1919 # ifdef RXVT_SCROLL_FULL
1920                         scr_page (DN, TermWin.nrow - 1);
1921 # else
1922                         scr_page (DN, TermWin.nrow / 4);
1923 # endif
1924                       else
1925                         scrollBar.setMotion ();
1926                     }
1927                   else
1928                     {
1929                       scr_page ((ev.button == Button1 ? DN : UP),
1930                                 (TermWin.nrow
1931                                  * scrollbar_position (ev.y)
1932                                  / scrollbar_size ()));
1933                     }
1934
1935                   break;
1936               }
1937         }
1938       return;
1939     }
1940 #if MENUBAR
1941   /*
1942    * Menubar window processing of button press
1943    */
1944   if (isMenuBarWindow (ev.window))
1945     menubar_control (ev);
1946 #endif
1947 }
1948
1949 void
1950 rxvt_term::button_release (XButtonEvent &ev)
1951 {
1952   int reportmode = 0;
1953
1954   csrO = 0;             /* reset csr Offset */
1955   if (!bypass_keystate)
1956     reportmode = !! (priv_modes & PrivMode_mouse_report);
1957
1958   if (scrollbar_isUpDn ())
1959     {
1960       scrollBar.setIdle ();
1961       scrollbar_show (0);
1962 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1963       refresh_type &= ~SMOOTH_REFRESH;
1964 #endif
1965     }
1966
1967 #ifdef SELECTION_SCROLLING
1968   if (sel_scroll_ev.active)
1969     sel_scroll_ev.stop();
1970 #endif
1971
1972   if (ev.window == TermWin.vt)
1973     {
1974 #if ISO_14755
1975       // 5.4
1976       if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1977         return;
1978 #endif
1979       if (reportmode)
1980         {
1981           /* mouse report from vt window */
1982           /* don't report release of wheel "buttons" */
1983           if (ev.button >= 4)
1984             return;
1985 #ifdef MOUSE_REPORT_DOUBLECLICK
1986           /* only report the release of 'slow' single clicks */
1987           if (MEvent.button != AnyButton
1988               && (ev.button != MEvent.button
1989                   || (ev.time - MEvent.time
1990                       > MULTICLICK_TIME / 2)))
1991             {
1992               MEvent.clicks = 0;
1993               MEvent.button = AnyButton;
1994               mouse_report (ev);
1995             }
1996 #else                           /* MOUSE_REPORT_DOUBLECLICK */
1997           MEvent.button = AnyButton;
1998           mouse_report (ev);
1999 #endif                          /* MOUSE_REPORT_DOUBLECLICK */
2000           return;
2001         }
2002
2003       /*
2004        * dumb hack to compensate for the failure of click-and-drag
2005        * when overriding mouse reporting
2006        */
2007       if (priv_modes & PrivMode_mouse_report
2008           && bypass_keystate
2009           && ev.button == Button1 && MEvent.clicks <= 1)
2010         selection_extend (ev.x, ev.y, 0);
2011
2012       switch (ev.button)
2013         {
2014           case Button1:
2015           case Button3:
2016             selection_make (ev.time);
2017             break;
2018           case Button2:
2019             selection_request (ev.time, ev.x, ev.y);
2020             break;
2021 #ifdef MOUSE_WHEEL
2022           case Button4:
2023           case Button5:
2024             {
2025               int i;
2026               page_dirn v;
2027
2028               v = ev.button == Button4 ? UP : DN;
2029
2030               if (ev.state & ShiftMask)
2031                 i = 1;
2032               else if (options & Opt_mouseWheelScrollPage)
2033                 i = TermWin.nrow - 1;
2034               else
2035                 i = 5;
2036
2037 # ifdef MOUSE_SLIP_WHEELING
2038               if (ev.state & ControlMask)
2039                 {
2040                   mouse_slip_wheel_speed += v ? -1 : 1;
2041                   if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
2042                   if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
2043
2044                   if (slip_wheel_ev.at < NOW)
2045                     slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
2046
2047                   slip_wheel_ev.start ();
2048                 }
2049               else
2050                 {
2051 # endif
2052 # ifdef JUMP_MOUSE_WHEEL
2053                   scr_page (v, i);
2054                   scr_refresh (SMOOTH_REFRESH);
2055                   scrollbar_show (1);
2056 # else
2057                   while (i--)
2058                     {
2059                       scr_page (v, 1);
2060                       scr_refresh (SMOOTH_REFRESH);
2061                       scrollbar_show (1);
2062                     }
2063 # endif
2064 # ifdef MOUSE_SLIP_WHEELING
2065                 }
2066 #endif
2067             }
2068             break;
2069 #endif
2070         }
2071     }
2072 #ifdef MENUBAR
2073   else if (isMenuBarWindow (ev.window))
2074     menubar_control (ev);
2075 #endif
2076 }
2077
2078 #ifdef TRANSPARENT
2079 #if TINTING
2080 /* taken from aterm-0.4.2 */
2081
2082 typedef uint32_t RUINT32T;
2083
2084 void ShadeXImage(rxvt_display *display, XImage* srcImage, int shade, int rm, int gm, int bm)
2085 {
2086   int sh_r, sh_g, sh_b;
2087   RUINT32T mask_r, mask_g, mask_b;
2088   RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
2089   unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
2090   unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
2091   int i;
2092
2093   Visual* visual = display->visual;
2094
2095   if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
2096
2097   /* for convenience */
2098   mask_r = visual->red_mask;
2099   mask_g = visual->green_mask;
2100   mask_b = visual->blue_mask;
2101
2102   /* boring lookup table pre-initialization */
2103   switch (srcImage->bits_per_pixel) {
2104     case 15:
2105       if ((mask_r != 0x7c00) ||
2106           (mask_g != 0x03e0) ||
2107           (mask_b != 0x001f))
2108         return;
2109         lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
2110         lookup_r = lookup;
2111         lookup_g = lookup+32;
2112         lookup_b = lookup+32+32;
2113         sh_r = 10;
2114         sh_g = 5;
2115         sh_b = 0;
2116       break;
2117     case 16:
2118       if ((mask_r != 0xf800) ||
2119           (mask_g != 0x07e0) ||
2120           (mask_b != 0x001f))
2121         return;
2122         lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
2123         lookup_r = lookup;
2124         lookup_g = lookup+32;
2125         lookup_b = lookup+32+64;
2126         sh_r = 11;
2127         sh_g = 5;
2128         sh_b = 0;
2129       break;
2130     case 24:
2131       if ((mask_r != 0xff0000) ||
2132           (mask_g != 0x00ff00) ||
2133           (mask_b != 0x0000ff))
2134         return;
2135         lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
2136         lookup_r = lookup;
2137         lookup_g = lookup+256;
2138         lookup_b = lookup+256+256;
2139         sh_r = 16;
2140         sh_g = 8;
2141         sh_b = 0;
2142       break;
2143     case 32:
2144       if ((mask_r != 0xff0000) ||
2145           (mask_g != 0x00ff00) ||
2146           (mask_b != 0x0000ff))
2147         return;
2148         lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
2149         lookup_r = lookup;
2150         lookup_g = lookup+256;
2151         lookup_b = lookup+256+256;
2152         sh_r = 16;
2153         sh_g = 8;
2154         sh_b = 0;
2155       break;
2156     default:
2157       return; /* we do not support this color depth */
2158   }
2159
2160   /* prepare limits for color transformation (each channel is handled separately) */
2161   if (shade < 0) {
2162     shade = -shade;
2163     if (shade < 0) shade = 0;
2164     if (shade > 100) shade = 100;
2165
2166     lower_lim_r = 65535-rm;
2167     lower_lim_g = 65535-gm;
2168     lower_lim_b = 65535-bm;
2169
2170     lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
2171     lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
2172     lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
2173
2174     upper_lim_r = upper_lim_g = upper_lim_b = 65535;
2175   } else {
2176     if (shade < 0) shade = 0;
2177     if (shade > 100) shade = 100;
2178
2179     lower_lim_r = lower_lim_g = lower_lim_b = 0;
2180
2181     upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
2182     upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
2183     upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
2184   }
2185
2186   /* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
2187   if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
2188   {
2189     unsigned int tmp;
2190
2191     tmp = lower_lim_r;
2192     lower_lim_r = lower_lim_b;
2193     lower_lim_b = tmp;
2194
2195     tmp = upper_lim_r;
2196     upper_lim_r = upper_lim_b;
2197     upper_lim_b = tmp;
2198   }
2199
2200   /* fill our lookup tables */
2201   for (i = 0; i <= mask_r>>sh_r; i++)
2202   {
2203     RUINT32T tmp;
2204     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
2205     tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
2206     lookup_r[i] = (tmp/65535)<<sh_r;
2207   }
2208   for (i = 0; i <= mask_g>>sh_g; i++)
2209   {
2210     RUINT32T tmp;
2211     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
2212     tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
2213     lookup_g[i] = (tmp/65535)<<sh_g;
2214   }
2215   for (i = 0; i <= mask_b>>sh_b; i++)
2216   {
2217     RUINT32T tmp;
2218     tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
2219     tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
2220     lookup_b[i] = (tmp/65535)<<sh_b;
2221   }
2222
2223   /* apply table to input image (replacing colors by newly calculated ones) */
2224   switch (srcImage->bits_per_pixel)
2225   {
2226     case 15:
2227     {
2228       unsigned short *p1, *pf, *p, *pl;
2229       p1 = (unsigned short *) srcImage->data;
2230       pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
2231       while (p1 < pf)
2232       {
2233         p = p1;
2234         pl = p1 + srcImage->width;
2235         for (; p < pl; p++)
2236         {
2237           *p = lookup_r[(*p & 0x7c00)>>10] |
2238                lookup_g[(*p & 0x03e0)>> 5] |
2239                lookup_b[(*p & 0x001f)];
2240         }
2241         p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
2242       }
2243       break;
2244     }
2245     case 16:
2246     {
2247       unsigned short *p1, *pf, *p, *pl;
2248       p1 = (unsigned short *) srcImage->data;
2249       pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
2250       while (p1 < pf)
2251       {
2252         p = p1;
2253         pl = p1 + srcImage->width;
2254         for (; p < pl; p++)
2255         {
2256           *p = lookup_r[(*p & 0xf800)>>11] |
2257                lookup_g[(*p & 0x07e0)>> 5] |
2258                lookup_b[(*p & 0x001f)];
2259         }
2260         p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
2261       }
2262       break;
2263     }
2264     case 24:
2265     {
2266       unsigned char *p1, *pf, *p, *pl;
2267       p1 = (unsigned char *) srcImage->data;
2268       pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
2269       while (p1 < pf)
2270       {
2271         p = p1;
2272         pl = p1 + srcImage->width * 3;
2273         for (; p < pl; p += 3)
2274         {
2275           p[0] = lookup_r[(p[0] & 0xff0000)>>16];
2276           p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
2277           p[2] = lookup_r[(p[2] & 0x0000ff)];
2278         }
2279         p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
2280       }
2281       break;
2282     }
2283     case 32:
2284     {
2285       RUINT32T *p1, *pf, *p, *pl;
2286       p1 = (RUINT32T *) srcImage->data;
2287       pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
2288
2289       while (p1 < pf)
2290       {
2291         p = p1;
2292         pl = p1 + srcImage->width;
2293         for (; p < pl; p++)
2294         {
2295           *p = lookup_r[(*p & 0xff0000)>>16] |
2296                lookup_g[(*p & 0x00ff00)>> 8] |
2297                lookup_b[(*p & 0x0000ff)] |
2298                (*p & ~0xffffff);
2299         }
2300         p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
2301       }
2302       break;
2303     }
2304   }
2305
2306   free (lookup);
2307 }
2308 #endif
2309
2310 /*
2311  * Check our parents are still who we think they are.
2312  * Do transparency updates if required
2313  */
2314 int
2315 rxvt_term::check_our_parents ()
2316 {
2317   int i, pchanged, aformat, have_pixmap, rootdepth;
2318   unsigned long nitems, bytes_after;
2319   Atom atype;
2320   unsigned char *prop = NULL;
2321   Window root, oldp, *list;
2322   Pixmap rootpixmap = None;
2323   XWindowAttributes wattr, wrootattr;
2324
2325   pchanged = 0;
2326
2327   if (!(options & Opt_transparent))
2328     return pchanged;    /* Don't try any more */
2329
2330   XGetWindowAttributes (display->display, display->root, &wrootattr);
2331   rootdepth = wrootattr.depth;
2332
2333   XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2334
2335   if (rootdepth != wattr.depth)
2336     {
2337       if (am_transparent)
2338         {
2339           pchanged = 1;
2340           XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2341           am_transparent = am_pixmap_trans = 0;
2342         }
2343
2344       return pchanged;  /* Don't try any more */
2345     }
2346
2347   /* Get all X ops out of the queue so that our information is up-to-date. */
2348   XSync (display->display, False);
2349
2350   /*
2351    * Make the frame window set by the window manager have
2352    * the root background. Some window managers put multiple nested frame
2353    * windows for each client, so we have to take care about that.
2354    */
2355   i = (xa[XA_XROOTPMAPID]
2356        && XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],
2357                               0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2358                               &nitems, &bytes_after, &prop) == Success);
2359
2360   if (!i || prop == NULL)
2361      i = (xa[XA_XSETROOTID]
2362           && XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
2363                                  0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2364                                  &nitems, &bytes_after, &prop) == Success);
2365
2366   if (!i || prop == NULL
2367 #if TINTING
2368       || !rs[Rs_color + Color_tint]
2369 #endif
2370       )
2371     have_pixmap = 0;
2372   else
2373     {
2374       have_pixmap = 1;
2375       rootpixmap = *(Pixmap *)prop;
2376       XFree (prop);
2377     }
2378
2379   if (have_pixmap)
2380     {
2381       /*
2382        * Copy display->root pixmap transparency
2383        */
2384       int sx, sy, nx, ny;
2385       unsigned int nw, nh;
2386       Window cr;
2387       XImage *image;
2388       GC gc;
2389       XGCValues gcvalue;
2390
2391       XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
2392                              0, 0, &sx, &sy, &cr);
2393       nw = (unsigned int)szHint.width;
2394       nh = (unsigned int)szHint.height;
2395       nx = ny = 0;
2396
2397       if (sx < 0)
2398         {
2399           nw += sx;
2400           nx = -sx;
2401           sx = 0;
2402         }
2403
2404       if (sy < 0)
2405         {
2406           nh += sy;
2407           ny = -sy;
2408           sy = 0;
2409         }
2410
2411       MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
2412       MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
2413
2414       XSync (display->display, False);
2415       allowedxerror = -1;
2416       image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
2417
2418       /* XXX: handle BadMatch - usually because we're outside the pixmap */
2419       /* XXX: may need a delay here? */
2420       allowedxerror = 0;
2421
2422       if (image == NULL)
2423         {
2424           if (am_transparent && am_pixmap_trans)
2425             {
2426               pchanged = 1;
2427               if (TermWin.pixmap != None)
2428                 {
2429                   XFreePixmap (display->display, TermWin.pixmap);
2430                   TermWin.pixmap = None;
2431                 }
2432             }
2433
2434           am_pixmap_trans = 0;
2435         }
2436       else
2437         {
2438           if (TermWin.pixmap != None)
2439             XFreePixmap (display->display, TermWin.pixmap);
2440
2441 #if TINTING
2442           if (ISSET_PIXCOLOR (Color_tint))
2443             {
2444               unsigned short rm, gm, bm;
2445               int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2446
2447               pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2448
2449               ShadeXImage (display, image, shade, rm, gm, bm);
2450             }
2451 #endif
2452
2453           TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2454                                           szHint.width, szHint.height, image->depth);
2455           gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2456           XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2457                      nx, ny, image->width, image->height);
2458           XFreeGC (display->display, gc);
2459           XDestroyImage (image);
2460           XSetWindowBackgroundPixmap (display->display, TermWin.parent[0], TermWin.pixmap);
2461           XClearWindow (display->display, TermWin.parent[0]);
2462
2463           if (!am_transparent || !am_pixmap_trans)
2464             pchanged = 1;
2465
2466           am_transparent = am_pixmap_trans = 1;
2467         }
2468     }
2469
2470   if (am_pixmap_trans)
2471     XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2472   else
2473     {
2474       unsigned int n;
2475       /*
2476        * InheritPixmap transparency
2477        */
2478       for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2479         {
2480           oldp = TermWin.parent[i];
2481           XQueryTree (display->display, TermWin.parent[i - 1], &root,
2482                       &TermWin.parent[i], &list, &n);
2483           XFree (list);
2484
2485           if (TermWin.parent[i] == display->root)
2486             {
2487               if (oldp != None)
2488                 pchanged = 1;
2489
2490               break;
2491             }
2492
2493           if (oldp != TermWin.parent[i])
2494             pchanged = 1;
2495         }
2496
2497       n = 0;
2498
2499       if (pchanged)
2500         {
2501           for (; n < (unsigned int)i; n++)
2502             {
2503               XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2504               if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2505                 {
2506                   n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2507                   break;
2508                 }
2509             }
2510         }
2511
2512       if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2513         {
2514           XSetWindowBackground (display->display, TermWin.parent[0], pix_colors_focused[Color_fg]);
2515           XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2516           am_transparent = 0;
2517           /* XXX: also turn off Opt_transparent? */
2518         }
2519       else
2520         {
2521 #if WAIT_FOR_WM
2522           /* wait (an arbitrary period) for the WM to do its thing
2523            * needed for fvwm2.2.2 (and before?) */
2524           sleep (1);
2525 #endif
2526           for (n = 0; n < (unsigned int)i; n++)
2527             {
2528               XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2529               XClearWindow (display->display, TermWin.parent[n]);
2530             }
2531
2532           XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2533           am_transparent = 1;
2534         }
2535
2536       for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2537         TermWin.parent[i] = None;
2538     }
2539
2540   if (scrollBar.win)
2541     {
2542       XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
2543       scrollBar.setIdle ();
2544       scrollbar_show (0);
2545     }
2546
2547   if (am_transparent)
2548     {
2549       want_refresh = want_full_refresh = 1;
2550       if (am_pixmap_trans)
2551         flush ();
2552     }
2553
2554   return pchanged;
2555 }
2556 #endif
2557
2558 /*}}} */
2559
2560 bool
2561 rxvt_term::cmd_parse ()
2562 {
2563   bool flag = false;
2564   unicode_t ch = NOCHAR;
2565   unsigned char *seq_begin; // remember start of esc-sequence here
2566
2567   for (;;)
2568     {
2569       if (ch == NOCHAR)
2570         {
2571           seq_begin = cmdbuf_ptr;
2572           ch = next_char ();
2573         }
2574
2575       if (ch == NOCHAR) // TODO: improve
2576         break;
2577
2578       if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2579         {
2580           if (!seen_input)
2581             {
2582               seen_input = 1;
2583               // many badly-written programs (e.g. jed) contain a race condition:
2584               // they first read the screensize and then install a SIGWINCH handler.
2585               // some window managers resize the window early, and these programs
2586               // then sometimes get the size wrong.
2587               // unfortunately other programs are even more buggy and dislike
2588               // being sent SIGWINCH, so only do it when we were in fact being
2589               // resized.
2590               if (seen_resize)
2591                 kill (-cmd_pid, SIGWINCH);
2592             }
2593
2594           /* Read a text string from the input buffer */
2595           unicode_t buf[UBUFSIZ];
2596           bool refreshnow = false;
2597           int nlines = 0;
2598           unicode_t *str = buf;
2599
2600           for (;;)
2601             {
2602               if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2603                 break;
2604
2605               *str++ = ch;
2606
2607               if (ch == C0_LF)
2608                 {
2609                   nlines++;
2610                   refresh_count++;
2611
2612                   if (!(options & Opt_jumpScroll)
2613                       || (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2614                     {
2615                       refreshnow = true;
2616                       ch = NOCHAR;
2617                       break;
2618                     }
2619
2620                   // scr_add_lines only works for nlines <= TermWin.nrow - 1.
2621                   if (nlines >= TermWin.nrow - 1)
2622                     {
2623                       scr_add_lines (buf, nlines, str - buf);
2624                       nlines = 0;
2625                       str = buf;
2626                     }
2627                 }
2628
2629               if (str >= buf + UBUFSIZ)
2630                 {
2631                   ch = NOCHAR;
2632                   break;
2633                 }
2634
2635               seq_begin = cmdbuf_ptr;
2636               ch = next_char ();
2637             }
2638
2639           scr_add_lines (buf, nlines, str - buf);
2640
2641           /*
2642            * If there have been a lot of new lines, then update the screen
2643            * What the heck I'll cheat and only refresh less than every page-full.
2644            * the number of pages between refreshes is refresh_limit, which
2645            * is incremented here because we must be doing flat-out scrolling.
2646            */
2647           if (refreshnow)
2648             {
2649               if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2650                 refresh_limit++;
2651               else
2652                 {
2653                   flag = true;
2654                   scr_refresh (refresh_type);
2655                 }
2656             }
2657
2658         }
2659       else
2660         {
2661           try
2662             {
2663               process_nonprinting (ch);
2664             }
2665           catch (const class out_of_input &o)
2666             {
2667               // we ran out of input, retry later
2668               cmdbuf_ptr = seq_begin;
2669               break;
2670             }
2671
2672           ch = NOCHAR;
2673         }
2674     }
2675
2676   return flag;
2677 }
2678
2679 // read the next octet
2680 unicode_t
2681 rxvt_term::next_octet ()
2682 {
2683   return cmdbuf_ptr < cmdbuf_endp
2684          ? *cmdbuf_ptr++
2685          : NOCHAR;
2686 }
2687
2688 // read the next character
2689 unicode_t
2690 rxvt_term::next_char ()
2691 {
2692   while (cmdbuf_ptr < cmdbuf_endp)
2693     {
2694       // assume 7-bit to be ascii ALWAYS
2695       if (*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)
2696         return *cmdbuf_ptr++;
2697
2698       wchar_t wc;
2699       size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2700
2701       if (len == (size_t)-2)
2702         {
2703           // the mbstate stores incomplete sequences. didn't know this :/
2704           cmdbuf_ptr = cmdbuf_endp;
2705           break;
2706         }
2707
2708       if (len == (size_t)-1)
2709         return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2710
2711       // assume wchar == unicode
2712       cmdbuf_ptr += len;
2713       return wc;
2714     }
2715
2716   return NOCHAR;
2717 }
2718
2719 /* rxvt_cmd_getc () - Return next input character */
2720 /*
2721  * Return the next input character after first passing any keyboard input
2722  * to the command.
2723  */
2724 unicode_t
2725 rxvt_term::cmd_getc ()
2726 {
2727   unicode_t c = next_char ();
2728
2729   if (c == NOCHAR)
2730     throw out_of_input;
2731
2732   return c;
2733 }
2734
2735 unicode_t
2736 rxvt_term::cmd_get8 ()
2737 {
2738   unicode_t c = next_octet ();
2739
2740   if (c == NOCHAR)
2741     throw out_of_input;
2742
2743   return c;
2744 }
2745
2746 /*{{{ print pipe */
2747 /*----------------------------------------------------------------------*/
2748 #ifdef PRINTPIPE
2749 FILE *
2750 rxvt_term::popen_printer ()
2751 {
2752   FILE *stream = popen (rs[Rs_print_pipe], "w");
2753
2754   if (stream == NULL)
2755     rxvt_warn ("can't open printer pipe, not printing.\n");
2756
2757   return stream;
2758 }
2759
2760 int
2761 rxvt_term::pclose_printer (FILE *stream)
2762 {
2763   fflush (stream);
2764   return pclose (stream);
2765 }
2766
2767 /*
2768  * simulate attached vt100 printer
2769  */
2770 void
2771 rxvt_term::process_print_pipe ()
2772 {
2773   int done;
2774   FILE *fd;
2775
2776   if ((fd = popen_printer ()) == NULL)
2777     return;
2778
2779   /*
2780    * Send all input to the printer until either ESC[4i or ESC[?4i
2781    * is received.
2782    */
2783   for (done = 0; !done;)
2784     {
2785       unsigned char buf[8];
2786       unicode_t ch;
2787       unsigned int i, len;
2788
2789       if ((ch = cmd_getc ()) != C0_ESC)
2790         {
2791           if (putc (ch, fd) == EOF)
2792             break;              /* done = 1 */
2793         }
2794       else
2795         {
2796           len = 0;
2797           buf[len++] = ch;
2798
2799           if ((buf[len++] = cmd_getc ()) == '[')
2800             {
2801               if ((ch = cmd_getc ()) == '?')
2802                 {
2803                   buf[len++] = '?';
2804                   ch = cmd_getc ();
2805                 }
2806               if ((buf[len++] = ch) == '4')
2807                 {
2808                   if ((buf[len++] = cmd_getc ()) == 'i')
2809                     break;      /* done = 1 */
2810                 }
2811             }
2812
2813           for (i = 0; i < len; i++)
2814             if (putc (buf[i], fd) == EOF)
2815               {
2816                 done = 1;
2817                 break;
2818               }
2819         }
2820     }
2821
2822   pclose_printer (fd);
2823 }
2824 #endif                          /* PRINTPIPE */
2825 /*}}} */
2826
2827 /* *INDENT-OFF* */
2828 enum {
2829   C1_40 = 0x40,
2830           C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,
2831   C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,
2832   C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2833   C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,
2834 };
2835 /* *INDENT-ON* */
2836
2837 /*{{{ process non-printing single characters */
2838 void
2839 rxvt_term::process_nonprinting (unicode_t ch)
2840 {
2841   switch (ch)
2842     {
2843       case C0_ESC:
2844         process_escape_seq ();
2845         break;
2846       case C0_ENQ:      /* terminal Status */
2847         if (rs[Rs_answerbackstring])
2848           tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2849                     (unsigned int)strlen (rs[Rs_answerbackstring]));
2850         else
2851           tt_write ((unsigned char *)VT100_ANS,
2852                     (unsigned int)strlen (VT100_ANS));
2853         break;
2854       case C0_BEL:      /* bell */
2855         scr_bell ();
2856         break;
2857       case C0_BS:               /* backspace */
2858         scr_backspace ();
2859         break;
2860       case C0_HT:               /* tab */
2861         scr_tab (1);
2862         break;
2863       case C0_CR:               /* carriage return */
2864         scr_gotorc (0, 0, R_RELATIVE);
2865         break;
2866       case C0_VT:               /* vertical tab, form feed */
2867       case C0_FF:
2868       case C0_LF:               /* line feed */
2869         scr_index (UP);
2870         break;
2871       case C0_SO:               /* shift out - acs */
2872         scr_charset_choose (1);
2873         break;
2874       case C0_SI:               /* shift in - acs */
2875         scr_charset_choose (0);
2876         break;
2877
2878 #ifdef EIGHT_BIT_CONTROLS
2879       // 8-bit controls
2880       case 0x90:        /* DCS */
2881         process_dcs_seq ();
2882         break;
2883       case 0x9b:        /* CSI */
2884         process_csi_seq ();
2885         break;
2886       case 0x9d:        /* CSI */
2887         process_osc_seq ();
2888         break;
2889 #endif
2890     }
2891 }
2892 /*}}} */
2893
2894
2895 /*{{{ process VT52 escape sequences */
2896 void
2897 rxvt_term::process_escape_vt52 (unicode_t ch)
2898 {
2899   int row, col;
2900
2901   switch (ch)
2902     {
2903       case 'A':         /* cursor up */
2904         scr_gotorc (-1, 0, R_RELATIVE | C_RELATIVE);
2905         break;
2906       case 'B':         /* cursor down */
2907         scr_gotorc (1, 0, R_RELATIVE | C_RELATIVE);
2908         break;
2909       case 'C':         /* cursor right */
2910         scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
2911         break;
2912       case 'D':         /* cursor left */
2913         scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
2914         break;
2915       case 'H':         /* cursor home */
2916         scr_gotorc (0, 0, 0);
2917         break;
2918       case 'I':         /* cursor up and scroll down if needed */
2919         scr_index (DN);
2920         break;
2921       case 'J':         /* erase to end of screen */
2922         scr_erase_screen (0);
2923         break;
2924       case 'K':         /* erase to end of line */
2925         scr_erase_line (0);
2926         break;
2927       case 'Y':                 /* move to specified row and col */
2928         /* full command is 'ESC Y row col' where row and col
2929          * are encoded by adding 32 and sending the ascii
2930          * character.  eg. SPACE = 0, '+' = 13, '0' = 18,
2931          * etc. */
2932         row = cmd_getc () - ' ';
2933         col = cmd_getc () - ' ';
2934         scr_gotorc (row, col, 0);
2935         break;
2936       case 'Z':         /* identify the terminal type */
2937         tt_printf ("\033/Z");   /* I am a VT100 emulating a VT52 */
2938         break;
2939       case '<':         /* turn off VT52 mode */
2940         PrivMode (0, PrivMode_vt52);
2941         break;
2942       case 'F':         /* use special graphics character set */
2943       case 'G':           /* use regular character set */
2944         /* unimplemented */
2945         break;
2946       case '=':         /* use alternate keypad mode */
2947       case '>':           /* use regular keypad mode */
2948         /* unimplemented */
2949         break;
2950     }
2951 }
2952 /*}}} */
2953
2954
2955 /*{{{ process escape sequences */
2956 void
2957 rxvt_term::process_escape_seq ()
2958 {
2959   unicode_t ch = cmd_getc ();
2960
2961   if (priv_modes & PrivMode_vt52)
2962     {
2963       process_escape_vt52 (ch);
2964       return;
2965     }
2966
2967   switch (ch)
2968     {
2969         /* case 1:        do_tek_mode (); break; */
2970       case '#':
2971         if (cmd_getc () == '8')
2972           scr_E ();
2973         break;
2974       case '(':
2975         scr_charset_set (0, (unsigned int)cmd_getc ());
2976         break;
2977       case ')':
2978         scr_charset_set (1, (unsigned int)cmd_getc ());
2979         break;
2980       case '*':
2981         scr_charset_set (2, (unsigned int)cmd_getc ());
2982         break;
2983       case '+':
2984         scr_charset_set (3, (unsigned int)cmd_getc ());
2985         break;
2986 #if ENABLE_FRILLS
2987       case '6':
2988         scr_backindex ();
2989         break;
2990 #endif
2991       case '7':
2992         scr_cursor (SAVE);
2993         break;
2994       case '8':
2995         scr_cursor (RESTORE);
2996         break;
2997 #if ENABLE_FRILLS
2998       case '9':
2999         scr_forwardindex ();
3000         break;
3001 #endif
3002       case '=':
3003       case '>':
3004         PrivMode ((ch == '='), PrivMode_aplKP);
3005         break;
3006
3007       case C1_40:
3008         cmd_getc ();
3009         break;
3010       case C1_44:
3011         scr_index (UP);
3012         break;
3013
3014         /* 8.3.87: NEXT LINE */
3015       case C1_NEL:              /* ESC E */
3016         {
3017           unicode_t nlcr[] = { C0_LF, C0_CR };
3018           scr_add_lines (nlcr, 1, 2);
3019         }
3020         break;
3021
3022         /* kidnapped escape sequence: Should be 8.3.48 */
3023       case C1_ESA:              /* ESC G */
3024         process_graphics ();
3025         break;
3026
3027         /* 8.3.63: CHARACTER TABULATION SET */
3028       case C1_HTS:              /* ESC H */
3029         scr_set_tab (1);
3030         break;
3031
3032         /* 8.3.105: REVERSE LINE FEED */
3033       case C1_RI:                       /* ESC M */
3034         scr_index (DN);
3035         break;
3036
3037         /* 8.3.142: SINGLE-SHIFT TWO */
3038       /*case C1_SS2: scr_single_shift (2);   break; */
3039
3040         /* 8.3.143: SINGLE-SHIFT THREE */
3041       /*case C1_SS3: scr_single_shift (3);   break; */
3042
3043         /* 8.3.27: DEVICE CONTROL STRING */
3044       case C1_DCS:              /* ESC P */
3045         process_dcs_seq ();
3046         break;
3047
3048         /* 8.3.110: SINGLE CHARACTER INTRODUCER */
3049       case C1_SCI:              /* ESC Z */
3050         tt_write ((const unsigned char *)ESCZ_ANSWER,
3051                  (unsigned int) (sizeof (ESCZ_ANSWER) - 1));
3052         break;                  /* steal obsolete ESC [ c */
3053
3054         /* 8.3.16: CONTROL SEQUENCE INTRODUCER */
3055       case C1_CSI:              /* ESC [ */
3056         process_csi_seq ();
3057         break;
3058
3059         /* 8.3.90: OPERATING SYSTEM COMMAND */
3060       case C1_OSC:              /* ESC ] */
3061         process_osc_seq ();
3062         break;
3063
3064         /* 8.3.106: RESET TO INITIAL STATE */
3065       case 'c':
3066         mbstate.reset ();
3067         scr_poweron ();
3068         scrollbar_show (1);
3069         break;
3070
3071         /* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
3072       case 'n':
3073         scr_charset_choose (2);
3074         break;
3075
3076         /* 8.3.81: LOCKING-SHIFT THREE (see ISO2022) */
3077       case 'o':
3078         scr_charset_choose (3);
3079         break;
3080     }
3081 }
3082 /*}}} */
3083
3084 /*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
3085 /* *INDENT-OFF* */
3086 enum {
3087   CSI_ICH = 0x40,
3088            CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
3089   CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
3090   CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
3091   CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
3092   CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
3093   CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
3094   CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,
3095   CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F
3096 };
3097
3098 #define make_byte(b7,b6,b5,b4,b3,b2,b1,b0)                      \
3099     (((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4)      \
3100      | ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
3101 #define get_byte_array_bit(array, bit)                          \
3102     (!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))
3103
3104 const unsigned char csi_defaults[] =
3105   {
3106     make_byte (1,1,1,1,1,1,1,1),        /* @, A, B, C, D, E, F, G, */
3107     make_byte (1,1,0,0,1,1,0,0),        /* H, I, J, K, L, M, N, O, */
3108     make_byte (1,0,1,1,1,1,1,0),        /* P, Q, R, S, T, U, V, W, */
3109     make_byte (1,1,1,0,0,0,1,0),        /* X, Y, Z, [, \, ], ^, _, */
3110     make_byte (1,1,1,0,1,1,1,0),        /* `, a, b, c, d, e, f, g, */
3111     make_byte (0,0,1,1,0,0,0,0),        /* h, i, j, k, l, m, n, o, */
3112     make_byte (0,0,0,0,0,0,0,0),        /* p, q, r, s, t, u, v, w, */
3113     make_byte (0,0,0,0,0,0,0,0),        /* x, y, z, {, |, }, ~,    */
3114   };
3115 /* *INDENT-ON* */
3116
3117 void
3118 rxvt_term::process_csi_seq ()
3119 {
3120   unicode_t ch, priv, i;
3121   unsigned int nargs, p;
3122   int n, ndef;
3123   int arg[ESC_ARGS];
3124
3125   for (nargs = ESC_ARGS; nargs > 0;)
3126     arg[--nargs] = 0;
3127
3128   priv = 0;
3129   ch = cmd_getc ();
3130   if (ch >= '<' && ch <= '?')
3131     {   /* '<' '=' '>' '?' */
3132       priv = ch;
3133       ch = cmd_getc ();
3134     }
3135
3136   /* read any numerical arguments */
3137   for (n = -1; ch < CSI_ICH; )
3138     {
3139       if (isdigit (ch))
3140         {
3141           if (n < 0)
3142             n = ch - '0';
3143           else
3144             n = n * 10 + ch - '0';
3145         }
3146       else if (ch == ';')
3147         {
3148           if (nargs < ESC_ARGS)
3149             arg[nargs++] = n;
3150           n = -1;
3151         }
3152       else if (IS_CONTROL (ch))
3153         process_nonprinting (ch);
3154
3155       ch = cmd_getc ();
3156     }
3157
3158   if (ch > CSI_7F)
3159     return;
3160
3161   if (nargs < ESC_ARGS)
3162     arg[nargs++] = n;
3163
3164   i = ch - CSI_ICH;
3165   ndef = get_byte_array_bit (csi_defaults, i);
3166   for (p = 0; p < nargs; p++)
3167     if (arg[p] == -1)
3168       arg[p] = ndef;
3169
3170 #ifdef DEBUG_CMD
3171   fprintf (stderr, "CSI ");
3172   for (p = 0; p < nargs; p++)
3173     fprintf (stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");
3174   fprintf (stderr, "%c\n", ch);
3175 #endif
3176
3177   /*
3178    * private mode handling
3179    */
3180   if (priv)
3181     {
3182       switch (priv)
3183         {
3184           case '>':
3185             if (ch == CSI_DA)   /* secondary device attributes */
3186               tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING);
3187             break;
3188           case '?':
3189             if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
3190               process_terminal_mode (ch, priv, nargs, arg);
3191             break;
3192         }
3193       return;
3194     }
3195
3196   switch (ch)
3197     {
3198         /*
3199          * ISO/IEC 6429:1992 (E) CSI sequences (defaults in parentheses)
3200          */
3201 #ifdef PRINTPIPE
3202       case CSI_MC:              /* 8.3.83: (0) MEDIA COPY */
3203         switch (arg[0])
3204           {
3205             case 0:                     /* initiate transfer to primary aux device */
3206               scr_printscreen (0);
3207               break;
3208             case 5:                     /* start relay to primary aux device */
3209               process_print_pipe ();
3210               break;
3211           }
3212         break;
3213 #endif
3214
3215       case CSI_CUU:             /* 8.3.22: (1) CURSOR UP */
3216       case CSI_VPR:             /* 8.3.161: (1) LINE POSITION FORWARD */
3217         arg[0] = -arg[0];
3218         /* FALLTHROUGH */
3219       case CSI_CUD:             /* 8.3.19: (1) CURSOR DOWN */
3220       case CSI_VPB:             /* 8.3.160: (1) LINE POSITION BACKWARD */
3221         scr_gotorc (arg[0], 0, RELATIVE);
3222         break;
3223
3224       case CSI_CUB:             /* 8.3.18: (1) CURSOR LEFT */
3225       case CSI_HPB:             /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
3226 #ifdef ISO6429
3227         arg[0] = -arg[0];
3228 #else                           /* emulate common DEC VTs */
3229         arg[0] = arg[0] ? -arg[0] : -1;
3230 #endif
3231         /* FALLTHROUGH */
3232       case CSI_CUF:             /* 8.3.20: (1) CURSOR RIGHT */
3233       case CSI_HPR:             /* 8.3.60: (1) CHARACTER POSITION FORWARD */
3234 #ifdef ISO6429
3235         scr_gotorc (0, arg[0], RELATIVE);
3236 #else                           /* emulate common DEC VTs */
3237         scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);
3238 #endif
3239         break;
3240
3241       case CSI_CPL:             /* 8.3.13: (1) CURSOR PRECEDING LINE */
3242         arg[0] = -arg[0];
3243         /* FALLTHROUGH */
3244       case CSI_CNL:             /* 8.3.12: (1) CURSOR NEXT LINE */
3245         scr_gotorc (arg[0], 0, R_RELATIVE);
3246         break;
3247
3248       case CSI_CHA:             /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */
3249       case CSI_HPA:             /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */
3250         scr_gotorc (0, arg[0] - 1, R_RELATIVE);
3251         break;
3252
3253       case CSI_VPA:             /* 8.3.159: (1) LINE POSITION ABSOLUTE */
3254         scr_gotorc (arg[0] - 1, 0, C_RELATIVE);
3255         break;
3256
3257       case CSI_CUP:             /* 8.3.21: (1,1) CURSOR POSITION */
3258       case CSI_HVP:             /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */
3259         scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);
3260         break;
3261
3262       case CSI_CBT:             /* 8.3.7: (1) CURSOR BACKWARD TABULATION */
3263         arg[0] = -arg[0];
3264         /* FALLTHROUGH */
3265       case CSI_CHT:             /* 8.3.10: (1) CURSOR FORWARD TABULATION */
3266         scr_tab (arg[0]);
3267         break;
3268
3269       case CSI_ED:              /* 8.3.40: (0) ERASE IN PAGE */
3270         scr_erase_screen (arg[0]);
3271         break;
3272
3273       case CSI_EL:              /* 8.3.42: (0) ERASE IN LINE */
3274         scr_erase_line (arg[0]);
3275         break;
3276
3277       case CSI_ICH:             /* 8.3.65: (1) INSERT CHARACTER */
3278         scr_insdel_chars (arg[0], INSERT);
3279         break;
3280
3281       case CSI_IL:              /* 8.3.68: (1) INSERT LINE */
3282         scr_insdel_lines (arg[0], INSERT);
3283         break;
3284
3285       case CSI_DL:              /* 8.3.33: (1) DELETE LINE */
3286         scr_insdel_lines (arg[0], DELETE);
3287         break;
3288
3289       case CSI_ECH:             /* 8.3.39: (1) ERASE CHARACTER */
3290         scr_insdel_chars (arg[0], ERASE);
3291         break;
3292
3293       case CSI_DCH:             /* 8.3.26: (1) DELETE CHARACTER */
3294         scr_insdel_chars (arg[0], DELETE);
3295         break;
3296
3297       case CSI_SD:              /* 8.3.114: (1) SCROLL DOWN */
3298         arg[0] = -arg[0];
3299         /* FALLTHROUGH */
3300       case CSI_SU:              /* 8.3.148: (1) SCROLL UP */
3301         scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
3302         break;
3303
3304       case CSI_DA:              /* 8.3.24: (0) DEVICE ATTRIBUTES */
3305         tt_write ((const unsigned char *)VT100_ANS,
3306                   (unsigned int) (sizeof (VT100_ANS) - 1));
3307         break;
3308
3309       case CSI_SGR:             /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
3310         process_sgr_mode (nargs, arg);
3311         break;
3312
3313       case CSI_DSR:             /* 8.3.36: (0) DEVICE STATUS REPORT */
3314         switch (arg[0])
3315           {
3316             case 5:                     /* DSR requested */
3317               tt_printf ("\033[0n");
3318               break;
3319             case 6:                     /* CPR requested */
3320               scr_report_position ();
3321               break;
3322             case 7:                     /* unofficial extension */
3323               if (options & Opt_insecure)
3324                 tt_printf ("%-.250s\012", rs[Rs_display_name]);
3325               break;
3326             case 8:                     /* unofficial extension */
3327               process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3328               break;
3329           }
3330         break;
3331
3332       case CSI_TBC:             /* 8.3.155: (0) TABULATION CLEAR */
3333         switch (arg[0])
3334           {
3335             case 0:                     /* char tab stop cleared at active position */
3336               scr_set_tab (0);
3337               break;
3338               /* case 1: */             /* line tab stop cleared in active line */
3339               /* case 2: */             /* char tab stops cleared in active line */
3340             case 3:                     /* all char tab stops are cleared */
3341               /* case 4: */             /* all line tab stops are cleared */
3342             case 5:                     /* all tab stops are cleared */
3343               scr_set_tab (-1);
3344               break;
3345           }
3346         break;
3347
3348       case CSI_CTC:             /* 8.3.17: (0) CURSOR TABULATION CONTROL */
3349         switch (arg[0])
3350           {
3351             case 0:                     /* char tab stop set at active position */
3352               scr_set_tab (1);
3353               break;            /* = ESC H */
3354               /* case 1: */             /* line tab stop set at active line */
3355             case 2:                     /* char tab stop cleared at active position */
3356               scr_set_tab (0);
3357               break;            /* = ESC [ 0 g */
3358               /* case 3: */             /* line tab stop cleared at active line */
3359               /* case 4: */             /* char tab stops cleared at active line */
3360             case 5:                     /* all char tab stops are cleared */
3361               scr_set_tab (-1);
3362               break;            /* = ESC [ 3 g */
3363               /* case 6: */             /* all line tab stops are cleared */
3364           }
3365         break;
3366
3367       case CSI_RM:              /* 8.3.107: RESET MODE */
3368         if (arg[0] == 4)
3369           scr_insert_mode (0);
3370         else if (arg[0] == 20)
3371           priv_modes &= ~PrivMode_LFNL;
3372         break;
3373
3374       case CSI_SM:              /* 8.3.126: SET MODE */
3375         if (arg[0] == 4)
3376           scr_insert_mode (1);
3377         else if (arg[0] == 20)
3378           priv_modes |= PrivMode_LFNL;
3379         break;
3380
3381         /*
3382          * PRIVATE USE beyond this point.  All CSI_7? sequences here
3383          */
3384       case CSI_72:              /* DECSTBM: set top and bottom margins */
3385         if (nargs == 1)
3386           scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);
3387         else if (nargs == 0 || arg[0] >= arg[1])
3388           scr_scroll_region (0, MAX_ROWS - 1);
3389         else
3390           scr_scroll_region (arg[0] - 1, arg[1] - 1);
3391         break;
3392
3393       case CSI_73:
3394         scr_cursor (SAVE);
3395         break;
3396       case CSI_75:
3397         scr_cursor (RESTORE);
3398         break;
3399
3400 #if ENABLE_FRILLS
3401       case CSI_74:
3402         process_window_ops (arg, nargs);
3403         break;
3404 #endif
3405
3406       case CSI_78:              /* DECREQTPARM */
3407         if (arg[0] == 0 || arg[0] == 1)
3408           tt_printf ("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
3409         break;
3410
3411       default:
3412         break;
3413     }
3414 }
3415 /*}}} */
3416
3417 #if ENABLE_FRILLS
3418 /* ARGSUSED */
3419 void
3420 rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3421 {
3422   int x, y;
3423   XWindowAttributes wattr;
3424   Window wdummy;
3425
3426   if (nargs == 0)
3427     return;
3428
3429   switch (args[0])
3430     {
3431       /*
3432        * commands
3433        */
3434       case 1:                   /* deiconify window */
3435         XMapWindow (display->display, TermWin.parent[0]);
3436         break;
3437       case 2:                   /* iconify window */
3438         XIconifyWindow (display->display, TermWin.parent[0],
3439                        DefaultScreen (display->display));
3440         break;
3441       case 3:                   /* set position (pixels) */
3442         XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]);
3443         break;
3444       case 4:                   /* set size (pixels) */
3445         set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3446         break;
3447       case 5:                   /* raise window */
3448         XRaiseWindow (display->display, TermWin.parent[0]);
3449         break;
3450       case 6:                   /* lower window */
3451         XLowerWindow (display->display, TermWin.parent[0]);
3452         break;
3453       case 7:                   /* refresh window */
3454         scr_touch (true);
3455         break;
3456       case 8:                   /* set size (chars) */
3457         set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),
3458                          (unsigned int) (args[1] * TermWin.fheight));
3459         break;
3460
3461       //case 9: NYI, TODO, restore maximized window or maximize window
3462       default:
3463         if (args[0] >= 24)      /* set height (chars) */
3464           set_widthheight ((unsigned int)TermWin.width,
3465                            (unsigned int) (args[1] * TermWin.fheight));
3466         break;
3467
3468
3469       /*
3470        * reports - some output format copied from XTerm
3471        */
3472       case 11:                  /* report window state */
3473         XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
3474         tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3475         break;
3476       case 13:                  /* report window position */
3477         XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
3478         XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,
3479                                -wattr.border_width, -wattr.border_width,
3480                                &x, &y, &wdummy);
3481         tt_printf ("\033[3;%d;%dt", x, y);
3482         break;
3483       case 14:                  /* report window size (pixels) */
3484         XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
3485         tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3486         break;
3487       case 18:                  /* report text area size (chars) */
3488         tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
3489         break;
3490       case 19:                  /* report window size (chars) */
3491         tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
3492         break;
3493       case 20:                  /* report icon label */
3494         {
3495           char *s;
3496           XGetIconName (display->display, TermWin.parent[0], &s);
3497           tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : "");      /* 8bit ST */
3498           XFree (s);
3499         }
3500         break;
3501       case 21:                  /* report window title */
3502         {
3503           char *s;
3504           XFetchName (display->display, TermWin.parent[0], &s);
3505           tt_printf ("\033]l%-.250s\234", (options & Opt_insecure) && s ? s : "");      /* 8bit ST */
3506           XFree (s);
3507         }
3508         break;
3509     }
3510 }
3511 #endif
3512
3513 /*----------------------------------------------------------------------*/
3514 /*
3515  * get input up until STRING TERMINATOR (or BEL)
3516  * ends_how is terminator used. returned input must be free()'d
3517  */
3518 unsigned char *
3519 rxvt_term::get_to_st (unicode_t &ends_how)
3520 {
3521   unicode_t ch;
3522   bool seen_esc = false;
3523   unsigned int n = 0;
3524   wchar_t string[STRING_MAX];
3525
3526   while ((ch = cmd_getc ()) != NOCHAR)
3527     {
3528       if (seen_esc)
3529         {
3530           if (ch == 0x5c)       /* 7bit ST */
3531             break;
3532           else
3533             return NULL;
3534         }
3535       else if (ch == C0_ESC)
3536         {
3537           seen_esc = true;
3538           continue;
3539         }
3540       else if (ch == C0_BEL || ch == CHAR_ST)
3541         break;
3542       else if (ch < 0x20)
3543         return NULL;    /* other control character - exit */
3544
3545       seen_esc = false;
3546
3547       if (n >= sizeof (string) - 1)
3548         // stop at some sane length
3549         return NULL;
3550
3551       if (ch == C0_SYN)
3552         string[n++] = cmd_get8 ();
3553       else
3554         string[n++] = ch;
3555     }
3556
3557   string[n++] = '\0';
3558
3559   ends_how = (ch == 0x5c ? C0_ESC : ch);
3560
3561   return (unsigned char *)rxvt_wcstombs (string);
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 = display->atom (str + 1);
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                 set_utf8_property (display->atom (str), eq + 1);
3701               }
3702             else
3703               XDeleteProperty (display->display, TermWin.parent[0],
3704                                display->atom (str));
3705           }
3706         break;
3707
3708       case XTerm_Color:
3709         for (buf = (char *)str; buf && *buf;)
3710           {
3711             if ((name = strchr (buf, ';')) == NULL)
3712               break;
3713
3714             *name++ = '\0';
3715             color = atoi (buf);
3716
3717             if (color < 0 || color >= TOTAL_COLORS)
3718               break;
3719
3720             if ((buf = strchr (name, ';')) != NULL)
3721               *buf++ = '\0';
3722
3723             if (name[0] == '?' && !name[1])
3724               {
3725                 unsigned short r, g, b;
3726                 pix_colors_focused[color + minCOLOR].get (display, r, g, b);
3727                 tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3728               }
3729             else
3730               set_window_color (color + minCOLOR, name);
3731           }
3732         break;
3733       case XTerm_Color00:
3734         process_color_seq (XTerm_Color00, Color_fg, str, resp);
3735         break;
3736       case XTerm_Color01:
3737         process_color_seq (XTerm_Color00, Color_bg, str, resp);
3738         break;
3739 #ifndef NO_CURSORCOLOR
3740       case XTerm_Color_cursor:
3741         process_color_seq (XTerm_Color_cursor, Color_cursor, str, resp);
3742         break;
3743 #endif
3744       case XTerm_Color_pointer_fg:
3745         process_color_seq (XTerm_Color_pointer_fg, Color_pointer_fg, str, resp);
3746         break;
3747       case XTerm_Color_pointer_bg:
3748         process_color_seq (XTerm_Color_pointer_bg, Color_pointer_bg, str, resp);
3749         break;
3750 #ifndef NO_BOLD_UNDERLINE_REVERSE
3751       case XTerm_Color_BD:
3752         process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3753         break;
3754       case XTerm_Color_IT:
3755         process_color_seq (XTerm_Color_IT, Color_IT, str, resp);
3756         break;
3757       case XTerm_Color_UL:
3758         process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3759         break;
3760       case XTerm_Color_RV:
3761         process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
3762         break;
3763 #endif
3764 #if TRANSPARENT && TINTING
3765       case XTerm_Color_tint:
3766         process_color_seq (XTerm_Color_tint, Color_tint, str, resp);
3767         check_our_parents ();
3768         if (am_transparent)
3769           want_full_refresh = want_refresh = 1;
3770         break;
3771 #endif
3772
3773       case XTerm_Pixmap:
3774         if (*str != ';')
3775           {
3776 #if XPM_BACKGROUND
3777             scale_pixmap ("");  /* reset to default scaling */
3778             set_bgPixmap (str); /* change pixmap */
3779 #endif
3780             scr_touch (true);
3781           }
3782         while ((str = strchr (str, ';')) != NULL)
3783           {
3784             str++;
3785 #if XPM_BACKGROUND
3786             changed += scale_pixmap (str);
3787 #endif
3788
3789           }
3790         if (changed)
3791           {
3792 #ifdef XPM_BACKGROUND
3793             resize_pixmap ();
3794 #endif
3795             scr_touch (true);
3796           }
3797         break;
3798
3799       case XTerm_restoreFG:
3800         set_window_color (Color_fg, str);
3801         break;
3802       case XTerm_restoreBG:
3803         set_window_color (Color_bg, str);
3804         break;
3805
3806       case XTerm_logfile:
3807         // TODO, when secure mode?
3808         break;
3809
3810       case XTerm_font:
3811         op = URxvt_font;
3812       case URxvt_font:
3813 #if ENABLE_STYLES
3814       case URxvt_boldFont:
3815       case URxvt_italicFont:
3816       case URxvt_boldItalicFont:
3817 #endif
3818         if (query)
3819           tt_printf ("\33]%d;%-.250s%c", saveop,
3820                      (options & Opt_insecure) && TermWin.fontset[op - URxvt_font]->fontdesc
3821                        ? TermWin.fontset[op - URxvt_font]->fontdesc : "",
3822                      resp);
3823         else
3824           {
3825             const char *&res = rs[Rs_font + (op - URxvt_font)];
3826
3827             res = strdup (str);
3828             allocated.push_back ((void *)res);
3829             set_fonts ();
3830           }
3831         break;
3832
3833 #if ENABLE_FRILLS
3834       case XTerm_locale:
3835         if (query)
3836           tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (options & Opt_insecure) ? locale : "", resp);
3837         else
3838           {
3839             set_locale (str);
3840 # ifdef USE_XIM
3841             im_cb ();
3842 # endif
3843           }
3844         break;
3845 #endif
3846
3847 #ifdef MENUBAR
3848      case XTerm_Menu:
3849        if (options & Opt_insecure)
3850          menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3851        break;
3852 #endif
3853 #if 0
3854       case XTerm_dumpscreen:    /* no error notices */
3855         {
3856           int fd;
3857           if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3858             {
3859               scr_dump (fd);
3860               close (fd);
3861             }
3862         }
3863         break;
3864 #endif
3865     }
3866 }
3867 /*----------------------------------------------------------------------*/
3868
3869 /*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */
3870 /*
3871  * mode can only have the following values:
3872  *      'l' = low
3873  *      'h' = high
3874  *      's' = save
3875  *      'r' = restore
3876  *      't' = toggle
3877  * so no need for fancy checking
3878  */
3879 int
3880 rxvt_term::privcases (int mode, unsigned long bit)
3881 {
3882   int state;
3883
3884   if (mode == 's')
3885     {
3886       SavedModes |= (priv_modes & bit);
3887       return -1;
3888     }
3889   else
3890     {
3891       if (mode == 'r')
3892         state = (SavedModes & bit) ? 1 : 0;     /* no overlapping */
3893       else
3894         state = (mode == 't') ? ! (priv_modes & bit) : mode;
3895       PrivMode (state, bit);
3896     }
3897
3898   return state;
3899 }
3900
3901 /* we're not using priv _yet_ */
3902 void
3903 rxvt_term::process_terminal_mode (int mode, int priv __attribute__ ((unused)), unsigned int nargs, const int *arg)
3904 {
3905   unsigned int i, j;
3906   int state;
3907
3908   static const struct
3909     {
3910       const int       argval;
3911       const unsigned long bit;
3912     }
3913
3914   argtopriv[] = {
3915                   { 1, PrivMode_aplCUR },
3916                   { 2, PrivMode_vt52 },
3917                   { 3, PrivMode_132 },
3918                   { 4, PrivMode_smoothScroll },
3919                   { 5, PrivMode_rVideo },
3920                   { 6, PrivMode_relOrigin },
3921                   { 7, PrivMode_Autowrap },
3922                  // 8, bi-directional support mode
3923                   { 9, PrivMode_MouseX10 },
3924 #ifdef menuBar_esc
3925                   { menuBar_esc, PrivMode_menuBar },
3926 #endif
3927                  // 18, 19 printing-related
3928                   { 25, PrivMode_VisibleCursor },
3929 #ifdef scrollBar_esc
3930                   { scrollBar_esc, PrivMode_scrollBar },
3931 #endif
3932                   { 35, PrivMode_ShiftKeys }, // rxvt extension
3933                   { 40, PrivMode_132OK },
3934                  // 41 xterm more fixes NYI
3935                  // 45 margin bell NYI
3936                  // 46 start logging
3937                   { 47, PrivMode_Screen },
3938                   { 66, PrivMode_aplKP },
3939 #ifndef NO_BACKSPACE_KEY
3940                   { 67, PrivMode_BackSpace },
3941 #endif
3942                   { 1000, PrivMode_MouseX11 },
3943                  // 1001 Use Hilite Mouse Tracking. NYI, TODO
3944                  // 1002 Use Cell Motion Mouse Tracking. NYI, TODO
3945                  // 1003 Use All Motion Mouse Tracking. NYI, TODO
3946                   { 1010, PrivMode_TtyOutputInh }, // rxvt extension
3947                   { 1011, PrivMode_Keypress }, // rxvt extension
3948                  // 1035 enable modifiers for alt, numlock NYI
3949                  // 1036 send ESC for meta keys NYI
3950                  // 1037 send DEL for keypad delete NYI
3951                   { 1047, PrivMode_Screen },
3952                  // 1048 save and restore cursor
3953                   { 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3954                  // 1051, 1052, 1060, 1061 keyboard emulation NYI
3955                 };
3956
3957   if (nargs == 0)
3958     return;
3959
3960   /* make lo/hi boolean */
3961   if (mode == 'l')
3962     mode = 0;           /* reset */
3963   else if (mode == 'h')
3964     mode = 1;           /* set */
3965
3966   for (i = 0; i < nargs; i++)
3967     {
3968       state = -1;
3969
3970       /* basic handling */
3971       for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)
3972         if (argtopriv[j].argval == arg[i])
3973           {
3974             state = privcases (mode, argtopriv[j].bit);
3975             break;
3976           }
3977
3978       /* extra handling for values with state unkept  */
3979       switch (arg[i])
3980         {
3981           case 1048:            /* alternative cursor save */
3982           case 1049:
3983             if (options & Opt_secondaryScreen)
3984               if (mode == 0)
3985                 scr_cursor (RESTORE);
3986               else if (mode == 1)
3987                 scr_cursor (SAVE);
3988             break;
3989         }
3990
3991       if (state >= 0)
3992         /* extra handling for values with valid 0 or 1 state */
3993         switch (arg[i])
3994           {
3995               /* case 1:        - application cursor keys */
3996             case 2:                     /* VT52 mode */
3997               /* oddball mode.  should be set regardless of set/reset
3998                * parameter.  Return from VT52 mode with an ESC < from
3999                * within VT52 mode
4000                */
4001               PrivMode (1, PrivMode_vt52);
4002               break;
4003             case 3:                     /* 80/132 */
4004               if (priv_modes & PrivMode_132OK)
4005                 set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
4006               break;
4007             case 4:                     /* smooth scrolling */
4008               if (state)
4009                 options &= ~Opt_jumpScroll;
4010               else
4011                 options |= Opt_jumpScroll;
4012               break;
4013             case 5:                     /* reverse video */
4014               scr_rvideo_mode (state);
4015               break;
4016             case 6:                     /* relative/absolute origins  */
4017               scr_relative_origin (state);
4018               break;
4019             case 7:                     /* autowrap */
4020               scr_autowrap (state);
4021               break;
4022             /* case 8:  - auto repeat, can't do on a per window basis */
4023             case 9:                     /* X10 mouse reporting */
4024               if (state)                /* orthogonal */
4025                 priv_modes &= ~PrivMode_MouseX11;
4026               break;
4027 #ifdef menuBar_esc
4028             case menuBar_esc:
4029 #ifdef MENUBAR
4030               map_menuBar (state);
4031 #endif
4032               break;
4033 #endif
4034 #ifdef scrollBar_esc
4035             case scrollBar_esc:
4036               if (scrollbar_mapping (state))
4037                 {
4038                   resize_all_windows (0, 0, 0);
4039                   scr_touch (true);
4040                 }
4041               break;
4042 #endif
4043             case 25:            /* visible/invisible cursor */
4044               scr_cursor_visible (state);
4045               break;
4046             /* case 35: - shift keys */
4047             /* case 40: - 80 <--> 132 mode */
4048             case 47:            /* secondary screen */
4049               scr_change_screen (state);
4050               break;
4051             /* case 66: - application key pad */
4052             /* case 67: - backspace key */
4053             case 1000:          /* X11 mouse reporting */
4054               if (state)                /* orthogonal */
4055                 priv_modes &= ~PrivMode_MouseX10;
4056               break;
4057 #if 0
4058             case 1001:
4059               break;            /* X11 mouse highlighting */
4060 #endif
4061             case 1010:          /* scroll to bottom on TTY output inhibit */
4062               if (state)
4063                 options &= ~Opt_scrollTtyOutput;
4064               else
4065                 options |= Opt_scrollTtyOutput;
4066               break;
4067             case 1011:          /* scroll to bottom on key press */
4068               if (state)
4069                 options |= Opt_scrollTtyKeypress;
4070               else
4071                 options &= ~Opt_scrollTtyKeypress;
4072               break;
4073             case 1047:          /* secondary screen w/ clearing last */
4074               if (options & Opt_secondaryScreen)
4075                 if (current_screen != PRIMARY)
4076                   scr_erase_screen (2);
4077               scr_change_screen (state);
4078               break;
4079             case 1049:          /* secondary screen w/ clearing first */
4080               scr_change_screen (state);
4081               if (options & Opt_secondaryScreen)
4082                 if (current_screen != PRIMARY)
4083                   scr_erase_screen (2);
4084               break;
4085             default:
4086               break;
4087           }
4088     }
4089 }
4090 /*}}} */
4091
4092 /*{{{ process sgr sequences */
4093 void
4094 rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
4095 {
4096   unsigned int i;
4097   short rendset;
4098   int rendstyle;
4099
4100   if (nargs == 0)
4101     {
4102       scr_rendition (0, ~RS_None);
4103       return;
4104     }
4105
4106   for (i = 0; i < nargs; i++)
4107     {
4108       rendset = -1;
4109       switch (arg[i])
4110         {
4111           case 0:
4112             rendset = 0, rendstyle = ~RS_None;
4113             break;
4114           case 1:
4115             rendset = 1, rendstyle = RS_Bold;
4116             break;
4117           //case 2: // low intensity
4118           case 3:
4119             rendset = 1, rendstyle = RS_Italic;
4120             break;
4121           case 4:
4122             rendset = 1, rendstyle = RS_Uline;
4123             break;
4124           case 5: // slowly blinking
4125           case 6: // rapidly blinking
4126             rendset = 1, rendstyle = RS_Blink;
4127             break;
4128           //case 6: // scoansi light background
4129           case 7:
4130             rendset = 1, rendstyle = RS_RVid;
4131             break;
4132           case 8:
4133             // invisible. NYI
4134             break;
4135           //case 9: // crossed out
4136           //case 10: // scoansi acs off, primary font
4137           //case 11: // scoansi acs on, first alt font
4138           //case 12: // scoansi acs on, |0x80, second alt font
4139           //...
4140           //case 19: // ninth alt font
4141           //case 20: // gothic
4142           case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
4143             rendset = 0, rendstyle = RS_Bold;
4144             break;
4145           case 22: // normal intensity
4146             rendset = 0, rendstyle = RS_Bold;
4147             break;
4148           case 23: // disable italic
4149             rendset = 0, rendstyle = RS_Italic;
4150             break;
4151           case 24:
4152             rendset = 0, rendstyle = RS_Uline;
4153             break;
4154           case 25:
4155             rendset = 0, rendstyle = RS_Blink;
4156             break;
4157           case 26: // variable spacing (iso 8613)
4158             rendset = 0, rendstyle = RS_Blink;
4159             break;
4160           case 27:
4161             rendset = 0, rendstyle = RS_RVid;
4162             break;
4163           //case 28: // visible. NYI
4164           //case 29: // not crossed-out
4165         }
4166
4167       if (rendset != -1)
4168         {
4169           scr_rendition (rendset, rendstyle);
4170           continue;             /* for (;i;) */
4171         }
4172
4173       switch (arg[i])
4174         {
4175           case 30:
4176           case 31:              /* set fg color */
4177           case 32:
4178           case 33:
4179           case 34:
4180           case 35:
4181           case 36:
4182           case 37:
4183             scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
4184             break;
4185           case 38: // set fg color, ISO 8613-6
4186             if (nargs > i + 2 && arg[i + 1] == 5)
4187               {
4188                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
4189                 i += 2;
4190               }
4191             break;
4192           case 39:              /* default fg */
4193             scr_color (Color_fg, Color_fg);
4194             break;
4195
4196           case 40:
4197           case 41:              /* set bg color */
4198           case 42:
4199           case 43:
4200           case 44:
4201           case 45:
4202           case 46:
4203           case 47:
4204             scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
4205             break;
4206           case 48: // set bg color, ISO 8613-6
4207             if (nargs > i + 2 && arg[i + 1] == 5)
4208               {
4209                 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
4210                 i += 2;
4211               }
4212             break;
4213           case 49:              /* default bg */
4214             scr_color (Color_bg, Color_bg);
4215             break;
4216
4217           //case 50: // not variable spacing
4218
4219 #ifndef NO_BRIGHTCOLOR
4220           case 90:
4221           case 91:              /* set bright fg color */
4222           case 92:
4223           case 93:
4224           case 94:
4225           case 95:
4226           case 96:
4227           case 97:
4228             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
4229             break;
4230           case 100:
4231           case 101:             /* set bright bg color */
4232           case 102:
4233           case 103:
4234           case 104:
4235           case 105:
4236           case 106:
4237           case 107:
4238             scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
4239             break;
4240 #endif
4241
4242         }
4243     }
4244 }
4245 /*}}} */
4246
4247 /*{{{ (do not) process Rob Nation's own graphics mode sequences */
4248 void
4249 rxvt_term::process_graphics ()
4250 {
4251   unicode_t ch, cmd = cmd_getc ();
4252
4253   if (cmd == 'Q')
4254     {           /* query graphics */
4255       tt_printf ("\033G0\012"); /* no graphics */
4256       return;
4257     }
4258   /* swallow other graphics sequences until terminating ':' */
4259   do
4260     ch = cmd_getc ();
4261   while (ch != ':');
4262 }
4263 /*}}} */
4264
4265 /* ------------------------------------------------------------------------- */
4266
4267 /*
4268  * Send printf () formatted output to the command.
4269  * Only use for small amounts of data.
4270  */
4271 void
4272 rxvt_term::tt_printf (const char *fmt,...)
4273 {
4274   va_list arg_ptr;
4275   unsigned char buf[256];
4276
4277   va_start (arg_ptr, fmt);
4278   vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4279   va_end (arg_ptr);
4280   tt_write (buf, strlen (buf));
4281 }
4282
4283 /* ---------------------------------------------------------------------- */
4284 /* Write data to the pty as typed by the user, pasted with the mouse,
4285  * or generated by us in response to a query ESC sequence.
4286  */
4287 void
4288 rxvt_term::tt_write (const unsigned char *data, unsigned int len)
4289 {
4290   const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
4291
4292   if (len)
4293     {
4294       if (v_buflen == 0)
4295         {
4296           ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
4297
4298           if ((unsigned int)written == len)
4299             return;
4300
4301           data += written;
4302           len -= written;
4303         }
4304
4305
4306       v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
4307
4308       memcpy (v_buffer + v_buflen, data, len);
4309       v_buflen += len;
4310     }
4311
4312   for (;;)
4313     {
4314       int written = write (pty.pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
4315
4316       if (written > 0)
4317         {
4318           v_buflen -= written;
4319
4320           if (v_buflen == 0)
4321             {
4322               free (v_buffer);
4323               v_buffer = 0;
4324               v_buflen = 0;
4325
4326               pty_ev.set (EVENT_READ);
4327               return;
4328             }
4329
4330           memmove (v_buffer, v_buffer + written, v_buflen);
4331         }
4332       else if (written != -1 || (errno != EAGAIN && errno != EINTR))
4333         // original code just ignores this...
4334         destroy ();
4335       else
4336         {
4337           pty_ev.set (EVENT_READ | EVENT_WRITE);
4338           return;
4339         }
4340     }
4341 }
4342
4343 /*----------------------- end-of-file (C source) -----------------------*/
4344