void
pluma_plugins_engine_deactivate_plugins (PlumaPluginsEngine *engine,
PlumaWindow *window)
{
GList *pl;
pluma_debug (DEBUG_PLUGINS);
g_return_if_fail (PLUMA_IS_PLUGINS_ENGINE (engine));
g_return_if_fail (PLUMA_IS_WINDOW (window));
for (pl = engine->priv->plugin_list; pl; pl = pl->next)
{
PlumaPluginInfo *info = (PlumaPluginInfo*)pl->data;
/* check if the plugin is actually active */
if (!pluma_plugin_info_is_active (info))
continue;
/* call deactivate for the plugin for this window */
pluma_plugin_deactivate (info->plugin, window);
}
pluma_debug_message (DEBUG_PLUGINS, "End");
}
static void
pluma_plugins_engine_finalize (GObject *object)
{
PlumaPluginsEngine *engine = PLUMA_PLUGINS_ENGINE (object);
GList *item;
pluma_debug (DEBUG_PLUGINS);
/* Firs deactivate all plugins */
for (item = engine->priv->plugin_list; item; item = item->next)
{
PlumaPluginInfo *info = PLUMA_PLUGIN_INFO (item->data);
if (pluma_plugin_info_is_active (info))
pluma_plugins_engine_deactivate_plugin_real (engine, info);
}
/* unref the loaders */
g_hash_table_destroy (engine->priv->loaders);
/* and finally free the infos */
for (item = engine->priv->plugin_list; item; item = item->next)
{
PlumaPluginInfo *info = PLUMA_PLUGIN_INFO (item->data);
_pluma_plugin_info_unref (info);
}
g_list_free (engine->priv->plugin_list);
G_OBJECT_CLASS (pluma_plugins_engine_parent_class)->finalize (object);
}
const GList *
pluma_plugins_engine_get_plugin_list (PlumaPluginsEngine *engine)
{
pluma_debug (DEBUG_PLUGINS);
return engine->priv->plugin_list;
}
static void
impl_activate (PlumaPlugin *plugin,
PlumaWindow *window)
{
SoupMessage *msg;
WindowData *data;
pluma_debug (DEBUG_PLUGINS);
data = g_slice_new (WindowData);
data->plugin = PLUMA_CHECK_UPDATE_PLUGIN (plugin);
data->url = NULL;
data->version = NULL;
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
data,
free_window_data);
msg = soup_message_new ("GET", PLUMA_URL);
soup_session_queue_message (PLUMA_CHECK_UPDATE_PLUGIN (plugin)->priv->session, msg,
(SoupSessionCallback)parse_page_version,
window);
}
static void
pluma_plugins_engine_init (PlumaPluginsEngine *engine)
{
pluma_debug (DEBUG_PLUGINS);
if (!g_module_supported ())
{
g_warning ("pluma is not able to initialize the plugins engine.");
return;
}
engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine,
PLUMA_TYPE_PLUGINS_ENGINE,
PlumaPluginsEnginePrivate);
load_all_plugins (engine);
/* make sure that the first reactivation will read active plugins
from the prefs */
engine->priv->activate_from_prefs = TRUE;
/* mapping from loadername -> loader object */
engine->priv->loaders = g_hash_table_new_full (hash_lowercase,
equal_lowercase,
(GDestroyNotify)g_free,
(GDestroyNotify)loader_destroy);
}
static void
impl_activate (PlumaPlugin *plugin,
PlumaWindow *window)
{
WindowData *data;
GList *views;
GList *item;
pluma_debug (DEBUG_PLUGINS);
data = g_slice_new (WindowData);
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
data,
(GDestroyNotify) free_window_data);
views = pluma_window_get_views (window);
for (item = views; item != NULL; item = item->next)
{
enable_bookmarks (PLUMA_VIEW (item->data), plugin);
load_bookmark_metadata (PLUMA_VIEW (item->data));
}
g_list_free (views);
g_signal_connect (window, "tab-added",
G_CALLBACK (on_tab_added), plugin);
g_signal_connect (window, "tab-removed",
G_CALLBACK (on_tab_removed), plugin);
install_menu (window);
install_messages (window);
}
static void
impl_deactivate (PlumaPlugin *plugin,
PlumaWindow *window)
{
WindowData *data;
GList *views;
GList *item;
pluma_debug (DEBUG_PLUGINS);
uninstall_menu (window);
uninstall_messages (window);
views = pluma_window_get_views (window);
for (item = views; item != NULL; item = item->next)
{
disable_bookmarks (PLUMA_VIEW (item->data));
}
g_list_free (views);
data = BOOKMARKS_DATA (window);
g_return_if_fail (data != NULL);
g_signal_handlers_disconnect_by_func (window, on_tab_added, plugin);
g_signal_handlers_disconnect_by_func (window, on_tab_removed, plugin);
g_object_set_data (G_OBJECT (window), WINDOW_DATA_KEY, NULL);
}
static gboolean
goto_next_word (PlumaDocument *doc)
{
CheckRange *range;
GtkTextIter current_iter;
GtkTextIter old_current_iter;
GtkTextIter end_iter;
pluma_debug (DEBUG_PLUGINS);
g_return_val_if_fail (doc != NULL, FALSE);
range = get_check_range (doc);
g_return_val_if_fail (range != NULL, FALSE);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
¤t_iter,
range->current_mark);
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end_iter);
old_current_iter = current_iter;
gtk_text_iter_forward_word_ends (¤t_iter, 2);
gtk_text_iter_backward_word_start (¤t_iter);
if (pluma_spell_utils_skip_no_spell_check (¤t_iter, &end_iter) &&
(gtk_text_iter_compare (&old_current_iter, ¤t_iter) < 0) &&
(gtk_text_iter_compare (¤t_iter, &end_iter) < 0))
{
update_current (doc, gtk_text_iter_get_offset (¤t_iter));
return TRUE;
}
return FALSE;
}
static void
ignore_cb (PlumaSpellCheckerDialog *dlg,
const gchar *w,
PlumaView *view)
{
gchar *word = NULL;
pluma_debug (DEBUG_PLUGINS);
g_return_if_fail (w != NULL);
g_return_if_fail (view != NULL);
word = get_next_misspelled_word (view);
if (word == NULL)
{
pluma_spell_checker_dialog_set_completed (dlg);
return;
}
pluma_spell_checker_dialog_set_misspelled_word (PLUMA_SPELL_CHECKER_DIALOG (dlg),
word,
-1);
g_free (word);
}
static void
pluma_spell_plugin_update_state (PeasActivatable *activatable)
{
pluma_debug (DEBUG_PLUGINS);
update_ui (PLUMA_SPELL_PLUGIN (activatable));
}
static void
auto_spell_cb (GtkAction *action,
PlumaSpellPlugin *plugin)
{
PlumaWindow *window;
PlumaDocument *doc;
gboolean active;
pluma_debug (DEBUG_PLUGINS);
window = PLUMA_WINDOW (plugin->priv->window);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
pluma_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated");
doc = pluma_window_get_active_document (window);
if (doc == NULL)
return;
if (get_autocheck_type (plugin) == AUTOCHECK_DOCUMENT)
{
pluma_document_set_metadata (doc,
PLUMA_METADATA_ATTRIBUTE_SPELL_ENABLED,
active ? "1" : NULL, NULL);
}
set_auto_spell (window, doc, active);
}
static void
docinfo_real (PlumaDocument *doc,
DocInfoDialog *dialog)
{
GtkTextIter start, end;
gint words = 0;
gint chars = 0;
gint white_chars = 0;
gint lines = 0;
gint bytes = 0;
gchar *tmp_str;
gchar *doc_name;
pluma_debug (DEBUG_PLUGINS);
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
lines = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc));
calculate_info (doc,
&start, &end,
&chars, &words, &white_chars, &bytes);
if (chars == 0)
lines = 0;
pluma_debug_message (DEBUG_PLUGINS, "Chars: %d", chars);
pluma_debug_message (DEBUG_PLUGINS, "Lines: %d", lines);
pluma_debug_message (DEBUG_PLUGINS, "Words: %d", words);
pluma_debug_message (DEBUG_PLUGINS, "Chars non-space: %d", chars - white_chars);
pluma_debug_message (DEBUG_PLUGINS, "Bytes: %d", bytes);
doc_name = pluma_document_get_short_name_for_display (doc);
tmp_str = g_strdup_printf ("<span weight=\"bold\">%s</span>", doc_name);
gtk_label_set_markup (GTK_LABEL (dialog->file_name_label), tmp_str);
g_free (doc_name);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", lines);
gtk_label_set_text (GTK_LABEL (dialog->lines_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", words);
gtk_label_set_text (GTK_LABEL (dialog->words_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars);
gtk_label_set_text (GTK_LABEL (dialog->chars_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars - white_chars);
gtk_label_set_text (GTK_LABEL (dialog->chars_ns_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", bytes);
gtk_label_set_text (GTK_LABEL (dialog->bytes_label), tmp_str);
g_free (tmp_str);
}
void
pluma_plugins_engine_configure_plugin (PlumaPluginsEngine *engine,
PlumaPluginInfo *info,
GtkWindow *parent)
{
GtkWidget *conf_dlg;
GtkWindowGroup *wg;
pluma_debug (DEBUG_PLUGINS);
g_return_if_fail (info != NULL);
conf_dlg = pluma_plugin_create_configure_dialog (info->plugin);
g_return_if_fail (conf_dlg != NULL);
gtk_window_set_transient_for (GTK_WINDOW (conf_dlg),
parent);
wg = gtk_window_get_group (parent);
if (wg == NULL)
{
wg = gtk_window_group_new ();
gtk_window_group_add_window (wg, parent);
}
gtk_window_group_add_window (wg,
GTK_WINDOW (conf_dlg));
gtk_window_set_modal (GTK_WINDOW (conf_dlg), TRUE);
gtk_widget_show (conf_dlg);
}
void
pluma_plugins_engine_active_plugins_changed (PlumaPluginsEngine *engine)
{
gboolean to_activate;
GSList *active_plugins;
GList *pl;
pluma_debug (DEBUG_PLUGINS);
active_plugins = pluma_prefs_manager_get_active_plugins ();
for (pl = engine->priv->plugin_list; pl; pl = pl->next)
{
PlumaPluginInfo *info = (PlumaPluginInfo*)pl->data;
if (!pluma_plugin_info_is_available (info))
continue;
to_activate = (g_slist_find_custom (active_plugins,
pluma_plugin_info_get_module_name (info),
(GCompareFunc)strcmp) != NULL);
if (!pluma_plugin_info_is_active (info) && to_activate)
g_signal_emit (engine, signals[ACTIVATE_PLUGIN], 0, info);
else if (pluma_plugin_info_is_active (info) && !to_activate)
g_signal_emit (engine, signals[DEACTIVATE_PLUGIN], 0, info);
}
g_slist_foreach (active_plugins, (GFunc) g_free, NULL);
g_slist_free (active_plugins);
}
void
pluma_document_saver_save (PlumaDocumentSaver *saver,
GTimeVal *old_mtime)
{
pluma_debug (DEBUG_SAVER);
g_return_if_fail (PLUMA_IS_DOCUMENT_SAVER (saver));
g_return_if_fail (saver->uri != NULL && strlen (saver->uri) > 0);
g_return_if_fail (saver->used == FALSE);
saver->used = TRUE;
// CHECK:
// - sanity check a max len for the uri?
// report async (in an idle handler) or sync (bool ret)
// async is extra work here, sync is special casing in the caller
/* never keep backup of autosaves */
if ((saver->flags & PLUMA_DOCUMENT_SAVE_PRESERVE_BACKUP) != 0)
saver->keep_backup = FALSE;
else
saver->keep_backup = pluma_prefs_manager_get_create_backup_copy ();
PLUMA_DOCUMENT_SAVER_GET_CLASS (saver)->save (saver, old_mtime);
}
static void
impl_deactivate (PlumaPlugin *plugin,
PlumaWindow *window)
{
PlumaDrawspacesPlugin *ds_plugin = PLUMA_DRAWSPACES_PLUGIN (plugin);
GtkUIManager *manager;
WindowData *data;
pluma_debug (DEBUG_PLUGINS);
data = (WindowData *) g_object_get_data (G_OBJECT (window),
WINDOW_DATA_KEY);
g_return_if_fail (data != NULL);
manager = pluma_window_get_ui_manager (window);
data->enable = FALSE;
draw_spaces_in_window (window, ds_plugin);
g_signal_handlers_disconnect_by_func (window, tab_added_cb, ds_plugin);
gtk_ui_manager_remove_ui (manager, data->ui_id);
gtk_ui_manager_remove_action_group (manager, data->action_group);
g_object_set_data (G_OBJECT (window), WINDOW_DATA_KEY, NULL);
}
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
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);
}
}
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_lockdown_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
PlumaApp *app;
gboolean locked;
pluma_debug (DEBUG_PREFS);
locked = g_settings_get_boolean (settings, key);
app = pluma_app_get_default ();
if (strcmp (key, GPM_LOCKDOWN_COMMAND_LINE) == 0)
_pluma_app_set_lockdown_bit (app,
PLUMA_LOCKDOWN_COMMAND_LINE,
locked);
else if (strcmp (key, GPM_LOCKDOWN_PRINTING) == 0)
_pluma_app_set_lockdown_bit (app,
PLUMA_LOCKDOWN_PRINTING,
locked);
else if (strcmp (key, GPM_LOCKDOWN_PRINT_SETUP) == 0)
_pluma_app_set_lockdown_bit (app,
PLUMA_LOCKDOWN_PRINT_SETUP,
locked);
else if (strcmp (key, GPM_LOCKDOWN_SAVE_TO_DISK) == 0)
_pluma_app_set_lockdown_bit (app,
PLUMA_LOCKDOWN_SAVE_TO_DISK,
locked);
}
static void
pluma_prefs_manager_wrap_mode_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_WRAP_MODE) == 0)
{
GtkWrapMode wrap_mode;
GList *views;
GList *l;
wrap_mode = get_wrap_mode_from_string (g_settings_get_string(settings, key));
views = pluma_app_get_views (pluma_app_get_default ());
l = views;
while (l != NULL)
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (l->data),
wrap_mode);
l = l->next;
}
g_list_free (views);
}
}
static void
pluma_prefs_manager_search_hl_enable_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_SEARCH_HIGHLIGHTING_ENABLE) == 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)
{
g_return_if_fail (PLUMA_IS_DOCUMENT (l->data));
pluma_document_set_enable_search_highlighting (PLUMA_DOCUMENT (l->data),
enable);
l = l->next;
}
g_list_free (docs);
}
}
static void
pluma_prefs_manager_max_recents_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_MAX_RECENTS) == 0)
{
const GList *windows;
gint max;
max = g_settings_get_int (settings, key);
if (max < 0) {
max = GPM_DEFAULT_MAX_RECENTS;
}
windows = pluma_app_get_windows (pluma_app_get_default ());
while (windows != NULL)
{
PlumaWindow *w = windows->data;
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (w->priv->toolbar_recent_menu),
max);
windows = g_list_next (windows);
}
/* FIXME: we have no way at the moment to trigger the
* update of the inline recents in the File menu */
}
}
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
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_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);
}
}
void
pluma_plugins_engine_rescan_plugins (PlumaPluginsEngine *engine)
{
pluma_debug (DEBUG_PLUGINS);
load_all_plugins (engine);
}
void
_pluma_cmd_search_find_prev (GtkAction *action,
PlumaWindow *window)
{
pluma_debug (DEBUG_COMMANDS);
do_find_again (window, TRUE);
}
void
_pluma_cmd_edit_preferences (GtkAction *action,
PlumaWindow *window)
{
pluma_debug (DEBUG_COMMANDS);
pluma_show_preferences_dialog (window);
}
gboolean
pluma_document_loader_cancel (PlumaDocumentLoader *loader)
{
pluma_debug (DEBUG_LOADER);
g_return_val_if_fail (PLUMA_IS_DOCUMENT_LOADER (loader), FALSE);
return PLUMA_DOCUMENT_LOADER_GET_CLASS (loader)->cancel (loader);
}
