PIKApp/app/widgets/pikacontainerview.c

1424 lines
48 KiB
C

/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* pikacontainerview.c
* Copyright (C) 2001-2010 Michael Natterer <mitch@gimp.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 <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include "libpikabase/pikabase.h"
#include "libpikawidgets/pikawidgets.h"
#include "widgets-types.h"
#include "core/pikacontainer.h"
#include "core/pikacontext.h"
#include "core/pikamarshal.h"
#include "core/pikatreehandler.h"
#include "core/pikaviewable.h"
#include "pikacontainerview.h"
#include "pikadnd.h"
#include "pikaviewrenderer.h"
#include "pikauimanager.h"
#include "pikacontainertreeview.h"
enum
{
SELECT_ITEMS,
ACTIVATE_ITEM,
LAST_SIGNAL
};
#define PIKA_CONTAINER_VIEW_GET_PRIVATE(obj) (pika_container_view_get_private ((PikaContainerView *) (obj)))
typedef struct _PikaContainerViewPrivate PikaContainerViewPrivate;
struct _PikaContainerViewPrivate
{
PikaContainer *container;
PikaContext *context;
GHashTable *item_hash;
gint view_size;
gint view_border_width;
gboolean reorderable;
GtkSelectionMode selection_mode;
/* initialized by subclass */
GtkWidget *dnd_widget;
PikaTreeHandler *name_changed_handler;
PikaTreeHandler *expanded_changed_handler;
};
/* local function prototypes */
static PikaContainerViewPrivate *
pika_container_view_get_private (PikaContainerView *view);
static void pika_container_view_real_set_container (PikaContainerView *view,
PikaContainer *container);
static void pika_container_view_real_set_context (PikaContainerView *view,
PikaContext *context);
static void pika_container_view_real_set_selection_mode (PikaContainerView *view,
GtkSelectionMode mode);
static void pika_container_view_clear_items (PikaContainerView *view);
static void pika_container_view_real_clear_items (PikaContainerView *view);
static gint pika_container_view_real_get_selected (PikaContainerView *view,
GList **list,
GList **paths);
static void pika_container_view_add_container (PikaContainerView *view,
PikaContainer *container);
static void pika_container_view_add_foreach (PikaViewable *viewable,
PikaContainerView *view);
static void pika_container_view_add (PikaContainerView *view,
PikaViewable *viewable,
PikaContainer *container);
static void pika_container_view_remove_container (PikaContainerView *view,
PikaContainer *container);
static void pika_container_view_remove_foreach (PikaViewable *viewable,
PikaContainerView *view);
static void pika_container_view_remove (PikaContainerView *view,
PikaViewable *viewable,
PikaContainer *container);
static void pika_container_view_reorder (PikaContainerView *view,
PikaViewable *viewable,
gint new_index,
PikaContainer *container);
static void pika_container_view_freeze (PikaContainerView *view,
PikaContainer *container);
static void pika_container_view_thaw (PikaContainerView *view,
PikaContainer *container);
static void pika_container_view_name_changed (PikaViewable *viewable,
PikaContainerView *view);
static void pika_container_view_expanded_changed (PikaViewable *viewable,
PikaContainerView *view);
static void pika_container_view_connect_context (PikaContainerView *view);
static void pika_container_view_disconnect_context (PikaContainerView *view);
static void pika_container_view_context_changed (PikaContext *context,
PikaViewable *viewable,
PikaContainerView *view);
static void pika_container_view_viewable_dropped (GtkWidget *widget,
gint x,
gint y,
PikaViewable *viewable,
gpointer data);
static void pika_container_view_button_viewables_dropped (GtkWidget *widget,
gint x,
gint y,
GList *viewables,
gpointer data);
static void pika_container_view_button_viewable_dropped (GtkWidget *widget,
gint x,
gint y,
PikaViewable *viewable,
gpointer data);
G_DEFINE_INTERFACE (PikaContainerView, pika_container_view, GTK_TYPE_WIDGET)
static guint view_signals[LAST_SIGNAL] = { 0 };
static void
pika_container_view_default_init (PikaContainerViewInterface *iface)
{
view_signals[SELECT_ITEMS] =
g_signal_new ("select-items",
G_TYPE_FROM_INTERFACE (iface),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (PikaContainerViewInterface, select_items),
NULL, NULL,
NULL,
G_TYPE_BOOLEAN, 2,
G_TYPE_POINTER,
G_TYPE_POINTER);
view_signals[ACTIVATE_ITEM] =
g_signal_new ("activate-item",
G_TYPE_FROM_INTERFACE (iface),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (PikaContainerViewInterface, activate_item),
NULL, NULL,
pika_marshal_VOID__OBJECT_POINTER,
G_TYPE_NONE, 2,
PIKA_TYPE_OBJECT,
G_TYPE_POINTER);
iface->select_items = NULL;
iface->activate_item = NULL;
iface->set_container = pika_container_view_real_set_container;
iface->set_context = pika_container_view_real_set_context;
iface->set_selection_mode = pika_container_view_real_set_selection_mode;
iface->insert_item = NULL;
iface->insert_items_after = NULL;
iface->remove_item = NULL;
iface->reorder_item = NULL;
iface->rename_item = NULL;
iface->expand_item = NULL;
iface->clear_items = pika_container_view_real_clear_items;
iface->set_view_size = NULL;
iface->get_selected = pika_container_view_real_get_selected;
iface->insert_data_free = NULL;
iface->model_is_tree = FALSE;
g_object_interface_install_property (iface,
g_param_spec_object ("container",
NULL, NULL,
PIKA_TYPE_CONTAINER,
PIKA_PARAM_READWRITE));
g_object_interface_install_property (iface,
g_param_spec_object ("context",
NULL, NULL,
PIKA_TYPE_CONTEXT,
PIKA_PARAM_READWRITE));
g_object_interface_install_property (iface,
g_param_spec_enum ("selection-mode",
NULL, NULL,
GTK_TYPE_SELECTION_MODE,
GTK_SELECTION_SINGLE,
PIKA_PARAM_READWRITE));
g_object_interface_install_property (iface,
g_param_spec_boolean ("reorderable",
NULL, NULL,
FALSE,
PIKA_PARAM_READWRITE));
g_object_interface_install_property (iface,
g_param_spec_int ("view-size",
NULL, NULL,
1, PIKA_VIEWABLE_MAX_PREVIEW_SIZE,
PIKA_VIEW_SIZE_MEDIUM,
PIKA_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_interface_install_property (iface,
g_param_spec_int ("view-border-width",
NULL, NULL,
0,
PIKA_VIEW_MAX_BORDER_WIDTH,
1,
PIKA_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
}
static void
pika_container_view_private_dispose (PikaContainerView *view,
PikaContainerViewPrivate *private)
{
if (private->container)
pika_container_view_set_container (view, NULL);
if (private->context)
pika_container_view_set_context (view, NULL);
}
static void
pika_container_view_private_finalize (PikaContainerViewPrivate *private)
{
if (private->item_hash)
{
g_hash_table_destroy (private->item_hash);
private->item_hash = NULL;
}
g_clear_pointer (&private->name_changed_handler,
pika_tree_handler_disconnect);
g_clear_pointer (&private->expanded_changed_handler,
pika_tree_handler_disconnect);
g_slice_free (PikaContainerViewPrivate, private);
}
/**
* pika_container_view_install_properties:
* @klass: the class structure for a type deriving from #GObject
*
* Installs the necessary properties for a class implementing
* #PikaContainerView. A #PikaContainerViewProp property is installed
* for each property, using the values from the #PikaContainerViewProp
* enumeration. The caller must make sure itself that the enumeration
* values don't collide with some other property values they
* are using (that's what %PIKA_CONTAINER_VIEW_PROP_LAST is good for).
**/
void
pika_container_view_install_properties (GObjectClass *klass)
{
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_CONTAINER,
"container");
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_CONTEXT,
"context");
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_SELECTION_MODE,
"selection-mode");
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_REORDERABLE,
"reorderable");
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_VIEW_SIZE,
"view-size");
g_object_class_override_property (klass,
PIKA_CONTAINER_VIEW_PROP_VIEW_BORDER_WIDTH,
"view-border-width");
}
PikaContainer *
pika_container_view_get_container (PikaContainerView *view)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), NULL);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return private->container;
}
void
pika_container_view_set_container (PikaContainerView *view,
PikaContainer *container)
{
PikaContainerViewPrivate *private;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (container == NULL || PIKA_IS_CONTAINER (container));
if (container)
g_return_if_fail (g_type_is_a (pika_container_get_children_type (container),
PIKA_TYPE_VIEWABLE));
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (container != private->container)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->set_container (view, container);
g_object_notify (G_OBJECT (view), "container");
}
}
PikaContext *
pika_container_view_get_context (PikaContainerView *view)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), NULL);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return private->context;
}
void
pika_container_view_set_context (PikaContainerView *view,
PikaContext *context)
{
PikaContainerViewPrivate *private;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (context == NULL || PIKA_IS_CONTEXT (context));
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (context != private->context)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->set_context (view, context);
g_object_notify (G_OBJECT (view), "context");
}
}
GtkSelectionMode
pika_container_view_get_selection_mode (PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return private->selection_mode;
}
void
pika_container_view_set_selection_mode (PikaContainerView *view,
GtkSelectionMode mode)
{
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (mode == GTK_SELECTION_SINGLE ||
mode == GTK_SELECTION_MULTIPLE);
PIKA_CONTAINER_VIEW_GET_IFACE (view)->set_selection_mode (view, mode);
}
gint
pika_container_view_get_view_size (PikaContainerView *view,
gint *view_border_width)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), 0);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (view_border_width)
*view_border_width = private->view_border_width;
return private->view_size;
}
void
pika_container_view_set_view_size (PikaContainerView *view,
gint view_size,
gint view_border_width)
{
PikaContainerViewPrivate *private;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (view_size > 0 &&
view_size <= PIKA_VIEWABLE_MAX_PREVIEW_SIZE);
g_return_if_fail (view_border_width >= 0 &&
view_border_width <= PIKA_VIEW_MAX_BORDER_WIDTH);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (private->view_size != view_size ||
private->view_border_width != view_border_width)
{
private->view_size = view_size;
private->view_border_width = view_border_width;
PIKA_CONTAINER_VIEW_GET_IFACE (view)->set_view_size (view);
g_object_freeze_notify (G_OBJECT (view));
g_object_notify (G_OBJECT (view), "view-size");
g_object_notify (G_OBJECT (view), "view-border-width");
g_object_thaw_notify (G_OBJECT (view));
}
}
gboolean
pika_container_view_get_reorderable (PikaContainerView *view)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), FALSE);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return private->reorderable;
}
void
pika_container_view_set_reorderable (PikaContainerView *view,
gboolean reorderable)
{
PikaContainerViewPrivate *private;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
private->reorderable = reorderable ? TRUE : FALSE;
g_object_notify (G_OBJECT (view), "reorderable");
}
GtkWidget *
pika_container_view_get_dnd_widget (PikaContainerView *view)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), NULL);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return private->dnd_widget;
}
void
pika_container_view_set_dnd_widget (PikaContainerView *view,
GtkWidget *dnd_widget)
{
PikaContainerViewPrivate *private;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (dnd_widget == NULL || GTK_IS_WIDGET (dnd_widget));
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
private->dnd_widget = dnd_widget;
}
void
pika_container_view_enable_dnd (PikaContainerView *view,
GtkButton *button,
GType children_type)
{
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (GTK_IS_BUTTON (button));
pika_dnd_viewable_list_dest_add (GTK_WIDGET (button),
children_type,
pika_container_view_button_viewables_dropped,
view);
pika_dnd_viewable_dest_add (GTK_WIDGET (button),
children_type,
pika_container_view_button_viewable_dropped,
view);
}
gboolean
pika_container_view_select_items (PikaContainerView *view,
GList *viewables)
{
PikaContainerViewPrivate *private;
gboolean success = FALSE;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), FALSE);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (pika_container_frozen (private->container))
return TRUE;
g_signal_emit (view, view_signals[SELECT_ITEMS], 0,
viewables, NULL, &success);
return success;
}
/* Mostly a convenience function calling the more generic
* pika_container_view_select_items().
* This is to be used when you want to select one viewable only (or
* because the container this is called from only handles single
* selection anyway).
*/
gboolean
pika_container_view_select_item (PikaContainerView *view,
PikaViewable *viewable)
{
GList *viewables = NULL;
gboolean success;
if (viewable)
viewables = g_list_prepend (viewables, viewable);
success = pika_container_view_select_items (view, viewables);
g_list_free (viewables);
return success;
}
void
pika_container_view_activate_item (PikaContainerView *view,
PikaViewable *viewable)
{
PikaContainerViewPrivate *private;
gpointer insert_data;
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (PIKA_IS_VIEWABLE (viewable));
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (pika_container_frozen (private->container))
return;
insert_data = g_hash_table_lookup (private->item_hash, viewable);
g_signal_emit (view, view_signals[ACTIVATE_ITEM], 0,
viewable, insert_data);
}
gpointer
pika_container_view_lookup (PikaContainerView *view,
PikaViewable *viewable)
{
PikaContainerViewPrivate *private;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), NULL);
g_return_val_if_fail (viewable == NULL || PIKA_IS_VIEWABLE (viewable), NULL);
/* we handle the NULL viewable here as a workaround for bug #149906 */
if (! viewable)
return NULL;
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
return g_hash_table_lookup (private->item_hash, viewable);
}
gboolean
pika_container_view_contains (PikaContainerView *view,
GList *viewables)
{
PikaContainerViewPrivate *private;
GList *iter;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), FALSE);
g_return_val_if_fail (viewables, FALSE);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
for (iter = viewables; iter; iter = iter->next)
{
if (! g_hash_table_contains (private->item_hash, iter->data))
return FALSE;
}
return TRUE;
}
gboolean
pika_container_view_item_selected (PikaContainerView *view,
PikaViewable *viewable)
{
PikaContainerViewPrivate *private;
gboolean success;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), FALSE);
g_return_val_if_fail (PIKA_IS_VIEWABLE (viewable), FALSE);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
/* HACK */
if (private->container && private->context)
{
GType children_type;
const gchar *signal_name;
children_type = pika_container_get_children_type (private->container);
signal_name = pika_context_type_to_signal_name (children_type);
if (signal_name)
{
pika_context_set_by_type (private->context, children_type,
PIKA_OBJECT (viewable));
return TRUE;
}
}
success = pika_container_view_select_item (view, viewable);
#if 0
if (success && private->container && private->context)
{
PikaContext *context;
GType children_type;
/* ref and remember the context because private->context may
* become NULL by calling pika_context_set_by_type()
*/
context = g_object_ref (private->context);
children_type = pika_container_get_children_type (private->container);
g_signal_handlers_block_by_func (context,
pika_container_view_context_changed,
view);
pika_context_set_by_type (context, children_type, PIKA_OBJECT (viewable));
g_signal_handlers_unblock_by_func (context,
pika_container_view_context_changed,
view);
g_object_unref (context);
}
#endif
return success;
}
gboolean
pika_container_view_multi_selected (PikaContainerView *view,
GList *items,
GList *items_data)
{
gboolean success = FALSE;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), FALSE);
g_signal_emit (view, view_signals[SELECT_ITEMS], 0,
items, items_data, &success);
return success;
}
/**
* pika_container_view_get_selected:
* @view:
* @items:
* @items_data:
*
* Get the selected items in @view.
*
* If @items is not %NULL, fills it with a newly allocated #GList of the
* selected items.
* If @items_data is not %NULL and if the implementing class associates
* data to its contents, it will be filled with a newly allocated #GList
* of the same size as @items, or will be %NULL otherwise. It is up to
* the class to decide what type of data is passed along.
*
* Note that by default, the interface only implements some basic single
* selection. Override select_items() signal to get more complete
* selection support.
*
* Returns: the number of selected items.
*/
gint
pika_container_view_get_selected (PikaContainerView *view,
GList **items,
GList **items_data)
{
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), 0);
return PIKA_CONTAINER_VIEW_GET_IFACE (view)->get_selected (view, items, items_data);
}
gboolean
pika_container_view_is_item_selected (PikaContainerView *view,
PikaViewable *viewable)
{
GList *items;
gboolean found;
pika_container_view_get_selected (view, &items, NULL);
found = (g_list_find (items, viewable) != NULL);
g_list_free (items);
return found;
}
void
pika_container_view_item_activated (PikaContainerView *view,
PikaViewable *viewable)
{
g_return_if_fail (PIKA_IS_CONTAINER_VIEW (view));
g_return_if_fail (PIKA_IS_VIEWABLE (viewable));
pika_container_view_activate_item (view, viewable);
}
void
pika_container_view_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaContainerView *view = PIKA_CONTAINER_VIEW (object);
switch (property_id)
{
case PIKA_CONTAINER_VIEW_PROP_CONTAINER:
pika_container_view_set_container (view, g_value_get_object (value));
break;
case PIKA_CONTAINER_VIEW_PROP_CONTEXT:
pika_container_view_set_context (view, g_value_get_object (value));
break;
case PIKA_CONTAINER_VIEW_PROP_SELECTION_MODE:
pika_container_view_set_selection_mode (view, g_value_get_enum (value));
break;
case PIKA_CONTAINER_VIEW_PROP_REORDERABLE:
pika_container_view_set_reorderable (view, g_value_get_boolean (value));
break;
case PIKA_CONTAINER_VIEW_PROP_VIEW_SIZE:
case PIKA_CONTAINER_VIEW_PROP_VIEW_BORDER_WIDTH:
{
gint size;
gint border = 0;
size = pika_container_view_get_view_size (view, &border);
if (property_id == PIKA_CONTAINER_VIEW_PROP_VIEW_SIZE)
size = g_value_get_int (value);
else
border = g_value_get_int (value);
pika_container_view_set_view_size (view, size, border);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
pika_container_view_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaContainerView *view = PIKA_CONTAINER_VIEW (object);
switch (property_id)
{
case PIKA_CONTAINER_VIEW_PROP_CONTAINER:
g_value_set_object (value, pika_container_view_get_container (view));
break;
case PIKA_CONTAINER_VIEW_PROP_CONTEXT:
g_value_set_object (value, pika_container_view_get_context (view));
break;
case PIKA_CONTAINER_VIEW_PROP_SELECTION_MODE:
g_value_set_enum (value, pika_container_view_get_selection_mode (view));
break;
case PIKA_CONTAINER_VIEW_PROP_REORDERABLE:
g_value_set_boolean (value, pika_container_view_get_reorderable (view));
break;
case PIKA_CONTAINER_VIEW_PROP_VIEW_SIZE:
case PIKA_CONTAINER_VIEW_PROP_VIEW_BORDER_WIDTH:
{
gint size;
gint border = 0;
size = pika_container_view_get_view_size (view, &border);
if (property_id == PIKA_CONTAINER_VIEW_PROP_VIEW_SIZE)
g_value_set_int (value, size);
else
g_value_set_int (value, border);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/* Private functions */
static PikaContainerViewPrivate *
pika_container_view_get_private (PikaContainerView *view)
{
PikaContainerViewPrivate *private;
static GQuark private_key = 0;
g_return_val_if_fail (PIKA_IS_CONTAINER_VIEW (view), NULL);
if (! private_key)
private_key = g_quark_from_static_string ("pika-container-view-private");
private = g_object_get_qdata ((GObject *) view, private_key);
if (! private)
{
PikaContainerViewInterface *view_iface;
view_iface = PIKA_CONTAINER_VIEW_GET_IFACE (view);
private = g_slice_new0 (PikaContainerViewPrivate);
private->view_border_width = 1;
private->item_hash = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
view_iface->insert_data_free);
g_object_set_qdata_full ((GObject *) view, private_key, private,
(GDestroyNotify) pika_container_view_private_finalize);
g_signal_connect (view, "destroy",
G_CALLBACK (pika_container_view_private_dispose),
private);
}
return private;
}
static void
pika_container_view_real_set_container (PikaContainerView *view,
PikaContainer *container)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (private->container)
{
if (private->context)
pika_container_view_disconnect_context (view);
pika_container_view_select_items (view, NULL);
/* freeze/thaw is only supported for the toplevel container */
g_signal_handlers_disconnect_by_func (private->container,
pika_container_view_freeze,
view);
g_signal_handlers_disconnect_by_func (private->container,
pika_container_view_thaw,
view);
if (! pika_container_frozen (private->container))
pika_container_view_remove_container (view, private->container);
}
private->container = container;
if (private->container)
{
if (! pika_container_frozen (private->container))
pika_container_view_add_container (view, private->container);
/* freeze/thaw is only supported for the toplevel container */
g_signal_connect_object (private->container, "freeze",
G_CALLBACK (pika_container_view_freeze),
view,
G_CONNECT_SWAPPED);
g_signal_connect_object (private->container, "thaw",
G_CALLBACK (pika_container_view_thaw),
view,
G_CONNECT_SWAPPED);
if (private->context)
pika_container_view_connect_context (view);
}
}
static void
pika_container_view_real_set_context (PikaContainerView *view,
PikaContext *context)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (private->context &&
private->container)
{
pika_container_view_disconnect_context (view);
}
g_set_object (&private->context, context);
if (private->context &&
private->container)
{
pika_container_view_connect_context (view);
}
}
static void
pika_container_view_real_set_selection_mode (PikaContainerView *view,
GtkSelectionMode mode)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
private->selection_mode = mode;
}
static void
pika_container_view_clear_items (PikaContainerView *view)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->clear_items (view);
}
static void
pika_container_view_real_clear_items (PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
g_hash_table_remove_all (private->item_hash);
}
static gint
pika_container_view_real_get_selected (PikaContainerView *view,
GList **items,
GList **items_data)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
GType children_type;
PikaObject *object;
if (items)
*items = NULL;
/* In base interface, @items_data just stays NULL. We don't have a
* concept for it. Classes implementing this interface may want to
* store and pass data for their items, but they will have to
* implement themselves which data, and pass through with this
* parameter.
*/
if (items_data)
*items_data = NULL;
if (! private->container || ! private->context)
return 0;
children_type = pika_container_get_children_type (private->container);
if (pika_context_type_to_property (children_type) == -1)
{
/* If you experience this warning, it means you should implement
* your own definition for get_selected() because the default one
* won't work for you (only made for context properties).
*/
g_warning ("%s: TODO: implement PikaContainerViewInterface's get_selected() for type '%s'.\n",
G_STRFUNC, g_type_name (G_OBJECT_TYPE (view)));
return 0;
}
object = pika_context_get_by_type (private->context,
children_type);
/* Base interface provides the API for multi-selection but only
* implements single selection. Classes must implement their own
* multi-selection.
*/
if (items && object)
*items = g_list_append (*items, object);
return object ? 1 : 0;
}
static void
pika_container_view_add_container (PikaContainerView *view,
PikaContainer *container)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
pika_container_foreach (container,
(GFunc) pika_container_view_add_foreach,
view);
if (container == private->container)
{
GType children_type;
PikaViewableClass *viewable_class;
children_type = pika_container_get_children_type (container);
viewable_class = g_type_class_ref (children_type);
private->name_changed_handler =
pika_tree_handler_connect (container,
viewable_class->name_changed_signal,
G_CALLBACK (pika_container_view_name_changed),
view);
if (PIKA_CONTAINER_VIEW_GET_IFACE (view)->expand_item)
{
private->expanded_changed_handler =
pika_tree_handler_connect (container,
"expanded-changed",
G_CALLBACK (pika_container_view_expanded_changed),
view);
}
g_type_class_unref (viewable_class);
}
g_signal_connect_object (container, "add",
G_CALLBACK (pika_container_view_add),
view,
G_CONNECT_SWAPPED);
g_signal_connect_object (container, "remove",
G_CALLBACK (pika_container_view_remove),
view,
G_CONNECT_SWAPPED);
g_signal_connect_object (container, "reorder",
G_CALLBACK (pika_container_view_reorder),
view,
G_CONNECT_SWAPPED);
}
static void
pika_container_view_add_foreach (PikaViewable *viewable,
PikaContainerView *view)
{
PikaContainerViewInterface *view_iface;
PikaContainerViewPrivate *private;
PikaViewable *parent;
PikaContainer *children;
gpointer parent_insert_data = NULL;
gpointer insert_data;
view_iface = PIKA_CONTAINER_VIEW_GET_IFACE (view);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
parent = pika_viewable_get_parent (viewable);
if (parent)
parent_insert_data = g_hash_table_lookup (private->item_hash, parent);
insert_data = view_iface->insert_item (view, viewable,
parent_insert_data, -1);
g_hash_table_insert (private->item_hash, viewable, insert_data);
children = pika_viewable_get_children (viewable);
if (children)
pika_container_view_add_container (view, children);
}
static void
pika_container_view_add (PikaContainerView *view,
PikaViewable *viewable,
PikaContainer *container)
{
PikaContainerViewInterface *view_iface;
PikaContainerViewPrivate *private;
PikaViewable *parent;
PikaContainer *children;
gpointer parent_insert_data = NULL;
gpointer insert_data;
gint index;
view_iface = PIKA_CONTAINER_VIEW_GET_IFACE (view);
private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
index = pika_container_get_child_index (container,
PIKA_OBJECT (viewable));
parent = pika_viewable_get_parent (viewable);
if (parent)
parent_insert_data = g_hash_table_lookup (private->item_hash, parent);
insert_data = view_iface->insert_item (view, viewable,
parent_insert_data, index);
g_hash_table_insert (private->item_hash, viewable, insert_data);
if (view_iface->insert_items_after)
view_iface->insert_items_after (view);
children = pika_viewable_get_children (viewable);
if (children)
pika_container_view_add_container (view, children);
}
static void
pika_container_view_remove_container (PikaContainerView *view,
PikaContainer *container)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
g_object_ref (container);
g_signal_handlers_disconnect_by_func (container,
pika_container_view_add,
view);
g_signal_handlers_disconnect_by_func (container,
pika_container_view_remove,
view);
g_signal_handlers_disconnect_by_func (container,
pika_container_view_reorder,
view);
if (container == private->container)
{
g_clear_pointer (&private->name_changed_handler,
pika_tree_handler_disconnect);
g_clear_pointer (&private->expanded_changed_handler,
pika_tree_handler_disconnect);
/* optimization: when the toplevel container gets removed, call
* clear_items() which will get rid of all view widget stuff
* *and* empty private->item_hash, so below call to
* remove_foreach() will only disconnect all containers but not
* remove all items individually (because they are gone from
* item_hash).
*/
pika_container_view_clear_items (view);
}
pika_container_foreach (container,
(GFunc) pika_container_view_remove_foreach,
view);
g_object_unref (container);
}
static void
pika_container_view_remove_foreach (PikaViewable *viewable,
PikaContainerView *view)
{
pika_container_view_remove (view, viewable, NULL);
}
static void
pika_container_view_remove (PikaContainerView *view,
PikaViewable *viewable,
PikaContainer *unused)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
PikaContainer *children;
gpointer insert_data;
children = pika_viewable_get_children (viewable);
if (children)
pika_container_view_remove_container (view, children);
insert_data = g_hash_table_lookup (private->item_hash, viewable);
if (insert_data)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->remove_item (view, viewable, insert_data);
g_hash_table_remove (private->item_hash, viewable);
}
}
static void
pika_container_view_reorder (PikaContainerView *view,
PikaViewable *viewable,
gint new_index,
PikaContainer *container)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
gpointer insert_data;
insert_data = g_hash_table_lookup (private->item_hash, viewable);
if (insert_data)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->reorder_item (view,
viewable,
new_index,
insert_data);
}
}
static void
pika_container_view_freeze (PikaContainerView *view,
PikaContainer *container)
{
pika_container_view_remove_container (view, container);
}
static void
pika_container_view_thaw (PikaContainerView *view,
PikaContainer *container)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
pika_container_view_add_container (view, container);
if (private->context)
{
GType children_type;
const gchar *signal_name;
children_type = pika_container_get_children_type (private->container);
signal_name = pika_context_type_to_signal_name (children_type);
if (signal_name)
{
PikaObject *object;
object = pika_context_get_by_type (private->context, children_type);
pika_container_view_select_item (view, PIKA_VIEWABLE (object));
}
}
}
static void
pika_container_view_name_changed (PikaViewable *viewable,
PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
gpointer insert_data;
insert_data = g_hash_table_lookup (private->item_hash, viewable);
if (insert_data)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->rename_item (view,
viewable,
insert_data);
}
}
static void
pika_container_view_expanded_changed (PikaViewable *viewable,
PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
gpointer insert_data;
insert_data = g_hash_table_lookup (private->item_hash, viewable);
if (insert_data)
{
PIKA_CONTAINER_VIEW_GET_IFACE (view)->expand_item (view,
viewable,
insert_data);
}
}
static void
pika_container_view_connect_context (PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
GType children_type;
const gchar *signal_name;
children_type = pika_container_get_children_type (private->container);
signal_name = pika_context_type_to_signal_name (children_type);
if (signal_name)
{
g_signal_connect_object (private->context, signal_name,
G_CALLBACK (pika_container_view_context_changed),
view,
0);
if (private->dnd_widget)
pika_dnd_viewable_dest_add (private->dnd_widget,
children_type,
pika_container_view_viewable_dropped,
view);
if (! pika_container_frozen (private->container))
{
PikaObject *object = pika_context_get_by_type (private->context,
children_type);
pika_container_view_select_item (view, PIKA_VIEWABLE (object));
}
}
}
static void
pika_container_view_disconnect_context (PikaContainerView *view)
{
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
GType children_type;
const gchar *signal_name;
children_type = pika_container_get_children_type (private->container);
signal_name = pika_context_type_to_signal_name (children_type);
if (signal_name)
{
g_signal_handlers_disconnect_by_func (private->context,
pika_container_view_context_changed,
view);
if (private->dnd_widget)
{
gtk_drag_dest_unset (private->dnd_widget);
pika_dnd_viewable_dest_remove (private->dnd_widget,
children_type);
}
}
}
static void
pika_container_view_context_changed (PikaContext *context,
PikaViewable *viewable,
PikaContainerView *view)
{
GList *viewables = NULL;
if (viewable)
viewables = g_list_prepend (viewables, viewable);
g_signal_handlers_block_by_func (context,
pika_container_view_context_changed,
view);
if (! pika_container_view_select_items (view, viewables))
g_warning ("%s: select_items() failed (should not happen)", G_STRFUNC);
g_signal_handlers_unblock_by_func (context,
pika_container_view_context_changed,
view);
g_list_free (viewables);
}
static void
pika_container_view_viewable_dropped (GtkWidget *widget,
gint x,
gint y,
PikaViewable *viewable,
gpointer data)
{
PikaContainerView *view = PIKA_CONTAINER_VIEW (data);
PikaContainerViewPrivate *private = PIKA_CONTAINER_VIEW_GET_PRIVATE (view);
if (viewable && private->container &&
pika_container_have (private->container, PIKA_OBJECT (viewable)))
{
pika_container_view_item_selected (view, viewable);
}
}
static void
pika_container_view_button_viewables_dropped (GtkWidget *widget,
gint x,
gint y,
GList *viewables,
gpointer data)
{
PikaContainerView *view = PIKA_CONTAINER_VIEW (data);
if (viewables)
{
pika_container_view_multi_selected (view, viewables, NULL);
gtk_button_clicked (GTK_BUTTON (widget));
}
}
static void
pika_container_view_button_viewable_dropped (GtkWidget *widget,
gint x,
gint y,
PikaViewable *viewable,
gpointer data)
{
PikaContainerView *view = PIKA_CONTAINER_VIEW (data);
if (viewable && pika_container_view_lookup (view, viewable))
{
pika_container_view_item_selected (view, viewable);
gtk_button_clicked (GTK_BUTTON (widget));
}
}