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

app: add GimpTaggedContainer 

which is a copy of GimpFilteredContainer with s/Filtered/Tagged/ and
no other change. #if 0 GimpFilteredContainer for now and use
GimpTaggedContainer instead all over the place.
This commit is contained in:
Michael Natterer 2011-03-22 23:11:46 +01:00
parent 49710c1cd4
commit 051ef0ebcb
12 changed files with 778 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/core/Makefile.am
View File

@ -353,6 +353,8 @@ libappcore_a_sources = \
gimptagcache.h \ gimptagcache.h \
gimptagged.c \ gimptagged.c \
gimptagged.h \ gimptagged.h \
gimptaggedcontainer.c \
gimptaggedcontainer.h \
gimptemplate.c \ gimptemplate.c \
gimptemplate.h \ gimptemplate.h \
gimptoolinfo.c \ gimptoolinfo.c \

1
app/core/core-types.h
View File

@ -72,6 +72,7 @@ typedef struct _GimpDocumentList GimpDocumentList;
typedef struct _GimpDrawableStack GimpDrawableStack; typedef struct _GimpDrawableStack GimpDrawableStack;
typedef struct _GimpFilteredContainer GimpFilteredContainer; typedef struct _GimpFilteredContainer GimpFilteredContainer;
typedef struct _GimpItemStack GimpItemStack; typedef struct _GimpItemStack GimpItemStack;
typedef struct _GimpTaggedContainer GimpTaggedContainer;
typedef struct _GimpToolPresets GimpToolPresets; typedef struct _GimpToolPresets GimpToolPresets;

2
app/core/gimpfilteredcontainer.c
View File

@ -1,3 +1,4 @@
#if 0
/* GIMP - The GNU Image Manipulation Program /* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
* *
@ -594,3 +595,4 @@ gimp_filtered_container_get_tag_count (GimpFilteredContainer *container)
return container->tag_count; return container->tag_count;
} }
#endif

2
app/core/gimpfilteredcontainer.h
View File

@ -1,3 +1,4 @@
#if 0
/* GIMP - The GNU Image Manipulation Program /* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
* *
@ -67,3 +68,4 @@ gint gimp_filtered_container_get_tag_count (GimpFilteredContainer *co
#endif /* __GIMP_FILTERED_CONTAINER_H__ */ #endif /* __GIMP_FILTERED_CONTAINER_H__ */
#endif

596
app/core/gimptaggedcontainer.c Normal file
View File

