static gboolean looks_like_makefile (IdeBuffer *buffer) { GtkSourceLanguage *language; const gchar *path; IdeFile *file; g_assert (IDE_IS_BUFFER (buffer)); file = ide_buffer_get_file (buffer); path = ide_file_get_path (file); if (path != NULL) { if (g_str_has_suffix (path, "Makefile.am") || g_str_has_suffix (path, ".mk")) return TRUE; } language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer)); if (language != NULL) { const gchar *lang_id; lang_id = gtk_source_language_get_id (language); if (ide_str_equal0 (lang_id, "automake") || ide_str_equal0 (lang_id, "makefile")) return TRUE; } return FALSE; }
static void gb_editor_tab_apply_settings (GbEditorTab *tab) { GbEditorTabPrivate *priv; GtkSourceLanguage *lang; const gchar *name; gchar *path; g_return_if_fail (GB_IS_EDITOR_TAB (tab)); priv = tab->priv; g_clear_object (&priv->settings); lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (priv->document)); if (lang) { name = gtk_source_language_get_id (lang); } else { name = "plaintext"; } path = g_strdup_printf ("/org/gnome/builder/preferences/editor/language/%s/", name); priv->settings = g_settings_new_with_path ("org.gnome.builder.preferences.editor.language", path); g_free (path); g_settings_bind (priv->settings, "highlight-matching-brackets", priv->document, "highlight-matching-brackets", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "highlight-current-line", priv->text_view, "highlight-current-line", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "insert-spaces-instead-of-tabs", priv->text_view, "insert-spaces-instead-of-tabs", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "right-margin-position", priv->text_view, "right-margin-position", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-line-marks", priv->text_view, "show-line-marks", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-line-numbers", priv->text_view, "show-line-numbers", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-right-margin", priv->text_view, "show-right-margin", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "tab-width", priv->text_view, "tab-width", G_SETTINGS_BIND_GET); }
static void ide_editor_view__extension_added (PeasExtensionSet *set, PeasPluginInfo *info, PeasExtension *exten, gpointer user_data) { IdeEditorView *self = user_data; IdeEditorViewAddin *addin = (IdeEditorViewAddin *)exten; g_assert (PEAS_IS_EXTENSION_SET (set)); g_assert (info != NULL); g_assert (IDE_IS_EDITOR_VIEW_ADDIN (addin)); g_assert (IDE_IS_EDITOR_VIEW (self)); ide_editor_view_addin_load (addin, self); if (self->document != NULL) { GtkSourceLanguage *language; language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document)); if (language != NULL) { const gchar *language_id; language_id = gtk_source_language_get_id (language); ide_editor_view_addin_language_changed (addin, language_id); } } }
static const gchar * get_language_string (GeditDocument *doc) { GtkSourceLanguage *lang = gedit_document_get_language (doc); return lang != NULL ? gtk_source_language_get_id (lang) : NO_LANGUAGE_NAME; }
static void gb_editor_view_actions_preview (GSimpleAction *action, GVariant *param, gpointer user_data) { GbEditorView *self = user_data; GtkSourceLanguage *language; const gchar *lang_id = NULL; g_autoptr(GbDocument) document = NULL; g_assert (GB_IS_EDITOR_VIEW (self)); language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document)); if (!language) return; lang_id = gtk_source_language_get_id (language); if (!lang_id) return; #if 0 if (g_str_equal (lang_id, "html")) { document = g_object_new (GB_TYPE_HTML_DOCUMENT, "buffer", self->document, NULL); } else if (g_str_equal (lang_id, "markdown")) { document = g_object_new (GB_TYPE_HTML_DOCUMENT, "buffer", self->document, NULL); gb_html_document_set_transform_func (GB_HTML_DOCUMENT (document), gb_html_markdown_transform); } #endif if (document) { GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (self)); while (parent && !GB_IS_VIEW_GRID (parent)) parent = gtk_widget_get_parent (parent); if (parent == NULL) { while (parent && !GB_IS_VIEW_STACK (parent)) parent = gtk_widget_get_parent (parent); g_assert (GB_IS_VIEW_STACK (parent)); gb_view_stack_focus_document (GB_VIEW_STACK (parent), document); return; } g_assert (GB_IS_VIEW_GRID (parent)); gb_view_grid_focus_document (GB_VIEW_GRID (parent), document); } }
static gboolean check_previous (GtkSourceView *view, ModelineOptions *previous, ModelineSet set) { GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); /* Do not restore default when this is the first time */ if (!previous) return FALSE; /* Do not restore default when previous was not set */ if (!(previous->set & set)) return FALSE; /* Only restore default when setting has not changed */ switch (set) { case MODELINE_SET_INSERT_SPACES: return gtk_source_view_get_insert_spaces_instead_of_tabs (view) == previous->insert_spaces; break; case MODELINE_SET_TAB_WIDTH: return gtk_source_view_get_tab_width (view) == previous->tab_width; break; case MODELINE_SET_INDENT_WIDTH: return gtk_source_view_get_indent_width (view) == previous->indent_width; break; case MODELINE_SET_WRAP_MODE: return gtk_text_view_get_wrap_mode (GTK_TEXT_VIEW (view)) == previous->wrap_mode; break; case MODELINE_SET_RIGHT_MARGIN_POSITION: return gtk_source_view_get_right_margin_position (view) == previous->right_margin_position; break; case MODELINE_SET_SHOW_RIGHT_MARGIN: return gtk_source_view_get_show_right_margin (view) == previous->display_right_margin; break; case MODELINE_SET_LANGUAGE: { GtkSourceLanguage *language = gtk_source_buffer_get_language (buffer); return (language == NULL && previous->language_id == NULL) || (language != NULL && g_strcmp0 (gtk_source_language_get_id (language), previous->language_id) == 0); } break; default: return FALSE; break; } }
static void ide_highlight_engine__notify_language_cb (IdeHighlightEngine *self, GParamSpec *pspec, IdeBuffer *buffer) { GtkSourceLanguage *language; const gchar *lang_id = NULL; g_assert (IDE_IS_HIGHLIGHT_ENGINE (self)); g_assert (IDE_IS_BUFFER (buffer)); if ((language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer)))) lang_id = gtk_source_language_get_id (language); ide_extension_adapter_set_value (self->extension, lang_id); }
static void ide_editor_view__buffer_notify_language (IdeEditorView *self, GParamSpec *pspec, IdeBuffer *document) { g_assert (IDE_IS_EDITOR_VIEW (self)); g_assert (IDE_IS_BUFFER (document)); if (self->extensions != NULL) { GtkSourceLanguage *language; const gchar *language_id; language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (document)); language_id = language ? gtk_source_language_get_id (language) : NULL; peas_extension_set_foreach (self->extensions, notify_language_foreach, (gchar *)language_id); } }
void gb_editor_view_actions_update (GbEditorView *self) { GtkSourceLanguage *language; const gchar *lang_id = NULL; GActionGroup *group; GAction *action; gboolean enabled; g_assert (GB_IS_EDITOR_VIEW (self)); group = gtk_widget_get_action_group (GTK_WIDGET (self), "view"); if (!G_IS_SIMPLE_ACTION_GROUP (group)) return; /* update preview sensitivity */ language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document)); if (language) lang_id = gtk_source_language_get_id (language); enabled = ((g_strcmp0 (lang_id, "html") == 0) || (g_strcmp0 (lang_id, "markdown") == 0)); action = g_action_map_lookup_action (G_ACTION_MAP (group), "preview"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled); }
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); }
/** * 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; }
static void populate_cache (EggTaskCache *cache, gconstpointer key, GTask *task, gpointer user_data) { IdeGettextDiagnosticProvider *self = user_data; g_autoptr(IdeUnsavedFile) unsaved_file = NULL; g_autoptr(GSubprocess) subprocess = NULL; GtkSourceLanguage *language; const gchar *language_id; const gchar *xgettext_lang; const gchar *temp_path; TranslationUnit *unit; IdeFile *file = (IdeFile *)key; GCancellable *cancellable; GError *error = NULL; GPtrArray *args; g_assert (EGG_IS_TASK_CACHE (cache)); g_assert (IDE_IS_FILE (file)); g_assert (IDE_IS_GETTEXT_DIAGNOSTIC_PROVIDER (self)); cancellable = g_task_get_cancellable (task); if (NULL == (unsaved_file = get_unsaved_file (self, file))) { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "Failed to locate file contents"); return; } if (NULL == (language = ide_file_get_language (file)) || NULL == (language_id = gtk_source_language_get_id (language)) || NULL == (xgettext_lang = id_to_xgettext_language (language_id))) { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Failed to determine language type"); return; } if (!ide_unsaved_file_persist (unsaved_file, cancellable, &error)) { g_task_return_error (task, error); return; } temp_path = ide_unsaved_file_get_temp_path (unsaved_file); g_assert (temp_path != NULL); args = g_ptr_array_new (); g_ptr_array_add (args, "xgettext"); g_ptr_array_add (args, "--check=ellipsis-unicode"); g_ptr_array_add (args, "--check=quote-unicode"); g_ptr_array_add (args, "--check=space-ellipsis"); g_ptr_array_add (args, "-k_"); g_ptr_array_add (args, "-kN_"); g_ptr_array_add (args, "-L"); g_ptr_array_add (args, (gchar *)xgettext_lang); g_ptr_array_add (args, "-o"); g_ptr_array_add (args, "-"); g_ptr_array_add (args, (gchar *)temp_path); g_ptr_array_add (args, NULL); #ifdef IDE_ENABLE_TRACE { g_autofree gchar *str = NULL; str = g_strjoinv (" ", (gchar **)args->pdata); IDE_TRACE_MSG ("Launching '%s'", str); } #endif subprocess = g_subprocess_newv ((const gchar * const *)args->pdata, G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_PIPE, &error); g_ptr_array_free (args, TRUE); if (subprocess == NULL) { g_task_return_error (task, error); return; } unit = g_slice_new0 (TranslationUnit); unit->file = g_object_ref (file); unit->unsaved_file = ide_unsaved_file_ref (unsaved_file); g_task_set_task_data (task, unit, (GDestroyNotify)translation_unit_free); g_subprocess_wait_async (subprocess, cancellable, subprocess_wait_cb, g_object_ref (task)); }
Gobby::MenuManager::MenuManager(GtkSourceLanguageManager* language_manager) { Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_resource( "/de/0x539/gobby/ui/menu.ui"); m_app_menu = Glib::RefPtr<Gio::Menu>::cast_dynamic( builder->get_object("appmenu")); m_menu = Glib::RefPtr<Gio::Menu>::cast_dynamic( builder->get_object("winmenu")); Glib::RefPtr<Gio::Menu> highlight_mode_menu = get_highlight_mode_menu(); const gchar* const* language_ids = gtk_source_language_manager_get_language_ids( language_manager); if(language_ids != NULL) { typedef std::list<GtkSourceLanguage*> LanguageList; typedef std::map<std::string, LanguageList> LanguageMap; LanguageMap languages; for(const gchar* const* id = language_ids; *id != NULL; ++id) { GtkSourceLanguage* language = gtk_source_language_manager_get_language( language_manager, *id); if(gtk_source_language_get_hidden(language)) continue; const std::string section = gtk_source_language_get_section(language); languages[section].push_back(language); } for(LanguageMap::iterator iter = languages.begin(); iter != languages.end(); ++iter) { Glib::RefPtr<Gio::Menu> submenu(Gio::Menu::create()); LanguageList& list = iter->second; list.sort(language_sort_func); for(LanguageList::const_iterator liter = list.begin(); liter != list.end(); ++liter) { GtkSourceLanguage* language = *liter; const std::string id = gtk_source_language_get_id(language); const std::string name = gtk_source_language_get_name(language); Glib::RefPtr<Gio::MenuItem> item( Gio::MenuItem::create( name, Glib::ustring::compose( "win.highlight-mode" "('%1')", id))); submenu->append_item(item); } highlight_mode_menu->append_submenu( iter->first, submenu); } } }