From ce531ce280e6f34c223b976d54cb7a354a22e62f Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Sun, 26 Mar 2023 00:50:45 +0100
Subject: [PATCH] listview: Add GtkListItem::focusable property

This makes the question if a listitem can be focused or not an explicit
decision by application developers.

Previously an item could be focused if it was selectable and no child or
grandchild was focusable - so if you put a label and icon into it, the
item was focusable, but if you put a GtkTreeExpander or a GtkButton into
it, the item wasn't. This needs to be decided explicitly now.

Technically this is an API break, because the previous behavior does not
exist anymore.
But I really don't want to make this a tristate (focusable, not
focusable, automatic), because then binding it to other things gets
hard, and because all the other focusable proeprties are booleans, too,
and working with them gets a lot harder.

Related: #3910
---
 demos/gtk-demo/main-listitem.ui |  1 +
 gtk/gtklistitem.c               | 75 +++++++++++++++++++++++++++++
 gtk/gtklistitem.h               |  5 ++
 gtk/gtklistitemprivate.h        |  1 +
 gtk/gtklistitemwidget.c         | 85 ++++++++++++++++++---------------
 5 files changed, 129 insertions(+), 38 deletions(-)

diff --git a/demos/gtk-demo/main-listitem.ui b/demos/gtk-demo/main-listitem.ui
index aab22e3e20..b3427611ed 100644
--- a/demos/gtk-demo/main-listitem.ui
+++ b/demos/gtk-demo/main-listitem.ui
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <template class="GtkListItem">
+    <property name="focusable">0</property>
     <property name="child">
       <object class="GtkTreeExpander" id="expander">
         <binding name="list-row">
diff --git a/gtk/gtklistitem.c b/gtk/gtklistitem.c
index a44752a4da..7aed3f410d 100644
--- a/gtk/gtklistitem.c
+++ b/gtk/gtklistitem.c
@@ -51,6 +51,7 @@ enum
   PROP_0,
   PROP_ACTIVATABLE,
   PROP_CHILD,
+  PROP_FOCUSABLE,
   PROP_ITEM,
   PROP_POSITION,
   PROP_SELECTABLE,
