704 lines
21 KiB
C
704 lines
21 KiB
C
/*
|
|
* moocompletionsimple.c
|
|
*
|
|
* Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
|
|
*
|
|
* 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 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* See COPYING file that comes with this distribution.
|
|
*/
|
|
|
|
#include "mooedit/moocompletionsimple.h"
|
|
#include "mooedit/mootextpopup.h"
|
|
#include "mooedit/mooedit-script.h"
|
|
#include "mooutils/moomarshals.h"
|
|
#include "mooutils/eggregex.h"
|
|
#include "mooscript/mooscript-parser.h"
|
|
#include <gtk/gtk.h>
|
|
#include <gdk/gdkkeysyms.h>
|
|
#include <string.h>
|
|
|
|
|
|
#define MOO_COMPLETION_VAR_MATCH "match"
|
|
#define MOO_COMPLETION_VAR_COMPLETION "completion"
|
|
|
|
enum {
|
|
COLUMN_DATA,
|
|
COLUMN_GROUP
|
|
};
|
|
|
|
/* same as GCompletionFunc - must not allocate a new string;
|
|
must allow two simultaneous calls */
|
|
typedef char* (*MooCompletionStringFunc) (gpointer data);
|
|
typedef void (*MooCompletionFreeFunc) (gpointer data);
|
|
typedef int (*MooCompletionCmpFunc) (gpointer data1,
|
|
gpointer data2);
|
|
|
|
struct _MooCompletionSimplePrivate {
|
|
GSList *groups;
|
|
GSList *active_groups;
|
|
gboolean groups_found;
|
|
GList *data;
|
|
|
|
MooCompletionStringFunc string_func;
|
|
MooCompletionFreeFunc free_func;
|
|
MooCompletionCmpFunc cmp_func;
|
|
};
|
|
|
|
struct _MooCompletionGroup {
|
|
char *name;
|
|
|
|
EggRegex *regex;
|
|
guint *parens;
|
|
guint n_parens;
|
|
|
|
GCompletion *cmpl;
|
|
GList *data;
|
|
char *suffix;
|
|
MSNode *script;
|
|
|
|
MooCompletionFreeFunc free_func;
|
|
};
|
|
|
|
|
|
static void moo_completion_simple_dispose (GObject *object);
|
|
|
|
static void moo_completion_simple_populate (MooTextCompletion *cmpl,
|
|
GtkTreeModel *model,
|
|
GtkTextIter *cursor,
|
|
const char *text);
|
|
static void moo_completion_simple_complete (MooTextCompletion *cmpl,
|
|
GtkTreeModel *model,
|
|
GtkTreeIter *iter);
|
|
|
|
static int list_sort_func (GtkTreeModel *model,
|
|
GtkTreeIter *a,
|
|
GtkTreeIter *b,
|
|
MooCompletionSimple *cmpl);
|
|
static char *completion_text_func (GtkTreeModel *model,
|
|
GtkTreeIter *iter,
|
|
gpointer data);
|
|
|
|
static MooCompletionSimple *moo_completion_simple_new (MooCompletionStringFunc string_func,
|
|
MooCompletionFreeFunc free_func,
|
|
MooCompletionCmpFunc cmp_func);
|
|
|
|
static MooCompletionGroup *moo_completion_group_new (const char *name,
|
|
MooCompletionStringFunc string_func,
|
|
MooCompletionFreeFunc free_func);
|
|
static void moo_completion_group_free (MooCompletionGroup *group);
|
|
|
|
static gboolean moo_completion_group_find (MooCompletionGroup *group,
|
|
const char *line,
|
|
int *start_pos,
|
|
int *end_pos);
|
|
static GList *moo_completion_group_complete (MooCompletionGroup *group,
|
|
const char *text,
|
|
char **prefix);
|
|
static void moo_completion_simple_finish (MooTextCompletion *cmpl);
|
|
|
|
|
|
G_DEFINE_TYPE (MooCompletionSimple, moo_completion_simple, MOO_TYPE_TEXT_COMPLETION)
|
|
|
|
|
|
static void
|
|
moo_completion_simple_dispose (GObject *object)
|
|
{
|
|
MooCompletionSimple *cmpl = MOO_COMPLETION_SIMPLE (object);
|
|
|
|
if (cmpl->priv)
|
|
{
|
|
g_slist_foreach (cmpl->priv->groups, (GFunc) moo_completion_group_free, NULL);
|
|
g_slist_free (cmpl->priv->groups);
|
|
g_slist_free (cmpl->priv->active_groups);
|
|
g_free (cmpl->priv);
|
|
cmpl->priv = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS(moo_completion_simple_parent_class)->dispose (object);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_class_init (MooCompletionSimpleClass *klass)
|
|
{
|
|
MooTextCompletionClass *cmpl_clas = MOO_TEXT_COMPLETION_CLASS(klass);
|
|
|
|
G_OBJECT_CLASS(klass)->dispose = moo_completion_simple_dispose;
|
|
|
|
cmpl_clas->populate = moo_completion_simple_populate;
|
|
cmpl_clas->finish = moo_completion_simple_finish;
|
|
cmpl_clas->complete = moo_completion_simple_complete;
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_init (MooCompletionSimple *cmpl)
|
|
{
|
|
GtkListStore *store;
|
|
|
|
cmpl->priv = g_new0 (MooCompletionSimplePrivate, 1);
|
|
|
|
store = gtk_list_store_new (2, G_TYPE_POINTER, G_TYPE_POINTER);
|
|
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
|
|
COLUMN_DATA,
|
|
(GtkTreeIterCompareFunc) list_sort_func,
|
|
cmpl, NULL);
|
|
moo_text_completion_set_model (MOO_TEXT_COMPLETION (cmpl),
|
|
GTK_TREE_MODEL (store));
|
|
moo_text_completion_set_text_func (MOO_TEXT_COMPLETION (cmpl),
|
|
completion_text_func, cmpl,
|
|
NULL);
|
|
|
|
g_object_unref (store);
|
|
}
|
|
|
|
|
|
static GtkTextBuffer *
|
|
get_buffer (MooCompletionSimple *cmpl)
|
|
{
|
|
return moo_text_completion_get_buffer (MOO_TEXT_COMPLETION (cmpl));
|
|
}
|
|
|
|
|
|
static char *
|
|
moo_completion_simple_find_groups (MooCompletionSimple *cmpl,
|
|
GtkTextIter *cursor,
|
|
const char *line)
|
|
{
|
|
GSList *l;
|
|
gboolean found = FALSE;
|
|
int start_pos = -1, end_pos = -1;
|
|
char *text = NULL;
|
|
|
|
for (l = cmpl->priv->groups; l != NULL; l = l->next)
|
|
{
|
|
int start_pos_here, end_pos_here;
|
|
MooCompletionGroup *grp = l->data;
|
|
|
|
if (!moo_completion_group_find (grp, line, &start_pos_here, &end_pos_here))
|
|
continue;
|
|
|
|
if (!found)
|
|
{
|
|
found = TRUE;
|
|
start_pos = start_pos_here;
|
|
end_pos = end_pos_here;
|
|
}
|
|
|
|
if (start_pos_here == start_pos && end_pos_here == end_pos)
|
|
cmpl->priv->active_groups =
|
|
g_slist_prepend (cmpl->priv->active_groups, grp);
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
GtkTextIter start, end;
|
|
|
|
cmpl->priv->active_groups = g_slist_reverse (cmpl->priv->active_groups);
|
|
|
|
start = end = *cursor;
|
|
gtk_text_iter_set_line_index (&start, start_pos);
|
|
gtk_text_iter_set_line_index (&end, end_pos);
|
|
text = gtk_text_iter_get_slice (&start, &end);
|
|
|
|
moo_text_completion_set_region (MOO_TEXT_COMPLETION (cmpl), &start, &end);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
|
|
static int
|
|
list_sort_func (GtkTreeModel *model,
|
|
GtkTreeIter *a,
|
|
GtkTreeIter *b,
|
|
MooCompletionSimple *cmpl)
|
|
{
|
|
gpointer data1, data2;
|
|
|
|
g_assert (MOO_IS_COMPLETION_SIMPLE (cmpl));
|
|
g_assert (cmpl->priv->cmp_func != NULL);
|
|
|
|
gtk_tree_model_get (model, a, COLUMN_DATA, &data1, -1);
|
|
gtk_tree_model_get (model, b, COLUMN_DATA, &data2, -1);
|
|
|
|
return cmpl->priv->cmp_func (data1, data2);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_exec_script (MooCompletionSimple *cmpl,
|
|
MooCompletionGroup *group,
|
|
GtkTextIter *start,
|
|
GtkTextIter *end,
|
|
const char *completion)
|
|
{
|
|
MSContext *ctx;
|
|
char *match;
|
|
MSValue *result;
|
|
GtkTextView *doc;
|
|
|
|
doc = moo_text_completion_get_doc (MOO_TEXT_COMPLETION (cmpl));
|
|
ctx = moo_edit_script_context_new (doc, NULL);
|
|
match = gtk_text_iter_get_slice (start, end);
|
|
|
|
ms_context_assign_string (ctx, MOO_COMPLETION_VAR_MATCH, match);
|
|
ms_context_assign_string (ctx, MOO_COMPLETION_VAR_COMPLETION, completion);
|
|
|
|
gtk_text_buffer_delete (get_buffer (cmpl), start, end);
|
|
gtk_text_buffer_place_cursor (get_buffer (cmpl), start);
|
|
result = ms_top_node_eval (group->script, ctx);
|
|
|
|
if (result)
|
|
ms_value_unref (result);
|
|
else
|
|
g_warning ("%s: %s", G_STRLOC,
|
|
ms_context_get_error_msg (ctx));
|
|
|
|
g_free (match);
|
|
g_object_unref (ctx);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_complete (MooTextCompletion *text_cmpl,
|
|
GtkTreeModel *model,
|
|
GtkTreeIter *iter)
|
|
{
|
|
char *text, *old_text;
|
|
GtkTextIter start, end;
|
|
gpointer data = NULL;
|
|
MooCompletionGroup *group = NULL;
|
|
gboolean set_cursor = FALSE;
|
|
MooCompletionSimple *cmpl = MOO_COMPLETION_SIMPLE (text_cmpl);
|
|
|
|
g_return_if_fail (cmpl->priv->active_groups != NULL);
|
|
|
|
gtk_tree_model_get (model, iter, COLUMN_DATA, &data, COLUMN_GROUP, &group, -1);
|
|
g_assert (group != NULL);
|
|
|
|
text = cmpl->priv->string_func ? cmpl->priv->string_func (data) : data;
|
|
g_return_if_fail (text != NULL);
|
|
|
|
moo_text_completion_get_region (MOO_TEXT_COMPLETION (cmpl), &start, &end);
|
|
old_text = gtk_text_iter_get_slice (&start, &end);
|
|
|
|
gtk_text_buffer_begin_user_action (get_buffer (cmpl));
|
|
|
|
if (group->script)
|
|
{
|
|
moo_completion_simple_exec_script (cmpl, group, &start, &end, text);
|
|
}
|
|
else
|
|
{
|
|
if (strcmp (text, old_text))
|
|
{
|
|
gtk_text_buffer_delete (get_buffer (cmpl), &start, &end);
|
|
gtk_text_buffer_insert (get_buffer (cmpl), &start, text, -1);
|
|
set_cursor = TRUE;
|
|
}
|
|
|
|
if (group->suffix)
|
|
{
|
|
gboolean do_insert = TRUE;
|
|
|
|
if (!gtk_text_iter_ends_line (&start))
|
|
{
|
|
char *old_suffix;
|
|
end = start;
|
|
gtk_text_iter_forward_to_line_end (&end);
|
|
old_suffix = gtk_text_iter_get_slice (&start, &end);
|
|
|
|
if (!strncmp (group->suffix, old_suffix, strlen (group->suffix)))
|
|
{
|
|
do_insert = FALSE;
|
|
gtk_text_iter_forward_chars (&start, g_utf8_strlen (group->suffix, -1));
|
|
set_cursor = TRUE;
|
|
}
|
|
|
|
g_free (old_suffix);
|
|
}
|
|
|
|
if (do_insert)
|
|
{
|
|
gtk_text_buffer_insert (get_buffer (cmpl), &start, group->suffix, -1);
|
|
set_cursor = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (set_cursor)
|
|
gtk_text_buffer_place_cursor (get_buffer (cmpl), &start);
|
|
|
|
gtk_text_buffer_end_user_action (get_buffer (cmpl));
|
|
|
|
moo_text_completion_hide (MOO_TEXT_COMPLETION (cmpl));
|
|
|
|
g_free (old_text);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_populate (MooTextCompletion *text_cmpl,
|
|
GtkTreeModel *model,
|
|
GtkTextIter *cursor,
|
|
const char *text)
|
|
{
|
|
GSList *l;
|
|
const char *prefix = text;
|
|
char *freeme = NULL;
|
|
MooCompletionSimple *cmpl = MOO_COMPLETION_SIMPLE (text_cmpl);
|
|
|
|
if (!cmpl->priv->groups_found)
|
|
{
|
|
freeme = moo_completion_simple_find_groups (cmpl, cursor, text);
|
|
|
|
if (!freeme)
|
|
return;
|
|
|
|
cmpl->priv->groups_found = TRUE;
|
|
prefix = freeme;
|
|
}
|
|
|
|
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
|
|
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
|
|
GTK_SORT_ASCENDING);
|
|
|
|
for (l = cmpl->priv->active_groups; l != NULL; l = l->next)
|
|
{
|
|
GList *list;
|
|
MooCompletionGroup *group;
|
|
|
|
group = l->data;
|
|
list = moo_completion_group_complete (group, prefix, NULL);
|
|
|
|
while (list)
|
|
{
|
|
GtkTreeIter iter;
|
|
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
|
|
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
|
|
COLUMN_DATA, list->data,
|
|
COLUMN_GROUP, group,
|
|
-1);
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
if (cmpl->priv->cmp_func)
|
|
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
|
|
COLUMN_DATA, GTK_SORT_ASCENDING);
|
|
|
|
g_free (freeme);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_simple_finish (MooTextCompletion *text_cmpl)
|
|
{
|
|
MooCompletionSimple *cmpl = MOO_COMPLETION_SIMPLE (text_cmpl);
|
|
g_slist_free (cmpl->priv->active_groups);
|
|
cmpl->priv->active_groups = NULL;
|
|
cmpl->priv->groups_found = FALSE;
|
|
}
|
|
|
|
|
|
static MooCompletionSimple *
|
|
moo_completion_simple_new (MooCompletionStringFunc string_func,
|
|
MooCompletionFreeFunc free_func,
|
|
MooCompletionCmpFunc cmp_func)
|
|
{
|
|
MooCompletionSimple *cmpl = g_object_new (MOO_TYPE_COMPLETION_SIMPLE, NULL);
|
|
|
|
cmpl->priv->string_func = string_func;
|
|
cmpl->priv->free_func = free_func;
|
|
cmpl->priv->cmp_func = cmp_func;
|
|
|
|
return cmpl;
|
|
}
|
|
|
|
|
|
static void
|
|
text_cell_data_func (G_GNUC_UNUSED GtkTreeViewColumn *tree_column,
|
|
GtkCellRenderer *cell,
|
|
GtkTreeModel *tree_model,
|
|
GtkTreeIter *iter,
|
|
MooCompletionSimple *cmpl)
|
|
{
|
|
gpointer data = NULL;
|
|
char *text;
|
|
|
|
g_assert (MOO_IS_COMPLETION_SIMPLE (cmpl));
|
|
|
|
gtk_tree_model_get (tree_model, iter, 0, &data, -1);
|
|
text = cmpl->priv->string_func ? cmpl->priv->string_func (data) : data;
|
|
g_return_if_fail (text != NULL);
|
|
|
|
g_object_set (cell, "text", text, NULL);
|
|
}
|
|
|
|
static char *
|
|
completion_text_func (GtkTreeModel *model,
|
|
GtkTreeIter *iter,
|
|
gpointer user_data)
|
|
{
|
|
MooCompletionSimple *cmpl = user_data;
|
|
gpointer data = NULL;
|
|
char *text;
|
|
|
|
gtk_tree_model_get (model, iter, 0, &data, -1);
|
|
text = cmpl->priv->string_func ? cmpl->priv->string_func (data) : data;
|
|
g_return_val_if_fail (text != NULL, NULL);
|
|
|
|
return g_strdup (text);
|
|
}
|
|
|
|
|
|
MooTextCompletion *
|
|
moo_completion_simple_new_text (GList *words)
|
|
{
|
|
MooCompletionSimple *cmpl;
|
|
GtkCellRenderer *cell;
|
|
MooTextPopup *popup;
|
|
|
|
cmpl = moo_completion_simple_new (NULL, g_free, (MooCompletionCmpFunc) strcmp);
|
|
|
|
if (words)
|
|
{
|
|
MooCompletionGroup *group = moo_completion_simple_new_group (cmpl, NULL);
|
|
moo_completion_group_add_data (group, words);
|
|
moo_completion_group_set_pattern (group, "\\w*", NULL, 0);
|
|
}
|
|
|
|
popup = moo_text_completion_get_popup (MOO_TEXT_COMPLETION (cmpl));
|
|
cell = gtk_cell_renderer_text_new ();
|
|
gtk_cell_layout_clear (GTK_CELL_LAYOUT (popup->column));
|
|
gtk_tree_view_column_pack_start (popup->column, cell, TRUE);
|
|
gtk_tree_view_column_set_cell_data_func (popup->column, cell,
|
|
(GtkTreeCellDataFunc) text_cell_data_func,
|
|
g_object_ref (cmpl),
|
|
g_object_unref);
|
|
|
|
return MOO_TEXT_COMPLETION (cmpl);
|
|
}
|
|
|
|
|
|
MooCompletionGroup *
|
|
moo_completion_simple_new_group (MooCompletionSimple *cmpl,
|
|
const char *name)
|
|
{
|
|
MooCompletionGroup *group;
|
|
|
|
g_return_val_if_fail (MOO_IS_COMPLETION_SIMPLE (cmpl), NULL);
|
|
|
|
group = moo_completion_group_new (name,
|
|
cmpl->priv->string_func,
|
|
cmpl->priv->free_func);
|
|
cmpl->priv->groups = g_slist_append (cmpl->priv->groups, group);
|
|
|
|
return group;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MooCompletionGroup
|
|
*/
|
|
|
|
MooCompletionGroup *
|
|
moo_completion_group_new (const char *name,
|
|
MooCompletionStringFunc string_func,
|
|
MooCompletionFreeFunc free_func)
|
|
{
|
|
MooCompletionGroup *group = g_new0 (MooCompletionGroup, 1);
|
|
group->cmpl = g_completion_new (string_func);
|
|
group->free_func = free_func;
|
|
group->name = g_strdup (name);
|
|
return group;
|
|
}
|
|
|
|
|
|
void
|
|
moo_completion_group_add_data (MooCompletionGroup *group,
|
|
GList *data)
|
|
{
|
|
g_return_if_fail (group != NULL);
|
|
|
|
if (!data)
|
|
return;
|
|
|
|
g_completion_clear_items (group->cmpl);
|
|
group->data = g_list_concat (group->data, data);
|
|
g_completion_add_items (group->cmpl, group->data);
|
|
}
|
|
|
|
|
|
static gboolean
|
|
moo_completion_group_find (MooCompletionGroup *group,
|
|
const char *line,
|
|
int *start_pos_p,
|
|
int *end_pos_p)
|
|
{
|
|
g_return_val_if_fail (group != NULL, FALSE);
|
|
g_return_val_if_fail (line != NULL, FALSE);
|
|
g_return_val_if_fail (group->regex != NULL, FALSE);
|
|
|
|
egg_regex_clear (group->regex);
|
|
|
|
if (egg_regex_match (group->regex, line, 0) >= 1)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < group->n_parens; ++i)
|
|
{
|
|
int start_pos = -1, end_pos = -1;
|
|
|
|
egg_regex_fetch_pos (group->regex, group->parens[i],
|
|
&start_pos, &end_pos);
|
|
|
|
if (start_pos >= 0 && end_pos >= 0)
|
|
{
|
|
if (start_pos_p)
|
|
*start_pos_p = start_pos;
|
|
if (end_pos_p)
|
|
*end_pos_p = end_pos;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
static GList *
|
|
moo_completion_group_complete (MooCompletionGroup *group,
|
|
const char *text,
|
|
char **prefix)
|
|
{
|
|
char *dummy = NULL;
|
|
GList *list;
|
|
|
|
if (!prefix)
|
|
prefix = &dummy;
|
|
|
|
/* g_completion_complete_utf8 wants prefix != NULL */
|
|
list = g_completion_complete_utf8 (group->cmpl, text, prefix);
|
|
|
|
g_free (dummy);
|
|
return list;
|
|
}
|
|
|
|
|
|
void
|
|
moo_completion_group_set_pattern (MooCompletionGroup *group,
|
|
const char *pattern,
|
|
const guint *parens,
|
|
guint n_parens)
|
|
{
|
|
EggRegex *regex;
|
|
GError *error = NULL;
|
|
char *real_pattern;
|
|
|
|
g_return_if_fail (group != NULL);
|
|
g_return_if_fail (pattern && pattern[0]);
|
|
g_return_if_fail (!parens || n_parens);
|
|
|
|
real_pattern = g_strdup_printf ("%s$", pattern);
|
|
regex = egg_regex_new (real_pattern, 0, 0, &error);
|
|
|
|
if (!regex)
|
|
{
|
|
g_warning ("%s: %s", G_STRLOC, error->message);
|
|
goto err;
|
|
}
|
|
|
|
egg_regex_optimize (regex, &error);
|
|
|
|
if (error)
|
|
{
|
|
g_warning ("%s: %s", G_STRLOC, error->message);
|
|
g_error_free (error);
|
|
}
|
|
|
|
egg_regex_free (group->regex);
|
|
group->regex = regex;
|
|
|
|
g_free (group->parens);
|
|
|
|
if (!parens)
|
|
{
|
|
group->parens = g_new0 (guint, 1);
|
|
group->n_parens = 1;
|
|
}
|
|
else
|
|
{
|
|
group->parens = g_memdup (parens, n_parens * sizeof (guint));
|
|
group->n_parens = n_parens;
|
|
}
|
|
|
|
g_free (real_pattern);
|
|
return;
|
|
|
|
err:
|
|
if (error)
|
|
g_error_free (error);
|
|
g_free (real_pattern);
|
|
egg_regex_free (regex);
|
|
}
|
|
|
|
|
|
void
|
|
moo_completion_group_set_suffix (MooCompletionGroup *group,
|
|
const char *suffix)
|
|
{
|
|
g_return_if_fail (group != NULL);
|
|
|
|
if (group->suffix != suffix)
|
|
{
|
|
g_free (group->suffix);
|
|
group->suffix = (suffix && suffix[0]) ? g_strdup (suffix) : NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
moo_completion_group_set_script (MooCompletionGroup *group,
|
|
const char *script)
|
|
{
|
|
g_return_if_fail (group != NULL);
|
|
|
|
if (group->script)
|
|
{
|
|
ms_node_unref (group->script);
|
|
group->script = NULL;
|
|
}
|
|
|
|
if (script)
|
|
group->script = ms_script_parse (script);
|
|
}
|
|
|
|
|
|
static void
|
|
moo_completion_group_free (MooCompletionGroup *group)
|
|
{
|
|
g_return_if_fail (group != NULL);
|
|
|
|
egg_regex_free (group->regex);
|
|
g_free (group->parens);
|
|
g_completion_free (group->cmpl);
|
|
g_free (group->suffix);
|
|
g_free (group->name);
|
|
|
|
if (group->script)
|
|
ms_node_unref (group->script);
|
|
|
|
if (group->free_func)
|
|
g_list_foreach (group->data, (GFunc) group->free_func, NULL);
|
|
g_list_free (group->data);
|
|
|
|
g_free (group);
|
|
}
|