Beispiel #1
0
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;
}
Beispiel #2
0
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;
}
Beispiel #3
0
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;
}
Beispiel #4
0
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);
}
Beispiel #5
0
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);
	}
}
Beispiel #6
0
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);
}
Beispiel #7
0
	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;
}
Beispiel #9
0
/* 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;
}
Beispiel #10
0
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);
}
Beispiel #11
0
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);
}
Beispiel #12
0
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);
		}
	}
}
Beispiel #13
0
/* 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
	{
Beispiel #14
0
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);
        }
    }
}
Beispiel #15
0
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);
			}
		}
	}
}
Beispiel #16
0
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);
}
Beispiel #18
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");
}
Beispiel #20
0
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));
}
Beispiel #21
0
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;
}
Beispiel #22
0
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);
}
Beispiel #23
0
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);
}
Beispiel #24
0
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);
}