自学教程：C++ GTK_SOURCE_BUFFER函数代码示例

static void pls_lang_active(GtkAction* action, GtkSourceLanguage* lang) {	gint page_num;	GtkTextBuffer* buf;	page_num = gtk_notebook_get_current_page(puss_get_doc_panel(g_self->app));	if( page_num < 0 )		return;	buf = g_self->app->doc_get_buffer_from_page_num(page_num);#if GTK_MAJOR_VERSION==2	if( !buf || !GTK_IS_SOURCE_BUFFER(buf) )		return;#else	if( !buf || !GTK_SOURCE_IS_BUFFER(buf) )		return;#endif	if( lang ) {		gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(buf), lang);		add_fill_favory_language(lang);	} else {		gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(buf), g_self->last_favory_lang);	}}

static gbooleangb_vim_command_syntax (GtkWidget      *active_widget,                       const gchar    *command,                       const gchar    *options,                       GError        **error){  g_assert (GTK_IS_WIDGET (active_widget));  if (IDE_IS_EDITOR_PAGE (active_widget))    {      IdeBuffer *buffer = ide_editor_page_get_buffer (IDE_EDITOR_PAGE (active_widget));      if (g_str_equal (options, "enable") || g_str_equal (options, "on"))        gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (buffer), TRUE);      else if (g_str_equal (options, "off"))        gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (buffer), FALSE);      else        {          g_set_error (error,                       GB_VIM_ERROR,                       GB_VIM_ERROR_UNKNOWN_OPTION,                       _("Invalid :syntax subcommand: %s"),                       options);          return FALSE;        }      return TRUE;    }  else    return gb_vim_set_source_view_error (error);}

static voidset_language (GeditDocument     *doc,              GtkSourceLanguage *lang,              gboolean           set_by_user){	GeditDocumentPrivate *priv;	GtkSourceLanguage *old_lang;	gedit_debug (DEBUG_DOCUMENT);	priv = gedit_document_get_instance_private (doc);	old_lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc));	if (old_lang == lang)	{		return;	}	gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (doc), lang);	if (set_by_user)	{		const gchar *language = get_language_string (doc);		gedit_document_set_metadata (doc,					     GEDIT_METADATA_ATTRIBUTE_LANGUAGE, language,					     NULL);	}	priv->language_set_by_user = set_by_user;}

void set_buffer(){	    gtk_source_buffer_begin_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));		gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mBuff),content,-1);	    g_free(content);        gtk_source_buffer_end_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));        gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mBuff),FALSE);        GtkTextIter iter;        gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mBuff),&iter);        gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(mBuff),&iter);}

