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

762 lines
25 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 "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);
}
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
static void
gtk_list_item_widget_setup_func (gpointer object,
gpointer data)
{
GtkListItemWidget *self = data;
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
GtkListItem *list_item = object;
priv->list_item = list_item;
list_item->owner = self;
if (list_item->child)
gtk_list_item_widget_add_child (self, list_item->child);
gtk_list_item_widget_set_activatable (self, list_item->activatable);
gtk_list_item_do_notify (list_item,
priv->item != NULL,
priv->position != GTK_INVALID_LIST_POSITION,
priv->selected);
}
static void
gtk_list_item_widget_setup_factory (GtkListItemWidget *self)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
GtkListItem *list_item;
list_item = gtk_list_item_new ();
gtk_list_item_factory_setup (priv->factory,
G_OBJECT (list_item),
priv->item != NULL,
gtk_list_item_widget_setup_func,
self);
g_assert (priv->list_item == list_item);
}
static void
gtk_list_item_widget_teardown_func (gpointer object,
gpointer data)
{
GtkListItemWidget *self = data;
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
GtkListItem *list_item = object;
g_assert (priv->list_item == list_item);
priv->list_item = NULL;
list_item->owner = NULL;
if (list_item->child)
gtk_list_item_widget_remove_child (self, list_item->child);
gtk_list_item_widget_set_activatable (self, FALSE);
gtk_list_item_do_notify (list_item,
priv->item != NULL,
priv->position != GTK_INVALID_LIST_POSITION,
priv->selected);
gtk_list_item_set_child (list_item, NULL);
}
static void
gtk_list_item_widget_teardown_factory (GtkListItemWidget *self)
{
GtkListItemWidgetPrivate *priv = gtk_list_item_widget_get_instance_private (self);
listitemwidget: Actually unref the listitems Fixes #5102
2022-08-14 20:55:27 +00:00
GtkListItem *list_item = priv->list_item;
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
gtk_list_item_factory_teardown (priv->factory,
listitemwidget: Actually unref the listitems Fixes #5102
2022-08-14 20:55:27 +00:00
G_OBJECT (list_item),
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
priv->item != NULL,
gtk_list_item_widget_teardown_func,
self);
g_assert (priv->list_item == NULL);
listitemwidget: Actually unref the listitems Fixes #5102
2022-08-14 20:55:27 +00:00
g_object_unref (list_item);
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +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
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)
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
gtk_list_item_widget_setup_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_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)
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
gtk_list_item_widget_teardown_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] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_object ("factory", 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
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] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_boolean ("single-click-activate", NULL, NULL,
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
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)
{
listitemwidget: Activate on release instead of press Single click activation should only be done on release and not on press, otherwise it breaks touch scrolling. Double-click activation still can be done on press. This matches the GtkListBox behavior as well. Fixes https://gitlab.gnome.org/GNOME/gtk/-/issues/3345
2020-12-28 14:41:30 +00:00
if (n_press == 2 && !priv->single_click_activate)
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
{
listitemwidget: Claim gesture when activating Claim the gesture when we are activating a list item. Otherwise we end up with double activations in columnviews: first GtkColumnViewCell handles the event, and then GtkListItemWidget handles it again. Fixes: #4015
2021-06-13 12:03:39 +00:00
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
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_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);
listitemwidget: Match activation conditions Make the conditions used for activation in the single- and double-click case properly match, so that it is obvious that we won't trigger both of them.
2021-06-13 12:02:06 +00:00
if (!priv->list_item || priv->list_item->activatable)
listitemwidget: Activate on release instead of press Single click activation should only be done on release and not on press, otherwise it breaks touch scrolling. Double-click activation still can be done on press. This matches the GtkListBox behavior as well. Fixes https://gitlab.gnome.org/GNOME/gtk/-/issues/3345
2020-12-28 14:41:30 +00:00
{
listitemwidget: Match activation conditions Make the conditions used for activation in the single- and double-click case properly match, so that it is obvious that we won't trigger both of them.
2021-06-13 12:02:06 +00:00
if (n_press == 1 && priv->single_click_activate)
{
listitemwidget: Claim gesture when activating Claim the gesture when we are activating a list item. Otherwise we end up with double activations in columnviews: first GtkColumnViewCell handles the event, and then GtkListItemWidget handles it again. Fixes: #4015
2021-06-13 12:03:39 +00:00
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
listitemwidget: Match activation conditions Make the conditions used for activation in the single- and double-click case properly match, so that it is obvious that we won't trigger both of them.
2021-06-13 12:02:06 +00:00
gtk_widget_activate_action (GTK_WIDGET (self),
"list.activate-item",
"u",
priv->position);
return;
}
listitemwidget: Activate on release instead of press Single click activation should only be done on release and not on press, otherwise it breaks touch scrolling. Double-click activation still can be done on press. This matches the GtkListBox behavior as well. Fixes https://gitlab.gnome.org/GNOME/gtk/-/issues/3345
2020-12-28 14:41:30 +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
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
}
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
typedef struct {
GtkListItemWidget *widget;
guint position;
gpointer item;
gboolean selected;
} GtkListItemWidgetUpdate;
static void
gtk_list_item_widget_update_func (gpointer object,
gpointer data)
{
GtkListItemWidgetUpdate *update = data;
GtkListItem *list_item = object;
/* Track notify manually instead of freeze/thaw_notify for performance reasons. */
gboolean notify_item = FALSE, notify_position = FALSE, notify_selected = FALSE;
GtkListItemWidget *self = update->widget;
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, update->item))
notify_item = TRUE;
if (priv->position != update->position)
{
priv->position = update->position;
notify_position = TRUE;
}
if (priv->selected != update->selected)
{
priv->selected = update->selected;
notify_selected = TRUE;
}
if (list_item)
gtk_list_item_do_notify (list_item, notify_item, notify_position, notify_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
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);
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
GtkListItemWidgetUpdate update = { self, position, item, selected };
listitemwidget: Avoid some unnecessary work Only update widget and accessible state if the selected property actually changed.
2022-05-07 01:36:22 +00:00
gboolean was_selected;
was_selected = priv->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
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)
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
{
gtk_list_item_factory_update (priv->factory,
G_OBJECT (priv->list_item),
priv->item != NULL,
item != NULL,
gtk_list_item_widget_update_func,
&update);
}
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
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
{
gtk_list_item_widget_update_func (NULL, &update);
}
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: Avoid some unnecessary work Only update widget and accessible state if the selected property actually changed.
2022-05-07 01:36:22 +00:00
/* don't look at selected variable, it's not reentrancy safe */
if (was_selected != priv->selected)
{
if (priv->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);
gtk_accessible_update_state (GTK_ACCESSIBLE (self),
GTK_ACCESSIBLE_STATE_SELECTED, priv->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
}
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
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)
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
gtk_list_item_widget_teardown_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
g_clear_object (&priv->factory);
}
if (factory)
{
priv->factory = g_object_ref (factory);
if (gtk_widget_get_root (GTK_WIDGET (self)))
listitemfactory: Make this callback-based This way, we no longer prescribe the use of either GtkListItem or GtkListItemWidget. This means we can use it in other places, such as for custom section header objects or with my Canvas ideas.
2022-06-28 14:34:24 +00:00
gtk_list_item_widget_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]);
}
listitemwidget: Have .activatable style class if the item is activatable Match GtkListBox, so it's possible to use the same styles for them. Update GtkListView and GtkGridView docs to reflect that, fix a few gtk-doc formatting leftovers along the way.
2021-05-17 13:05:05 +00:00
void
gtk_list_item_widget_set_activatable (GtkListItemWidget *self,
gboolean activatable)
{
if (activatable)
gtk_widget_add_css_class (GTK_WIDGET (self), "activatable");
else
gtk_widget_remove_css_class (GTK_WIDGET (self), "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
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