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