void new_file(){	//unsigned int u_id	//GtkSourceBuffer  *tBuff=(GtkSourceBuffer *)tpad_buff_get_buff(u_id);    if(save_modified()) {        gtk_source_buffer_begin_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));        gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mBuff),"",-1);        gtk_source_buffer_end_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));        gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mBuff),FALSE);        gtk_window_set_title(GTK_WINDOW(window),_FALLBACK_SAVE_FILE_NAME);	save_locked=FALSE;    }}

static voidpeacock_file_load_async_close_cb (GnomeVFSAsyncHandle *handle,				  GnomeVFSResult result,				  gpointer user_data){	gboolean success = TRUE;	PeacockFile *file = PEACOCK_FILE (user_data);#ifdef PEACOCK_FILE_DEBUG	g_warning ("peacock_file_load_async_close_cb (): Closed GnomeVFS handle - %s/n", gnome_vfs_result_to_string (result));#endif	/*	 * File read ok. Emit the PeacockFile::loaded signal.	 * The handler should load it up in the MDI (besides other things it	 * might want to do). Else destroy the PeacockFile object.	 */	if (result == GNOME_VFS_OK) {		gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (file), FALSE);		gtk_source_buffer_end_not_undoable_action (GTK_SOURCE_BUFFER (file));	} else {		g_object_unref (file);		success = FALSE;	}	g_signal_emit (G_OBJECT (file), peacock_file_signals[LOADED],		       0, success);}

static voidpeacock_file_load_async_open_cb (GnomeVFSAsyncHandle *handle,				 GnomeVFSResult result,				 gpointer data){	PeacockFile *file = PEACOCK_FILE (data);#ifdef PEACOCK_FILE_DEBUG	g_warning ("peacock_file_load_async_open_cb(): Error opening file to read: %s./n", gnome_vfs_result_to_string (result));#endif	if (result != GNOME_VFS_OK) {		/*		 * Display UI error dialog.		 */		gchar *err_msg = g_strdup_printf (_("Error opening file to load./nReason - %s./n"), gnome_vfs_result_to_string (result));		peacock_file_util_show_ui_error (err_msg);		g_free (err_msg);		/*		 * Cleanup. Destructor peacock_file_finalize handles		 * PeacockFile related memory.		 */		g_object_unref (file);		return;	} else {	        gchar *buffer = g_malloc (PEACOCK_FILE_READ_WRITE_BUF_SIZE);		gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (file));		gnome_vfs_async_read (handle, buffer,				      PEACOCK_FILE_READ_WRITE_BUF_SIZE,				      peacock_file_load_async_read_cb, data);	}}

static voidide_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 voidon_delete_range (GtkTextBuffer *buffer,	     	 GtkTextIter   *start,	     	 GtkTextIter   *end,	     	 gpointer       user_data){	GtkTextIter iter;	GSList *marks;	GSList *item;	iter = *start;	/* move to start of line */	gtk_text_iter_set_line_offset (&iter, 0);	/* remove any bookmarks that are collapsed on each other due to this */	marks = gtk_source_buffer_get_source_marks_at_iter (GTK_SOURCE_BUFFER (buffer),							    &iter,							    BOOKMARK_CATEGORY);	if (marks == NULL)		return;	/* remove all but the first mark */	for (item = marks->next; item; item = item->next)		gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (item->data));	g_slist_free (marks);}

static gbooleangutter_renderer_query_tooltip (GtkSourceGutterRenderer *renderer,                               GtkTextIter             *iter,                               GdkRectangle            *area,                               gint                     x,                               gint                     y,                               GtkTooltip              *tooltip){	GSList *marks;	GtkSourceView *view;	GtkSourceBuffer *buffer;	view = GTK_SOURCE_VIEW (gtk_source_gutter_renderer_get_view (renderer));	buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));	marks = gtk_source_buffer_get_source_marks_at_iter (buffer,	                                                    iter,	                                                    NULL);	if (marks != NULL)	{		marks = g_slist_sort_with_data (marks,		                                sort_marks_by_priority,		                                view);		marks = g_slist_reverse (marks);		return set_tooltip_widget_from_marks (view, tooltip, marks);	}	return FALSE;}

static voidgb_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 voidpluma_prefs_manager_undo_changed (GSettings *settings,                                  gchar       *key,                                  gpointer     user_data){    pluma_debug (DEBUG_PREFS);    if (strcmp (key, GPM_UNDO_ACTIONS_LIMIT) == 0)    {        gint ul;        GList *docs;        GList *l;        ul = g_settings_get_int (settings, key);        ul = CLAMP (ul, -1, 250);        docs = pluma_app_get_documents (pluma_app_get_default ());        l = docs;        while (l != NULL)        {            gtk_source_buffer_set_max_undo_levels (GTK_SOURCE_BUFFER (l->data),                                                   ul);            l = l->next;        }        g_list_free (docs);    }}

static voidpluma_prefs_manager_bracket_matching_changed (GSettings *settings,        gchar       *key,        gpointer     user_data){    pluma_debug (DEBUG_PREFS);    if (strcmp (key, GPM_BRACKET_MATCHING) == 0)    {        gboolean enable;        GList *docs;        GList *l;        enable = g_settings_get_boolean (settings, key);        docs = pluma_app_get_documents (pluma_app_get_default ());        l = docs;        while (l != NULL)        {            gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (l->data),                    enable);            l = l->next;        }        g_list_free (docs);    }}

