static void
gb_view_source_tab_size_activate (GtkMenuItem *menu_item,
GbViewSource *source)
{
GbViewSourcePrivate *priv;
const gchar *label;
gint size;
ENTRY;
g_return_if_fail(GTK_IS_MENU_ITEM(menu_item));
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
priv = source->priv;
label = gtk_menu_item_get_label(menu_item);
size = g_ascii_strtoll(label, NULL, 10);
if (size > 0) {
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(priv->source1), size);
if (priv->source2) {
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(priv->source2), size);
}
g_object_set(priv->size_combo,
"label", label,
NULL);
}
EXIT;
}
static void
enable_bookmarks (GeditView *view,
GeditPlugin *plugin)
{
GdkPixbuf *pixbuf;
pixbuf = get_bookmark_pixbuf (plugin);
/* Make sure the category pixbuf is set */
if (pixbuf)
{
InsertData *data;
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
update_background_color (view);
gtk_source_view_set_mark_category_icon_from_pixbuf (GTK_SOURCE_VIEW (view),
BOOKMARK_CATEGORY,
pixbuf);
g_object_unref (pixbuf);
gtk_source_view_set_show_line_marks (GTK_SOURCE_VIEW (view), TRUE);
g_signal_connect (buffer,
"notify::style-scheme",
G_CALLBACK (on_style_scheme_notify),
view);
g_signal_connect_after (buffer,
"delete-range",
G_CALLBACK (on_delete_range),
NULL);
data = g_slice_new0 (InsertData);
g_object_set_data_full (G_OBJECT (buffer),
INSERT_DATA_KEY,
data,
(GDestroyNotify) free_insert_data);
g_signal_connect (buffer,
"insert-text",
G_CALLBACK (on_insert_text_before),
data);
g_signal_connect (buffer,
"begin-user-action",
G_CALLBACK (on_begin_user_action),
data);
g_signal_connect (buffer,
"end-user-action",
G_CALLBACK (on_end_user_action),
data);
}
else
{
g_warning ("Could not set bookmark icon!");
}
}
static void
gbp_retab_editor_page_addin_action (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
GbpRetabEditorPageAddin *self = user_data;
IdeSourceView *source_view;
GtkTextBuffer *buffer;
IdeCompletion *completion;
guint tab_width;
gint start_line;
gint end_line;
gint indent;
GtkTextIter begin;
GtkTextIter end;
gboolean editable;
gboolean to_spaces;
g_assert (GBP_IS_RETAB_EDITOR_PAGE_ADDIN (self));
g_assert (G_IS_SIMPLE_ACTION (action));
buffer = GTK_TEXT_BUFFER (ide_editor_page_get_buffer (self->editor_view));
source_view = ide_editor_page_get_view (self->editor_view);
g_assert (IDE_IS_SOURCE_VIEW (source_view));
editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (source_view));
completion = ide_source_view_get_completion (IDE_SOURCE_VIEW (source_view));
tab_width = gtk_source_view_get_tab_width(GTK_SOURCE_VIEW (source_view));
to_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW (source_view));
if (!editable)
return;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
if (!gtk_text_iter_equal (&begin, &end) && gtk_text_iter_starts_line (&end))
gtk_text_iter_backward_char (&end);
start_line = gtk_text_iter_get_line (&begin);
end_line = gtk_text_iter_get_line (&end);
ide_completion_block_interactive (completion);
gtk_text_buffer_begin_user_action (buffer);
for (gint line = start_line; line <= end_line; ++line)
{
indent = get_buffer_range_indent (buffer, line, to_spaces);
if (indent > 0)
gbp_retab_editor_page_addin_retab (buffer, line, tab_width, indent, to_spaces);
}
gtk_text_buffer_end_user_action (buffer);
ide_completion_unblock_interactive (completion);
}
static gchar *
ide_xml_indenter_format (IdeIndenter *indenter,
GtkTextView *view,
GtkTextIter *begin,
GtkTextIter *end,
gint *cursor_offset,
GdkEventKey *trigger)
{
IdeXmlIndenter *xml = (IdeXmlIndenter *)indenter;
guint tab_width = 2;
gint indent_width = -1;
g_return_val_if_fail (IDE_IS_XML_INDENTER (xml), NULL);
*cursor_offset = 0;
if (GTK_SOURCE_IS_VIEW (view))
{
tab_width = gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (view));
indent_width = gtk_source_view_get_indent_width (GTK_SOURCE_VIEW (view));
if (indent_width != -1)
tab_width = indent_width;
}
xml->tab_width = tab_width;
xml->use_tabs = !gtk_source_view_get_insert_spaces_instead_of_tabs (GTK_SOURCE_VIEW (view));
if (indent_width <= 0)
xml->indent_width = tab_width;
else
xml->indent_width = indent_width;
/* do nothing if we are in a cdata section */
if (text_iter_in_cdata (begin))
return NULL;
switch (trigger->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
if ((trigger->state & GDK_SHIFT_MASK) == 0)
return ide_xml_indenter_indent (xml, begin, end, cursor_offset);
return NULL;
case GDK_KEY_slash:
return ide_xml_indenter_maybe_unindent (xml, begin, end);
case GDK_KEY_greater:
return ide_xml_indenter_maybe_add_closing (xml, begin, end, cursor_offset);
default:
g_return_val_if_reached (NULL);
}
return NULL;
}
//行数表示の設定を変える
void set_display_line_number(void)
{
if (state & line_mask) {
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), FALSE);
} else {
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), TRUE);
}
state ^= line_mask;
}
//タブを用いるかどうかの設定を変える
void set_insert_space(void)
{
if (state & space_mask) {
gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), FALSE);
} else {
gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), TRUE);
}
state ^= space_mask;
}
//行のハイライトの設定を変える
void set_highlight_line(void)
{
if (state & highlight_mask) {
gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), FALSE);
} else {
gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), TRUE);
}
state ^= highlight_mask;
}
static void
pluma_prefs_manager_tabs_size_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_TABS_SIZE) == 0)
{
gint tab_width;
GList *views;
GList *l;
tab_width = g_settings_get_int (settings, key);
tab_width = CLAMP (tab_width, 1, 24);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_tab_width (GTK_SOURCE_VIEW (l->data),
tab_width);
l = l->next;
}
g_list_free (views);
}
else if (strcmp (key, GPM_INSERT_SPACES) == 0)
{
gboolean enable;
GList *views;
GList *l;
enable = g_settings_get_boolean (settings, key);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_insert_spaces_instead_of_tabs (
GTK_SOURCE_VIEW (l->data),
enable);
l = l->next;
}
g_list_free (views);
}
}
static void
pluma_prefs_manager_right_margin_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_RIGHT_MARGIN_POSITION) == 0)
{
gint pos;
GList *views;
GList *l;
pos = g_settings_get_int (settings, key);
pos = CLAMP (pos, 1, 160);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_right_margin_position (GTK_SOURCE_VIEW (l->data),
pos);
l = l->next;
}
g_list_free (views);
}
else if (strcmp (key, GPM_DISPLAY_RIGHT_MARGIN) == 0)
{
gboolean display;
GList *views;
GList *l;
display = g_settings_get_boolean (settings, key);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_show_right_margin (GTK_SOURCE_VIEW (l->data),
display);
l = l->next;
}
g_list_free (views);
}
}
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));
}
void
gui_editor_show (GUIEditor * self)
{
gtk_widget_show (GTK_WIDGET (self->widget));
gtk_widget_show (GTK_WIDGET (self->scroll));
gtk_source_view_set_show_line_numbers (GTK_SOURCE_VIEW(self->widget), TRUE);
self->language = gtk_source_language_manager_get_language(self->lang_manager,"8085_asm");
if (self->language != NULL){
gtk_source_buffer_set_language (self->buffer, self->language);
gtk_source_buffer_set_style_scheme (self->buffer, gtk_source_style_scheme_manager_get_scheme(self->style_scheme_manager,"classic"));
gtk_source_buffer_set_highlight_syntax (self->buffer, TRUE);
}
self->mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(self->buffer));
gtk_source_view_set_show_line_marks (GTK_SOURCE_VIEW(self->widget), TRUE);
}
static void
impl_activate (GeditPlugin *plugin,
GeditWindow *window)
{
WindowData *data;
GList *views, *l;
gedit_debug (DEBUG_PLUGINS);
data = g_slice_new (WindowData);
data->provider = gtk_source_completion_words_new (_("Document Words"),
NULL);
views = gedit_window_get_views (window);
for (l = views; l != NULL; l = g_list_next (l))
{
add_view (data, GTK_SOURCE_VIEW (l->data));
}
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
data,
(GDestroyNotify) free_window_data);
data->tab_added_id =
g_signal_connect (window, "tab-added",
G_CALLBACK (tab_added_cb),
NULL);
data->tab_removed_id =
g_signal_connect (window, "tab-removed",
G_CALLBACK (tab_removed_cb),
NULL);
}
static void
gtk_source_gutter_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkSourceGutter *self = GTK_SOURCE_GUTTER (object);
switch (prop_id)
{
case PROP_VIEW:
set_view (self, GTK_SOURCE_VIEW (g_value_get_object (value)));
break;
case PROP_WINDOW_TYPE:
self->priv->window_type = g_value_get_enum (value);
break;
case PROP_XPAD:
set_xpad (self, g_value_get_int (value), TRUE);
break;
case PROP_YPAD:
set_ypad (self, g_value_get_int (value), TRUE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
message_get_view_iter (PlumaWindow *window,
PlumaMessage *message,
GtkSourceView **view,
GtkTextIter *iter)
{
if (pluma_message_has_key (message, "view"))
{
pluma_message_get (message, "view", view, NULL);
}
else
{
*view = GTK_SOURCE_VIEW (pluma_window_get_active_view (window));
}
if (!*view)
{
return;
}
if (pluma_message_has_key (message, "iter"))
{
pluma_message_get (message, "iter", iter, NULL);
}
else
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (*view));
gtk_text_buffer_get_iter_at_mark (buffer,
iter,
gtk_text_buffer_get_insert (buffer));
}
}
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 void
pluma_prefs_manager_smart_home_end_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_SMART_HOME_END) == 0)
{
GtkSourceSmartHomeEndType smart_he;
GList *views;
GList *l;
smart_he = get_smart_home_end_from_string (g_settings_get_string (settings, key));
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_smart_home_end (GTK_SOURCE_VIEW (l->data),
smart_he);
l = l->next;
}
g_list_free (views);
}
}
static void
gb_view_source_notify_cursor (GbViewSource *source,
GParamSpec *pspec,
GtkTextBuffer *buffer)
{
GbViewSourcePrivate *priv;
GtkTextIter iter;
guint col;
guint line;
guint position;
gchar *s;
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
g_return_if_fail(pspec != NULL);
g_return_if_fail(GTK_SOURCE_IS_BUFFER(buffer));
priv = source->priv;
g_object_get(buffer, "cursor-position", &position, NULL);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, position);
line = gtk_text_iter_get_line(&iter);
col = gtk_source_view_get_visual_column(GTK_SOURCE_VIEW(priv->source1),
&iter);
s = g_strdup_printf(_("Line %d, Column %d"), line + 1, col + 1);
g_object_set(priv->pos_label, "label", s, NULL);
g_free(s);
}
static void
pluma_prefs_manager_auto_indent_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_AUTO_INDENT) == 0)
{
gboolean enable;
GList *views;
GList *l;
enable = g_settings_get_boolean (settings, key);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_auto_indent (GTK_SOURCE_VIEW (l->data),
enable);
l = l->next;
}
g_list_free (views);
}
}
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 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_VIEW (active_widget))
{
GtkSourceView *source_view = GTK_SOURCE_VIEW (IDE_EDITOR_VIEW (active_widget)->frame1->source_view);
if (g_str_equal (options, "enable") || g_str_equal (options, "on"))
g_object_set (source_view, "highlight-syntax", TRUE, NULL);
else if (g_str_equal (options, "off"))
g_object_set (source_view, "highlight-syntax", FALSE, NULL);
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
gedit_word_completion_view_activate (GeditViewActivatable *activatable)
{
GeditWordCompletionPluginPrivate *priv;
GtkSourceCompletion *completion;
GtkSourceCompletionProvider *provider;
GtkTextBuffer *buf;
gedit_debug (DEBUG_PLUGINS);
priv = GEDIT_WORD_COMPLETION_PLUGIN (activatable)->priv;
priv->window = gtk_widget_get_toplevel (GTK_WIDGET (priv->view));
/* We are disposing the window */
g_object_ref (priv->window);
completion = gtk_source_view_get_completion (GTK_SOURCE_VIEW (priv->view));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->view));
provider = g_object_get_data (G_OBJECT (priv->window), WINDOW_PROVIDER);
if (provider == NULL)
{
/* Standalone provider */
provider = GTK_SOURCE_COMPLETION_PROVIDER (create_provider ());
}
priv->provider = g_object_ref (provider);
gtk_source_completion_add_provider (completion, provider, NULL);
gtk_source_completion_words_register (GTK_SOURCE_COMPLETION_WORDS (provider),
buf);
}
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);
}
/**
* gtk_source_completion_info_move_to_iter:
* @info: A #GtkSourceCompletionInfo
* @view: A #GtkTextView on which the info window should be positioned
* @iter: A #GtkTextIter
*
* Moves the #GtkSourceCompletionInfo to @iter. If @iter is %NULL @info is
* moved to the cursor position. Moving will respect the #GdkGravity setting
* of the info window and will ensure the line at @iter is not occluded by
* the window.
*
*/
void
gtk_source_completion_info_move_to_iter (GtkSourceCompletionInfo *info,
GtkTextView *view,
GtkTextIter *iter)
{
GtkTextBuffer *buffer;
GtkTextMark *insert_mark;
GtkTextIter start;
g_return_if_fail (GTK_IS_SOURCE_COMPLETION_INFO (info));
g_return_if_fail (GTK_IS_SOURCE_VIEW (view));
if (iter == NULL)
{
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &start, insert_mark);
}
else
{
start = *iter;
}
gtk_source_completion_utils_move_to_iter (GTK_WINDOW (info),
GTK_SOURCE_VIEW (view),
&start);
}
static void
xedit_modeline_plugin_deactivate (XeditPlugin *plugin,
XeditWindow *window)
{
WindowData *wdata;
GList *views;
GList *l;
xedit_debug (DEBUG_PLUGINS);
wdata = g_object_steal_data (G_OBJECT (window), WINDOW_DATA_KEY);
g_signal_handler_disconnect (window, wdata->tab_added_handler_id);
g_signal_handler_disconnect (window, wdata->tab_removed_handler_id);
window_data_free (wdata);
views = xedit_window_get_views (window);
for (l = views; l != NULL; l = l->next)
{
disconnect_handlers (XEDIT_VIEW (l->data));
modeline_parser_deactivate (GTK_SOURCE_VIEW (l->data));
}
g_list_free (views);
}
static void
xedit_modeline_plugin_activate (XeditPlugin *plugin,
XeditWindow *window)
{
WindowData *wdata;
GList *views;
GList *l;
xedit_debug (DEBUG_PLUGINS);
views = xedit_window_get_views (window);
for (l = views; l != NULL; l = l->next)
{
connect_handlers (XEDIT_VIEW (l->data));
modeline_parser_apply_modeline (GTK_SOURCE_VIEW (l->data));
}
g_list_free (views);
wdata = g_slice_new (WindowData);
wdata->tab_added_handler_id =
g_signal_connect (window, "tab-added",
G_CALLBACK (on_window_tab_added), NULL);
wdata->tab_removed_handler_id =
g_signal_connect (window, "tab-removed",
G_CALLBACK (on_window_tab_removed), NULL);
g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY,
wdata, (GDestroyNotify) window_data_free);
}
static void
pluma_prefs_manager_hl_current_line_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_HIGHLIGHT_CURRENT_LINE) == 0)
{
gboolean hl;
GList *views;
GList *l;
hl = g_settings_get_boolean (settings, key);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_highlight_current_line (GTK_SOURCE_VIEW (l->data),
hl);
l = l->next;
}
g_list_free (views);
}
}
static void
pluma_prefs_manager_line_numbers_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_DISPLAY_LINE_NUMBERS) == 0)
{
gboolean dln;
GList *views;
GList *l;
dln = g_settings_get_boolean (settings, key);
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_source_view_set_show_line_numbers (GTK_SOURCE_VIEW (l->data),
dln);
l = l->next;
}
g_list_free (views);
}
}
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);
}
static void
on_notify_view_eol (GSettings* settings,
const gchar* key,
gpointer user_data)
{
Sourceview *sv;
sv = ANJUTA_SOURCEVIEW(user_data);
GtkSourceDrawSpacesFlags flags =
gtk_source_view_get_draw_spaces (GTK_SOURCE_VIEW (sv->priv->view));
if (g_settings_get_boolean (settings, key))
flags |= GTK_SOURCE_DRAW_SPACES_NEWLINE;
else
flags &= ~GTK_SOURCE_DRAW_SPACES_NEWLINE;
gtk_source_view_set_draw_spaces (GTK_SOURCE_VIEW(sv->priv->view),
flags);
}
static gboolean
gb_vim_jump_to_line (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))
{
GtkSourceView *source_view = GTK_SOURCE_VIEW (IDE_EDITOR_VIEW (active_widget)->frame1->source_view);
GtkTextBuffer *buffer;
gboolean extend_selection;
gint line;
if (!int32_parse (&line, options, 0, G_MAXINT32, "line number", error))
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
extend_selection = gtk_text_buffer_get_has_selection (buffer);
ide_source_view_set_count (IDE_SOURCE_VIEW (source_view), line);
if (line == 0)
{
GtkTextIter iter;
/*
* Zero is not a valid line number, and IdeSourceView treats
* that as a move to the end of the buffer. Instead, we want
* line 1 to be like vi/vim.
*/
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (source_view),
gtk_text_buffer_get_insert (buffer),
0.0, FALSE, 0.0, 0.0);
}
else
{
g_signal_emit_by_name (source_view,
"movement",
IDE_SOURCE_VIEW_MOVEMENT_NTH_LINE,
extend_selection, TRUE, TRUE);
}
ide_source_view_set_count (IDE_SOURCE_VIEW (source_view), 0);
g_signal_emit_by_name (source_view, "save-insert-mark");
return TRUE;
}
else
return gb_vim_set_source_view_error (error);
}
