Instructions to use abr00kx/nemo-smooth with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- NeMo
How to use abr00kx/nemo-smooth with NeMo:
# tag did not correspond to a valid NeMo domain.
- Notebooks
- Google Colab
- Kaggle
Download src/nemo-application.c from abr00kx/nemo-smooth: direct link, hf CLI and curl.
- Browser
- Download file 22.5 kB
-
https://huggingface.co/abr00kx/nemo-smooth/resolve/main/src/nemo-application.c
- Command line
-
hf download hf://abr00kx/nemo-smooth/src/nemo-application.c
-
curl -L -o nemo-application.c https://huggingface.co/abr00kx/nemo-smooth/resolve/main/src/nemo-application.c
22.5 kB
| /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ | |
| /* | |
| * nemo-application: main Nemo application class. | |
| * | |
| * Copyright (C) 1999, 2000 Red Hat, Inc. | |
| * Copyright (C) 2000, 2001 Eazel, Inc. | |
| * Copyright (C) 2010, Cosimo Cecchi <cosimoc@gnome.org> | |
| * | |
| * Nemo is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU General Public License as | |
| * published by the Free Software Foundation; either version 2 of the | |
| * License, or (at your option) any later version. | |
| * | |
| * Nemo is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Suite 500, MA 02110-1335, USA. | |
| * | |
| * Authors: Elliot Lee <sopwith@redhat.com>, | |
| * Darin Adler <darin@bentspoon.com> | |
| * Cosimo Cecchi <cosimoc@gnome.org> | |
| * | |
| */ | |
| G_DEFINE_TYPE (NemoApplication, nemo_application, GTK_TYPE_APPLICATION); | |
| struct _NemoApplicationPriv { | |
| NemoProgressUIHandler *progress_handler; | |
| gboolean cache_problem; | |
| gboolean ignore_cache_problem; | |
| }; | |
| static NemoApplication *singleton = NULL; | |
| /* Common startup stuff */ | |
| /* The saving of the accelerator map was requested */ | |
| static gboolean save_of_accel_map_requested = FALSE; | |
| static GtkCssProvider *mandatory_css_provider = NULL; | |
| static gboolean | |
| css_provider_load_from_resource (GtkCssProvider *provider, | |
| const char *resource_path, | |
| GError **error) | |
| { | |
| GBytes *data; | |
| gboolean retval; | |
| data = g_resources_lookup_data (resource_path, 0, error); | |
| if (!data) | |
| return FALSE; | |
| retval = gtk_css_provider_load_from_data (provider, | |
| g_bytes_get_data (data, NULL), | |
| g_bytes_get_size (data), | |
| error); | |
| g_bytes_unref (data); | |
| return retval; | |
| } | |
| static gchar * | |
| load_file_contents_from_resource (const char *resource_path, | |
| GError **error) | |
| { | |
| GBytes *data; | |
| gchar *retval; | |
| data = NULL; | |
| data = g_resources_lookup_data (resource_path, 0, error); | |
| if (!data) { | |
| return FALSE; | |
| } | |
| retval = g_strdup ((gchar *) g_bytes_get_data (data, NULL)); | |
| g_bytes_unref (data); | |
| return retval; | |
| } | |
| static void | |
| add_css_provider_at_priority (const gchar *rpath, guint priority) | |
| { | |
| GtkCssProvider *provider; | |
| GError *error = NULL; | |
| provider = gtk_css_provider_new (); | |
| if (!css_provider_load_from_resource (provider, rpath, &error)) | |
| { | |
| g_warning ("Failed to load fallback css file: %s", error->message); | |
| if (error->message != NULL) | |
| g_error_free (error); | |
| goto out; | |
| } | |
| gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), | |
| GTK_STYLE_PROVIDER (provider), | |
| priority); | |
| out: | |
| g_object_unref (provider); | |
| } | |
| static void | |
| add_fallback_mandatory_css_provider (const gchar *theme_name) | |
| { | |
| GtkCssProvider *current_provider; | |
| gchar *css, *init_fallback_css, *final_fallback_css; | |
| GError *error = NULL; | |
| current_provider = gtk_css_provider_get_named (theme_name, NULL); | |
| css = gtk_css_provider_to_string (current_provider); | |
| init_fallback_css = NULL; | |
| if (!g_strstr_len (css, -1, "nemo")) { | |
| g_warning ("The theme appears to have no nemo support. Adding some..."); | |
| init_fallback_css = load_file_contents_from_resource ("/org/nemo/nemo-style-fallback-mandatory.css", | |
| &error); | |
| if (!init_fallback_css) { | |
| g_warning ("Failed to load fallback mandatory css file: %s", error->message); | |
| g_clear_error (&error); | |
| goto out; | |
| } | |
| } else { | |
| goto out; | |
| } | |
| final_fallback_css = NULL; | |
| /* Our fallback uses @theme_ prefixed names for colors. If the active theme does also, skip | |
| * to apply */ | |
| if (g_strstr_len (css, -1, "theme_selected_bg_color")) { | |
| final_fallback_css = g_strdup (init_fallback_css); | |
| goto apply; | |
| } | |
| /* Some themes don't prefix colors with theme_ - remove this from our fallback css */ | |
| if (g_strstr_len (css, -1, "@define-color selected_bg_color")) { | |
| g_warning ("Replacing theme_selected_bg_color with selected_bg_color"); | |
| final_fallback_css = eel_str_replace_substring (init_fallback_css, | |
| "@theme_", | |
| "@"); | |
| } else { | |
| /* If we can find neither, just bail out */ | |
| goto out; | |
| } | |
| apply: | |
| g_free (init_fallback_css); | |
| mandatory_css_provider = gtk_css_provider_new (); | |
| gtk_css_provider_load_from_data (mandatory_css_provider, | |
| final_fallback_css, | |
| -1, | |
| &error); | |
| if (error) { | |
| g_warning ("Failed to create a fallback provider: %s", error->message); | |
| g_clear_error (&error); | |
| goto out; | |
| } | |
| gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), | |
| GTK_STYLE_PROVIDER (mandatory_css_provider), | |
| GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); | |
| out: | |
| g_free (css); | |
| } | |
| static const char *supported_theme_hints[] = { | |
| "mint", | |
| "arc", | |
| "numix", | |
| "matcha" | |
| }; | |
| static gboolean | |
| is_known_supported_theme (const gchar *theme_name) | |
| { | |
| gint i; | |
| gchar *name; | |
| gboolean ret; | |
| name = g_utf8_casefold (theme_name, -1); | |
| ret = FALSE; | |
| for (i = 0; i < G_N_ELEMENTS (supported_theme_hints); i++) { | |
| gchar *hint; | |
| hint = g_utf8_casefold (supported_theme_hints[i], -1); | |
| if (g_strstr_len (name, -1, hint)) { | |
| ret = TRUE; | |
| } | |
| g_free (hint); | |
| if (ret) { | |
| break; | |
| } | |
| } | |
| g_free (name); | |
| return ret; | |
| } | |
| static void | |
| process_system_theme (GtkSettings *gtk_settings) | |
| { | |
| gchar *theme_name; | |
| if (mandatory_css_provider != NULL) { | |
| gtk_style_context_remove_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (mandatory_css_provider)); | |
| g_clear_object (&mandatory_css_provider); | |
| } | |
| g_object_get (gtk_settings, | |
| "gtk-theme-name", &theme_name, | |
| NULL); | |
| if (!is_known_supported_theme (theme_name)) { | |
| g_warning ("Current gtk theme is not known to have nemo support (%s) - checking...", theme_name); | |
| add_fallback_mandatory_css_provider (theme_name); | |
| } | |
| gtk_style_context_reset_widgets (gdk_screen_get_default ()); | |
| g_free (theme_name); | |
| } | |
| static void | |
| init_icons_and_styles (void) | |
| { | |
| /* initialize search path for custom icons */ | |
| gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), | |
| NEMO_DATADIR G_DIR_SEPARATOR_S "icons"); | |
| gtk_icon_size_register (NEMO_STATUSBAR_ICON_SIZE_NAME, | |
| NEMO_STATUSBAR_ICON_SIZE, | |
| NEMO_STATUSBAR_ICON_SIZE); | |
| add_css_provider_at_priority ("/org/nemo/nemo-style-fallback.css", | |
| GTK_STYLE_PROVIDER_PRIORITY_FALLBACK); | |
| add_css_provider_at_priority ("/org/nemo/nemo-style-application.css", | |
| GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); | |
| GtkSettings *gtk_settings = gtk_settings_get_default (); | |
| /* We create our own 'runtime theme' when we encounter one that doesn't | |
| * include nemo support. We must listen for the theme changing so this | |
| * customization can be removed (then re-applied only if necessary for the | |
| * new theme). */ | |
| g_signal_connect_swapped (gtk_settings, "notify::gtk-theme-name", G_CALLBACK (process_system_theme), gtk_settings); | |
| process_system_theme (gtk_settings); | |
| } | |
| static gboolean | |
| save_accel_map (gpointer data) | |
| { | |
| if (save_of_accel_map_requested) { | |
| char *accel_map_filename; | |
| accel_map_filename = nemo_get_accel_map_file (); | |
| if (accel_map_filename) { | |
| gtk_accel_map_save (accel_map_filename); | |
| g_free (accel_map_filename); | |
| } | |
| save_of_accel_map_requested = FALSE; | |
| } | |
| return FALSE; | |
| } | |
| static void | |
| queue_accel_map_save_callback (GtkAccelMap *object, gchar *accel_path, | |
| guint accel_key, GdkModifierType accel_mods, | |
| gpointer user_data) | |
| { | |
| if (!save_of_accel_map_requested) { | |
| save_of_accel_map_requested = TRUE; | |
| g_timeout_add_seconds (NEMO_ACCEL_MAP_SAVE_DELAY, | |
| save_accel_map, NULL); | |
| } | |
| } | |
| static void | |
| init_gtk_accels (void) | |
| { | |
| char *accel_map_filename; | |
| /* load accelerator map, and register save callback */ | |
| accel_map_filename = nemo_get_accel_map_file (); | |
| if (accel_map_filename) { | |
| gtk_accel_map_load (accel_map_filename); | |
| g_free (accel_map_filename); | |
| } | |
| g_signal_connect (gtk_accel_map_get (), "changed", | |
| G_CALLBACK (queue_accel_map_save_callback), NULL); | |
| } | |
| static void | |
| menu_provider_items_updated_handler (NemoMenuProvider *provider, GtkWidget* parent_window, gpointer data) | |
| { | |
| g_signal_emit_by_name (nemo_signaller_get_current (), | |
| "popup_menu_changed"); | |
| } | |
| static void | |
| init_menu_provider_callback (void) | |
| { | |
| GList *providers; | |
| GList *l; | |
| providers = nemo_module_get_extensions_for_type (NEMO_TYPE_MENU_PROVIDER); | |
| for (l = providers; l != NULL; l = l->next) { | |
| NemoMenuProvider *provider = NEMO_MENU_PROVIDER (l->data); | |
| g_signal_connect_after (G_OBJECT (provider), "items_updated", | |
| (GCallback)menu_provider_items_updated_handler, | |
| NULL); | |
| } | |
| nemo_module_extension_list_free (providers); | |
| } | |
| /* end Common Startup Stuff */ | |
| gboolean | |
| nemo_application_check_required_directory (NemoApplication *application, | |
| gchar *path) | |
| { | |
| gboolean ret; | |
| g_assert (NEMO_IS_APPLICATION (application)); | |
| ret = TRUE; | |
| if (!g_file_test (path, G_FILE_TEST_IS_DIR)) { | |
| ret = FALSE; | |
| } | |
| if (!ret) { | |
| char *error_string; | |
| const char *detail_string; | |
| GtkDialog *dialog; | |
| error_string = g_strdup_printf (_("Nemo could not create the required folder \"%s\"."), | |
| path); | |
| detail_string = _("Before running Nemo, please create the following folder, or " | |
| "set permissions such that Nemo can create it."); | |
| 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_free (error_string); | |
| } | |
| g_free (path); | |
| return ret; | |
| } | |
| void | |
| nemo_application_open_location (NemoApplication *application, | |
| GFile *location, | |
| GFile *selection, | |
| const char *startup_id, | |
| const gboolean open_in_tabs) | |
| { | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->open_location (application, | |
| location, | |
| selection, | |
| startup_id, | |
| open_in_tabs); | |
| } | |
| void | |
| nemo_application_show_items (NemoApplication *application, | |
| GFile **uris, | |
| gint n_uris, | |
| const char *startup_id) | |
| { | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->show_items (application, | |
| uris, | |
| n_uris, | |
| startup_id); | |
| } | |
| NemoWindow * | |
| nemo_application_create_window (NemoApplication *application, | |
| GdkScreen *screen) | |
| { | |
| return NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->create_window (application, | |
| screen); | |
| } | |
| void | |
| nemo_application_notify_unmount_done (NemoApplication *application, | |
| const gchar *message) | |
| { | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->notify_unmount_done (application, | |
| message); | |
| } | |
| void | |
| nemo_application_notify_unmount_show (NemoApplication *application, | |
| const gchar *message) | |
| { | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->notify_unmount_show (application, | |
| message); | |
| } | |
| void | |
| nemo_application_close_all_windows (NemoApplication *application) | |
| { | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (application))->close_all_windows (application); | |
| } | |
| static GObject * | |
| nemo_application_constructor (GType type, | |
| guint n_construct_params, | |
| GObjectConstructParam *construct_params) | |
| { | |
| GObject *retval; | |
| retval = G_OBJECT_CLASS (nemo_application_parent_class)->constructor | |
| (type, n_construct_params, construct_params); | |
| singleton = NEMO_APPLICATION (retval); | |
| g_object_add_weak_pointer (retval, (gpointer) &singleton); | |
| return retval; | |
| } | |
| static void | |
| nemo_application_init (NemoApplication *application) | |
| { | |
| GSimpleAction *action; | |
| application->priv = G_TYPE_INSTANCE_GET_PRIVATE (application, | |
| NEMO_TYPE_APPLICATION, | |
| NemoApplicationPriv); | |
| if (g_getenv("NEMO_BENCHMARK_LOADING")) | |
| nemo_startup_timer = g_timer_new (); | |
| action = g_simple_action_new ("quit", NULL); | |
| g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action)); | |
| g_signal_connect_swapped (action, "activate", | |
| G_CALLBACK (nemo_application_quit), application); | |
| g_object_unref (action); | |
| } | |
| void | |
| nemo_application_quit (NemoApplication *self) | |
| { | |
| GApplication *app = G_APPLICATION (self); | |
| /* Run desktop or -main specific destruction - namely tearing down the | |
| * desktop manager before our g_list_foreach below takes out its windows. | |
| */ | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (self))->continue_quit (self); | |
| GList *windows; | |
| windows = gtk_application_get_windows (GTK_APPLICATION (app)); | |
| /* Save session state once, before we destroy all windows. | |
| * Save the last non-desktop window we find. */ | |
| { | |
| NemoWindow *last_window = NULL; | |
| for (GList *l = windows; l != NULL; l = l->next) { | |
| GtkWindow *w = GTK_WINDOW (l->data); | |
| if (!NEMO_IS_WINDOW (w)) { | |
| continue; | |
| } | |
| /* Avoid saving the desktop window */ | |
| if (NEMO_IS_DESKTOP_WINDOW (w)) { | |
| continue; | |
| } | |
| last_window = NEMO_WINDOW (w); | |
| break; | |
| } | |
| if (last_window != NULL) { | |
| nemo_window_save_session_state (last_window); | |
| } | |
| } | |
| g_list_foreach (windows, (GFunc) gtk_widget_destroy, NULL); | |
| /* we have been asked to force quit */ | |
| g_application_quit (G_APPLICATION (self)); | |
| } | |
| static void | |
| nemo_application_startup (GApplication *app) | |
| { | |
| NemoApplication *self = NEMO_APPLICATION (app); | |
| /* chain up to the GTK+ implementation early, so gtk_init() | |
| * is called for us. | |
| */ | |
| G_APPLICATION_CLASS (nemo_application_parent_class)->startup (app); | |
| /* create an undo manager */ | |
| self->undo_manager = nemo_undo_manager_new (); | |
| /* initialize preferences and create the global GSettings objects */ | |
| nemo_global_preferences_init (); | |
| /* Registers favorites:/// with GIO before anything (the places sidebar | |
| * first of all) asks whether it is supported. */ | |
| nemo_favorites_get_default (); | |
| /* Run desktop- or main- specific things */ | |
| NEMO_APPLICATION_CLASS (G_OBJECT_GET_CLASS (self))->continue_startup (self); | |
| /* register property pages */ | |
| nemo_image_properties_page_register (); | |
| /* initialize theming */ | |
| init_icons_and_styles (); | |
| init_gtk_accels (); | |
| /* initialize nemo modules */ | |
| nemo_module_setup (); | |
| /* attach menu-provider module callback */ | |
| init_menu_provider_callback (); | |
| /* Initialize the UI handler singleton for file operations */ | |
| self->priv->progress_handler = nemo_progress_ui_handler_new (); | |
| self->priv->cache_problem = FALSE; | |
| self->priv->ignore_cache_problem = FALSE; | |
| /* If 'treat-root-as-normal' is true, assume we're running root as well, | |
| so we can skip the permission checks */ | |
| if (nemo_user_is_root () && nemo_treating_root_as_normal ()) { | |
| return; | |
| } | |
| /* silently do a full check of the cache and fix if running as root. | |
| * If running as a normal user, do a quick check, and we'll notify the | |
| * user later if there's a problem via an infobar */ | |
| if (nemo_user_is_root ()) { | |
| if (!nemo_thumbnail_cache_check_permissions (FALSE)) | |
| nemo_thumbnail_cache_fix_permissions (); | |
| } else { | |
| if (!nemo_thumbnail_cache_check_permissions (TRUE)) | |
| self->priv->cache_problem = TRUE; | |
| } | |
| } | |
| static void | |
| nemo_application_quit_mainloop (GApplication *app) | |
| { | |
| DEBUG ("Quitting mainloop"); | |
| nemo_icon_info_clear_caches (); | |
| save_accel_map (NULL); | |
| g_object_unref (NEMO_APPLICATION (app)->undo_manager); | |
| g_clear_object (&mandatory_css_provider); | |
| nemo_application_notify_unmount_done (NEMO_APPLICATION (app), NULL); | |
| G_APPLICATION_CLASS (nemo_application_parent_class)->quit_mainloop (app); | |
| } | |
| static void | |
| nemo_application_window_removed (GtkApplication *app, | |
| GtkWindow *window) | |
| { | |
| NemoPreviewer *previewer; | |
| /* chain to parent */ | |
| GTK_APPLICATION_CLASS (nemo_application_parent_class)->window_removed (app, window); | |
| /* if this was the last window, close the previewer */ | |
| if (g_list_length (gtk_application_get_windows (app)) == 0) { | |
| previewer = nemo_previewer_get_singleton (); | |
| nemo_previewer_call_close (previewer); | |
| } | |
| } | |
| static void | |
| nemo_application_class_init (NemoApplicationClass *class) | |
| { | |
| GObjectClass *object_class; | |
| GApplicationClass *application_class; | |
| GtkApplicationClass *gtkapp_class; | |
| object_class = G_OBJECT_CLASS (class); | |
| object_class->constructor = nemo_application_constructor; | |
| application_class = G_APPLICATION_CLASS (class); | |
| application_class->startup = nemo_application_startup; | |
| application_class->quit_mainloop = nemo_application_quit_mainloop; | |
| gtkapp_class = GTK_APPLICATION_CLASS (class); | |
| gtkapp_class->window_removed = nemo_application_window_removed; | |
| g_type_class_add_private (class, sizeof (NemoApplicationPriv)); | |
| } | |
| NemoApplication * | |
| nemo_application_initialize_singleton (GType object_type, | |
| const gchar *first_property_name, | |
| ...) | |
| { | |
| NemoApplication *application; | |
| va_list var_args; | |
| va_start (var_args, first_property_name); | |
| application = NEMO_APPLICATION (g_object_new_valist (object_type, first_property_name, var_args)); | |
| va_end (var_args); | |
| return application; | |
| } | |
| NemoApplication * | |
| nemo_application_get_singleton (void) | |
| { | |
| return singleton; | |
| } | |
| void | |
| nemo_application_check_thumbnail_cache (NemoApplication *application) | |
| { | |
| application->priv->cache_problem = !nemo_thumbnail_factory_check_status (); | |
| } | |
| gboolean | |
| nemo_application_get_cache_bad (NemoApplication *application) | |
| { | |
| return application->priv->cache_problem; | |
| } | |
| void | |
| nemo_application_clear_cache_flag (NemoApplication *application) | |
| { | |
| application->priv->cache_problem = FALSE; | |
| } | |
| void | |
| nemo_application_set_cache_flag (NemoApplication *application) | |
| { | |
| application->priv->cache_problem = TRUE; | |
| } | |
| void | |
| nemo_application_ignore_cache_problem (NemoApplication *application) | |
| { | |
| application->priv->ignore_cache_problem = TRUE; | |
| } | |
| gboolean | |
| nemo_application_get_cache_problem_ignored (NemoApplication *application) | |
| { | |
| return application->priv->ignore_cache_problem; | |
| } | |