@@ -92,6 +93,10 @@ gtk_list_item_get_property (GObject    *object,
       g_value_set_object (value, self->child);
       break;
 
+    case PROP_FOCUSABLE:
+      g_value_set_boolean (value, self->focusable);
+      break;
+
     case PROP_ITEM:
       if (self->owner)
         g_value_set_object (value, gtk_list_item_base_get_item (GTK_LIST_ITEM_BASE (self->owner)));
@@ -139,6 +144,10 @@ gtk_list_item_set_property (GObject      *object,
       gtk_list_item_set_child (self, g_value_get_object (value));
       break;
 
+    case PROP_FOCUSABLE:
+      gtk_list_item_set_focusable (self, g_value_get_boolean (value));
+      break;
+
     case PROP_SELECTABLE:
       gtk_list_item_set_selectable (self, g_value_get_boolean (value));
       break;
@@ -178,6 +187,18 @@ gtk_list_item_class_init (GtkListItemClass *klass)
                          GTK_TYPE_WIDGET,
                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * GtkListItem:focusable: (attributes org.gtk.Property.get=gtk_list_item_get_focusable org.gtk.Property.set=gtk_list_item_set_focusable)
+   *
+   * If the item can be focused with the keyboard.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_FOCUSABLE] =
+    g_param_spec_boolean ("focusable", NULL, NULL,
+                          TRUE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
   /**
    * GtkListItem:item: (attributes org.gtk.Property.get=gtk_list_item_get_item)
    *
@@ -226,6 +247,7 @@ gtk_list_item_init (GtkListItem *self)
 {
   self->selectable = TRUE;
   self->activatable = TRUE;
+  self->focusable = TRUE;
 }
 
 GtkListItem *
@@ -468,3 +490,56 @@ gtk_list_item_set_activatable (GtkListItem *self,
 
   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ACTIVATABLE]);
 }
+
+/**
+ * gtk_list_item_get_focusable: (attributes org.gtk.Method.get_property=focusable)
+ * @self: a `GtkListItem`
+ *
+ * Checks if a list item has been set to be focusable via
+ * gtk_list_item_set_focusable().
+ *
+ * Returns: %TRUE if the item is focusable
+ *
+ * Since: 4.12
+ */
+gboolean
+gtk_list_item_get_focusable (GtkListItem *self)
+{
+  g_return_val_if_fail (GTK_IS_LIST_ITEM (self), FALSE);
+
+  return self->focusable;
+}
+
+/**
+ * gtk_list_item_set_focusable: (attributes org.gtk.Method.set_property=focusable)
+ * @self: a `GtkListItem`
+ * @focusable: if the item should be focusable
+ *
+ * Sets @self to be focusable.
+ *
+ * If an item is focusable, it can be focused using the keyboard.
+ * This works similar to [method@Gtk.Widget.set_focusable].
+ *
+ * Note that if items are not focusable, the keyboard cannot be used to activate
+ * them and selecting only works if one of the listitem's children is focusable.
+ *
+ * By default, list items are focusable.
+ *
+ * Since: 4.12
+ */
+void
+gtk_list_item_set_focusable (GtkListItem *self,
+                             gboolean     focusable)
+{
+  g_return_if_fail (GTK_IS_LIST_ITEM (self));
+
+  if (self->focusable == focusable)
+    return;
+
+  self->focusable = focusable;
+
+  if (self->owner)
+    gtk_widget_set_focusable (GTK_WIDGET (self->owner), focusable);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FOCUSABLE]);
+}
diff --git a/gtk/gtklistitem.h b/gtk/gtklistitem.h
index 88e5da2f7e..9c5fb844e1 100644
--- a/gtk/gtklistitem.h
+++ b/gtk/gtklistitem.h
@@ -47,6 +47,11 @@ gboolean        gtk_list_item_get_activatable                   (GtkListItem
 GDK_AVAILABLE_IN_ALL
 void            gtk_list_item_set_activatable                   (GtkListItem            *self,
                                                                  gboolean                activatable);
+GDK_AVAILABLE_IN_4_12
+gboolean        gtk_list_item_get_focusable                     (GtkListItem            *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void            gtk_list_item_set_focusable                     (GtkListItem            *self,
+                                                                 gboolean                focusable);
 
 GDK_AVAILABLE_IN_ALL
 void            gtk_list_item_set_child                         (GtkListItem            *self,
diff --git a/gtk/gtklistitemprivate.h b/gtk/gtklistitemprivate.h
index af56b37a37..28ab8b5d63 100644
--- a/gtk/gtklistitemprivate.h
+++ b/gtk/gtklistitemprivate.h
@@ -35,6 +35,7 @@ struct _GtkListItem
 
   guint activatable : 1;
   guint selectable : 1;
+  guint focusable : 1;
 };
 
 GtkListItem *   gtk_list_item_new                               (void);
diff --git a/gtk/gtklistitemwidget.c b/gtk/gtklistitemwidget.c
index ccd56c1b3a..b5fac6f7b8 100644
--- a/gtk/gtklistitemwidget.c
+++ b/gtk/gtklistitemwidget.c
@@ -28,6 +28,7 @@
 #include "gtklistitemprivate.h"
 #include "gtklistbaseprivate.h"
 #include "gtkwidget.h"
+#include "gtkwidgetprivate.h"
 
 G_DEFINE_TYPE (GtkListItemWidget, gtk_list_item_widget, GTK_TYPE_LIST_FACTORY_WIDGET)
 
@@ -35,59 +36,65 @@ static gboolean
 gtk_list_item_widget_focus (GtkWidget        *widget,
                             GtkDirectionType  direction)
 {
-  GtkWidget *child, *focus_child;
+  GtkWidget *child = gtk_widget_get_first_child (widget);
 
-  /* 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.
-   */
-
-  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))
+  if (gtk_widget_get_focus_child (widget))
     {
-      if (gtk_widget_child_focus (child, direction))
-        return TRUE;
+      /* focus is in the child */
+      if (direction == GTK_DIR_TAB_BACKWARD)
+        return gtk_widget_grab_focus_self (widget);
+      else
+        return FALSE;
     }
+  else if (gtk_widget_is_focus (widget))
+    {
+      /* The widget has focus */
+      if (direction == GTK_DIR_TAB_FORWARD)
+        {
+          if (child)
+            return gtk_widget_child_focus (child, direction);
+        }
 
-  if (focus_child)
-    return FALSE;
+      return FALSE;
+    }
+  else
+    {
+      /* focus coming in from the outside */
+      if (direction == GTK_DIR_TAB_BACKWARD)
+        {
+          if (child &&
+              gtk_widget_child_focus (child, direction))
+            return TRUE;
 
-  if (gtk_widget_is_focus (widget))
-    return FALSE;
+          return gtk_widget_grab_focus_self (widget);
+        }
+      else
+        {
+          if (gtk_widget_grab_focus_self (widget))
+            return TRUE;
 
-  return gtk_widget_grab_focus (widget);
+          if (child &&
+              gtk_widget_child_focus (child, direction))
+            return TRUE;
+
+          return FALSE;
+        }
+    }
 }
 
 static gboolean
 gtk_list_item_widget_grab_focus (GtkWidget *widget)
 {
-  GtkListItemWidget *self = GTK_LIST_ITEM_WIDGET (widget);
   GtkWidget *child;
 
-  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 (GTK_WIDGET_CLASS (gtk_list_item_widget_parent_class)->grab_focus (widget))
+    return TRUE;
 
-  if (!gtk_list_factory_widget_get_selectable (GTK_LIST_FACTORY_WIDGET (self)))
-    return FALSE;
+  child = gtk_widget_get_first_child (widget);
+  if (child && gtk_widget_grab_focus (child))
+    return TRUE;
 
-  return GTK_WIDGET_CLASS (gtk_list_item_widget_parent_class)->grab_focus (widget);
+  return FALSE;
 }
 
 static gpointer
@@ -111,6 +118,7 @@ gtk_list_item_widget_setup_object (GtkListFactoryWidget *fw,
 
   gtk_list_factory_widget_set_activatable (fw, list_item->activatable);
   gtk_list_factory_widget_set_selectable (fw, list_item->selectable);
+  gtk_widget_set_focusable (GTK_WIDGET (self), list_item->focusable);
 
   gtk_list_item_do_notify (list_item,
                            gtk_list_item_base_get_item (GTK_LIST_ITEM_BASE (self)) != NULL,
@@ -133,6 +141,7 @@ gtk_list_item_widget_teardown_object (GtkListFactoryWidget *fw,
 
   gtk_list_factory_widget_set_activatable (fw, FALSE);
   gtk_list_factory_widget_set_selectable (fw, FALSE);
+  gtk_widget_set_focusable (GTK_WIDGET (self), TRUE);
 
   gtk_list_item_do_notify (list_item,
                            gtk_list_item_base_get_item (GTK_LIST_ITEM_BASE (self)) != NULL,