src/main.C

   1 /*--------------------------------*-C-*---------------------------------*
   2  * File:        main.c
   3  *----------------------------------------------------------------------*
   4  * $Id: main.C,v 1.2 2003-11-24 17:31:27 pcg Exp $
   5  *
   6  * All portions of code are copyright by their respective author/s.
   7  * Copyright (c) 1992      John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
   8  *                              - original version
   9  * Copyright (c) 1994      Robert Nation <nation@rocket.sanders.lockheed.com>
  10  *                              - extensive modifications
  11  * Copyright (c) 1995      Garrett D'Amore <garrett@netcom.com>
  12  * Copyright (c) 1997      mj olesen <olesen@me.QueensU.CA>
  13  *                              - extensive modifications
  14  * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
  15  * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  16  *                              - extensive modifications
  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 /*----------------------------------------------------------------------*/
  48 /* rxvt_init() */
  49 /* LIBPROTO */
  50 rxvt_t         *
  51 rxvt_init(int argc, const char *const *argv)
  52 {
  53     const char    **cmd_argv;
  54
  55     SET_R ((rxvt_t *)rxvt_calloc(1, sizeof(rxvt_t)));
  56
  57     dR;
  58     if (rxvt_init_vars(aR) < 0) {
  59         free(R);
  60         return NULL;
  61     }
  62
  63 /*
  64  * Save and then give up any super-user privileges
  65  * If we need privileges in any area then we must specifically request it.
  66  * We should only need to be root in these cases:
  67  *  1.  write utmp entries on some systems
  68  *  2.  chown tty on some systems
  69  */
  70     rxvt_privileges(aR_ SAVE);
  71     rxvt_privileges(aR_ IGNORE);
  72
  73     rxvt_init_secondary(aR);
  74
  75     cmd_argv = rxvt_init_resources(aR_ argc, argv);
  76
  77 #if (MENUBAR_MAX)
  78     rxvt_menubar_read(aR_ R->h->rs[Rs_menu]);
  79 #endif
  80 #ifdef HAVE_SCROLLBARS
  81     if (R->Options & Opt_scrollBar)
  82       scrollbar_setIdle();      /* set existence for size calculations */
  83 #endif
  84
  85     rxvt_Create_Windows(aR_ argc, argv);
  86
  87     rxvt_init_xlocale(aR);
  88
  89     rxvt_scr_reset(aR);         /* initialize screen */
  90 #ifdef RXVT_GRAPHICS
  91     rxvt_Gr_reset(aR);          /* reset graphics */
  92 #endif
  93
  94 #if 0
  95 #ifdef DEBUG_X
  96     XSynchronize(R->Xdisplay, True);
  97     XSetErrorHandler((XErrorHandler) abort);
  98 #else
  99     XSetErrorHandler((XErrorHandler) rxvt_xerror_handler);
 100 #endif
 101 #endif
 102
 103 #ifdef HAVE_SCROLLBARS
 104     if (R->Options & Opt_scrollBar)
 105         rxvt_Resize_scrollBar(aR);      /* create and map scrollbar */
 106 #endif
 107 #if (MENUBAR_MAX)
 108     if (menubar_visible(r))
 109         XMapWindow(R->Xdisplay, R->menuBar.win);
 110 #endif
 111 #ifdef TRANSPARENT
 112     if (R->Options & Opt_transparent) {
 113         XSelectInput(R->Xdisplay, Xroot, PropertyChangeMask);
 114         rxvt_check_our_parents(aR);
 115     }
 116 #endif
 117     XMapWindow(R->Xdisplay, R->TermWin.vt);
 118     XMapWindow(R->Xdisplay, R->TermWin.parent[0]);
 119
 120     rxvt_init_env(aR);
 121     rxvt_init_command(aR_ cmd_argv);
 122
 123     return R;
 124 }
 125
 126 /* ------------------------------------------------------------------------- *
 127  *                       SIGNAL HANDLING & EXIT HANDLER                      *
 128  * ------------------------------------------------------------------------- */
 129 /*
 130  * Catch a SIGCHLD signal and exit if the direct child has died
 131  */
 132 /* ARGSUSED */
 133 /* EXTPROTO */
 134 RETSIGTYPE
 135 rxvt_Child_signal(int sig __attribute__((unused)))
 136 {
 137     dR;
 138     int             pid, save_errno = errno;
 139
 140     do {
 141         errno = 0;
 142     } while ((pid = waitpid(-1, NULL, WNOHANG)) == -1 && errno == EINTR);
 143
 144     if (pid == R->h->cmd_pid)
 145         exit(EXIT_SUCCESS);
 146
 147     errno = save_errno;
 148     signal(SIGCHLD, rxvt_Child_signal);
 149 }
 150
 151 /*
 152  * Catch a fatal signal and tidy up before quitting
 153  */
 154 /* EXTPROTO */
 155 RETSIGTYPE
 156 rxvt_Exit_signal(int sig)
 157 {
 158     signal(sig, SIG_DFL);
 159 #ifdef DEBUG_CMD
 160     rxvt_print_error("signal %d", sig);
 161 #endif
 162     rxvt_clean_exit();
 163     kill(getpid(), sig);
 164 }
 165
 166 /* ARGSUSED */
 167 /* INTPROTO */
 168 int
 169 rxvt_xerror_handler(const Display *display __attribute__((unused)), const XErrorEvent *event)
 170 {
 171     dR;
 172
 173     if (R->h->allowedxerror == -1) {
 174         R->h->allowedxerror = event->error_code;
 175         return 0;               /* ignored anyway */
 176     }
 177     rxvt_print_error("XError: Request: %d . %d, Error: %d",
 178                      event->request_code, event->minor_code,
 179                      event->error_code);
 180     /* XXX: probably should call rxvt_clean_exit() bypassing X routines */
 181     exit(EXIT_FAILURE);
 182     /* NOTREACHED */
 183 }
 184
 185 /*----------------------------------------------------------------------*/
 186 /*
 187  * Exit gracefully, clearing the utmp entry and restoring tty attributes
 188  * TODO: if debugging, this should free up any known resources if we can
 189  */
 190 /* EXTPROTO */
 191 void
 192 rxvt_clean_exit(void)
 193 {
 194     dR;
 195
 196 #ifdef DEBUG_SCREEN
 197     rxvt_scr_release(aR);
 198 #endif
 199 #ifndef NO_SETOWNER_TTYDEV
 200     rxvt_privileged_ttydev(aR_ RESTORE);
 201 #endif
 202 #ifdef UTMP_SUPPORT
 203     rxvt_privileged_utmp(aR_ RESTORE);
 204 #endif
 205 #ifdef USE_XIM
 206     if (R->h->Input_Context != NULL) {
 207         XDestroyIC(R->h->Input_Context);
 208         R->h->Input_Context = NULL;
 209     }
 210 #endif
 211 }
 212
 213 /* ------------------------------------------------------------------------- *
 214  *                         MEMORY ALLOCATION WRAPPERS                        *
 215  * ------------------------------------------------------------------------- */
 216 /* EXTPROTO */
 217 void           *
 218 rxvt_malloc(size_t size)
 219 {
 220      void           *p;
 221
 222      p = malloc(size);
 223      if (p)
 224         return p;
 225
 226      fprintf(stderr, APL_NAME ": memory allocation failure.  Aborting");
 227      rxvt_clean_exit();
 228      exit(EXIT_FAILURE);
 229      /* NOTREACHED */
 230 }
 231
 232 /* EXTPROTO */
 233 void           *
 234 rxvt_calloc(size_t number, size_t size)
 235 {
 236      void           *p;
 237
 238      p = calloc(number, size);
 239      if (p)
 240         return p;
 241
 242      fprintf(stderr, APL_NAME ": memory allocation failure.  Aborting");
 243      rxvt_clean_exit();
 244      exit(EXIT_FAILURE);
 245      /* NOTREACHED */
 246 }
 247
 248 /* EXTPROTO */
 249 void           *
 250 rxvt_realloc(void *ptr, size_t size)
 251 {
 252      void           *p;
 253
 254      if (ptr)
 255         p = realloc(ptr, size);
 256      else
 257         p = malloc(size);
 258      if (p)
 259         return p;
 260
 261      fprintf(stderr, APL_NAME ": memory allocation failure.  Aborting");
 262      rxvt_clean_exit();
 263      exit(EXIT_FAILURE);
 264      /* NOTREACHED */
 265 }
 266 /* ------------------------------------------------------------------------- *
 267  *                            PRIVILEGED OPERATIONS                          *
 268  * ------------------------------------------------------------------------- */
 269 /* take care of suid/sgid super-user (root) privileges */
 270 /* INTPROTO */
 271 void
 272 rxvt_privileges(pR_ int mode)
 273 {
 274 #if ! defined(__CYGWIN32__)
 275 # if !defined(HAVE_SETEUID) && defined(HAVE_SETREUID)
 276 /* setreuid() is the poor man's setuid(), seteuid() */
 277 #  define seteuid(a)    setreuid(-1, (a))
 278 #  define setegid(a)    setregid(-1, (a))
 279 #  define HAVE_SETEUID
 280 # endif
 281 # ifdef HAVE_SETEUID
 282     switch (mode) {
 283     case IGNORE:
 284         /*
 285          * change effective uid/gid - not real uid/gid - so we can switch
 286          * back to root later, as required
 287          */
 288         seteuid(getuid());
 289         setegid(getgid());
 290         break;
 291     case SAVE:
 292         R->h->euid = geteuid();
 293         R->h->egid = getegid();
 294         break;
 295     case RESTORE:
 296         seteuid(R->h->euid);
 297         setegid(R->h->egid);
 298         break;
 299     }
 300 # else
 301     switch (mode) {
 302     case IGNORE:
 303         setuid(getuid());
 304         setgid(getgid());
 305     /* FALLTHROUGH */
 306     case SAVE:
 307     /* FALLTHROUGH */
 308     case RESTORE:
 309         break;
 310     }
 311 # endif
 312 #endif
 313 }
 314
 315 #ifdef UTMP_SUPPORT
 316 /* EXTPROTO */
 317 void
 318 rxvt_privileged_utmp(pR_ char action)
 319 {
 320     struct rxvt_hidden *h = R->h;
 321
 322     D_MAIN((stderr, "rxvt_privileged_utmp(%c); waiting for: %c (pid: %d)", action, h->next_utmp_action, getpid()));
 323     if (h->next_utmp_action != action
 324         || (action != SAVE && action != RESTORE)
 325         || (R->Options & Opt_utmpInhibit)
 326         || h->ttydev == NULL
 327         || *h->ttydev == '\0')
 328         return;
 329
 330     rxvt_privileges(aR_ RESTORE);
 331     if (action == SAVE) {
 332         h->next_utmp_action = RESTORE;
 333         rxvt_makeutent(aR_ h->ttydev, h->rs[Rs_display_name]);
 334     } else {            /* action == RESTORE */
 335         h->next_utmp_action = IGNORE;
 336         rxvt_cleanutent(aR);
 337     }
 338     rxvt_privileges(aR_ IGNORE);
 339 }
 340 #endif
 341
 342 #ifndef NO_SETOWNER_TTYDEV
 343 /* EXTPROTO */
 344 void
 345 rxvt_privileged_ttydev(pR_ char action)
 346 {
 347     struct rxvt_hidden *h = R->h;
 348
 349     D_MAIN((stderr, "rxvt_privileged_ttydev(aR_ %c); waiting for: %c (pid: %d)", action, h->next_tty_action, getpid()));
 350     if (h->next_tty_action != action
 351         || (action != SAVE && action != RESTORE)
 352         || h->ttydev == NULL
 353         || *h->ttydev == '\0')
 354         return;
 355
 356     rxvt_privileges(aR_ RESTORE);
 357
 358     if (action == SAVE) {
 359         h->next_tty_action = RESTORE;
 360 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 361 /* store original tty status for restoration rxvt_clean_exit() -- rgg 04/12/95 */
 362         if (lstat(h->ttydev, &h->ttyfd_stat) < 0)       /* you lose out */
 363             h->next_tty_action = IGNORE;
 364         else
 365 # endif
 366         {
 367             chown(h->ttydev, getuid(), h->ttygid); /* fail silently */
 368             chmod(h->ttydev, h->ttymode);
 369 # ifdef HAVE_REVOKE
 370             revoke(h->ttydev);
 371 # endif
 372         }
 373     } else {                    /* action == RESTORE */
 374         h->next_tty_action = IGNORE;
 375 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 376         chmod(h->ttydev, h->ttyfd_stat.st_mode);
 377         chown(h->ttydev, h->ttyfd_stat.st_uid, h->ttyfd_stat.st_gid);
 378 # else
 379         chmod(h->ttydev,
 380               (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
 381         chown(h->ttydev, 0, 0);
 382 # endif
 383     }
 384
 385     rxvt_privileges(aR_ IGNORE);
 386
 387 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 388     D_MAIN((stderr, "%s \"%s\": mode %03o, uid %d, gid %d", action == RESTORE ? "Restoring" : (action == SAVE ? "Saving" : "UNKNOWN ERROR for"), h->ttydev, h->ttyfd_stat.st_mode, h->ttyfd_stat.st_uid, h->ttyfd_stat.st_gid));
 389 # endif
 390 }
 391 #endif
 392
 393 /*----------------------------------------------------------------------*/
 394 /*
 395  * window size/position calculcations for XSizeHint and other storage.
 396  * if width/height are non-zero then override calculated width/height
 397  */
 398 /* EXTPROTO */
 399 void
 400 rxvt_window_calc(pR_ unsigned int width, unsigned int height)
 401 {
 402     short           recalc_x, recalc_y;
 403     int             x, y, sb_w, mb_h, flags;
 404     unsigned int    w, h;
 405     unsigned int    max_width, max_height;
 406
 407     D_SIZE((stderr, "< Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d", R->TermWin.ncol, R->TermWin.nrow, R->szHint.width, R->szHint.height));
 408     R->szHint.flags = PMinSize | PResizeInc | PBaseSize | PWinGravity;
 409     R->szHint.win_gravity = NorthWestGravity;
 410     /* R->szHint.min_aspect.x = R->szHint.min_aspect.y = 1; */
 411
 412     recalc_x = recalc_y = 0;
 413     flags = 0;
 414     if (!R->h->parsed_geometry) {
 415         R->h->parsed_geometry = 1;
 416         if (R->h->rs[Rs_geometry])
 417             flags = XParseGeometry(R->h->rs[Rs_geometry], &x, &y, &w, &h);
 418         if (flags & WidthValue) {
 419             R->TermWin.ncol = BOUND_POSITIVE_INT16(w);
 420             R->szHint.flags |= USSize;
 421         }
 422         if (flags & HeightValue) {
 423             R->TermWin.nrow = BOUND_POSITIVE_INT16(h);
 424             R->szHint.flags |= USSize;
 425         }
 426         if (flags & XValue) {
 427             R->szHint.x = x;
 428             R->szHint.flags |= USPosition;
 429             if (flags & XNegative) {
 430                 recalc_x = 1;
 431                 R->szHint.win_gravity = NorthEastGravity;
 432             }
 433         }
 434         if (flags & YValue) {
 435             R->szHint.y = y;
 436             R->szHint.flags |= USPosition;
 437             if (flags & YNegative) {
 438                 recalc_y = 1;
 439                 if (R->szHint.win_gravity == NorthEastGravity)
 440                     R->szHint.win_gravity = SouthEastGravity;
 441                 else
 442                     R->szHint.win_gravity = SouthWestGravity;
 443             }
 444         }
 445     }
 446 /* TODO: BOUNDS */
 447     R->TermWin.width = R->TermWin.ncol * R->TermWin.fwidth;
 448     R->TermWin.height = R->TermWin.nrow * R->TermWin.fheight;
 449     max_width = MAX_COLS * R->TermWin.fwidth;
 450     max_height = MAX_ROWS * R->TermWin.fheight;
 451
 452     R->szHint.base_width = R->szHint.base_height = 2 * R->TermWin.int_bwidth;
 453
 454     sb_w = mb_h = 0;
 455     R->h->window_vt_x = R->h->window_vt_y = 0;
 456     if (scrollbar_visible(R)) {
 457         sb_w = scrollbar_TotalWidth();
 458         R->szHint.base_width += sb_w;
 459         if (!(R->Options & Opt_scrollBar_right))
 460             R->h->window_vt_x = sb_w;
 461     }
 462     if (menubar_visible(R)) {
 463         mb_h = menuBar_TotalHeight();
 464         R->szHint.base_height += mb_h;
 465         R->h->window_vt_y = mb_h;
 466     }
 467     R->szHint.width_inc = R->TermWin.fwidth;
 468     R->szHint.height_inc = R->TermWin.fheight;
 469     R->szHint.min_width = R->szHint.base_width + R->szHint.width_inc;
 470     R->szHint.min_height = R->szHint.base_height + R->szHint.height_inc;
 471
 472     if (width && width - R->szHint.base_width < max_width) {
 473         R->szHint.width = width;
 474         R->TermWin.width = width - R->szHint.base_width;
 475     } else {
 476         MIN_IT(R->TermWin.width, max_width);
 477         R->szHint.width = R->szHint.base_width + R->TermWin.width;
 478     }
 479     if (height && height - R->szHint.base_height < max_height) {
 480         R->szHint.height = height;
 481         R->TermWin.height = height - R->szHint.base_height;
 482     } else {
 483         MIN_IT(R->TermWin.height, max_height);
 484         R->szHint.height = R->szHint.base_height + R->TermWin.height;
 485     }
 486     if (scrollbar_visible(R) && (R->Options & Opt_scrollBar_right))
 487         R->h->window_sb_x = R->szHint.width - sb_w;
 488
 489     if (recalc_x)
 490         R->szHint.x += (DisplayWidth(R->Xdisplay, Xscreen)
 491                         - R->szHint.width - 2 * R->TermWin.ext_bwidth);
 492     if (recalc_y)
 493         R->szHint.y += (DisplayHeight(R->Xdisplay, Xscreen)
 494                         - R->szHint.height - 2 * R->TermWin.ext_bwidth);
 495
 496     R->TermWin.ncol = R->TermWin.width / R->TermWin.fwidth;
 497     R->TermWin.nrow = R->TermWin.height / R->TermWin.fheight;
 498     D_SIZE((stderr, "> Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d", R->TermWin.ncol, R->TermWin.nrow, R->szHint.width, R->szHint.height));
 499     return;
 500 }
 501
 502 /*----------------------------------------------------------------------*/
 503 /*
 504  * Tell the teletype handler what size the window is.
 505  * Called after a window size change.
 506  */
 507 /* EXTPROTO */
 508 void
 509 rxvt_tt_winsize(int fd, unsigned short col, unsigned short row, int pid)
 510 {
 511     struct winsize  ws;
 512
 513     if (fd < 0)
 514         return;
 515     ws.ws_col = col;
 516     ws.ws_row = row;
 517     ws.ws_xpixel = ws.ws_ypixel = 0;
 518 #ifndef DEBUG_SIZE
 519     (void)ioctl(fd, TIOCSWINSZ, &ws);
 520 #else
 521     if (ioctl(fd, TIOCSWINSZ, &ws) < 0) {
 522         D_SIZE((stderr, "Failed to send TIOCSWINSZ to fd %d", fd));
 523     }
 524 # ifdef SIGWINCH
 525     else if (pid)               /* force through to the command */
 526         kill(pid, SIGWINCH);
 527 # endif
 528 #endif
 529 }
 530
 531 /*----------------------------------------------------------------------*/
 532 /* rxvt_change_font() - Switch to a new font */
 533 /*
 534  * init = 1   - initialize
 535  *
 536  * fontname == FONT_UP  - switch to bigger font
 537  * fontname == FONT_DN  - switch to smaller font
 538  */
 539 /* EXTPROTO */
 540 void
 541 rxvt_change_font(pR_ int init, const char *fontname)
 542 {
 543 }
 544
 545 /* INTPROTO */
 546 void
 547 rxvt_font_up_down(pR_ int n, int direction)
 548 {
 549 }
 550
 551 /*----------------------------------------------------------------------*/
 552 /*----------------------------------------------------------------------*/
 553 /* xterm sequences - title, iconName, color (exptl) */
 554 /* EXTPROTO */
 555 void
 556 rxvt_set_title(pR_ const char *str)
 557 {
 558 #ifndef SMART_WINDOW_TITLE
 559     XStoreName(R->Xdisplay, R->TermWin.parent[0], str);
 560 #else
 561     char           *name;
 562
 563     if (XFetchName(R->Xdisplay, R->TermWin.parent[0], &name) == 0)
 564         name = NULL;
 565     if (name == NULL || STRCMP(name, str))
 566         XStoreName(R->Xdisplay, R->TermWin.parent[0], str);
 567     if (name)
 568         XFree(name);
 569 #endif
 570 }
 571
 572 /* EXTPROTO */
 573 void
 574 rxvt_set_iconName(pR_ const char *str)
 575 {
 576 #ifndef SMART_WINDOW_TITLE
 577     XSetIconName(R->Xdisplay, R->TermWin.parent[0], str);
 578 #else
 579     char           *name;
 580
 581     if (XGetIconName(R->Xdisplay, R->TermWin.parent[0], &name))
 582         name = NULL;
 583     if (name == NULL || STRCMP(name, str))
 584         XSetIconName(R->Xdisplay, R->TermWin.parent[0], str);
 585     if (name)
 586         XFree(name);
 587 #endif
 588 }
 589
 590 #ifdef XTERM_COLOR_CHANGE
 591 /* EXTPROTO */
 592 void
 593 rxvt_set_window_color(pR_ int idx, const char *color)
 594 {
 595     rxvt_color      xcol;
 596     int             i;
 597
 598     if (color == NULL || *color == '\0')
 599         return;
 600
 601 /* handle color aliases */
 602     if (isdigit(*color)) {
 603         i = atoi(color);
 604         if (i >= 8 && i <= 15) {        /* bright colors */
 605             i -= 8;
 606 # ifndef NO_BRIGHTCOLOR
 607             R->PixColors[idx] = R->PixColors[minBrightCOLOR + i];
 608             SET_PIXCOLOR(R->h, idx);
 609             goto Done;
 610 # endif
 611         }
 612         if (i >= 0 && i <= 7) { /* normal colors */
 613             R->PixColors[idx] = R->PixColors[minCOLOR + i];
 614             SET_PIXCOLOR(R->h, idx);
 615             goto Done;
 616         }
 617     }
 618     if (!rxvt_rXParseAllocColor(aR_ &xcol, color))
 619         return;
 620 /* XStoreColor (R->Xdisplay, XCMAP, XColor*); */
 621
 622 /*
 623  * FIXME: should free colors here, but no idea how to do it so instead,
 624  * so just keep gobbling up the colormap
 625  */
 626 # if 0
 627     for (i = Color_Black; i <= Color_White; i++)
 628         if (R->PixColors[idx] == R->PixColors[i])
 629             break;
 630     if (i > Color_White) {
 631         /* fprintf (stderr, "XFreeColors: R->PixColors [%d] = %lu\n", idx, R->PixColors [idx]); */
 632         XFreeColors(R->Xdisplay, XCMAP, (R->PixColors + idx), 1,
 633                     DisplayPlanes(R->Xdisplay, Xscreen));
 634     }
 635 # endif
 636
 637     R->PixColors[idx] = xcol;
 638     SET_PIXCOLOR(R->h, idx);
 639
 640 /* XSetWindowAttributes attr; */
 641 /* Cursor cursor; */
 642   Done:
 643     if (idx == Color_bg && !(R->Options & Opt_transparent))
 644         XSetWindowBackground(R->Xdisplay, R->TermWin.vt,
 645                              R->PixColors[Color_bg]);
 646
 647 /* handle Color_BD, scrollbar background, etc. */
 648
 649     rxvt_set_colorfgbg(aR);
 650     rxvt_recolour_cursor(aR);
 651 /* the only reasonable way to enforce a clean update */
 652     rxvt_scr_poweron(aR);
 653 }
 654
 655 #else
 656 # define rxvt_set_window_color(aR_ idx,color)   ((void)0)
 657 #endif                          /* XTERM_COLOR_CHANGE */
 658
 659 /* EXTPROTO */
 660 void
 661 rxvt_recolour_cursor(pR)
 662 {
 663     rxvt_color      xcol[2];
 664
 665 #if TODO
 666     xcol[0] = R->PixColors[Color_pointer];
 667     xcol[1] = R->PixColors[Color_bg];
 668     XQueryColors(R->Xdisplay, XCMAP, xcol, 2);
 669     XRecolorCursor(R->Xdisplay, R->TermWin_cursor, &(xcol[0]), &(xcol[1]));
 670 #endif
 671 }
 672
 673 /*----------------------------------------------------------------------*/
 674 /*
 675  * find if fg/bg matches any of the normal (low-intensity) colors
 676  */
 677 /* INTPROTO */
 678 void
 679 rxvt_set_colorfgbg(pR)
 680 {
 681     unsigned int    i;
 682     const char     *xpmb = "\0";
 683     char            fstr[sizeof("default") + 1], bstr[sizeof("default") + 1];
 684
 685     R->h->env_colorfgbg = (char *)rxvt_malloc(sizeof("COLORFGBG=default;default;bg") + 1);
 686     STRCPY(fstr, "default");
 687     STRCPY(bstr, "default");
 688     for (i = Color_Black; i <= Color_White; i++)
 689         if (R->PixColors[Color_fg] == R->PixColors[i]) {
 690             sprintf(fstr, "%d", (i - Color_Black));
 691             break;
 692         }
 693     for (i = Color_Black; i <= Color_White; i++)
 694         if (R->PixColors[Color_bg] == R->PixColors[i]) {
 695             sprintf(bstr, "%d", (i - Color_Black));
 696 #ifdef XPM_BACKGROUND
 697             xpmb = "default;";
 698 #endif
 699             break;
 700         }
 701     sprintf(R->h->env_colorfgbg, "COLORFGBG=%s;%s%s", fstr, xpmb, bstr);
 702     putenv(R->h->env_colorfgbg);
 703
 704 #ifndef NO_BRIGHTCOLOR
 705     R->h->colorfgbg = DEFAULT_RSTYLE;
 706     for (i = minCOLOR; i <= maxCOLOR; i++) {
 707         if (R->PixColors[Color_fg] == R->PixColors[i])
 708             R->h->colorfgbg = SET_FGCOLOR(R->h->colorfgbg, i);
 709         if (R->PixColors[Color_bg] == R->PixColors[i])
 710             R->h->colorfgbg = SET_BGCOLOR(R->h->colorfgbg, i);
 711     }
 712 #endif
 713 }
 714
 715 /*----------------------------------------------------------------------*/
 716 /*
 717  * Colour determination for low colour displays, routine from
 718  *     Hans de Goede <hans@highrise.nl>
 719  */
 720
 721 /* EXTPROTO */
 722 int
 723 rxvt_rXParseAllocColor(pR_ rxvt_color *screen_in_out, const char *colour)
 724 {
 725     screen_in_out->set (aR_ colour);
 726
 727     if (!screen_in_out->set (aR_ colour))
 728       {
 729         rxvt_print_error("can't allocate colour: %s", colour);
 730         return false;
 731       }
 732
 733     return true;
 734 }
 735
 736 /* -------------------------------------------------------------------- *
 737  * -                         WINDOW RESIZING                          - *
 738  * -------------------------------------------------------------------- */
 739 /* EXTPROTO */
 740 void
 741 rxvt_resize_all_windows(pR_ unsigned int width, unsigned int height, int ignoreparent)
 742 {
 743     int             fix_screen;
 744 #ifdef SMART_RESIZE
 745     int             old_width = R->szHint.width,
 746                     old_height = R->szHint.height;
 747 #endif
 748
 749     rxvt_window_calc(aR_ width, height);
 750     XSetWMNormalHints(R->Xdisplay, R->TermWin.parent[0], &R->szHint);
 751     if (!ignoreparent) {
 752 #ifdef SMART_RESIZE
 753 /*
 754  * resize by Marius Gedminas <marius.gedminas@uosis.mif.vu.lt>
 755  * reposition window on resize depending on placement on screen
 756  */
 757         int             x, y, x1, y1;
 758         int             dx, dy;
 759         unsigned int    unused_w1, unused_h1, unused_b1, unused_d1;
 760         Window          unused_cr;
 761
 762         XTranslateCoordinates(R->Xdisplay, R->TermWin.parent[0], Xroot,
 763                               0, 0, &x, &y, &unused_cr);
 764         XGetGeometry(R->Xdisplay, R->TermWin.parent[0], &unused_cr, &x1, &y1,
 765                      &unused_w1, &unused_h1, &unused_b1, &unused_d1);
 766         /*
 767          * if Xroot isn't the parent window, a WM will probably have offset
 768          * our position for handles and decorations.  Counter it
 769          */
 770         if (x1 != x || y1 != y) {
 771             x -= x1;
 772             y -= y1;
 773         }
 774
 775         x1 = (DisplayWidth(R->Xdisplay, Xscreen) - old_width) / 2;
 776         y1 = (DisplayHeight(R->Xdisplay, Xscreen) - old_height) / 2;
 777         dx = old_width - R->szHint.width;
 778         dy = old_height - R->szHint.height;
 779
 780         /* Check position of the center of the window */
 781         if (x < x1)             /* left half */
 782             dx = 0;
 783         else if (x == x1)       /* exact center */
 784             dx /= 2;
 785         if (y < y1)             /* top half */
 786             dy = 0;
 787         else if (y == y1)       /* exact center */
 788             dy /= 2;
 789
 790         XMoveResizeWindow(R->Xdisplay, R->TermWin.parent[0], x + dx, y + dy,
 791                           R->szHint.width, R->szHint.height);
 792 #else
 793         XResizeWindow(R->Xdisplay, R->TermWin.parent[0], R->szHint.width,
 794                       R->szHint.height);
 795 #endif
 796     }
 797
 798     fix_screen = (R->TermWin.ncol != R->h->prev_ncol
 799                   || R->TermWin.nrow != R->h->prev_nrow);
 800     if (fix_screen || width != R->h->old_width || height != R->h->old_height) {
 801         if (scrollbar_visible(R)) {
 802             XMoveResizeWindow(R->Xdisplay, R->scrollBar.win, R->h->window_sb_x,
 803                               0, scrollbar_TotalWidth(), R->szHint.height);
 804             rxvt_Resize_scrollBar(aR);
 805         }
 806         if (menubar_visible(R))
 807             XMoveResizeWindow(R->Xdisplay, R->menuBar.win, R->h->window_vt_x,
 808                               0, TermWin_TotalWidth(), menuBar_TotalHeight());
 809         XMoveResizeWindow(R->Xdisplay, R->TermWin.vt, R->h->window_vt_x,
 810                           R->h->window_vt_y, TermWin_TotalWidth(),
 811                           TermWin_TotalHeight());
 812 #ifdef RXVT_GRAPHICS
 813         if (R->h->old_height)
 814             rxvt_Gr_Resize(aR_ R->h->old_width - R->szHint.base_width,
 815                            R->h->old_height - R->szHint.base_height);
 816 #endif
 817         rxvt_scr_clear(aR);
 818 #ifdef XPM_BACKGROUND
 819         rxvt_resize_pixmap(aR);
 820 #endif
 821     }
 822
 823     if (fix_screen || R->h->old_height == 0) {
 824         int             curr_screen = -1;
 825         uint16_t       old_ncol = R->h->prev_ncol;
 826
 827         /* scr_reset only works on the primary screen */
 828         if (R->h->old_height)   /* this is not the first time through */
 829             curr_screen = rxvt_scr_change_screen(aR_ PRIMARY);
 830         rxvt_scr_reset(aR);
 831         if (curr_screen >= 0) { /* this is not the first time through */
 832             rxvt_scr_change_screen(aR_ curr_screen);
 833             rxvt_selection_check(aR_ (old_ncol != R->TermWin.ncol ? 4 : 0));
 834         }
 835     }
 836
 837     R->h->old_width = R->szHint.width;
 838     R->h->old_height = R->szHint.height;
 839
 840 #ifdef USE_XIM
 841     rxvt_IMSetStatusPosition(aR);
 842 #endif
 843 }
 844
 845 /*
 846  * Set the width/height of the vt window in characters.  Units are pixels.
 847  * good for toggling 80/132 columns
 848  */
 849 /* EXTPROTO */
 850 void
 851 rxvt_set_widthheight(pR_ unsigned int width, unsigned int height)
 852 {
 853     XWindowAttributes wattr;
 854
 855     if (width == 0 || height == 0) {
 856         XGetWindowAttributes(R->Xdisplay, Xroot, &wattr);
 857         if (width == 0)
 858             width = wattr.width - R->szHint.base_width;
 859         if (height == 0)
 860             height = wattr.height - R->szHint.base_height;
 861     }
 862     if (width != R->TermWin.width || height != R->TermWin.height) {
 863         width += R->szHint.base_width;
 864         height += R->szHint.base_height;
 865         rxvt_resize_all_windows(aR_ width, height, 0);
 866     }
 867 }
 868
 869 /* -------------------------------------------------------------------- *
 870  * -                      X INPUT METHOD ROUTINES                     - *
 871  * -------------------------------------------------------------------- */
 872 #ifdef USE_XIM
 873 /* INTPROTO */
 874 void
 875 rxvt_setSize(pR_ XRectangle *size)
 876 {
 877     size->x = R->TermWin.int_bwidth;
 878     size->y = R->TermWin.int_bwidth;
 879     size->width = Width2Pixel(R->TermWin.ncol);
 880     size->height = Height2Pixel(R->TermWin.nrow);
 881 }
 882
 883 /* INTPROTO */
 884 void
 885 rxvt_setColor(pR_ unsigned long *fg, unsigned long *bg)
 886 {
 887     *fg = R->PixColors[Color_fg];
 888     *bg = R->PixColors[Color_bg];
 889 }
 890
 891 /* Checking whether input method is running. */
 892 /* INTPROTO */
 893 Bool
 894 rxvt_IMisRunning(pR)
 895 {
 896     char           *p;
 897     Atom            atom;
 898     Window          win;
 899     char            server[IMBUFSIZ];
 900
 901     /* get current locale modifier */
 902     if ((p = XSetLocaleModifiers(NULL)) != NULL) {
 903         STRCPY(server, "@server=");
 904         STRNCAT(server, &(p[4]), IMBUFSIZ - 9); /* skip "@im=" */
 905         if ((p = STRCHR(server + 1, '@')) != NULL)      /* first one only */
 906             *p = '\0';
 907
 908         atom = XInternAtom(R->Xdisplay, server, False);
 909         win = XGetSelectionOwner(R->Xdisplay, atom);
 910         if (win != None)
 911             return True;
 912     }
 913     return False;
 914 }
 915
 916 /* EXTPROTO */
 917 void
 918 rxvt_IMSendSpot(pR)
 919 {
 920     XPoint          spot;
 921     XVaNestedList   preedit_attr;
 922
 923     if (R->h->Input_Context == NULL
 924         || !R->TermWin.focus
 925         || !(R->h->input_style & XIMPreeditPosition)
 926         || !(R->h->event_type == KeyPress
 927              || R->h->event_type == Expose
 928              || R->h->event_type == NoExpose
 929              || R->h->event_type == SelectionNotify
 930              || R->h->event_type == ButtonRelease
 931              || R->h->event_type == FocusIn)
 932         || !rxvt_IMisRunning(aR))
 933         return;
 934
 935     rxvt_setPosition(aR_ &spot);
 936
 937     preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
 938     XSetICValues(R->h->Input_Context, XNPreeditAttributes, preedit_attr, NULL);
 939     XFree(preedit_attr);
 940 }
 941
 942 /* EXTPROTO */
 943 void
 944 rxvt_setTermFontSet(pR_ int idx)
 945 {
 946     char           *string;
 947     long            length;
 948     int             success = 0;
 949
 950     if (idx < 0 || idx >= MAX_NFONTS)
 951         return;
 952 }
 953
 954 /* INTPROTO */
 955 void
 956 rxvt_setPreeditArea(pR_ XRectangle *preedit_rect, XRectangle *status_rect, XRectangle *needed_rect)
 957 {
 958     int             mbh, vtx = 0;
 959
 960     if (scrollbar_visible(R) && !(R->Options & Opt_scrollBar_right))
 961         vtx = scrollbar_TotalWidth();
 962     mbh = menubar_visible(R) ? menuBar_TotalHeight() : 0;
 963     mbh -= R->TermWin.lineSpace;
 964
 965     preedit_rect->x = needed_rect->width + vtx;
 966     preedit_rect->y = Height2Pixel(R->TermWin.nrow - 1) + mbh;
 967
 968     preedit_rect->width = Width2Pixel(R->TermWin.ncol + 1) - needed_rect->width
 969                           + vtx;
 970     preedit_rect->height = Height2Pixel(1);
 971
 972     status_rect->x = vtx;
 973     status_rect->y = Height2Pixel(R->TermWin.nrow - 1) + mbh;
 974
 975     status_rect->width = needed_rect->width ? needed_rect->width
 976                                             : Width2Pixel(R->TermWin.ncol + 1);
 977     status_rect->height = Height2Pixel(1);
 978 }
 979
 980 /* ARGSUSED */
 981 /* INTPROTO */
 982 void
 983 rxvt_IMDestroyCallback(XIM xim __attribute__((unused)), XPointer client_data __attribute__((unused)), XPointer call_data __attribute__((unused)))
 984 {
 985     dR;
 986
 987     R->h->Input_Context = NULL;
 988     /* To avoid Segmentation Fault in C locale: Solaris only? */
 989     if (STRCMP(R->h->locale, "C"))
 990         XRegisterIMInstantiateCallback(R->Xdisplay, NULL, NULL, NULL,
 991                                        rxvt_IMInstantiateCallback, NULL);
 992 }
 993
 994 /*
 995  * X manual pages and include files don't match on some systems:
 996  * some think this is an XIDProc and others an XIMProc so we can't
 997  * use the first argument - need to update this to be nice for
 998  * both types via some sort of configure detection
 999  */
1000 /* ARGSUSED */
1001 /* EXTPROTO */
1002 void
1003 rxvt_IMInstantiateCallback(Display *unused __attribute__((unused)), XPointer client_data __attribute__((unused)), XPointer call_data __attribute__((unused)))
1004 {
1005     dR;
1006     int             i, found, had_im;
1007     const char     *p;
1008     char          **s;
1009     char            buf[IMBUFSIZ];
1010
1011     D_MAIN((stderr, "rxvt_IMInstantiateCallback()"));
1012     if (R->h->Input_Context)
1013         return;
1014
1015     found = had_im = 0;
1016     p = R->h->rs[Rs_inputMethod];
1017     if (p && *p) {
1018         had_im = 1;
1019         s = rxvt_splitcommastring(p);
1020         for (i = 0; s[i]; i++) {
1021             if (*s[i]) {
1022                 STRCPY(buf, "@im=");
1023                 STRNCAT(buf, s[i], IMBUFSIZ - 5);
1024                 if ((p = XSetLocaleModifiers(buf)) != NULL && *p
1025                     && (rxvt_IM_get_IC(aR) == True)) {
1026                     found = 1;
1027                     break;
1028                 }
1029             }
1030         }
1031         for (i = 0; s[i]; i++)
1032             free(s[i]);
1033         free(s);
1034     }
1035     if (found)
1036         return;
1037
1038 /* try with XMODIFIERS env. var. */
1039     if ((p = XSetLocaleModifiers("")) != NULL && *p) {
1040         rxvt_IM_get_IC(aR);
1041         return;
1042     }
1043
1044 /* try with no modifiers base IF the user didn't specify an IM */
1045     if (!had_im && (p = XSetLocaleModifiers("@im=none")) != NULL && *p
1046         && rxvt_IM_get_IC(aR) == True)
1047         return;
1048 }
1049
1050 /*
1051  * Try to open a XIM with the current modifiers, then see if we can
1052  * open a suitable preedit type
1053  */
1054 /* INTPROTO */
1055 Bool
1056 rxvt_IM_get_IC(pR)
1057 {
1058     int             i, j, found;
1059     XIM             xim;
1060     XPoint          spot;
1061     XRectangle      rect, status_rect, needed_rect;
1062     unsigned long   fg, bg;
1063     const char     *p;
1064     char          **s;
1065     XIMStyles      *xim_styles;
1066     XVaNestedList   preedit_attr, status_attr;
1067     XIMCallback     ximcallback;
1068     struct rxvt_hidden *h = R->h;
1069
1070     D_MAIN((stderr, "rxvt_IM_get_IC()"));
1071     xim = XOpenIM(R->Xdisplay, NULL, NULL, NULL);
1072     if (xim == NULL)
1073         return False;
1074
1075     xim_styles = NULL;
1076     if (XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL)
1077         || !xim_styles || !xim_styles->count_styles) {
1078         XCloseIM(xim);
1079         return False;
1080     }
1081
1082     p = h->rs[Rs_preeditType] ? h->rs[Rs_preeditType]
1083                               : "OverTheSpot,OffTheSpot,Root";
1084     s = rxvt_splitcommastring(p);
1085     for (i = found = 0; !found && s[i]; i++) {
1086         if (!STRCMP(s[i], "OverTheSpot"))
1087             h->input_style = (XIMPreeditPosition | XIMStatusNothing);
1088         else if (!STRCMP(s[i], "OffTheSpot"))
1089             h->input_style = (XIMPreeditArea | XIMStatusArea);
1090         else if (!STRCMP(s[i], "Root"))
1091             h->input_style = (XIMPreeditNothing | XIMStatusNothing);
1092
1093         for (j = 0; j < xim_styles->count_styles; j++)
1094             if (h->input_style == xim_styles->supported_styles[j]) {
1095                 found = 1;
1096                 break;
1097             }
1098     }
1099     for (i = 0; s[i]; i++)
1100         free(s[i]);
1101     free(s);
1102     XFree(xim_styles);
1103
1104     if (!found) {
1105         XCloseIM(xim);
1106         return False;
1107     }
1108
1109     ximcallback.callback = rxvt_IMDestroyCallback;
1110
1111     /* XXX: not sure why we need this (as well as IC one below) */
1112     XSetIMValues(xim, XNDestroyCallback, &ximcallback, NULL);
1113
1114     preedit_attr = status_attr = NULL;
1115
1116     if (h->input_style & XIMPreeditPosition) {
1117         rxvt_setSize(aR_ &rect);
1118         rxvt_setPosition(aR_ &spot);
1119         rxvt_setColor(aR_ &fg, &bg);
1120
1121         preedit_attr = XVaCreateNestedList(0, XNArea, &rect,
1122                                            XNSpotLocation, &spot,
1123                                            XNForeground, fg,
1124                                            XNBackground, bg,
1125                                            //XNFontSet, R->TermWin.fontset,
1126                                            NULL);
1127     } else if (h->input_style & XIMPreeditArea) {
1128         rxvt_setColor(aR_ &fg, &bg);
1129
1130         /*
1131          * The necessary width of preedit area is unknown
1132          * until create input context.
1133          */
1134         needed_rect.width = 0;
1135
1136         rxvt_setPreeditArea(aR_ &rect, &status_rect, &needed_rect);
1137
1138         preedit_attr = XVaCreateNestedList(0, XNArea, &rect,
1139                                            XNForeground, fg,
1140                                            XNBackground, bg,
1141                                            //XNFontSet, R->TermWin.fontset,
1142                                            NULL);
1143         status_attr = XVaCreateNestedList(0, XNArea, &status_rect,
1144                                           XNForeground, fg,
1145                                           XNBackground, bg,
1146                                           //XNFontSet, R->TermWin.fontset,
1147                                           NULL);
1148     }
1149     h->Input_Context = XCreateIC(xim, XNInputStyle, h->input_style,
1150                                  XNClientWindow, R->TermWin.parent[0],
1151                                  XNFocusWindow, R->TermWin.parent[0],
1152                                  XNDestroyCallback, &ximcallback,
1153                                  preedit_attr ? XNPreeditAttributes : NULL,
1154                                  preedit_attr,
1155                                  status_attr ? XNStatusAttributes : NULL,
1156                                  status_attr, NULL);
1157     if (preedit_attr)
1158         XFree(preedit_attr);
1159     if (status_attr)
1160         XFree(status_attr);
1161     if (h->Input_Context == NULL) {
1162         rxvt_print_error("failed to create input context");
1163         XCloseIM(xim);
1164         return False;
1165     }
1166     if (h->input_style & XIMPreeditArea)
1167         rxvt_IMSetStatusPosition(aR);
1168     D_MAIN((stderr, "rxvt_IM_get_IC() - successful connection"));
1169     return True;
1170 }
1171
1172 /* EXTPROTO */
1173 void
1174 rxvt_IMSetStatusPosition(pR)
1175 {
1176     XRectangle      preedit_rect, status_rect, *needed_rect;
1177     XVaNestedList   preedit_attr, status_attr;
1178
1179     if (R->h->Input_Context == NULL
1180         || !R->TermWin.focus
1181         || !(R->h->input_style & XIMPreeditArea)
1182         || !rxvt_IMisRunning(aR))
1183         return;
1184
1185     /* Getting the necessary width of preedit area */
1186     status_attr = XVaCreateNestedList(0, XNAreaNeeded, &needed_rect, NULL);
1187     XGetICValues(R->h->Input_Context, XNStatusAttributes, status_attr, NULL);
1188     XFree(status_attr);
1189
1190     rxvt_setPreeditArea(aR_ &preedit_rect, &status_rect, needed_rect);
1191
1192     preedit_attr = XVaCreateNestedList(0, XNArea, &preedit_rect, NULL);
1193     status_attr = XVaCreateNestedList(0, XNArea, &status_rect, NULL);
1194
1195     XSetICValues(R->h->Input_Context,
1196                  XNPreeditAttributes, preedit_attr,
1197                  XNStatusAttributes, status_attr, NULL);
1198
1199     XFree(preedit_attr);
1200     XFree(status_attr);
1201 }
1202 #endif                          /* USE_XIM */
1203
1204 /*----------------------------------------------------------------------*/
1205 rxvt_t *rxvt_current_term;
1206
1207 /*----------------------- end-of-file (C source) -----------------------*/