static void thumbnail_problem_bar_response_cb (GtkInfoBar *infobar, gint response_id, gpointer user_data) { NemoThumbnailProblemBar *bar; bar = NEMO_THUMBNAIL_PROBLEM_BAR (infobar); switch (response_id) { case FIX_CACHE: g_spawn_command_line_sync ("sh -c \"pkexec nemo --fix-cache\"", NULL, NULL, NULL, NULL); nemo_application_check_thumbnail_cache (nemo_application_get_singleton ()); nemo_window_slot_queue_reload (nemo_view_get_nemo_window_slot (bar->priv->view), FALSE); nemo_window_slot_check_bad_cache_bar (nemo_view_get_nemo_window_slot (bar->priv->view)); break; case DISMISS: nemo_application_clear_cache_flag (nemo_application_get_singleton ()); nemo_application_ignore_cache_problem (nemo_application_get_singleton ()); gtk_widget_hide (GTK_WIDGET (infobar)); break; default: break; } }
static void create_new_desktop_window (NemoDesktopManager *manager, gint monitor, gboolean primary, gboolean show_desktop) { FETCH_PRIV (manager); GtkWidget *window; DesktopInfo *info = g_slice_new0 (DesktopInfo); info->monitor_num = monitor; info->shows_desktop = show_desktop; info->is_primary = primary; if (show_desktop) { window = GTK_WIDGET (nemo_desktop_window_new (monitor)); } else { window = GTK_WIDGET (nemo_blank_desktop_window_new (monitor)); } info->window = window; if (priv->scale_factor_changed_id == 0) { priv->scale_factor_changed_id = g_signal_connect (window, "notify::scale-factor", G_CALLBACK (on_window_scale_changed), manager); } gtk_application_add_window (GTK_APPLICATION (nemo_application_get_singleton ()), GTK_WINDOW (window)); priv->desktops = g_list_append (priv->desktops, info); }
static void create_new_desktop_window (NemoDesktopManager *manager, gint monitor, gboolean primary, gboolean show_desktop) { GtkWidget *window; DesktopInfo *info = g_slice_new0 (DesktopInfo); info->monitor_num = monitor; info->shows_desktop = show_desktop; info->is_primary = primary; if (show_desktop) { window = GTK_WIDGET (nemo_desktop_window_new (monitor)); } else { window = GTK_WIDGET (nemo_blank_desktop_window_new (monitor)); } info->window = window; /* We realize it immediately so that the NEMO_DESKTOP_WINDOW_ID property is set so gnome-settings-daemon doesn't try to set the background. And we do a gdk_flush() to be sure X gets it. */ gtk_widget_realize (GTK_WIDGET (window)); gdk_flush (); gtk_application_add_window (GTK_APPLICATION (nemo_application_get_singleton ()), GTK_WINDOW (window)); manager->desktops = g_list_append (manager->desktops, info); }
static void action_undo_callback (GtkAction *action, gpointer user_data) { NemoApplication *app; app = nemo_application_get_singleton (); nemo_undo_manager_undo (app->undo_manager); }
static void release_application (NemoProgressInfo *info, NemoProgressUIHandler *self) { NemoApplication *app; /* release the GApplication hold we acquired */ app = nemo_application_get_singleton (); g_application_release (G_APPLICATION (app)); }
static void on_open_folder_clicked (GtkWidget *button, NemoActionConfigWidget *widget) { gchar *path = NULL; path = g_build_filename (g_get_user_data_dir (), "nemo", "actions", NULL); GFile *location = g_file_new_for_path (path); nemo_application_open_location (nemo_application_get_singleton (), location, NULL, "nemo"); g_free (path); g_object_unref (location); }
static void action_new_window_callback (GtkAction *action, gpointer user_data) { NemoApplication *application; NemoWindow *current_window, *new_window; current_window = NEMO_WINDOW (user_data); application = nemo_application_get_singleton (); new_window = nemo_application_create_window ( application, gtk_window_get_screen (GTK_WINDOW (current_window))); nemo_window_slot_go_home (nemo_window_get_active_slot (new_window), FALSE); }
static void on_open_folder_clicked (GtkWidget *button, NemoScriptConfigWidget *widget) { gchar *path = NULL; path = nemo_get_scripts_directory_path (); GFile *location = g_file_new_for_path (path); nemo_application_open_location (nemo_application_get_singleton (), location, NULL, "nemo"); g_free (path); g_object_unref (location); }
static void on_run_state_changed (NemoDesktopManager *manager) { g_return_if_fail (NEMO_IS_DESKTOP_MANAGER (manager)); FETCH_PRIV (manager); RunState new_state; DEBUG ("New run state..."); /* If we're already running (showing icons,) there's no * change in behavior, we just keep showing. */ if (priv->current_run_state == RUN_STATE_RUNNING) { return; } new_state = get_run_state (manager); /* If our state is INIT, we're waiting for the proxy to * get picked up (cinnamon starting) and still within our * failsafe timeout, so we just return */ if (new_state == RUN_STATE_INIT) { priv->current_run_state = new_state; return; } /* If our state is STARTUP, RUNNING, or FAILSAFE, we can * cancel our failsafe timer. We've either gotten a proxy * owner, given up waiting, or are now running */ if (new_state > RUN_STATE_INIT) { if (priv->failsafe_timeout_id > 0) { g_source_remove (priv->failsafe_timeout_id); priv->failsafe_timeout_id = 0; } } /* RUNNING or FALLBACK is the final endpoint of the desktop startup * sequence. Either way we trigger the desktop to start and release * our hold on the GApplication (the windows created in layout_changed * will keep the application alive from here on out.) */ if (new_state == RUN_STATE_RUNNING || new_state == RUN_STATE_FALLBACK) { priv->current_run_state = new_state; layout_changed (manager); g_application_release (G_APPLICATION (nemo_application_get_singleton ())); } }
static void activate_bookmark_by_quicklist (DbusmenuMenuitem *menu, guint timestamp, NemoBookmark *bookmark) { g_assert (NEMO_IS_BOOKMARK (bookmark)); GFile *location; NemoApplication *application; NemoWindow *new_window; location = nemo_bookmark_get_location (bookmark); application = nemo_application_get_singleton (); new_window = nemo_application_create_window (application, gdk_screen_get_default ()); nemo_window_slot_go_to (nemo_window_get_active_slot (new_window), location, FALSE); g_object_unref (location); }
static void progress_info_queued_cb (NemoProgressInfo *info, NemoProgressUIHandler *self) { NemoApplication *app; TimeoutData *data; /* hold GApplication so we never quit while there's an operation pending */ app = nemo_application_get_singleton (); g_application_hold (G_APPLICATION (app)); g_signal_connect (info, "finished", G_CALLBACK (release_application), self); data = timeout_data_new (self, info); /* timeout for the progress window to appear */ g_timeout_add_seconds (2, (GSourceFunc) new_op_queued_timeout, data); }
static void nemo_desktop_manager_init (NemoDesktopManager *manager) { NemoDesktopManagerPrivate *priv; manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, NEMO_TYPE_DESKTOP_MANAGER, NemoDesktopManagerPrivate); DEBUG ("Desktop Manager Initialization"); priv = manager->priv; priv->scale_factor_changed_id = 0; priv->desktops = NULL; priv->desktop_on_primary_only = FALSE; priv->action_manager = nemo_action_manager_new (); priv->update_layout_idle_id = 0; g_signal_connect_swapped (nemo_desktop_preferences, "changed::" NEMO_PREFERENCES_SHOW_DESKTOP, G_CALLBACK (queue_update_layout), manager); g_signal_connect_swapped (nemo_desktop_preferences, "changed::" NEMO_PREFERENCES_DESKTOP_LAYOUT, G_CALLBACK (queue_update_layout), manager); g_signal_connect_swapped (nemo_desktop_preferences, "changed::" NEMO_PREFERENCES_USE_DESKTOP_GRID, G_CALLBACK (queue_update_layout), manager); /* Monitor the preference to have the desktop */ /* point to the Unix home folder */ g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_DESKTOP_IS_HOME_DIR, G_CALLBACK (queue_update_layout), manager); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_ORPHANED_DESKTOP_ICONS, G_CALLBACK (queue_update_layout), manager); /* If we're a cinnamon session, increase the use count temporarily for the application, * and establish a proxy for org.Cinnamon. The hold prevents the GApplication from simply * exiting while waiting for the GAsyncReadyCallback. * * If we're not running cinnamon, */ g_application_hold (G_APPLICATION (nemo_application_get_singleton ())); if (is_cinnamon_desktop ()) { g_message ("nemo-desktop: session is cinnamon, establishing proxy"); nemo_cinnamon_proxy_new_for_bus (G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, "org.Cinnamon", "/org/Cinnamon", NULL, (GAsyncReadyCallback) on_proxy_created, manager); } else { g_message ("nemo-desktop: session is not cinnamon (checked XDG_SESSION_DESKTOP," "DESKTOP_SESSION environment variables.) Applying default behavior"); priv->other_desktop = TRUE; connect_fallback_signals (manager); /* Even though we start immediately when we can't do a proxy, we need to get out * of the desktop manager's init first, or else we have recursion problems. */ g_idle_add ((GSourceFunc) fallback_startup_idle_cb, manager); } }
static void drag_data_received_callback (GtkWidget *widget, GdkDragContext *context, int x, int y, GtkSelectionData *data, guint info, guint32 time, gpointer callback_data) { char **names; NemoApplication *application; int name_count; NemoWindow *new_window, *window; GdkScreen *screen; gboolean new_windows_for_extras; char *prompt; char *detail; GFile *location; NemoLocationBar *self = NEMO_LOCATION_BAR (widget); g_assert (data != NULL); g_assert (callback_data == NULL); names = g_uri_list_extract_uris ((const gchar *) gtk_selection_data_get_data (data)); if (names == NULL || *names == NULL) { g_warning ("No D&D URI's"); g_strfreev (names); gtk_drag_finish (context, FALSE, FALSE, time); return; } window = nemo_location_bar_get_window (widget); new_windows_for_extras = FALSE; /* Ask user if they really want to open multiple windows * for multiple dropped URIs. This is likely to have been * a mistake. */ name_count = g_strv_length (names); if (name_count > 1) { prompt = g_strdup_printf (ngettext("Do you want to view %d location?", "Do you want to view %d locations?", name_count), name_count); detail = g_strdup_printf (ngettext("This will open %d separate window.", "This will open %d separate windows.", name_count), name_count); /* eel_run_simple_dialog should really take in pairs * like gtk_dialog_new_with_buttons() does. */ new_windows_for_extras = eel_run_simple_dialog (GTK_WIDGET (window), TRUE, GTK_MESSAGE_QUESTION, prompt, detail, GTK_STOCK_CANCEL, GTK_STOCK_OK, NULL) != 0 /* GNOME_OK */; g_free (prompt); g_free (detail); if (!new_windows_for_extras) { g_strfreev (names); gtk_drag_finish (context, FALSE, FALSE, time); return; } } nemo_location_bar_set_location (self, names[0]); emit_location_changed (self); if (new_windows_for_extras) { int i; application = nemo_application_get_singleton (); screen = gtk_window_get_screen (GTK_WINDOW (window)); for (i = 1; names[i] != NULL; ++i) { new_window = nemo_application_create_window (application, screen); location = g_file_new_for_uri (names[i]); nemo_window_go_to (new_window, location); g_object_unref (location); } } g_strfreev (names); gtk_drag_finish (context, TRUE, FALSE, time); }
static void action_close_all_windows_callback (GtkAction *action, gpointer user_data) { nemo_application_close_all_windows (nemo_application_get_singleton ()); }