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 gboolean
gb_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 void
set_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 void insert_text_in_document(SourceviewIO* sio, const gchar* text, gsize len)
{
GtkSourceBuffer* document = GTK_SOURCE_BUFFER (sio->sv->priv->document);
gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (sio->sv->priv->document));
/* Insert text in the buffer */
gtk_text_buffer_set_text (GTK_TEXT_BUFFER (document),
text,
len);
gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (document),
FALSE);
gtk_source_buffer_end_not_undoable_action (document);
}
static void
peacock_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 void
peacock_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 void
ide_editor_view__extension_added (PeasExtensionSet *set,
PeasPluginInfo *info,
PeasExtension *exten,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeEditorViewAddin *addin = (IdeEditorViewAddin *)exten;
g_assert (PEAS_IS_EXTENSION_SET (set));
g_assert (info != NULL);
g_assert (IDE_IS_EDITOR_VIEW_ADDIN (addin));
g_assert (IDE_IS_EDITOR_VIEW (self));
ide_editor_view_addin_load (addin, self);
if (self->document != NULL)
{
GtkSourceLanguage *language;
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (language != NULL)
{
const gchar *language_id;
language_id = gtk_source_language_get_id (language);
ide_editor_view_addin_language_changed (addin, language_id);
}
}
}
static void
on_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 gboolean
gutter_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 void
gb_editor_tab_apply_settings (GbEditorTab *tab)
{
GbEditorTabPrivate *priv;
GtkSourceLanguage *lang;
const gchar *name;
gchar *path;
g_return_if_fail (GB_IS_EDITOR_TAB (tab));
priv = tab->priv;
g_clear_object (&priv->settings);
lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (priv->document));
if (lang) {
name = gtk_source_language_get_id (lang);
} else {
name = "plaintext";
}
path = g_strdup_printf ("/org/gnome/builder/preferences/editor/language/%s/", name);
priv->settings = g_settings_new_with_path ("org.gnome.builder.preferences.editor.language", path);
g_free (path);
g_settings_bind (priv->settings, "highlight-matching-brackets", priv->document, "highlight-matching-brackets", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "highlight-current-line", priv->text_view, "highlight-current-line", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "insert-spaces-instead-of-tabs", priv->text_view, "insert-spaces-instead-of-tabs", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "right-margin-position", priv->text_view, "right-margin-position", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-line-marks", priv->text_view, "show-line-marks", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-line-numbers", priv->text_view, "show-line-numbers", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-right-margin", priv->text_view, "show-right-margin", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "tab-width", priv->text_view, "tab-width", G_SETTINGS_BIND_GET);
}
static void
pluma_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 void
pluma_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 void
on_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 void
gutter_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 void
disable_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 gboolean
looks_like_makefile (IdeBuffer *buffer)
{
GtkSourceLanguage *language;
const gchar *path;
IdeFile *file;
g_assert (IDE_IS_BUFFER (buffer));
file = ide_buffer_get_file (buffer);
path = ide_file_get_path (file);
if (path != NULL)
{
if (g_str_has_suffix (path, "Makefile.am") || g_str_has_suffix (path, ".mk"))
return TRUE;
}
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer));
if (language != NULL)
{
const gchar *lang_id;
lang_id = gtk_source_language_get_id (language);
if (ide_str_equal0 (lang_id, "automake") || ide_str_equal0 (lang_id, "makefile"))
return TRUE;
}
return FALSE;
}
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))
)
);
}
void
peacock_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 void
peacock_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 void
cedit_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 void
set_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 void
editor_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 void
gb_editor_view_actions_preview (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
GbEditorView *self = user_data;
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
g_autoptr(GbDocument) document = NULL;
g_assert (GB_IS_EDITOR_VIEW (self));
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (!language)
return;
lang_id = gtk_source_language_get_id (language);
if (!lang_id)
return;
#if 0
if (g_str_equal (lang_id, "html"))
{
document = g_object_new (GB_TYPE_HTML_DOCUMENT,
"buffer", self->document,
NULL);
}
else if (g_str_equal (lang_id, "markdown"))
{
document = g_object_new (GB_TYPE_HTML_DOCUMENT,
"buffer", self->document,
NULL);
gb_html_document_set_transform_func (GB_HTML_DOCUMENT (document),
gb_html_markdown_transform);
}
#endif
if (document)
{
GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (self));
while (parent && !GB_IS_VIEW_GRID (parent))
parent = gtk_widget_get_parent (parent);
if (parent == NULL)
{
while (parent && !GB_IS_VIEW_STACK (parent))
parent = gtk_widget_get_parent (parent);
g_assert (GB_IS_VIEW_STACK (parent));
gb_view_stack_focus_document (GB_VIEW_STACK (parent), document);
return;
}
g_assert (GB_IS_VIEW_GRID (parent));
gb_view_grid_focus_document (GB_VIEW_GRID (parent), document);
}
}
static void
gedit_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 void
on_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));
}
