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