@ -0,0 +1,596 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* gimptaggedcontainer.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 <glib-object.h>
#include "core-types.h"
#include "gimp.h"
#include "gimpmarshal.h"
#include "gimptag.h"
#include "gimptagged.h"
#include "gimptaggedcontainer.h"
enum
{
TAG_COUNT_CHANGED,
LAST_SIGNAL
};
enum
{
PROP_0,
PROP_SRC_CONTAINER
};
typedef struct _MatchParams
{
GimpTaggedContainer *tagged_container;
GList *items_to_add;
GList *items_to_remove;
} MatchParams;
static void gimp_tagged_container_constructed (GObject *object);
static void gimp_tagged_container_dispose (GObject *object);
static void gimp_tagged_container_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_tagged_container_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gint64 gimp_tagged_container_get_memsize (GimpObject *object,
gint64 *gui_size);
static gboolean gimp_tagged_container_object_matches (GimpTaggedContainer *tagged_container,
GimpObject *object);
static void gimp_tagged_container_filter (GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_src_add (GimpContainer *src_container,
GimpObject *obj,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_src_remove (GimpContainer *src_container,
GimpObject *obj,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_src_freeze (GimpContainer *src_container,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_src_thaw (GimpContainer *src_container,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_tag_added (GimpTagged *tagged,
GimpTag *tag,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_tag_removed (GimpTagged *tagged,
GimpTag *tag,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_tagged_item_added (GimpTagged *tagged,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_tagged_item_removed(GimpTagged *tagged,
GimpTaggedContainer *tagged_container);
static void gimp_tagged_container_tag_count_changed (GimpTaggedContainer *tagged_container,
gint tag_count);
G_DEFINE_TYPE (GimpTaggedContainer, gimp_tagged_container, GIMP_TYPE_LIST)
#define parent_class gimp_tagged_container_parent_class
static guint gimp_tagged_container_signals[LAST_SIGNAL] = { 0, };
static void
gimp_tagged_container_class_init (GimpTaggedContainerClass *klass)
{
GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
g_object_class->constructed = gimp_tagged_container_constructed;
g_object_class->dispose = gimp_tagged_container_dispose;
g_object_class->set_property = gimp_tagged_container_set_property;
g_object_class->get_property = gimp_tagged_container_get_property;
gimp_object_class->get_memsize = gimp_tagged_container_get_memsize;
klass->tag_count_changed = gimp_tagged_container_tag_count_changed;
gimp_tagged_container_signals[TAG_COUNT_CHANGED] =
g_signal_new ("tag-count-changed",
GIMP_TYPE_TAGGED_CONTAINER,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpTaggedContainerClass, tag_count_changed),
NULL, NULL,
gimp_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
g_object_class_install_property (g_object_class, PROP_SRC_CONTAINER,
g_param_spec_object ("src-container",
NULL, NULL,
GIMP_TYPE_CONTAINER,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
}
static void
gimp_tagged_container_init (GimpTaggedContainer *tagged_container)
{
tagged_container->src_container = NULL;
tagged_container->filter = NULL;
tagged_container->tag_ref_counts = NULL;
tagged_container->tag_count = 0;
}
static void
gimp_tagged_container_constructed (GObject *object)
{
GimpTaggedContainer *tagged_container = GIMP_TAGGED_CONTAINER (object);
if (G_OBJECT_CLASS (parent_class)->constructed)
G_OBJECT_CLASS (parent_class)->constructed (object);
tagged_container->tag_ref_counts =
g_hash_table_new ((GHashFunc) gimp_tag_get_hash,
(GEqualFunc) gimp_tag_equals);
gimp_container_foreach (tagged_container->src_container,
(GFunc) gimp_tagged_container_tagged_item_added,
tagged_container);
gimp_tagged_container_filter (tagged_container);
}
static void
gimp_tagged_container_dispose (GObject *object)
{
GimpTaggedContainer *tagged_container = GIMP_TAGGED_CONTAINER (object);
if (tagged_container->tag_ref_counts)
{
g_hash_table_unref (tagged_container->tag_ref_counts);
tagged_container->tag_ref_counts = NULL;
}
if (tagged_container->src_container)
{
g_signal_handlers_disconnect_by_func (tagged_container->src_container,
gimp_tagged_container_src_add,
tagged_container);
g_signal_handlers_disconnect_by_func (tagged_container->src_container,
gimp_tagged_container_src_remove,
tagged_container);
g_signal_handlers_disconnect_by_func (tagged_container->src_container,
gimp_tagged_container_src_freeze,
tagged_container);
g_signal_handlers_disconnect_by_func (tagged_container->src_container,
gimp_tagged_container_src_thaw,
tagged_container);
g_object_unref (tagged_container->src_container);
tagged_container->src_container = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_tagged_container_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpTaggedContainer *tagged_container = GIMP_TAGGED_CONTAINER (object);
switch (property_id)
{
case PROP_SRC_CONTAINER:
tagged_container->src_container = g_value_dup_object (value);
g_signal_connect (tagged_container->src_container, "add",
G_CALLBACK (gimp_tagged_container_src_add),
tagged_container);
g_signal_connect (tagged_container->src_container, "remove",
G_CALLBACK (gimp_tagged_container_src_remove),
tagged_container);
g_signal_connect (tagged_container->src_container, "freeze",
G_CALLBACK (gimp_tagged_container_src_freeze),
tagged_container);
g_signal_connect (tagged_container->src_container, "thaw",
G_CALLBACK (gimp_tagged_container_src_thaw),
tagged_container);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tagged_container_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpTaggedContainer *tagged_container = GIMP_TAGGED_CONTAINER (object);
switch (property_id)
{
case PROP_SRC_CONTAINER:
g_value_set_object (value, tagged_container->src_container);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gint64
gimp_tagged_container_get_memsize (GimpObject *object,
gint64 *gui_size)
{
gint64 memsize = 0;
/* FIXME take members into account */
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
/**
* gimp_tagged_container_new:
* @src_container: container to be filtered.
*
* Creates a new #GimpTaggedContainer object which creates filtered
* data view of #GimpTagged objects. It filters @src_container for objects
* containing all of the filtering tags. Syncronization with @src_container
* data is performed automatically.
*
* Return value: a new #GimpTaggedContainer object.
**/
GimpContainer *
gimp_tagged_container_new (GimpContainer *src_container,
GCompareFunc sort_func)
{
GimpTaggedContainer *tagged_container;
GType children_type;
g_return_val_if_fail (GIMP_IS_CONTAINER (src_container), NULL);
children_type = gimp_container_get_children_type (src_container);
tagged_container = g_object_new (GIMP_TYPE_TAGGED_CONTAINER,
"sort-func", sort_func,
"children-type", children_type,
"policy", GIMP_CONTAINER_POLICY_WEAK,
"unique-names", FALSE,
"src-container", src_container,
NULL);
return GIMP_CONTAINER (tagged_container);
}
/**
* gimp_tagged_container_set_filter:
* @tagged_container: a #GimpTaggedContainer object.
* @tags: list of #GimpTag objects.
*
* Sets list of tags to be used for filtering. Only objects which have all of
* the tags assigned match filtering criteria.
**/
void
gimp_tagged_container_set_filter (GimpTaggedContainer *tagged_container,
GList *tags)
{
g_return_if_fail (GIMP_IS_TAGGED_CONTAINER (tagged_container));
tagged_container->filter = tags;
gimp_container_freeze (GIMP_CONTAINER (tagged_container));
gimp_tagged_container_filter (tagged_container);
gimp_container_thaw (GIMP_CONTAINER (tagged_container));
}
/**
* gimp_tagged_container_get_filter:
* @tagged_container: a #GimpTaggedContainer object.
*
* Returns current tag filter. Tag filter is a list of GimpTag objects, which
* must be contained by each object matching filter criteria.
*
* Return value: a list of GimpTag objects used as filter. This value should
* not be modified or freed.
**/
const GList *
gimp_tagged_container_get_filter (GimpTaggedContainer *tagged_container)
{
g_return_val_if_fail (GIMP_IS_TAGGED_CONTAINER (tagged_container), NULL);
return tagged_container->filter;
}
static gboolean
gimp_tagged_container_object_matches (GimpTaggedContainer *tagged_container,
GimpObject *object)
{
GList *filter_tag;
GList *object_tag;
filter_tag = tagged_container->filter;
while (filter_tag)
{
if (! filter_tag->data)
{
/* invalid tag - does not match */
return FALSE;
}
object_tag = gimp_tagged_get_tags (GIMP_TAGGED (object));
while (object_tag)
{
if (gimp_tag_equals (GIMP_TAG (object_tag->data),
GIMP_TAG (filter_tag->data)))
{
/* found match for the tag */
break;
}
object_tag = g_list_next (object_tag);
}
if (! object_tag)
{
/* match for the tag was not found.
* since query is of type AND, it whole fails. */
return FALSE;
}
filter_tag = g_list_next (filter_tag);
}
return TRUE;
}
static void
gimp_tagged_container_check_needs_remove (GimpObject *object,
MatchParams *match_params)
{
if (! gimp_tagged_container_object_matches (match_params->tagged_container,
object))
{
match_params->items_to_remove = g_list_prepend (match_params->items_to_remove,
object);
}
}
static void
gimp_tagged_container_check_needs_add (GimpObject *object,
MatchParams *match_params)
{
if (gimp_tagged_container_object_matches (match_params->tagged_container,
object) &&
! gimp_container_have (GIMP_CONTAINER (match_params->tagged_container),
object))
{
match_params->items_to_add = g_list_prepend (match_params->items_to_add,
object);
}
}
static void
gimp_tagged_container_filter (GimpTaggedContainer *tagged_container)
{
MatchParams match_params;
GList *list;
match_params.tagged_container = tagged_container;
match_params.items_to_add = NULL;
match_params.items_to_remove = NULL;
gimp_container_foreach (GIMP_CONTAINER (tagged_container),
(GFunc) gimp_tagged_container_check_needs_remove,
&match_params);
gimp_container_foreach (GIMP_CONTAINER (tagged_container->src_container),
(GFunc) gimp_tagged_container_check_needs_add,
&match_params);
for (list = match_params.items_to_remove; list; list = g_list_next (list))
{
gimp_container_remove (GIMP_CONTAINER (tagged_container),
GIMP_OBJECT (list->data));
}
for (list = match_params.items_to_add; list; list = g_list_next (list))
{
gimp_container_add (GIMP_CONTAINER (tagged_container),
GIMP_OBJECT (list->data));
}
g_list_free (match_params.items_to_add);
g_list_free (match_params.items_to_remove);
}
static void
gimp_tagged_container_src_add (GimpContainer *src_container,
GimpObject *obj,
GimpTaggedContainer *tagged_container)
{
gimp_tagged_container_tagged_item_added (GIMP_TAGGED (obj),
tagged_container);
if (! gimp_container_frozen (src_container))
{
gimp_container_add (GIMP_CONTAINER (tagged_container), obj);
}
}
static void
gimp_tagged_container_src_remove (GimpContainer *src_container,
GimpObject *obj,
GimpTaggedContainer *tagged_container)
{
gimp_tagged_container_tagged_item_removed (GIMP_TAGGED (obj),
tagged_container);
if (! gimp_container_frozen (src_container) &&
gimp_container_have (GIMP_CONTAINER (tagged_container), obj))
{
gimp_container_remove (GIMP_CONTAINER (tagged_container), obj);
}
}
static void
gimp_tagged_container_src_freeze (GimpContainer *src_container,
GimpTaggedContainer *tagged_container)
{
gimp_container_freeze (GIMP_CONTAINER (tagged_container));
gimp_container_clear (GIMP_CONTAINER (tagged_container));
}
static void
gimp_tagged_container_src_thaw (GimpContainer *src_container,
GimpTaggedContainer *tagged_container)
{
gimp_tagged_container_filter (tagged_container);
gimp_container_thaw (GIMP_CONTAINER (tagged_container));
}
static void
gimp_tagged_container_tagged_item_added (GimpTagged *tagged,
GimpTaggedContainer *tagged_container)
{
GList *list;
for (list = gimp_tagged_get_tags (tagged); list; list = g_list_next (list))
{
gimp_tagged_container_tag_added (tagged,
list->data,
tagged_container);
}
g_signal_connect (tagged, "tag-added",
G_CALLBACK (gimp_tagged_container_tag_added),
tagged_container);
g_signal_connect (tagged, "tag-removed",
G_CALLBACK (gimp_tagged_container_tag_removed),
tagged_container);
}
static void
gimp_tagged_container_tagged_item_removed (GimpTagged *tagged,
GimpTaggedContainer *tagged_container)
{
GList *list;
g_signal_handlers_disconnect_by_func (tagged,
gimp_tagged_container_tag_added,
tagged_container);
g_signal_handlers_disconnect_by_func (tagged,
gimp_tagged_container_tag_removed,
tagged_container);
for (list = gimp_tagged_get_tags (tagged); list; list = g_list_next (list))
{
gimp_tagged_container_tag_removed (tagged,
GIMP_TAG (list->data),
tagged_container);
}
}
static void
gimp_tagged_container_tag_added (GimpTagged *tagged,
GimpTag *tag,
GimpTaggedContainer *tagged_container)
{
gint ref_count;
ref_count = GPOINTER_TO_INT (g_hash_table_lookup (tagged_container->tag_ref_counts,
tag));
ref_count++;
g_hash_table_insert (tagged_container->tag_ref_counts,
tag, GINT_TO_POINTER (ref_count));
if (ref_count == 1)
{
tagged_container->tag_count++;
g_signal_emit (tagged_container,
gimp_tagged_container_signals[TAG_COUNT_CHANGED], 0,
tagged_container->tag_count);
}
}
static void
gimp_tagged_container_tag_removed (GimpTagged *tagged,
GimpTag *tag,
GimpTaggedContainer *tagged_container)
{
gint ref_count;
ref_count = GPOINTER_TO_INT (g_hash_table_lookup (tagged_container->tag_ref_counts,
tag));
ref_count--;
if (ref_count > 0)
{
g_hash_table_insert (tagged_container->tag_ref_counts,
tag, GINT_TO_POINTER (ref_count));
}
else
{
if (g_hash_table_remove (tagged_container->tag_ref_counts, tag))
{
tagged_container->tag_count--;
g_signal_emit (tagged_container,
gimp_tagged_container_signals[TAG_COUNT_CHANGED], 0,
tagged_container->tag_count);
}
}
}
static void
gimp_tagged_container_tag_count_changed (GimpTaggedContainer *container,
gint tag_count)
{
}
/**
* gimp_tagged_container_get_tag_count:
* @container: a #GimpTaggedContainer object.
*
* Get number of distinct tags that are currently assigned to all
* objects in the container. The count is independent of currently
* used filter, it is provided for all available objects (ie. empty
* filter).
*
* Return value: number of distinct tags assigned to all objects in the
* container.
**/
gint
gimp_tagged_container_get_tag_count (GimpTaggedContainer *container)
{
g_return_val_if_fail (GIMP_IS_TAGGED_CONTAINER (container), 0);
return container->tag_count;
}

69
app/core/gimptaggedcontainer.h Normal file
View File

@ -0,0 +1,69 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* gimptaggedcontainer.h
* 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/>.
*/
#ifndef __GIMP_TAGGED_CONTAINER_H__
#define __GIMP_TAGGED_CONTAINER_H__
#include "gimplist.h"
#define GIMP_TYPE_TAGGED_CONTAINER (gimp_tagged_container_get_type ())
#define GIMP_TAGGED_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_TAGGED_CONTAINER, GimpTaggedContainer))
#define GIMP_TAGGED_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TAGGED_CONTAINER, GimpTaggedContainerClass))
#define GIMP_IS_TAGGED_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_TAGGED_CONTAINER))
#define GIMP_IS_TAGGED_CONTAINER_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), GIMP_TYPE_TAGGED_CONTAINER))
#define GIMP_TAGGED_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_TAGGED_CONTAINER, GimpTaggedContainerClass))
typedef struct _GimpTaggedContainerClass GimpTaggedContainerClass;
struct _GimpTaggedContainer
{
GimpList parent_instance;
GimpContainer *src_container;
GList *filter;
GHashTable *tag_ref_counts;
gint tag_count;
};
struct _GimpTaggedContainerClass
{
GimpContainerClass parent_class;
void (* tag_count_changed) (GimpTaggedContainer *container,
gint count);
};
GType gimp_tagged_container_get_type (void) G_GNUC_CONST;
GimpContainer * gimp_tagged_container_new (GimpContainer *src_container,
GCompareFunc sort_func);
void gimp_tagged_container_set_filter (GimpTaggedContainer *tagged_container,
GList *tags);
const GList * gimp_tagged_container_get_filter (GimpTaggedContainer *tagged_container);
gint gimp_tagged_container_get_tag_count (GimpTaggedContainer *container);
#endif /* __GIMP_TAGGED_CONTAINER_H__ */

54
app/widgets/gimpcombotagentry.c
View File

@ -27,36 +27,36 @@
#include "widgets-types.h" #include "widgets-types.h"
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpfilteredcontainer.h"
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpviewable.h"
#include "core/gimptag.h" #include "core/gimptag.h"
#include "core/gimptagged.h" #include "core/gimptagged.h"
#include "core/gimptaggedcontainer.h"
#include "core/gimpviewable.h"
#include "gimptagentry.h" #include "gimptagentry.h"
#include "gimptagpopup.h" #include "gimptagpopup.h"
#include "gimpcombotagentry.h" #include "gimpcombotagentry.h"
static void gimp_combo_tag_entry_constructed (GObject *object); static void gimp_combo_tag_entry_constructed (GObject *object);
static void gimp_combo_tag_entry_dispose (GObject *object); static void gimp_combo_tag_entry_dispose (GObject *object);
static gboolean gimp_combo_tag_entry_expose (GtkWidget *widget, static gboolean gimp_combo_tag_entry_expose (GtkWidget *widget,
GdkEventExpose *event); GdkEventExpose *event);
static void gimp_combo_tag_entry_style_set (GtkWidget *widget, static void gimp_combo_tag_entry_style_set (GtkWidget *widget,
GtkStyle *previous_style); GtkStyle *previous_style);
static void gimp_combo_tag_entry_icon_press (GtkWidget *widget, static void gimp_combo_tag_entry_icon_press (GtkWidget *widget,
GtkEntryIconPosition icon_pos, GtkEntryIconPosition icon_pos,
GdkEvent *event, GdkEvent *event,
gpointer user_data); gpointer user_data);
static void gimp_combo_tag_entry_popup_destroy (GtkObject *object, static void gimp_combo_tag_entry_popup_destroy (GtkObject *object,
GimpComboTagEntry *entry); GimpComboTagEntry *entry);
static void gimp_combo_tag_entry_tag_count_changed (GimpFilteredContainer *container, static void gimp_combo_tag_entry_tag_count_changed (GimpTaggedContainer *container,
gint tag_count, gint tag_count,
GimpComboTagEntry *entry); GimpComboTagEntry *entry);
G_DEFINE_TYPE (GimpComboTagEntry, gimp_combo_tag_entry, GIMP_TYPE_TAG_ENTRY); G_DEFINE_TYPE (GimpComboTagEntry, gimp_combo_tag_entry, GIMP_TYPE_TAG_ENTRY);
@ -240,7 +240,7 @@ gimp_combo_tag_entry_style_set (GtkWidget *widget,
/** /**
* gimp_combo_tag_entry_new: * gimp_combo_tag_entry_new:
* @container: a filtered container to be used. * @container: a tagged container to be used.
* @mode: tag entry mode to work in. * @mode: tag entry mode to work in.
* *
* Creates a new #GimpComboTagEntry widget which extends #GimpTagEntry by * Creates a new #GimpComboTagEntry widget which extends #GimpTagEntry by
@ -249,10 +249,10 @@ gimp_combo_tag_entry_style_set (GtkWidget *widget,
* Return value: a new #GimpComboTagEntry widget. * Return value: a new #GimpComboTagEntry widget.
**/ **/
GtkWidget * GtkWidget *
gimp_combo_tag_entry_new (GimpFilteredContainer *container, gimp_combo_tag_entry_new (GimpTaggedContainer *container,
GimpTagEntryMode mode) GimpTagEntryMode mode)
{ {
g_return_val_if_fail (GIMP_IS_FILTERED_CONTAINER (container), NULL); g_return_val_if_fail (GIMP_IS_TAGGED_CONTAINER (container), NULL);
return g_object_new (GIMP_TYPE_COMBO_TAG_ENTRY, return g_object_new (GIMP_TYPE_COMBO_TAG_ENTRY,
"container", container, "container", container,
@ -270,10 +270,10 @@ gimp_combo_tag_entry_icon_press (GtkWidget *widget,
if (! entry->popup) if (! entry->popup)
{ {
GimpFilteredContainer *container = GIMP_TAG_ENTRY (entry)->container; GimpTaggedContainer *container = GIMP_TAG_ENTRY (entry)->container;
gint tag_count; gint tag_count;
tag_count = gimp_filtered_container_get_tag_count (container); tag_count = gimp_tagged_container_get_tag_count (container);
if (tag_count > 0 && ! GIMP_TAG_ENTRY (entry)->has_invalid_tags) if (tag_count > 0 && ! GIMP_TAG_ENTRY (entry)->has_invalid_tags)
{ {
@ -299,9 +299,9 @@ gimp_combo_tag_entry_popup_destroy (GtkObject *object,
} }
static void static void
gimp_combo_tag_entry_tag_count_changed (GimpFilteredContainer *container, gimp_combo_tag_entry_tag_count_changed (GimpTaggedContainer *container,
gint tag_count, gint tag_count,
GimpComboTagEntry *entry) GimpComboTagEntry *entry)
{ {
gboolean sensitive; gboolean sensitive;

4
app/widgets/gimpcombotagentry.h
View File

@ -54,8 +54,8 @@ struct _GimpComboTagEntryClass
GType gimp_combo_tag_entry_get_type (void) G_GNUC_CONST; GType gimp_combo_tag_entry_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_combo_tag_entry_new (GimpFilteredContainer *container, GtkWidget * gimp_combo_tag_entry_new (GimpTaggedContainer *container,
GimpTagEntryMode mode); GimpTagEntryMode mode);
#endif /* __GIMP_COMBO_TAG_ENTRY_H__ */ #endif /* __GIMP_COMBO_TAG_ENTRY_H__ */

41
app/widgets/gimpdatafactoryview.c
View File

@ -35,9 +35,9 @@
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpdata.h" #include "core/gimpdata.h"
#include "core/gimpdatafactory.h" #include "core/gimpdatafactory.h"
#include "core/gimpfilteredcontainer.h"
#include "core/gimplist.h" #include "core/gimplist.h"
#include "core/gimpmarshal.h" #include "core/gimpmarshal.h"
#include "core/gimptaggedcontainer.h"
#include "gimpcombotagentry.h" #include "gimpcombotagentry.h"
#include "gimpcontainertreestore.h" #include "gimpcontainertreestore.h"
@ -57,7 +57,7 @@ struct _GimpDataFactoryViewPriv
{ {
GimpDataFactory *factory; GimpDataFactory *factory;
GimpContainer *tag_filtered_container; GimpContainer *tagged_container;
GtkWidget *query_tag_entry; GtkWidget *query_tag_entry;
GtkWidget *assign_tag_entry; GtkWidget *assign_tag_entry;
GList *selected_items; GList *selected_items;
@ -108,15 +108,15 @@ gimp_data_factory_view_init (GimpDataFactoryView *view)
GIMP_TYPE_DATA_FACTORY_VIEW, GIMP_TYPE_DATA_FACTORY_VIEW,
GimpDataFactoryViewPriv); GimpDataFactoryViewPriv);
view->priv->tag_filtered_container = NULL; view->priv->tagged_container = NULL;
view->priv->query_tag_entry = NULL; view->priv->query_tag_entry = NULL;
view->priv->assign_tag_entry = NULL; view->priv->assign_tag_entry = NULL;
view->priv->selected_items = NULL; view->priv->selected_items = NULL;
view->priv->edit_button = NULL; view->priv->edit_button = NULL;
view->priv->new_button = NULL; view->priv->new_button = NULL;
view->priv->duplicate_button = NULL; view->priv->duplicate_button = NULL;
view->priv->delete_button = NULL; view->priv->delete_button = NULL;
view->priv->refresh_button = NULL; view->priv->refresh_button = NULL;
} }
static void static void
@ -124,10 +124,10 @@ gimp_data_factory_view_dispose (GObject *object)
{ {
GimpDataFactoryView *factory_view = GIMP_DATA_FACTORY_VIEW (object); GimpDataFactoryView *factory_view = GIMP_DATA_FACTORY_VIEW (object);
if (factory_view->priv->tag_filtered_container) if (factory_view->priv->tagged_container)
{ {
g_object_unref (factory_view->priv->tag_filtered_container); g_object_unref (factory_view->priv->tagged_container);
factory_view->priv->tag_filtered_container = NULL; factory_view->priv->tagged_container = NULL;
} }
G_OBJECT_CLASS (parent_class)->dispose (object); G_OBJECT_CLASS (parent_class)->dispose (object);
@ -241,13 +241,14 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
factory_view->priv->factory = factory; factory_view->priv->factory = factory;
factory_view->priv->tag_filtered_container = factory_view->priv->tagged_container =
gimp_filtered_container_new (gimp_data_factory_get_container (factory), gimp_tagged_container_new (gimp_data_factory_get_container (factory),
(GCompareFunc) gimp_data_compare); (GCompareFunc) gimp_data_compare);
if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (factory_view), if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (factory_view),
view_type, view_type,
factory_view->priv->tag_filtered_container, context, factory_view->priv->tagged_container,
context,
view_size, view_border_width, view_size, view_border_width,
menu_factory, menu_identifier, menu_factory, menu_identifier,
ui_identifier)) ui_identifier))
@ -305,7 +306,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
/* Query tag entry */ /* Query tag entry */
factory_view->priv->query_tag_entry = factory_view->priv->query_tag_entry =
gimp_combo_tag_entry_new (GIMP_FILTERED_CONTAINER (factory_view->priv->tag_filtered_container), gimp_combo_tag_entry_new (GIMP_TAGGED_CONTAINER (factory_view->priv->tagged_container),
GIMP_TAG_ENTRY_MODE_QUERY); GIMP_TAG_ENTRY_MODE_QUERY);
gtk_box_pack_start (GTK_BOX (editor->view), gtk_box_pack_start (GTK_BOX (editor->view),
factory_view->priv->query_tag_entry, factory_view->priv->query_tag_entry,
@ -316,7 +317,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
/* Assign tag entry */ /* Assign tag entry */
factory_view->priv->assign_tag_entry = factory_view->priv->assign_tag_entry =
gimp_combo_tag_entry_new (GIMP_FILTERED_CONTAINER (factory_view->priv->tag_filtered_container), gimp_combo_tag_entry_new (GIMP_TAGGED_CONTAINER (factory_view->priv->tagged_container),
GIMP_TAG_ENTRY_MODE_ASSIGN); GIMP_TAG_ENTRY_MODE_ASSIGN);
gimp_tag_entry_set_selected_items (GIMP_TAG_ENTRY (factory_view->priv->assign_tag_entry), gimp_tag_entry_set_selected_items (GIMP_TAG_ENTRY (factory_view->priv->assign_tag_entry),
factory_view->priv->selected_items); factory_view->priv->selected_items);

20
app/widgets/gimptagentry.c
View File

@ -30,9 +30,9 @@
#include "core/gimp-utils.h" #include "core/gimp-utils.h"
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpfilteredcontainer.h"
#include "core/gimptag.h" #include "core/gimptag.h"
#include "core/gimptagged.h" #include "core/gimptagged.h"
#include "core/gimptaggedcontainer.h"
#include "core/gimpviewable.h" #include "core/gimpviewable.h"
#include "gimptagentry.h" #include "gimptagentry.h"
@ -157,9 +157,9 @@ gimp_tag_entry_class_init (GimpTagEntryClass *klass)
g_object_class_install_property (object_class, g_object_class_install_property (object_class,
PROP_CONTAINER, PROP_CONTAINER,
g_param_spec_object ("container", g_param_spec_object ("container",
"Filtered container", "Tagged container",
"The Filtered container", "The Tagged container",
GIMP_TYPE_FILTERED_CONTAINER, GIMP_TYPE_TAGGED_CONTAINER,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_READWRITE)); G_PARAM_READWRITE));
@ -310,7 +310,7 @@ gimp_tag_entry_get_property (GObject *object,
/** /**
* gimp_tag_entry_new: * gimp_tag_entry_new:
* @container: a #GimpFilteredContainer object * @container: a #GimpTaggedContainer object
* @mode: #GimpTagEntryMode to work in. * @mode: #GimpTagEntryMode to work in.
* *
* #GimpTagEntry is a widget which can query and assign tags to tagged objects. * #GimpTagEntry is a widget which can query and assign tags to tagged objects.
@ -321,10 +321,10 @@ gimp_tag_entry_get_property (GObject *object,
* Return value: a new GimpTagEntry widget. * Return value: a new GimpTagEntry widget.
**/ **/
GtkWidget * GtkWidget *
gimp_tag_entry_new (GimpFilteredContainer *container, gimp_tag_entry_new (GimpTaggedContainer *container,
GimpTagEntryMode mode) GimpTagEntryMode mode)
{ {
g_return_val_if_fail (GIMP_IS_FILTERED_CONTAINER (container), NULL); g_return_val_if_fail (GIMP_IS_TAGGED_CONTAINER (container), NULL);
return g_object_new (GIMP_TYPE_TAG_ENTRY, return g_object_new (GIMP_TYPE_TAG_ENTRY,
"container", container, "container", container,
@ -616,8 +616,8 @@ gimp_tag_entry_query_tag (GimpTagEntry *entry)
} }
g_strfreev (parsed_tags); g_strfreev (parsed_tags);
gimp_filtered_container_set_filter (GIMP_FILTERED_CONTAINER (entry->container), gimp_tagged_container_set_filter (GIMP_TAGGED_CONTAINER (entry->container),
query_list); query_list);
if (has_invalid_tags != entry->has_invalid_tags) if (has_invalid_tags != entry->has_invalid_tags)
{ {

43
app/widgets/gimptagentry.h
View File

@ -34,9 +34,9 @@ typedef struct _GimpTagEntryClass GimpTagEntryClass;
struct _GimpTagEntry struct _GimpTagEntry
{ {
GtkEntry parent_instance; GtkEntry parent_instance;
GimpFilteredContainer *container; GimpTaggedContainer *container;
/* mask describes the meaning of each char in GimpTagEntry. /* mask describes the meaning of each char in GimpTagEntry.
* It is maintained automatically on insert-text and delete-text * It is maintained automatically on insert-text and delete-text
@ -49,18 +49,18 @@ struct _GimpTagEntry
* s - separator * s - separator
* w - whitespace. * w - whitespace.
*/ */
GString *mask; GString *mask;
GList *selected_items; GList *selected_items;
GList *common_tags; GList *common_tags;
GList *recent_list; GList *recent_list;
gint tab_completion_index; gint tab_completion_index;
gint internal_operation; gint internal_operation;
gint suppress_mask_update; gint suppress_mask_update;
gint suppress_tag_query; gint suppress_tag_query;
GimpTagEntryMode mode; GimpTagEntryMode mode;
gboolean description_shown; gboolean description_shown;
gboolean has_invalid_tags; gboolean has_invalid_tags;
gboolean tag_query_pending; gboolean tag_query_pending;
}; };
struct _GimpTagEntryClass struct _GimpTagEntryClass
@ -71,15 +71,16 @@ struct _GimpTagEntryClass
GType gimp_tag_entry_get_type (void) G_GNUC_CONST; GType gimp_tag_entry_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_tag_entry_new (GimpFilteredContainer *container, GtkWidget * gimp_tag_entry_new (GimpTaggedContainer *container,
GimpTagEntryMode mode); GimpTagEntryMode mode);
void gimp_tag_entry_set_selected_items (GimpTagEntry *entry, void gimp_tag_entry_set_selected_items (GimpTagEntry *entry,
GList *items); GList *items);
gchar ** gimp_tag_entry_parse_tags (GimpTagEntry *entry); gchar ** gimp_tag_entry_parse_tags (GimpTagEntry *entry);
void gimp_tag_entry_set_tag_string (GimpTagEntry *entry, void gimp_tag_entry_set_tag_string (GimpTagEntry *entry,
const gchar *tag_string); const gchar *tag_string);
const gchar * gimp_tag_entry_get_separator (void); const gchar * gimp_tag_entry_get_separator (void);
#endif /* __GIMP_TAG_ENTRY_H__ */ #endif /* __GIMP_TAG_ENTRY_H__ */

48
app/widgets/gimptagpopup.c
View File

@ -29,9 +29,9 @@
#include "core/gimpcontainer.h" #include "core/gimpcontainer.h"
#include "core/gimpcontext.h" #include "core/gimpcontext.h"
#include "core/gimpfilteredcontainer.h"
#include "core/gimptag.h" #include "core/gimptag.h"
#include "core/gimptagged.h" #include "core/gimptagged.h"
#include "core/gimptaggedcontainer.h"
#include "core/gimpviewable.h" #include "core/gimpviewable.h"
#include "gimpcombotagentry.h" #include "gimpcombotagentry.h"
@ -195,28 +195,28 @@ gimp_tag_popup_init (GimpTagPopup *popup)
static void static void
gimp_tag_popup_constructed (GObject *object) gimp_tag_popup_constructed (GObject *object)
{ {
GimpTagPopup *popup = GIMP_TAG_POPUP (object); GimpTagPopup *popup = GIMP_TAG_POPUP (object);
GimpFilteredContainer *container; GimpTaggedContainer *container;
GtkWidget *entry; GtkWidget *entry;
GtkAllocation entry_allocation; GtkAllocation entry_allocation;
GtkStyle *frame_style; GtkStyle *frame_style;
gint x; gint x;
gint y; gint y;
gint width; gint width;
gint height; gint height;
gint popup_height; gint popup_height;
GHashTable *tag_hash; GHashTable *tag_hash;
GList *tag_list; GList *tag_list;
GList *tag_iterator; GList *tag_iterator;
gint i; gint i;
gint j; gint j;
gint max_height; gint max_height;
gint screen_height; gint screen_height;
gchar **current_tags; gchar **current_tags;
gint current_count; gint current_count;
const gchar *list_tag; const gchar *list_tag;
GdkRectangle popup_rects[2]; /* variants of popup placement */ GdkRectangle popup_rects[2]; /* variants of popup placement */
GdkRectangle popup_rect; /* best popup rect in screen coordinates */ GdkRectangle popup_rect; /* best popup rect in screen coordinates */
if (G_OBJECT_CLASS (parent_class)->constructed) if (G_OBJECT_CLASS (parent_class)->constructed)
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
@ -1028,7 +1028,7 @@ gimp_tag_popup_toggle_tag (GimpTagPopup *popup,
if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY) if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{ {
GimpFilteredContainer *container; GimpTaggedContainer *container;
container = GIMP_TAG_ENTRY (popup->combo_entry)->container; container = GIMP_TAG_ENTRY (popup->combo_entry)->container;