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