int main (int argc, char **argv) { int i; char **argv_copy; int argc_copy; const char *startup_id, *display_name, *home_dir; GdkDisplay *display; TerminalOptions *options; GError *error = NULL; char *working_directory; int ret = EXIT_SUCCESS; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, TERM_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); _terminal_debug_init (); /* Make a NULL-terminated copy since we may need it later */ argv_copy = g_new (char *, argc + 1); for (i = 0; i < argc; ++i) argv_copy [i] = argv [i]; argv_copy [i] = NULL; argc_copy = argc; startup_id = g_getenv ("DESKTOP_STARTUP_ID"); working_directory = g_get_current_dir (); /* Now change directory to $HOME so we don't prevent unmounting, e.g. if the * factory is started by caja-open-terminal. See bug #565328. * On failure back to /. */ home_dir = g_get_home_dir (); if (home_dir == NULL || chdir (home_dir) < 0) (void) chdir ("/"); options = terminal_options_parse (working_directory, NULL, startup_id, NULL, FALSE, FALSE, &argc, &argv, &error, gtk_get_option_group (TRUE), egg_sm_client_get_option_group (), NULL); g_free (working_directory); if (options == NULL) { g_printerr (_("Failed to parse arguments: %s\n"), error->message); g_error_free (error); exit (EXIT_FAILURE); } g_set_application_name (_("Terminal")); /* Unset the these env variables, so they doesn't end up * in the factory's env and thus in the terminals' envs. */ g_unsetenv ("DESKTOP_STARTUP_ID"); g_unsetenv ("GIO_LAUNCHED_DESKTOP_FILE_PID"); g_unsetenv ("GIO_LAUNCHED_DESKTOP_FILE"); display = gdk_display_get_default (); display_name = gdk_display_get_name (display); options->display_name = g_strdup (display_name); if (options->startup_id == NULL) { /* Create a fake one containing a timestamp that we can use */ Time timestamp; timestamp = slowly_and_stupidly_obtain_timestamp (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ())); options->startup_id = g_strdup_printf ("_TIME%lu", timestamp); } if (options->use_factory) { OwnData *data; guint owner_id; data = g_new (OwnData, 1); data->factory_name = get_factory_name_for_display (display_name); data->options = options; data->exit_code = -1; data->argv = argv_copy; data->argc = argc_copy; gtk_init(&argc, &argv); options->initial_workspace = get_initial_workspace (); owner_id = g_bus_own_name (G_BUS_TYPE_SESSION, data->factory_name, G_BUS_NAME_OWNER_FLAGS_NONE, bus_acquired_cb, name_acquired_cb, name_lost_cb, data, NULL); gtk_main (); ret = data->exit_code; g_bus_unown_name (owner_id); g_free (data->factory_name); g_free (data); } else { terminal_app_handle_options (terminal_app_get (), options, TRUE /* allow resume */, &error); terminal_options_free (options); if (error == NULL) { gtk_main (); } else { g_printerr ("Error handling options: %s\n", error->message); g_error_free (error); ret = EXIT_FAILURE; } } terminal_app_shutdown (); g_free (argv_copy); return ret; }
int main (int argc, char *argv[]) { gboolean kill_shell; gboolean restart_shell; gboolean no_default_window; gboolean browser_window; gboolean no_desktop; const char *startup_id; char *startup_id_copy; char *session_to_load; gchar *geometry; const gchar **remaining; gboolean perform_self_check; GOptionContext *context; NautilusApplication *application; char **argv_copy; GnomeProgram *program; const GOptionEntry options[] = { #ifndef NAUTILUS_OMIT_SELF_CHECK { "check", 'c', 0, G_OPTION_ARG_NONE, &perform_self_check, N_("Perform a quick set of self-check tests."), NULL }, #endif { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry, N_("Create the initial window with the given geometry."), N_("GEOMETRY") }, { "no-default-window", 'n', 0, G_OPTION_ARG_NONE, &no_default_window, N_("Only create windows for explicitly specified URIs."), NULL }, { "no-desktop", '\0', 0, G_OPTION_ARG_NONE, &no_desktop, N_("Do not manage the desktop (ignore the preference set in the preferences dialog)."), NULL }, { "browser", '\0', 0, G_OPTION_ARG_NONE, &browser_window, N_("open a browser window."), NULL }, { "quit", 'q', 0, G_OPTION_ARG_NONE, &kill_shell, N_("Quit Nautilus."), NULL }, { "restart", '\0', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &restart_shell, N_("Restart Nautilus."), NULL }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") }, { "load-session", 'l', 0, G_OPTION_ARG_STRING, &session_to_load, /* Translators: --no-default-window is a nautilus command line parameter, don't modify it. */ N_("Load a saved session from the specified file. Implies \"--no-default-window\"."), N_("FILENAME") }, { NULL } }; g_thread_init (NULL); setlocale (LC_ALL, ""); /* This will be done by gtk+ later, but for now, force it to GNOME */ g_desktop_app_info_set_desktop_env ("GNOME"); if (g_getenv ("NAUTILUS_DEBUG") != NULL) { eel_make_warnings_and_criticals_stop_in_debugger (); } /* Initialize gettext support */ bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); startup_id = g_getenv ("DESKTOP_STARTUP_ID"); startup_id_copy = NULL; if (startup_id != NULL && *startup_id != '\0') { /* Clear the DESKTOP_STARTUP_ID, but make sure to copy it first */ startup_id_copy = g_strdup (startup_id); g_unsetenv ("DESKTOP_STARTUP_ID"); } /* we'll do it ourselves due to complicated factory setup */ gtk_window_set_auto_startup_notification (FALSE); /* Get parameters. */ remaining = NULL; geometry = NULL; session_to_load = NULL; kill_shell = FALSE; no_default_window = FALSE; no_desktop = FALSE; perform_self_check = FALSE; restart_shell = FALSE; browser_window = FALSE; g_set_application_name (_("File Manager")); context = g_option_context_new (_("\n\nBrowse the file system with the file manager")); g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE); #ifdef HAVE_EXEMPI xmp_init(); #endif program = gnome_program_init ("nautilus", VERSION, LIBGNOMEUI_MODULE, argc, argv, GNOME_PROGRAM_STANDARD_PROPERTIES, GNOME_PARAM_GOPTION_CONTEXT, context, GNOME_PARAM_HUMAN_READABLE_NAME, _("Nautilus"), NULL); /* We do this after gnome_program_init(), since that function sets up * its own handler for SIGSEGV and others --- we want to chain to those * handlers. */ setup_debug_log (); if (session_to_load != NULL) { no_default_window = TRUE; } /* Do this here so that gdk_display is initialized */ if (startup_id_copy == NULL) { /* Create a fake one containing a timestamp that we can use */ Time timestamp; timestamp = slowly_and_stupidly_obtain_timestamp (gdk_display); startup_id_copy = g_strdup_printf ("_TIME%lu", timestamp); } /* Set default icon for all nautilus windows */ gtk_window_set_default_icon_name (NAUTILUS_ICON_FOLDER); /* Need to set this to the canonical DISPLAY value, since thats where we're registering per-display components */ bonobo_activation_set_activation_env_value ("DISPLAY", gdk_display_get_name (gdk_display_get_default())); if (perform_self_check && remaining != NULL) { /* translators: %s is an option (e.g. --check) */ fprintf (stderr, _("nautilus: %s cannot be used with URIs.\n"), "--check"); return EXIT_FAILURE; } if (perform_self_check && (kill_shell || restart_shell)) { fprintf (stderr, _("nautilus: --check cannot be used with other options.\n")); return EXIT_FAILURE; } if (kill_shell && remaining != NULL) { fprintf (stderr, _("nautilus: %s cannot be used with URIs.\n"), "--quit"); return EXIT_FAILURE; } if (restart_shell && remaining != NULL) { fprintf (stderr, _("nautilus: %s cannot be used with URIs.\n"), "--restart"); return EXIT_FAILURE; } if (geometry != NULL && remaining != NULL && remaining[0] != NULL && remaining[1] != NULL) { fprintf (stderr, _("nautilus: --geometry cannot be used with more than one URI.\n")); return EXIT_FAILURE; } /* Initialize the services that we use. */ LIBXML_TEST_VERSION /* Initialize preferences. This is needed so that proper * defaults are available before any preference peeking * happens. */ nautilus_global_preferences_init (); if (no_desktop) { eel_preferences_set_is_invisible (NAUTILUS_PREFERENCES_SHOW_DESKTOP, TRUE); eel_preferences_set_is_invisible (NAUTILUS_PREFERENCES_DESKTOP_IS_HOME_DIR, TRUE); } bonobo_activate (); /* do now since we need it before main loop */ application = NULL; /* Do either the self-check or the real work. */ if (perform_self_check) { #ifndef NAUTILUS_OMIT_SELF_CHECK /* Run the checks (each twice) for nautilus and libnautilus-private. */ nautilus_run_self_checks (); nautilus_run_lib_self_checks (); eel_exit_if_self_checks_failed (); nautilus_run_self_checks (); nautilus_run_lib_self_checks (); eel_exit_if_self_checks_failed (); #endif } else { /* Run the nautilus application. */ application = nautilus_application_new (); nautilus_application_startup (application, kill_shell, restart_shell, no_default_window, no_desktop, !(kill_shell || restart_shell), browser_window, startup_id_copy, geometry, session_to_load, remaining); g_free (startup_id_copy); /* The application startup does things in an idle, so we need to check whether the main loop is needed in an idle */ g_idle_add (initial_event_loop_needed, NULL); gtk_main (); } nautilus_icon_info_clear_caches (); if (application != NULL) { bonobo_object_unref (application); } eel_debug_shut_down (); /* If told to restart, exec() myself again. This is used when * the program is told to restart with CORBA, for example when * an update takes place. */ if (g_getenv ("_NAUTILUS_RESTART") != NULL) { g_unsetenv ("_NAUTILUS_RESTART"); /* Might eventually want to copy all the parameters * from argv into the new exec. For now, though, that * would just interfere with the re-creation of * windows based on the window info stored in gconf, * including whether the desktop was started. */ argv_copy = g_new0 (char *, 2); argv_copy[0] = argv[0]; execvp (argv[0], argv_copy); }