src/main.C

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