/* lazy loading of language mappings */ static void load_language_mappings (void) { gchar *fname; GKeyFile *mappings; GError *error = NULL; fname = g_build_filename (modelines_data_dir, MODELINES_LANGUAGE_MAPPINGS_FILE, NULL); mappings = g_key_file_new (); if (g_key_file_load_from_file (mappings, fname, 0, &error)) { gedit_debug_message (DEBUG_PLUGINS, "Loaded language mappings from %s", fname); vim_languages = load_language_mappings_group (mappings, "vim"); emacs_languages = load_language_mappings_group (mappings, "emacs"); kate_languages = load_language_mappings_group (mappings, "kate"); } else { gedit_debug_message (DEBUG_PLUGINS, "Failed to loaded language mappings from %s: %s", fname, error->message); g_error_free (error); } g_key_file_free (mappings); g_free (fname); }
static void gedit_main (gboolean service) { GeditPluginsEngine *engine; GeditApp *app; const gchar *dir; gchar *icon_dir; gedit_debug_message (DEBUG_APP, "Set icon"); dir = gedit_dirs_get_gedit_data_dir (); icon_dir = g_build_filename (dir, "icons", NULL); gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), icon_dir); g_free (icon_dir); /* Init plugins engine */ gedit_debug_message (DEBUG_APP, "Init plugins"); engine = gedit_plugins_engine_get_default (); app = gedit_app_get_default (); /* Initialize session management */ gedit_debug_message (DEBUG_APP, "Init session manager"); gedit_session_init (); if (!service) { gboolean restored = FALSE; if (gedit_session_is_restored ()) { restored = gedit_session_load (); } if (!restored) { gedit_main_window (); } } _gedit_app_ready (app); gedit_debug_message (DEBUG_APP, "Start gtk-main"); gtk_main (); /* Make sure settings are saved */ g_settings_sync (); /* Cleanup */ g_object_unref (engine); g_object_unref (app); gedit_dirs_shutdown (); #ifndef ENABLE_GVFS_METADATA gedit_metadata_manager_shutdown (); #endif }
static GtkSourceLanguage * guess_language (GeditDocument *doc) { GeditDocumentPrivate *priv; gchar *data; GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default (); GtkSourceLanguage *language = NULL; priv = gedit_document_get_instance_private (doc); data = gedit_document_get_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE); if (data != NULL) { gedit_debug_message (DEBUG_DOCUMENT, "Language from metadata: %s", data); if (!g_str_equal (data, NO_LANGUAGE_NAME)) { language = gtk_source_language_manager_get_language (manager, data); } g_free (data); } else { GFile *location; gchar *basename = NULL; location = gtk_source_file_get_location (priv->file); gedit_debug_message (DEBUG_DOCUMENT, "Sniffing Language"); if (location != NULL) { basename = g_file_get_basename (location); } else if (priv->short_name != NULL) { basename = g_strdup (priv->short_name); } language = gtk_source_language_manager_guess_language (manager, basename, priv->content_type); g_free (basename); } return language; }
static GHashTable * load_language_mappings_group (GKeyFile *key_file, const gchar *group) { GHashTable *table; gchar **keys; gsize length = 0; int i; table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); keys = g_key_file_get_keys (key_file, group, &length, NULL); gedit_debug_message (DEBUG_PLUGINS, "%" G_GSIZE_FORMAT " mappings in group %s", length, group); for (i = 0; i < length; i++) { /* steal the name string */ gchar *name = keys[i]; gchar *id = g_key_file_get_string (key_file, group, name, NULL); g_hash_table_insert (table, name, id); } g_free (keys); return table; }
static void gedit_spell_plugin_finalize (GObject *object) { gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin finalizing"); G_OBJECT_CLASS (gedit_spell_plugin_parent_class)->finalize (object); }
static void auto_spell_cb (GSimpleAction *action, GVariant *state, gpointer data) { GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data); GeditSpellPluginPrivate *priv = plugin->priv; GeditView *view; gboolean active; gedit_debug (DEBUG_PLUGINS); active = g_variant_get_boolean (state); gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated"); view = gedit_window_get_active_view (priv->window); if (view != NULL) { GeditDocument *doc; doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED, active ? "1" : NULL, NULL); set_auto_spell (priv->window, view, active); g_simple_action_set_state (action, g_variant_new_boolean (active)); } }
/* Copied from nautilus */ static gchar * get_direct_save_filename (GdkDragContext *context) { guchar *prop_text; gint prop_len; if (!gdk_property_get (gdk_drag_context_get_source_window (context), gdk_atom_intern ("XdndDirectSave0", FALSE), gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL, &prop_len, &prop_text) && prop_text != NULL) { return NULL; } /* Zero-terminate the string */ prop_text = g_realloc (prop_text, prop_len + 1); prop_text[prop_len] = '\0'; /* Verify that the file name provided by the source is valid */ if (*prop_text == '\0' || strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL) { gedit_debug_message (DEBUG_UTILS, "Invalid filename provided by XDS drag site"); g_free (prop_text); return NULL; } return (gchar *)prop_text; }
static gchar * get_current_word (GeditDocument *doc, gint *start, gint *end) { const CheckRange *range; GtkTextIter end_iter; GtkTextIter current_iter; gint range_end; gedit_debug (DEBUG_PLUGINS); g_return_val_if_fail (doc != NULL, NULL); g_return_val_if_fail (start != NULL, NULL); g_return_val_if_fail (end != NULL, NULL); range = get_check_range (doc); g_return_val_if_fail (range != NULL, NULL); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc), &end_iter, range->end_mark); range_end = gtk_text_iter_get_offset (&end_iter); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc), ¤t_iter, range->current_mark); end_iter = current_iter; if (!gtk_text_iter_is_end (&end_iter)) { gedit_debug_message (DEBUG_PLUGINS, "Current is not end"); gtk_text_iter_forward_word_end (&end_iter); } *start = gtk_text_iter_get_offset (¤t_iter); *end = MIN (gtk_text_iter_get_offset (&end_iter), range_end); gedit_debug_message (DEBUG_PLUGINS, "Current word extends [%d, %d]", *start, *end); if (!(*start < *end)) return NULL; return gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), ¤t_iter, &end_iter, TRUE); }
/** * gedit_debug: * @section: debug section. * @file: file name. * @line: line number. * @function: name of the function that is calling gedit_debug(). * * If @section is enabled, then logs the trace information @file, @line, and * @function. */ void gedit_debug (GeditDebugSection section, const gchar *file, gint line, const gchar *function) { gedit_debug_message (section, file, line, function, "%s", ""); }
/** * gedit_debug_plugin_message: * @file: file name. * @line: line number. * @function: name of the function that is calling gedit_debug_plugin_message(). * @message: a message. * * If the section %GEDIT_DEBUG_PLUGINS is enabled, then logs the trace * information @file, @line, and @function along with @message. * * This function may be overridden by GObject Introspection language bindings * to be more language-specific. * * <emphasis>Python</emphasis> * * A PyGObject override is provided that has the following signature: * <informalexample> * <programlisting> * def debug_plugin_message(format_str, *format_args): * #... * </programlisting> * </informalexample> * * It automatically supplies parameters @file, @line, and @function, and it * formats <code>format_str</code> with the given format arguments. The syntax * of the format string is the usual Python string formatting syntax described * by <ulink url="http://docs.python.org/library/stdtypes.html#string-formatting">5.6.2. String Formatting Operations</ulink>. * * Since: 3.4 */ void gedit_debug_plugin_message (const gchar *file, gint line, const gchar *function, const gchar *message) { gedit_debug_message (GEDIT_DEBUG_PLUGINS, file, line, function, "%s", message); }
static void gedit_word_completion_plugin_init (GeditWordCompletionPlugin *plugin) { gedit_debug_message (DEBUG_PLUGINS, "GeditWordCompletionPlugin initializing"); plugin->priv = G_TYPE_INSTANCE_GET_PRIVATE (plugin, GEDIT_TYPE_WORD_COMPLETION_PLUGIN, GeditWordCompletionPluginPrivate); }
static void gedit_spell_plugin_init (GeditSpellPlugin *plugin) { gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin initializing"); plugin->priv = G_TYPE_INSTANCE_GET_PRIVATE (plugin, GEDIT_TYPE_SPELL_PLUGIN, GeditSpellPluginPrivate); }
static void gedit_modeline_plugin_finalize (GObject *object) { gedit_debug_message (DEBUG_PLUGINS, "GeditModelinePlugin finalizing"); modeline_parser_shutdown (); G_OBJECT_CLASS (gedit_modeline_plugin_parent_class)->finalize (object); }
gboolean gedit_utils_uri_exists (const gchar* text_uri) { GFile *gfile; gboolean res; g_return_val_if_fail (text_uri != NULL, FALSE); gedit_debug_message (DEBUG_UTILS, "text_uri: %s", text_uri); gfile = g_file_new_for_uri (text_uri); res = g_file_query_exists (gfile, NULL); g_object_unref (gfile); gedit_debug_message (DEBUG_UTILS, res ? "TRUE" : "FALSE"); return res; }
static void new_window_activated (GSimpleAction *action, GVariant *parameter, gpointer user_data) { GeditApp *app; GeditWindow *window; app = GEDIT_APP (user_data); window = gedit_app_create_window (app, NULL); gedit_debug_message (DEBUG_APP, "Show window"); gtk_widget_show (GTK_WIDGET (window)); gedit_debug_message (DEBUG_APP, "Create tab"); gedit_window_create_tab (window, TRUE); gtk_window_present (GTK_WINDOW (window)); }
gchar * gedit_utils_escape_search_text (const gchar* text) { GString *str; gint length; const gchar *p; const gchar *end; if (text == NULL) return NULL; gedit_debug_message (DEBUG_SEARCH, "Text: %s", text); length = strlen (text); /* no escape when typing. * The short circuit works only for ascii, but we only * care about not escaping a single '\' */ if (length == 1) return g_strdup (text); str = g_string_new (""); p = text; end = text + length; while (p != end) { const gchar *next; next = g_utf8_next_char (p); switch (*p) { case '\n': g_string_append (str, "\\n"); break; case '\r': g_string_append (str, "\\r"); break; case '\t': g_string_append (str, "\\t"); break; case '\\': g_string_append (str, "\\\\"); break; default: g_string_append_len (str, p, next - p); break; } p = next; } return g_string_free (str, FALSE); }
static void gedit_spell_plugin_dispose (GObject *object) { GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (object); gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin disposing"); g_clear_object (&plugin->priv->window); G_OBJECT_CLASS (gedit_spell_plugin_parent_class)->dispose (object); }
gchar * gedit_convert_from_utf8 (const gchar *content, gsize len, const GeditEncoding *encoding, gsize *new_len, GError **error) { GError *conv_error = NULL; gchar *converted_contents = NULL; gsize bytes_written = 0; gedit_debug (DEBUG_UTILS); g_return_val_if_fail (content != NULL, NULL); g_return_val_if_fail (g_utf8_validate (content, len, NULL), NULL); g_return_val_if_fail (encoding != NULL, NULL); if (len < 0) len = strlen (content); if (encoding == gedit_encoding_get_utf8 ()) return g_strndup (content, len); converted_contents = g_convert (content, len, gedit_encoding_get_charset (encoding), "UTF-8", NULL, &bytes_written, &conv_error); if (conv_error != NULL) { gedit_debug_message (DEBUG_UTILS, "Cannot convert from UTF-8 to %s", gedit_encoding_get_charset (encoding)); if (converted_contents != NULL) { g_free (converted_contents); converted_contents = NULL; } g_propagate_error (error, conv_error); } else { if (new_len != NULL) *new_len = bytes_written; } return converted_contents; }
/* Scan a line for vi(m)/emacs/kate modelines. * Line numbers are counted starting at one. */ static void parse_modeline (gchar *s, gint line_number, gint line_count, ModelineOptions *options) { gchar prev; /* look for the beginning of a modeline */ for (prev = ' '; (s != NULL) && (*s != '\0'); prev = *(s++)) { if (!g_ascii_isspace (prev)) continue; if ((line_number <= 3 || line_number > line_count - 3) && (strncmp (s, "ex:", 3) == 0 || strncmp (s, "vi:", 3) == 0 || strncmp (s, "vim:", 4) == 0)) { gedit_debug_message (DEBUG_PLUGINS, "Vim modeline on line %d", line_number); while (*s != ':') s++; s = parse_vim_modeline (s + 1, options); } else if (line_number <= 2 && strncmp (s, "-*-", 3) == 0) { gedit_debug_message (DEBUG_PLUGINS, "Emacs modeline on line %d", line_number); s = parse_emacs_modeline (s + 3, options); } else if ((line_number <= 10 || line_number > line_count - 10) && strncmp (s, "kate:", 5) == 0) { gedit_debug_message (DEBUG_PLUGINS, "Kate modeline on line %d", line_number); s = parse_kate_modeline (s + 5, options); } } }
static void load_accels (void) { gchar *filename; filename = g_build_filename (gedit_dirs_get_user_config_dir (), "accels", NULL); if (filename != NULL) { gedit_debug_message (DEBUG_APP, "Loading keybindings from %s\n", filename); gtk_accel_map_load (filename); g_free (filename); } }
static void on_content_type_changed (GeditDocument *doc, GParamSpec *pspec, gpointer useless) { if (!doc->priv->language_set_by_user) { GtkSourceLanguage *language = guess_language (doc); gedit_debug_message (DEBUG_DOCUMENT, "Language: %s", language != NULL ? gtk_source_language_get_name (language) : "None"); set_language (doc, language, FALSE); } }
static GeditWindow * gedit_app_create_window_impl (GeditApp *app) { GeditWindow *window; window = g_object_new (GEDIT_TYPE_WINDOW, "application", app, NULL); gedit_debug_message (DEBUG_APP, "Window created"); g_signal_connect (window, "delete_event", G_CALLBACK (window_delete_event), app); return window; }
static void gedit_document_loaded_real (GeditDocument *doc) { GFile *location; if (!doc->priv->language_set_by_user) { GtkSourceLanguage *language = guess_language (doc); gedit_debug_message (DEBUG_DOCUMENT, "Language: %s", language != NULL ? gtk_source_language_get_name (language) : "None"); set_language (doc, language, FALSE); } doc->priv->mtime_set = FALSE; doc->priv->externally_modified = FALSE; doc->priv->deleted = FALSE; g_get_current_time (&doc->priv->time_of_last_save_or_load); set_readonly (doc, FALSE); gedit_document_set_content_type (doc, NULL); location = gtk_source_file_get_location (doc->priv->file); if (location != NULL) { /* Keep the doc alive during the async operation. */ g_object_ref (doc); g_file_query_info_async (location, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE "," G_FILE_ATTRIBUTE_TIME_MODIFIED, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, (GAsyncReadyCallback) loaded_query_info_cb, doc); } }
static void gedit_app_shutdown (GApplication *app) { gedit_debug_message (DEBUG_APP, "Quitting\n"); /* Last window is gone... save some settings and exit */ ensure_user_config_dir (); save_accels (); save_page_setup (GEDIT_APP (app)); save_print_settings (GEDIT_APP (app)); /* GTK+ can still hold references to some gedit objects, for example * GeditDocument for the clipboard. So the metadata-manager should be * shutdown after. */ G_APPLICATION_CLASS (gedit_app_parent_class)->shutdown (app); #ifndef ENABLE_GVFS_METADATA gedit_metadata_manager_shutdown (); #endif gedit_dirs_shutdown (); }
static void auto_spell_cb (GtkAction *action, GeditWindow *window) { GeditDocument *doc; gboolean active; gedit_debug (DEBUG_PLUGINS); active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated"); doc = gedit_window_get_active_document (window); if (doc == NULL) return; gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED, active ? "1" : NULL, NULL); set_auto_spell (window, doc, active); }
static void gedit_main_window (void) { GSList *file_list; GeditWindow *window; GeditCommandLine *command_line; GeditApp *app; gboolean doc_created = FALSE; const gchar *geometry; app = gedit_app_get_default (); gedit_debug_message (DEBUG_APP, "Create main window"); window = gedit_app_create_window (app, NULL); command_line = gedit_command_line_get_default (); file_list = gedit_command_line_get_file_list (command_line); if (file_list != NULL) { GSList *loaded; const GeditEncoding *encoding; gint line_position; gint column_position; encoding = gedit_command_line_get_encoding (command_line); line_position = gedit_command_line_get_line_position (command_line); column_position = gedit_command_line_get_column_position (command_line); gedit_debug_message (DEBUG_APP, "Load files"); loaded = _gedit_cmd_load_files_from_prompt (window, file_list, encoding, line_position, column_position); doc_created = loaded != NULL; g_slist_free (loaded); } if (gedit_utils_can_read_from_stdin ()) { doc_created = gedit_main_load_from_stdin (window, !doc_created); } if (!doc_created || gedit_command_line_get_new_document (command_line)) { gedit_debug_message (DEBUG_APP, "Create tab"); gedit_window_create_tab (window, TRUE); } geometry = gedit_command_line_get_geometry (command_line); gedit_debug_message (DEBUG_APP, "Show window"); gtk_widget_show (GTK_WIDGET (window)); if (geometry) { gtk_window_parse_geometry (GTK_WINDOW (window), geometry); } }
int main (int argc, char *argv[]) { const gchar *dir; GeditCommandLine *command_line; gboolean ret; gboolean service = FALSE; #ifdef G_OS_UNIX GeditDBus *dbus; GeditDBusResult dbusret; #endif #ifdef OS_OSX GPollFunc orig_poll_func; GPollFunc gdk_poll_func; #endif #ifndef ENABLE_GVFS_METADATA const gchar *cache_dir; gchar *metadata_filename; #endif /* Setup debugging */ gedit_debug_init (); gedit_debug_message (DEBUG_APP, "Startup"); /* Setup locale/gettext */ setlocale (LC_ALL, ""); gedit_dirs_init (); dir = gedit_dirs_get_gedit_locale_dir (); bindtextdomain (GETTEXT_PACKAGE, dir); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #ifndef ENABLE_GVFS_METADATA /* Setup metadata-manager */ cache_dir = gedit_dirs_get_user_cache_dir (); metadata_filename = g_build_filename (cache_dir, METADATA_FILE, NULL); gedit_metadata_manager_init (metadata_filename); g_free (metadata_filename); #endif #ifdef OS_OSX orig_poll_func = g_main_context_get_poll_func (NULL); #endif /* Parse command line arguments */ command_line = gedit_command_line_get_default (); ret = gedit_command_line_parse (command_line, &argc, &argv); if (!ret) { g_object_unref (command_line); return 1; } #ifdef G_OS_UNIX #ifdef OS_OSX /* Note: this is a bit of a hack. What happens here is that we are going to * store the poll function installed by gdk (happens in post-parse of options) * and replace it with the original main loop poll handler. We do this because * the gedit dbus stuff is going to run some main loops to run async gdbus calls. * The problem is that for OS X, the gdk poll func in the main context (which * will be run due to the fact that the main loops in our dbus code iterate the * main context) is going to process events from NSApp, INCLUDING apple events * such as OpenFiles. Since we are not setup yet, we are going to miss these * events. By swapping out the gdk poll func, and swapping it back in later, * we prevent this from happening. Note that we only do this when building * on OS X to prevent any possible future problems for other platforms. * This is a dirty hack, but it works for now. */ gdk_poll_func = g_main_context_get_poll_func (NULL); g_main_context_set_poll_func (NULL, orig_poll_func); #endif /* Run over dbus */ dbus = gedit_dbus_new (); dbusret = gedit_dbus_run (dbus); #ifdef OS_OSX g_main_context_set_poll_func (NULL, gdk_poll_func); #endif switch (dbusret) { case GEDIT_DBUS_RESULT_SUCCESS: case GEDIT_DBUS_RESULT_FAILED: /* fallthrough */ g_object_unref (command_line); g_object_unref (dbus); return dbusret == GEDIT_DBUS_RESULT_SUCCESS ? 0 : 1; break; case GEDIT_DBUS_RESULT_PROCEED_SERVICE: service = TRUE; break; case GEDIT_DBUS_RESULT_PROCEED: break; } #endif gedit_main (service); #ifdef G_OS_UNIX g_object_unref (dbus); #endif g_object_unref (command_line); return 0; }
static GCharsetConverter * guess_encoding (GeditDocumentOutputStream *stream, const void *inbuf, gsize inbuf_size) { GCharsetConverter *conv = NULL; if (inbuf == NULL || inbuf_size == 0) { stream->priv->is_utf8 = TRUE; return NULL; } if (stream->priv->encodings != NULL && stream->priv->encodings->next == NULL) { stream->priv->use_first = TRUE; } /* We just check the first block */ while (TRUE) { const GeditEncoding *enc; if (conv != NULL) { g_object_unref (conv); conv = NULL; } /* We get an encoding from the list */ enc = get_encoding (stream); /* if it is NULL we didn't guess anything */ if (enc == NULL) { break; } gedit_debug_message (DEBUG_UTILS, "trying charset: %s", gedit_encoding_get_charset (stream->priv->current_encoding->data)); if (enc == gedit_encoding_get_utf8 ()) { gsize remainder; const gchar *end; if (g_utf8_validate (inbuf, inbuf_size, &end) || stream->priv->use_first) { stream->priv->is_utf8 = TRUE; break; } /* Check if the end is less than one char */ remainder = inbuf_size - (end - (gchar *)inbuf); if (remainder < 6) { stream->priv->is_utf8 = TRUE; break; } continue; } conv = g_charset_converter_new ("UTF-8", gedit_encoding_get_charset (enc), NULL); /* If we tried all encodings we use the first one */ if (stream->priv->use_first) { break; } /* Try to convert */ if (try_convert (conv, inbuf, inbuf_size)) { break; } } if (conv != NULL) { g_converter_reset (G_CONVERTER (conv)); } return conv; }
static void open_files (GApplication *application, gboolean new_window, gboolean new_document, gchar *geometry, gint line_position, gint column_position, const GtkSourceEncoding *encoding, GInputStream *stdin_stream, GSList *file_list, GApplicationCommandLine *command_line) { GeditWindow *window = NULL; GeditTab *tab; gboolean doc_created = FALSE; if (!new_window) { window = get_active_window (GTK_APPLICATION (application)); } if (window == NULL) { gedit_debug_message (DEBUG_APP, "Create main window"); window = gedit_app_create_window (GEDIT_APP (application), NULL); gedit_debug_message (DEBUG_APP, "Show window"); gtk_widget_show (GTK_WIDGET (window)); } if (geometry) { gtk_window_parse_geometry (GTK_WINDOW (window), geometry); } if (stdin_stream) { gedit_debug_message (DEBUG_APP, "Load stdin"); tab = gedit_window_create_tab_from_stream (window, stdin_stream, encoding, line_position, column_position, TRUE); doc_created = tab != NULL; if (doc_created && command_line) { set_command_line_wait (GEDIT_APP (application), tab); } g_input_stream_close (stdin_stream, NULL, NULL); } if (file_list != NULL) { GSList *loaded; gedit_debug_message (DEBUG_APP, "Load files"); loaded = _gedit_cmd_load_files_from_prompt (window, file_list, encoding, line_position, column_position); doc_created = doc_created || loaded != NULL; if (command_line) { g_slist_foreach (loaded, (GFunc)set_command_line_wait_doc, GEDIT_APP (application)); } g_slist_free (loaded); } if (!doc_created || new_document) { gedit_debug_message (DEBUG_APP, "Create tab"); tab = gedit_window_create_tab (window, TRUE); if (command_line) { set_command_line_wait (GEDIT_APP (application), tab); } } gtk_window_present (GTK_WINDOW (window)); }
static void gedit_app_startup (GApplication *application) { GeditAppPrivate *priv; GtkCssProvider *css_provider; GtkSourceStyleSchemeManager *manager; const gchar *dir; gchar *icon_dir; #ifndef ENABLE_GVFS_METADATA const gchar *cache_dir; gchar *metadata_filename; #endif priv = gedit_app_get_instance_private (GEDIT_APP (application)); G_APPLICATION_CLASS (gedit_app_parent_class)->startup (application); /* Setup debugging */ gedit_debug_init (); gedit_debug_message (DEBUG_APP, "Startup"); gedit_debug_message (DEBUG_APP, "Set icon"); dir = gedit_dirs_get_gedit_data_dir (); icon_dir = g_build_filename (dir, "icons", NULL); gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), icon_dir); g_free (icon_dir); setup_theme_extensions (GEDIT_APP (application)); #ifndef ENABLE_GVFS_METADATA cache_dir = gedit_dirs_get_user_cache_dir (); metadata_filename = g_build_filename (cache_dir, "gedit-metadata.xml", NULL); gedit_metadata_manager_init (metadata_filename); g_free (metadata_filename); #endif /* Load settings */ priv->settings = gedit_settings_new (); priv->ui_settings = g_settings_new ("org.gnome.gedit.preferences.ui"); priv->window_settings = g_settings_new ("org.gnome.gedit.state.window"); /* initial lockdown state */ priv->lockdown = gedit_settings_get_lockdown (GEDIT_SETTINGS (priv->settings)); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); /* menus */ priv->window_menu = gtk_application_get_menubar (GTK_APPLICATION (application)); if (priv->window_menu == NULL) { priv->window_menu = get_menu_model (GEDIT_APP (application), "gear-menu"); } else { g_object_ref (priv->window_menu); } priv->notebook_menu = get_menu_model (GEDIT_APP (application), "notebook-menu"); priv->tab_width_menu = get_menu_model (GEDIT_APP (application), "tab-width-menu"); priv->line_col_menu = get_menu_model (GEDIT_APP (application), "line-col-menu"); /* Accelerators */ add_accelerator (GTK_APPLICATION (application), "app.new-window", "<Primary>N"); add_accelerator (GTK_APPLICATION (application), "app.quit", "<Primary>Q"); add_accelerator (GTK_APPLICATION (application), "app.help", "F1"); add_accelerator (GTK_APPLICATION (application), "win.gear-menu", "F10"); add_accelerator (GTK_APPLICATION (application), "win.open", "<Primary>O"); add_accelerator (GTK_APPLICATION (application), "win.save", "<Primary>S"); add_accelerator (GTK_APPLICATION (application), "win.save-as", "<Primary><Shift>S"); add_accelerator (GTK_APPLICATION (application), "win.save-all", "<Primary><Shift>L"); add_accelerator (GTK_APPLICATION (application), "win.new-tab", "<Primary>T"); add_accelerator (GTK_APPLICATION (application), "win.reopen-closed-tab", "<Primary><Shift>T"); add_accelerator (GTK_APPLICATION (application), "win.close", "<Primary>W"); add_accelerator (GTK_APPLICATION (application), "win.close-all", "<Primary><Shift>W"); add_accelerator (GTK_APPLICATION (application), "win.print", "<Primary>P"); add_accelerator (GTK_APPLICATION (application), "win.find", "<Primary>F"); add_accelerator (GTK_APPLICATION (application), "win.find-next", "<Primary>G"); add_accelerator (GTK_APPLICATION (application), "win.find-prev", "<Primary><Shift>G"); add_accelerator (GTK_APPLICATION (application), "win.replace", "<Primary>H"); add_accelerator (GTK_APPLICATION (application), "win.clear-highlight", "<Primary><Shift>K"); add_accelerator (GTK_APPLICATION (application), "win.goto-line", "<Primary>I"); add_accelerator (GTK_APPLICATION (application), "win.focus-active-view", "Escape"); add_accelerator (GTK_APPLICATION (application), "win.side-panel", "F9"); add_accelerator (GTK_APPLICATION (application), "win.bottom-panel", "<Primary>F9"); add_accelerator (GTK_APPLICATION (application), "win.fullscreen", "F11"); add_accelerator (GTK_APPLICATION (application), "win.new-tab-group", "<Primary><Alt>N"); add_accelerator (GTK_APPLICATION (application), "win.previous-tab-group", "<Primary><Shift><Alt>Page_Up"); add_accelerator (GTK_APPLICATION (application), "win.next-tab-group", "<Primary><Shift><Alt>Page_Down"); add_accelerator (GTK_APPLICATION (application), "win.previous-document", "<Primary><Alt>Page_Up"); add_accelerator (GTK_APPLICATION (application), "win.next-document", "<Primary><Alt>Page_Down"); load_accels (); /* Load custom css */ g_object_unref (load_css_from_resource ("gedit-style.css", TRUE)); css_provider = load_css_from_resource ("gedit-style-os.css", FALSE); g_clear_object (&css_provider); /* * We use the default gtksourceview style scheme manager so that plugins * can obtain it easily without a gedit specific api, but we need to * add our search path at startup before the manager is actually used. */ manager = gtk_source_style_scheme_manager_get_default (); gtk_source_style_scheme_manager_append_search_path (manager, gedit_dirs_get_user_styles_dir ()); priv->engine = gedit_plugins_engine_get_default (); priv->extensions = peas_extension_set_new (PEAS_ENGINE (priv->engine), GEDIT_TYPE_APP_ACTIVATABLE, "app", GEDIT_APP (application), NULL); g_signal_connect (priv->extensions, "extension-added", G_CALLBACK (extension_added), application); g_signal_connect (priv->extensions, "extension-removed", G_CALLBACK (extension_removed), application); peas_extension_set_foreach (priv->extensions, (PeasExtensionSetForeachFunc) extension_added, application); }