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 GtkSourceStyleScheme * get_default_style_scheme (GSettings *editor_settings) { GtkSourceStyleSchemeManager *manager; gchar *scheme_id; GtkSourceStyleScheme *def_style; manager = gtk_source_style_scheme_manager_get_default (); scheme_id = g_settings_get_string (editor_settings, GEDIT_SETTINGS_SCHEME); def_style = gtk_source_style_scheme_manager_get_scheme (manager, scheme_id); if (def_style == NULL) { g_warning ("Default style scheme '%s' cannot be found, falling back to 'classic' style scheme ", scheme_id); def_style = gtk_source_style_scheme_manager_get_scheme (manager, "classic"); if (def_style == NULL) { g_warning ("Style scheme 'classic' cannot be found, check your GtkSourceView installation."); } } g_free (scheme_id); return def_style; }
static gboolean gb_vim_command_colorscheme (GtkSourceView *source_view, const gchar *command, const gchar *options, GError **error) { GtkSourceStyleSchemeManager *manager; GtkSourceStyleScheme *style_scheme; GtkTextBuffer *buffer; g_autofree gchar *trimmed = NULL; trimmed = g_strstrip (g_strdup (options)); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); manager = gtk_source_style_scheme_manager_get_default (); style_scheme = gtk_source_style_scheme_manager_get_scheme (manager, trimmed); if (style_scheme == NULL) { g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Cannot find colorscheme '%s'"), options); return FALSE; } g_object_set (buffer, "style-scheme", style_scheme, NULL); return TRUE; }
static GtkTreeModel* create_style_model (GSettings* settings, GtkTreeIter** current) { GtkListStore* model = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); GtkSourceStyleSchemeManager* manager = gtk_source_style_scheme_manager_get_default(); const gchar* const *styles = gtk_source_style_scheme_manager_get_scheme_ids (manager); const gchar* const *style; gchar* current_style = g_settings_get_string (settings, SOURCEVIEW_STYLE); *current = NULL; for (style = styles; *style != NULL; style++) { GtkTreeIter iter; GtkSourceStyleScheme* scheme = gtk_source_style_scheme_manager_get_scheme (manager, *style); const gchar* id = gtk_source_style_scheme_get_id (scheme); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COLUMN_NAME, gtk_source_style_scheme_get_name (scheme), COLUMN_DESC, gtk_source_style_scheme_get_description (scheme), COLUMN_ID, id, -1); if (current_style && g_str_equal (id, current_style)) { *current = gtk_tree_iter_copy (&iter); } } g_free (current_style); return GTK_TREE_MODEL (model); }
static void append_global_paths() { // append style path PUSS/styles { GtkSourceStyleSchemeManager* ssm = gtk_source_style_scheme_manager_get_default(); gchar* style_path = g_build_filename(puss_app->module_path, "styles", NULL); gtk_source_style_scheme_manager_append_search_path(ssm, style_path); g_free(style_path); } }
static void set_style_scheme_search_path () { GtkSourceStyleSchemeManager *manager = gtk_source_style_scheme_manager_get_default (); gchar *path = gitg_dirs_get_data_filename ("styles", NULL); gtk_source_style_scheme_manager_prepend_search_path (manager, path); g_free (path); }
SourceView::SourceView (const std::string& language, bool readOnly) { // Set the search path to the language and style files gchar* directories[2]; std::string langFilesDir = GlobalRegistry().get(RKEY_APP_PATH) + "sourceviewer/"; directories[0] = const_cast<gchar*> (langFilesDir.c_str()); // stupid GtkSourceLanguageManager is expecting non-const gchar* pointer... directories[1] = NULL; GtkSourceStyleSchemeManager* styleSchemeManager = gtk_source_style_scheme_manager_get_default(); gtk_source_style_scheme_manager_set_search_path(styleSchemeManager, directories); gtk_source_style_scheme_manager_force_rescan(styleSchemeManager); _langManager = gtk_source_language_manager_new(); gtk_source_language_manager_set_search_path(_langManager, directories); GtkSourceLanguage* lang = gtk_source_language_manager_get_language(_langManager, language.c_str()); if (lang == NULL) { gtkutil::errorDialog(_("Cannot find language for source viewer")); g_error("SourceView: Cannot find language %s\n", language.c_str()); throw std::runtime_error("SourceView: Cannot find language"); } // Remember the pointers to the textbuffers _buffer = gtk_source_buffer_new_with_language(lang); gtk_source_buffer_set_highlight_syntax(_buffer, TRUE); _view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(_buffer)); gtk_widget_set_size_request(GTK_WIDGET(_view), 0, -1); // allow shrinking gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(_view), GTK_WRAP_NONE); gtk_text_view_set_editable(GTK_TEXT_VIEW(_view), readOnly ? FALSE : TRUE); gtk_source_view_set_show_line_numbers(_view, TRUE); gtk_source_view_set_auto_indent(_view, TRUE); // Use a fixed width font PangoFontDescription* fontDesc = pango_font_description_from_string("Monospace"); if (fontDesc != NULL) { gtk_widget_modify_font(GTK_WIDGET(_view), fontDesc); } // Use a tab size of 4 gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(_view), 4); g_signal_connect(G_OBJECT(_view), "key_press_event", G_CALLBACK(escape_clear_focus_widget), 0); _widget = gtkutil::ScrolledFrame(GTK_WIDGET(_view)); }
/** * gb_view_source_get_scheme: * @scheme_id: (in) (allow-none): The id of the scheme. * * Fetches a given scheme from the schemes manager. If @scheme_id is %NULL, * the default scheme will be retrieved. */ static GtkSourceStyleScheme * gb_view_source_get_scheme (const gchar *scheme_id) { GtkSourceStyleSchemeManager *manager; GtkSourceStyleScheme *scheme; if (!scheme_id) { scheme_id = gb_view_source_get_scheme_id(); } manager = gtk_source_style_scheme_manager_get_default(); scheme = gtk_source_style_scheme_manager_get_scheme(manager, scheme_id); return scheme; }
/* This function is taken from GEdit. * GEdit is licensed under the GPLv2. * * Copyright (C) 1998, 1999 Alex Roberts, Evan Lawrence * Copyright (C) 2000, 2001 Chema Celorio, Paolo Maggi * Copyright (C) 2002-2005 Paolo Maggi */ static GtkSourceStyleScheme * get_style_scheme(void) { GtkSourceStyleSchemeManager *manager; GtkSourceStyleScheme *def_style; manager = gtk_source_style_scheme_manager_get_default(); def_style = gtk_source_style_scheme_manager_get_scheme(manager, settings->scheme); if(def_style == NULL) { error_dialog("Error: style scheme cannot be found, falling back to 'classic' style scheme"); def_style = gtk_source_style_scheme_manager_get_scheme(manager, "classic"); if(def_style == NULL) error_dialog("Error: style scheme 'classic' cannot be found, check your GtkSourceView installation."); } return def_style; }
static IAnjutaEditor* ieditor_factory_new_editor(IAnjutaEditorFactory* factory, GFile* file, const gchar* filename, GError** error) { AnjutaPlugin* plugin = ANJUTA_PLUGIN(factory); SourceviewPlugin* splugin = ANJUTA_PLUGIN_SOURCEVIEW (plugin); gchar* current_style = g_settings_get_string (splugin->settings, SOURCEVIEW_STYLE); GtkSourceStyleSchemeManager* manager = gtk_source_style_scheme_manager_get_default(); Sourceview* sv; sv = sourceview_new(file, filename, plugin); if (current_style) gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (sv->priv->document), gtk_source_style_scheme_manager_get_scheme (manager, current_style)); g_free (current_style); return IANJUTA_EDITOR (sv); }
static void gb_editor_tab_set_style_scheme_name (GbEditorTab *tab, const gchar *style_scheme_name) { GtkSourceStyleSchemeManager *manager; GtkSourceStyleScheme *style_scheme; GbEditorTabPrivate *priv; g_return_if_fail(GB_IS_EDITOR_TAB(tab)); priv = tab->priv; if (!style_scheme_name) style_scheme_name = "tango"; manager = gtk_source_style_scheme_manager_get_default (); style_scheme = gtk_source_style_scheme_manager_get_scheme (manager, style_scheme_name); gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (priv->document), style_scheme); }
static void parse_puss_editor_style_option(const Option* option, const gchar* old, gpointer tag) { GtkSourceStyleSchemeManager* ssm; GtkSourceStyleScheme* style; GtkSourceBuffer* buf; gint num; gint i; if( !option->value || option->value[0]=='\0' ) return; ssm = gtk_source_style_scheme_manager_get_default(); style = gtk_source_style_scheme_manager_get_scheme(ssm, option->value); if( style ) { num = gtk_notebook_get_n_pages(puss_app->doc_panel); for( i=0; i<num; ++i ) { buf = GTK_SOURCE_BUFFER(puss_doc_get_buffer_from_page_num(i)); if( buf ) gtk_source_buffer_set_style_scheme(buf, style); } } }
/* 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_style_scheme_manager (void) { gchar *dir; dir = g_build_filename (TOP_SRCDIR, "data", "styles", NULL); if (g_file_test (dir, G_FILE_TEST_IS_DIR)) { GtkSourceStyleSchemeManager *manager; gchar **dirs; manager = gtk_source_style_scheme_manager_get_default (); dirs = g_new0 (gchar *, 2); dirs[0] = dir; gtk_source_style_scheme_manager_set_search_path (manager, dirs); g_strfreev (dirs); } else {
static void gb_vim_complete_colorscheme (const gchar *line, GPtrArray *ar) { GtkSourceStyleSchemeManager *manager; const gchar * const *scheme_ids; const gchar *tmp; g_autofree gchar *prefix = NULL; gsize i; manager = gtk_source_style_scheme_manager_get_default (); scheme_ids = gtk_source_style_scheme_manager_get_scheme_ids (manager); for (tmp = strchr (line, ' '); tmp && *tmp && g_unichar_isspace (g_utf8_get_char (tmp)); tmp = g_utf8_next_char (tmp)) { /* do nothing */ } if (!tmp) return; prefix = g_strndup (line, tmp - line); for (i = 0; scheme_ids [i]; i++) { const gchar *scheme_id = scheme_ids [i]; if (g_str_has_prefix (scheme_id, tmp)) { gchar *item; item = g_strdup_printf ("%s%s", prefix, scheme_id); IDE_TRACE_MSG ("colorscheme: %s", item); g_ptr_array_add (ar, item); } } }
static void on_style_changed (GtkComboBox* combo, SourceviewPlugin* plugin) { GtkTreeIter iter; gchar* id; GtkSourceStyleSchemeManager* manager = gtk_source_style_scheme_manager_get_default(); GtkSourceStyleScheme* scheme; IAnjutaDocumentManager* docman; AnjutaShell* shell = ANJUTA_PLUGIN (plugin)->shell; gtk_combo_box_get_active_iter (combo, &iter); gtk_tree_model_get (gtk_combo_box_get_model(combo), &iter, COLUMN_ID, &id, -1); scheme = gtk_source_style_scheme_manager_get_scheme (manager, id); g_settings_set_string (plugin->settings, SOURCEVIEW_STYLE, id); g_free (id); docman = anjuta_shell_get_interface (shell, IAnjutaDocumentManager, NULL); if (docman) { GList* editors = ianjuta_document_manager_get_doc_widgets (docman, NULL); GList* node; for (node = editors; node != NULL; node = g_list_next (node)) { IAnjutaDocument* editor = IANJUTA_DOCUMENT (node->data); if (ANJUTA_IS_SOURCEVIEW (editor)) { Sourceview* sv = ANJUTA_SOURCEVIEW (editor); gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (sv->priv->document), scheme); } } } }
static gboolean gb_vim_command_colorscheme (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { g_assert (GTK_IS_WIDGET (active_widget)); if (IDE_IS_EDITOR_VIEW (active_widget)) { GtkSourceStyleSchemeManager *manager; GtkSourceStyleScheme *style_scheme; GtkTextBuffer *buffer; g_autofree gchar *trimmed = NULL; GtkSourceView *source_view = GTK_SOURCE_VIEW (IDE_EDITOR_VIEW (active_widget)->frame1->source_view); trimmed = g_strstrip (g_strdup (options)); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); manager = gtk_source_style_scheme_manager_get_default (); style_scheme = gtk_source_style_scheme_manager_get_scheme (manager, trimmed); if (style_scheme == NULL) { g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Cannot find colorscheme '%s'"), options); return FALSE; } g_object_set (buffer, "style-scheme", style_scheme, NULL); return TRUE; } else return gb_vim_set_source_view_error (error); }
static void ide_preferences_builtin_register_appearance (IdePreferences *preferences) { GtkSourceStyleSchemeManager *manager; const gchar * const *scheme_ids; gint i; ide_preferences_add_page (preferences, "appearance", _("Appearance"), 0); ide_preferences_add_list_group (preferences, "appearance", "basic", _("Themes"), 0); ide_preferences_add_switch (preferences, "appearance", "basic", "org.gnome.builder", "night-mode", NULL, NULL, _("Dark Theme"), _("Whether Builder should use a dark theme"), _("dark theme"), 0); ide_preferences_add_switch (preferences, "appearance", "basic", "org.gnome.builder.editor", "show-grid-lines", NULL, NULL, _("Grid Pattern"), _("Display a grid pattern underneath source code"), NULL, 0); ide_preferences_add_list_group (preferences, "appearance", "schemes", NULL, 100); manager = gtk_source_style_scheme_manager_get_default (); scheme_ids = gtk_source_style_scheme_manager_get_scheme_ids (manager); for (i = 0; scheme_ids [i]; i++) { g_autofree gchar *variant_str = NULL; GtkSourceStyleScheme *scheme; const gchar *title; variant_str = g_strdup_printf ("\"%s\"", scheme_ids [i]); scheme = gtk_source_style_scheme_manager_get_scheme (manager, scheme_ids [i]); title = gtk_source_style_scheme_get_name (scheme); ide_preferences_add_radio (preferences, "appearance", "schemes", "org.gnome.builder.editor", "style-scheme-name", NULL, variant_str, title, NULL, title, i); } ide_preferences_add_list_group (preferences, "appearance", "font", _("Font"), 200); ide_preferences_add_font_button (preferences, "appearance", "font", "org.gnome.builder.editor", "font-name", _("Editor"), C_("Keywords", "editor font monospace"), 0); /* XXX: This belongs in terminal addin */ ide_preferences_add_font_button (preferences, "appearance", "font", "org.gnome.builder.terminal", "font-name", _("Terminal"), C_("Keywords", "terminal font monospace"), 0); }
GUIEditor * gui_editor_new (void) { GUIEditor *self; GPtrArray *dirs; const gchar * const *current_search_path; gchar **lang_spec_search_path; self = g_malloc0 (sizeof (GUIEditor)); self->buffer = gtk_source_buffer_new (NULL); self->widget = gtk_source_view_new_with_buffer (self->buffer); self->scroll = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (self->scroll), self->widget); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self->scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gui_editor_set_font (self, DEFAULT_EDITOR_FONT); self->hltag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER(self->buffer), HIGHLIGHT_TAG, "background", COLOUR_BG_HL, NULL); self->lang_manager = gtk_source_language_manager_new (); self->style_scheme_manager = gtk_source_style_scheme_manager_get_default (); dirs = g_ptr_array_new(); current_search_path = gtk_source_language_manager_get_search_path(self->lang_manager); for (; current_search_path != NULL && *current_search_path != NULL; ++current_search_path) g_ptr_array_add(dirs, g_strdup(*current_search_path)); // look for spec file in our own directory g_ptr_array_add(dirs, g_strdup(PACKAGE_DATA_DIR)); // look for spec file in data directory when running from svn g_ptr_array_add(dirs, g_strdup("data")); // look for spec file in current directory, when running on windows g_ptr_array_add(dirs, g_strdup(".")); g_ptr_array_add(dirs, g_strdup(NULL)); lang_spec_search_path = (gchar **)g_ptr_array_free(dirs, FALSE); gtk_source_language_manager_set_search_path (self->lang_manager, lang_spec_search_path); gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, "data"); gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, "."); #if GTK_CHECK_VERSION(3, 0, 0) GtkSourceMarkAttributes *mark_attributes = gtk_source_mark_attributes_new (); gtk_source_mark_attributes_set_icon_name (mark_attributes, "gtk-no"); gtk_source_view_set_mark_attributes (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, mark_attributes, 0); #else GdkPixbuf *pixbuf; pixbuf = gui_editor_get_stock_icon (GTK_WIDGET(self->widget), GTK_STOCK_NO, GTK_ICON_SIZE_MENU); if (pixbuf) { gtk_source_view_set_mark_category_icon_from_pixbuf (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, pixbuf); g_object_unref (pixbuf); } #endif return self; }
/** * gb_view_source_class_init: * @klass: (in): A #GbViewSourceClass. * * Initializes the #GbViewSourceClass and prepares the vtable. */ static void gb_view_source_class_init (GbViewSourceClass *klass) { GbViewClass *view_class; GObjectClass *object_class; GtkWidgetClass *widget_class; GtkSourceStyleSchemeManager *schemes; object_class = G_OBJECT_CLASS(klass); object_class->finalize = gb_view_source_finalize; object_class->get_property = gb_view_source_get_property; object_class->set_property = gb_view_source_set_property; g_type_class_add_private(object_class, sizeof(GbViewSourcePrivate)); widget_class = GTK_WIDGET_CLASS(klass); widget_class->grab_focus = gb_view_source_grab_focus; widget_class->style_set = gb_view_source_style_set; view_class = GB_VIEW_CLASS(klass); view_class->is_file = gb_view_source_is_file; view_class->save = gb_view_source_save; /** * GbViewSource:buffer: * * The "buffer" property is the #GtkSourceBuffer being visualized by * the editor. */ gParamSpecs[PROP_BUFFER] = g_param_spec_object("buffer", _("Buffer"), _("The text buffer."), GTK_SOURCE_TYPE_BUFFER, G_PARAM_READABLE); g_object_class_install_property(object_class, PROP_BUFFER, gParamSpecs[PROP_BUFFER]); /** * GbViewSource:file: * * The "file" property is a #GFile that represents the target path. */ gParamSpecs[PROP_FILE] = g_param_spec_object("file", _("File"), _("A GFile to display."), G_TYPE_FILE, G_PARAM_READWRITE); g_object_class_install_property(object_class, PROP_FILE, gParamSpecs[PROP_FILE]); /** * GbViewSource:path: * * The "path" property is the path to the destination file. */ gParamSpecs[PROP_PATH] = g_param_spec_string("path", _("Path"), _("The path of the file."), NULL, G_PARAM_READABLE); g_object_class_install_property(object_class, PROP_PATH, gParamSpecs[PROP_PATH]); /** * GbViewSource:source-view: * * The "source-view" property is the #GtkSourceView widget. */ gParamSpecs[PROP_SOURCE_VIEW] = g_param_spec_object("source-view", _("Source View"), _("The GtkSourceView widget."), GTK_SOURCE_TYPE_VIEW, G_PARAM_READABLE); g_object_class_install_property(object_class, PROP_SOURCE_VIEW, gParamSpecs[PROP_SOURCE_VIEW]); /** * GbViewSource::pre-save: * * The "pre-save" signal is emitted before saving a buffer. */ gSignals[PRE_SAVE] = g_signal_new("pre-save", GB_TYPE_VIEW_SOURCE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /* * Add search paths for our custom style schemes. */ schemes = gtk_source_style_scheme_manager_get_default(); gtk_source_style_scheme_manager_prepend_search_path( schemes, PACKAGE_DATA_DIR"/data/schemes"); gtk_source_style_scheme_manager_prepend_search_path(schemes, "data/schemes"); }
SourceView::SourceView(const std::string& language, bool readOnly) { // Set the search path to the language and style files gchar* directories[2]; #if defined(POSIX) && defined(PKGDATADIR) std::string langFilesDir = std::string(PKGDATADIR) + "/sourceviewer/"; #else std::string langFilesDir = GlobalRegistry().get(RKEY_APP_PATH) + "sourceviewer/"; #endif directories[0] = const_cast<gchar*>(langFilesDir.c_str()); // stupid GtkSourceLanguageManager is expecting non-const gchar* pointer... directories[1] = NULL; GtkSourceStyleSchemeManager* styleSchemeManager = gtk_source_style_scheme_manager_get_default(); gtk_source_style_scheme_manager_set_search_path(styleSchemeManager, directories); gtk_source_style_scheme_manager_force_rescan(styleSchemeManager); _langManager = gtk_source_language_manager_new(); gtk_source_language_manager_set_search_path(_langManager, directories); GtkSourceLanguage* lang = gtk_source_language_manager_get_language(_langManager, language.c_str()); if (lang == NULL) { globalErrorStream() << "SourceView: Cannot find language " << language << " in " << langFilesDir << std::endl; } // Remember the pointers to the textbuffers if (lang != NULL) { _buffer = gtk_source_buffer_new_with_language(lang); gtk_source_buffer_set_highlight_syntax(_buffer, TRUE); } else { _buffer = gtk_source_buffer_new(NULL); gtk_source_buffer_set_highlight_syntax(_buffer, FALSE); } _view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(_buffer)); gtk_widget_set_size_request(GTK_WIDGET(_view), 0, -1); // allow shrinking gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(_view), GTK_WRAP_WORD); gtk_text_view_set_editable(GTK_TEXT_VIEW(_view), readOnly ? FALSE : TRUE); gtk_source_view_set_show_line_numbers(_view, TRUE); gtk_source_view_set_auto_indent(_view, TRUE); // Use a fixed width font PangoFontDescription* fontDesc = pango_font_description_from_string("Monospace"); if (fontDesc != NULL) { gtk_widget_modify_font(GTK_WIDGET(_view), fontDesc); } // Use a tab size of 4 gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(_view), 4); widget_connect_escape_clear_focus_widget(GTK_WIDGET(_view)); _widget = gtkutil::ScrolledFrame(GTK_WIDGET(_view)); }
GtkWidget* puss_create_global_options_setup_widget(gpointer tag) { gchar* filepath; GtkBuilder* builder; GtkWidget* panel; GtkWidget* w; GError* err = 0; const Option* option; // create UI builder = gtk_builder_new(); if( !builder ) return 0; gtk_builder_set_translation_domain(builder, TEXT_DOMAIN); filepath = g_build_filename(puss_app->module_path, "res", "puss_setup_widget.ui", NULL); if( !filepath ) { g_printerr("ERROR(puss) : build setup dialog filepath failed!\n"); g_object_unref(G_OBJECT(builder)); return 0; } gtk_builder_add_from_file(builder, filepath, &err); g_free(filepath); if( err ) { g_printerr("ERROR(puss): %s\n", err->message); g_error_free(err); g_object_unref(G_OBJECT(builder)); return 0; } panel = GTK_WIDGET(g_object_ref(gtk_builder_get_object(builder, "main_panel"))); #ifdef G_OS_WIN32 { gchar* path; GDir* dir; const gchar* fname; gchar* rcfile; gint i; gint index = -1; option = puss_option_manager_option_find("puss", "theme"); w = GTK_WIDGET(gtk_builder_get_object(builder, "theme_combo")); path = gtk_rc_get_theme_dir(); dir = g_dir_open(path, 0, 0); if( dir ) { i = 0; for(;;) { fname = g_dir_read_name(dir); if( !fname ) break; rcfile = g_build_filename(path, fname, "gtk-2.0", "gtkrc", NULL); if( g_file_test(rcfile, G_FILE_TEST_EXISTS) ) { #if GTK_MAJOR_VERSION==2 gtk_combo_box_append_text(GTK_COMBO_BOX(w), fname); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(w), fname); #endif if( index < 0 && option->value ) { if( g_str_equal(fname, option->value) ) index = i; ++i; } } g_free(rcfile); } g_dir_close(dir); } g_free(path); if( index >= 0 ) gtk_combo_box_set_active(GTK_COMBO_BOX(w), index); g_signal_connect(w, "changed", G_CALLBACK(cb_combo_box_option_changed), (gpointer)option); } #endif { const gchar* const * ids; const gchar* const * p; gint i; gint index = -1; GtkSourceStyleSchemeManager* ssm = gtk_source_style_scheme_manager_get_default(); option = puss_option_manager_option_find("puss", "editor.style"); w = GTK_WIDGET(gtk_builder_get_object(builder, "style_combo")); if( ssm ) { gtk_source_style_scheme_manager_force_rescan(ssm); ids = gtk_source_style_scheme_manager_get_scheme_ids(ssm); i = 0; for( p=ids; *p; ++p ) { #if GTK_MAJOR_VERSION==2 gtk_combo_box_append_text(GTK_COMBO_BOX(w), *p); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(w), *p); #endif if( index < 0 && option->value ) { if( g_str_equal(*p, option->value) ) index = i; ++i; } } if( index >= 0 ) gtk_combo_box_set_active(GTK_COMBO_BOX(w), index); } g_signal_connect(w, "changed", G_CALLBACK(cb_combo_box_option_changed), (gpointer)option); } { option = puss_option_manager_option_find("puss", "editor.font"); w = GTK_WIDGET(gtk_builder_get_object(builder, "font_button")); if( option->value && option->value[0] ) gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), option->value); g_signal_connect(w, "font-set", G_CALLBACK(cb_font_button_changed), (gpointer)option); } { GtkEntry* entry; option = puss_option_manager_option_find("puss", "fileloader.charset_list"); entry = GTK_ENTRY(gtk_builder_get_object(builder, "charset_entry")); w = GTK_WIDGET(gtk_builder_get_object(builder, "charset_apply_button")); gtk_entry_set_text(entry, option->value); g_signal_connect(w, "clicked", G_CALLBACK(cb_apply_button_changed), (gpointer)entry); } g_object_unref(G_OBJECT(builder)); return panel; }
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); }
Gobby::PreferencesDialog::Appearance::Appearance( const Glib::RefPtr<Gtk::Builder>& builder, Preferences& preferences) : m_scheme_list(Gtk::ListStore::create(m_scheme_columns)) { builder->get_widget_derived("toolbar-style", m_cmb_toolbar_style); builder->get_widget("font", m_btn_font); builder->get_widget("color-scheme-treeview", m_scheme_tree); const Pango::FontDescription& font = preferences.appearance.font; m_cmb_toolbar_style->set_option(preferences.appearance.toolbar_style); m_cmb_toolbar_style->add(_("Show text only"), Gtk::TOOLBAR_TEXT); m_cmb_toolbar_style->add(_("Show icons only"), Gtk::TOOLBAR_ICONS); m_cmb_toolbar_style->add(_("Show both icons and text"), Gtk::TOOLBAR_BOTH ); m_cmb_toolbar_style->add(_("Show text besides icons"), Gtk::TOOLBAR_BOTH_HORIZ ); m_btn_font->set_font_name(font.to_string()); m_conn_font.reset(new FontConnection( *m_btn_font, preferences.appearance.font)); Gtk::TreeViewColumn column_name; Gtk::CellRendererText renderer_name; column_name.pack_start(renderer_name, false); column_name.add_attribute(renderer_name.property_text(), m_scheme_columns.name); Pango::AttrList list; Pango::Attribute attr(Pango::Attribute::create_attr_weight( Pango::WEIGHT_BOLD)); list.insert(attr); renderer_name.property_attributes() = list; m_scheme_tree->append_column(column_name); m_scheme_tree->append_column(_("Scheme Description"), m_scheme_columns.description); m_scheme_tree->set_model(m_scheme_list); // Populate scheme list GtkSourceStyleSchemeManager* manager = gtk_source_style_scheme_manager_get_default(); const gchar* const* ids = gtk_source_style_scheme_manager_get_scheme_ids(manager); const Glib::ustring current_scheme = preferences.appearance.scheme_id; for (const gchar* const* id = ids; *id != NULL; ++id) { GtkSourceStyleScheme* scheme = gtk_source_style_scheme_manager_get_scheme( manager, *id); const gchar* name = gtk_source_style_scheme_get_name(scheme); const gchar* desc = gtk_source_style_scheme_get_description(scheme); Gtk::TreeIter iter = m_scheme_list->append(); (*iter)[m_scheme_columns.name] = name; (*iter)[m_scheme_columns.description] = desc; (*iter)[m_scheme_columns.scheme] = scheme; if (current_scheme == gtk_source_style_scheme_get_id(scheme)) m_scheme_tree->get_selection()->select(iter); } m_scheme_tree->get_selection()->signal_changed().connect( sigc::bind( sigc::mem_fun(*this, &Appearance::on_scheme_changed), sigc::ref(preferences))); m_scheme_list->set_sort_column(m_scheme_columns.name, Gtk::SORT_ASCENDING); }
Gobby::PreferencesDialog::Appearance::Appearance(Preferences& preferences): m_group_toolbar(_("Toolbar") ), m_group_font(_("Font") ), m_group_scheme(_("Color Scheme")), m_cmb_toolbar_style(preferences.appearance.toolbar_style), m_conn_font(m_btn_font, preferences.appearance.font), m_list(Gtk::ListStore::create(m_columns)), m_tree(m_list) { const Pango::FontDescription& font = preferences.appearance.font; m_cmb_toolbar_style.add(_("Show text only"), Gtk::TOOLBAR_TEXT); m_cmb_toolbar_style.add(_("Show icons only"), Gtk::TOOLBAR_ICONS); m_cmb_toolbar_style.add(_("Show both icons and text"), Gtk::TOOLBAR_BOTH ); m_cmb_toolbar_style.add(_("Show text besides icons"), Gtk::TOOLBAR_BOTH_HORIZ ); m_cmb_toolbar_style.show(); m_conn_font.block(); m_btn_font.set_font_name(font.to_string()); m_btn_font.show(); m_conn_font.unblock(); m_group_toolbar.add(m_cmb_toolbar_style); m_group_toolbar.show(); m_group_font.add(m_btn_font); m_group_font.show(); Gtk::TreeViewColumn column_name; Gtk::CellRendererText renderer_name; column_name.pack_start(renderer_name, false); column_name.add_attribute(renderer_name.property_text(), m_columns.name); m_tree.append_column(column_name);//"Scheme Name", m_columns.name); m_tree.append_column("Scheme description", m_columns.description); Pango::AttrList list; Pango::Attribute attr(Pango::Attribute::create_attr_weight(Pango::WEIGHT_BOLD)); list.insert(attr); renderer_name.property_attributes() = list; m_tree.set_headers_visible(false); m_tree.show(); Gtk::ScrolledWindow* scroll = Gtk::manage(new Gtk::ScrolledWindow); scroll->set_shadow_type(Gtk::SHADOW_IN); scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); scroll->add(m_tree); scroll->show(); m_group_scheme.add(*scroll); m_group_scheme.show(); GtkSourceStyleSchemeManager* manager = gtk_source_style_scheme_manager_get_default(); const gchar* const* ids = gtk_source_style_scheme_manager_get_scheme_ids(manager); Glib::ustring current_scheme = preferences.appearance.scheme_id; for (const gchar* const* id = ids; *id != NULL; ++id) { GtkSourceStyleScheme* scheme = gtk_source_style_scheme_manager_get_scheme(manager, *id); const gchar* name = gtk_source_style_scheme_get_name(scheme); const gchar* desc = gtk_source_style_scheme_get_description(scheme); Gtk::TreeIter iter = m_list->append(); (*iter)[m_columns.name] = name; (*iter)[m_columns.description] = desc; (*iter)[m_columns.scheme] = scheme; if (current_scheme == gtk_source_style_scheme_get_id(scheme)) m_tree.get_selection()->select(iter); } m_tree.get_selection()->signal_changed().connect( sigc::bind( sigc::mem_fun(*this, &Appearance::on_scheme_changed), sigc::ref(preferences))); #ifdef USE_GTKMM3 m_list->set_sort_column(m_columns.name, Gtk::SORT_ASCENDING); #else m_list->set_sort_column_id(m_columns.name, Gtk::SORT_ASCENDING); #endif add(m_group_toolbar, false); add(m_group_font, false); add(m_group_scheme, true); }