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