static voidon_toggle_bookmark_activate (GtkAction   *action,			     PlumaWindow *window){	GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (pluma_window_get_active_document (window));	toggle_bookmark (buffer, NULL);}

/** * gedit_document_get_language: * @doc: * * Return value: (transfer none): */GtkSourceLanguage *gedit_document_get_language (GeditDocument *doc){	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);	return gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc));}

static voidgutter_renderer_query_data (GtkSourceGutterRenderer      *renderer,			    GtkTextIter                  *start,			    GtkTextIter                  *end,			    GtkSourceGutterRendererState  state){	GSList *marks;	GdkPixbuf *pixbuf = NULL;	gint size = 0;	GtkSourceView *view;	GtkSourceBuffer *buffer;	view = GTK_SOURCE_VIEW (gtk_source_gutter_renderer_get_view (renderer));	buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));	marks = gtk_source_buffer_get_source_marks_at_iter (buffer,	                                                    start,	                                                    NULL);	if (marks != NULL)	{		size = measure_line_height (view);		pixbuf = composite_marks (view, marks, size);		g_slist_free (marks);	}	g_object_set (G_OBJECT (renderer),	              "pixbuf", pixbuf,	              "xpad", 2,	              "yalign", 0.5,	              "xalign", 0.5,	              "alignment-mode", GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST,	              NULL);}

static voiddisable_bookmarks (PlumaView *view){	GtkTextIter start;	GtkTextIter end;	GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));	gpointer data;	gtk_source_view_set_show_line_marks (GTK_SOURCE_VIEW (view), FALSE);	gtk_text_buffer_get_bounds (buffer, &start, &end);	gtk_source_buffer_remove_source_marks (GTK_SOURCE_BUFFER (buffer),					       &start,					       &end,					       BOOKMARK_CATEGORY);	g_signal_handlers_disconnect_by_func (buffer, on_style_scheme_notify, view);	g_signal_handlers_disconnect_by_func (buffer, on_delete_range, NULL);	data = g_object_get_data (G_OBJECT (buffer), INSERT_DATA_KEY);	g_signal_handlers_disconnect_by_func (buffer, on_insert_text_before, data);	g_signal_handlers_disconnect_by_func (buffer, on_begin_user_action, data);	g_signal_handlers_disconnect_by_func (buffer, on_end_user_action, data);	g_object_set_data (G_OBJECT (buffer), INSERT_DATA_KEY, NULL);}

static gbooleanlooks_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;}

void mape_edit_view_apply_preferences(MapeEditView* edit_view,                                      MapePreferences* preferences){	GtkSourceView* view;	GtkSourceBuffer* buffer;	GtkWrapMode wrap_mode;		view = GTK_SOURCE_VIEW(edit_view->view);	buffer = GTK_SOURCE_BUFFER(		gtk_text_view_get_buffer(GTK_TEXT_VIEW(view))	);	gtk_source_view_set_tab_width(		view,		preferences->tab_width	);	gtk_source_view_set_insert_spaces_instead_of_tabs(		view,		preferences->tab_to_spaces	);	gtk_source_view_set_auto_indent(		view,		preferences->auto_indentation	);	wrap_mode = GTK_WRAP_CHAR;	if(preferences->text_wrapping == FALSE)		wrap_mode = GTK_WRAP_NONE;	gtk_text_view_set_wrap_mode(		GTK_TEXT_VIEW(view),		wrap_mode	);		gtk_source_view_set_show_line_numbers(		view,		preferences->line_numbers	);	gtk_source_view_set_highlight_current_line(		view,		preferences->highlight_line	);		gtk_source_buffer_set_highlight_matching_brackets(		buffer,		preferences->bracket_matching	);	edit_view->fixed_seed = preferences->fixed_seed;	edit_view->random_seed = preferences->random_seed;	edit_view->map_width = preferences->map_width;	edit_view->map_height = preferences->map_height;	edit_view->map_zoom = preferences->map_zoom;	/* Rerender with new random settings */	mape_edit_view_reload(edit_view);}

