dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/widgets/gimptagentry.c

2203 lines
64 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptagentry.c
* Copyright (C) 2008 Aurimas Juška <aurisj@svn.gnome.org>
*
* 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 3 of the License, or
* (at your option) any later version.
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimp-utils.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimptag.h"
#include "core/gimptagged.h"
#include "core/gimptaggedcontainer.h"
#include "core/gimpviewable.h"
#include "gimptagentry.h"
#include "gimp-intl.h"
#define GIMP_TAG_ENTRY_QUERY_DESC _("filter")
#define GIMP_TAG_ENTRY_ASSIGN_DESC _("enter tags")
#define GIMP_TAG_ENTRY_MAX_RECENT_ITEMS 20
typedef enum
{
TAG_SEARCH_NONE,
TAG_SEARCH_LEFT,
TAG_SEARCH_RIGHT,
} GimpTagSearchDir;
enum
{
PROP_0,
PROP_CONTAINER,
PROP_MODE
};
static void gimp_tag_entry_dispose (GObject *object);
static void gimp_tag_entry_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_tag_entry_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_tag_entry_activate (GtkEntry *entry);
static void gimp_tag_entry_changed (GtkEntry *entry);
static void gimp_tag_entry_insert_text (GtkEditable *editable,
gchar *new_text,
gint text_length,
gint *position);
static void gimp_tag_entry_delete_text (GtkEditable *editable,
gint start_pos,
gint end_pos);
static gboolean gimp_tag_entry_focus_in (GtkWidget *widget,
GdkEventFocus *event);
static gboolean gimp_tag_entry_focus_out (GtkWidget *widget,
GdkEventFocus *event);
static void gimp_tag_entry_container_changed (GimpContainer *container,
GimpObject *object,
GimpTagEntry *entry);
static gboolean gimp_tag_entry_button_release (GtkWidget *widget,
GdkEventButton *event);
static gboolean gimp_tag_entry_key_press (GtkWidget *widget,
GdkEventKey *event);
static gboolean gimp_tag_entry_query_tag (GimpTagEntry *entry);
static void gimp_tag_entry_assign_tags (GimpTagEntry *entry);
static void gimp_tag_entry_load_selection (GimpTagEntry *entry,
gboolean sort);
static void gimp_tag_entry_find_common_tags (gpointer key,
gpointer value,
gpointer user_data);
static gchar * gimp_tag_entry_get_completion_prefix (GimpTagEntry *entry);
static GList * gimp_tag_entry_get_completion_candidates (GimpTagEntry *entry,
gchar **used_tags,
gchar *prefix);
static gchar * gimp_tag_entry_get_completion_string (GimpTagEntry *entry,
GList *candidates,
gchar *prefix);
static gboolean gimp_tag_entry_auto_complete (GimpTagEntry *entry);
static void gimp_tag_entry_toggle_desc (GimpTagEntry *widget,
gboolean show);
static gboolean gimp_tag_entry_expose (GtkWidget *widget,
GdkEventExpose *event);
static void gimp_tag_entry_commit_region (GString *tags,
GString *mask);
static void gimp_tag_entry_commit_tags (GimpTagEntry *entry);
static gboolean gimp_tag_entry_commit_source_func (GimpTagEntry *entry);
static gboolean gimp_tag_entry_select_jellybean (GimpTagEntry *entry,
gint selection_start,
gint selection_end,
GimpTagSearchDir search_dir);
static gboolean gimp_tag_entry_try_select_jellybean (GimpTagEntry *entry);
static gboolean gimp_tag_entry_add_to_recent (GimpTagEntry *entry,
const gchar *tags_string,
gboolean to_front);
static void gimp_tag_entry_next_tag (GimpTagEntry *entry,
gboolean select);
static void gimp_tag_entry_previous_tag (GimpTagEntry *entry,
gboolean select);
static void gimp_tag_entry_select_for_deletion (GimpTagEntry *entry,
GimpTagSearchDir search_dir);
static gboolean gimp_tag_entry_strip_extra_whitespace (GimpTagEntry *entry);
G_DEFINE_TYPE (GimpTagEntry, gimp_tag_entry, GTK_TYPE_ENTRY)
#define parent_class gimp_tag_entry_parent_class
static void
gimp_tag_entry_class_init (GimpTagEntryClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->dispose = gimp_tag_entry_dispose;
object_class->get_property = gimp_tag_entry_get_property;
object_class->set_property = gimp_tag_entry_set_property;
widget_class->button_release_event = gimp_tag_entry_button_release;
g_object_class_install_property (object_class,
PROP_CONTAINER,
g_param_spec_object ("container",
"Tagged container",
"The Tagged container",
GIMP_TYPE_TAGGED_CONTAINER,
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MODE,
g_param_spec_enum ("mode",
"Working mode",
"Mode in which to work.",
GIMP_TYPE_TAG_ENTRY_MODE,
GIMP_TAG_ENTRY_MODE_QUERY,
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_READWRITE));
}
static void
gimp_tag_entry_init (GimpTagEntry *entry)
{
entry->container = NULL;
entry->selected_items = NULL;
entry->common_tags = NULL;
entry->tab_completion_index = -1;
entry->mode = GIMP_TAG_ENTRY_MODE_QUERY;
entry->description_shown = FALSE;
entry->has_invalid_tags = FALSE;
entry->mask = g_string_new ("");
g_signal_connect (entry, "activate",
G_CALLBACK (gimp_tag_entry_activate),
NULL);
g_signal_connect (entry, "changed",
G_CALLBACK (gimp_tag_entry_changed),
NULL);
g_signal_connect (entry, "insert-text",
G_CALLBACK (gimp_tag_entry_insert_text),
NULL);
g_signal_connect (entry, "delete-text",
G_CALLBACK (gimp_tag_entry_delete_text),
NULL);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (gimp_tag_entry_key_press),
NULL);
g_signal_connect (entry, "focus-in-event",
G_CALLBACK (gimp_tag_entry_focus_in),
NULL);
g_signal_connect (entry, "focus-out-event",
G_CALLBACK (gimp_tag_entry_focus_out),
NULL);
g_signal_connect_after (entry, "expose-event",
G_CALLBACK (gimp_tag_entry_expose),
NULL);
}
static void
gimp_tag_entry_dispose (GObject *object)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (object);
if (entry->selected_items)
{
g_list_free (entry->selected_items);
entry->selected_items = NULL;
}
if (entry->common_tags)
{
g_list_free_full (entry->common_tags, (GDestroyNotify) g_object_unref);
entry->common_tags = NULL;
}
if (entry->recent_list)
{
g_list_free_full (entry->recent_list, (GDestroyNotify) g_free);
entry->recent_list = NULL;
}
if (entry->container)
{
g_signal_handlers_disconnect_by_func (entry->container,
gimp_tag_entry_container_changed,
entry);
g_object_unref (entry->container);
entry->container = NULL;
}
if (entry->mask)
{
g_string_free (entry->mask, TRUE);
entry->mask = NULL;
}
if (entry->tag_query_idle_id)
{
g_source_remove (entry->tag_query_idle_id);
entry->tag_query_idle_id = 0;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_tag_entry_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (object);
switch (property_id)
{
case PROP_CONTAINER:
entry->container = g_value_dup_object (value);
g_signal_connect (entry->container, "add",
G_CALLBACK (gimp_tag_entry_container_changed),
entry);
g_signal_connect (entry->container, "remove",
G_CALLBACK (gimp_tag_entry_container_changed),
entry);
break;
case PROP_MODE:
entry->mode = g_value_get_enum (value);
gimp_tag_entry_toggle_desc (entry, TRUE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tag_entry_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (object);
switch (property_id)
{
case PROP_CONTAINER:
g_value_set_object (value, entry->container);
break;
case PROP_MODE:
g_value_set_enum (value, entry->mode);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/**
* gimp_tag_entry_new:
* @container: a #GimpTaggedContainer object
* @mode: #GimpTagEntryMode to work in.
*
* #GimpTagEntry is a widget which can query and assign tags to tagged objects.
* When operating in query mode, @container is kept up to date with
* tags selected. When operating in assignment mode, tags are assigned to
* objects selected and visible in @container.
*
* Return value: a new GimpTagEntry widget.
**/
GtkWidget *
gimp_tag_entry_new (GimpTaggedContainer *container,
GimpTagEntryMode mode)
{
g_return_val_if_fail (GIMP_IS_TAGGED_CONTAINER (container), NULL);
return g_object_new (GIMP_TYPE_TAG_ENTRY,
"container", container,
"mode", mode,
NULL);
}
static void
gimp_tag_entry_activate (GtkEntry *entry)
{
GimpTagEntry *tag_entry = GIMP_TAG_ENTRY (entry);
gint selection_start;
gint selection_end;
GList *list;
gimp_tag_entry_toggle_desc (tag_entry, FALSE);
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
if (selection_start != selection_end)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_end, selection_end);
}
for (list = tag_entry->selected_items; list; list = g_list_next (list))
{
if (gimp_container_have (GIMP_CONTAINER (tag_entry->container),
GIMP_OBJECT (list->data)))
{
break;
}
}
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN && list)
{
gimp_tag_entry_assign_tags (GIMP_TAG_ENTRY (entry));
}
}
/**
* gimp_tag_entry_set_tag_string:
* @entry: a #GimpTagEntry object.
* @tag_string: string of tags, separated by any terminal punctuation
* character.
*
* Sets tags from @tag_string to @tag_entry. Given tags do not need to
* be valid as they can be fixed or dropped automatically. Depending on
* selected #GimpTagEntryMode, appropriate action is performed.
**/
void
gimp_tag_entry_set_tag_string (GimpTagEntry *entry,
const gchar *tag_string)
{
g_return_if_fail (GIMP_IS_TAG_ENTRY (entry));
entry->internal_operation++;
entry->suppress_tag_query++;
gtk_entry_set_text (GTK_ENTRY (entry), tag_string);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
entry->suppress_tag_query--;
entry->internal_operation--;
gimp_tag_entry_commit_tags (entry);
if (entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN)
{
gimp_tag_entry_assign_tags (entry);
}
else if (entry->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{
gimp_tag_entry_query_tag (entry);
}
}
static void
gimp_tag_entry_changed (GtkEntry *entry)
{
GimpTagEntry *tag_entry = GIMP_TAG_ENTRY (entry);
gchar *text;
text = g_strdup (gtk_entry_get_text (entry));
text = g_strstrip (text);
if (! gtk_widget_has_focus (GTK_WIDGET (entry)) &&
strlen (text) == 0)
{
gimp_tag_entry_toggle_desc (tag_entry, TRUE);
}
else
{
gimp_tag_entry_toggle_desc (tag_entry, FALSE);
}
g_free (text);
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_QUERY &&
! tag_entry->suppress_tag_query &&
! tag_entry->tag_query_idle_id)
{
tag_entry->tag_query_idle_id =
g_idle_add ((GSourceFunc) gimp_tag_entry_query_tag, entry);
}
}
static void
gimp_tag_entry_insert_text (GtkEditable *editable,
gchar *new_text,
gint text_length,
gint *position)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (editable);
gboolean is_tag[2];
gint i;
gint insert_pos = *position;
glong num_chars;
num_chars = g_utf8_strlen (new_text, text_length);
if (! entry->internal_operation)
{
/* suppress tag queries until auto completion runs */
entry->suppress_tag_query++;
}
is_tag[0] = FALSE;
if (*position > 0)
{
is_tag[0] = (entry->mask->str[*position - 1] == 't' ||
entry->mask->str[*position - 1] == 's');
}
is_tag[1] = (entry->mask->str[*position] == 't' ||
entry->mask->str[*position] == 's');
if (is_tag[0] && is_tag[1])
{
g_signal_stop_emission_by_name (editable, "insert-text");
}
else if (num_chars > 0)
{
gunichar c = g_utf8_get_char (new_text);
if (! entry->internal_operation &&
*position > 0 &&
entry->mask->str[*position - 1] == 's' &&
! g_unichar_isspace (c))
{
if (! entry->suppress_mask_update)
{
g_string_insert_c (entry->mask, *position, 'u');
}
g_signal_handlers_block_by_func (editable,
gimp_tag_entry_insert_text,
NULL);
gtk_editable_insert_text (editable, " ", 1, position);
gtk_editable_insert_text (editable, new_text, text_length, position);
g_signal_handlers_unblock_by_func (editable,
gimp_tag_entry_insert_text,
NULL);
g_signal_stop_emission_by_name (editable, "insert-text");
}
else if (! entry->internal_operation &&
num_chars == 1 &&
*position < entry->mask->len &&
entry->mask->str[*position] == 't' &&
! g_unichar_isspace (c))
{
if (! entry->suppress_mask_update)
{
g_string_insert_c (entry->mask, *position, 'u');
}
g_signal_handlers_block_by_func (editable,
gimp_tag_entry_insert_text,
NULL);
gtk_editable_insert_text (editable, new_text, text_length, position);
gtk_editable_insert_text (editable, " ", 1, position);
(*position)--;
g_signal_handlers_unblock_by_func (editable,
gimp_tag_entry_insert_text,
NULL);
g_signal_stop_emission_by_name (editable, "insert-text");
}
if (! entry->suppress_mask_update)
{
for (i = 0; i < num_chars; i++)
{
g_string_insert_c (entry->mask, insert_pos + i, 'u');
}
}
}
if (! entry->internal_operation)
{
entry->tab_completion_index = -1;
g_idle_add ((GSourceFunc) gimp_tag_entry_auto_complete, editable);
}
}
static void
gimp_tag_entry_delete_text (GtkEditable *editable,
gint start_pos,
gint end_pos)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (editable);
if (! entry->internal_operation)
{
g_signal_handlers_block_by_func (editable,
gimp_tag_entry_delete_text,
NULL);
if (end_pos > start_pos &&
(entry->mask->str[end_pos - 1] == 't' ||
entry->mask->str[end_pos - 1] == 's'))
{
while (end_pos <= entry->mask->len &&
(entry->mask->str[end_pos] == 's'))
{
end_pos++;
}
}
gtk_editable_delete_text (editable, start_pos, end_pos);
if (! entry->suppress_mask_update)
{
g_string_erase (entry->mask, start_pos, end_pos - start_pos);
}
g_signal_handlers_unblock_by_func (editable,
gimp_tag_entry_delete_text,
NULL);
g_signal_stop_emission_by_name (editable, "delete-text");
}
else
{
if (! entry->suppress_mask_update)
{
g_string_erase (entry->mask, start_pos, end_pos - start_pos);
}
}
}
static gboolean
gimp_tag_entry_query_tag (GimpTagEntry *entry)
{
gchar **parsed_tags;
gint count;
gint i;
GList *query_list = NULL;
gboolean has_invalid_tags;
entry->tag_query_idle_id = 0;
if (entry->suppress_tag_query)
return FALSE;
has_invalid_tags = FALSE;
parsed_tags = gimp_tag_entry_parse_tags (entry);
count = g_strv_length (parsed_tags);
for (i = 0; i < count; i++)
{
if (strlen (parsed_tags[i]) > 0)
{
GimpTag *tag = gimp_tag_try_new (parsed_tags[i]);
if (! tag)
has_invalid_tags = TRUE;
query_list = g_list_append (query_list, tag);
}
}
g_strfreev (parsed_tags);
gimp_tagged_container_set_filter (GIMP_TAGGED_CONTAINER (entry->container),
query_list);
g_list_free_full (query_list, (GDestroyNotify) gimp_tag_or_null_unref);
if (has_invalid_tags != entry->has_invalid_tags)
{
entry->has_invalid_tags = has_invalid_tags;
gtk_widget_queue_draw (GTK_WIDGET (entry));
}
return FALSE;
}
static gboolean
gimp_tag_entry_auto_complete (GimpTagEntry *tag_entry)
{
GtkEntry *entry = GTK_ENTRY (tag_entry);
gchar *completion_prefix;
GList *completion_candidates;
gint candidate_count = 0;
gchar **tags;
gchar *completion;
gint start_position;
gint end_position;
tag_entry->suppress_tag_query--;
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{
/* tag query was suppressed until we got to auto completion (here),
* now queue tag query
*/
tag_entry->tag_query_idle_id =
g_idle_add ((GSourceFunc) gimp_tag_entry_query_tag, tag_entry);
}
if (tag_entry->tab_completion_index >= 0)
{
tag_entry->internal_operation++;
tag_entry->suppress_tag_query++;
gtk_editable_delete_selection (GTK_EDITABLE (tag_entry));
tag_entry->suppress_tag_query--;
tag_entry->internal_operation--;
}
gtk_editable_get_selection_bounds (GTK_EDITABLE (tag_entry),
&start_position, &end_position);
if (start_position != end_position)
{
/* only autocomplete what user types,
* not was autocompleted in the previous step.
*/
return FALSE;
}
completion_prefix =
gimp_tag_entry_get_completion_prefix (GIMP_TAG_ENTRY (entry));
tags = gimp_tag_entry_parse_tags (GIMP_TAG_ENTRY (entry));
completion_candidates =
gimp_tag_entry_get_completion_candidates (GIMP_TAG_ENTRY (entry),
tags,
completion_prefix);
completion_candidates = g_list_sort (completion_candidates,
gimp_tag_compare_func);
if (tag_entry->tab_completion_index >= 0 && completion_candidates)
{
GimpTag *the_chosen_one;
candidate_count = g_list_length (completion_candidates);
tag_entry->tab_completion_index %= candidate_count;
the_chosen_one = g_list_nth_data (completion_candidates,
tag_entry->tab_completion_index);
g_list_free (completion_candidates);
completion_candidates = NULL;
completion_candidates = g_list_append (completion_candidates,
the_chosen_one);
}
completion = gimp_tag_entry_get_completion_string (GIMP_TAG_ENTRY (entry),
completion_candidates,
completion_prefix);
if (completion && strlen (completion) > 0)
{
start_position = gtk_editable_get_position (GTK_EDITABLE (entry));
end_position = start_position;
tag_entry->internal_operation++;
gtk_editable_insert_text (GTK_EDITABLE (entry),
completion, strlen (completion),
&end_position);
tag_entry->internal_operation--;
if (tag_entry->tab_completion_index >= 0 &&
candidate_count == 1)
{
gtk_editable_set_position (GTK_EDITABLE (entry), end_position);
}
else
{
gtk_editable_select_region (GTK_EDITABLE (entry),
start_position, end_position);
}
}
g_free (completion);
g_strfreev (tags);
g_list_free (completion_candidates);
g_free (completion_prefix);
return FALSE;
}
static void
gimp_tag_entry_assign_tags (GimpTagEntry *tag_entry)
{
gchar **parsed_tags;
gint count;
gint i;
GList *resource_iter;
GList *tag_iter;
GList *dont_remove_list = NULL;
GList *remove_list = NULL;
GList *add_list = NULL;
GList *common_tags = NULL;
parsed_tags = gimp_tag_entry_parse_tags (tag_entry);
count = g_strv_length (parsed_tags);
for (i = 0; i < count; i++)
{
GimpTag *tag = gimp_tag_new (parsed_tags[i]);
if (tag)
{
if (g_list_find_custom (tag_entry->common_tags, tag,
gimp_tag_compare_func))
{
dont_remove_list = g_list_prepend (dont_remove_list, tag);
}
else
{
add_list = g_list_prepend (add_list, g_object_ref (tag));
}
common_tags = g_list_prepend (common_tags, tag);
}
}
g_strfreev (parsed_tags);
/* find common tags which were removed. */
for (tag_iter = tag_entry->common_tags;
tag_iter;
tag_iter = g_list_next (tag_iter))
{
if (! g_list_find_custom (dont_remove_list, tag_iter->data,
gimp_tag_compare_func))
{
remove_list = g_list_prepend (remove_list,
g_object_ref (tag_iter->data));
}
}
g_list_free (dont_remove_list);
for (resource_iter = tag_entry->selected_items;
resource_iter;
resource_iter = g_list_next (resource_iter))
{
GimpTagged *tagged = GIMP_TAGGED (resource_iter->data);
for (tag_iter = remove_list; tag_iter; tag_iter = g_list_next (tag_iter))
{
gimp_tagged_remove_tag (tagged, tag_iter->data);
}
for (tag_iter = add_list; tag_iter; tag_iter = g_list_next (tag_iter))
{
gimp_tagged_add_tag (tagged, tag_iter->data);
}
}
g_list_free_full (add_list, (GDestroyNotify) g_object_unref);
g_list_free_full (remove_list, (GDestroyNotify) g_object_unref);
/* common tags list with changes applied. */
g_list_free_full (tag_entry->common_tags, (GDestroyNotify) g_object_unref);
tag_entry->common_tags = common_tags;
}
/**
* gimp_tag_entry_parse_tags:
* @entry: a #GimpTagEntry widget.
*
* Parses currently entered tags from @entry. Tags do not need to be
* valid as they are fixed when necessary. Only valid tags are
* returned.
*
* Return value: a newly allocated NULL terminated list of strings. It
* should be freed using g_strfreev().
**/
gchar **
gimp_tag_entry_parse_tags (GimpTagEntry *entry)
{
gchar **parsed_tags;
gint length;
gint i;
GString *parsed_tag;
const gchar *cursor;
GList *tag_list = NULL;
GList *iterator;
gunichar c;
g_return_val_if_fail (GIMP_IS_TAG_ENTRY (entry), NULL);
parsed_tag = g_string_new ("");
cursor = gtk_entry_get_text (GTK_ENTRY (entry));
do
{
c = g_utf8_get_char (cursor);
cursor = g_utf8_next_char (cursor);
if (! c || gimp_tag_is_tag_separator (c))
{
if (parsed_tag->len > 0)
{
gchar *validated_tag = gimp_tag_string_make_valid (parsed_tag->str);
if (validated_tag)
{
tag_list = g_list_append (tag_list, validated_tag);
}
g_string_set_size (parsed_tag, 0);
}
}
else
{
g_string_append_unichar (parsed_tag, c);
}
}
while (c);
g_string_free (parsed_tag, TRUE);
length = g_list_length (tag_list);
parsed_tags = g_malloc ((length + 1) * sizeof (gchar **));
iterator = tag_list;
for (i = 0; i < length; i++)
{
parsed_tags[i] = (gchar *) iterator->data;
iterator = g_list_next (iterator);
}
parsed_tags[length] = NULL;
g_list_free (tag_list);
return parsed_tags;
}
/**
* gimp_tag_entry_set_selected_items:
* @tag_entry: a #GimpTagEntry widget.
* @items: a list of #GimpTagged objects.
*
* Set list of currently selected #GimpTagged objects. Only selected and
* visible (not filtered out) #GimpTagged objects are assigned tags when
* operating in tag assignment mode.
**/
void
gimp_tag_entry_set_selected_items (GimpTagEntry *tag_entry,
GList *items)
{
g_return_if_fail (GIMP_IS_TAG_ENTRY (tag_entry));
if (tag_entry->selected_items)
{
g_list_free (tag_entry->selected_items);
tag_entry->selected_items = NULL;
}
if (tag_entry->common_tags)
{
g_list_free_full (tag_entry->common_tags, (GDestroyNotify) g_object_unref);
tag_entry->common_tags = NULL;
}
tag_entry->selected_items = g_list_copy (items);
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN)
{
gimp_tag_entry_load_selection (tag_entry, TRUE);
}
}
static void
gimp_tag_entry_load_selection (GimpTagEntry *tag_entry,
gboolean sort)
{
GList *list;
gint insert_pos;
GHashTable *refcounts;
GList *resource;
GList *tag;
tag_entry->internal_operation++;
gtk_editable_delete_text (GTK_EDITABLE (tag_entry), 0, -1);
tag_entry->internal_operation--;
if (! tag_entry->selected_items)
{
gimp_tag_entry_toggle_desc (tag_entry, FALSE);
return;
}
refcounts = g_hash_table_new ((GHashFunc) gimp_tag_get_hash,
(GEqualFunc) gimp_tag_equals);
/* find set of tags common to all resources. */
for (resource = tag_entry->selected_items;
resource;
resource = g_list_next (resource))
{
for (tag = gimp_tagged_get_tags (GIMP_TAGGED (resource->data));
tag;
tag = g_list_next (tag))
{
/* count refcount for each tag */
guint refcount = GPOINTER_TO_UINT (g_hash_table_lookup (refcounts,
tag->data));
g_hash_table_insert (refcounts, tag->data,
GUINT_TO_POINTER (refcount + 1));
}
}
g_hash_table_foreach (refcounts, gimp_tag_entry_find_common_tags, tag_entry);
g_hash_table_destroy (refcounts);
tag_entry->common_tags = g_list_sort (tag_entry->common_tags,
gimp_tag_compare_func);
insert_pos = gtk_editable_get_position (GTK_EDITABLE (tag_entry));
for (list = tag_entry->common_tags; list; list = g_list_next (list))
{
GimpTag *tag = list->data;
gchar *text;
text = g_strdup_printf ("%s%s ",
gimp_tag_get_name (tag),
gimp_tag_entry_get_separator ());
tag_entry->internal_operation++;
gtk_editable_insert_text (GTK_EDITABLE (tag_entry), text, strlen (text),
&insert_pos);
tag_entry->internal_operation--;
g_free (text);
}
gimp_tag_entry_commit_tags (tag_entry);
}
static void
gimp_tag_entry_find_common_tags (gpointer key,
gpointer value,
gpointer user_data)
{
guint ref_count = GPOINTER_TO_UINT (value);
GimpTagEntry *tag_entry = GIMP_TAG_ENTRY (user_data);
/* FIXME: more efficient list length */
if (ref_count == g_list_length (tag_entry->selected_items))
{
tag_entry->common_tags = g_list_prepend (tag_entry->common_tags,
g_object_ref (key));
}
}
static gchar *
gimp_tag_entry_get_completion_prefix (GimpTagEntry *entry)
{
gchar *original_string;
gchar *prefix_start;
gchar *prefix;
gchar *cursor;
gint position;
gint i;
position = gtk_editable_get_position (GTK_EDITABLE (entry));
if (position < 1 ||
entry->mask->str[position - 1] != 'u')
{
return g_strdup ("");
}
original_string = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
cursor = original_string;
prefix_start = original_string;
for (i = 0; i < position; i++)
{
gunichar c;
c = g_utf8_get_char (cursor);
cursor = g_utf8_next_char (cursor);
if (gimp_tag_is_tag_separator (c))
prefix_start = cursor;
}
*cursor = '\0';
prefix = g_strdup (g_strchug (prefix_start));
g_free (original_string);
return prefix;
}
static GList *
gimp_tag_entry_get_completion_candidates (GimpTagEntry *tag_entry,
gchar **used_tags,
gchar *src_prefix)
{
GList *candidates = NULL;
GList *all_tags;
GList *list;
gint length;
gchar *prefix;
if (! src_prefix || strlen (src_prefix) < 1)
return NULL;
prefix = g_utf8_normalize (src_prefix, -1, G_NORMALIZE_ALL);
if (! prefix)
return NULL;
all_tags = g_hash_table_get_keys (tag_entry->container->tag_ref_counts);
length = g_strv_length (used_tags);
for (list = all_tags; list; list = g_list_next (list))
{
GimpTag *tag = list->data;
if (gimp_tag_has_prefix (tag, prefix))
{
gint i;
/* check if tag is not already entered */
for (i = 0; i < length; i++)
{
if (! gimp_tag_compare_with_string (tag, used_tags[i]))
break;
}
if (i == length)
candidates = g_list_append (candidates, list->data);
}
}
g_list_free (all_tags);
g_free (prefix);
return candidates;
}
static gchar *
gimp_tag_entry_get_completion_string (GimpTagEntry *tag_entry,
GList *candidates,
gchar *prefix)
{
const gchar **completions;
guint length;
guint i;
GList *candidate_iterator;
const gchar *candidate_string;
gint prefix_length;
gunichar c;
gint num_chars_match;
gchar *completion;
gchar *completion_end;
gint completion_length;
gchar *normalized_prefix;
if (! candidates)
return NULL;
normalized_prefix = g_utf8_normalize (prefix, -1, G_NORMALIZE_ALL);
if (! normalized_prefix)
return NULL;
prefix_length = strlen (normalized_prefix);
g_free (normalized_prefix);
length = g_list_length (candidates);
if (length < 2)
{
candidate_string = gimp_tag_get_name (GIMP_TAG (candidates->data));
return g_strdup (candidate_string + prefix_length);
}
completions = g_malloc (length * sizeof (gchar*));
candidate_iterator = candidates;
for (i = 0; i < length; i++)
{
candidate_string = gimp_tag_get_name (GIMP_TAG (candidate_iterator->data));
completions[i] = candidate_string + prefix_length;
candidate_iterator = g_list_next (candidate_iterator);
}
num_chars_match = 0;
do
{
c = g_utf8_get_char (completions[0]);
if (! c)
break;
for (i = 1; i < length; i++)
{
gunichar d = g_utf8_get_char (completions[i]);
if (c != d)
{
candidate_string = gimp_tag_get_name (GIMP_TAG (candidates->data));
candidate_string += prefix_length;
completion_end = g_utf8_offset_to_pointer (candidate_string,
num_chars_match);
completion_length = completion_end - candidate_string;
completion = g_malloc (completion_length + 1);
memcpy (completion, candidate_string, completion_length);
completion[completion_length] = '\0';
g_free (completions);
return completion;
}
completions[i] = g_utf8_next_char (completions[i]);
}
completions[0] = g_utf8_next_char (completions[0]);
num_chars_match++;
}
while (c);
g_free (completions);
candidate_string = gimp_tag_get_name (GIMP_TAG (candidates->data));
return g_strdup (candidate_string + prefix_length);
}
static gboolean
gimp_tag_entry_focus_in (GtkWidget *widget,
GdkEventFocus *event)
{
gimp_tag_entry_toggle_desc (GIMP_TAG_ENTRY (widget), FALSE);
return FALSE;
}
static gboolean
gimp_tag_entry_focus_out (GtkWidget *widget,
GdkEventFocus *event)
{
GimpTagEntry *tag_entry = GIMP_TAG_ENTRY (widget);
gimp_tag_entry_commit_tags (tag_entry);
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN)
{
gimp_tag_entry_assign_tags (GIMP_TAG_ENTRY (widget));
}
gimp_tag_entry_add_to_recent (tag_entry,
gtk_entry_get_text (GTK_ENTRY (widget)),
TRUE);
gimp_tag_entry_toggle_desc (tag_entry, TRUE);
return FALSE;
}
static void
gimp_tag_entry_container_changed (GimpContainer *container,
GimpObject *object,
GimpTagEntry *tag_entry)
{
GList *list;
if (! gimp_container_have (GIMP_CONTAINER (tag_entry->container),
object))
{
GList *selected_items = NULL;
for (list = tag_entry->selected_items; list; list = g_list_next (list))
{
if (list->data != object)
selected_items = g_list_prepend (selected_items, list->data);
}
selected_items = g_list_reverse (selected_items);
gimp_tag_entry_set_selected_items (tag_entry, selected_items);
g_list_free (selected_items);
}
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN)
{
for (list = tag_entry->selected_items; list; list = g_list_next (list))
{
if (gimp_tagged_get_tags (GIMP_TAGGED (list->data)) &&
gimp_container_have (GIMP_CONTAINER (tag_entry->container),
GIMP_OBJECT (list->data)))
{
break;
}
}
if (! list)
{
tag_entry->internal_operation++;
gtk_editable_delete_text (GTK_EDITABLE (tag_entry), 0, -1);
tag_entry->internal_operation--;
}
}
}
static void
gimp_tag_entry_toggle_desc (GimpTagEntry *tag_entry,
gboolean show)
{
GtkWidget *widget = GTK_WIDGET (tag_entry);
if (! (show ^ tag_entry->description_shown))
return;
if (show)
{
gchar *current_text;
size_t len;
current_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tag_entry)));
current_text = g_strstrip (current_text);
len = strlen (current_text);
g_free (current_text);
if (len > 0)
{
return;
}
tag_entry->description_shown = TRUE;
gtk_widget_queue_draw (widget);
}
else
{
tag_entry->description_shown = FALSE;
gtk_widget_queue_draw (widget);
}
}
static gboolean
gimp_tag_entry_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GimpTagEntry *tag_entry = GIMP_TAG_ENTRY (widget);
PangoLayout *layout;
PangoAttrList *attr_list;
PangoAttribute *attribute;
gint layout_width;
gint layout_height;
gint window_width;
gint window_height;
gint offset;
const char *display_text;
/* eeeeeek */
if (event->window != gtk_entry_get_text_window (GTK_ENTRY (widget)))
return FALSE;
if (! GIMP_TAG_ENTRY (widget)->description_shown)
return FALSE;
if (tag_entry->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{
display_text = GIMP_TAG_ENTRY_QUERY_DESC;
}
else
{
display_text = GIMP_TAG_ENTRY_ASSIGN_DESC;
}
layout = gtk_widget_create_pango_layout (widget, display_text);
attr_list = pango_attr_list_new ();
attribute = pango_attr_style_new (PANGO_STYLE_ITALIC);
pango_attr_list_insert (attr_list, attribute);
pango_layout_set_attributes (layout, attr_list);
pango_attr_list_unref (attr_list);
window_width = gdk_window_get_width (event->window);
window_height = gdk_window_get_height (event->window);
pango_layout_get_size (layout,
&layout_width, &layout_height);
offset = (window_height - PANGO_PIXELS (layout_height)) / 2;
gtk_paint_layout (gtk_widget_get_style (widget),
event->window,
GTK_STATE_INSENSITIVE,
TRUE,
&event->area,
widget,
NULL,
(gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
window_width - PANGO_PIXELS (layout_width) - offset :
offset,
offset,
layout);
g_object_unref (layout);
return FALSE;
}
static gboolean
gimp_tag_entry_key_press (GtkWidget *widget,
GdkEventKey *event)
{
GimpTagEntry *entry = GIMP_TAG_ENTRY (widget);
GdkModifierType extend_mask;
guchar c;
extend_mask =
gtk_widget_get_modifier_mask (widget,
GDK_MODIFIER_INTENT_EXTEND_SELECTION);
c = gdk_keyval_to_unicode (event->keyval);
if (gimp_tag_is_tag_separator (c))
{
g_idle_add ((GSourceFunc) gimp_tag_entry_commit_source_func, entry);
return FALSE;
}
switch (event->keyval)
{
case GDK_KEY_Tab:
case GDK_KEY_KP_Tab:
case GDK_KEY_ISO_Left_Tab:
/* allow to leave the widget with Ctrl+Tab */
if (! (event->state & GDK_CONTROL_MASK))
{
entry->tab_completion_index++;
entry->suppress_tag_query++;
g_idle_add ((GSourceFunc) gimp_tag_entry_auto_complete, entry);
}
else
{
gimp_tag_entry_commit_tags (entry);
g_signal_emit_by_name (widget, "move-focus",
(event->state & GDK_SHIFT_MASK) ?
GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD);
}
return TRUE;
case GDK_KEY_Return:
gimp_tag_entry_commit_tags (entry);
break;
case GDK_KEY_Left:
gimp_tag_entry_previous_tag (entry,
(event->state & extend_mask) ? TRUE : FALSE);
return TRUE;
case GDK_KEY_Right:
gimp_tag_entry_next_tag (entry,
(event->state & extend_mask) ? TRUE : FALSE);
return TRUE;
case GDK_KEY_BackSpace:
{
gint selection_start;
gint selection_end;
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
if (gimp_tag_entry_select_jellybean (entry,
selection_start, selection_end,
TAG_SEARCH_LEFT))
{
return TRUE;
}
else
{
gimp_tag_entry_select_for_deletion (entry, TAG_SEARCH_LEFT);
/* FIXME: need to remove idle handler in dispose */
g_idle_add ((GSourceFunc) gimp_tag_entry_strip_extra_whitespace,
entry);
}
}
break;
case GDK_KEY_Delete:
{
gint selection_start;
gint selection_end;
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
if (gimp_tag_entry_select_jellybean (entry,
selection_start, selection_end,
TAG_SEARCH_RIGHT))
{
return TRUE;
}
else
{
gimp_tag_entry_select_for_deletion (entry, TAG_SEARCH_RIGHT);
/* FIXME: need to remove idle handler in dispose */
g_idle_add ((GSourceFunc) gimp_tag_entry_strip_extra_whitespace,
entry);
}
}
break;
case GDK_KEY_Up:
case GDK_KEY_Down:
if (entry->recent_list != NULL)
{
gchar *recent_item;
gchar *very_recent_item;
very_recent_item = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
gimp_tag_entry_add_to_recent (entry, very_recent_item, TRUE);
g_free (very_recent_item);
if (event->keyval == GDK_KEY_Up)
{
recent_item = (gchar *) g_list_first (entry->recent_list)->data;
entry->recent_list = g_list_remove (entry->recent_list, recent_item);
entry->recent_list = g_list_append (entry->recent_list, recent_item);
}
else
{
recent_item = (gchar *) g_list_last (entry->recent_list)->data;
entry->recent_list = g_list_remove (entry->recent_list, recent_item);
entry->recent_list = g_list_prepend (entry->recent_list, recent_item);
}
recent_item = (gchar *) g_list_first (entry->recent_list)->data;
entry->internal_operation++;
gtk_entry_set_text (GTK_ENTRY (entry), recent_item);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
entry->internal_operation--;
}
return TRUE;
default:
break;
}
return FALSE;
}
static gboolean
gimp_tag_entry_button_release (GtkWidget *widget,
GdkEventButton *event)
{
if (event->button == 1)
{
/* FIXME: need to remove idle handler in dispose */
g_idle_add ((GSourceFunc) gimp_tag_entry_try_select_jellybean,
widget);
}
return GTK_WIDGET_CLASS (parent_class)->button_release_event (widget, event);
}
static gboolean
gimp_tag_entry_try_select_jellybean (GimpTagEntry *entry)
{
gint selection_start;
gint selection_end;
gint selection_pos = gtk_editable_get_position (GTK_EDITABLE (entry));
gint char_count = g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (entry)), -1);
if (selection_pos == char_count)
{
return FALSE;
}
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
gimp_tag_entry_select_jellybean (entry, selection_start, selection_end,
TAG_SEARCH_NONE);
return FALSE;
}
static gboolean
gimp_tag_entry_select_jellybean (GimpTagEntry *entry,
gint selection_start,
gint selection_end,
GimpTagSearchDir search_dir)
{
gint prev_selection_start;
gint prev_selection_end;
if (! entry->mask->len)
{
return FALSE;
}
if (selection_start >= entry->mask->len)
{
selection_start = entry->mask->len - 1;
selection_end = selection_start;
}
if (entry->mask->str[selection_start] == 'u')
{
return FALSE;
}
switch (search_dir)
{
case TAG_SEARCH_NONE:
if (selection_start > 0 &&
entry->mask->str[selection_start] == 's')
{
selection_start--;
}
if (selection_start > 0 &&
(entry->mask->str[selection_start - 1] == 'w') &&
(entry->mask->str[selection_start] == 't'))
{
/* between whitespace and tag,
* should allow to select tag.
*/
selection_start--;
}
break;
case TAG_SEARCH_LEFT:
if (selection_start == selection_end)
{
if (selection_start > 0 &&
entry->mask->str[selection_start] == 't' &&
entry->mask->str[selection_start - 1] == 'w')
{
selection_start--;
}
if ((entry->mask->str[selection_start] == 'w' ||
entry->mask->str[selection_start] == 's') &&
selection_start > 0)
{
while ((entry->mask->str[selection_start] == 'w' ||
entry->mask->str[selection_start] == 's') &&
selection_start > 0)
{
selection_start--;
}
selection_end = selection_start + 1;
}
}
break;
case TAG_SEARCH_RIGHT:
if (selection_start == selection_end)
{
if ((entry->mask->str[selection_start] == 'w' ||
entry->mask->str[selection_start] == 's') &&
selection_start < entry->mask->len - 1)
{
while ((entry->mask->str[selection_start] == 'w' ||
entry->mask->str[selection_start] == 's') &&
selection_start < entry->mask->len - 1)
{
selection_start++;
}
selection_end = selection_start + 1;
}
}
break;
}
if (selection_start < entry->mask->len &&
selection_start == selection_end)
{
selection_end = selection_start + 1;
}
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&prev_selection_start,
&prev_selection_end);
if (entry->mask->str[selection_start] == 't')
{
while (selection_start > 0 &&
(entry->mask->str[selection_start - 1] == 't'))
{
selection_start--;
}
}
if (selection_end > selection_start &&
(entry->mask->str[selection_end - 1] == 't'))
{
while (selection_end <= entry->mask->len &&
(entry->mask->str[selection_end] == 't'))
{
selection_end++;
}
}
if (search_dir == TAG_SEARCH_NONE &&
selection_end - selection_start == 1 &&
entry->mask->str[selection_start] == 'w')
{
gtk_editable_set_position (GTK_EDITABLE (entry), selection_end);
return TRUE;
}
if ((selection_start != prev_selection_start ||
selection_end != prev_selection_end) &&
(entry->mask->str[selection_start] == 't') &&
selection_start < selection_end)
{
if (search_dir == TAG_SEARCH_LEFT)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_end, selection_start);
}
else
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_start, selection_end);
}
return TRUE;
}
else
{
return FALSE;
}
}
static gboolean
gimp_tag_entry_add_to_recent (GimpTagEntry *entry,
const gchar *tags_string,
gboolean to_front)
{
gchar *recent_item = NULL;
gchar *stripped_string;
gint stripped_length;
GList *list;
if (entry->mode == GIMP_TAG_ENTRY_MODE_ASSIGN)
return FALSE;
stripped_string = g_strdup (tags_string);
stripped_string = g_strstrip (stripped_string);
stripped_length = strlen (stripped_string);
g_free (stripped_string);
if (stripped_length <= 0)
{
/* there is no content in the string,
* therefore don't add to recent list.
*/
return FALSE;
}
if (g_list_length (entry->recent_list) >= GIMP_TAG_ENTRY_MAX_RECENT_ITEMS)
{
gchar *last_item = g_list_last (entry->recent_list)->data;
entry->recent_list = g_list_remove (entry->recent_list, last_item);
g_free (last_item);
}
for (list = entry->recent_list; list; list = g_list_next (list))
{
if (! strcmp (tags_string, list->data))
{
recent_item = list->data;
entry->recent_list = g_list_remove (entry->recent_list, recent_item);
break;
}
}
if (! recent_item)
{
recent_item = g_strdup (tags_string);
}
if (to_front)
{
entry->recent_list = g_list_prepend (entry->recent_list, recent_item);
}
else
{
entry->recent_list = g_list_append (entry->recent_list, recent_item);
}
return TRUE;
}
/**
* gimp_tag_entry_get_separator:
*
* Tag separator is a single Unicode terminal punctuation
* character.
*
* Return value: returns locale dependent tag separator.
**/
const gchar *
gimp_tag_entry_get_separator (void)
{
/* Separator for tags
* IMPORTANT: use only one of Unicode terminal punctuation chars.
* http://unicode.org/review/pr-23.html
*/
return _(",");
}
static void
gimp_tag_entry_commit_region (GString *tags,
GString *mask)
{
gint i = 0;
gint j;
gint stage = 0;
gunichar c;
gchar *cursor;
GString *out_tags;
GString *out_mask;
GString *tag_buffer;
out_tags = g_string_new ("");
out_mask = g_string_new ("");
tag_buffer = g_string_new ("");
cursor = tags->str;
for (i = 0; i <= mask->len; i++)
{
c = g_utf8_get_char (cursor);
cursor = g_utf8_next_char (cursor);
if (stage == 0)
{
/* whitespace before tag */
if (g_unichar_isspace (c))
{
g_string_append_unichar (out_tags, c);
g_string_append_c (out_mask, 'w');
}
else
{
stage++;
}
}
if (stage == 1)
{
/* tag */
if (c && ! gimp_tag_is_tag_separator (c))
{
g_string_append_unichar (tag_buffer, c);
}
else
{
gchar *valid_tag = gimp_tag_string_make_valid (tag_buffer->str);
gsize tag_length;
if (valid_tag)
{
tag_length = g_utf8_strlen (valid_tag, -1);
g_string_append (out_tags, valid_tag);
for (j = 0; j < tag_length; j++)
{
g_string_append_c (out_mask, 't');
}
g_free (valid_tag);
if (! c)
{
g_string_append (out_tags, gimp_tag_entry_get_separator ());
g_string_append_c (out_mask, 's');
}
stage++;
}
else
{
stage = 0;
}
g_string_set_size (tag_buffer, 0);
}
}
if (stage == 2)
{
if (gimp_tag_is_tag_separator (c))
{
g_string_append_unichar (out_tags, c);
g_string_append_c (out_mask, 's');
}
else
{
if (g_unichar_isspace (c))
{
g_string_append_unichar (out_tags, c);
g_string_append_c (out_mask, 'w');
}
stage = 0;
}
}
}
g_string_assign (tags, out_tags->str);
g_string_assign (mask, out_mask->str);
g_string_free (tag_buffer, TRUE);
g_string_free (out_tags, TRUE);
g_string_free (out_mask, TRUE);
}
static void
gimp_tag_entry_commit_tags (GimpTagEntry *entry)
{
gboolean found_region;
gint cursor_position;
cursor_position = gtk_editable_get_position (GTK_EDITABLE (entry));
do
{
gint region_start;
gint region_end;
gint position;
glong length_before;
gint i;
found_region = FALSE;
for (i = 0; i < entry->mask->len; i++)
{
if (entry->mask->str[i] == 'u')
{
found_region = TRUE;
region_start = i;
region_end = i + 1;
for (i++; i < entry->mask->len; i++)
{
if (entry->mask->str[i] == 'u')
{
region_end = i + 1;
}
else
{
break;
}
}
break;
}
}
if (found_region)
{
gchar *tags_string;
GString *tags;
GString *mask;
tags_string = gtk_editable_get_chars (GTK_EDITABLE (entry),
region_start, region_end);
tags = g_string_new (tags_string);
g_free (tags_string);
length_before = region_end - region_start;
mask = g_string_new_len (entry->mask->str + region_start, region_end - region_start);
gimp_tag_entry_commit_region (tags, mask);
/* prepend space before if needed */
if (region_start > 0
&& entry->mask->str[region_start - 1] != 'w'
&& mask->len > 0
&& mask->str[0] != 'w')
{
g_string_prepend_c (tags, ' ');
g_string_prepend_c (mask, 'w');
}
/* append space after if needed */
if (region_end <= entry->mask->len
&& entry->mask->str[region_end] != 'w'
&& mask->len > 0
&& mask->str[mask->len - 1] != 'w')
{
g_string_append_c (tags, ' ');
g_string_append_c (mask, 'w');
}
if (cursor_position >= region_start)
{
cursor_position += g_utf8_strlen (tags->str, tags->len) - length_before;
}
entry->internal_operation++;
entry->suppress_mask_update++;
entry->suppress_tag_query++;
gtk_editable_delete_text (GTK_EDITABLE (entry),
region_start, region_end);
position = region_start;
gtk_editable_insert_text (GTK_EDITABLE (entry),
tags->str, tags->len, &position);
entry->suppress_tag_query--;
entry->suppress_mask_update--;
entry->internal_operation--;
g_string_erase (entry->mask, region_start, region_end - region_start);
g_string_insert_len (entry->mask, region_start, mask->str, mask->len);
g_string_free (mask, TRUE);
g_string_free (tags, TRUE);
}
}
while (found_region);
gtk_editable_set_position (GTK_EDITABLE (entry), cursor_position);
gimp_tag_entry_strip_extra_whitespace (entry);
}
static gboolean
gimp_tag_entry_commit_source_func (GimpTagEntry *entry)
{
gimp_tag_entry_commit_tags (entry);
return FALSE;
}
static void
gimp_tag_entry_next_tag (GimpTagEntry *entry,
gboolean select)
{
gint position = gtk_editable_get_position (GTK_EDITABLE (entry));
if (entry->mask->str[position] != 'u')
{
while (position < entry->mask->len &&
(entry->mask->str[position] != 'w'))
{
position++;
}
if (entry->mask->str[position] == 'w')
{
position++;
}
}
else if (position < entry->mask->len)
{
position++;
}
if (select)
{
gint current_position;
gint selection_start;
gint selection_end;
current_position = gtk_editable_get_position (GTK_EDITABLE (entry));
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
if (current_position == selection_end)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_start, position);
}
else if (current_position == selection_start)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_end, position);
}
}
else
{
gtk_editable_set_position (GTK_EDITABLE (entry), position);
}
}
static void
gimp_tag_entry_previous_tag (GimpTagEntry *entry,
gboolean select)
{
gint position = gtk_editable_get_position (GTK_EDITABLE (entry));
if (position >= 1 &&
entry->mask->str[position - 1] == 'w')
{
position--;
}
if (position < 1)
{
return;
}
if (entry->mask->str[position - 1] != 'u')
{
while (position > 0 &&
(entry->mask->str[position - 1] != 'w'))
{
if (entry->mask->str[position - 1] == 'u')
{
break;
}
position--;
}
}
else
{
position--;
}
if (select)
{
gint current_position;
gint selection_start;
gint selection_end;
current_position = gtk_editable_get_position (GTK_EDITABLE (entry));
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&selection_start, &selection_end);
if (current_position == selection_start)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_end, position);
}
else if (current_position == selection_end)
{
gtk_editable_select_region (GTK_EDITABLE (entry),
selection_start, position);
}
}
else
{
gtk_editable_set_position (GTK_EDITABLE (entry), position);
}
}
static void
gimp_tag_entry_select_for_deletion (GimpTagEntry *entry,
GimpTagSearchDir search_dir)
{
gint start_pos;
gint end_pos;
/* make sure the whole tag is selected,
* including a separator
*/
gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
&start_pos, &end_pos);
while (start_pos > 0 &&
(entry->mask->str[start_pos - 1] == 't'))
{
start_pos--;
}
if (end_pos > start_pos &&
(entry->mask->str[end_pos - 1] == 't' ||
entry->mask->str[end_pos - 1] == 's'))
{
while (end_pos <= entry->mask->len &&
(entry->mask->str[end_pos] == 's'))
{
end_pos++;
}
}
/* ensure there is no unnecessary whitespace selected */
while (start_pos < end_pos &&
entry->mask->str[start_pos] == 'w')
{
start_pos++;
}
while (start_pos < end_pos &&
entry->mask->str[end_pos - 1] == 'w')
{
end_pos--;
}
/* delete spaces in one side */
if (search_dir == TAG_SEARCH_LEFT)
{
gtk_editable_select_region (GTK_EDITABLE (entry), end_pos, start_pos);
}
else if (end_pos > start_pos &&
search_dir == TAG_SEARCH_RIGHT &&
(entry->mask->str[end_pos - 1] == 't' ||
entry->mask->str[end_pos - 1] == 's'))
{
gtk_editable_select_region (GTK_EDITABLE (entry), start_pos, end_pos);
}
}
static gboolean
gimp_tag_entry_strip_extra_whitespace (GimpTagEntry *entry)
{
gint i;
gint position;
position = gtk_editable_get_position (GTK_EDITABLE (entry));
entry->internal_operation++;
entry->suppress_tag_query++;
/* strip whitespace in front */
while (entry->mask->len > 0 &&
entry->mask->str[0] == 'w')
{
gtk_editable_delete_text (GTK_EDITABLE (entry), 0, 1);
}
/* strip whitespace in back */
while (entry->mask->len > 1 &&
entry->mask->str[entry->mask->len - 1] == 'w' &&
entry->mask->str[entry->mask->len - 2] == 'w')
{
gtk_editable_delete_text (GTK_EDITABLE (entry),
entry->mask->len - 1, entry->mask->len);
if (position == entry->mask->len)
{
position--;
}
}
/* strip extra whitespace in the middle */
for (i = entry->mask->len - 1; i > 0; i--)
{
if (entry->mask->str[i] == 'w' &&
entry->mask->str[i - 1] == 'w')
{
gtk_editable_delete_text (GTK_EDITABLE (entry), i, i + 1);
if (position >= i)
{
position--;
}
}
}
/* special case when cursor is in the last position:
* it must be positioned after the last whitespace.
*/
if (position == entry->mask->len - 1 &&
entry->mask->str[position] == 'w')
{
position++;
}
gtk_editable_set_position (GTK_EDITABLE (entry), position);
entry->suppress_tag_query--;
entry->internal_operation--;
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink