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