AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
c3050231d1
gtk2/gtk/gtklistitemwidget.c

680 lines
22 KiB
C
Raw Normal View History

listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
/*
* Copyright © 2018 Benjamin Otte
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#include "config.h"
#include "gtklistitemwidgetprivate.h"
#include "gtkbinlayout.h"
#include "gtkeventcontrollerfocus.h"
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
#include "gtkeventcontrollermotion.h"
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
#include "gtkgestureclick.h"
#include "gtkintl.h"
#include "gtklistitemfactoryprivate.h"
#include "gtklistitemprivate.h"
listbase: Add rubberband selection Implement the typical rubberband selection, including autoscroll. This is only useful with multiselection, and not very compatible with single-click-activate. Therefore, it is not enabled by default, and needs to be turned on explicitly.
2019-12-22 00:07:11 +00:00
#include "gtklistbaseprivate.h"
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
#include "gtkmain.h"
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
#include "gtkselectionmodel.h"
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
#include "gtkwidget.h"
#include "gtkwidgetprivate.h"
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
typedef struct _GtkListItemWidgetPrivate GtkListItemWidgetPrivate;
struct _GtkListItemWidgetPrivate
{
GtkListItemFactory *factory;
GtkListItem *list_item;
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
GObject *item;
guint position;
gboolean selected;
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
gboolean single_click_activate;
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
};
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
enum {
PROP_0,
PROP_FACTORY,
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
PROP_SINGLE_CLICK_ACTIVATE,
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
N_PROPS
};
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
enum
{
ACTIVATE_SIGNAL,
LAST_SIGNAL
};
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (GtkListItemWidget, gtk_list_item_widget, GTK_TYPE_WIDGET)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
static GParamSpec *properties[N_PROPS] = { NULL, };
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
static guint signals[LAST_SIGNAL] = { 0 };
static void
gtk_list_item_widget_activate_signal (GtkListItemWidget *self)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->list_item && !priv->list_item->activatable)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return;
gtk_widget_activate_action (GTK_WIDGET (self),
"list.activate-item",
"u",
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
priv->position);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
static gboolean
gtk_list_item_widget_focus (GtkWidget *widget,
GtkDirectionType direction)
{
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
GtkWidget *child, *focus_child;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
/* The idea of this function is the following:
* 1. If any child can take focus, do not ever attempt
* to take focus.
* 2. Otherwise, if this item is selectable or activatable,
* allow focusing this widget.
*
* This makes sure every item in a list is focusable for
* activation and selection handling, but no useless widgets
* get focused and moving focus is as fast as possible.
*/
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
focus_child = gtk_widget_get_focus_child (widget);
if (focus_child && gtk_widget_child_focus (focus_child, direction))
return TRUE;
for (child = focus_child ? gtk_widget_get_next_sibling (focus_child)
: gtk_widget_get_first_child (widget);
child;
child = gtk_widget_get_next_sibling (child))
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
if (gtk_widget_child_focus (child, direction))
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return TRUE;
}
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
if (focus_child)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return FALSE;
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
if (gtk_widget_is_focus (widget))
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return FALSE;
return gtk_widget_grab_focus (widget);
}
static gboolean
gtk_list_item_widget_grab_focus (GtkWidget *widget)
{
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (widget);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
GtkWidget *child;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
listitemwidget: Fix focus handling for columnview ListItemWidget needs to be aware of potentially having multiple children, so make it aware.
2020-06-03 16:12:00 +00:00
for (child = gtk_widget_get_first_child (widget);
child;
child = gtk_widget_get_next_sibling (child))
{
if (gtk_widget_grab_focus (child))
return TRUE;
}
if (priv->list_item == NULL ||
!priv->list_item->selectable)
return FALSE;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return GTK_WIDGET_CLASS (gtk_list_item_widget_parent_class)->grab_focus (widget);
}
static void
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
gtk_list_item_widget_root (GtkWidget *widget)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (widget);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
GTK_WIDGET_CLASS (gtk_list_item_widget_parent_class)->root (widget);
if (priv->factory)
gtk_list_item_factory_setup (priv->factory, self);
}
static void
gtk_list_item_widget_unroot (GtkWidget *widget)
{
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (widget);
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
GTK_WIDGET_CLASS (gtk_list_item_widget_parent_class)->unroot (widget);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
if (priv->list_item)
gtk_list_item_factory_teardown (priv->factory, self);
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
}
static void
gtk_list_item_widget_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (object);
switch (property_id)
{
case PROP_FACTORY:
gtk_list_item_widget_set_factory (self, g_value_get_object (value));
break;
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
case PROP_SINGLE_CLICK_ACTIVATE:
gtk_list_item_widget_set_single_click_activate (self, g_value_get_boolean (value));
break;
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
}
static void
gtk_list_item_widget_dispose (GObject *object)
{
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (object);
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
g_assert (priv->list_item == NULL);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
g_clear_object (&priv->item);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
g_clear_object (&priv->factory);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
G_OBJECT_CLASS (gtk_list_item_widget_parent_class)->dispose (object);
}
static void
gtk_list_item_widget_select_action (GtkWidget *widget,
const char *action_name,
GVariant *parameter)
{
GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (widget);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
gboolean modify, extend;
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->list_item && !priv->list_item->selectable)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
return;
g_variant_get (parameter, "(bb)", &modify, &extend);
gtk_widget_activate_action (GTK_WIDGET (self),
"list.select-item",
"(ubb)",
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
priv->position, modify, extend);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
static void
gtk_list_item_widget_class_init (GtkListItemWidgetClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
klass->activate_signal = gtk_list_item_widget_activate_signal;
widget_class->focus = gtk_list_item_widget_focus;
widget_class->grab_focus = gtk_list_item_widget_grab_focus;
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
widget_class->root = gtk_list_item_widget_root;
widget_class->unroot = gtk_list_item_widget_unroot;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
gobject_class->set_property = gtk_list_item_widget_set_property;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
gobject_class->dispose = gtk_list_item_widget_dispose;
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
properties[PROP_FACTORY] =
g_param_spec_object ("factory",
"Factory",
"Factory managing this list item",
GTK_TYPE_LIST_ITEM_FACTORY,
G_PARAM_WRITABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
properties[PROP_SINGLE_CLICK_ACTIVATE] =
g_param_spec_boolean ("single-click-activate",
"Single click activate",
"Activate on single click",
FALSE,
G_PARAM_WRITABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
g_object_class_install_properties (gobject_class, N_PROPS, properties);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
signals[ACTIVATE_SIGNAL] =
g_signal_new (I_("activate-keybinding"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkListItemWidgetClass, activate_signal),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
Use function setter for WidgetClass.activate_signal
2020-12-04 23:12:20 +00:00
gtk_widget_class_set_activate_signal (widget_class, signals[ACTIVATE_SIGNAL]);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
/**
* GtkListItem|listitem.select:
* @modify: %TRUE to toggle the existing selection, %FALSE to select
* @extend: %TRUE to extend the selection
*
* Changes selection if the item is selectable.
* If the item is not selectable, nothing happens.
*
* This function will emit the list.select-item action and the resulting
* behavior, in particular the interpretation of @modify and @extend
* depends on the view containing this listitem. See for example
* GtkListView|list.select-item or GtkGridView|list.select-item.
*/
gtk_widget_class_install_action (widget_class,
"listitem.select",
"(bb)",
gtk_list_item_widget_select_action);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Return, 0,
"activate-keybinding", 0);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_ISO_Enter, 0,
"activate-keybinding", 0);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Enter, 0,
"activate-keybinding", 0);
/* note that some of these may get overwritten by child widgets,
* such as GtkTreeExpander */
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_space, 0,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_space, GDK_CONTROL_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_space, GDK_SHIFT_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_space, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Space, 0,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Space, GDK_CONTROL_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Space, GDK_SHIFT_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Space, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
"listitem.select", "(bb)", TRUE, FALSE);
/* This gets overwritten by gtk_list_item_widget_new() but better safe than sorry */
gtk_widget_class_set_css_name (widget_class, I_("row"));
gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
}
static void
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
gtk_list_item_widget_click_gesture_pressed (GtkGestureClick *gesture,
int n_press,
double x,
double y,
GtkListItemWidget *self)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
GtkWidget *widget = GTK_WIDGET (self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->list_item && !priv->list_item->selectable && !priv->list_item->activatable)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
return;
}
listitemwidget: Don't look at rubberbanding Move the selection changes to button release, to avoid conflict with the drag gesture for rubberbanding. This avoids peeking at the parent, and is generally nicer. Among other things, you can now shift-click to select a range in the colors demo in gtk4-demo.
2020-06-06 04:23:04 +00:00
if (!priv->list_item || priv->list_item->activatable)
{
if (n_press == 2 || priv->single_click_activate)
{
gtk_widget_activate_action (GTK_WIDGET (self),
"list.activate-item",
"u",
priv->position);
}
}
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_ACTIVE, FALSE);
if (gtk_widget_get_focus_on_click (widget))
gtk_widget_grab_focus (widget);
}
listbase: Add rubberband selection Implement the typical rubberband selection, including autoscroll. This is only useful with multiselection, and not very compatible with single-click-activate. Therefore, it is not enabled by default, and needs to be turned on explicitly.
2019-12-22 00:07:11 +00:00
listitemwidget: Don't look at rubberbanding Move the selection changes to button release, to avoid conflict with the drag gesture for rubberbanding. This avoids peeking at the parent, and is generally nicer. Among other things, you can now shift-click to select a range in the colors demo in gtk4-demo.
2020-06-06 04:23:04 +00:00
static void
gtk_list_item_widget_click_gesture_released (GtkGestureClick *gesture,
int n_press,
double x,
double y,
GtkListItemWidget *self)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
if (!priv->list_item || priv->list_item->selectable)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
GdkModifierType state;
GdkEvent *event;
gboolean extend, modify;
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture),
gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)));
state = gdk_event_get_modifier_state (event);
extend = (state & GDK_SHIFT_MASK) != 0;
modify = (state & GDK_CONTROL_MASK) != 0;
gtk_widget_activate_action (GTK_WIDGET (self),
"list.select-item",
"(ubb)",
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
priv->position, modify, extend);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
listitemwidget: Don't look at rubberbanding Move the selection changes to button release, to avoid conflict with the drag gesture for rubberbanding. This avoids peeking at the parent, and is generally nicer. Among other things, you can now shift-click to select a range in the colors demo in gtk4-demo.
2020-06-06 04:23:04 +00:00
gtk_widget_unset_state_flags (GTK_WIDGET (self), GTK_STATE_FLAG_ACTIVE);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
static void
gtk_list_item_widget_enter_cb (GtkEventControllerFocus *controller,
GtkListItemWidget *self)
{
GtkWidget *widget = GTK_WIDGET (self);
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
gtk_widget_activate_action (widget,
"list.scroll-to-item",
"u",
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
priv->position);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
static void
gtk_list_item_widget_hover_cb (GtkEventControllerMotion *controller,
double x,
double y,
GtkListItemWidget *self)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
if (!priv->single_click_activate)
return;
if (!priv->list_item || priv->list_item->selectable)
{
gtk_widget_activate_action (GTK_WIDGET (self),
"list.select-item",
"(ubb)",
priv->position, FALSE, FALSE);
}
}
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
static void
gtk_list_item_widget_click_gesture_canceled (GtkGestureClick *gesture,
GdkEventSequence *sequence,
GtkListItemWidget *self)
{
gtk_widget_unset_state_flags (GTK_WIDGET (self), GTK_STATE_FLAG_ACTIVE);
}
static void
gtk_list_item_widget_init (GtkListItemWidget *self)
{
GtkEventController *controller;
GtkGesture *gesture;
gtk_widget_set_focusable (GTK_WIDGET (self), TRUE);
gesture = gtk_gesture_click_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_BUBBLE);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture),
FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
GDK_BUTTON_PRIMARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_list_item_widget_click_gesture_pressed), self);
g_signal_connect (gesture, "released",
G_CALLBACK (gtk_list_item_widget_click_gesture_released), self);
g_signal_connect (gesture, "cancel",
G_CALLBACK (gtk_list_item_widget_click_gesture_canceled), self);
gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (gesture));
controller = gtk_event_controller_focus_new ();
g_signal_connect (controller, "enter", G_CALLBACK (gtk_list_item_widget_enter_cb), self);
gtk_widget_add_controller (GTK_WIDGET (self), controller);
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
controller = gtk_event_controller_motion_new ();
g_signal_connect (controller, "enter", G_CALLBACK (gtk_list_item_widget_hover_cb), self);
gtk_widget_add_controller (GTK_WIDGET (self), controller);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
GtkWidget *
gtk_list_item_widget_new (GtkListItemFactory *factory,
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
const char *css_name,
GtkAccessibleRole role)
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
{
g_return_val_if_fail (css_name != NULL, NULL);
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
return g_object_new (GTK_TYPE_LIST_ITEM_WIDGET,
"css-name", css_name,
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
"accessible-role", role,
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
"factory", factory,
NULL);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
void
gtk_list_item_widget_update (GtkListItemWidget *self,
guint position,
listitemfactory: Reorganize vfuncs Instead of bind/rebind/update/unbind, we now just have update, and the factories get to interpret that in the way they want.
2019-11-02 17:56:36 +00:00
gpointer item,
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
gboolean selected)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
if (priv->list_item)
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
gtk_list_item_factory_update (priv->factory, self, position, item, selected);
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
else
gtk_list_item_widget_default_update (self, NULL, position, item, selected);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
if (selected)
gtk_widget_set_state_flags (GTK_WIDGET (self), GTK_STATE_FLAG_SELECTED, FALSE);
else
gtk_widget_unset_state_flags (GTK_WIDGET (self), GTK_STATE_FLAG_SELECTED);
listview: Set accessible roles Use the LIST and LIST_ITEM roles for GtkListView and its children. Use the GRID and GRID_CELL roles for GtkGridView and its children.
2020-10-15 03:34:51 +00:00
gtk_accessible_update_state (GTK_ACCESSIBLE (self),
GTK_ACCESSIBLE_STATE_SELECTED, selected,
-1);
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
void
gtk_list_item_widget_default_setup (GtkListItemWidget *self,
GtkListItem *list_item)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
priv->list_item = list_item;
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
list_item->owner = self;
if (list_item->child)
gtk_list_item_widget_add_child (self, list_item->child);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->item)
g_object_notify (G_OBJECT (list_item), "item");
if (priv->position != GTK_INVALID_LIST_POSITION)
g_object_notify (G_OBJECT (list_item), "position");
if (priv->selected)
g_object_notify (G_OBJECT (list_item), "selected");
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
}
void
gtk_list_item_widget_default_teardown (GtkListItemWidget *self,
GtkListItem *list_item)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
g_assert (priv->list_item == list_item);
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
priv->list_item = NULL;
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
list_item->owner = NULL;
if (list_item->child)
gtk_list_item_widget_remove_child (self, list_item->child);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->item)
g_object_notify (G_OBJECT (list_item), "item");
if (priv->position != GTK_INVALID_LIST_POSITION)
g_object_notify (G_OBJECT (list_item), "position");
if (priv->selected)
g_object_notify (G_OBJECT (list_item), "selected");
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
}
void
gtk_list_item_widget_default_update (GtkListItemWidget *self,
GtkListItem *list_item,
guint position,
gpointer item,
gboolean selected)
{
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
/* FIXME: It's kinda evil to notify external objects from here... */
if (g_set_object (&priv->item, item))
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
{
if (list_item)
g_object_notify (G_OBJECT (list_item), "item");
}
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
if (priv->position != position)
{
priv->position = position;
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
if (list_item)
g_object_notify (G_OBJECT (list_item), "position");
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
}
if (priv->selected != selected)
{
priv->selected = selected;
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
if (list_item)
g_object_notify (G_OBJECT (list_item), "selected");
}
}
void
gtk_list_item_widget_set_factory (GtkListItemWidget *self,
GtkListItemFactory *factory)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
if (priv->factory == factory)
return;
if (priv->factory)
{
if (priv->list_item)
gtk_list_item_factory_teardown (factory, self);
g_clear_object (&priv->factory);
}
if (factory)
{
priv->factory = g_object_ref (factory);
if (gtk_widget_get_root (GTK_WIDGET (self)))
gtk_list_item_factory_setup (factory, self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
}
listitemwidget: Lazily create listitems We only create them in root/unroot (they should be created in appear/disappear, but that vfunc doesn't exist yet), that way we can avoid expensive work while the widget isn't used for anything.
2019-11-03 02:59:04 +00:00
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FACTORY]);
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
}
listitemwidget: Add single-click-activate Add a mode to GtkListItemWidget that activates on single click and selects on hover. Make GtkListItemManager set this on its items when its own 'property' of the same name is set.
2019-12-14 01:56:32 +00:00
void
gtk_list_item_widget_set_single_click_activate (GtkListItemWidget *self,
gboolean single_click_activate)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
if (priv->single_click_activate == single_click_activate)
return;
priv->single_click_activate = single_click_activate;
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SINGLE_CLICK_ACTIVATE]);
}
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
void
gtk_list_item_widget_add_child (GtkListItemWidget *self,
GtkWidget *child)
{
gtk_widget_set_parent (child, GTK_WIDGET (self));
}
listitemwidget: Add api to reorder children We need this to keep the rows in sync with the columns when they are reordered.
2020-06-05 16:39:00 +00:00
void
gtk_list_item_widget_reorder_child (GtkListItemWidget *self,
GtkWidget *child,
guint position)
{
GtkWidget *widget = GTK_WIDGET (self);
GtkWidget *sibling = NULL;
if (position > 0)
{
GtkWidget *c;
guint i;
for (c = gtk_widget_get_first_child (widget), i = 0;
c;
c = gtk_widget_get_next_sibling (c), i++)
{
if (i + 1 == position)
{
sibling = c;
break;
}
}
}
listview: Avoid a critical when reordering When sorting a cell into the place its already at, we were triggering criticals. Avoid that. Fixes: #3180
2020-09-24 02:53:21 +00:00
if (child != sibling)
listitemwidget: Remove unnecessary code gtk_widget_insert_after() reorders CSS nodes properly.
2020-10-20 01:54:07 +00:00
gtk_widget_insert_after (child, widget, sibling);
listitemwidget: Add api to reorder children We need this to keep the rows in sync with the columns when they are reordered.
2020-06-05 16:39:00 +00:00
}
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
void
gtk_list_item_widget_remove_child (GtkListItemWidget *self,
GtkWidget *child)
{
gtk_widget_unparent (child);
}
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
GtkListItem *
gtk_list_item_widget_get_list_item (GtkListItemWidget *self)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
return priv->list_item;
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
}
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
guint
gtk_list_item_widget_get_position (GtkListItemWidget *self)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
return priv->position;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
gpointer
gtk_list_item_widget_get_item (GtkListItemWidget *self)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
return priv->item;
listitem: Make this a GObject This splits GtkListItem into 2 parts: 1. GtkListItem This is purely a GObject with public API for developers who want to populate lists. There is no chance to cause conflict with GtkWidget properties that the list implementation assumed control over and defines a clear boundary. 2. GtkListItemWidget The widget part of the listitem. This is not only fully in control of the list machinery, the machinery can also use different widget implementations for different list widgets like I inted to for GtkColumnView.
2019-11-01 06:31:38 +00:00
}
listitemfactory: Reorganize vfuncs Instead of bind/rebind/update/unbind, we now just have update, and the factories get to interpret that in the way they want.
2019-11-02 17:56:36 +00:00
gboolean
gtk_list_item_widget_get_selected (GtkListItemWidget *self)
{
listitemwidget: Add a private struct I had to rename the item property to list_item anyway, so I could just do the next step with it.
2019-11-03 02:17:37 +00:00
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitem: Move position/item/selected tracking to widget This way, we can ensure it's always there when we need it (before the item gets created) and gone when we don't (if some GC language holds on to the item after we've destroyed the widget).
2019-11-03 02:34:56 +00:00
return priv->selected;
listitemfactory: Reorganize vfuncs Instead of bind/rebind/update/unbind, we now just have update, and the factories get to interpret that in the way they want.
2019-11-02 17:56:36 +00:00
}
Reference in New Issue Copy Permalink