ROX-Filer/src/main.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2005, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* main.c - parses command-line options and parameters, plus some global
  23  *          housekeeping.
  24  *
  25  * New to the code and feeling lost? Read global.h now.
  26  */
  27
  28 #include "config.h"
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <sys/types.h>
  33 #include <signal.h>
  34 #include <string.h>
  35 #include <sys/wait.h>
  36 #include <unistd.h>
  37 #include <fcntl.h>
  38 #include <pwd.h>
  39 #include <grp.h>
  40 #include <libxml/parser.h>
  41
  42 #ifdef HAVE_GETOPT_LONG
  43 #  include <getopt.h>
  44 #endif
  45
  46 #include <gtk/gtk.h>
  47 #include <gdk/gdkx.h>           /* For rox_x_error */
  48
  49 #include "global.h"
  50
  51 #include "main.h"
  52 #include "support.h"
  53 #include "gui_support.h"
  54 #include "filer.h"
  55 #include "display.h"
  56 #include "mount.h"
  57 #include "menu.h"
  58 #include "dnd.h"
  59 #include "options.h"
  60 #include "choices.h"
  61 #include "type.h"
  62 #include "pixmaps.h"
  63 #include "dir.h"
  64 #include "diritem.h"
  65 #include "action.h"
  66 #include "i18n.h"
  67 #include "remote.h"
  68 #include "pinboard.h"
  69 #include "run.h"
  70 #include "toolbar.h"
  71 #include "bind.h"
  72 #include "panel.h"
  73 #include "session.h"
  74 #include "minibuffer.h"
  75 #include "xtypes.h"
  76
  77 int number_of_windows = 0;      /* Quit when this reaches 0 again... */
  78 int to_wakeup_pipe = -1;        /* Write here to get noticed */
  79
  80 /* Information about the ROX-Filer process */
  81 uid_t euid;
  82 gid_t egid;
  83 int ngroups;                    /* Number of supplemental groups */
  84 gid_t *supplemental_groups = NULL;
  85
  86 /* Message to display at the top of each filer window */
  87 const gchar *show_user_message = NULL;
  88
  89 int home_dir_len;
  90 const char *home_dir, *app_dir;
  91
  92 GtkTooltips *tooltips = NULL;
  93
  94 #define COPYING                                                         \
  95              N_("Copyright (C) 2005 Thomas Leonard.\n"                  \
  96                 "ROX-Filer comes with ABSOLUTELY NO WARRANTY,\n"        \
  97                 "to the extent permitted by law.\n"                     \
  98                 "You may redistribute copies of ROX-Filer\n"            \
  99                 "under the terms of the GNU General Public License.\n"  \
 100                 "For more information about these matters, "            \
 101                 "see the file named COPYING.\n")
 102
 103 #ifdef HAVE_GETOPT_LONG
 104 #  define USAGE   N_("Try `ROX-Filer/AppRun --help' for more information.\n")
 105 #  define SHORT_ONLY_WARNING ""
 106 #else
 107 #  define USAGE   N_("Try `ROX-Filer/AppRun -h' for more information.\n")
 108 #  define SHORT_ONLY_WARNING    \
 109                 _("NOTE: Your system does not support long options - \n" \
 110                 "you must use the short versions instead.\n\n")
 111 #endif
 112
 113 #define BUGS_TO "<rox-devel@lists.sourceforge.net>"
 114
 115 #define HELP N_("Usage: ROX-Filer/AppRun [OPTION]... [FILE]...\n"       \
 116        "Open each directory or file listed, or the current working\n"   \
 117        "directory if no arguments are given.\n\n"                       \
 118        "  -b, --border=PANEL    open PANEL as a border panel\n" \
 119        "  -B, --bottom=PANEL    open PAN as a bottom-edge panel\n"      \
 120        "  -c, --client-id=ID    used for session management\n"          \
 121        "  -d, --dir=DIR         open DIR as directory (not application)\n"  \
 122        "  -D, --close=DIR       close DIR and its subdirectories\n"     \
 123        "  -h, --help            display this help and exit\n"           \
 124        "  -l, --left=PANEL      open PAN as a left-edge panel\n"        \
 125        "  -m, --mime-type=FILE  print MIME type of FILE and exit\n" \
 126        "  -n, --new             start new copy; for debugging the filer\n"  \
 127        "  -p, --pinboard=PIN    use pinboard PIN as the pinboard\n"     \
 128        "  -r, --right=PANEL     open PAN as a right-edge panel\n"       \
 129        "  -R, --RPC             invoke method call read from stdin\n"   \
 130        "  -s, --show=FILE       open a directory showing FILE\n"        \
 131        "  -S, --rox-session     use default panel and pinboard options, and -n\n"\
 132        "  -t, --top=PANEL       open PANEL as a top-edge panel\n"       \
 133        "  -u, --user            show user name in each window \n"       \
 134        "  -v, --version         display the version information and exit\n"   \
 135        "  -x, --examine=FILE    FILE has changed - re-examine it\n"     \
 136        "\nReport bugs to " BUGS_TO ".\n"                \
 137        "Home page (including updated versions): http://rox.sourceforge.net/\n")
 138
 139 #define SHORT_OPS "c:d:t:b:l:r:B:op:s:hvnux:m:D:RS"
 140
 141 #ifdef HAVE_GETOPT_LONG
 142 static struct option long_opts[] =
 143 {
 144         {"dir", 1, NULL, 'd'},
 145         {"top", 1, NULL, 't'},
 146         {"bottom", 1, NULL, 'B'},
 147         {"border", 1, NULL, 'b'},
 148         {"left", 1, NULL, 'l'},
 149         {"override", 0, NULL, 'o'},
 150         {"pinboard", 1, NULL, 'p'},
 151         {"right", 1, NULL, 'r'},
 152         {"help", 0, NULL, 'h'},
 153         {"version", 0, NULL, 'v'},
 154         {"user", 0, NULL, 'u'},
 155         {"new", 0, NULL, 'n'},
 156         {"RPC", 0, NULL, 'R'},
 157         {"show", 1, NULL, 's'},
 158         {"rox-session", 0, NULL, 'S'},
 159         {"examine", 1, NULL, 'x'},
 160         {"close", 1, NULL, 'D'},
 161         {"mime-type", 1, NULL, 'm'},
 162         {"client-id", 1, NULL, 'c'},
 163         {NULL, 0, NULL, 0},
 164 };
 165 #endif
 166
 167 /* Take control of panels away from WM? */
 168 Option o_override_redirect;
 169
 170 /* Options used when we are called by ROX-Session */
 171 enum {
 172         SESSION_PANEL_ONLY,
 173         SESSION_PINBOARD_ONLY,
 174         SESSION_BOTH,
 175 };
 176 Option o_session_panel_or_pin;
 177 Option o_session_panel_name;
 178 Option o_session_pinboard_name;
 179
 180 /* Always start a new filer, even if one seems to be already running */
 181 gboolean new_copy = FALSE;
 182
 183 /* Maps child PIDs to Callback pointers */
 184 static GHashTable *death_callbacks = NULL;
 185 static gboolean child_died_flag = FALSE;
 186
 187 Option o_dnd_no_hostnames;
 188
 189 /* Static prototypes */
 190 static void show_features(void);
 191 static void soap_add(xmlNodePtr body,
 192                            xmlChar *function,
 193                            const xmlChar *arg1_name, const xmlChar *arg1_value,
 194                            const xmlChar *arg2_name, const xmlChar *arg2_value);
 195 static void child_died(int signum);
 196 static void child_died_callback(void);
 197 static void wake_up_cb(gpointer data, gint source, GdkInputCondition condition);
 198 static void xrandr_size_change(GdkScreen *screen, gpointer user_data);
 199 static void add_default_panel_and_pinboard(xmlNodePtr body);
 200 static GList *build_launch(Option *option, xmlNode *node, guchar *label);
 201
 202 /****************************************************************
 203  *                      EXTERNAL INTERFACE                      *
 204  ****************************************************************/
 205
 206 /* The value that goes with an option */
 207 #define VALUE (*optarg == '=' ? optarg + 1 : optarg)
 208
 209 static int rox_x_error(Display *display, XErrorEvent *error)
 210 {
 211         gchar buf[64];
 212
 213         XGetErrorText(display, error->error_code, buf, 63);
 214
 215         g_warning ("The program '%s' received an X Window System error.\n"
 216                         "This probably reflects a bug in the program.\n"
 217                         "The error was '%s'.\n"
 218                         "  (Details: serial %ld error_code %d request_code %d minor_code %d)\n"
 219                         "  (Note to programmers: normally, X errors are reported asynchronously;\n"
 220                         "   that is, you will receive the error a while after causing it.\n"
 221                         "   To debug your program, run it with the --sync command line\n"
 222                         "   option to change this behavior. You can then get a meaningful\n"
 223                         "   backtrace from your debugger.)",
 224                         g_get_prgname (),
 225                         buf,
 226                         error->serial,
 227                         error->error_code,
 228                         error->request_code,
 229                         error->minor_code);
 230
 231         /* Try to cope with BadWindow errors */
 232         if (error->error_code == BadWindow || error->error_code == BadDrawable)
 233         {
 234                 g_warning(_("We got a BadWindow error from the X server. "
 235                             "This might be due to this GTK bug (during drag-and-drop?):\n"
 236                             "http://bugzilla.gnome.org/show_bug.cgi?id=152151\n"
 237                             "Trying to continue..."));
 238                 return 0;
 239         }
 240
 241         abort();
 242 }
 243
 244 /* Parses the command-line to work out what the user wants to do.
 245  * Tries to send the request to an already-running copy of the filer.
 246  * If that fails, it initialises all the other modules and executes the
 247  * request itself.
 248  */
 249 int main(int argc, char **argv)
 250 {
 251         int              wakeup_pipe[2];
 252         int              i;
 253         struct sigaction act;
 254         guchar          *tmp, *dir;
 255         gchar *client_id = NULL;
 256         gboolean        show_user = FALSE;
 257         xmlDocPtr       rpc, soap_rpc = NULL, reply;
 258         xmlNodePtr      body;
 259
 260         home_dir = g_get_home_dir();
 261         home_dir_len = strlen(home_dir);
 262         app_dir = g_strdup(getenv("APP_DIR"));
 263
 264         /* Get internationalisation up and running. This requires the
 265          * choices system, to discover the user's preferred language.
 266          */
 267         choices_init();
 268         options_init();
 269         i18n_init();
 270         xtype_init();
 271
 272 #ifdef HAVE_GNOME_VFS
 273         if (!gnome_vfs_init())
 274                 g_warning("Failed to init gnomevfs!");
 275 #endif
 276
 277         if (!app_dir)
 278         {
 279                 g_warning("APP_DIR environment variable was unset!\n"
 280                         "Use the AppRun script to invoke ROX-Filer...\n");
 281                 app_dir = g_get_current_dir();
 282         }
 283 #ifdef HAVE_UNSETENV
 284         else
 285         {
 286                 /* Don't pass it on to our child processes... */
 287                 unsetenv("APP_DIR");
 288         }
 289 #endif
 290
 291         /* Sometimes we want to take special action when a child
 292          * process exits. This hash table is used to convert the
 293          * child's PID to the callback function.
 294          */
 295         death_callbacks = g_hash_table_new(NULL, NULL);
 296
 297         /* Find out some information about ourself */
 298         euid = geteuid();
 299         egid = getegid();
 300         ngroups = getgroups(0, NULL);
 301         if (ngroups < 0)
 302                 ngroups = 0;
 303         else if (ngroups > 0)
 304         {
 305                 supplemental_groups = g_malloc(sizeof(gid_t) * ngroups);
 306                 getgroups(ngroups, supplemental_groups);
 307         }
 308
 309         if (argc == 2 && strcmp(argv[1], "-v") == 0)
 310         {
 311                 /* This is used by install.sh to test if the filer
 312                  * compiled OK. Do this test before gtk_init so that
 313                  * we don't need an X server to install.
 314                  */
 315                 g_print("ROX-Filer %s\n", VERSION);
 316                 g_print(_(COPYING));
 317                 show_features();
 318                 return EXIT_SUCCESS;
 319         }
 320
 321         option_add_int(&o_override_redirect, "override_redirect", FALSE);
 322
 323         option_add_int(&o_session_panel_or_pin, "session_panel_or_pin",
 324                        SESSION_BOTH);
 325         option_add_string(&o_session_panel_name, "session_panel_name",
 326                           "Default");
 327         option_add_string(&o_session_pinboard_name, "session_pinboard_name",
 328                           "Default");
 329         option_register_widget("launch", build_launch);
 330
 331         /* The idea here is to convert the command-line arguments
 332          * into a SOAP RPC.
 333          * We attempt to invoke the call on an already-running copy of
 334          * the filer if possible, or execute it ourselves if not.
 335          */
 336         rpc = soap_new(&body);
 337
 338         /* Note: must do this before checking our options,
 339          * otherwise we report an error for Gtk's options.
 340          */
 341         gtk_init(&argc, &argv);
 342         /* Set a default style for the collection widget */
 343         gtk_rc_parse_string("style \"rox-default-collection-style\" {\n"
 344                 "  bg[NORMAL] = \"#f3f3f3\"\n"
 345                 "  fg[NORMAL] = \"#000000\"\n"
 346                 "  bg[INSENSITIVE] = \"#bfbfbf\"\n"
 347                 "  fg[INSENSITIVE] = \"#000000\"\n"
 348                 "}\n"
 349                 "style \"rox-default-pinboard-style\" {\n"
 350                 "  bg[NORMAL] = \"#666666\"\n"
 351                 "}\n"
 352                 "widget \"rox-pinboard\" style : gtk "
 353                 "\"rox-default-pinboard-style\"\n"
 354
 355                 "class \"Collection\" style : gtk "
 356                 "\"rox-default-collection-style\"\n");
 357
 358         g_signal_connect(gdk_screen_get_default(), "size-changed",
 359                          G_CALLBACK(xrandr_size_change), NULL);
 360
 361         /* Process each option in turn */
 362         while (1)
 363         {
 364                 int     c;
 365 #ifdef HAVE_GETOPT_LONG
 366                 int     long_index;
 367                 c = getopt_long(argc, argv, SHORT_OPS,
 368                                 long_opts, &long_index);
 369 #else
 370                 c = getopt(argc, argv, SHORT_OPS);
 371 #endif
 372
 373                 if (c == EOF)
 374                         break;          /* No more options */
 375
 376                 switch (c)
 377                 {
 378                         case 'n':
 379                                 new_copy = TRUE;
 380                                 break;
 381                         case 'o':
 382                                 info_message(_("The -o argument is no longer "
 383                                         "used. You can turn on override "
 384                                         "redirect from the Options box "
 385                                         "instead."));
 386                                 break;
 387                         case 'v':
 388                                 g_print("ROX-Filer %s\n", VERSION);
 389                                 g_print("%s", _(COPYING));
 390                                 show_features();
 391                                 return EXIT_SUCCESS;
 392                         case 'h':
 393                                 g_print("%s", _(HELP));
 394                                 g_print("%s", _(SHORT_ONLY_WARNING));
 395                                 return EXIT_SUCCESS;
 396                         case 'D':
 397                         case 'd':
 398                         case 'x':
 399                                 /* Argument is a path */
 400                                 if (c == 'd' && VALUE[0] == '/')
 401                                         tmp = g_strdup(VALUE);
 402                                 else
 403                                         tmp = pathdup(VALUE);
 404                                 soap_add(body,
 405                                         c == 'D' ? "CloseDir" :
 406                                         c == 'd' ? "OpenDir" :
 407                                         c == 'x' ? "Examine" : "Unknown",
 408                                         "Filename", tmp,
 409                                         NULL, NULL);
 410                                 g_free(tmp);
 411                                 break;
 412                         case 's':
 413                                 tmp = g_path_get_dirname(VALUE);
 414
 415                                 if (tmp[0] == '/')
 416                                         dir = NULL;
 417                                 else
 418                                         dir = pathdup(tmp);
 419
 420                                 soap_add(body, "Show",
 421                                         "Directory", dir ? dir : tmp,
 422                                         "Leafname", g_basename(VALUE));
 423                                 g_free(tmp);
 424                                 g_free(dir);
 425                                 break;
 426                         case 'l':
 427                         case 'r':
 428                         case 't':
 429                         case 'B':
 430                                 /* Argument is a leaf (or starts with /) */
 431                                 soap_add(body, "Panel", "Name", VALUE,
 432                                          "Side", c == 'l' ? "Left" :
 433                                                  c == 'r' ? "Right" :
 434                                                  c == 't' ? "Top" :
 435                                                  c == 'B' ? "Bottom" :
 436                                                  "Unkown");
 437                                 break;
 438                         case 'b':
 439                                 /* Argument is a leaf (or starts with /) */
 440                                 if (*VALUE)
 441                                         soap_add(body, "Panel", "Name", VALUE,
 442                                                         NULL, NULL);
 443                                 else
 444                                         soap_add(body, "Panel",
 445                                                         "Side", "Bottom",
 446                                                         NULL, NULL);
 447                                 break;
 448                         case 'p':
 449                                 soap_add(body, "Pinboard",
 450                                                 "Name", VALUE, NULL, NULL);
 451                                 break;
 452                         case 'u':
 453                                 show_user = TRUE;
 454                                 break;
 455                         case 'm':
 456                         {
 457                                 MIME_type *type;
 458                                 type_init();
 459                                 diritem_init();
 460                                 pixmaps_init();
 461                                 type = type_get_type(VALUE);
 462                                 printf("%s/%s\n", type->media_type,
 463                                                 type->subtype);
 464                                 return EXIT_SUCCESS;
 465                         }
 466                         case 'c':
 467                                 client_id = g_strdup(VALUE);
 468                                 break;
 469                         case 'R':
 470                                 soap_rpc = xmlParseFile("-");
 471                                 if (!soap_rpc)
 472                                         g_error("Invalid XML in RPC");
 473                                 break;
 474
 475                         case 'S':
 476                                 new_copy = TRUE;
 477                                 add_default_panel_and_pinboard(body);
 478                                 break;
 479
 480                         default:
 481                                 printf(_(USAGE));
 482                                 return EXIT_FAILURE;
 483                 }
 484         }
 485
 486         tooltips = gtk_tooltips_new();
 487
 488         if (euid == 0 || show_user)
 489                 show_user_message = g_strdup_printf(_("Running as user '%s'"),
 490                                                     user_name(euid));
 491
 492         /* Add each remaining (non-option) argument to the list of files
 493          * to run.
 494          */
 495         i = optind;
 496         while (i < argc)
 497         {
 498                 tmp = pathdup(argv[i++]);
 499
 500                 soap_add(body, "Run", "Filename", tmp, NULL, NULL);
 501
 502                 g_free(tmp);
 503         }
 504
 505         if (soap_rpc)
 506         {
 507                 if (body->xmlChildrenNode)
 508                         g_error("Can't use -R with other options - sorry!");
 509                 xmlFreeDoc(rpc);
 510                 body = NULL;
 511                 rpc = soap_rpc;
 512         }
 513         else if (!body->xmlChildrenNode)
 514         {
 515                 /* The user didn't request any action. Open the current
 516                  * directory.
 517                  */
 518                 guchar  *dir;
 519
 520                 dir = g_get_current_dir();
 521                 soap_add(body, "OpenDir", "Filename", dir, NULL, NULL);
 522                 g_free(dir);
 523         }
 524
 525         option_add_int(&o_dnd_no_hostnames, "dnd_no_hostnames", 1);
 526
 527         /* Try to send the request to an already-running copy of the filer */
 528         gui_support_init();
 529         if (remote_init(rpc, new_copy))
 530                 return EXIT_SUCCESS;    /* It worked - exit */
 531
 532         /* Put ourselves into the background (so 'rox' always works the
 533          * same, whether we're already running or not).
 534          * Not for -n, though (helps when debugging).
 535          */
 536         if (!new_copy)
 537         {
 538                 int fd;
 539                 pid_t child;
 540
 541                 child = fork();
 542                 if (child > 0)
 543                         _exit(0);       /* Parent exits */
 544                 /* Otherwise we're the child (or an error occurred - ignore
 545                  * it!).
 546                  */
 547
 548                 /* Close stdin. We don't need it, and it can cause problems if
 549                  * a child process wants a password, etc...
 550                  */
 551                 fd = open("/dev/null", O_RDONLY);
 552                 if (fd > 0)
 553                 {
 554                         close(0);
 555                         dup2(fd, 0);
 556                         close(fd);
 557                 }
 558         }
 559
 560         /* Initialize the rest of the filer... */
 561
 562         pixmaps_init();
 563
 564         dnd_init();
 565         bind_init();
 566         dir_init();
 567         diritem_init();
 568         menu_init();
 569         minibuffer_init();
 570         filer_init();
 571         toolbar_init();
 572         display_init();
 573         mount_init();
 574         type_init();
 575         action_init();
 576
 577         pinboard_init();
 578         panel_init();
 579
 580         /* Let everyone update */
 581         options_notify();
 582
 583         /* When we get a signal, we can't do much right then. Instead,
 584          * we send a char down this pipe, which causes the main loop to
 585          * deal with the event next time we're idle.
 586          */
 587         pipe(wakeup_pipe);
 588         close_on_exec(wakeup_pipe[0], TRUE);
 589         close_on_exec(wakeup_pipe[1], TRUE);
 590         gdk_input_add_full(wakeup_pipe[0], GDK_INPUT_READ, wake_up_cb,
 591                         NULL, NULL);
 592         to_wakeup_pipe = wakeup_pipe[1];
 593
 594         /* If the pipe is full then we're going to get woken up anyway... */
 595         set_blocking(to_wakeup_pipe, FALSE);
 596
 597         /* Let child processes die */
 598         act.sa_handler = child_died;
 599         sigemptyset(&act.sa_mask);
 600         act.sa_flags = SA_NOCLDSTOP;
 601         sigaction(SIGCHLD, &act, NULL);
 602
 603         /* Ignore SIGPIPE - check for EPIPE errors instead */
 604         act.sa_handler = SIG_IGN;
 605         sigemptyset(&act.sa_mask);
 606         act.sa_flags = 0;
 607         sigaction(SIGPIPE, &act, NULL);
 608
 609         /* Set up session managament if available */
 610         session_init(client_id);
 611         g_free(client_id);
 612
 613         /* See if we need to migrate the Choices directories*/
 614         choices_migrate();
 615
 616         /* Finally, execute the request */
 617         reply = run_soap(rpc);
 618         xmlFreeDoc(rpc);
 619         if (reply)
 620         {
 621                 /* Write the result, if any, to stdout */
 622                 save_xml_file(reply, "-");
 623                 xmlFreeDoc(reply);
 624         }
 625
 626         /* Try to find out why we crash with GTK 2.4 */
 627         XSetErrorHandler(rox_x_error);
 628
 629         /* Enter the main loop, processing events until all our windows
 630          * are closed.
 631          */
 632         if (number_of_windows > 0)
 633                 gtk_main();
 634
 635         return EXIT_SUCCESS;
 636 }
 637
 638 /* Register a function to be called when process number 'child' dies. */
 639 void on_child_death(gint child, CallbackFn callback, gpointer data)
 640 {
 641         Callback        *cb;
 642
 643         g_return_if_fail(callback != NULL);
 644
 645         cb = g_new(Callback, 1);
 646
 647         cb->callback = callback;
 648         cb->data = data;
 649
 650         g_hash_table_insert(death_callbacks, GINT_TO_POINTER(child), cb);
 651 }
 652
 653 void one_less_window(void)
 654 {
 655         if (--number_of_windows < 1)
 656                 gtk_main_quit();
 657 }
 658
 659 /****************************************************************
 660  *                      INTERNAL FUNCTIONS                      *
 661  ****************************************************************/
 662
 663 static void show_features(void)
 664 {
 665         g_print("\n");
 666         g_print(_("Compiled with GTK version %s\n"), GTK_VERSION);
 667         g_print(_("Running with GTK version %d.%d.%d\n"),
 668                                 gtk_major_version,
 669                                 gtk_minor_version,
 670                                 gtk_micro_version);
 671         g_print("\n-- %s --\n\n", _("features set at compile time"));
 672         g_print("%s... %s\n", _("Large File Support"),
 673 #ifdef LARGE_FILE_SUPPORT
 674                 _("Yes")
 675 #else
 676                 _("No")
 677 #endif
 678                 );
 679         g_print("%s... %s\n", _("GNOME-VFS library"),
 680 # ifdef HAVE_GNOME_VFS
 681                         _("Yes")
 682 # else
 683                         _("No (need 2.8.0 or later)")
 684 # endif
 685                   );
 686         g_print("%s... %s\n", _("Dnotify support"),
 687 #ifdef USE_DNOTIFY
 688                 _("Yes")
 689 #else
 690                 _("No")
 691 #endif
 692                );
 693         g_print("%s... %s\n", _("Binary compatibility"),
 694 #if defined(HAVE_APSYMBOLS_H) || defined(HAVE_APBUILD_APSYMBOLS_H)
 695                 _("Yes (can run with older glibc versions)")
 696 #else
 697                 _("No (apsymbols.h not found)")
 698 #endif
 699                );
 700 }
 701
 702 static void soap_add(xmlNodePtr body,
 703                            xmlChar *function,
 704                            const xmlChar *arg1_name, const xmlChar *arg1_value,
 705                            const xmlChar *arg2_name, const xmlChar *arg2_value)
 706 {
 707         xmlNodePtr node;
 708         xmlNs *rox;
 709
 710         rox = xmlSearchNsByHref(body->doc, body, ROX_NS);
 711
 712         node = xmlNewChild(body, rox, function, NULL);
 713
 714         if (arg1_name)
 715         {
 716                 xmlNewTextChild(node, rox, arg1_name, arg1_value);
 717                 if (arg2_name)
 718                         xmlNewTextChild(node, rox, arg2_name, arg2_value);
 719         }
 720 }
 721
 722 /* This is called as a signal handler; simply ensures that
 723  * child_died_callback() will get called later.
 724  */
 725 static void child_died(int signum)
 726 {
 727         child_died_flag = TRUE;
 728         write(to_wakeup_pipe, "\0", 1); /* Wake up! */
 729 }
 730
 731 static void child_died_callback(void)
 732 {
 733         int             status;
 734         gint            child;
 735
 736         child_died_flag = FALSE;
 737
 738         /* Find out which children exited and allow them to die */
 739         do
 740         {
 741                 Callback        *cb;
 742
 743                 child = waitpid(-1, &status, WNOHANG);
 744
 745                 if (child == 0 || child == -1)
 746                         return;
 747
 748                 cb = g_hash_table_lookup(death_callbacks,
 749                                 GINT_TO_POINTER(child));
 750                 if (cb)
 751                 {
 752                         cb->callback(cb->data);
 753                         g_hash_table_remove(death_callbacks,
 754                                         GINT_TO_POINTER(child));
 755                 }
 756
 757         } while (1);
 758 }
 759
 760 #define BUFLEN 40
 761 /* When data is written to_wakeup_pipe, this gets called from the event
 762  * loop some time later. Useful for getting out of signal handlers, etc.
 763  */
 764 static void wake_up_cb(gpointer data, gint source, GdkInputCondition condition)
 765 {
 766         char buf[BUFLEN];
 767
 768         read(source, buf, BUFLEN);
 769
 770         if (child_died_flag)
 771                 child_died_callback();
 772 #ifdef USE_DNOTIFY
 773         if (dnotify_wakeup_flag)
 774                 dnotify_wakeup();
 775 #endif
 776 }
 777
 778 static void xrandr_size_change(GdkScreen *screen, gpointer user_data)
 779 {
 780         gui_store_screen_geometry(screen);
 781
 782         panel_update_size();
 783         pinboard_update_size();
 784 }
 785
 786 static void add_default_panel_and_pinboard(xmlNodePtr body)
 787 {
 788         char *name;
 789
 790         if (o_session_panel_or_pin.int_value != SESSION_PANEL_ONLY)
 791         {
 792                 name=o_session_pinboard_name.value;
 793                 if (!name[0])
 794                         name="Default";
 795                 soap_add(body, "Pinboard","Name", name, NULL, NULL);
 796         }
 797
 798         if (o_session_panel_or_pin.int_value != SESSION_PINBOARD_ONLY)
 799         {
 800                 name = o_session_panel_name.value;
 801                 if (!name[0])
 802                         name="Default";
 803
 804                 soap_add(body, "Panel", "Name", name, NULL, NULL);
 805         }
 806 }
 807
 808 static GtkWidget *launch_button_new(const char *label, const char *uri)
 809 {
 810         GtkWidget *button;
 811         GClosure *closure;
 812
 813         button = button_new_mixed(GTK_STOCK_PREFERENCES, label);
 814         closure = g_cclosure_new_swap(G_CALLBACK(launch_uri),
 815                                         g_strdup(uri),
 816                                         (GClosureNotify) g_free);
 817         g_signal_connect_closure(button, "clicked", closure, FALSE);
 818
 819         allow_right_click(button);
 820
 821         return button;
 822 }
 823
 824 static GList *build_launch(Option *option, xmlNode *node, guchar *label)
 825 {
 826         GtkWidget *align;
 827         char *uri;
 828
 829         g_return_val_if_fail(option == NULL, NULL);
 830         g_return_val_if_fail(label != NULL, NULL);
 831
 832         uri = xmlGetProp(node, "uri");
 833
 834         g_return_val_if_fail(uri != NULL, NULL);
 835
 836         align = gtk_alignment_new(0, 0.5, 0, 0);
 837
 838         gtk_container_add(GTK_CONTAINER(align),
 839                         launch_button_new(_(label), uri));
 840
 841         g_free(uri);
 842
 843         return g_list_append(NULL, align);
 844 }