static void
open_window (NautilusApplication *application,
GFile *location, GdkScreen *screen, const char *geometry)
{
NautilusWindow *window;
nautilus_profile_start (NULL);
window = nautilus_application_create_window (application, screen);
if (location != NULL) {
nautilus_window_go_to (window, location);
} else {
nautilus_window_slot_go_home (nautilus_window_get_active_slot (window), 0);
}
if (geometry != NULL && !gtk_widget_get_visible (GTK_WIDGET (window))) {
/* never maximize windows opened from shell if a
* custom geometry has been requested.
*/
gtk_window_unmaximize (GTK_WINDOW (window));
eel_gtk_window_set_initial_geometry_from_string (GTK_WINDOW (window),
geometry,
APPLICATION_WINDOW_MIN_WIDTH,
APPLICATION_WINDOW_MIN_HEIGHT,
FALSE);
}
nautilus_profile_end (NULL);
}
void
nautilus_directory_emit_files_changed (NautilusDirectory *directory,
GList *changed_files)
{
nautilus_profile_start (NULL);
if (changed_files != NULL) {
g_signal_emit (directory,
signals[FILES_CHANGED], 0,
changed_files);
}
nautilus_profile_end (NULL);
}
void
nautilus_directory_emit_files_added (NautilusDirectory *directory,
GList *added_files)
{
nautilus_profile_start (NULL);
if (added_files != NULL) {
g_signal_emit (directory,
signals[FILES_ADDED], 0,
added_files);
}
nautilus_profile_end (NULL);
}
void
nautilus_directory_emit_change_signals (NautilusDirectory *directory,
GList *changed_files)
{
GList *p;
nautilus_profile_start (NULL);
for (p = changed_files; p != NULL; p = p->next) {
nautilus_file_emit_changed (p->data);
}
nautilus_directory_emit_files_changed (directory, changed_files);
nautilus_profile_end (NULL);
}
NautilusWindow *
nautilus_application_create_window (NautilusApplication *application,
GdkScreen *screen)
{
NautilusWindow *window;
char *geometry_string;
gboolean maximized;
g_return_val_if_fail (NAUTILUS_IS_APPLICATION (application), NULL);
nautilus_profile_start (NULL);
window = nautilus_window_new (screen);
maximized = g_settings_get_boolean
(nautilus_window_state, NAUTILUS_WINDOW_STATE_MAXIMIZED);
if (maximized) {
gtk_window_maximize (GTK_WINDOW (window));
} else {
gtk_window_unmaximize (GTK_WINDOW (window));
}
geometry_string = g_settings_get_string
(nautilus_window_state, NAUTILUS_WINDOW_STATE_GEOMETRY);
if (geometry_string != NULL &&
geometry_string[0] != 0) {
/* Ignore saved window position if a window with the same
* location is already showing. That way the two windows
* wont appear at the exact same location on the screen.
*/
eel_gtk_window_set_initial_geometry_from_string
(GTK_WINDOW (window),
geometry_string,
NAUTILUS_WINDOW_MIN_WIDTH,
NAUTILUS_WINDOW_MIN_HEIGHT,
another_navigation_window_already_showing (application, window));
}
g_free (geometry_string);
DEBUG ("Creating a new navigation window");
nautilus_profile_end (NULL);
return window;
}
static void
do_perform_self_checks (gint *exit_status)
{
#ifndef NAUTILUS_OMIT_SELF_CHECK
gtk_init (NULL, NULL);
nautilus_profile_start (NULL);
/* 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 ();
nautilus_profile_end (NULL);
#endif
*exit_status = EXIT_SUCCESS;
}
void
nautilus_application_open_location (NautilusApplication *application,
GFile *location,
GFile *selection,
const char *startup_id)
{
NautilusWindow *window;
NautilusWindowSlot *slot;
GList *sel_list = NULL;
nautilus_profile_start (NULL);
slot = get_window_slot_for_location (application, location);
if (!slot) {
window = nautilus_application_create_window (application, gdk_screen_get_default ());
slot = nautilus_window_get_active_slot (window);
} else {
window = nautilus_window_slot_get_window (slot);
nautilus_window_set_active_slot (window, slot);
gtk_window_present (GTK_WINDOW (window));
}
if (selection != NULL) {
sel_list = g_list_prepend (sel_list, nautilus_file_get (selection));
}
gtk_window_set_startup_id (GTK_WINDOW (window), startup_id);
nautilus_window_slot_open_location_full (slot, location, 0, sel_list, NULL, NULL);
if (sel_list != NULL) {
nautilus_file_list_free (sel_list);
}
nautilus_profile_end (NULL);
}
static gboolean
check_required_directories (NautilusApplication *application)
{
char *user_directory;
char *desktop_directory;
GSList *directories;
gboolean ret;
g_assert (NAUTILUS_IS_APPLICATION (application));
nautilus_profile_start (NULL);
ret = TRUE;
user_directory = nautilus_get_user_directory ();
desktop_directory = nautilus_get_desktop_directory ();
directories = NULL;
if (!g_file_test (user_directory, G_FILE_TEST_IS_DIR)) {
directories = g_slist_prepend (directories, user_directory);
}
if (!g_file_test (desktop_directory, G_FILE_TEST_IS_DIR)) {
directories = g_slist_prepend (directories, desktop_directory);
}
if (directories != NULL) {
int failed_count;
GString *directories_as_string;
GSList *l;
char *error_string;
const char *detail_string;
GtkDialog *dialog;
ret = FALSE;
failed_count = g_slist_length (directories);
directories_as_string = g_string_new ((const char *)directories->data);
for (l = directories->next; l != NULL; l = l->next) {
g_string_append_printf (directories_as_string, ", %s", (const char *)l->data);
}
error_string = _("Oops! Something went wrong.");
if (failed_count == 1) {
detail_string = g_strdup_printf (_("Unable to create a required folder. "
"Please create the following folder, or "
"set permissions such that it can be created:\n%s"),
directories_as_string->str);
} else {
detail_string = g_strdup_printf (_("Unable to create required folders. "
"Please create the following folders, or "
"set permissions such that they can be created:\n%s"),
directories_as_string->str);
}
dialog = eel_show_error_dialog (error_string, detail_string, NULL);
/* We need the main event loop so the user has a chance to see the dialog. */
gtk_application_add_window (GTK_APPLICATION (application),
GTK_WINDOW (dialog));
g_string_free (directories_as_string, TRUE);
}
g_slist_free (directories);
g_free (user_directory);
g_free (desktop_directory);
nautilus_profile_end (NULL);
return ret;
}
static gboolean
nautilus_application_local_command_line (GApplication *application,
gchar ***arguments,
gint *exit_status)
{
gboolean perform_self_check = FALSE;
gboolean version = FALSE;
gboolean browser = FALSE;
gboolean kill_shell = FALSE;
gboolean open_new_window = FALSE;
gboolean no_default_window = FALSE;
gboolean select_uris = FALSE;
gchar **remaining = NULL;
NautilusApplication *self = NAUTILUS_APPLICATION (application);
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
/* dummy, only for compatibility reasons */
{ "browser", '\0', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &browser,
NULL, NULL },
{ "version", '\0', 0, G_OPTION_ARG_NONE, &version,
N_("Show the version of the program."), NULL },
{ "geometry", 'g', 0, G_OPTION_ARG_STRING, &self->priv->geometry,
N_("Create the initial window with the given geometry."), N_("GEOMETRY") },
{ "new-window", 'w', 0, G_OPTION_ARG_NONE, &open_new_window,
N_("Always open a new window for browsing specified URIs"), NULL },
{ "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, &self->priv->no_desktop,
N_("Never manage the desktop (ignore the GSettings preference)."), NULL },
{ "force-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->force_desktop,
N_("Always manage the desktop (ignore the GSettings preference)."), NULL },
{ "quit", 'q', 0, G_OPTION_ARG_NONE, &kill_shell,
N_("Quit Nautilus."), NULL },
{ "select", 's', 0, G_OPTION_ARG_NONE, &select_uris,
N_("Select specified URI in parent folder."), NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") },
{ NULL }
};
GOptionContext *context;
GError *error = NULL;
gint argc = 0;
gchar **argv = NULL;
*exit_status = EXIT_SUCCESS;
nautilus_profile_start (NULL);
context = g_option_context_new (_("\n\nBrowse the file system with the file manager"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
argv = *arguments;
argc = g_strv_length (argv);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
/* Translators: this is a fatal error quit message printed on the
* command line */
g_printerr ("%s: %s\n", _("Could not parse arguments"), error->message);
g_error_free (error);
*exit_status = EXIT_FAILURE;
goto out;
}
if (version) {
g_print ("GNOME nautilus " PACKAGE_VERSION "\n");
goto out;
}
if (!do_cmdline_sanity_checks (self, perform_self_check,
version, kill_shell, select_uris, remaining)) {
*exit_status = EXIT_FAILURE;
goto out;
}
if (perform_self_check) {
do_perform_self_checks (exit_status);
goto out;
}
DEBUG ("Parsing local command line: open_new_window %d, no_default_window %d, "
"quit %d, self checks %d, no_desktop %d, show_desktop %d",
open_new_window, no_default_window, kill_shell, perform_self_check,
self->priv->no_desktop, self->priv->force_desktop);
g_application_register (application, NULL, &error);
if (error != NULL) {
/* Translators: this is a fatal error quit message printed on the
* command line */
g_printerr ("%s: %s\n", _("Could not register the application"), error->message);
g_error_free (error);
*exit_status = EXIT_FAILURE;
goto out;
}
if (kill_shell) {
DEBUG ("Killing application, as requested");
g_action_group_activate_action (G_ACTION_GROUP (application),
"kill", NULL);
goto out;
}
GFile **files;
gint idx, len;
len = 0;
files = NULL;
/* Convert args to GFiles */
if (remaining != NULL) {
GFile *file;
GPtrArray *file_array;
file_array = g_ptr_array_new ();
for (idx = 0; remaining[idx] != NULL; idx++) {
file = g_file_new_for_commandline_arg (remaining[idx]);
if (file != NULL) {
g_ptr_array_add (file_array, file);
}
}
len = file_array->len;
files = (GFile **) g_ptr_array_free (file_array, FALSE);
g_strfreev (remaining);
}
if (files == NULL && !no_default_window && !select_uris) {
files = g_malloc0 (2 * sizeof (GFile *));
len = 1;
files[0] = g_file_new_for_path (g_get_home_dir ());
files[1] = NULL;
}
if (len == 0) {
goto out;
}
if (select_uris) {
nautilus_application_select (self, files, len);
} else {
/* Invoke "Open" to create new windows */
g_application_open (application, files, len, open_new_window ? "new-window" : "");
}
for (idx = 0; idx < len; idx++) {
g_object_unref (files[idx]);
}
g_free (files);
out:
g_option_context_free (context);
nautilus_profile_end (NULL);
return TRUE;
}
void
nautilus_directory_notify_files_added (GList *files)
{
GHashTable *added_lists;
GList *p;
NautilusDirectory *directory;
GHashTable *parent_directories;
NautilusFile *file;
GFile *location, *parent;
nautilus_profile_start (NULL);
/* Make a list of added files in each directory. */
added_lists = g_hash_table_new (NULL, NULL);
/* Make a list of parent directories that will need their counts updated. */
parent_directories = g_hash_table_new (NULL, NULL);
for (p = files; p != NULL; p = p->next) {
location = p->data;
/* See if the directory is already known. */
directory = get_parent_directory_if_exists (location);
if (directory == NULL) {
/* In case the directory is not being
* monitored, but the corresponding file is,
* we must invalidate it's item count.
*/
file = NULL;
parent = g_file_get_parent (location);
if (parent) {
file = nautilus_file_get_existing (parent);
g_object_unref (parent);
}
if (file != NULL) {
nautilus_file_invalidate_count_and_mime_list (file);
nautilus_file_unref (file);
}
continue;
}
collect_parent_directories (parent_directories, directory);
/* If no one is monitoring files in the directory, nothing to do. */
if (!nautilus_directory_is_file_list_monitored (directory)) {
nautilus_directory_unref (directory);
continue;
}
file = nautilus_file_get_existing (location);
/* We check is_added here, because the file could have been added
* to the directory by a nautilus_file_get() but not gotten
* files_added emitted
*/
if (file && file->details->is_added) {
/* A file already exists, it was probably renamed.
* If it was renamed this could be ignored, but
* queue a change just in case */
nautilus_file_changed (file);
nautilus_file_unref (file);
} else {
hash_table_list_prepend (added_lists,
directory,
g_object_ref (location));
}
nautilus_directory_unref (directory);
}
/* Now get file info for the new files. This creates NautilusFile
* objects for the new files, and sends out a files_added signal.
*/
g_hash_table_foreach (added_lists, call_get_file_info_free_list, NULL);
g_hash_table_destroy (added_lists);
/* Invalidate count for each parent directory. */
g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
g_hash_table_destroy (parent_directories);
nautilus_profile_end (NULL);
}