static void
gedit_document_dispose (GObject *object)
{
GeditDocumentPrivate *priv;
gedit_debug (DEBUG_DOCUMENT);
priv = gedit_document_get_instance_private (GEDIT_DOCUMENT (object));
/* Metadata must be saved here and not in finalize because the language
* is gone by the time finalize runs.
*/
if (priv->file != NULL)
{
save_metadata (GEDIT_DOCUMENT (object));
g_object_unref (priv->file);
priv->file = NULL;
}
g_clear_object (&priv->editor_settings);
g_clear_object (&priv->metadata_info);
g_clear_object (&priv->search_context);
G_OBJECT_CLASS (gedit_document_parent_class)->dispose (object);
}
static void
gedit_document_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
switch (prop_id)
{
case PROP_SHORTNAME:
g_value_take_string (value, gedit_document_get_short_name_for_display (doc));
break;
case PROP_CONTENT_TYPE:
g_value_take_string (value, gedit_document_get_content_type (doc));
break;
case PROP_MIME_TYPE:
g_value_take_string (value, gedit_document_get_mime_type (doc));
break;
case PROP_READ_ONLY:
g_value_set_boolean (value, doc->priv->readonly);
break;
case PROP_EMPTY_SEARCH:
g_value_set_boolean (value, doc->priv->empty_search);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gedit_document_changed (GtkTextBuffer *buffer)
{
g_signal_emit (GEDIT_DOCUMENT (buffer), document_signals[CURSOR_MOVED], 0);
GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->changed (buffer);
}
static void
set_auto_spell (GeditWindow *window,
GeditView *view,
gboolean active)
{
GeditAutomaticSpellChecker *autospell;
GeditSpellChecker *spell;
GeditDocument *doc;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
spell = get_spell_checker_from_document (doc);
g_return_if_fail (spell != NULL);
autospell = gedit_automatic_spell_checker_get_from_document (doc);
if (active)
{
if (autospell == NULL)
{
autospell = gedit_automatic_spell_checker_new (doc, spell);
gedit_automatic_spell_checker_attach_view (autospell, view);
gedit_automatic_spell_checker_recheck_all (autospell);
}
}
else
{
if (autospell != NULL)
gedit_automatic_spell_checker_free (autospell);
}
}
static void
set_auto_spell_from_metadata (GeditSpellPlugin *plugin,
GeditView *view)
{
gboolean active = FALSE;
gchar *active_str;
GeditDocument *doc;
GeditDocument *active_doc;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
active_str = gedit_document_get_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED);
if (active_str)
{
active = *active_str == '1';
g_free (active_str);
}
set_auto_spell (plugin->priv->window, view, active);
/* In case that the doc is the active one we mark the spell action */
active_doc = gedit_window_get_active_document (plugin->priv->window);
if (active_doc == doc)
{
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (plugin->priv->window),
"auto-spell");
g_action_change_state (action, g_variant_new_boolean (active));
}
}
static void
auto_spell_cb (GSimpleAction *action,
GVariant *state,
gpointer data)
{
GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data);
GeditSpellPluginPrivate *priv = plugin->priv;
GeditView *view;
gboolean active;
gedit_debug (DEBUG_PLUGINS);
active = g_variant_get_boolean (state);
gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated");
view = gedit_window_get_active_view (priv->window);
if (view != NULL)
{
GeditDocument *doc;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
gedit_document_set_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED,
active ? "1" : NULL, NULL);
set_auto_spell (priv->window, view, active);
g_simple_action_set_state (action, g_variant_new_boolean (active));
}
}
static void
tab_added_cb (GeditWindow *window,
GeditTab *tab,
GeditSpellPlugin *plugin)
{
GeditView *view;
GeditDocument *doc;
view = gedit_tab_get_view (tab);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
/* we need to pass the view with the document as there is no way to
attach the view to the automatic spell checker. */
g_object_set_data (G_OBJECT (doc), GEDIT_AUTOMATIC_SPELL_VIEW, view);
g_signal_connect (doc,
"loaded",
G_CALLBACK (on_document_loaded),
plugin);
g_signal_connect (doc,
"saved",
G_CALLBACK (on_document_saved),
plugin);
}
GeditDocument *
gedit_view_frame_get_document (GeditViewFrame *frame)
{
g_return_val_if_fail (GEDIT_IS_VIEW_FRAME (frame), NULL);
return GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view)));
}
static void
gedit_document_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
GeditDocumentPrivate *priv = gedit_document_get_instance_private (doc);
switch (prop_id)
{
case PROP_SHORTNAME:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gedit_document_set_short_name_for_display (doc, g_value_get_string (value));
G_GNUC_END_IGNORE_DEPRECATIONS;
break;
case PROP_CONTENT_TYPE:
set_content_type (doc, g_value_get_string (value));
break;
case PROP_USE_GVFS_METADATA:
priv->use_gvfs_metadata = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
update_ui (GeditSpellPlugin *plugin)
{
GeditSpellPluginPrivate *priv;
GeditView *view;
GAction *check_spell_action;
GAction *config_spell_action;
GAction *auto_spell_action;
gedit_debug (DEBUG_PLUGINS);
priv = plugin->priv;
view = gedit_window_get_active_view (priv->window);
check_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"check-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
config_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"config-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (config_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
auto_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"auto-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (auto_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
if (view != NULL)
{
GeditDocument *doc;
GeditTab *tab;
GeditTabState state;
gboolean autospell;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
tab = gedit_window_get_active_tab (priv->window);
state = gedit_tab_get_state (tab);
autospell = (doc != NULL &&
gedit_automatic_spell_checker_get_from_document (doc) != NULL);
/* If the document is loading we can't get the metadata so we
endup with an useless speller */
if (state == GEDIT_TAB_STATE_NORMAL)
{
g_action_change_state (auto_spell_action, g_variant_new_boolean (autospell));
}
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) > 0);
}
}
static void
change_cb (GeditSpellCheckerDialog *dlg,
const gchar *word,
const gchar *change,
GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gchar *w = NULL;
GtkTextIter start, end;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (view != NULL);
g_return_if_fail (word != NULL);
g_return_if_fail (change != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
if (range->mw_end < 0)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
else
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);
w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
g_return_if_fail (w != NULL);
if (strcmp (w, word) != 0)
{
g_free (w);
return;
}
g_free (w);
gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER(doc));
gtk_text_buffer_delete (GTK_TEXT_BUFFER (doc), &start, &end);
gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc), &start, change, -1);
gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER(doc));
update_current (doc, range->mw_start + g_utf8_strlen (change, -1));
/* go to next misspelled word */
ignore_cb (dlg, word, view);
}
static void
change_all_cb (GeditSpellCheckerDialog *dlg,
const gchar *word,
const gchar *change,
GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gchar *w = NULL;
GtkTextIter start, end;
gint flags = 0;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (view != NULL);
g_return_if_fail (word != NULL);
g_return_if_fail (change != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
if (range->mw_end < 0)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
else
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);
w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
g_return_if_fail (w != NULL);
if (strcmp (w, word) != 0)
{
g_free (w);
return;
}
g_free (w);
GEDIT_SEARCH_SET_CASE_SENSITIVE (flags, TRUE);
GEDIT_SEARCH_SET_ENTIRE_WORD (flags, TRUE);
/* CHECK: currently this function does escaping etc */
gedit_document_replace_all (doc, word, change, flags);
update_current (doc, range->mw_start + g_utf8_strlen (change, -1));
/* go to next misspelled word */
ignore_cb (dlg, word, view);
}
static void
gedit_document_end_user_action (GtkTextBuffer *buffer)
{
GeditDocumentPrivate *priv;
priv = gedit_document_get_instance_private (GEDIT_DOCUMENT (buffer));
--priv->user_action;
if (GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->end_user_action != NULL)
{
GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->end_user_action (buffer);
}
}
static void
gedit_document_constructed (GObject *object)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
/* Bind construct properties. */
g_settings_bind (doc->priv->editor_settings,
GEDIT_SETTINGS_ENSURE_TRAILING_NEWLINE,
doc,
"implicit-trailing-newline",
G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY);
G_OBJECT_CLASS (gedit_document_parent_class)->constructed (object);
}
static void
save_bookmark_metadata (GeditView *view)
{
GtkTextIter iter;
GtkTextBuffer *buf;
GString *string;
gchar *val = NULL;
gboolean first = TRUE;
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_start_iter (buf, &iter);
string = g_string_new (NULL);
while (gtk_source_buffer_forward_iter_to_source_mark (GTK_SOURCE_BUFFER (buf),
&iter,
BOOKMARK_CATEGORY))
{
gint line;
line = gtk_text_iter_get_line (&iter);
if (!first)
{
g_string_append_printf (string, ",%d", line);
}
else
{
g_string_append_printf (string, "%d", line);
first = FALSE;
}
}
if (string->len == 0)
{
val = g_string_free (string, TRUE);
val = NULL;
}
else
val = g_string_free (string, FALSE);
gedit_document_set_metadata (GEDIT_DOCUMENT (buf), METADATA_ATTR,
val, NULL);
g_free (val);
}
static void
gedit_document_finalize (GObject *object)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
gedit_debug (DEBUG_DOCUMENT);
if (doc->priv->untitled_number > 0)
{
release_untitled_number (doc->priv->untitled_number);
}
g_free (doc->priv->content_type);
g_free (doc->priv->short_name);
G_OBJECT_CLASS (gedit_document_parent_class)->finalize (object);
}
static void
gedit_document_mark_set (GtkTextBuffer *buffer,
const GtkTextIter *iter,
GtkTextMark *mark)
{
GeditDocument *doc = GEDIT_DOCUMENT (buffer);
if (GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set != NULL)
{
GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set (buffer, iter, mark);
}
if (mark == gtk_text_buffer_get_insert (buffer))
{
g_signal_emit (doc, document_signals[CURSOR_MOVED], 0);
}
}
static void
gedit_document_finalize (GObject *object)
{
GeditDocumentPrivate *priv;
gedit_debug (DEBUG_DOCUMENT);
priv = gedit_document_get_instance_private (GEDIT_DOCUMENT (object));
if (priv->untitled_number > 0)
{
release_untitled_number (priv->untitled_number);
}
g_free (priv->content_type);
g_free (priv->short_name);
G_OBJECT_CLASS (gedit_document_parent_class)->finalize (object);
}
static void
gedit_document_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
GeditDocumentPrivate *priv;
priv = gedit_document_get_instance_private (doc);
switch (prop_id)
{
case PROP_SHORTNAME:
g_value_take_string (value, gedit_document_get_short_name_for_display (doc));
break;
case PROP_CONTENT_TYPE:
g_value_take_string (value, gedit_document_get_content_type (doc));
break;
case PROP_MIME_TYPE:
g_value_take_string (value, gedit_document_get_mime_type (doc));
break;
case PROP_READ_ONLY:
g_value_set_boolean (value, gtk_source_file_is_readonly (priv->file));
break;
case PROP_EMPTY_SEARCH:
g_value_set_boolean (value, priv->empty_search);
break;
case PROP_USE_GVFS_METADATA:
g_value_set_boolean (value, priv->use_gvfs_metadata);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
load_bookmark_metadata (GeditView *view)
{
GeditDocument *doc;
gchar *bookmarks_attr;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
bookmarks_attr = gedit_document_get_metadata (doc, METADATA_ATTR);
if (bookmarks_attr != NULL)
{
gchar **bookmarks;
bookmarks = g_strsplit (bookmarks_attr, ",", -1);
g_free (bookmarks_attr);
load_bookmarks (view, bookmarks);
g_strfreev (bookmarks);
}
}
static void
gedit_document_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GeditDocument *doc = GEDIT_DOCUMENT (object);
switch (prop_id)
{
case PROP_SHORTNAME:
gedit_document_set_short_name_for_display (doc, g_value_get_string (value));
break;
case PROP_CONTENT_TYPE:
gedit_document_set_content_type (doc, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gedit_document_output_stream_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GeditDocumentOutputStream *stream = GEDIT_DOCUMENT_OUTPUT_STREAM (object);
switch (prop_id)
{
case PROP_DOCUMENT:
stream->priv->doc = GEDIT_DOCUMENT (g_value_get_object (value));
break;
case PROP_ENSURE_TRAILING_NEWLINE:
stream->priv->ensure_trailing_newline = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
spell_cb (GtkAction *action,
ActionData *action_data)
{
GeditView *view;
GeditDocument *doc;
GeditSpellChecker *spell;
GtkWidget *dlg;
GtkTextIter start, end;
gchar *word;
gchar *data_dir;
gedit_debug (DEBUG_PLUGINS);
view = gedit_window_get_active_view (action_data->window);
g_return_if_fail (view != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
spell = get_spell_checker_from_document (doc);
g_return_if_fail (spell != NULL);
if (gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) <= 0)
{
WindowData *data;
GtkWidget *statusbar;
data = (WindowData *) g_object_get_data (G_OBJECT (action_data->window),
WINDOW_DATA_KEY);
g_return_if_fail (data != NULL);
statusbar = gedit_window_get_statusbar (action_data->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
data->message_cid,
_("The document is empty."));
return;
}
if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end))
{
/* no selection, get the whole doc */
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
}
set_check_range (doc, &start, &end);
word = get_next_misspelled_word (view);
if (word == NULL)
{
WindowData *data;
GtkWidget *statusbar;
data = (WindowData *) g_object_get_data (G_OBJECT (action_data->window),
WINDOW_DATA_KEY);
g_return_if_fail (data != NULL);
statusbar = gedit_window_get_statusbar (action_data->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
data->message_cid,
_("No misspelled words"));
return;
}
data_dir = gedit_plugin_get_data_dir (action_data->plugin);
dlg = gedit_spell_checker_dialog_new_from_spell_checker (spell, data_dir);
g_free (data_dir);
gtk_window_set_modal (GTK_WINDOW (dlg), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (dlg),
GTK_WINDOW (action_data->window));
g_signal_connect (dlg, "ignore", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "ignore_all", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "change", G_CALLBACK (change_cb), view);
g_signal_connect (dlg, "change_all", G_CALLBACK (change_all_cb), view);
g_signal_connect (dlg, "add_word_to_personal", G_CALLBACK (add_word_cb), view);
gedit_spell_checker_dialog_set_misspelled_word (GEDIT_SPELL_CHECKER_DIALOG (dlg),
word,
-1);
g_free (word);
gtk_widget_show (dlg);
}
static void
init_search_entry (GeditViewFrame *frame)
{
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view));
customize_for_search_mode (frame);
if (frame->priv->search_mode == GOTO_LINE)
{
gint line;
gchar *line_str;
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark (buffer,
&iter,
frame->priv->start_mark);
line = gtk_text_iter_get_line (&iter);
line_str = g_strdup_printf ("%d", line + 1);
gtk_entry_set_text (GTK_ENTRY (frame->priv->search_entry),
line_str);
gtk_editable_select_region (GTK_EDITABLE (frame->priv->search_entry),
0, -1);
g_free (line_str);
return;
}
else
{
/* SEARCH mode */
gboolean selection_exists;
gchar *find_text = NULL;
gchar *old_find_text;
guint old_find_flags = 0;
gint sel_len = 0;
old_find_text = gedit_document_get_search_text (GEDIT_DOCUMENT (buffer),
&old_find_flags);
if (old_find_flags != 0)
{
frame->priv->old_search_flags = old_find_flags;
}
selection_exists = get_selected_text (buffer,
&find_text,
&sel_len);
if (selection_exists && (find_text != NULL) && (sel_len <= 160))
{
gtk_entry_set_text (GTK_ENTRY (frame->priv->search_entry),
find_text);
gtk_editable_set_position (GTK_EDITABLE (frame->priv->search_entry),
-1);
}
else if (old_find_text != NULL)
{
g_free (frame->priv->old_search_text);
frame->priv->old_search_text = old_find_text;
g_signal_handler_block (frame->priv->search_entry,
frame->priv->search_entry_changed_id);
gtk_entry_set_text (GTK_ENTRY (frame->priv->search_entry),
old_find_text);
gtk_editable_select_region (GTK_EDITABLE (frame->priv->search_entry),
0, -1);
g_signal_handler_unblock (frame->priv->search_entry,
frame->priv->search_entry_changed_id);
}
g_free (find_text);
}
}
static void
change_all_cb (GeditSpellCheckerDialog *dlg,
const gchar *word,
const gchar *change,
GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gchar *w = NULL;
GtkTextIter start, end;
GtkSourceSearchSettings *search_settings;
GtkSourceSearchContext *search_context;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (view != NULL);
g_return_if_fail (word != NULL);
g_return_if_fail (change != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
if (range->mw_end < 0)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
else
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);
w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
g_return_if_fail (w != NULL);
if (strcmp (w, word) != 0)
{
g_free (w);
return;
}
g_free (w);
search_settings = gtk_source_search_settings_new ();
gtk_source_search_settings_set_case_sensitive (search_settings, TRUE);
gtk_source_search_settings_set_at_word_boundaries (search_settings, TRUE);
gtk_source_search_settings_set_search_text (search_settings, word);
search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (doc),
search_settings);
gtk_source_search_context_set_highlight (search_context, FALSE);
gtk_source_search_context_replace_all (search_context, change, -1, NULL);
update_current (doc, range->mw_start + g_utf8_strlen (change, -1));
/* go to next misspelled word */
ignore_cb (dlg, word, view);
g_object_unref (search_settings);
g_object_unref (search_context);
}
static void
spell_cb (GSimpleAction *action,
GVariant *parameter,
gpointer data)
{
GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data);
GeditSpellPluginPrivate *priv;
GeditView *view;
GeditDocument *doc;
GeditSpellChecker *spell;
GtkWidget *dlg;
GtkTextIter start, end;
gchar *word;
gchar *data_dir;
gedit_debug (DEBUG_PLUGINS);
priv = plugin->priv;
view = gedit_window_get_active_view (priv->window);
g_return_if_fail (view != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
spell = get_spell_checker_from_document (doc);
g_return_if_fail (spell != NULL);
if (gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) <= 0)
{
GtkWidget *statusbar;
statusbar = gedit_window_get_statusbar (priv->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
priv->message_cid,
_("The document is empty."));
return;
}
if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end))
{
/* no selection, get the whole doc */
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
}
set_check_range (doc, &start, &end);
word = get_next_misspelled_word (view);
if (word == NULL)
{
GtkWidget *statusbar;
statusbar = gedit_window_get_statusbar (priv->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
priv->message_cid,
_("No misspelled words"));
return;
}
data_dir = peas_extension_base_get_data_dir (PEAS_EXTENSION_BASE (plugin));
dlg = gedit_spell_checker_dialog_new_from_spell_checker (spell, data_dir);
g_free (data_dir);
gtk_window_set_modal (GTK_WINDOW (dlg), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (dlg),
GTK_WINDOW (priv->window));
g_signal_connect (dlg, "ignore", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "ignore_all", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "change", G_CALLBACK (change_cb), view);
g_signal_connect (dlg, "change_all", G_CALLBACK (change_all_cb), view);
g_signal_connect (dlg, "add_word_to_personal", G_CALLBACK (add_word_cb), view);
gedit_spell_checker_dialog_set_misspelled_word (GEDIT_SPELL_CHECKER_DIALOG (dlg),
word,
-1);
g_free (word);
gtk_widget_show (dlg);
}
static gchar *
get_next_misspelled_word (GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gint start, end;
gchar *word;
GeditSpellChecker *spell;
g_return_val_if_fail (view != NULL, NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_val_if_fail (doc != NULL, NULL);
range = get_check_range (doc);
g_return_val_if_fail (range != NULL, NULL);
spell = get_spell_checker_from_document (doc);
g_return_val_if_fail (spell != NULL, NULL);
word = get_current_word (doc, &start, &end);
if (word == NULL)
return NULL;
gedit_debug_message (DEBUG_PLUGINS, "Word to check: %s", word);
while (gedit_spell_checker_check_word (spell, word, -1))
{
g_free (word);
if (!goto_next_word (doc))
return NULL;
/* may return null if we reached the end of the selection */
word = get_current_word (doc, &start, &end);
if (word == NULL)
return NULL;
gedit_debug_message (DEBUG_PLUGINS, "Word to check: %s", word);
}
if (!goto_next_word (doc))
update_current (doc, gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)));
if (word != NULL)
{
GtkTextIter s, e;
range->mw_start = start;
range->mw_end = end;
gedit_debug_message (DEBUG_PLUGINS, "Select [%d, %d]", start, end);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &s, start);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &e, end);
gtk_text_buffer_select_range (GTK_TEXT_BUFFER (doc), &s, &e);
gedit_view_scroll_to_cursor (view);
}
else
{
range->mw_start = -1;
range->mw_end = -1;
}
return word;
}
static void
impl_activate (GeditPlugin *plugin,
GeditWindow *window)
{
GtkUIManager *manager;
WindowData *data;
ActionData *action_data;
GList *docs, *l;
gedit_debug (DEBUG_PLUGINS);
data = g_slice_new (WindowData);
action_data = g_slice_new (ActionData);
action_data->plugin = plugin;
action_data->window = window;
manager = gedit_window_get_ui_manager (window);
data->action_group = gtk_action_group_new ("GeditSpellPluginActions");
gtk_action_group_set_translation_domain (data->action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions_full (data->action_group,
action_entries,
G_N_ELEMENTS (action_entries),
action_data,
(GDestroyNotify) free_action_data);
gtk_action_group_add_toggle_actions (data->action_group,
toggle_action_entries,
G_N_ELEMENTS (toggle_action_entries),
window);
gtk_ui_manager_insert_action_group (manager, data->action_group, -1);
data->ui_id = gtk_ui_manager_new_merge_id (manager);
data->message_cid = gtk_statusbar_get_context_id
(GTK_STATUSBAR (gedit_window_get_statusbar (window)),
"spell_plugin_message");
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
data,
(GDestroyNotify) free_window_data);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"CheckSpell",
"CheckSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"AutoSpell",
"AutoSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"ConfigSpell",
"ConfigSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
update_ui_real (window, data);
docs = gedit_window_get_documents (window);
for (l = docs; l != NULL; l = g_list_next (l))
{
set_auto_spell_from_metadata (window, GEDIT_DOCUMENT (l->data),
data->action_group);
}
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);
}
void
modeline_parser_apply_modeline (GtkSourceView *view)
{
ModelineOptions options;
GtkTextBuffer *buffer;
GtkTextIter iter, liter;
gint line_count;
GSettings *settings;
options.language_id = NULL;
options.set = MODELINE_SET_NONE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_start_iter (buffer, &iter);
line_count = gtk_text_buffer_get_line_count (buffer);
/* Parse the modelines on the 10 first lines... */
while ((gtk_text_iter_get_line (&iter) < 10) &&
!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* ...and on the 10 last ones (modelines are not allowed in between) */
if (!gtk_text_iter_is_end (&iter))
{
gint cur_line;
guint remaining_lines;
/* we are on the 11th line (count from 0) */
cur_line = gtk_text_iter_get_line (&iter);
/* g_assert (10 == cur_line); */
remaining_lines = line_count - cur_line - 1;
if (remaining_lines > 10)
{
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_iter_backward_lines (&iter, 9);
}
}
while (!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* Try to set language */
if (has_option (&options, MODELINE_SET_LANGUAGE) && options.language_id)
{
if (g_ascii_strcasecmp (options.language_id, "text") == 0)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
NULL);
}
else
{
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
manager = gedit_get_language_manager ();
language = gtk_source_language_manager_get_language
(manager, options.language_id);
if (language != NULL)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
language);
}
else
{
gedit_debug_message (DEBUG_PLUGINS,
"Unknown language `%s'",
options.language_id);
}
}
}
ModelineOptions *previous = g_object_get_data (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY);
settings = g_settings_new ("org.gnome.gedit.preferences.editor");
/* Apply the options we got from modelines and restore defaults if
we set them before */
if (has_option (&options, MODELINE_SET_INSERT_SPACES))
{
gtk_source_view_set_insert_spaces_instead_of_tabs
(view, options.insert_spaces);
}
else if (check_previous (view, previous, MODELINE_SET_INSERT_SPACES))
{
gboolean insert_spaces;
insert_spaces = g_settings_get_boolean (settings, GEDIT_SETTINGS_INSERT_SPACES);
gtk_source_view_set_insert_spaces_instead_of_tabs (view, insert_spaces);
}
if (has_option (&options, MODELINE_SET_TAB_WIDTH))
{
gtk_source_view_set_tab_width (view, options.tab_width);
}
else if (check_previous (view, previous, MODELINE_SET_TAB_WIDTH))
{
guint tab_width;
g_settings_get (settings, GEDIT_SETTINGS_TABS_SIZE, "u", &tab_width);
gtk_source_view_set_tab_width (view, tab_width);
}
if (has_option (&options, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, options.indent_width);
}
else if (check_previous (view, previous, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, -1);
}
if (has_option (&options, MODELINE_SET_WRAP_MODE))
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), options.wrap_mode);
}
else if (check_previous (view, previous, MODELINE_SET_WRAP_MODE))
{
GtkWrapMode mode;
mode = g_settings_get_enum (settings,
GEDIT_SETTINGS_WRAP_MODE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), mode);
}
if (has_option (&options, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
gtk_source_view_set_right_margin_position (view, options.right_margin_position);
}
else if (check_previous (view, previous, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
guint right_margin_pos;
g_settings_get (settings, GEDIT_SETTINGS_RIGHT_MARGIN_POSITION, "u",
&right_margin_pos);
gtk_source_view_set_right_margin_position (view,
right_margin_pos);
}
if (has_option (&options, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gtk_source_view_set_show_right_margin (view, options.display_right_margin);
}
else if (check_previous (view, previous, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gboolean display_right_margin;
display_right_margin = g_settings_get_boolean (settings,
GEDIT_SETTINGS_DISPLAY_RIGHT_MARGIN);
gtk_source_view_set_show_right_margin (view, display_right_margin);
}
if (previous)
{
g_free (previous->language_id);
*previous = options;
previous->language_id = g_strdup (options.language_id);
}
else
{
previous = g_slice_new (ModelineOptions);
*previous = options;
previous->language_id = g_strdup (options.language_id);
g_object_set_data_full (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY,
previous,
(GDestroyNotify)free_modeline_options);
}
g_object_unref (settings);
g_free (options.language_id);
}
