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-2004 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 "main.intpro"          /* PROTOS for internal routines */
  36
  37 #include <signal.h>
  38
  39 #ifdef TTY_GID_SUPPORT
  40 # include <grp.h>
  41 #endif
  42
  43 #ifdef HAVE_TERMIOS_H
  44 # include <termios.h>
  45 #endif
  46
  47 #include <cstring>
  48
  49 static char curlocale[128];
  50
  51 void
  52 rxvt_set_locale (const char *locale)
  53 {
  54   if (locale && STRNCMP (locale, curlocale, 128))
  55     {
  56       STRNCPY (curlocale, locale, 128);
  57       setlocale (LC_CTYPE, curlocale);
  58     }
  59 }
  60
  61 void *
  62 rxvt_term::operator new (size_t s)
  63 {
  64   void *p = malloc (s);
  65
  66   MEMSET (p, 0, s);
  67   return p;
  68 }
  69
  70 void
  71 rxvt_term::operator delete (void *p, size_t s)
  72 {
  73   free (p);
  74 }
  75
  76 rxvt_term::rxvt_term ()
  77     :
  78     rootwin_ev (this, &rxvt_term::rootwin_cb),
  79     termwin_ev (this, &rxvt_term::x_cb),
  80     vt_ev (this, &rxvt_term::x_cb),
  81 #ifdef HAVE_SCROLLBARS
  82     scrollbar_ev (this, &rxvt_term::x_cb),
  83 #endif
  84 #ifdef MENUBAR
  85     menubar_ev (this, &rxvt_term::x_cb), fixme
  86 #endif
  87 #ifdef CURSOR_BLINK
  88     cursor_blink_ev (this, &rxvt_term::cursor_blink_cb),
  89 #endif
  90 #ifdef TEXT_BLINK
  91     text_blink_ev (this, &rxvt_term::text_blink_cb),
  92 #endif
  93 #ifdef POINTER_BLANK
  94     pointer_ev (this, &rxvt_term::pointer_cb),
  95 #endif
  96 #ifdef USE_XIM
  97     im_ev (this, &rxvt_term::im_cb),
  98 #endif
  99     check_ev (this, &rxvt_term::check_cb),
 100     destroy_ev (this, &rxvt_term::destroy_cb),
 101     pty_ev (this, &rxvt_term::pty_cb),
 102     incr_ev (this, &rxvt_term::incr_cb)
 103 {
 104   cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;
 105 }
 106
 107 rxvt_term::~rxvt_term ()
 108 {
 109   if (cmd_fd >= 0)
 110     close (cmd_fd);
 111
 112 #ifndef NO_SETOWNER_TTYDEV
 113   privileged_ttydev (RESTORE);
 114 #endif
 115 #ifdef UTMP_SUPPORT
 116   privileged_utmp (RESTORE);
 117 #endif
 118
 119   delete TermWin.fontset;
 120
 121   if (display)
 122     if (TermWin.parent[0])
 123       XDestroyWindow (display->display, TermWin.parent[0]);
 124
 125   // TODO: free pixcolours, colours should become part of rxvt_display
 126
 127   delete PixColors;
 128
 129   displays.put (display);
 130
 131   scr_release ();
 132
 133   free (env_windowid);
 134   free (env_display);
 135   free (env_term);
 136   free (env_colorfgbg);
 137   free (locale);
 138   free (codeset);
 139
 140   delete envv;
 141   delete argv;
 142 }
 143
 144 void
 145 rxvt_term::destroy ()
 146 {
 147   if (display)
 148     {
 149       rootwin_ev.stop (display);
 150       termwin_ev.stop (display);
 151       vt_ev.stop (display);
 152 #ifdef USE_XIM
 153       im_destroy ();
 154       im_ev.stop (display);
 155 #endif
 156 #ifdef HAVE_SCROLLBARS
 157       scrollbar_ev.stop (display);
 158 #endif
 159 #ifdef MENUBAR
 160       menubar_ev.stop (display);
 161 #endif
 162     }
 163
 164   check_ev.stop ();
 165   pty_ev.stop ();
 166 #ifdef CURSOR_BLINK
 167   cursor_blink_ev.stop ();
 168 #endif
 169 #ifdef TEXT_BLINK
 170   text_blink_ev.stop ();
 171 #endif
 172 #ifdef POINTER_BLANK
 173   pointer_ev.stop ();
 174 #endif
 175
 176   destroy_ev.start (0);
 177 }
 178
 179 void
 180 rxvt_term::destroy_cb (time_watcher &w)
 181 {
 182   SET_R (this);
 183
 184   delete this;
 185 }
 186
 187 /*----------------------------------------------------------------------*/
 188 /* rxvt_init () */
 189 /* LIBPROTO */
 190 rxvt_t
 191 rxvt_init (int argc, const char *const *argv)
 192 {
 193   SET_R (new rxvt_term);
 194
 195   if (!GET_R->init_vars () || !GET_R->init (argc, argv))
 196     {
 197       delete GET_R;
 198       SET_R (0);
 199     }
 200
 201   return GET_R;
 202 }
 203
 204 static int (*old_xerror_handler) (Display *dpy, XErrorEvent *event);
 205
 206 void
 207 rxvt_init_signals ()
 208 {
 209   /* install exit handler for cleanup */
 210 #if 0
 211 #ifdef HAVE_ATEXIT
 212   atexit (rxvt_clean_exit);
 213 #else
 214 #endif
 215 #endif
 216
 217   struct sigaction sa;
 218
 219   sigfillset (&sa.sa_mask);
 220   sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
 221   sa.sa_handler = SIG_IGN;           sigaction (SIGHUP , &sa, 0);
 222   sa.sa_handler = SIG_IGN;           sigaction (SIGPIPE, &sa, 0);
 223   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGINT , &sa, 0);
 224   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGQUIT, &sa, 0);
 225   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGTERM, &sa, 0);
 226   sa.sa_handler = rxvt_Child_signal; sigaction (SIGCHLD, &sa, 0);
 227
 228   /* need to trap SIGURG for SVR4 (Unixware) rlogin */
 229   /* signal (SIGURG, SIG_DFL); */
 230
 231   old_xerror_handler = XSetErrorHandler ((XErrorHandler) rxvt_xerror_handler);
 232   //XSetIOErrorHandler ((XErrorHandler) rxvt_xioerror_handler);
 233 }
 234
 235 bool
 236 rxvt_term::init (int argc, const char *const *argv)
 237 {
 238   /*
 239    * Save and then give up any super-user privileges
 240    * If we need privileges in any area then we must specifically request it.
 241    * We should only need to be root in these cases:
 242    *  1.  write utmp entries on some systems
 243    *  2.  chown tty on some systems
 244    */
 245   privileges (SAVE);
 246   privileges (IGNORE);
 247
 248   init_secondary ();
 249
 250   const char **cmd_argv = init_resources (argc, argv);
 251
 252   set_locale ("");
 253
 254 #if (MENUBAR_MAX)
 255   menubar_read (rs[Rs_menu]);
 256 #endif
 257 #ifdef HAVE_SCROLLBARS
 258   if (Options & Opt_scrollBar)
 259     scrollBar.setIdle ();    /* set existence for size calculations */
 260 #endif
 261
 262   create_windows (argc, argv);
 263
 264   init_xlocale ();
 265
 266   scr_reset ();         /* initialize screen */
 267 #ifdef RXVT_GRAPHICS
 268   Gr_reset ();          /* reset graphics */
 269 #endif
 270
 271 #if 0
 272   XSynchronize (display->display, True);
 273 #endif
 274
 275 #ifdef HAVE_SCROLLBARS
 276   if (Options & Opt_scrollBar)
 277     resize_scrollbar ();      /* create and map scrollbar */
 278 #endif
 279 #if (MENUBAR_MAX)
 280   if (menubar_visible (r))
 281     XMapWindow (display->display, menuBar.win);
 282 #endif
 283 #ifdef TRANSPARENT
 284   if (Options & Opt_transparent)
 285     {
 286       XSelectInput (display->display, display->root, PropertyChangeMask);
 287       check_our_parents ();
 288     }
 289 #endif
 290
 291   rootwin_ev.start (display, display->root);
 292
 293   XMapWindow (display->display, TermWin.vt);
 294   XMapWindow (display->display, TermWin.parent[0]);
 295
 296   init_command (cmd_argv);
 297
 298   pty_ev.start (cmd_fd, EVENT_READ);
 299
 300   check_ev.start ();
 301
 302   return true;
 303 }
 304
 305 /* ------------------------------------------------------------------------- *
 306  *                       SIGNAL HANDLING & EXIT HANDLER                      *
 307  * ------------------------------------------------------------------------- */
 308 /*
 309  * Catch a SIGCHLD signal and exit if the direct child has died
 310  */
 311 /* ARGSUSED */
 312 /* EXTPROTO */
 313 RETSIGTYPE
 314 rxvt_Child_signal (int sig __attribute__ ((unused)))
 315 {
 316   int pid, save_errno = errno;
 317   while ((pid = waitpid (-1, NULL, WNOHANG)) == -1 && errno == EINTR)
 318     ;
 319   errno = save_errno;
 320
 321 #if 0
 322   if (pid == cmd_pid)
 323     exit (EXIT_SUCCESS);
 324 #endif
 325 }
 326
 327 /*
 328  * Catch a fatal signal and tidy up before quitting
 329  */
 330 /* EXTPROTO */
 331 RETSIGTYPE
 332 rxvt_Exit_signal (int sig)
 333 {
 334   signal (sig, SIG_DFL);
 335 #ifdef DEBUG_CMD
 336   rxvt_print_error ("signal %d", sig);
 337 #endif
 338   rxvt_clean_exit ();
 339   kill (getpid (), sig);
 340 }
 341
 342 /* INTPROTO */
 343 int
 344 rxvt_xerror_handler (Display *display, XErrorEvent *event)
 345 {
 346   if (GET_R->allowedxerror == -1)
 347     GET_R->allowedxerror = event->error_code;
 348   else
 349     {
 350       old_xerror_handler (display, event);
 351       GET_R->destroy ();
 352     }
 353
 354   return 0;
 355 }
 356
 357 /*----------------------------------------------------------------------*/
 358 /*
 359  * Exit gracefully, clearing the utmp entry and restoring tty attributes
 360  * TODO: if debugging, this should free up any known resources if we can
 361  */
 362 /* EXTPROTO */
 363 void
 364 rxvt_clean_exit ()
 365 {
 366   // TODO: rxvtd should clean up all ressources
 367   if (GET_R)
 368     GET_R->destroy ();
 369 }
 370
 371 /* ------------------------------------------------------------------------- *
 372  *                         MEMORY ALLOCATION WRAPPERS                        *
 373  * ------------------------------------------------------------------------- */
 374 /* EXTPROTO */
 375 void           *
 376 rxvt_malloc (size_t size)
 377 {
 378   void           *p;
 379
 380   p = malloc (size);
 381   if (p)
 382     return p;
 383
 384   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 385   rxvt_clean_exit ();
 386   exit (EXIT_FAILURE);
 387   /* NOTREACHED */
 388 }
 389
 390 /* EXTPROTO */
 391 void           *
 392 rxvt_calloc (size_t number, size_t size)
 393 {
 394   void           *p;
 395
 396   p = calloc (number, size);
 397   if (p)
 398     return p;
 399
 400   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 401   rxvt_clean_exit ();
 402   exit (EXIT_FAILURE);
 403   /* NOTREACHED */
 404 }
 405
 406 /* EXTPROTO */
 407 void           *
 408 rxvt_realloc (void *ptr, size_t size)
 409 {
 410   void           *p;
 411
 412   if (ptr)
 413     p = realloc (ptr, size);
 414   else
 415     p = malloc (size);
 416   if (p)
 417     return p;
 418
 419   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 420   rxvt_clean_exit ();
 421   exit (EXIT_FAILURE);
 422   /* NOTREACHED */
 423 }
 424
 425 /* ------------------------------------------------------------------------- *
 426  *                            PRIVILEGED OPERATIONS                          *
 427  * ------------------------------------------------------------------------- */
 428 /* take care of suid/sgid super-user (root) privileges */
 429 void
 430 rxvt_term::privileges (int mode)
 431 {
 432 #if ! defined(__CYGWIN32__)
 433 # if !defined(HAVE_SETEUID) && defined(HAVE_SETREUID)
 434   /* setreuid () is the poor man's setuid (), seteuid () */
 435 #  define seteuid(a)    setreuid(-1, (a))
 436 #  define setegid(a)    setregid(-1, (a))
 437 #  define HAVE_SETEUID
 438 # endif
 439 # ifdef HAVE_SETEUID
 440   switch (mode)
 441     {
 442       case IGNORE:
 443         /*
 444          * change effective uid/gid - not real uid/gid - so we can switch
 445          * back to root later, as required
 446          */
 447         seteuid (getuid ());
 448         setegid (getgid ());
 449         break;
 450       case SAVE:
 451         euid = geteuid ();
 452         egid = getegid ();
 453         break;
 454       case RESTORE:
 455         seteuid (euid);
 456         setegid (egid);
 457         break;
 458     }
 459 # else
 460   switch (mode)
 461     {
 462       case IGNORE:
 463         setuid (getuid ());
 464         setgid (getgid ());
 465         /* FALLTHROUGH */
 466       case SAVE:
 467         /* FALLTHROUGH */
 468       case RESTORE:
 469         break;
 470     }
 471 # endif
 472 #endif
 473 }
 474
 475 #ifdef UTMP_SUPPORT
 476 void
 477 rxvt_term::privileged_utmp (char action)
 478 {
 479   D_MAIN ((stderr, "rxvt_privileged_utmp (%c); waiting for: %c (pid: %d)",
 480           action, next_utmp_action, getpid ()));
 481   if (next_utmp_action != action || (action != SAVE && action != RESTORE)
 482       || (Options & Opt_utmpInhibit)
 483       || ttydev == NULL || *ttydev == '\0')
 484     return;
 485
 486   privileges (RESTORE);
 487   if (action == SAVE)
 488     {
 489       next_utmp_action = RESTORE;
 490       makeutent (ttydev, rs[Rs_display_name]);
 491     }
 492   else
 493     {                    /* action == RESTORE */
 494       next_utmp_action = IGNORE;
 495       cleanutent ();
 496     }
 497   privileges (IGNORE);
 498 }
 499 #endif
 500
 501 #ifndef NO_SETOWNER_TTYDEV
 502 void
 503 rxvt_term::privileged_ttydev (char action)
 504 {
 505   D_MAIN ((stderr,
 506           "privileged_ttydev (%c); waiting for: %c (pid: %d)",
 507           action, next_tty_action, getpid ()));
 508   if (next_tty_action != action || (action != SAVE && action != RESTORE)
 509       || ttydev == NULL || *ttydev == '\0')
 510     return;
 511
 512   privileges (RESTORE);
 513
 514   if (action == SAVE)
 515     {
 516       next_tty_action = RESTORE;
 517 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 518       /* store original tty status for restoration rxvt_clean_exit () -- rgg 04/12/95 */
 519       if (lstat (ttydev, &ttyfd_stat) < 0)       /* you lose out */
 520         next_tty_action = IGNORE;
 521       else
 522 # endif
 523
 524         {
 525           chown (ttydev, getuid (), ttygid);      /* fail silently */
 526           chmod (ttydev, ttymode);
 527 # ifdef HAVE_REVOKE
 528           revoke (ttydev);
 529 # endif
 530
 531         }
 532     }
 533   else
 534     {                    /* action == RESTORE */
 535       next_tty_action = IGNORE;
 536 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 537       chmod (ttydev, ttyfd_stat.st_mode);
 538       chown (ttydev, ttyfd_stat.st_uid, ttyfd_stat.st_gid);
 539 # else
 540       chmod (ttydev,
 541             (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
 542       chown (ttydev, 0, 0);
 543 # endif
 544
 545     }
 546
 547   privileges (IGNORE);
 548
 549 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 550   D_MAIN ((stderr, "%s \"%s\": mode %03o, uid %d, gid %d",
 551           action == RESTORE ? "Restoring" : (action ==
 552                                              SAVE ? "Saving" :
 553                                              "UNKNOWN ERROR for"), ttydev,
 554           ttyfd_stat.st_mode, ttyfd_stat.st_uid,
 555           ttyfd_stat.st_gid));
 556 # endif
 557 }
 558 #endif
 559
 560 /*----------------------------------------------------------------------*/
 561 /*
 562  * window size/position calculcations for XSizeHint and other storage.
 563  * if width/height are non-zero then override calculated width/height
 564  */
 565 void
 566 rxvt_term::window_calc (unsigned int width, unsigned int height)
 567 {
 568   short           recalc_x, recalc_y;
 569   int             x, y, sb_w, mb_h, flags;
 570   unsigned int    w, h;
 571   unsigned int    max_width, max_height;
 572
 573   D_SIZE ((stderr, "< Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
 574           TermWin.ncol, TermWin.nrow, szHint.width,
 575           szHint.height));
 576   szHint.flags = PMinSize | PResizeInc | PBaseSize | PWinGravity;
 577   szHint.win_gravity = NorthWestGravity;
 578   /* szHint.min_aspect.x = szHint.min_aspect.y = 1; */
 579
 580   recalc_x = recalc_y = 0;
 581   flags = 0;
 582   if (!parsed_geometry)
 583     {
 584       parsed_geometry = 1;
 585       if (rs[Rs_geometry])
 586         flags = XParseGeometry (rs[Rs_geometry], &x, &y, &w, &h);
 587       if (flags & WidthValue)
 588         {
 589           TermWin.ncol = BOUND_POSITIVE_INT16 (w);
 590           szHint.flags |= USSize;
 591         }
 592       if (flags & HeightValue)
 593         {
 594           TermWin.nrow = BOUND_POSITIVE_INT16 (h);
 595           szHint.flags |= USSize;
 596         }
 597       if (flags & XValue)
 598         {
 599           szHint.x = x;
 600           szHint.flags |= USPosition;
 601           if (flags & XNegative)
 602             {
 603               recalc_x = 1;
 604               szHint.win_gravity = NorthEastGravity;
 605             }
 606         }
 607       if (flags & YValue)
 608         {
 609           szHint.y = y;
 610           szHint.flags |= USPosition;
 611           if (flags & YNegative)
 612             {
 613               recalc_y = 1;
 614               if (szHint.win_gravity == NorthEastGravity)
 615                 szHint.win_gravity = SouthEastGravity;
 616               else
 617                 szHint.win_gravity = SouthWestGravity;
 618             }
 619         }
 620     }
 621   /* TODO: BOUNDS */
 622   TermWin.width = TermWin.ncol * TermWin.fwidth;
 623   TermWin.height = TermWin.nrow * TermWin.fheight;
 624   max_width = MAX_COLS * TermWin.fwidth;
 625   max_height = MAX_ROWS * TermWin.fheight;
 626
 627   szHint.base_width = szHint.base_height = 2 * TermWin.int_bwidth;
 628
 629   sb_w = mb_h = 0;
 630   window_vt_x = window_vt_y = 0;
 631   if (scrollbar_visible ())
 632     {
 633       sb_w = scrollbar_TotalWidth ();
 634       szHint.base_width += sb_w;
 635       if (! (Options & Opt_scrollBar_right))
 636         window_vt_x = sb_w;
 637     }
 638   if (menubar_visible ())
 639     {
 640       mb_h = menuBar_TotalHeight ();
 641       szHint.base_height += mb_h;
 642       window_vt_y = mb_h;
 643     }
 644   szHint.width_inc = TermWin.fwidth;
 645   szHint.height_inc = TermWin.fheight;
 646   szHint.min_width = szHint.base_width + szHint.width_inc;
 647   szHint.min_height = szHint.base_height + szHint.height_inc;
 648
 649   if (width && width - szHint.base_width < max_width)
 650     {
 651       szHint.width = width;
 652       TermWin.width = width - szHint.base_width;
 653     }
 654   else
 655     {
 656       MIN_IT (TermWin.width, max_width);
 657       szHint.width = szHint.base_width + TermWin.width;
 658     }
 659   if (height && height - szHint.base_height < max_height)
 660     {
 661       szHint.height = height;
 662       TermWin.height = height - szHint.base_height;
 663     }
 664   else
 665     {
 666       MIN_IT (TermWin.height, max_height);
 667       szHint.height = szHint.base_height + TermWin.height;
 668     }
 669   if (scrollbar_visible () && (Options & Opt_scrollBar_right))
 670     window_sb_x = szHint.width - sb_w;
 671
 672   if (recalc_x)
 673     szHint.x += (DisplayWidth (display->display, DefaultScreen (display->display))
 674                  - szHint.width - 2 * TermWin.ext_bwidth);
 675   if (recalc_y)
 676     szHint.y += (DisplayHeight (display->display, DefaultScreen (display->display))
 677                  - szHint.height - 2 * TermWin.ext_bwidth);
 678
 679   TermWin.ncol = TermWin.width / TermWin.fwidth;
 680   TermWin.nrow = TermWin.height / TermWin.fheight;
 681   D_SIZE ((stderr, "> Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
 682           TermWin.ncol, TermWin.nrow, szHint.width,
 683           szHint.height));
 684   return;
 685 }
 686
 687 /*----------------------------------------------------------------------*/
 688 /*
 689  * Tell the teletype handler what size the window is.
 690  * Called after a window size change.
 691  */
 692 void
 693 rxvt_term::tt_winch ()
 694 {
 695   struct winsize ws;
 696
 697   if (cmd_fd < 0)
 698     return;
 699
 700   ws.ws_col = TermWin.ncol;
 701   ws.ws_row = TermWin.nrow;
 702   ws.ws_xpixel = ws.ws_ypixel = 0;
 703 #ifndef DEBUG_SIZE
 704   (void)ioctl (cmd_fd, TIOCSWINSZ, &ws);
 705 #else
 706   if (ioctl (cmd_fd, TIOCSWINSZ, &ws) < 0)
 707     D_SIZE ((stderr, "Failed to send TIOCSWINSZ to fd %d", fd));
 708 # ifdef SIGWINCH
 709   else if (cmd_pid)               /* force through to the command */
 710     kill (cmd_pid, SIGWINCH);
 711 # endif
 712 #endif
 713 }
 714
 715 /*----------------------------------------------------------------------*/
 716 /* rxvt_change_font () - Switch to a new font */
 717 /*
 718  * init = 1   - initialize
 719  *
 720  * fontname == FONT_UP  - switch to bigger font
 721  * fontname == FONT_DN  - switch to smaller font
 722  */
 723 void
 724 rxvt_term::change_font (int init, const char *fontname)
 725 {}
 726
 727 void
 728 rxvt_term::font_up_down (int n, int direction)
 729 {}
 730
 731 /*----------------------------------------------------------------------*/
 732 /*----------------------------------------------------------------------*/
 733 /* xterm sequences - title, iconName, color (exptl) */
 734 void
 735 rxvt_term::set_title (const char *str)
 736 {
 737 #ifndef SMART_WINDOW_TITLE
 738   XStoreName (display->display, TermWin.parent[0], str);
 739 #else
 740   char           *name;
 741
 742   if (XFetchName (display->display, TermWin.parent[0], &name) == 0)
 743     name = NULL;
 744   if (name == NULL || STRCMP (name, str))
 745     XStoreName (display->display, TermWin.parent[0], str);
 746   if (name)
 747     XFree (name);
 748 #endif
 749 }
 750
 751 void
 752 rxvt_term::set_iconName (const char *str)
 753 {
 754 #ifndef SMART_WINDOW_TITLE
 755   XSetIconName (display->display, TermWin.parent[0], str);
 756 #else
 757   char           *name;
 758
 759   if (XGetIconName (display->display, TermWin.parent[0], &name))
 760     name = NULL;
 761   if (name == NULL || STRCMP (name, str))
 762     XSetIconName (display->display, TermWin.parent[0], str);
 763   if (name)
 764     XFree (name);
 765 #endif
 766 }
 767
 768 #ifdef XTERM_COLOR_CHANGE
 769 void
 770 rxvt_term::set_window_color (int idx, const char *color)
 771 {
 772   rxvt_color      xcol;
 773   int             i;
 774
 775   if (color == NULL || *color == '\0')
 776     return;
 777
 778   /* handle color aliases */
 779   if (isdigit (*color))
 780     {
 781       i = atoi (color);
 782       if (i >= 8 && i <= 15)
 783         {        /* bright colors */
 784           i -= 8;
 785 # ifndef NO_BRIGHTCOLOR
 786           PixColors[idx] = PixColors[minBrightCOLOR + i];
 787           SET_PIXCOLOR (idx);
 788           goto Done;
 789 # endif
 790
 791         }
 792       if (i >= 0 && i <= 7)
 793         { /* normal colors */
 794           PixColors[idx] = PixColors[minCOLOR + i];
 795           SET_PIXCOLOR (idx);
 796           goto Done;
 797         }
 798     }
 799   if (!rXParseAllocColor (& xcol, color))
 800     return;
 801   /* XStoreColor (display->display, XCMAP, XColor*); */
 802
 803   /*
 804    * FIXME: should free colors here, but no idea how to do it so instead,
 805    * so just keep gobbling up the colormap
 806    */
 807 # if 0
 808   for (i = Color_Black; i <= Color_White; i++)
 809     if (PixColors[idx] == PixColors[i])
 810       break;
 811   if (i > Color_White)
 812     {
 813       /* fprintf (stderr, "XFreeColors: PixColors [%d] = %lu\n", idx, PixColors [idx]); */
 814       XFreeColors (display->display, XCMAP, (PixColors + idx), 1,
 815                   DisplayPlanes (display->display, display->screen));
 816     }
 817 # endif
 818
 819   PixColors[idx] = xcol;
 820   SET_PIXCOLOR (idx);
 821
 822   /* XSetWindowAttributes attr; */
 823   /* Cursor cursor; */
 824 Done:
 825   if (idx == Color_bg && ! (Options & Opt_transparent))
 826     XSetWindowBackground (display->display, TermWin.vt,
 827                          PixColors[Color_bg]);
 828
 829   /* handle Color_BD, scrollbar background, etc. */
 830
 831   set_colorfgbg ();
 832   recolour_cursor ();
 833   /* the only reasonable way to enforce a clean update */
 834   scr_poweron ();
 835 }
 836
 837 #else
 838 # define set_window_color (idx,color)   ((void)0)
 839 #endif                          /* XTERM_COLOR_CHANGE */
 840
 841 void
 842 rxvt_term::recolour_cursor ()
 843 {
 844 #if TODO
 845   rxvt_color xcol[2];
 846
 847   xcol[0] = PixColors[Color_pointer];
 848   xcol[1] = PixColors[Color_bg];
 849   XQueryColors (display->display, XCMAP, xcol, 2);
 850   XRecolorCursor (display->display, TermWin_cursor, & (xcol[0]), & (xcol[1]));
 851 #endif
 852 }
 853
 854 /*----------------------------------------------------------------------*/
 855 /*
 856  * find if fg/bg matches any of the normal (low-intensity) colors
 857  */
 858 void
 859 rxvt_term::set_colorfgbg ()
 860 {
 861   unsigned int    i;
 862   const char     *xpmb = "\0";
 863   char            fstr[sizeof ("default") + 1], bstr[sizeof ("default") + 1];
 864
 865   env_colorfgbg =
 866     (char *)rxvt_malloc (sizeof ("COLORFGBG=default;default;bg") + 1);
 867   STRCPY (fstr, "default");
 868   STRCPY (bstr, "default");
 869   for (i = Color_Black; i <= Color_White; i++)
 870     if (PixColors[Color_fg] == PixColors[i])
 871       {
 872         sprintf (fstr, "%d", (i - Color_Black));
 873         break;
 874       }
 875   for (i = Color_Black; i <= Color_White; i++)
 876     if (PixColors[Color_bg] == PixColors[i])
 877       {
 878         sprintf (bstr, "%d", (i - Color_Black));
 879 #ifdef XPM_BACKGROUND
 880         xpmb = "default;";
 881 #endif
 882         break;
 883       }
 884
 885   sprintf (env_colorfgbg, "COLORFGBG=%s;%s%s", fstr, xpmb, bstr);
 886
 887 #ifndef NO_BRIGHTCOLOR
 888   colorfgbg = DEFAULT_RSTYLE;
 889   for (i = minCOLOR; i <= maxCOLOR; i++)
 890     {
 891       if (PixColors[Color_fg] == PixColors[i])
 892         colorfgbg = SET_FGCOLOR (colorfgbg, i);
 893       if (PixColors[Color_bg] == PixColors[i])
 894         colorfgbg = SET_BGCOLOR (colorfgbg, i);
 895     }
 896 #endif
 897 }
 898
 899 /*----------------------------------------------------------------------*/
 900 /*
 901  * Colour determination for low colour displays, routine from
 902  *     Hans de Goede <hans@highrise.nl>
 903  */
 904
 905 int
 906 rxvt_term::rXParseAllocColor (rxvt_color *screen_in_out, const char *colour)
 907 {
 908   if (!screen_in_out->set (display, colour))
 909     {
 910       rxvt_print_error ("can't allocate colour: %s", colour);
 911       return false;
 912     }
 913
 914   return true;
 915 }
 916
 917 /* -------------------------------------------------------------------- *
 918  * -                         WINDOW RESIZING                          - *
 919  * -------------------------------------------------------------------- */
 920 void
 921 rxvt_term::resize_all_windows (unsigned int width, unsigned int height, int ignoreparent)
 922 {
 923   int fix_screen;
 924
 925 #ifdef SMART_RESIZE
 926   int old_width = szHint.width, old_height = szHint.height;
 927 #endif
 928
 929   window_calc (width, height);
 930   XSetWMNormalHints (display->display, TermWin.parent[0], &szHint);
 931   if (!ignoreparent)
 932     {
 933 #ifdef SMART_RESIZE
 934       /*
 935        * resize by Marius Gedminas <marius.gedminas@uosis.mif.vu.lt>
 936        * reposition window on resize depending on placement on screen
 937        */
 938       int x, y, x1, y1;
 939       int dx, dy;
 940       unsigned int unused_w1, unused_h1, unused_b1, unused_d1;
 941       Window unused_cr;
 942
 943       XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
 944                              0, 0, &x, &y, &unused_cr);
 945       XGetGeometry (display->display, TermWin.parent[0], &unused_cr, &x1, &y1,
 946                     &unused_w1, &unused_h1, &unused_b1, &unused_d1);
 947       /*
 948        * if display->root isn't the parent window, a WM will probably have offset
 949        * our position for handles and decorations.  Counter it
 950        */
 951       if (x1 != x || y1 != y)
 952         {
 953           x -= x1;
 954           y -= y1;
 955         }
 956
 957       x1 = (DisplayWidth (display->display, display->screen) - old_width) / 2;
 958       y1 = (DisplayHeight (display->display, display->screen) - old_height) / 2;
 959       dx = old_width - szHint.width;
 960       dy = old_height - szHint.height;
 961
 962       /* Check position of the center of the window */
 963       if (x < x1)             /* left half */
 964         dx = 0;
 965       else if (x == x1)       /* exact center */
 966         dx /= 2;
 967       if (y < y1)             /* top half */
 968         dy = 0;
 969       else if (y == y1)       /* exact center */
 970         dy /= 2;
 971
 972       XMoveResizeWindow (display->display, TermWin.parent[0], x + dx, y + dy,
 973                          szHint.width, szHint.height);
 974 #else
 975       XResizeWindow (display->display, TermWin.parent[0], szHint.width,
 976                      szHint.height);
 977 #endif
 978
 979     }
 980
 981   fix_screen = (TermWin.ncol != prev_ncol
 982                 || TermWin.nrow != prev_nrow);
 983
 984   if (fix_screen || width != old_width || height != old_height)
 985     {
 986       if (scrollbar_visible ())
 987         {
 988           XMoveResizeWindow (display->display, scrollBar.win, window_sb_x,
 989                              0, scrollbar_TotalWidth (), szHint.height);
 990           resize_scrollbar ();
 991         }
 992
 993       if (menubar_visible ())
 994         XMoveResizeWindow (display->display, menuBar.win, window_vt_x,
 995                            0, TermWin_TotalWidth (), menuBar_TotalHeight ());
 996
 997       XMoveResizeWindow (display->display, TermWin.vt, window_vt_x,
 998                          window_vt_y, TermWin_TotalWidth (),
 999                          TermWin_TotalHeight ());
1000 #ifdef RXVT_GRAPHICS
1001       if (old_height)
1002         Gr_Resize (old_width - szHint.base_width,
1003                    old_height - szHint.base_height);
1004 #endif
1005       scr_clear ();
1006 #ifdef XPM_BACKGROUND
1007       resize_pixmap ();
1008 #endif
1009
1010     }
1011
1012   if (fix_screen || old_height == 0)
1013     {
1014       int curr_screen = -1;
1015       int old_ncol = prev_ncol;
1016
1017       /* scr_reset only works on the primary screen */
1018       if (old_height)      /* this is not the first time through */
1019         {
1020           unsigned int ncol = TermWin.ncol;
1021           TermWin.ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
1022           curr_screen = scr_change_screen (PRIMARY);
1023           TermWin.ncol = ncol;
1024         }
1025
1026       scr_reset ();
1027
1028       if (curr_screen >= 0) /* this is not the first time through */
1029         {
1030           scr_change_screen (curr_screen);
1031           selection_check (old_ncol != TermWin.ncol ? 4 : 0);
1032         }
1033     }
1034
1035   old_width = szHint.width;
1036   old_height = szHint.height;
1037
1038 #ifdef USE_XIM
1039   IMSetStatusPosition ();
1040 #endif
1041 }
1042
1043 /*
1044  * Set the width/height of the vt window in characters.  Units are pixels.
1045  * good for toggling 80/132 columns
1046  */
1047 void
1048 rxvt_term::set_widthheight (unsigned int width, unsigned int height)
1049 {
1050   XWindowAttributes wattr;
1051
1052   if (width == 0 || height == 0)
1053     {
1054       XGetWindowAttributes (display->display, display->root, &wattr);
1055       if (width == 0)
1056         width = wattr.width - szHint.base_width;
1057       if (height == 0)
1058         height = wattr.height - szHint.base_height;
1059     }
1060   if (width != TermWin.width || height != TermWin.height)
1061     {
1062       width += szHint.base_width;
1063       height += szHint.base_height;
1064       resize_all_windows (width, height, 0);
1065     }
1066 }
1067
1068 /* -------------------------------------------------------------------- *
1069  * -                      X INPUT METHOD ROUTINES                     - *
1070  * -------------------------------------------------------------------- */
1071 #ifdef USE_XIM
1072
1073 void
1074 rxvt_term::im_set_size (XRectangle *size)
1075 {
1076   size->x = TermWin.int_bwidth;
1077   size->y = TermWin.int_bwidth;
1078   size->width = Width2Pixel (TermWin.ncol);
1079   size->height = Height2Pixel (TermWin.nrow);
1080 }
1081
1082 void
1083 rxvt_term::im_set_color (unsigned long *fg, unsigned long *bg)
1084 {
1085   *fg = PixColors[Color_fg];
1086   *bg = PixColors[Color_bg];
1087 }
1088
1089 /* Checking whether input method is running. */
1090 bool
1091 rxvt_term::IMisRunning ()
1092 {
1093   char           *p;
1094   Atom            atom;
1095   Window          win;
1096   char            server[IMBUFSIZ];
1097
1098   /* get current locale modifier */
1099   if ((p = XSetLocaleModifiers (NULL)) != NULL)
1100     {
1101       STRCPY (server, "@server=");
1102       STRNCAT (server, & (p[4]), IMBUFSIZ - 9); /* skip "@im=" */
1103       if ((p = STRCHR (server + 1, '@')) != NULL)      /* first one only */
1104         *p = '\0';
1105
1106       atom = XInternAtom (display->display, server, False);
1107       win = XGetSelectionOwner (display->display, atom);
1108       if (win != None)
1109         return True;
1110     }
1111   return False;
1112 }
1113
1114 void
1115 rxvt_term::IMSendSpot ()
1116 {
1117   XPoint          spot;
1118   XVaNestedList   preedit_attr;
1119
1120   if (Input_Context == NULL
1121       || !TermWin.focus || ! (input_style & XIMPreeditPosition)
1122       || ! (event_type == KeyPress
1123            || event_type == Expose
1124            || event_type == NoExpose
1125            || event_type == SelectionNotify
1126            || event_type == ButtonRelease || event_type == FocusIn)
1127       || !IMisRunning ())
1128     return;
1129
1130   im_set_position (&spot);
1131
1132   preedit_attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
1133   XSetICValues (Input_Context, XNPreeditAttributes, preedit_attr, NULL);
1134   XFree (preedit_attr);
1135 }
1136
1137 void
1138 rxvt_term::im_set_preedit_area (XRectangle * preedit_rect, XRectangle * status_rect,
1139                                 XRectangle * needed_rect)
1140 {
1141   int mbh, vtx = 0;
1142
1143   if (scrollbar_visible () && ! (Options & Opt_scrollBar_right))
1144     vtx = scrollbar_TotalWidth ();
1145
1146   mbh = menubar_visible () ? menuBar_TotalHeight () : 0;
1147   mbh -= TermWin.lineSpace;
1148
1149   preedit_rect->x = needed_rect->width + vtx;
1150   preedit_rect->y = Height2Pixel (TermWin.nrow - 1) + mbh;
1151
1152   preedit_rect->width = Width2Pixel (TermWin.ncol + 1) - needed_rect->width + vtx;
1153   preedit_rect->height = Height2Pixel (1);
1154
1155   status_rect->x = vtx;
1156   status_rect->y = Height2Pixel (TermWin.nrow - 1) + mbh;
1157
1158   status_rect->width = needed_rect->width ? needed_rect->width : Width2Pixel (TermWin.ncol + 1);
1159   status_rect->height = Height2Pixel (1);
1160 }
1161
1162 void
1163 rxvt_term::im_destroy ()
1164 {
1165   if (Input_Context)
1166     {
1167       XDestroyIC (Input_Context);
1168       Input_Context = NULL;
1169     }
1170
1171   if (input_method)
1172     {
1173       display->put_xim (input_method);
1174       input_method = 0;
1175     }
1176 }
1177
1178 /*
1179  * Try to open a XIM with the current modifiers, then see if we can
1180  * open a suitable preedit type
1181  */
1182 bool
1183 rxvt_term::IM_get_IC (const char *modifiers)
1184 {
1185   int             i, j, found;
1186   XIM             xim;
1187   XPoint          spot;
1188   XRectangle      rect, status_rect, needed_rect;
1189   unsigned long   fg, bg;
1190   const char     *p;
1191   char          **s;
1192   XIMStyles      *xim_styles;
1193   XVaNestedList   preedit_attr, status_attr;
1194
1195   if (! ((p = XSetLocaleModifiers (modifiers)) && *p))
1196     return false;
1197
1198   D_MAIN ((stderr, "rxvt_IM_get_IC ()"));
1199   input_method = display->get_xim (locale, modifiers);
1200   if (input_method == NULL)
1201     return false;
1202
1203   xim = input_method->xim;
1204
1205   xim_styles = NULL;
1206   if (XGetIMValues (xim, XNQueryInputStyle, &xim_styles, NULL)
1207       || !xim_styles || !xim_styles->count_styles)
1208     {
1209       display->put_xim (input_method);
1210       return false;
1211     }
1212
1213   p = rs[Rs_preeditType] ? rs[Rs_preeditType] : "OverTheSpot,OffTheSpot,Root";
1214   s = rxvt_splitcommastring (p);
1215   for (i = found = 0; !found && s[i]; i++)
1216     {
1217       if (!STRCMP (s[i], "OverTheSpot"))
1218         input_style = (XIMPreeditPosition | XIMStatusNothing);
1219       else if (!STRCMP (s[i], "OffTheSpot"))
1220         input_style = (XIMPreeditArea | XIMStatusArea);
1221       else if (!STRCMP (s[i], "Root"))
1222         input_style = (XIMPreeditNothing | XIMStatusNothing);
1223
1224       for (j = 0; j < xim_styles->count_styles; j++)
1225         if (input_style == xim_styles->supported_styles[j])
1226           {
1227             found = 1;
1228             break;
1229           }
1230     }
1231
1232   for (i = 0; s[i]; i++)
1233     free (s[i]);
1234
1235   free (s);
1236   XFree (xim_styles);
1237
1238   if (!found)
1239     {
1240       display->put_xim (input_method);
1241       return false;
1242     }
1243
1244   preedit_attr = status_attr = NULL;
1245
1246   if (input_style & XIMPreeditPosition)
1247     {
1248       im_set_size (&rect);
1249       im_set_position (&spot);
1250       im_set_color (&fg, &bg);
1251
1252       preedit_attr = XVaCreateNestedList (0, XNArea, &rect,
1253                                          XNSpotLocation, &spot,
1254                                          XNForeground, fg, XNBackground, bg,
1255                                          //XNFontSet, TermWin.fontset,
1256                                          NULL);
1257     }
1258   else if (input_style & XIMPreeditArea)
1259     {
1260       im_set_color (&fg, &bg);
1261
1262       /*
1263        * The necessary width of preedit area is unknown
1264        * until create input context.
1265        */
1266       needed_rect.width = 0;
1267
1268       im_set_preedit_area (&rect, &status_rect, &needed_rect);
1269
1270       preedit_attr = XVaCreateNestedList (0, XNArea, &rect,
1271                                          XNForeground, fg, XNBackground, bg,
1272                                          //XNFontSet, TermWin.fontset,
1273                                          NULL);
1274       status_attr = XVaCreateNestedList (0, XNArea, &status_rect,
1275                                         XNForeground, fg, XNBackground, bg,
1276                                         //XNFontSet, TermWin.fontset,
1277                                         NULL);
1278     }
1279
1280   Input_Context = XCreateIC (xim, XNInputStyle, input_style,
1281                             XNClientWindow, TermWin.parent[0],
1282                             XNFocusWindow, TermWin.parent[0],
1283                             preedit_attr ? XNPreeditAttributes : NULL,
1284                             preedit_attr,
1285                             status_attr ? XNStatusAttributes : NULL,
1286                             status_attr, NULL);
1287   if (preedit_attr) XFree (preedit_attr);
1288   if (status_attr) XFree (status_attr);
1289
1290   if (Input_Context == NULL)
1291     {
1292       rxvt_print_error ("failed to create input context");
1293       display->put_xim (input_method);
1294       return false;
1295     }
1296
1297   if (input_style & XIMPreeditArea)
1298     IMSetStatusPosition ();
1299
1300   D_MAIN ((stderr, "rxvt_IM_get_IC () - successful connection"));
1301   return true;
1302 }
1303
1304 void
1305 rxvt_term::im_cb ()
1306 {
1307   int i, found, had_im;
1308   const char *p;
1309   char **s;
1310   char buf[IMBUFSIZ];
1311
1312   im_destroy ();
1313
1314   D_MAIN ((stderr, "rxvt_IMInstantiateCallback ()"));
1315   if (Input_Context)
1316     return;
1317
1318 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1319   if (rs[Rs_imLocale])
1320     SET_LOCALE (rs[Rs_imLocale]);
1321 #endif
1322
1323   p = rs[Rs_inputMethod];
1324   if (p && *p)
1325     {
1326       bool found = false;
1327
1328       s = rxvt_splitcommastring (p);
1329       for (i = 0; s[i]; i++)
1330         {
1331           if (*s[i])
1332             {
1333               STRCPY (buf, "@im=");
1334               STRNCAT (buf, s[i], IMBUFSIZ - 5);
1335               if (IM_get_IC (buf))
1336                 {
1337                   found = true;
1338                   break;
1339                 }
1340             }
1341         }
1342       for (i = 0; s[i]; i++)
1343         free (s[i]);
1344       free (s);
1345
1346       if (found)
1347         goto done;
1348     }
1349
1350   /* try with XMODIFIERS env. var. */
1351   if (IM_get_IC (""))
1352     goto done;
1353
1354   /* try with no modifiers base IF the user didn't specify an IM */
1355   if (IM_get_IC ("@im=none"))
1356     goto done;
1357
1358 done:
1359 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1360   if (rs[Rs_imLocale])
1361     SET_LOCALE (locale);
1362 #endif
1363 }
1364
1365 void
1366 rxvt_term::IMSetStatusPosition ()
1367 {
1368   XRectangle      preedit_rect, status_rect, *needed_rect;
1369   XVaNestedList   preedit_attr, status_attr;
1370
1371   if (Input_Context == NULL
1372       || !TermWin.focus || ! (input_style & XIMPreeditArea)
1373       || !IMisRunning ())
1374     return;
1375
1376   /* Getting the necessary width of preedit area */
1377   status_attr = XVaCreateNestedList (0, XNAreaNeeded, &needed_rect, NULL);
1378   XGetICValues (Input_Context, XNStatusAttributes, status_attr, NULL);
1379   XFree (status_attr);
1380
1381   im_set_preedit_area (&preedit_rect, &status_rect, needed_rect);
1382
1383   preedit_attr = XVaCreateNestedList (0, XNArea, &preedit_rect, NULL);
1384   status_attr = XVaCreateNestedList (0, XNArea, &status_rect, NULL);
1385
1386   XSetICValues (Input_Context,
1387                XNPreeditAttributes, preedit_attr,
1388                XNStatusAttributes, status_attr, NULL);
1389
1390   XFree (preedit_attr);
1391   XFree (status_attr);
1392 }
1393 #endif                          /* USE_XIM */
1394
1395 /*----------------------------------------------------------------------*/
1396 rxvt_t          rxvt_current_term;
1397
1398 /*----------------------- end-of-file (C source) -----------------------*/