void mape_edit_view_redo(MapeEditView* edit_view){	gtk_source_buffer_redo(		GTK_SOURCE_BUFFER(			gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit_view->view))		)	);}

voidpeacock_file_redo (PeacockFile *file){	g_return_if_fail (file != NULL);	g_return_if_fail (PEACOCK_IS_FILE (file));	gtk_source_buffer_redo (GTK_SOURCE_BUFFER (file));}

/** * peacock_file_construct: * @file:  *  * Sort of a post constructor, constructor. **/static voidpeacock_file_construct (PeacockFile *file){	GtkSourceLanguagesManager *lang_manager;	GtkSourceLanguage *lang;	/*	 * Get the highlighting style for HTML and apply it to	 * the GtkSourceBuffer.	 */	lang_manager = gtk_source_languages_manager_new ();	lang = gtk_source_languages_manager_get_language_from_mime_type (		lang_manager, "text/html");	gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (file), lang);	gtk_source_buffer_set_highlight (GTK_SOURCE_BUFFER (file), TRUE);}

static voidcedit_prefs_manager_source_style_scheme_changed (GSettings *settings,						 gchar       *key,						 gpointer     user_data){	cedit_debug (DEBUG_PREFS);	if (strcmp (key, GPM_SOURCE_STYLE_SCHEME) == 0)	{		static gchar *old_scheme = NULL;		gchar *scheme;		GtkSourceStyleScheme *style;		GList *docs;		GList *l;		scheme = g_settings_get_string (settings, key);		if (old_scheme != NULL && (strcmp (scheme, old_scheme) == 0))		    	return;		g_free (old_scheme);		old_scheme = scheme;		style = gtk_source_style_scheme_manager_get_scheme (				cedit_get_style_scheme_manager (),				scheme);		if (style == NULL)		{			g_warning ("Default style scheme '%s' not found, falling back to 'classic'", scheme);			style = gtk_source_style_scheme_manager_get_scheme (				cedit_get_style_scheme_manager (),				"classic");			if (style == NULL)			{				g_warning ("Style scheme 'classic' cannot be found, check your GtkSourceView installation.");				return;			}		}		docs = cedit_app_get_documents (cedit_app_get_default ());		for (l = docs; l != NULL; l = l->next)		{#if GTK_CHECK_VERSION (3, 0, 0)			g_return_if_fail (GTK_SOURCE_IS_BUFFER (l->data));#else			g_return_if_fail (GTK_IS_SOURCE_BUFFER (l->data));#endif			gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (l->data),							    style);		}		g_list_free (docs);	}}

static voidset_language (GeditDocument     *doc,              GtkSourceLanguage *lang,              gboolean           set_by_user){	GtkSourceLanguage *old_lang;	gedit_debug (DEBUG_DOCUMENT);	old_lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc));	if (old_lang == lang)	{		return;	}	gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (doc), lang);	if (lang != NULL)	{		gboolean syntax_hl;		syntax_hl = g_settings_get_boolean (doc->priv->editor_settings,						    GEDIT_SETTINGS_SYNTAX_HIGHLIGHTING);		gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc),							syntax_hl);	}	else	{		gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc),							FALSE);	}	if (set_by_user)	{		const gchar *language = get_language_string (doc);		gedit_document_set_metadata (doc,					     GEDIT_METADATA_ATTRIBUTE_LANGUAGE, language,					     NULL);	}	doc->priv->language_set_by_user = set_by_user;}

