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);
}
