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