static void gb_view_source_lang_activate (GbViewSource *source, GtkMenuItem *menu_item) { GbViewSourcePrivate *priv; GtkSourceLanguageManager *lm; GtkSourceLanguage *lang; const gchar *lang_id; ENTRY; g_return_if_fail(GB_IS_VIEW_SOURCE(source)); g_return_if_fail(GTK_IS_MENU_ITEM(menu_item)); priv = source->priv; if ((lang_id = g_object_get_data(G_OBJECT(menu_item), "language-id"))) { lm = gtk_source_language_manager_get_default(); lang = gtk_source_language_manager_get_language(lm, lang_id); gtk_source_buffer_set_language(priv->buffer, lang); gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo), gtk_source_language_get_name(lang)); } EXIT; }
static GtkWidget * setup_editor (AppData *data) { GtkSourceBuffer *buffer; GtkSourceLanguageManager *manager; GtkSourceLanguage *lang; GtkWidget *view; manager = gtk_source_language_manager_get_default (); lang = gtk_source_language_manager_get_language (manager, "hip"); buffer = gtk_source_buffer_new_with_language (lang); view = gtk_source_view_new_with_buffer (buffer); gtk_widget_modify_font (view, pango_font_description_from_string ("monospace")); g_object_set (view, "auto-indent", TRUE, "indent-on-tab", TRUE, "indent-width", 8, "show-line-numbers", TRUE, NULL); /* Make it pretty ;) */ gtk_source_buffer_set_style_scheme (buffer, gtk_source_style_scheme_manager_get_scheme ( gtk_source_style_scheme_manager_get_default (), "tango")); gtk_widget_show (view); g_object_unref (buffer); data->text_buffer = GTK_TEXT_BUFFER (buffer); return view; }
static GtkSourceLanguage * ide_file_create_language (IdeFile *self) { GtkSourceLanguageManager *manager; GtkSourceLanguage *srclang; g_autofree gchar *content_type = NULL; const gchar *filename; gboolean uncertain = FALSE; g_assert (IDE_IS_FILE (self)); filename = g_file_get_basename (self->file); if (self->content_type) content_type = g_strdup (self->content_type); else content_type = g_content_type_guess (filename, NULL, 0, &uncertain); if (uncertain) g_clear_pointer (&content_type, g_free); else if (self->content_type == NULL) self->content_type = g_strdup (content_type); manager = gtk_source_language_manager_get_default (); srclang = gtk_source_language_manager_guess_language (manager, filename, content_type); return srclang; }
static void ide_preferences_builtin_register_languages (IdePreferences *preferences) { GtkSourceLanguageManager *manager; const gchar * const *language_ids; g_autoptr(GHashTable) sections = NULL; guint section_count = 0; gint i; sections = g_hash_table_new (g_str_hash, g_str_equal); ide_preferences_add_page (preferences, "languages", _("Programming Languages"), 200); manager = gtk_source_language_manager_get_default (); language_ids = gtk_source_language_manager_get_language_ids (manager); for (i = 0; language_ids [i]; i++) { IdePreferencesLanguageRow *row; GtkSourceLanguage *language; const gchar *name; const gchar *section; if (ide_str_equal0 (language_ids [i], "def")) continue; language = gtk_source_language_manager_get_language (manager, language_ids [i]); name = gtk_source_language_get_name (language); section = gtk_source_language_get_section (language); if (!g_hash_table_contains (sections, section)) { ide_preferences_add_list_group (preferences, "languages", section, section, section_count++); g_hash_table_insert (sections, (gchar *)section, NULL); } row = g_object_new (IDE_TYPE_PREFERENCES_LANGUAGE_ROW, "id", language_ids [i], "title", name, "visible", TRUE, NULL); ide_preferences_add_custom (preferences, "languages", section, GTK_WIDGET (row), NULL, 0); } ide_preferences_add_page (preferences, "languages.id", NULL, 0); ide_preferences_add_list_group (preferences, "languages.id", "basic", NULL, 0); ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "trim-trailing-whitespace", "/org/gnome/builder/editor/language/{id}/", NULL, _("Trim trailing whitespace"), _("Upon saving, trailing whitespace from modified lines will be trimmed."), NULL, 10); ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "overwrite-braces", "/org/gnome/builder/editor/language/{id}/", NULL, _("Overwrite Braces"), _("Overwrite closing braces"), NULL, 20); ide_preferences_add_list_group (preferences, "languages.id", "margin", _("Margins"), 0); ide_preferences_add_radio (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "show-right-margin", "/org/gnome/builder/editor/language/{id}/", NULL, _("Show right margin"), NULL, NULL, 0); ide_preferences_add_spin_button (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "right-margin-position", "/org/gnome/builder/editor/language/{id}/", _("Right margin position"), _("Position in spaces for the right margin"), NULL, 10); ide_preferences_add_list_group (preferences, "languages.id", "indentation", _("Indentation"), 100); ide_preferences_add_spin_button (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "tab-width", "/org/gnome/builder/editor/language/{id}/", _("Tab width"), _("Width of a tab character in spaces"), NULL, 10); ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "insert-spaces-instead-of-tabs", "/org/gnome/builder/editor/language/{id}/", NULL, _("Insert spaces instead of tabs"), _("Prefer spaces over use of tabs"), NULL, 20); ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "auto-indent", "/org/gnome/builder/editor/language/{id}/", NULL, _("Automatically indent"), _("Indent source code as you type"), NULL, 30); }
static gboolean gb_vim_set_filetype (GtkSourceView *source_view, const gchar *key, const gchar *value, GError **error) { GtkSourceLanguageManager *manager; GtkSourceLanguage *language; GtkTextBuffer *buffer; if (0 == g_strcmp0 (value, "cs")) value = "c-sharp"; else if (0 == g_strcmp0 (value, "xhmtl")) value = "html"; else if (0 == g_strcmp0 (value, "javascript")) value = "js"; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); manager = gtk_source_language_manager_get_default (); language = gtk_source_language_manager_get_language (manager, value); if (language == NULL) { g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Cannot find language '%s'"), value); return FALSE; } g_object_set (buffer, "language", language, NULL); return TRUE; }
GtkSourceLanguage * gitg_utils_get_language(gchar const *filename, gchar const *content_type) { if (!gitg_utils_can_display_content_type(content_type)) return NULL; GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default(); return gtk_source_language_manager_guess_language(manager, filename, content_type); }
static gboolean is_a_lang_id (GbBeautifierWorkbenchAddin *self, const gchar *lang_id) { GtkSourceLanguageManager *lang_manager; const gchar * const * lang_ids = NULL; lang_manager = gtk_source_language_manager_get_default (); lang_ids = gtk_source_language_manager_get_language_ids (lang_manager); return g_strv_contains (lang_ids, lang_id); }
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; }
GtkSourceLanguage * gitg_utils_get_language(gchar const *content_type) { if (!gitg_utils_can_display_content_type(content_type)) return NULL; gchar *mime = g_content_type_get_mime_type(content_type); GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default(); gchar const * const *ids = gtk_source_language_manager_get_language_ids(manager); gchar const *ptr; GtkSourceLanguage *ret; while ((ptr = *ids++)) { ret = gtk_source_language_manager_get_language(manager, ptr); gchar **mime_types = gtk_source_language_get_mime_types(ret); gchar **types = mime_types; gchar *m; if (types) { while ((m = *types++)) { if (strcmp(mime, m) == 0) { g_free(mime); g_strfreev(mime_types); return ret; } } g_strfreev(mime_types); } ret = NULL; } g_free(mime); return NULL; }
static void set_language_search_path () { GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default (); gchar const * const *orig = gtk_source_language_manager_get_search_path (manager); gchar const **dirs = g_new0 (gchar const *, g_strv_length ((gchar **)orig) + 2); guint i = 0; while (orig[i]) { dirs[i + 1] = orig[i]; ++i; } gchar *path = gitg_dirs_get_data_filename ("language-specs", NULL); dirs[0] = path; gtk_source_language_manager_set_search_path (manager, (gchar **)dirs); g_free (path); g_free (dirs); }
static void load_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GtkSourceFileLoader *loader = GTK_SOURCE_FILE_LOADER (source_object); EditorApplicationWindow *window = EDITOR_APPLICATION_WINDOW (user_data); GtkTextIter iter; GFile *location; GtkSourceLanguageManager *manager; GtkSourceLanguage *language; gchar *filename; GError *error = NULL; if (!gtk_source_file_loader_load_finish (loader, res, &error)) { g_warning ("Error while loading the file: %s", error->message); g_error_free (error); g_clear_object (&window->file); goto out; } gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (window->buffer), &iter); gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (window->buffer), &iter); location = gtk_source_file_loader_get_location (loader); filename = g_file_get_path (location); manager = gtk_source_language_manager_get_default (); language = gtk_source_language_manager_guess_language (manager, filename, NULL); g_free (filename); if (language) gtk_source_buffer_set_language (window->buffer, language); if (grammar_filename) set_indenter (window, grammar_filename); out: g_object_unref (loader); gtk_window_present (GTK_WINDOW (window)); }
/* If we are running from the source dir (e.g. during make check) * we override the path to read from the data dir */ static void init_default_manager (void) { gchar *dir; dir = g_build_filename (TOP_SRCDIR, "data", "language-specs", NULL); if (g_file_test (dir, G_FILE_TEST_IS_DIR)) { GtkSourceLanguageManager *lm; gchar **lang_dirs; lm = gtk_source_language_manager_get_default (); lang_dirs = g_new0 (gchar *, 2); lang_dirs[0] = dir; gtk_source_language_manager_set_search_path (lm, lang_dirs); g_strfreev (lang_dirs); } else {
static void gb_editor_tab_guess_language (GbEditorTab *tab) { GtkSourceLanguageManager *manager; GbEditorTabPrivate *priv; GtkSourceLanguage *lang; gboolean result_uncertain; gchar *content_type; gchar *filename; g_return_if_fail (GB_IS_EDITOR_TAB (tab)); priv = tab->priv; if (!priv->file) { return; } manager = gtk_source_language_manager_get_default (); filename = g_file_get_path (priv->file); content_type = g_content_type_guess (filename, NULL, 0, &result_uncertain); if (result_uncertain) { g_free (content_type); content_type = NULL; } lang = gtk_source_language_manager_guess_language (manager, filename, content_type); gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (priv->document), lang); gb_editor_tab_reload_snippets (tab, lang); g_free (content_type); g_free (filename); }
static void ide_editor_view_actions_language (GSimpleAction *action, GVariant *variant, gpointer user_data) { IdeEditorView *self = user_data; GtkSourceLanguageManager *manager; GtkSourceLanguage *language; GtkSourceBuffer *buffer; const gchar *name; g_assert (IDE_IS_EDITOR_VIEW (self)); manager = gtk_source_language_manager_get_default (); name = g_variant_get_string (variant, NULL); buffer = GTK_SOURCE_BUFFER (self->document); if (name != NULL) { language = gtk_source_language_manager_get_language (manager, name); gtk_source_buffer_set_language (buffer, language); ide_editor_view_actions_update (self); } }
static void gb_view_source_set_file_attribs (GbViewSource *source, GFile *file) { GtkSourceLanguageManager *lm; GbViewSourcePrivate *priv; GtkSourceLanguage *lang; const gchar *icon_name; GFileInfo *info; gchar *path; ENTRY; g_return_if_fail(GB_IS_VIEW_SOURCE(source)); g_return_if_fail(G_IS_FILE(file)); priv = source->priv; if (!(path = g_file_get_path(file))) { path = g_file_get_uri(file); } if ((icon_name = gb_path_get_icon_name(path))) { gb_view_set_icon_name(GB_VIEW(source), icon_name); } info = g_file_query_info(file, "standard::*", 0, NULL, NULL); /* * Get the relative path to the file from the project. */ { const gchar *directory; GtkWidget *window; GbProject *project; gb_view_set_name(GB_VIEW(source), path); window = gtk_widget_get_toplevel(GTK_WIDGET(source)); if (GB_IS_WINDOW(window)) { project = gb_window_get_project(GB_WINDOW(window)); directory = gb_project_get_directory(project); if (g_str_has_prefix(path, directory)) { gb_view_set_name(GB_VIEW(source), path + strlen(directory)); } } } lm = gtk_source_language_manager_get_default(); lang = gtk_source_language_manager_guess_language( lm, path, g_file_info_get_content_type(info)); if (lang) { gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo), gtk_source_language_get_name(lang)); } else { gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo), ""); } gtk_source_buffer_set_language(priv->buffer, lang); g_object_unref(info); g_free(path); EXIT; }
/** * gb_view_source_init: * @: (in): A #GbViewSource. * * Initializes the newly created #GbViewSource instance. */ static void gb_view_source_init (GbViewSource *source) { GbViewSourcePrivate *priv; GtkWidget *overlay; ENTRY; source->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE(source, GB_TYPE_VIEW_SOURCE, GbViewSourcePrivate); g_object_set(source, "icon-name", GTK_STOCK_FILE, "name", _("Unsaved Document"), NULL); priv->buffer = gtk_source_buffer_new(NULL); g_signal_connect_swapped(priv->buffer, "notify::cursor-position", G_CALLBACK(gb_view_source_notify_cursor), source); g_signal_connect_swapped(priv->buffer, "modified-changed", G_CALLBACK(gb_view_source_buffer_modified_changed), source); overlay = g_object_new(GTK_TYPE_OVERLAY, "visible", TRUE, NULL); g_signal_connect(overlay, "get-child-position", G_CALLBACK(gb_view_source_position_progress), NULL); gtk_container_add_with_properties(GTK_CONTAINER(source), overlay, "left-attach", 0, "width", 1, "top-attach", 0, "height", 1, NULL); priv->vpaned = g_object_new(GTK_TYPE_VPANED, "visible", TRUE, NULL); gtk_container_add(GTK_CONTAINER(overlay), priv->vpaned); priv->progress = g_object_new(GB_TYPE_PROGRESS_BAR, "visible", FALSE, NULL); gtk_overlay_add_overlay(GTK_OVERLAY(overlay), priv->progress); priv->scroller1 = g_object_new(gb_get_scrolled_window_gtype(), "expand", TRUE, "visible", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(priv->vpaned), priv->scroller1, "shrink", FALSE, "resize", TRUE, NULL); priv->source1 = gb_view_source_create_source_view(source); gtk_container_add(GTK_CONTAINER(priv->scroller1), priv->source1); { GtkSourceLanguageManager *langs = gtk_source_language_manager_get_default(); const gchar * const * ids = gtk_source_language_manager_get_language_ids(langs); GtkSourceLanguage *lang; const gchar *section; GHashTable *section_menu; GPtrArray *sorted; GtkWidget *controls = gb_view_get_controls(GB_VIEW(source)); GtkWidget *menu; GtkWidget *mitem; GtkWidget *submenu; guint i; section_menu = g_hash_table_new(g_str_hash, g_str_equal); menu = gtk_menu_new(); sorted = g_ptr_array_new(); for (i = 0; ids[i]; i++) { lang = gtk_source_language_manager_get_language(langs, ids[i]); g_ptr_array_add(sorted, lang); } g_ptr_array_sort(sorted, lang_sort_func); for (i = 0; i < sorted->len; i++) { lang = g_ptr_array_index(sorted, i); section = gtk_source_language_get_section(lang); if (!(submenu = g_hash_table_lookup(section_menu, section))) { submenu = gtk_menu_new(); mitem = g_object_new(GTK_TYPE_MENU_ITEM, "label", section, "submenu", submenu, "visible", TRUE, NULL); gtk_container_add(GTK_CONTAINER(menu), mitem); g_hash_table_insert(section_menu, (gchar*)section, submenu); } mitem = g_object_new(GTK_TYPE_MENU_ITEM, "label", gtk_source_language_get_name(lang), "visible", TRUE, NULL); g_signal_connect_swapped(mitem, "activate", G_CALLBACK(gb_view_source_lang_activate), source); g_object_set_data(G_OBJECT(mitem), "language-id", (gchar *)gtk_source_language_get_id(lang)); gtk_container_add(GTK_CONTAINER(submenu), mitem); } g_ptr_array_free(sorted, TRUE); priv->lang_combo = g_object_new(GB_TYPE_MENU_BUTTON, "hexpand", FALSE, "label", "", "menu", menu, "tooltip-text", _("Set source language."), "visible", TRUE, NULL); gb_widget_shrink_font( gb_menu_button_get_label_widget( GB_MENU_BUTTON(priv->lang_combo))); gtk_style_context_add_class(gtk_widget_get_style_context(priv->lang_combo), GB_STYLE_CLASS_TOP_BAR); gtk_container_add_with_properties(GTK_CONTAINER(controls), priv->lang_combo, "expand", FALSE, NULL); g_hash_table_unref(section_menu); } { GtkWidget *controls = gb_view_get_controls(GB_VIEW(source)); GtkWidget *b; GtkWidget *item; GtkWidget *menu; GtkWidget *group = NULL; gboolean active; gchar *str; int tabs[] = { 2, 3, 4, 5, 8, 0 }; int i; b = g_object_new(GB_TYPE_MENU_BUTTON, "hexpand", FALSE, "label", "4", "tooltip-text", _("Set tab-character width."), "visible", TRUE, "width-request", 45, NULL); menu = gtk_menu_new(); for (i = 0; tabs[i]; i++) { str = g_strdup_printf("%d", tabs[i]); item = g_object_new(GTK_TYPE_RADIO_MENU_ITEM, "group", group, "label", str, "visible", TRUE, NULL); if (!group) { group = item; } active = (tabs[i] == gtk_source_view_get_tab_width( GTK_SOURCE_VIEW(priv->source1))); g_object_set(item, "active", active, NULL); if (active) { g_object_set(b, "label", str, NULL); } g_signal_connect(item, "activate", G_CALLBACK(gb_view_source_tab_size_activate), source); gtk_container_add(GTK_CONTAINER(menu), item); g_free(str); } g_object_set(b, "menu", menu, NULL); item = g_object_new(GTK_TYPE_SEPARATOR_MENU_ITEM, "visible", TRUE, NULL); gtk_container_add(GTK_CONTAINER(menu), item); item = g_object_new(GTK_TYPE_CHECK_MENU_ITEM, "active", TRUE, "label", _("Use Spaces"), "visible", TRUE, NULL); g_signal_connect(item, "toggled", G_CALLBACK(gb_view_source_spaces_toggled), source); gtk_container_add(GTK_CONTAINER(menu), item); gb_widget_shrink_font(gb_menu_button_get_label_widget(GB_MENU_BUTTON(b))); gtk_style_context_add_class(gtk_widget_get_style_context(b), GB_STYLE_CLASS_TOP_BAR); gtk_container_add_with_properties(GTK_CONTAINER(controls), b, "expand", FALSE, NULL); priv->size_combo = b; } { GtkWidget *controls = gb_view_get_controls(GB_VIEW(source)); GtkWidget *img; GtkWidget *b; img = g_object_new(GTK_TYPE_IMAGE, "icon-name", "gb-split", "icon-size", GTK_ICON_SIZE_MENU, "visible", TRUE, NULL); b = g_object_new(GTK_TYPE_TOGGLE_BUTTON, "child", img, "tooltip-text", _("Split the editor into two views."), "visible", TRUE, NULL); gtk_style_context_add_class(gtk_widget_get_style_context(b), GB_STYLE_CLASS_TOP_BAR); gtk_container_add_with_properties(GTK_CONTAINER(controls), b, "expand", FALSE, NULL); g_signal_connect(b, "toggled", G_CALLBACK(split_toggled), source); } { GtkWidget *hbox; GtkWidget *vp; GtkWidget *c; hbox = g_object_new(GTK_TYPE_HBOX, "height-request", 30, "visible", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(source), hbox, "height", 1, "left-attach", 0, "top-attach", 1, "width", 1, NULL); gtk_container_add(GTK_CONTAINER(hbox), (c = g_object_new(GTK_TYPE_COMBO_BOX, "visible", TRUE, NULL))); gtk_style_context_add_class(gtk_widget_get_style_context(c), GB_STYLE_CLASS_BOTTOM_BAR); vp = g_object_new(GTK_TYPE_VIEWPORT, "visible", TRUE, NULL); gtk_style_context_add_class(gtk_widget_get_style_context(vp), GB_STYLE_CLASS_BOTTOM_BAR); gtk_container_add_with_properties(GTK_CONTAINER(hbox), vp, "expand", FALSE, "fill", TRUE, NULL); priv->pos_label = g_object_new(GTK_TYPE_LABEL, "label", _("Line 1, Column 1"), "visible", TRUE, "xalign", 1.0f, "xpad", 6, NULL); gb_widget_shrink_font(priv->pos_label); gtk_container_add(GTK_CONTAINER(vp), priv->pos_label); } priv->theme_handler = g_signal_connect_swapped(gtk_settings_get_default(), "notify::gtk-application-prefer-dark-theme", G_CALLBACK(gb_view_source_update_style), source); EXIT; }
void modeline_parser_apply_modeline (GtkSourceView *view) { ModelineOptions options; GtkTextBuffer *buffer; GtkTextIter iter, liter; gint line_count; GSettings *settings; options.language_id = NULL; options.set = MODELINE_SET_NONE; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_buffer_get_start_iter (buffer, &iter); line_count = gtk_text_buffer_get_line_count (buffer); /* Parse the modelines on the 10 first lines... */ while ((gtk_text_iter_get_line (&iter) < 10) && !gtk_text_iter_is_end (&iter)) { gchar *line; liter = iter; gtk_text_iter_forward_to_line_end (&iter); line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE); parse_modeline (line, 1 + gtk_text_iter_get_line (&iter), line_count, &options); gtk_text_iter_forward_line (&iter); g_free (line); } /* ...and on the 10 last ones (modelines are not allowed in between) */ if (!gtk_text_iter_is_end (&iter)) { gint cur_line; guint remaining_lines; /* we are on the 11th line (count from 0) */ cur_line = gtk_text_iter_get_line (&iter); /* g_assert (10 == cur_line); */ remaining_lines = line_count - cur_line - 1; if (remaining_lines > 10) { gtk_text_buffer_get_end_iter (buffer, &iter); gtk_text_iter_backward_lines (&iter, 9); } } while (!gtk_text_iter_is_end (&iter)) { gchar *line; liter = iter; gtk_text_iter_forward_to_line_end (&iter); line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE); parse_modeline (line, 1 + gtk_text_iter_get_line (&iter), line_count, &options); gtk_text_iter_forward_line (&iter); g_free (line); } /* Try to set language */ if (has_option (&options, MODELINE_SET_LANGUAGE) && options.language_id) { if (g_ascii_strcasecmp (options.language_id, "text") == 0) { gedit_document_set_language (GEDIT_DOCUMENT (buffer), NULL); } else { GtkSourceLanguageManager *manager; GtkSourceLanguage *language; manager = gtk_source_language_manager_get_default (); language = gtk_source_language_manager_get_language (manager, options.language_id); if (language != NULL) { gedit_document_set_language (GEDIT_DOCUMENT (buffer), language); } else { gedit_debug_message (DEBUG_PLUGINS, "Unknown language `%s'", options.language_id); } } } ModelineOptions *previous = g_object_get_data (G_OBJECT (buffer), MODELINE_OPTIONS_DATA_KEY); settings = g_settings_new ("org.gnome.gedit.preferences.editor"); /* Apply the options we got from modelines and restore defaults if we set them before */ if (has_option (&options, MODELINE_SET_INSERT_SPACES)) { gtk_source_view_set_insert_spaces_instead_of_tabs (view, options.insert_spaces); } else if (check_previous (view, previous, MODELINE_SET_INSERT_SPACES)) { gboolean insert_spaces; insert_spaces = g_settings_get_boolean (settings, GEDIT_SETTINGS_INSERT_SPACES); gtk_source_view_set_insert_spaces_instead_of_tabs (view, insert_spaces); } if (has_option (&options, MODELINE_SET_TAB_WIDTH)) { gtk_source_view_set_tab_width (view, options.tab_width); } else if (check_previous (view, previous, MODELINE_SET_TAB_WIDTH)) { guint tab_width; g_settings_get (settings, GEDIT_SETTINGS_TABS_SIZE, "u", &tab_width); gtk_source_view_set_tab_width (view, tab_width); } if (has_option (&options, MODELINE_SET_INDENT_WIDTH)) { gtk_source_view_set_indent_width (view, options.indent_width); } else if (check_previous (view, previous, MODELINE_SET_INDENT_WIDTH)) { gtk_source_view_set_indent_width (view, -1); } if (has_option (&options, MODELINE_SET_WRAP_MODE)) { gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), options.wrap_mode); } else if (check_previous (view, previous, MODELINE_SET_WRAP_MODE)) { GtkWrapMode mode; mode = g_settings_get_enum (settings, GEDIT_SETTINGS_WRAP_MODE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), mode); } if (has_option (&options, MODELINE_SET_RIGHT_MARGIN_POSITION)) { gtk_source_view_set_right_margin_position (view, options.right_margin_position); } else if (check_previous (view, previous, MODELINE_SET_RIGHT_MARGIN_POSITION)) { guint right_margin_pos; g_settings_get (settings, GEDIT_SETTINGS_RIGHT_MARGIN_POSITION, "u", &right_margin_pos); gtk_source_view_set_right_margin_position (view, right_margin_pos); } if (has_option (&options, MODELINE_SET_SHOW_RIGHT_MARGIN)) { gtk_source_view_set_show_right_margin (view, options.display_right_margin); } else if (check_previous (view, previous, MODELINE_SET_SHOW_RIGHT_MARGIN)) { gboolean display_right_margin; display_right_margin = g_settings_get_boolean (settings, GEDIT_SETTINGS_DISPLAY_RIGHT_MARGIN); gtk_source_view_set_show_right_margin (view, display_right_margin); } if (previous) { g_free (previous->language_id); *previous = options; previous->language_id = g_strdup (options.language_id); } else { previous = g_slice_new (ModelineOptions); *previous = options; previous->language_id = g_strdup (options.language_id); g_object_set_data_full (G_OBJECT (buffer), MODELINE_OPTIONS_DATA_KEY, previous, (GDestroyNotify)free_modeline_options); } g_object_unref (settings); g_free (options.language_id); }
PUSS_EXPORT void* puss_plugin_create(Puss* app) { GTree* sections; GtkSourceLanguageManager* lm; const gchar* const* ids; const gchar* const* id; GtkSourceLanguage* lang; const gchar* name; gchar* action_name; GtkAction* action; const gchar* section; GList* section_list; GtkUIManager* ui_mgr; IToolMenuAction* tool_menu_interface; GString* gstr; gchar* ui_info; GError* err; tool_menu_interface = app->extend_query("puss_controls", INTERFACE_TOOL_MENU_ACTION); if( !tool_menu_interface ) return 0; bindtextdomain(TEXT_DOMAIN, app->get_locale_path()); bind_textdomain_codeset(TEXT_DOMAIN, "UTF-8"); g_self = g_new0(LanguageSelector, 1); g_self->app = app; g_self->action_group = gtk_action_group_new("puss_language_selector_action_group"); // set select language menu sections = g_tree_new_full((GCompareDataFunc)&g_ascii_strcasecmp, 0, 0, (GDestroyNotify)g_list_free); lm = gtk_source_language_manager_get_default(); ids = gtk_source_language_manager_get_language_ids(lm); g_self->last_favory_lang = gtk_source_language_manager_get_language(lm, "cpp"); for( id=ids; *id; ++id ) { lang = gtk_source_language_manager_get_language(lm, *id); if( lang ) { name = gtk_source_language_get_name(lang); action_name = g_strdup_printf("pls_lang_%s", name); action = gtk_action_new(action_name, name, NULL, NULL); g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), lang); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); g_free(action_name); section = gtk_source_language_get_section(lang); section_list = (GList*)g_tree_lookup(sections, section); if( section_list ) { g_tree_steal(sections, section); } else { action_name = g_strdup_printf("pls_sec_%s", section); action = GTK_ACTION(gtk_action_new(action_name, section, NULL, NULL)); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); g_free(action_name); } section_list = g_list_insert_sorted(section_list, (gchar*)name, (GCompareFunc)&g_ascii_strcasecmp); g_tree_insert(sections, (gchar*)section, section_list); } } // insert language selector menu-tool-button // action = gtk_action_new("language_selector_open", _("Language"), _("select high-light source language, default use last"), GTK_STOCK_SELECT_COLOR); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); action = GTK_ACTION( g_object_new(tool_menu_interface->get_type () , "name", "language_selector_toolmenu_open" , "label", _("Language") , "tooltip", _("select high-light source language, default use last") , "stock-id", GTK_STOCK_SELECT_COLOR , NULL) ); g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), 0); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); ui_mgr = GTK_UI_MANAGER(gtk_builder_get_object(app->get_ui_builder(), "main_ui_manager")); gtk_ui_manager_insert_action_group(ui_mgr, g_self->action_group, 0); // main selector menu gstr= g_string_new(NULL); g_tree_foreach(sections, (GTraverseFunc)&fill_language_section, gstr); g_tree_destroy(sections); ui_info = g_strdup_printf( "<ui>" " <menubar name='main_menubar'>" " <menu action='view_menu'>\n" " <placeholder name='view_menu_extend_place'>" " <menu action='language_selector_open'>" " %s" " <placeholder name='pls_favory_menu_place'>" " </placeholder>" " </menu>" " </placeholder>" " </menu>" " </menubar>" "" " <toolbar name='main_toolbar'>" " <placeholder name='main_toolbar_view_place'>" " <toolitem action='language_selector_toolmenu_open'>" " <menu action='language_selector_toolmenu_open'>" " %s" " <placeholder name='pls_favory_toolmenu_place'>" " </placeholder>" " </menu>" " </toolitem>" " </placeholder>" " </toolbar>" "</ui>" , gstr->str , gstr->str ); //g_print(ui_info); err = 0; g_self->merge_id = gtk_ui_manager_add_ui_from_string(ui_mgr, ui_info, -1, &err); if( err ) { g_printerr("%s", err->message); g_error_free(err); } g_free(ui_info); g_string_free(gstr, TRUE); gtk_ui_manager_ensure_update(ui_mgr); fill_favory_language_menu(); return g_self; }
void save_as_file(GtkButton *button) { /** Save the current editor content as the choosen file. **/ #ifdef DEBUG DEBUG_FUNC_MARK #endif GtkWidget *file_chooser = gtk_file_chooser_dialog_new( _("Save as file"), GTK_WINDOW(gui->main_window), GTK_FILE_CHOOSER_ACTION_SAVE, _("Cancel"), GTK_RESPONSE_CANCEL, _("Save as"), GTK_RESPONSE_ACCEPT, NULL) ; /** Retrieve the stored filepath: **/ gpointer stored_filepath = g_object_get_data(G_OBJECT(current_editor.current_buffer), "filepath") ; /** Storing last opened file folder. **/ if (open_file_dirname != NULL) { g_free(open_file_dirname) ; } open_file_dirname = g_strdup(g_path_get_dirname(stored_filepath)) ; gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), open_file_dirname ); gint res; GtkFileChooser *chooser; chooser = GTK_FILE_CHOOSER(file_chooser); gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); res = gtk_dialog_run(GTK_DIALOG(file_chooser)) ; if (res == GTK_RESPONSE_ACCEPT) { char *filepath ; filepath = gtk_file_chooser_get_filename(chooser); /** Getting current editor content **/ GtkTextIter iter_start, iter_end ; GError *error = NULL ; gtk_text_buffer_get_start_iter(current_editor.current_buffer, &iter_start); gtk_text_buffer_get_end_iter(current_editor.current_buffer, &iter_end); gchar *file_content = gtk_text_buffer_get_text(current_editor.current_buffer, &iter_start, &iter_end, FALSE) ; if (! g_file_set_contents(filepath, file_content, -1, &error) ) { /** Failed to save editor content as file, display an error message and return. **/ char *msg = g_strdup_printf(_("Failed to save file:\n%s"), filepath) ; display_message_dialog(_("Cannot save file !!!"), msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE) ; free(msg) ; return ; } /** Mark the TextBuffer as not modfied. **/ gtk_text_buffer_set_modified(current_editor.current_buffer, FALSE) ; /** Only useful if the content type has changed like a new file saved as a *.c file. **/ GtkSourceLanguage *source_language = NULL ; GtkSourceLanguageManager *source_language_manager = gtk_source_language_manager_get_default(); gboolean result_uncertain ; gchar *content_type ; content_type = g_content_type_guess( g_path_get_basename(filepath), (const guchar *) file_content, strlen(file_content), &result_uncertain) ; if (content_type && source_language_manager) { source_language = gtk_source_language_manager_guess_language(source_language_manager, g_path_get_basename(filepath), content_type); if (source_language) { set_syntax_highlight_radio(gtk_source_language_get_id(source_language)) ; gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(current_editor.current_buffer), source_language) ; g_object_set_data(G_OBJECT(current_editor.current_textview), "lang_id", (char *) gtk_source_language_get_id(source_language)) ; } g_free(content_type) ; } /** Update the notebook label tab **/ GtkWidget *notebook_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui->editor_notebook), current_editor.current_notebook_page); /** The tab contains an mimetype icon, the filename and the page closing button. **/ GList *tab_compound_list = gtk_container_get_children(GTK_CONTAINER(notebook_tab)) ; tab_compound_list = g_list_first(tab_compound_list) ; while (tab_compound_list->data != NULL) { /** We iterate over the notebook tab component **/ if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_filename_widget")) { /** Set the new filename in the tab. **/ gtk_label_set_text(GTK_LABEL(tab_compound_list->data), g_path_get_basename(filepath)) ; } if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_icon") && source_language) { uint8_t c ; for ( c=0 ; ; c++) { if (gtk_source_language_get_mime_types(source_language) == NULL) { break ; } char *mimetype = gtk_source_language_get_mime_types(source_language)[c] ; if (mimetype == NULL) { /** don't find an specific mimetype for this new file extension use default icon. **/ g_object_set(G_OBJECT(tab_compound_list->data),"file", PATH_TO_MIMETYPE_ICON "unknown.png", NULL) ; break ; } /** We search for an image filename ending with the corresponding mimetype: **/ char *ptr = strchr(mimetype, '/') ; if (ptr != NULL) { /** Simply pointer arithmetic to exchange the '/' (used in mimetypes) and the '-' (used in the images names) character **/ mimetype[ptr - mimetype] = '-' ; gchar *filepath = g_strdup_printf("%s%s.png", PATH_TO_MIMETYPE_ICON, mimetype) ; if ( g_file_test(filepath, G_FILE_TEST_EXISTS) ) { /** We found an corresponding image for this mimetype. **/ g_object_set(G_OBJECT(tab_compound_list->data),"file", filepath, NULL) ; free(filepath) ; break ; } free(filepath) ; } } } if (tab_compound_list->next == NULL) { break ; } tab_compound_list = tab_compound_list->next ; } g_free(file_content) ; /** Storing filepath for further saving operations. **/ g_object_set_data(G_OBJECT(current_editor.current_buffer), "filepath", filepath) ; /** setting the base filename in the bottom bar. **/ gtk_label_set_text(GTK_LABEL(gui->bottom_bar->filename_label), g_path_get_basename(filepath)) ; if (settings.rm_trailing_spaces) { /** Deleting trailing spaces. **/ char *trailing_spaces_deleting ; trailing_spaces_deleting = g_strdup_printf("sed -i 's/[[:space:]]$//' '%s'", (char *) filepath) ; int ret ; if ((ret = system(trailing_spaces_deleting)) == -1) { g_warning( _("Removing trailing space failure:\n%s\n"), trailing_spaces_deleting) ; } free(trailing_spaces_deleting) ; } File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ; gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(gui->editor_notebook), file_editor->scrolled_window, g_path_get_basename(filepath) ) ; #ifdef RELOADING_FUNC /** Update Last modification timestamp. **/ File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ; g_stat(filepath, &file_editor->file_info) ; #endif } /** @NOTE: the filepath must not be free because it is set as data from the file_editor->buffer for further use. **/ gtk_widget_destroy(file_chooser); }