src/main.C

   1 /*----------------------------------------------------------------------*
   2  * File:        main.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  * Copyright (c) 1997      mj olesen <olesen@me.QueensU.CA>
  12  *                              - extensive modifications
  13  * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
  14  * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  15  *                              - extensive modifications
  16  * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  *---------------------------------------------------------------------*/
  32
  33 #include "../config.h"          /* NECESSARY */
  34 #include "rxvt.h"               /* NECESSARY */
  35 #include "keyboard.h"
  36 #include "rxvtperl.h"
  37
  38 #include <limits>
  39
  40 #include <csignal>
  41 #include <cstring>
  42
  43 #ifdef HAVE_TERMIOS_H
  44 # include <termios.h>
  45 #endif
  46
  47 #ifdef HAVE_XSETLOCALE
  48 # define X_LOCALE
  49 # include <X11/Xlocale.h>
  50 #else
  51 # ifdef HAVE_SETLOCALE
  52 #  include <clocale>
  53 # endif
  54 #endif
  55
  56 vector<rxvt_term *> rxvt_term::termlist;
  57
  58 // used to tell global functions which terminal instance is "active"
  59 rxvt_t rxvt_current_term;
  60
  61 static char curlocale[128], savelocale[128];
  62
  63 bool
  64 rxvt_set_locale (const char *locale) NOTHROW
  65 {
  66   int size = strlen (locale) + 1;
  67
  68   if (size > sizeof (curlocale))
  69     rxvt_fatal ("locale string too long, aborting.\n");
  70
  71   if (!locale || !memcmp (locale, curlocale, size))
  72     return false;
  73
  74   memcpy (curlocale, locale, size);
  75   setlocale (LC_CTYPE, curlocale);
  76   return true;
  77 }
  78
  79 void
  80 rxvt_push_locale (const char *locale) NOTHROW
  81 {
  82   strcpy (savelocale, curlocale);
  83   rxvt_set_locale (locale);
  84 }
  85
  86 void
  87 rxvt_pop_locale () NOTHROW
  88 {
  89   rxvt_set_locale (savelocale);
  90 }
  91
  92 #if ENABLE_COMBINING
  93 class rxvt_composite_vec rxvt_composite;
  94
  95 text_t rxvt_composite_vec::compose (unicode_t c1, unicode_t c2)
  96 {
  97   compose_char *cc;
  98
  99   // break compose chains, as stupid readline really likes to duplicate
 100   // composing characters for some reason near the end of a line.
 101   cc = (*this)[c1];
 102   while (cc)
 103     {
 104       if (cc->c2 == c2) return c1;
 105       cc = (*this)[cc->c1];
 106     }
 107
 108   // check to see wether this combination already exists otherwise
 109   for (cc = v.end (); cc-- > v.begin (); )
 110     {
 111       if (cc->c1 == c1 && cc->c2 == c2)
 112         return COMPOSE_LO + (cc - v.begin ());
 113     }
 114
 115   // allocate a new combination
 116   if (v.size () == COMPOSE_HI - COMPOSE_LO + 1)
 117     {
 118       static int seen;
 119
 120       if (!seen++)
 121         fprintf (stderr, "too many unrepresentable composite characters, try --enable-unicode3\n");
 122
 123       return REPLACEMENT_CHAR;
 124     }
 125
 126   v.push_back (compose_char (c1, c2));
 127
 128   return v.size () - 1 + COMPOSE_LO;
 129 }
 130
 131 int rxvt_composite_vec::expand (unicode_t c, wchar_t *r)
 132 {
 133   compose_char *cc = (*this)[c];
 134
 135   if (!cc)
 136     {
 137       if (r) *r = c;
 138       return 1;
 139     }
 140
 141   int len = expand (cc->c1, r);
 142
 143   if (r) r += len;
 144
 145   if (cc->c2 != NOCHAR)
 146     {
 147       len++;
 148       if (r) *r++ = cc->c2;
 149     }
 150
 151   return len;
 152
 153 }
 154 #endif
 155
 156 rxvt_term::rxvt_term ()
 157     :
 158 #if HAVE_BG_PIXMAP
 159     update_background_ev(this, &rxvt_term::update_background_cb),
 160 #endif
 161 #ifdef CURSOR_BLINK
 162     cursor_blink_ev (this, &rxvt_term::cursor_blink_cb),
 163 #endif
 164 #ifdef TEXT_BLINK
 165     text_blink_ev (this, &rxvt_term::text_blink_cb),
 166 #endif
 167 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
 168     cont_scroll_ev (this, &rxvt_term::cont_scroll_cb),
 169 #endif
 170 #ifdef SELECTION_SCROLLING
 171     sel_scroll_ev (this, &rxvt_term::sel_scroll_cb),
 172 #endif
 173 #if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
 174     slip_wheel_ev (this, &rxvt_term::slip_wheel_cb),
 175 #endif
 176 #ifdef POINTER_BLANK
 177     pointer_ev (this, &rxvt_term::pointer_cb),
 178 #endif
 179 #ifndef NO_BELL
 180     bell_ev    (this, &rxvt_term::bell_cb),
 181 #endif
 182     child_ev   (this, &rxvt_term::child_cb),
 183     prepare_ev (this, &rxvt_term::prepare_cb),
 184     flush_ev   (this, &rxvt_term::flush_cb),
 185     destroy_ev (this, &rxvt_term::destroy_cb),
 186     pty_ev     (this, &rxvt_term::pty_cb),
 187     incr_ev    (this, &rxvt_term::incr_cb)
 188 {
 189 #if ENABLE_TRANSPARENCY || ENABLE_PERL
 190   callback_set (rootwin_ev  , this, rxvt_term, rootwin_cb);
 191 #endif
 192 #ifdef HAVE_SCROLLBARS
 193   callback_set (scrollbar_ev, this, rxvt_term, x_cb);
 194 #endif
 195 #ifdef USE_XIM
 196   callback_set (im_ev       , this, rxvt_term, im_cb);
 197 #endif
 198   callback_set (termwin_ev  , this, rxvt_term, x_cb);
 199   callback_set (vt_ev       , this, rxvt_term, x_cb);
 200
 201   cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;
 202
 203   termlist.push_back (this);
 204
 205 #ifdef KEYSYM_RESOURCE
 206   keyboard = new keyboard_manager;
 207 #endif
 208 }
 209
 210 // clean up the most important stuff, do *not* call x or free mem etc.
 211 // for use before an emergency exit
 212 void
 213 rxvt_term::emergency_cleanup ()
 214 {
 215   if (cmd_pid)
 216     kill (-cmd_pid, SIGHUP);
 217
 218   pty_ev.stop ();
 219   delete pty; pty = 0;
 220 }
 221
 222 rxvt_term::~rxvt_term ()
 223 {
 224   termlist.erase (find (termlist.begin (), termlist.end(), this));
 225
 226   emergency_cleanup ();
 227
 228 #if ENABLE_STYLES
 229   for (int i = RS_styleCount; --i; )
 230     if (fontset[i] != fontset[0])
 231       delete fontset[i];
 232 #endif
 233   delete fontset[0];
 234
 235   if (display)
 236     {
 237       selection_clear ();
 238
 239 #ifdef USE_XIM
 240       im_destroy ();
 241 #endif
 242 #ifdef XTERM_SCROLLBAR
 243       if (xscrollbarGC) XFreeGC (dpy, xscrollbarGC);
 244       if (ShadowGC)     XFreeGC (dpy, ShadowGC);
 245 #endif
 246 #ifdef PLAIN_SCROLLBAR
 247       if (pscrollbarGC) XFreeGC (dpy, pscrollbarGC);
 248 #endif
 249 #ifdef NEXT_SCROLLBAR
 250       if (blackGC)      XFreeGC (dpy, blackGC);
 251       if (whiteGC)      XFreeGC (dpy, whiteGC);
 252       if (grayGC)       XFreeGC (dpy, grayGC);
 253       if (darkGC)       XFreeGC (dpy, darkGC);
 254       if (stippleGC)    XFreeGC (dpy, stippleGC);
 255       if (dimple)       XFreePixmap (dpy, dimple);
 256       if (upArrow)      XFreePixmap (dpy, upArrow);
 257       if (downArrow)    XFreePixmap (dpy, downArrow);
 258       if (upArrowHi)    XFreePixmap (dpy, upArrowHi);
 259       if (downArrowHi)  XFreePixmap (dpy, downArrowHi);
 260 #endif
 261 #ifdef RXVT_SCROLLBAR
 262       if (topShadowGC)  XFreeGC (dpy, topShadowGC);
 263       if (botShadowGC)  XFreeGC (dpy, botShadowGC);
 264       if (scrollbarGC)  XFreeGC (dpy, scrollbarGC);
 265 #endif
 266       if (gc)   XFreeGC (dpy, gc);
 267
 268       delete drawable;
 269       // destroy all windows
 270       if (parent[0])
 271         XDestroyWindow (dpy, parent[0]);
 272
 273       for (int i = 0; i < TOTAL_COLORS; i++)
 274         if (ISSET_PIXCOLOR (i))
 275           {
 276             pix_colors_focused   [i].free (this);
 277 #if OFF_FOCUS_FADING
 278             pix_colors_unfocused [i].free (this);
 279 #endif
 280           }
 281
 282       clear ();
 283     }
 284
 285   delete [] pix_colors_focused;
 286 #if OFF_FOCUS_FADING
 287   delete [] pix_colors_unfocused;
 288 #endif
 289
 290 #ifdef HAVE_BG_PIXMAP
 291   bgPixmap.destroy ();
 292 #endif
 293   displays.put (display);
 294
 295   scr_release ();
 296
 297   /* clear all resources */
 298   for (int i = 0; i < allocated.size (); i++)
 299     free (allocated [i]);
 300
 301   free (selection.text);
 302   // TODO: manage env vars in child only(!)
 303   free (env_display);
 304   free (env_term);
 305   free (locale);
 306   free (v_buffer);
 307   free (incr_buf);
 308
 309   delete envv;
 310   delete argv;
 311
 312 #ifdef KEYSYM_RESOURCE
 313   delete keyboard;
 314 #endif
 315 #ifndef NO_RESOURCES
 316   XrmDestroyDatabase (option_db);
 317 #endif
 318 }
 319
 320 // child has exited, usually destroys
 321 void
 322 rxvt_term::child_cb (ev::child &w, int status)
 323 {
 324   HOOK_INVOKE ((this, HOOK_CHILD_EXIT, DT_INT, status, DT_END));
 325
 326   cmd_pid = 0;
 327
 328   if (!option (Opt_hold))
 329     destroy ();
 330 }
 331
 332 void
 333 rxvt_term::destroy ()
 334 {
 335   if (destroy_ev.active)
 336     return;
 337
 338   HOOK_INVOKE ((this, HOOK_DESTROY, DT_END));
 339
 340 #if ENABLE_OVERLAY
 341   scr_overlay_off ();
 342 #endif
 343
 344   if (display)
 345     {
 346 #if USE_XIM
 347       im_ev.stop (display);
 348 #endif
 349 #if HAVE_SCROLLBARS
 350       scrollbar_ev.stop (display);
 351 #endif
 352 #if ENABLE_TRANSPARENCY || ENABLE_PERL
 353       rootwin_ev.stop (display);
 354 #endif
 355       incr_ev.stop ();
 356       termwin_ev.stop (display);
 357       vt_ev.stop (display);
 358     }
 359
 360   prepare_ev.stop ();
 361   pty_ev.stop ();
 362 #ifdef CURSOR_BLINK
 363   cursor_blink_ev.stop ();
 364 #endif
 365 #ifdef TEXT_BLINK
 366   text_blink_ev.stop ();
 367 #endif
 368 #ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
 369   cont_scroll_ev.stop ();
 370 #endif
 371 #ifdef SELECTION_SCROLLING
 372   sel_scroll_ev.stop ();
 373 #endif
 374 #ifdef POINTER_BLANK
 375   pointer_ev.stop ();
 376 #endif
 377
 378   destroy_ev.start ();
 379 }
 380
 381 void
 382 rxvt_term::destroy_cb (ev::idle &w, int revents)
 383 {
 384   make_current ();
 385
 386   delete this;
 387 }
 388
 389 /*----------------------------------------------------------------------*/
 390 /*
 391  * Exit gracefully, clearing the utmp entry and restoring tty attributes
 392  * TODO: if debugging, this should free up any known resources if we can
 393  */
 394 static XErrorHandler old_xerror_handler;
 395
 396 static void
 397 rxvt_emergency_cleanup ()
 398 {
 399   for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
 400     (*t)->emergency_cleanup ();
 401 }
 402
 403 #if !ENABLE_MINIMAL
 404 static void
 405 print_x_error (Display *dpy, XErrorEvent *event)
 406 {
 407     char buffer[BUFSIZ];
 408     char mesg[BUFSIZ];
 409     char number[32];
 410     char *mtype = "XlibMessage";
 411     XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
 412     XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
 413     rxvt_warn ("An X Error occured, trying to continue after report.\n");
 414     rxvt_warn ("%s:  %s\n", mesg, buffer);
 415     XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d", mesg, BUFSIZ);
 416     rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->request_code);
 417     sprintf(number, "%d", event->request_code);
 418     XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
 419     rxvt_warn ("(which is %s)\n", buffer);
 420     if (event->request_code >= 128) {
 421         XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
 422                               mesg, BUFSIZ);
 423         rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->minor_code);
 424     }
 425     if ((event->error_code == BadWindow) ||
 426                (event->error_code == BadPixmap) ||
 427                (event->error_code == BadCursor) ||
 428                (event->error_code == BadFont) ||
 429                (event->error_code == BadDrawable) ||
 430                (event->error_code == BadColor) ||
 431                (event->error_code == BadGC) ||
 432                (event->error_code == BadIDChoice) ||
 433                (event->error_code == BadValue) ||
 434                (event->error_code == BadAtom)) {
 435         if (event->error_code == BadValue)
 436             XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
 437                                   mesg, BUFSIZ);
 438         else if (event->error_code == BadAtom)
 439             XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
 440                                   mesg, BUFSIZ);
 441         else
 442             XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
 443                                   mesg, BUFSIZ);
 444         rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->resourceid);
 445     }
 446     XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
 447                           mesg, BUFSIZ);
 448     rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->serial);
 449 }
 450 #endif
 451
 452 int
 453 rxvt_xerror_handler (Display *display, XErrorEvent *event)
 454 {
 455   if (GET_R->allowedxerror == -1)
 456     GET_R->allowedxerror = event->error_code;
 457   else
 458     {
 459       // GET_R is most likely not the terminal which caused the error,
 460       // so just output the error and continue
 461 #if ENABLE_MINIMAL
 462       old_xerror_handler (display, event);
 463 #else
 464       print_x_error (display, event);
 465 #endif
 466     }
 467
 468   return 0;
 469 }
 470
 471 int
 472 rxvt_xioerror_handler (Display *display)
 473 {
 474   rxvt_warn ("X connection to '%s' broken, unable to recover, exiting.\n",
 475              DisplayString (display));
 476   rxvt_emergency_cleanup ();
 477   _exit (EXIT_FAILURE);
 478 }
 479
 480 /*----------------------------------------------------------------------*/
 481 bool
 482 rxvt_term::init (int argc, const char *const *argv, stringvec *envv)
 483 {
 484   this->envv = envv;
 485
 486   SET_R (this);
 487   set_locale ("");
 488   set_environ (envv); // few things in X do not call setlocale :(
 489
 490   if (!init_vars ())
 491     return false;
 492
 493   init_secondary ();
 494
 495   const char **cmd_argv = init_resources (argc, argv);
 496
 497 #ifdef KEYSYM_RESOURCE
 498   keyboard->register_done ();
 499 #endif
 500
 501 #ifdef HAVE_SCROLLBARS
 502   if (option (Opt_scrollBar))
 503     scrollBar.setIdle ();    /* set existence for size calculations */
 504 #endif
 505
 506   pty = ptytty::create ();
 507
 508   create_windows (argc, argv);
 509
 510   init_xlocale ();
 511
 512   scr_reset (); // initialize screen
 513
 514 #if 0
 515   XSynchronize (dpy, True);
 516 #endif
 517
 518 #ifdef HAVE_SCROLLBARS
 519   if (option (Opt_scrollBar))
 520     resize_scrollbar ();      /* create and map scrollbar */
 521 #endif
 522 #ifdef HAVE_BG_PIXMAP
 523   {
 524     bgPixmap.set_target (this);
 525
 526 #ifdef ENABLE_TRANSPARENCY
 527     if (option (Opt_transparent))
 528       {
 529         bgPixmap.set_transparent ();
 530 #ifdef HAVE_AFTERIMAGE
 531         if (rs [Rs_blurradius])
 532           bgPixmap.set_blur_radius (rs [Rs_blurradius]);
 533 #endif
 534         if (ISSET_PIXCOLOR (Color_tint))
 535           bgPixmap.set_tint (pix_colors_focused [Color_tint]);
 536         if (rs [Rs_shade])
 537           bgPixmap.set_shade (rs [Rs_shade]);
 538
 539         bgPixmap.set_root_pixmap ();
 540         XSelectInput (dpy, display->root, PropertyChangeMask);
 541         rootwin_ev.start (display, display->root);
 542       }
 543 #endif
 544
 545 #ifdef BG_IMAGE_FROM_FILE
 546     if (rs[Rs_backgroundPixmap] != NULL)
 547       {
 548         const char *p = rs[Rs_backgroundPixmap];
 549
 550         if ((p = strchr (p, ';')) != NULL)
 551           {
 552             p++;
 553             bgPixmap.set_geometry (p);
 554           }
 555         else
 556           bgPixmap.set_defaultGeometry ();
 557
 558         if (bgPixmap.set_file (rs[Rs_backgroundPixmap]))
 559           if (!bgPixmap.window_position_sensitive ())
 560             update_background ();
 561       }
 562 #endif
 563   }
 564 #endif
 565
 566 #if ENABLE_PERL
 567   rootwin_ev.start (display, display->root);
 568 #endif
 569
 570   set_colorfgbg ();
 571
 572   init_command (cmd_argv);
 573
 574   free (cmd_argv);
 575
 576   if (pty->pty >= 0)
 577     pty_ev.start (pty->pty, ev::READ);
 578
 579   prepare_ev.start ();
 580
 581   HOOK_INVOKE ((this, HOOK_START, DT_END));
 582
 583 #if ENABLE_XEMBED
 584   if (rs[Rs_embed])
 585     {
 586       long info[2] = { 0, XEMBED_MAPPED };
 587
 588       XChangeProperty (dpy, parent[0], xa[XA_XEMBED_INFO], xa[XA_XEMBED_INFO],
 589                        32, PropModeReplace, (unsigned char *)&info, 2);
 590     }
 591 #endif
 592
 593   XMapWindow (dpy, vt);
 594   XMapWindow (dpy, parent[0]);
 595
 596   return true;
 597 }
 598
 599 static struct sig_handlers
 600 {
 601   ev::sig sw_term, sw_int;
 602
 603   /*
 604    * Catch a fatal signal and tidy up before quitting
 605    */
 606   void
 607   sig_term (ev::sig &w, int revents)
 608   {
 609     rxvt_emergency_cleanup ();
 610     w.stop ();
 611     kill (getpid (), w.signum);
 612   }
 613
 614   sig_handlers ()
 615   : sw_term (this, &sig_handlers::sig_term),
 616     sw_int  (this, &sig_handlers::sig_term)
 617   {
 618   }
 619 } sig_handlers;
 620
 621 char **rxvt_environ; // startup environment
 622
 623 void
 624 rxvt_init ()
 625 {
 626   ptytty::init ();
 627
 628   if (!ev_default_loop (0))
 629     rxvt_fatal ("cannot initialise libev (bad value for LIBEV_METHODS?)\n");
 630
 631   rxvt_environ = environ;
 632
 633   signal (SIGHUP,  SIG_IGN);
 634   signal (SIGPIPE, SIG_IGN);
 635
 636   sig_handlers.sw_term.start (SIGTERM); ev_unref ();
 637   sig_handlers.sw_int.start  (SIGINT);  ev_unref ();
 638
 639   /* need to trap SIGURG for SVR4 (Unixware) rlogin */
 640   /* signal (SIGURG, SIG_DFL); */
 641
 642   old_xerror_handler = XSetErrorHandler ((XErrorHandler) rxvt_xerror_handler);
 643   // TODO: handle this with exceptions and tolerate the memory loss
 644   XSetIOErrorHandler (rxvt_xioerror_handler);
 645
 646   XrmInitialize ();
 647 }
 648
 649 /* ------------------------------------------------------------------------- *
 650  *                         MEMORY ALLOCATION WRAPPERS                        *
 651  * ------------------------------------------------------------------------- */
 652 void *
 653 rxvt_malloc (size_t size)
 654 {
 655   void *p = malloc (size);
 656
 657   if (!p)
 658     rxvt_fatal ("memory allocation failure. aborting.\n");
 659
 660   return p;
 661 }
 662
 663 void *
 664 rxvt_calloc (size_t number, size_t size)
 665 {
 666   void *p = calloc (number, size);
 667
 668   if (!p)
 669     rxvt_fatal ("memory allocation failure. aborting.\n");
 670
 671   return p;
 672 }
 673
 674 void *
 675 rxvt_realloc (void *ptr, size_t size)
 676 {
 677   void *p = realloc (ptr, size);
 678
 679   if (!p)
 680     rxvt_fatal ("memory allocation failure. aborting.\n");
 681
 682   return p;
 683 }
 684
 685 /*----------------------------------------------------------------------*/
 686 /*
 687  * window size/position calculations for XSizeHint and other storage.
 688  * if width/height are non-zero then override calculated width/height
 689  */
 690 void
 691 rxvt_term::window_calc (unsigned int newwidth, unsigned int newheight)
 692 {
 693   short recalc_x, recalc_y;
 694   int x, y, sb_w, flags;
 695   unsigned int w, h;
 696   unsigned int max_width, max_height;
 697
 698   szHint.flags = PMinSize | PResizeInc | PBaseSize | PWinGravity;
 699   szHint.win_gravity = NorthWestGravity;
 700   /* szHint.min_aspect.x = szHint.min_aspect.y = 1; */
 701
 702   recalc_x = recalc_y = 0;
 703   flags = 0;
 704
 705   if (!parsed_geometry)
 706     {
 707       parsed_geometry = 1;
 708
 709       if (rs[Rs_geometry])
 710         flags = XParseGeometry (rs[Rs_geometry], &x, &y, &w, &h);
 711
 712       if (flags & WidthValue)
 713         {
 714           ncol = clamp (w, 0, std::numeric_limits<int16_t>::max ());
 715           szHint.flags |= USSize;
 716         }
 717
 718       if (flags & HeightValue)
 719         {
 720           nrow = clamp (h, 0, std::numeric_limits<int16_t>::max ());
 721           szHint.flags |= USSize;
 722         }
 723
 724       if (flags & XValue)
 725         {
 726           szHint.x = x;
 727           szHint.flags |= USPosition;
 728
 729           if (flags & XNegative)
 730             {
 731               recalc_x = 1;
 732               szHint.win_gravity = NorthEastGravity;
 733             }
 734         }
 735
 736       if (flags & YValue)
 737         {
 738           szHint.y = y;
 739           szHint.flags |= USPosition;
 740
 741           if (flags & YNegative)
 742             {
 743               recalc_y = 1;
 744
 745               if (szHint.win_gravity == NorthEastGravity)
 746                 szHint.win_gravity = SouthEastGravity;
 747               else
 748                 szHint.win_gravity = SouthWestGravity;
 749             }
 750         }
 751     }
 752
 753   /* TODO: BOUNDS */
 754   width = ncol * fwidth;
 755   height = nrow * fheight;
 756   max_width = MAX_COLS * fwidth;
 757   max_height = MAX_ROWS * fheight;
 758
 759   szHint.base_width = szHint.base_height = 2 * int_bwidth;
 760
 761   sb_w = 0;
 762   window_vt_x = window_vt_y = int_bwidth;
 763
 764   if (scrollBar.state)
 765     {
 766       sb_w = scrollbar_TotalWidth ();
 767       szHint.base_width += sb_w;
 768
 769       if (!option (Opt_scrollBar_right))
 770         window_vt_x += sb_w;
 771     }
 772
 773   szHint.width_inc  = fwidth;
 774   szHint.height_inc = fheight;
 775   szHint.min_width  = szHint.base_width + szHint.width_inc;
 776   szHint.min_height = szHint.base_height + szHint.height_inc;
 777
 778   if (newwidth && newwidth - szHint.base_width < max_width)
 779     {
 780       szHint.width = newwidth;
 781       width = newwidth - szHint.base_width;
 782     }
 783   else
 784     {
 785       min_it (width, max_width);
 786       szHint.width = szHint.base_width + width;
 787     }
 788
 789   if (newheight && newheight - szHint.base_height < max_height)
 790     {
 791       szHint.height = newheight;
 792       height = newheight - szHint.base_height;
 793     }
 794   else
 795     {
 796       min_it (height, max_height);
 797       szHint.height = szHint.base_height + height;
 798     }
 799
 800   if (scrollBar.state && option (Opt_scrollBar_right))
 801     window_sb_x = szHint.width - sb_w;
 802
 803   if (recalc_x)
 804     szHint.x += DisplayWidth  (dpy, display->screen) - szHint.width  - 2 * ext_bwidth;
 805
 806   if (recalc_y)
 807     szHint.y += DisplayHeight (dpy, display->screen) - szHint.height - 2 * ext_bwidth;
 808
 809   ncol = width / fwidth;
 810   nrow = height / fheight;
 811 }
 812
 813 /*----------------------------------------------------------------------*/
 814 /*
 815  * Tell the teletype handler what size the window is.
 816  * Called after a window size change.
 817  */
 818 void
 819 rxvt_term::tt_winch ()
 820 {
 821   if (pty->pty < 0)
 822     return;
 823
 824   struct winsize ws;
 825
 826   ws.ws_col = ncol;
 827   ws.ws_row = nrow;
 828   ws.ws_xpixel = width;
 829   ws.ws_ypixel = height;
 830   (void)ioctl (pty->pty, TIOCSWINSZ, &ws);
 831
 832 #if 0
 833   // TIOCSWINSZ⎈ is supposed to do this automatically and correctly
 834   if (cmd_pid)               /* force through to the command */
 835     kill (-cmd_pid, SIGWINCH);
 836 #endif
 837 }
 838
 839 /*----------------------------------------------------------------------*/
 840 /* set_fonts () - load and set the various fonts
 841  *
 842  * init = 1   - initialize
 843  *
 844  * fontname == FONT_UP  - switch to bigger font
 845  * fontname == FONT_DN  - switch to smaller font
 846  */
 847 bool
 848 rxvt_term::set_fonts ()
 849 {
 850   rxvt_fontset *fs = new rxvt_fontset (this);
 851   rxvt_fontprop prop;
 852
 853   if (!fs
 854       || !fs->populate (rs[Rs_font] ? rs[Rs_font] : "fixed")
 855       || !fs->realize_font (1))
 856     {
 857       delete fs;
 858       return false;
 859     }
 860
 861 #if ENABLE_STYLES
 862   for (int i = RS_styleCount; --i; )
 863     if (fontset[i] != fontset[0])
 864       delete fontset[i];
 865 #endif
 866
 867   delete fontset[0];
 868   fontset[0] = fs;
 869
 870   prop = (*fs)[1]->properties ();
 871   prop.height += lineSpace;
 872
 873   fs->set_prop (prop, false);
 874
 875   fwidth  = prop.width;
 876   fheight = prop.height;
 877   fbase   = prop.ascent;
 878
 879   for (int style = 1; style < 4; style++)
 880     {
 881 #if ENABLE_STYLES
 882       const char *res = rs[Rs_font + style];
 883
 884       if (res && !*res)
 885         fontset[style] = fontset[0];
 886       else
 887         {
 888           fontset[style] = fs = new rxvt_fontset (this);
 889           rxvt_fontprop prop2 = prop;
 890
 891           if (res)
 892             {
 893               fs->populate (res);
 894               fs->set_prop (prop2, false);
 895             }
 896           else
 897             {
 898               fs->populate (fontset[0]->fontdesc);
 899
 900               if (SET_STYLE (0, style) & RS_Bold)   prop2.weight = rxvt_fontprop::bold;
 901               if (SET_STYLE (0, style) & RS_Italic) prop2.slant  = rxvt_fontprop::italic;
 902
 903               fs->set_prop (prop2, true);
 904             }
 905
 906         }
 907 #else
 908       fontset[style] = fontset[0];
 909 #endif
 910     }
 911
 912   if (parent[0])
 913     {
 914       resize_all_windows (0, 0, 0);
 915       scr_remap_chars ();
 916       scr_touch (true);
 917     }
 918
 919   return true;
 920 }
 921
 922 void
 923 rxvt_term::set_string_property (Atom prop, const char *str, int len)
 924 {
 925   XChangeProperty (dpy, parent[0],
 926                    prop, XA_STRING, 8, PropModeReplace,
 927                    (const unsigned char *)str, len >= 0 ? len : strlen (str));
 928 }
 929
 930 void
 931 rxvt_term::set_utf8_property (Atom prop, const char *str, int len)
 932 {
 933   wchar_t *ws = rxvt_mbstowcs (str, len);
 934   char *s = rxvt_wcstoutf8 (ws);
 935
 936   XChangeProperty (dpy, parent[0],
 937                    prop, xa[XA_UTF8_STRING], 8, PropModeReplace,
 938                    (const unsigned char *)s, strlen (s));
 939
 940   free (s);
 941   free (ws);
 942 }
 943
 944 /*----------------------------------------------------------------------*/
 945 /*----------------------------------------------------------------------*/
 946 /* xterm sequences - title, iconName, color (exptl) */
 947 void
 948 rxvt_term::set_title (const char *str)
 949 {
 950   set_string_property (XA_WM_NAME, str);
 951 #if ENABLE_EWMH
 952   set_utf8_property (xa[XA_NET_WM_NAME], str);
 953 #endif
 954 }
 955
 956 void
 957 rxvt_term::set_icon_name (const char *str)
 958 {
 959   set_string_property (XA_WM_ICON_NAME, str);
 960 #if ENABLE_EWMH
 961   set_utf8_property (xa[XA_NET_WM_ICON_NAME], str);
 962 #endif
 963 }
 964
 965 void
 966 rxvt_term::set_window_color (int idx, const char *color)
 967 {
 968 #ifdef XTERM_COLOR_CHANGE
 969   rxvt_color xcol;
 970   int i;
 971
 972   if (color == NULL || *color == '\0')
 973     return;
 974
 975   color = strdup (color);
 976   allocated.push_back ((void *)color);
 977   rs[Rs_color + idx] = color;
 978
 979   /* handle color aliases */
 980   if (isdigit (*color))
 981     {
 982       i = atoi (color);
 983
 984       if (i >= 8 && i <= 15)
 985         {
 986           /* bright colors */
 987           pix_colors_focused[idx] = pix_colors_focused[minBrightCOLOR + i - 8];
 988           goto done;
 989         }
 990
 991       if (i >= 0 && i <= 7)
 992         {
 993           /* normal colors */
 994           pix_colors_focused[idx] = pix_colors_focused[minCOLOR + i];
 995           goto done;
 996         }
 997     }
 998
 999   set_color (xcol, color);
1000
1001   /*
1002    * FIXME: should free colors here, but no idea how to do it so instead,
1003    * so just keep gobbling up the colormap
1004    */
1005
1006   pix_colors_focused[idx] = xcol;
1007
1008 done:
1009   /*TODO: handle Color_BD, scrollbar background, etc. */
1010
1011   update_fade_color (idx);
1012   recolour_cursor ();
1013   scr_recolour ();
1014 #endif /* XTERM_COLOR_CHANGE */
1015 }
1016
1017 void
1018 rxvt_term::recolour_cursor ()
1019 {
1020   XColor fg, bg;
1021
1022   (ISSET_PIXCOLOR (Color_pointer_fg)
1023      ? pix_colors_focused[Color_pointer_fg]
1024      : pix_colors_focused[Color_fg]).get (fg);
1025
1026   (ISSET_PIXCOLOR (Color_pointer_bg)
1027      ? pix_colors_focused[Color_pointer_bg]
1028      : pix_colors_focused[Color_bg]).get (bg);
1029
1030   XRecolorCursor (dpy, TermWin_cursor, &fg, &bg);
1031 }
1032
1033 /*----------------------------------------------------------------------*/
1034 /*
1035  * find if fg/bg matches any of the normal (low-intensity) colors
1036  */
1037 void
1038 rxvt_term::set_colorfgbg ()
1039 {
1040   unsigned int i;
1041   const char *xpmb = "";
1042   char fstr[sizeof ("default") + 1], bstr[sizeof ("default") + 1];
1043
1044   strcpy (fstr, "default");
1045   strcpy (bstr, "default");
1046   for (i = Color_Black; i <= Color_White; i++)
1047     if (pix_colors[Color_fg] == pix_colors[i])
1048       {
1049         sprintf (fstr, "%d", (i - Color_Black));
1050         break;
1051       }
1052
1053   for (i = Color_Black; i <= Color_White; i++)
1054     if (pix_colors[Color_bg] == pix_colors[i])
1055       {
1056         sprintf (bstr, "%d", (i - Color_Black));
1057 #ifdef BG_IMAGE_FROM_FILE
1058         xpmb = "default;";
1059 #endif
1060         break;
1061       }
1062
1063   sprintf (env_colorfgbg, "COLORFGBG=%s;%s%s", fstr, xpmb, bstr);
1064 }
1065
1066 /*----------------------------------------------------------------------*/
1067
1068 bool
1069 rxvt_term::set_color (rxvt_color &color, const char *name)
1070 {
1071   if (color.set (this, name))
1072     return true;
1073
1074   rxvt_warn ("can't get colour '%s', continuing without.\n", name);
1075   return false;
1076 }
1077
1078 void
1079 rxvt_term::alias_color (int dst, int src)
1080 {
1081   pix_colors[dst].set (this, rs[Rs_color + dst] = rs[Rs_color + src]);
1082 }
1083
1084 /* -------------------------------------------------------------------- *
1085  * -                         WINDOW RESIZING                          - *
1086  * -------------------------------------------------------------------- */
1087 void
1088 rxvt_term::resize_all_windows (unsigned int newwidth, unsigned int newheight, int ignoreparent)
1089 {
1090   int fix_screen;
1091   int old_width  = szHint.width;
1092   int old_height = szHint.height;
1093
1094   window_calc (newwidth, newheight);
1095
1096   if (!HOOK_INVOKE ((this, HOOK_RESIZE_ALL_WINDOWS, DT_INT, newwidth, DT_INT, newheight, DT_END)))
1097     XSetWMNormalHints (dpy, parent[0], &szHint);
1098
1099   if (!ignoreparent)
1100     {
1101 #ifdef SMART_RESIZE
1102       /*
1103        * resize by Marius Gedminas <marius.gedminas@uosis.mif.vu.lt>
1104        * reposition window on resize depending on placement on screen
1105        */
1106       int x, y, x1, y1;
1107       int dx, dy;
1108       unsigned int unused_w1, unused_h1, unused_b1, unused_d1;
1109       Window unused_cr;
1110
1111       XTranslateCoordinates (dpy, parent[0], display->root,
1112                              0, 0, &x, &y, &unused_cr);
1113       XGetGeometry (dpy, parent[0], &unused_cr, &x1, &y1,
1114                     &unused_w1, &unused_h1, &unused_b1, &unused_d1);
1115       /*
1116        * if display->root isn't the parent window, a WM will probably have offset
1117        * our position for handles and decorations.  Counter it
1118        */
1119       if (x1 != x || y1 != y)
1120         {
1121           x -= x1;
1122           y -= y1;
1123         }
1124
1125       x1 = (DisplayWidth  (dpy, display->screen) - old_width ) / 2;
1126       y1 = (DisplayHeight (dpy, display->screen) - old_height) / 2;
1127       dx = old_width  - szHint.width;
1128       dy = old_height - szHint.height;
1129
1130       /* Check position of the center of the window */
1131       if (x < x1)             /* left half */
1132         dx = 0;
1133       else if (x == x1)       /* exact center */
1134         dx /= 2;
1135       if (y < y1)             /* top half */
1136         dy = 0;
1137       else if (y == y1)       /* exact center */
1138         dy /= 2;
1139
1140       XMoveResizeWindow (dpy, parent[0], x + dx, y + dy,
1141                          szHint.width, szHint.height);
1142 #else
1143       XResizeWindow (dpy, parent[0], szHint.width, szHint.height);
1144 #endif
1145     }
1146
1147   fix_screen = ncol != prev_ncol || nrow != prev_nrow;
1148
1149   if (fix_screen || newwidth != old_width || newheight != old_height)
1150     {
1151       if (scrollBar.state)
1152         {
1153           XMoveResizeWindow (dpy, scrollBar.win,
1154                              window_sb_x, 0,
1155                              scrollbar_TotalWidth (), szHint.height);
1156           resize_scrollbar ();
1157         }
1158
1159       XMoveResizeWindow (dpy, vt,
1160                          window_vt_x, window_vt_y,
1161                          width, height);
1162
1163 #ifdef HAVE_BG_PIXMAP
1164       if (bgPixmap.window_size_sensitive ())
1165         update_background ();
1166 #endif
1167
1168       scr_clear ();
1169     }
1170
1171   if (fix_screen || old_height == 0)
1172     scr_reset ();
1173
1174   // TODO, with nvidia-8178, resizes kill the alpha channel, report if not fixed in newer version
1175   //scr_touch (false);
1176
1177 #ifdef HAVE_BG_PIXMAP
1178 //  TODO: this don't seem to have any effect - do we still need it ? If so - in which case exactly ?
1179 //  if (bgPixmap.pixmap)
1180 //    scr_touch (false);
1181 #endif
1182
1183 #ifdef USE_XIM
1184   IMSetPosition ();
1185 #endif
1186 }
1187
1188 /*
1189  * Set the width/height of the vt window in characters.  Units are pixels.
1190  * good for toggling 80/132 columns
1191  */
1192 void
1193 rxvt_term::set_widthheight (unsigned int newwidth, unsigned int newheight)
1194 {
1195   XWindowAttributes wattr;
1196
1197   if (newwidth == 0 || newheight == 0)
1198     {
1199       XGetWindowAttributes (dpy, display->root, &wattr);
1200
1201       if (newwidth == 0)
1202         newwidth = wattr.width - szHint.base_width;
1203       if (newheight == 0)
1204         newheight = wattr.height - szHint.base_height;
1205     }
1206
1207   if (newwidth != width || newheight != height)
1208     {
1209       newwidth += szHint.base_width;
1210       newheight += szHint.base_height;
1211       resize_all_windows (newwidth, newheight, 0);
1212     }
1213 }
1214
1215 /* -------------------------------------------------------------------- *
1216  * -                      X INPUT METHOD ROUTINES                     - *
1217  * -------------------------------------------------------------------- */
1218 #ifdef USE_XIM
1219
1220 void
1221 rxvt_term::im_set_color (unsigned long &fg, unsigned long &bg)
1222 {
1223   fg = pix_colors [Color_fg];
1224   bg = pix_colors [Color_bg];
1225 }
1226
1227 void
1228 rxvt_term::im_set_size (XRectangle &size)
1229 {
1230   // the int_bwidth terms make no sense to me
1231   size.x      = int_bwidth;
1232   size.y      = int_bwidth;
1233   size.width  = Width2Pixel (ncol) + int_bwidth;
1234   size.height = Height2Pixel (nrow) + int_bwidth;
1235 }
1236
1237 void
1238 rxvt_term::im_set_preedit_area (XRectangle &preedit_rect,
1239                                 XRectangle &status_rect,
1240                                 const XRectangle &needed_rect)
1241 {
1242   preedit_rect.x      = needed_rect.width;
1243   preedit_rect.y      = 0;
1244   preedit_rect.width  = Width2Pixel (ncol) - needed_rect.width + 1;
1245   preedit_rect.height = fheight;
1246
1247   status_rect.x       = 0;
1248   status_rect.y       = 0;
1249   status_rect.width   = needed_rect.width ? needed_rect.width : Width2Pixel (ncol) + 1;
1250   status_rect.height  = fheight;
1251 }
1252
1253 /* Checking whether input method is running. */
1254 bool
1255 rxvt_term::IMisRunning ()
1256 {
1257   char *p;
1258   Atom atom;
1259   Window win;
1260   char server[IMBUFSIZ];
1261
1262   /* get current locale modifier */
1263   if ((p = XSetLocaleModifiers (NULL)) != NULL)
1264     {
1265       strcpy (server, "@server=");
1266       strncat (server, & (p[4]), IMBUFSIZ - 9); /* skip "@im=" */
1267
1268       if ((p = strchr (server + 1, '@')) != NULL)      /* first one only */
1269         *p = '\0';
1270
1271       atom = XInternAtom (dpy, server, False);
1272       win = XGetSelectionOwner (dpy, atom);
1273
1274       if (win != None)
1275         return True;
1276     }
1277
1278   return False;
1279 }
1280
1281 void
1282 rxvt_term::IMSendSpot ()
1283 {
1284   XPoint nspot;
1285   XVaNestedList preedit_attr;
1286
1287   if (!Input_Context
1288       || !focus
1289       || !(input_style & (XIMPreeditPosition | XIMPreeditCallbacks)))
1290     return;
1291
1292   im_set_position (nspot);
1293
1294   if (nspot.x == spot.x && nspot.y == spot.y)
1295     return;
1296
1297   spot = nspot;
1298
1299   preedit_attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
1300   XSetICValues (Input_Context, XNPreeditAttributes, preedit_attr, NULL);
1301   XFree (preedit_attr);
1302 }
1303
1304 void
1305 rxvt_term::im_destroy ()
1306 {
1307   if (input_method)
1308     {
1309       if (Input_Context && input_method->xim)
1310         XDestroyIC (Input_Context);
1311
1312       display->put_xim (input_method);
1313       input_method = 0;
1314     }
1315
1316   Input_Context = 0;
1317 }
1318
1319 #ifdef ENABLE_XIM_ONTHESPOT
1320
1321 static void
1322 xim_preedit_start (XIC ic, XPointer client_data, XPointer call_data)
1323 {
1324   ((rxvt_term *)client_data)->make_current ();
1325   HOOK_INVOKE (((rxvt_term *)client_data, HOOK_XIM_PREEDIT_START, DT_END));
1326 }
1327
1328 static void
1329 xim_preedit_done (XIC ic, XPointer client_data, XPointer call_data)
1330 {
1331   ((rxvt_term *)client_data)->make_current ();
1332   HOOK_INVOKE (((rxvt_term *)client_data, HOOK_XIM_PREEDIT_DONE, DT_END));
1333 }
1334
1335 static void
1336 xim_preedit_draw (XIC ic, XPointer client_data, XIMPreeditDrawCallbackStruct *call_data)
1337 {
1338   rxvt_term *term = (rxvt_term *)client_data;
1339   XIMText *text = call_data->text;
1340
1341   term->make_current ();
1342
1343   if (text)
1344     {
1345       void *str;
1346
1347       if (!text->encoding_is_wchar && text->string.multi_byte)
1348         {
1349           // of course, X makes it ugly again
1350           if (term->rs[Rs_imLocale])
1351             SET_LOCALE (term->rs[Rs_imLocale]);
1352
1353           str = rxvt_temp_buf ((text->length + 1) * sizeof (wchar_t));
1354           mbstowcs ((wchar_t *)str, text->string.multi_byte, text->length + 1);
1355
1356           if (term->rs[Rs_imLocale])
1357             SET_LOCALE (term->locale);
1358         }
1359       else
1360         str = (void *)text->string.wide_char;
1361
1362       HOOK_INVOKE ((term, HOOK_XIM_PREEDIT_DRAW,
1363                     DT_INT, call_data->caret,
1364                     DT_INT, call_data->chg_first,
1365                     DT_INT, call_data->chg_length,
1366                     DT_LCS_LEN, (void *)text->feedback, text->feedback ? (int)text->length : 0,
1367                     DT_WCS_LEN, str, str ? (int)text->length : 0,
1368                     DT_END));
1369     }
1370   else
1371     HOOK_INVOKE ((term, HOOK_XIM_PREEDIT_DRAW,
1372                   DT_INT, call_data->caret,
1373                   DT_INT, call_data->chg_first,
1374                   DT_INT, call_data->chg_length,
1375                   DT_END));
1376 }
1377
1378 #if 0
1379 static void
1380 xim_preedit_caret (XIC ic, XPointer client_data, XIMPreeditCaretCallbackStruct *call_data)
1381 {
1382   ((rxvt_term *)client_data)->make_current ();
1383   HOOK_INVOKE (((rxvt_term *)client_data, HOOK_XIM_PREEDIT_CARET,
1384                 DT_INT, call_data->position,
1385                 DT_INT, call_data->direction,
1386                 DT_INT, call_data->style,
1387                 DT_END));
1388 }
1389 #endif
1390
1391 #endif
1392
1393 /*
1394  * Try to open a XIM with the current modifiers, then see if we can
1395  * open a suitable preedit type
1396  */
1397 bool
1398 rxvt_term::IM_get_IC (const char *modifiers)
1399 {
1400   int i, j, found;
1401   XIM xim;
1402   XPoint spot;
1403   XRectangle rect, status_rect, needed_rect;
1404   unsigned long fg, bg;
1405   const char *p;
1406   char **s;
1407   XIMStyles *xim_styles;
1408 #ifdef ENABLE_XIM_ONTHESPOT
1409   XIMCallback xcb[4];
1410 #endif
1411
1412   set_environ (envv);
1413
1414   if (! ((p = XSetLocaleModifiers (modifiers)) && *p))
1415     return false;
1416
1417   input_method = display->get_xim (locale, modifiers);
1418   if (input_method == NULL)
1419     return false;
1420
1421   xim = input_method->xim;
1422   spot.x = spot.y = -1;
1423
1424   xim_styles = NULL;
1425   if (XGetIMValues (xim, XNQueryInputStyle, &xim_styles, NULL)
1426       || !xim_styles || !xim_styles->count_styles)
1427     {
1428       im_destroy ();
1429       return false;
1430     }
1431
1432   const char *pet[] = { rs[Rs_preeditType], "OverTheSpot,OffTheSpot,Root,None" };
1433
1434   for (int pi = 0; pi < 2; pi++)
1435     {
1436       p = pet[pi];
1437
1438       if (!p)
1439         continue;
1440
1441       s = rxvt_splitcommastring (p);
1442
1443       for (i = found = 0; !found && s[i]; i++)
1444         {
1445           if (!strcmp (s[i], "OverTheSpot"))
1446             input_style = XIMPreeditPosition | XIMStatusNothing;
1447           else if (!strcmp (s[i], "OffTheSpot"))
1448             input_style = XIMPreeditArea | XIMStatusArea;
1449           else if (!strcmp (s[i], "Root"))
1450             input_style = XIMPreeditNothing | XIMStatusNothing;
1451           else if (!strcmp (s[i], "None"))
1452             input_style = XIMPreeditNone | XIMStatusNone;
1453 #ifdef ENABLE_XIM_ONTHESPOT
1454           else if (SHOULD_INVOKE (HOOK_XIM_PREEDIT_START) && !strcmp (s[i], "OnTheSpot"))
1455             input_style = XIMPreeditCallbacks | XIMStatusNothing;
1456 #endif
1457           else
1458             input_style = XIMPreeditNothing | XIMStatusNothing;
1459
1460           for (j = 0; j < xim_styles->count_styles; j++)
1461             if (input_style == xim_styles->supported_styles[j])
1462               {
1463                 rxvt_freecommastring (s);
1464
1465                 found = 1;
1466                 goto foundpet;
1467               }
1468
1469         }
1470
1471       rxvt_freecommastring (s);
1472     }
1473
1474 foundpet:
1475
1476   XFree (xim_styles);
1477
1478   if (!found)
1479     {
1480       im_destroy ();
1481       return false;
1482     }
1483
1484   XFontSet fs = 0;
1485   XVaNestedList preedit_attr = 0, status_attr = 0;
1486
1487   if (input_style & (XIMPreeditPosition | XIMPreeditArea))
1488     {
1489       // fake us a font-set, please
1490       char **missing_charset_list;
1491       int missing_charset_count;
1492       char *def_string;
1493       char pat[512];
1494
1495       sprintf (pat,
1496                "-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
1497                "-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
1498                "-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
1499                "-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
1500                "-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
1501                "*",
1502                fheight,
1503                fheight + 1, fheight - 1,
1504                fheight - 2, fheight + 2);
1505
1506       fs = XCreateFontSet (dpy, rs[Rs_imFont] ? rs[Rs_imFont] : pat,
1507                            &missing_charset_list, &missing_charset_count, &def_string);
1508
1509       if (missing_charset_list)
1510         XFreeStringList (missing_charset_list);
1511
1512       if (!fs)
1513         {
1514           input_style &= ~(XIMPreeditPosition | XIMPreeditArea);
1515           rxvt_warn ("unable to create fontset for input method, try \"-pt Root\". Continuing.\n");
1516         }
1517     }
1518
1519   if (input_style & XIMPreeditPosition)
1520     {
1521       im_set_size (rect);
1522       im_set_position (spot);
1523       im_set_color (fg, bg);
1524
1525       preedit_attr = XVaCreateNestedList (0,
1526                                           XNForeground, fg,
1527                                           XNBackground, bg,
1528                                           XNArea, &rect,
1529                                           XNSpotLocation, &spot,
1530                                           XNFontSet, fs,
1531                                           NULL);
1532     }
1533   else if (input_style & XIMPreeditArea)
1534     {
1535       im_set_color (fg, bg);
1536
1537       /*
1538        * The necessary width of preedit area is unknown
1539        * until create input context.
1540        */
1541       needed_rect.width = 0;
1542       im_set_preedit_area (rect, status_rect, needed_rect);
1543
1544       preedit_attr = XVaCreateNestedList (0,
1545                                           XNForeground, fg,
1546                                           XNBackground, bg,
1547                                           XNArea, &rect,
1548                                           XNFontSet, fs,
1549                                           NULL);
1550       status_attr = XVaCreateNestedList (0,
1551                                          XNForeground, fg,
1552                                          XNBackground, bg,
1553                                          XNArea, &status_rect,
1554                                          XNFontSet, fs,
1555                                          NULL);
1556     }
1557 #if ENABLE_XIM_ONTHESPOT
1558   else if (input_style & XIMPreeditCallbacks)
1559     {
1560       im_set_position (spot);
1561
1562       xcb[0].client_data = (XPointer)this; xcb[0].callback = (XIMProc)xim_preedit_start;
1563       xcb[1].client_data = (XPointer)this; xcb[1].callback = (XIMProc)xim_preedit_done;
1564       xcb[2].client_data = (XPointer)this; xcb[2].callback = (XIMProc)xim_preedit_draw;
1565 # if 0
1566       xcb[3].client_data = (XPointer)this; xcb[3].callback = (XIMProc)xim_preedit_caret;
1567 # endif
1568
1569       preedit_attr = XVaCreateNestedList (0,
1570                                           XNSpotLocation, &spot,
1571                                           XNPreeditStartCallback, &xcb[0],
1572                                           XNPreeditDoneCallback , &xcb[1],
1573                                           XNPreeditDrawCallback , &xcb[2],
1574 # if 0
1575                                           XNPreeditCaretCallback, &xcb[3],
1576 # endif
1577                                           NULL);
1578     }
1579 #endif
1580
1581   Input_Context = XCreateIC (xim,
1582                              XNInputStyle, input_style,
1583                              XNClientWindow, vt,
1584                              XNFocusWindow, parent[0],
1585                              preedit_attr ? XNPreeditAttributes : NULL,
1586                              preedit_attr,
1587                              status_attr ? XNStatusAttributes : NULL,
1588                              status_attr, NULL);
1589
1590   if (preedit_attr) XFree (preedit_attr);
1591   if (status_attr)  XFree (status_attr);
1592   if (fs)           XFreeFontSet (dpy, fs);
1593
1594   if (Input_Context == NULL)
1595     {
1596       rxvt_warn ("failed to create input context, continuing without XIM.\n");
1597       im_destroy ();
1598       return false;
1599     }
1600
1601 #if 0
1602   // unfortunately, only the focus window is used by XIM, hard to fix
1603   if (!XGetICValues (Input_Context, XNFilterEvents, &vt_emask_xim, NULL))
1604     vt_select_input ();
1605 #endif
1606
1607   IMSetPosition ();
1608
1609   return true;
1610 }
1611
1612 void
1613 rxvt_term::im_cb ()
1614 {
1615   int i;
1616   const char *p;
1617   char **s;
1618   char buf[IMBUFSIZ];
1619
1620   make_current ();
1621
1622   im_destroy ();
1623
1624   if (Input_Context)
1625     return;
1626
1627 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1628   if (rs[Rs_imLocale])
1629     SET_LOCALE (rs[Rs_imLocale]);
1630 #endif
1631
1632   p = rs[Rs_inputMethod];
1633   if (p && *p)
1634     {
1635       bool found = false;
1636
1637       s = rxvt_splitcommastring (p);
1638
1639       for (i = 0; s[i]; i++)
1640         {
1641           if (*s[i])
1642             {
1643               strcpy (buf, "@im=");
1644               strncat (buf, s[i], IMBUFSIZ - 5);
1645               if (IM_get_IC (buf))
1646                 {
1647                   found = true;
1648                   break;
1649                 }
1650             }
1651         }
1652
1653       rxvt_freecommastring (s);
1654
1655       if (found)
1656         goto done;
1657     }
1658
1659   /* try with XMODIFIERS env. var. */
1660   if (IM_get_IC (""))
1661     goto done;
1662
1663   /* try with no modifiers base IF the user didn't specify an IM */
1664   if (IM_get_IC ("@im=none"))
1665     goto done;
1666
1667 done:
1668 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1669   if (rs[Rs_imLocale])
1670     SET_LOCALE (locale);
1671 #endif
1672 }
1673
1674 void
1675 rxvt_term::IMSetPosition ()
1676 {
1677   XRectangle preedit_rect, status_rect, *needed_rect;
1678   XVaNestedList preedit_attr, status_attr;
1679
1680   if (!Input_Context
1681       || !focus
1682       || !(input_style & (XIMPreeditArea | XIMPreeditPosition))
1683       || !IMisRunning ())
1684     return;
1685
1686   if (input_style & XIMPreeditPosition)
1687     {
1688       im_set_size (preedit_rect);
1689       preedit_attr = XVaCreateNestedList (0, XNArea, &preedit_rect, NULL);
1690
1691       XSetICValues (Input_Context,
1692                     XNPreeditAttributes, preedit_attr, NULL);
1693     }
1694   else
1695     {
1696       /* Getting the necessary width of preedit area */
1697       status_attr = XVaCreateNestedList (0, XNAreaNeeded, &needed_rect, NULL);
1698       XGetICValues (Input_Context, XNStatusAttributes, status_attr, NULL);
1699       XFree (status_attr);
1700
1701       im_set_preedit_area (preedit_rect, status_rect, *needed_rect);
1702       XFree (needed_rect);
1703
1704       preedit_attr = XVaCreateNestedList (0, XNArea, &preedit_rect, NULL);
1705       status_attr  = XVaCreateNestedList (0, XNArea, &status_rect,  NULL);
1706
1707       XSetICValues (Input_Context,
1708                     XNPreeditAttributes, preedit_attr,
1709                     XNStatusAttributes,  status_attr,
1710                     NULL);
1711
1712       XFree (status_attr);
1713     }
1714
1715    XFree (preedit_attr);
1716 }
1717 #endif /* USE_XIM */
1718
1719 void
1720 rxvt_term::get_window_origin (int &x, int &y)
1721 {
1722   Window cr;
1723   XTranslateCoordinates (dpy, parent[0], display->root, 0, 0, &x, &y, &cr);
1724 /*  fprintf( stderr, "origin is %+d%+d\n", x, y);*/
1725 }
1726
1727 Pixmap
1728 rxvt_term::get_pixmap_property (int prop_id)
1729 {
1730   if (prop_id > 0 && prop_id < NUM_XA)
1731     if (xa[prop_id])
1732       {
1733         int aformat;
1734         unsigned long nitems, bytes_after;
1735         Atom atype;
1736         unsigned char *prop = NULL;
1737         int result = XGetWindowProperty (dpy, display->root, xa[prop_id],
1738                                          0L, 1L, False, XA_PIXMAP, &atype, &aformat,
1739                                          &nitems, &bytes_after, &prop);
1740         if (result == Success && prop && atype == XA_PIXMAP)
1741           {
1742             return *(Pixmap *)prop;
1743           }
1744       }
1745   return None;
1746 }
1747
1748 #ifdef HAVE_BG_PIXMAP
1749 # if TRACE_PIXMAPS
1750 #  undef update_background
1751 int rxvt_term::trace_update_background (const char *file, int line)
1752 {
1753   fprintf (stderr, "%s:%d:update_background()\n", file, line);
1754   update_background ();
1755 }
1756 # endif
1757
1758 int
1759 rxvt_term::update_background ()
1760 {
1761   bgPixmap.invalidate ();
1762
1763   /* no chance of real time refresh if we are blurring! */
1764   if (bgPixmap.invalid_since + 0.5 < ev::now () && !(bgPixmap.flags & bgPixmap_t::blurNeeded))
1765     bgPixmap.render ();
1766   else
1767     {
1768       update_background_ev.stop ();
1769
1770       if (!bgPixmap.need_client_side_rendering())
1771         update_background_ev.start (.05);
1772       else if (bgPixmap.flags & bgPixmap_t::blurNeeded)
1773         update_background_ev.start (.20); /* very slow !!! */
1774       else
1775         update_background_ev.start (.07);
1776     }
1777
1778   return 0;
1779 }
1780
1781 void
1782 rxvt_term::update_background_cb (ev::timer &w, int revents)
1783 {
1784   bgPixmap.render ();
1785 }
1786
1787 #endif /* HAVE_BG_PIXMAP */
1788
1789 /*----------------------- end-of-file (C source) -----------------------*/