xed/plugins/sort/pluma-sort-plugin.c

589 lines
13 KiB
C
Raw Normal View History

2011-11-07 13:46:58 -06:00
/*
2011-11-07 16:52:18 -06:00
* pluma-sort-plugin.c
2011-11-07 18:10:16 -06:00
*
2011-11-07 13:46:58 -06:00
* Original author: Carlo Borreo <borreo@softhome.net>
2011-11-07 16:52:18 -06:00
* Ported to Pluma2 by Lee Mallabone <mate@fonicmonkey.net>
2011-11-07 13:46:58 -06:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
2011-11-07 18:10:16 -06:00
*
2011-11-07 13:46:58 -06:00
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
2012-11-18 19:54:49 -06:00
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
2011-11-07 13:46:58 -06:00
*
* $Id$
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
2011-11-07 16:52:18 -06:00
#include "pluma-sort-plugin.h"
2011-11-07 13:46:58 -06:00
#include <string.h>
#include <glib/gi18n-lib.h>
#include <gmodule.h>
2011-11-07 16:52:18 -06:00
#include <pluma/pluma-debug.h>
#include <pluma/pluma-utils.h>
#include <pluma/pluma-help.h>
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
#define PLUMA_SORT_PLUGIN_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), PLUMA_TYPE_SORT_PLUGIN, PlumaSortPluginPrivate))
2011-11-07 13:46:58 -06:00
/* Key in case the plugin ever needs any settings. */
2011-11-07 18:10:16 -06:00
#define SORT_BASE_KEY "/apps/pluma/plugins/sort"
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
#define WINDOW_DATA_KEY "PlumaSortPluginWindowData"
2011-11-07 13:46:58 -06:00
#define MENU_PATH "/MenuBar/EditMenu/EditOps_6"
2011-11-07 16:52:18 -06:00
PLUMA_PLUGIN_REGISTER_TYPE(PlumaSortPlugin, pluma_sort_plugin)
2011-11-07 13:46:58 -06:00
typedef struct
{
GtkWidget *dialog;
GtkWidget *col_num_spinbutton;
GtkWidget *reverse_order_checkbutton;
GtkWidget *ignore_case_checkbutton;
GtkWidget *remove_dups_checkbutton;
2011-11-07 16:52:18 -06:00
PlumaDocument *doc;
2011-11-07 13:46:58 -06:00
GtkTextIter start, end; /* selection */
} SortDialog;
typedef struct
{
GtkActionGroup *ui_action_group;
guint ui_id;
} WindowData;
typedef struct
{
2011-11-07 16:52:18 -06:00
PlumaPlugin *plugin;
PlumaWindow *window;
2011-11-07 13:46:58 -06:00
} ActionData;
typedef struct
{
gboolean ignore_case;
gboolean reverse_order;
gboolean remove_duplicates;
gint starting_column;
} SortInfo;
static void sort_cb (GtkAction *action, ActionData *action_data);
static void sort_real (SortDialog *dialog);
static const GtkActionEntry action_entries[] =
{
{ "Sort",
GTK_STOCK_SORT_ASCENDING,
N_("S_ort..."),
NULL,
N_("Sort the current document or selection"),
G_CALLBACK (sort_cb) }
};
static void
2013-10-30 10:20:47 -05:00
sort_dialog_dispose (GObject *obj,
2011-11-07 13:46:58 -06:00
gpointer dialog_pointer)
{
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
g_slice_free (SortDialog, dialog_pointer);
}
static void
sort_dialog_response_handler (GtkDialog *widget,
gint res_id,
SortDialog *dialog)
{
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
switch (res_id)
{
case GTK_RESPONSE_OK:
sort_real (dialog);
gtk_widget_destroy (dialog->dialog);
break;
case GTK_RESPONSE_HELP:
2011-11-07 16:52:18 -06:00
pluma_help_display (GTK_WINDOW (widget),
2011-11-07 13:46:58 -06:00
NULL,
2011-11-07 16:52:18 -06:00
"pluma-sort-plugin");
2011-11-07 13:46:58 -06:00
break;
case GTK_RESPONSE_CANCEL:
gtk_widget_destroy (dialog->dialog);
break;
}
}
/* NOTE: we store the current selection in the dialog since focusing
* the text field (like the combo box) looses the documnent selection.
* Storing the selection ONLY works because the dialog is modal */
static void
2011-11-07 16:52:18 -06:00
get_current_selection (PlumaWindow *window, SortDialog *dialog)
2011-11-07 13:46:58 -06:00
{
2011-11-07 16:52:18 -06:00
PlumaDocument *doc;
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
doc = pluma_window_get_active_document (window);
2011-11-07 13:46:58 -06:00
if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&dialog->start,
&dialog->end))
{
/* No selection, get the whole document. */
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&dialog->start,
&dialog->end);
}
}
static SortDialog *
get_sort_dialog (ActionData *action_data)
{
SortDialog *dialog;
GtkWidget *error_widget;
gboolean ret;
gchar *data_dir;
gchar *ui_file;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
dialog = g_slice_new (SortDialog);
2011-11-07 16:52:18 -06:00
data_dir = pluma_plugin_get_data_dir (action_data->plugin);
2011-11-07 13:46:58 -06:00
ui_file = g_build_filename (data_dir, "sort.ui", NULL);
g_free (data_dir);
2011-11-07 16:52:18 -06:00
ret = pluma_utils_get_ui_objects (ui_file,
2011-11-07 13:46:58 -06:00
NULL,
&error_widget,
"sort_dialog", &dialog->dialog,
"reverse_order_checkbutton", &dialog->reverse_order_checkbutton,
"col_num_spinbutton", &dialog->col_num_spinbutton,
"ignore_case_checkbutton", &dialog->ignore_case_checkbutton,
"remove_dups_checkbutton", &dialog->remove_dups_checkbutton,
NULL);
g_free (ui_file);
if (!ret)
{
const gchar *err_message;
err_message = gtk_label_get_label (GTK_LABEL (error_widget));
2011-11-07 16:52:18 -06:00
pluma_warning (GTK_WINDOW (action_data->window),
2011-11-07 13:46:58 -06:00
"%s", err_message);
g_free (dialog);
gtk_widget_destroy (error_widget);
return NULL;
}
gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog),
GTK_RESPONSE_OK);
g_signal_connect (dialog->dialog,
2013-10-30 10:20:47 -05:00
"dispose",
G_CALLBACK (sort_dialog_dispose),
2011-11-07 13:46:58 -06:00
dialog);
g_signal_connect (dialog->dialog,
"response",
G_CALLBACK (sort_dialog_response_handler),
dialog);
get_current_selection (action_data->window, dialog);
return dialog;
}
static void
sort_cb (GtkAction *action,
ActionData *action_data)
{
2011-11-07 16:52:18 -06:00
PlumaDocument *doc;
2011-11-07 13:46:58 -06:00
GtkWindowGroup *wg;
SortDialog *dialog;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
doc = pluma_window_get_active_document (action_data->window);
2011-11-07 13:46:58 -06:00
g_return_if_fail (doc != NULL);
dialog = get_sort_dialog (action_data);
g_return_if_fail (dialog != NULL);
2011-11-07 16:52:18 -06:00
wg = pluma_window_get_group (action_data->window);
2011-11-07 13:46:58 -06:00
gtk_window_group_add_window (wg,
GTK_WINDOW (dialog->dialog));
dialog->doc = doc;
gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog),
GTK_WINDOW (action_data->window));
2011-11-07 18:10:16 -06:00
2011-11-07 13:46:58 -06:00
gtk_window_set_modal (GTK_WINDOW (dialog->dialog),
TRUE);
gtk_widget_show (GTK_WIDGET (dialog->dialog));
}
/* Compares two strings for the sorting algorithm. Uses the UTF-8 processing
* functions in GLib to be as correct as possible.*/
static gint
compare_algorithm (gconstpointer s1,
gconstpointer s2,
gpointer data)
{
gint length1, length2;
gint ret;
gchar *string1, *string2;
gchar *substring1, *substring2;
gchar *key1, *key2;
SortInfo *sort_info;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
sort_info = (SortInfo *) data;
g_return_val_if_fail (sort_info != NULL, -1);
if (!sort_info->ignore_case)
{
string1 = *((gchar **) s1);
string2 = *((gchar **) s2);
}
else
{
string1 = g_utf8_casefold (*((gchar **) s1), -1);
string2 = g_utf8_casefold (*((gchar **) s2), -1);
}
length1 = g_utf8_strlen (string1, -1);
length2 = g_utf8_strlen (string2, -1);
if ((length1 < sort_info->starting_column) &&
(length2 < sort_info->starting_column))
{
ret = 0;
}
else if (length1 < sort_info->starting_column)
{
ret = -1;
}
else if (length2 < sort_info->starting_column)
{
ret = 1;
}
else if (sort_info->starting_column < 1)
{
key1 = g_utf8_collate_key (string1, -1);
key2 = g_utf8_collate_key (string2, -1);
ret = strcmp (key1, key2);
g_free (key1);
g_free (key2);
}
else
{
/* A character column offset is required, so figure out
* the correct offset into the UTF-8 string. */
substring1 = g_utf8_offset_to_pointer (string1, sort_info->starting_column);
substring2 = g_utf8_offset_to_pointer (string2, sort_info->starting_column);
key1 = g_utf8_collate_key (substring1, -1);
key2 = g_utf8_collate_key (substring2, -1);
ret = strcmp (key1, key2);
g_free (key1);
g_free (key2);
}
/* Do the necessary cleanup. */
if (sort_info->ignore_case)
{
g_free (string1);
g_free (string2);
}
if (sort_info->reverse_order)
{
ret = -1 * ret;
}
return ret;
}
static gchar *
get_line_slice (GtkTextBuffer *buf,
gint line)
{
GtkTextIter start, end;
char *ret;
gtk_text_buffer_get_iter_at_line (buf, &start, line);
end = start;
if (!gtk_text_iter_ends_line (&start))
gtk_text_iter_forward_to_line_end (&end);
ret= gtk_text_buffer_get_slice (buf,
&start,
&end,
TRUE);
g_assert (ret != NULL);
return ret;
}
static void
sort_real (SortDialog *dialog)
{
2011-11-07 16:52:18 -06:00
PlumaDocument *doc;
2011-11-07 13:46:58 -06:00
GtkTextIter start, end;
gint start_line, end_line;
gint i;
gchar *last_row = NULL;
gint num_lines;
gchar **lines;
SortInfo *sort_info;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
doc = dialog->doc;
g_return_if_fail (doc != NULL);
sort_info = g_new0 (SortInfo, 1);
sort_info->ignore_case = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->ignore_case_checkbutton));
sort_info->reverse_order = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->reverse_order_checkbutton));
sort_info->remove_duplicates = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->remove_dups_checkbutton));
sort_info->starting_column = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->col_num_spinbutton)) - 1;
start = dialog->start;
end = dialog->end;
start_line = gtk_text_iter_get_line (&start);
end_line = gtk_text_iter_get_line (&end);
/* if we are at line start our last line is the previus one.
* Otherwise the last line is the current one but we try to
* move the iter after the line terminator */
if (gtk_text_iter_get_line_offset (&end) == 0)
end_line = MAX (start_line, end_line - 1);
else
gtk_text_iter_forward_line (&end);
num_lines = end_line - start_line + 1;
lines = g_new0 (gchar *, num_lines + 1);
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "Building list...");
2011-11-07 13:46:58 -06:00
for (i = 0; i < num_lines; i++)
{
lines[i] = get_line_slice (GTK_TEXT_BUFFER (doc), start_line + i);
}
lines[num_lines] = NULL;
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "Sort list...");
2011-11-07 13:46:58 -06:00
g_qsort_with_data (lines,
num_lines,
sizeof (gpointer),
compare_algorithm,
sort_info);
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "Rebuilding document...");
2011-11-07 13:46:58 -06:00
gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (doc));
gtk_text_buffer_delete (GTK_TEXT_BUFFER (doc),
&start,
&end);
for (i = 0; i < num_lines; i++)
{
if (sort_info->remove_duplicates &&
last_row != NULL &&
(strcmp (last_row, lines[i]) == 0))
continue;
gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc),
&start,
lines[i],
-1);
gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc),
&start,
"\n",
-1);
last_row = lines[i];
}
gtk_source_buffer_end_not_undoable_action (GTK_SOURCE_BUFFER (doc));
g_strfreev (lines);
g_free (sort_info);
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "Done.");
2011-11-07 13:46:58 -06:00
}
static void
free_window_data (WindowData *data)
{
g_return_if_fail (data != NULL);
g_object_unref (data->ui_action_group);
g_slice_free (WindowData, data);
}
static void
free_action_data (ActionData *data)
{
g_return_if_fail (data != NULL);
g_slice_free (ActionData, data);
}
static void
2011-11-07 16:52:18 -06:00
update_ui_real (PlumaWindow *window,
2011-11-07 13:46:58 -06:00
WindowData *data)
{
2011-11-07 16:52:18 -06:00
PlumaView *view;
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
view = pluma_window_get_active_view (window);
2011-11-07 13:46:58 -06:00
gtk_action_group_set_sensitive (data->ui_action_group,
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
}
static void
2011-11-07 16:52:18 -06:00
impl_activate (PlumaPlugin *plugin,
PlumaWindow *window)
2011-11-07 13:46:58 -06:00
{
GtkUIManager *manager;
WindowData *data;
ActionData *action_data;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
data = g_slice_new (WindowData);
action_data = g_slice_new (ActionData);
action_data->window = window;
action_data->plugin = plugin;
2011-11-07 16:52:18 -06:00
manager = pluma_window_get_ui_manager (window);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
data->ui_action_group = gtk_action_group_new ("PlumaSortPluginActions");
2011-11-07 18:10:16 -06:00
gtk_action_group_set_translation_domain (data->ui_action_group,
2011-11-07 13:46:58 -06:00
GETTEXT_PACKAGE);
gtk_action_group_add_actions_full (data->ui_action_group,
action_entries,
G_N_ELEMENTS (action_entries),
action_data,
(GDestroyNotify) free_action_data);
gtk_ui_manager_insert_action_group (manager,
data->ui_action_group,
-1);
data->ui_id = gtk_ui_manager_new_merge_id (manager);
2011-11-07 18:10:16 -06:00
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
2011-11-07 13:46:58 -06:00
data,
(GDestroyNotify) free_window_data);
2011-11-07 18:10:16 -06:00
gtk_ui_manager_add_ui (manager,
data->ui_id,
2011-11-07 13:46:58 -06:00
MENU_PATH,
"Sort",
2011-11-07 18:10:16 -06:00
"Sort",
GTK_UI_MANAGER_MENUITEM,
2011-11-07 13:46:58 -06:00
FALSE);
update_ui_real (window,
data);
}
static void
2011-11-07 16:52:18 -06:00
impl_deactivate (PlumaPlugin *plugin,
PlumaWindow *window)
2011-11-07 13:46:58 -06:00
{
GtkUIManager *manager;
WindowData *data;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
manager = pluma_window_get_ui_manager (window);
2011-11-07 13:46:58 -06:00
data = (WindowData *) g_object_get_data (G_OBJECT (window),
WINDOW_DATA_KEY);
g_return_if_fail (data != NULL);
gtk_ui_manager_remove_ui (manager,
data->ui_id);
gtk_ui_manager_remove_action_group (manager,
data->ui_action_group);
g_object_set_data (G_OBJECT (window),
WINDOW_DATA_KEY,
NULL);
}
static void
2011-11-07 16:52:18 -06:00
impl_update_ui (PlumaPlugin *plugin,
PlumaWindow *window)
2011-11-07 13:46:58 -06:00
{
WindowData *data;
2011-11-07 16:52:18 -06:00
pluma_debug (DEBUG_PLUGINS);
2011-11-07 13:46:58 -06:00
data = (WindowData *) g_object_get_data (G_OBJECT (window),
WINDOW_DATA_KEY);
g_return_if_fail (data != NULL);
update_ui_real (window,
data);
}
static void
2011-11-07 16:52:18 -06:00
pluma_sort_plugin_init (PlumaSortPlugin *plugin)
2011-11-07 13:46:58 -06:00
{
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "PlumaSortPlugin initializing");
2011-11-07 13:46:58 -06:00
}
static void
2011-11-07 16:52:18 -06:00
pluma_sort_plugin_finalize (GObject *object)
2011-11-07 13:46:58 -06:00
{
2011-11-07 16:52:18 -06:00
pluma_debug_message (DEBUG_PLUGINS, "PlumaSortPlugin finalizing");
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
G_OBJECT_CLASS (pluma_sort_plugin_parent_class)->finalize (object);
2011-11-07 13:46:58 -06:00
}
static void
2011-11-07 16:52:18 -06:00
pluma_sort_plugin_class_init (PlumaSortPluginClass *klass)
2011-11-07 13:46:58 -06:00
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
2011-11-07 16:52:18 -06:00
PlumaPluginClass *plugin_class = PLUMA_PLUGIN_CLASS (klass);
2011-11-07 13:46:58 -06:00
2011-11-07 16:52:18 -06:00
object_class->finalize = pluma_sort_plugin_finalize;
2011-11-07 13:46:58 -06:00
plugin_class->activate = impl_activate;
plugin_class->deactivate = impl_deactivate;
plugin_class->update_ui = impl_update_ui;
}