void set_language(){	if(cfg_lang()){			GtkSourceLanguageManager *lm;			lm=gtk_source_language_manager_new();			char* currentfile=(char*)tpad_fp_get_current();			if(currentfile!=NULL){				long unsigned int i= 0,pos= 0;				size_t mlewn = sizeof(currentfile)/sizeof(currentfile[1]);				size_t blew = strlen(currentfile) + 1;				if(blew > mlewn) mlewn = blew;				 char fil[mlewn];    			for(i=0; currentfile[i]; i++){        			if(currentfile[i]=='//') fil[pos++]='//';        			fil[pos++]=currentfile[i];    				}    			fil[pos]=0;				gboolean result_uncertain;				gchar *content_type;				content_type = g_content_type_guess (fil, NULL, 0, &result_uncertain);				if (result_uncertain){					g_free (content_type);					content_type = NULL;					}				GtkSourceLanguage *lang = NULL;				lang = gtk_source_language_manager_guess_language (lm, fil, content_type);				gtk_source_buffer_set_language (GTK_SOURCE_BUFFER(mBuff),GTK_SOURCE_LANGUAGE(lang));				gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER(mBuff), (gboolean) cfg_lang());				if(cfg_lang()) (lang) ? gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),TRUE) : gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),FALSE);					if(content_type) g_free (content_type);		}	}	else {		gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(mBuff),NULL);		gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),FALSE); 	     }	if(cfg_undo() >= 1 && cfg_undo() <= UNDO_MAX) gtk_source_buffer_set_max_undo_levels ((GtkSourceBuffer *)mBuff,(gint)cfg_undo());	else {		gtk_source_buffer_set_max_undo_levels ((GtkSourceBuffer *)mBuff,(gint)-1);		cfg_set_undo(0);	}		(cfg_line_wrap()) ? gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view),GTK_WRAP_WORD) : gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view),GTK_WRAP_NONE);}

static voideditor_application_window_init (EditorApplicationWindow *window){  GtkTextView *view;  gtk_widget_init_template (GTK_WIDGET (window));  view = GTK_TEXT_VIEW (window->view);  window->buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (view));}

static voidgb_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 voidgedit_document_init (GeditDocument *doc){	GeditDocumentPrivate *priv;	GtkSourceStyleScheme *style_scheme;	gedit_debug (DEBUG_DOCUMENT);	doc->priv = gedit_document_get_instance_private (doc);	priv = doc->priv;	priv->editor_settings = g_settings_new ("org.gnome.gedit.preferences.editor");	priv->untitled_number = get_untitled_number ();	priv->content_type = get_default_content_type ();	priv->readonly = FALSE;	priv->language_set_by_user = FALSE;	priv->empty_search = TRUE;	g_get_current_time (&doc->priv->time_of_last_save_or_load);	priv->file = gtk_source_file_new ();	g_signal_connect_object (priv->file,				 "notify::location",				 G_CALLBACK (on_location_changed),				 doc,				 0);	g_settings_bind (priv->editor_settings,	                 GEDIT_SETTINGS_MAX_UNDO_ACTIONS,	                 doc,	                 "max-undo-levels",	                 G_SETTINGS_BIND_GET);	g_settings_bind (priv->editor_settings,	                 GEDIT_SETTINGS_BRACKET_MATCHING,	                 doc,	                 "highlight-matching-brackets",	                 G_SETTINGS_BIND_GET);	style_scheme = get_default_style_scheme (priv->editor_settings);	if (style_scheme != NULL)	{		gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (doc), style_scheme);	}	g_signal_connect (doc,			  "notify::content-type",			  G_CALLBACK (on_content_type_changed),			  NULL);}

static voidon_style_scheme_notify (GObject     *object,			GParamSpec  *pspec,			PlumaView   *view){	GtkSourceMarkAttributes *attrs;	attrs = gtk_source_view_get_mark_attributes (GTK_SOURCE_VIEW (view),						     BOOKMARK_CATEGORY,						     NULL);	update_background_color (attrs, GTK_SOURCE_BUFFER(object));}