2013-06-10 09:17:10 +00:00
|
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2012 Alexander Larsson <alexl@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* 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 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/>.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
#include "gtkactionhelper.h"
|
2014-07-03 00:36:41 +00:00
|
|
|
|
#include "gtkadjustmentprivate.h"
|
2015-05-30 03:03:11 +00:00
|
|
|
|
#include "gtkcssnodeprivate.h"
|
2013-06-15 16:13:28 +00:00
|
|
|
|
#include "gtklistbox.h"
|
|
|
|
|
#include "gtkwidget.h"
|
|
|
|
|
#include "gtkmarshalers.h"
|
|
|
|
|
#include "gtkprivate.h"
|
|
|
|
|
#include "gtkintl.h"
|
2014-08-13 09:32:47 +00:00
|
|
|
|
#include "gtkwidgetprivate.h"
|
2015-12-12 04:48:34 +00:00
|
|
|
|
#include "gtkcontainerprivate.h"
|
2015-12-10 05:43:58 +00:00
|
|
|
|
#include "gtkcsscustomgadgetprivate.h"
|
2013-06-15 16:13:28 +00:00
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
#include <float.h>
|
|
|
|
|
#include <math.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
|
#include "a11y/gtklistboxaccessibleprivate.h"
|
2013-09-22 00:49:18 +00:00
|
|
|
|
#include "a11y/gtklistboxrowaccessible.h"
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* SECTION:gtklistbox
|
|
|
|
|
* @Short_description: A list container
|
|
|
|
|
* @Title: GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @See_also: #GtkScrolledWindow
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* A GtkListBox is a vertical container that contains GtkListBoxRow
|
2021-04-10 01:04:05 +00:00
|
|
|
|
* children. These rows can be dynamically sorted and filtered, and
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* headers can be added dynamically depending on the row content.
|
|
|
|
|
* It also allows keyboard and mouse navigation and selection like
|
|
|
|
|
* a typical list.
|
|
|
|
|
*
|
|
|
|
|
* Using GtkListBox is often an alternative to #GtkTreeView, especially
|
|
|
|
|
* when the list contents has a more complicated layout than what is allowed
|
|
|
|
|
* by a #GtkCellRenderer, or when the contents is interactive (i.e. has a
|
|
|
|
|
* button in it).
|
|
|
|
|
*
|
|
|
|
|
* Although a #GtkListBox must have only #GtkListBoxRow children you can
|
|
|
|
|
* add any kind of widget to it via gtk_container_add(), and a #GtkListBoxRow
|
|
|
|
|
* widget will automatically be inserted between the list and the widget.
|
|
|
|
|
*
|
2014-07-16 03:45:27 +00:00
|
|
|
|
* #GtkListBoxRows can be marked as activatable or selectable. If a row
|
|
|
|
|
* is activatable, #GtkListBox::row-activated will be emitted for it when
|
|
|
|
|
* the user tries to activate it. If it is selectable, the row will be marked
|
|
|
|
|
* as selected when the user tries to select it.
|
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* The GtkListBox widget was added in GTK+ 3.10.
|
2015-11-05 18:48:02 +00:00
|
|
|
|
*
|
2019-06-18 20:43:07 +00:00
|
|
|
|
* # GtkListBox as GtkBuildable
|
|
|
|
|
*
|
|
|
|
|
* The GtkListBox implementation of the #GtkBuildable interface supports
|
|
|
|
|
* setting a child as the placeholder by specifying “placeholder” as the “type”
|
|
|
|
|
* attribute of a <child> element. See gtk_list_box_set_placeholder() for info.
|
|
|
|
|
*
|
2015-11-05 18:48:02 +00:00
|
|
|
|
* # CSS nodes
|
|
|
|
|
*
|
2016-09-20 22:32:00 +00:00
|
|
|
|
* |[<!-- language="plain" -->
|
|
|
|
|
* list
|
|
|
|
|
* ╰── row[.activatable]
|
|
|
|
|
* ]|
|
|
|
|
|
*
|
|
|
|
|
* GtkListBox uses a single CSS node named list. Each GtkListBoxRow uses
|
|
|
|
|
* a single CSS node named row. The row nodes get the .activatable
|
2015-11-05 18:48:02 +00:00
|
|
|
|
* style class added when appropriate.
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
typedef struct
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GSequence *children;
|
2013-06-11 12:09:19 +00:00
|
|
|
|
GHashTable *header_hash;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 14:53:31 +00:00
|
|
|
|
GtkWidget *placeholder;
|
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
GtkCssGadget *gadget;
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxSortFunc sort_func;
|
|
|
|
|
gpointer sort_func_target;
|
|
|
|
|
GDestroyNotify sort_func_target_destroy_notify;
|
|
|
|
|
|
|
|
|
|
GtkListBoxFilterFunc filter_func;
|
|
|
|
|
gpointer filter_func_target;
|
|
|
|
|
GDestroyNotify filter_func_target_destroy_notify;
|
|
|
|
|
|
2013-06-11 12:09:19 +00:00
|
|
|
|
GtkListBoxUpdateHeaderFunc update_header_func;
|
|
|
|
|
gpointer update_header_func_target;
|
|
|
|
|
GDestroyNotify update_header_func_target_destroy_notify;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GtkListBoxRow *selected_row;
|
|
|
|
|
GtkListBoxRow *prelight_row;
|
|
|
|
|
GtkListBoxRow *cursor_row;
|
|
|
|
|
|
|
|
|
|
gboolean active_row_active;
|
|
|
|
|
GtkListBoxRow *active_row;
|
|
|
|
|
|
|
|
|
|
GtkSelectionMode selection_mode;
|
|
|
|
|
|
|
|
|
|
GtkAdjustment *adjustment;
|
|
|
|
|
gboolean activate_single_click;
|
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
GtkGesture *multipress_gesture;
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
/* DnD */
|
|
|
|
|
GtkListBoxRow *drag_highlighted_row;
|
2013-06-11 14:20:45 +00:00
|
|
|
|
|
|
|
|
|
int n_visible_rows;
|
2013-06-17 13:13:17 +00:00
|
|
|
|
gboolean in_widget;
|
2015-02-09 10:49:31 +00:00
|
|
|
|
|
|
|
|
|
GListModel *bound_model;
|
|
|
|
|
GtkListBoxCreateWidgetFunc create_widget_func;
|
|
|
|
|
gpointer create_widget_func_data;
|
|
|
|
|
GDestroyNotify create_widget_func_data_destroy;
|
2013-07-02 11:44:17 +00:00
|
|
|
|
} GtkListBoxPrivate;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
typedef struct
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter;
|
2013-06-11 12:09:19 +00:00
|
|
|
|
GtkWidget *header;
|
2015-12-10 05:43:58 +00:00
|
|
|
|
GtkCssGadget *gadget;
|
2017-11-24 13:33:42 +00:00
|
|
|
|
GtkActionHelper *action_helper;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gint y;
|
|
|
|
|
gint height;
|
2014-07-16 02:42:29 +00:00
|
|
|
|
guint visible :1;
|
|
|
|
|
guint selected :1;
|
|
|
|
|
guint activatable :1;
|
2014-07-16 03:10:51 +00:00
|
|
|
|
guint selectable :1;
|
2013-07-02 11:44:17 +00:00
|
|
|
|
} GtkListBoxRowPrivate;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
ROW_SELECTED,
|
|
|
|
|
ROW_ACTIVATED,
|
|
|
|
|
ACTIVATE_CURSOR_ROW,
|
|
|
|
|
TOGGLE_CURSOR_ROW,
|
|
|
|
|
MOVE_CURSOR,
|
2014-03-28 23:21:57 +00:00
|
|
|
|
SELECTED_ROWS_CHANGED,
|
|
|
|
|
SELECT_ALL,
|
|
|
|
|
UNSELECT_ALL,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2013-09-10 12:12:07 +00:00
|
|
|
|
enum {
|
|
|
|
|
ROW__ACTIVATE,
|
|
|
|
|
ROW__LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
enum {
|
2013-06-10 09:17:10 +00:00
|
|
|
|
PROP_0,
|
|
|
|
|
PROP_SELECTION_MODE,
|
|
|
|
|
PROP_ACTIVATE_ON_SINGLE_CLICK,
|
|
|
|
|
LAST_PROPERTY
|
|
|
|
|
};
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
enum {
|
|
|
|
|
ROW_PROP_0,
|
|
|
|
|
ROW_PROP_ACTIVATABLE,
|
2014-07-16 03:10:51 +00:00
|
|
|
|
ROW_PROP_SELECTABLE,
|
2017-11-24 13:33:42 +00:00
|
|
|
|
|
|
|
|
|
/* actionable properties */
|
|
|
|
|
ROW_PROP_ACTION_NAME,
|
|
|
|
|
ROW_PROP_ACTION_TARGET,
|
|
|
|
|
|
|
|
|
|
LAST_ROW_PROPERTY = ROW_PROP_ACTION_NAME
|
2014-07-13 00:37:41 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
#define BOX_PRIV(box) ((GtkListBoxPrivate*)gtk_list_box_get_instance_private ((GtkListBox*)(box)))
|
|
|
|
|
#define ROW_PRIV(row) ((GtkListBoxRowPrivate*)gtk_list_box_row_get_instance_private ((GtkListBoxRow*)(row)))
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
static void gtk_list_box_buildable_interface_init (GtkBuildableIface *iface);
|
|
|
|
|
|
|
|
|
|
static void gtk_list_box_row_actionable_iface_init (GtkActionableInterface *iface);
|
2014-10-12 22:54:44 +00:00
|
|
|
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkListBox, gtk_list_box, GTK_TYPE_CONTAINER,
|
|
|
|
|
G_ADD_PRIVATE (GtkListBox)
|
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
|
|
|
|
|
gtk_list_box_buildable_interface_init))
|
2017-11-24 13:33:42 +00:00
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkListBoxRow, gtk_list_box_row, GTK_TYPE_BIN,
|
|
|
|
|
G_ADD_PRIVATE (GtkListBoxRow)
|
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE, gtk_list_box_row_actionable_iface_init))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_apply_filter_all (GtkListBox *box);
|
|
|
|
|
static void gtk_list_box_update_header (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GSequenceIter *iter);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static GSequenceIter * gtk_list_box_get_next_visible (GtkListBox *box,
|
|
|
|
|
GSequenceIter *iter);
|
|
|
|
|
static void gtk_list_box_apply_filter (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row);
|
|
|
|
|
static void gtk_list_box_add_move_binding (GtkBindingSet *binding_set,
|
|
|
|
|
guint keyval,
|
|
|
|
|
GdkModifierType modmask,
|
|
|
|
|
GtkMovementStep step,
|
|
|
|
|
gint count);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_update_cursor (GtkListBox *box,
|
2015-02-10 19:02:08 +00:00
|
|
|
|
GtkListBoxRow *row,
|
|
|
|
|
gboolean grab_focus);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_update_prelight (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_update_active (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static gboolean gtk_list_box_enter_notify_event (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkEventCrossing *event);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static gboolean gtk_list_box_leave_notify_event (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkEventCrossing *event);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static gboolean gtk_list_box_motion_notify_event (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkEventMotion *event);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_show (GtkWidget *widget);
|
|
|
|
|
static gboolean gtk_list_box_focus (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkDirectionType direction);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static GSequenceIter* gtk_list_box_get_previous_visible (GtkListBox *box,
|
|
|
|
|
GSequenceIter *iter);
|
|
|
|
|
static GtkListBoxRow *gtk_list_box_get_first_focusable (GtkListBox *box);
|
|
|
|
|
static GtkListBoxRow *gtk_list_box_get_last_focusable (GtkListBox *box);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static gboolean gtk_list_box_draw (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
cairo_t *cr);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_realize (GtkWidget *widget);
|
|
|
|
|
static void gtk_list_box_add (GtkContainer *container,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkWidget *widget);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_remove (GtkContainer *container,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkWidget *widget);
|
2015-08-16 22:11:50 +00:00
|
|
|
|
static void gtk_list_box_forall (GtkContainer *container,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gboolean include_internals,
|
|
|
|
|
GtkCallback callback,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gpointer callback_target);
|
2015-08-16 22:11:50 +00:00
|
|
|
|
static void gtk_list_box_compute_expand (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gboolean *hexpand,
|
|
|
|
|
gboolean *vexpand);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static GType gtk_list_box_child_type (GtkContainer *container);
|
|
|
|
|
static GtkSizeRequestMode gtk_list_box_get_request_mode (GtkWidget *widget);
|
|
|
|
|
static void gtk_list_box_size_allocate (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkAllocation *allocation);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_drag_leave (GtkWidget *widget,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkDragContext *context,
|
|
|
|
|
guint time_);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_activate_cursor_row (GtkListBox *box);
|
|
|
|
|
static void gtk_list_box_toggle_cursor_row (GtkListBox *box);
|
|
|
|
|
static void gtk_list_box_move_cursor (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkMovementStep step,
|
|
|
|
|
gint count);
|
|
|
|
|
static void gtk_list_box_finalize (GObject *obj);
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_parent_set (GtkWidget *widget,
|
2013-06-10 14:07:20 +00:00
|
|
|
|
GtkWidget *prev_parent);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-09-28 02:00:38 +00:00
|
|
|
|
static void gtk_list_box_get_preferred_height (GtkWidget *widget,
|
|
|
|
|
gint *minimum_height,
|
|
|
|
|
gint *natural_height);
|
|
|
|
|
static void gtk_list_box_get_preferred_height_for_width (GtkWidget *widget,
|
|
|
|
|
gint width,
|
|
|
|
|
gint *minimum_height,
|
|
|
|
|
gint *natural_height);
|
|
|
|
|
static void gtk_list_box_get_preferred_width (GtkWidget *widget,
|
|
|
|
|
gint *minimum_width,
|
|
|
|
|
gint *natural_width);
|
|
|
|
|
static void gtk_list_box_get_preferred_width_for_height (GtkWidget *widget,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *minimum_width,
|
|
|
|
|
gint *natural_width);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static void gtk_list_box_select_row_internal (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row);
|
|
|
|
|
static void gtk_list_box_unselect_row_internal (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row);
|
|
|
|
|
static void gtk_list_box_select_all_between (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row1,
|
|
|
|
|
GtkListBoxRow *row2,
|
|
|
|
|
gboolean modify);
|
|
|
|
|
static gboolean gtk_list_box_unselect_all_internal (GtkListBox *box);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
static void gtk_list_box_selected_rows_changed (GtkListBox *box);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
static void gtk_list_box_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
|
|
|
|
|
guint n_press,
|
|
|
|
|
gdouble x,
|
|
|
|
|
gdouble y,
|
|
|
|
|
GtkListBox *box);
|
|
|
|
|
static void gtk_list_box_multipress_gesture_released (GtkGestureMultiPress *gesture,
|
|
|
|
|
guint n_press,
|
|
|
|
|
gdouble x,
|
|
|
|
|
gdouble y,
|
|
|
|
|
GtkListBox *box);
|
|
|
|
|
|
2014-07-16 03:13:43 +00:00
|
|
|
|
static void gtk_list_box_update_row_styles (GtkListBox *box);
|
|
|
|
|
static void gtk_list_box_update_row_style (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row);
|
2014-06-05 13:40:02 +00:00
|
|
|
|
|
2015-02-09 10:49:31 +00:00
|
|
|
|
static void gtk_list_box_bound_model_changed (GListModel *list,
|
|
|
|
|
guint position,
|
|
|
|
|
guint removed,
|
|
|
|
|
guint added,
|
|
|
|
|
gpointer user_data);
|
|
|
|
|
|
2015-08-25 17:16:24 +00:00
|
|
|
|
static void gtk_list_box_check_model_compat (GtkListBox *box);
|
2015-12-12 04:48:34 +00:00
|
|
|
|
|
|
|
|
|
static void gtk_list_box_measure (GtkCssGadget *gadget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
gint for_size,
|
|
|
|
|
gint *minimum_size,
|
|
|
|
|
gint *natural_size,
|
|
|
|
|
gint *minimum_baseline,
|
|
|
|
|
gint *natural_baseline,
|
|
|
|
|
gpointer data);
|
|
|
|
|
static void gtk_list_box_allocate (GtkCssGadget *gadget,
|
|
|
|
|
const GtkAllocation *allocation,
|
|
|
|
|
int baseline,
|
|
|
|
|
GtkAllocation *out_clip,
|
|
|
|
|
gpointer data);
|
|
|
|
|
static gboolean gtk_list_box_render (GtkCssGadget *gadget,
|
|
|
|
|
cairo_t *cr,
|
|
|
|
|
int x,
|
|
|
|
|
int y,
|
|
|
|
|
int width,
|
|
|
|
|
int height,
|
|
|
|
|
gpointer data);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static GParamSpec *properties[LAST_PROPERTY] = { NULL, };
|
|
|
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
2014-07-13 00:37:41 +00:00
|
|
|
|
static GParamSpec *row_properties[LAST_ROW_PROPERTY] = { NULL, };
|
2013-09-10 12:12:07 +00:00
|
|
|
|
static guint row_signals[ROW__LAST_SIGNAL] = { 0 };
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_new:
|
|
|
|
|
*
|
|
|
|
|
* Creates a new #GtkListBox container.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkListBox
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkWidget *
|
|
|
|
|
gtk_list_box_new (void)
|
|
|
|
|
{
|
|
|
|
|
return g_object_new (GTK_TYPE_LIST_BOX, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_get_property (GObject *obj,
|
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (obj);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_SELECTION_MODE:
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_value_set_enum (value, priv->selection_mode);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_ACTIVATE_ON_SINGLE_CLICK:
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_value_set_boolean (value, priv->activate_single_click);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_set_property (GObject *obj,
|
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (obj);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_SELECTION_MODE:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_selection_mode (box, g_value_get_enum (value));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
case PROP_ACTIVATE_ON_SINGLE_CLICK:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_activate_on_single_click (box, g_value_get_boolean (value));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_finalize (GObject *obj)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (obj);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->sort_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->sort_func_target_destroy_notify (priv->sort_func_target);
|
|
|
|
|
if (priv->filter_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->filter_func_target_destroy_notify (priv->filter_func_target);
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (priv->update_header_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->update_header_func_target_destroy_notify (priv->update_header_func_target);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
g_clear_object (&priv->adjustment);
|
|
|
|
|
g_clear_object (&priv->drag_highlighted_row);
|
2015-01-14 15:41:54 +00:00
|
|
|
|
g_clear_object (&priv->multipress_gesture);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
g_sequence_free (priv->children);
|
2013-06-11 12:09:19 +00:00
|
|
|
|
g_hash_table_unref (priv->header_hash);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-02-09 10:49:31 +00:00
|
|
|
|
if (priv->bound_model)
|
|
|
|
|
{
|
|
|
|
|
if (priv->create_widget_func_data_destroy)
|
|
|
|
|
priv->create_widget_func_data_destroy (priv->create_widget_func_data);
|
|
|
|
|
|
|
|
|
|
g_signal_handlers_disconnect_by_func (priv->bound_model, gtk_list_box_bound_model_changed, obj);
|
|
|
|
|
g_clear_object (&priv->bound_model);
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
g_clear_object (&priv->gadget);
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
G_OBJECT_CLASS (gtk_list_box_parent_class)->finalize (obj);
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-11 13:33:13 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_dispose (GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (object);
|
|
|
|
|
|
|
|
|
|
if (priv->placeholder)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_unparent (priv->placeholder);
|
|
|
|
|
priv->placeholder = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_list_box_parent_class)->dispose (object);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_class_init (GtkListBoxClass *klass)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
|
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
|
|
|
|
|
GtkBindingSet *binding_set;
|
|
|
|
|
|
|
|
|
|
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_LIST_BOX_ACCESSIBLE);
|
|
|
|
|
|
|
|
|
|
object_class->get_property = gtk_list_box_get_property;
|
|
|
|
|
object_class->set_property = gtk_list_box_set_property;
|
|
|
|
|
object_class->finalize = gtk_list_box_finalize;
|
2017-05-11 13:33:13 +00:00
|
|
|
|
object_class->dispose = gtk_list_box_dispose;
|
2013-09-28 02:00:38 +00:00
|
|
|
|
widget_class->enter_notify_event = gtk_list_box_enter_notify_event;
|
|
|
|
|
widget_class->leave_notify_event = gtk_list_box_leave_notify_event;
|
|
|
|
|
widget_class->motion_notify_event = gtk_list_box_motion_notify_event;
|
|
|
|
|
widget_class->show = gtk_list_box_show;
|
|
|
|
|
widget_class->focus = gtk_list_box_focus;
|
|
|
|
|
widget_class->draw = gtk_list_box_draw;
|
|
|
|
|
widget_class->realize = gtk_list_box_realize;
|
2015-08-16 22:11:50 +00:00
|
|
|
|
widget_class->compute_expand = gtk_list_box_compute_expand;
|
2013-09-28 02:00:38 +00:00
|
|
|
|
widget_class->get_request_mode = gtk_list_box_get_request_mode;
|
|
|
|
|
widget_class->get_preferred_height = gtk_list_box_get_preferred_height;
|
|
|
|
|
widget_class->get_preferred_height_for_width = gtk_list_box_get_preferred_height_for_width;
|
|
|
|
|
widget_class->get_preferred_width = gtk_list_box_get_preferred_width;
|
|
|
|
|
widget_class->get_preferred_width_for_height = gtk_list_box_get_preferred_width_for_height;
|
|
|
|
|
widget_class->size_allocate = gtk_list_box_size_allocate;
|
|
|
|
|
widget_class->drag_leave = gtk_list_box_drag_leave;
|
|
|
|
|
widget_class->parent_set = gtk_list_box_parent_set;
|
|
|
|
|
container_class->add = gtk_list_box_add;
|
|
|
|
|
container_class->remove = gtk_list_box_remove;
|
2015-08-16 22:11:50 +00:00
|
|
|
|
container_class->forall = gtk_list_box_forall;
|
2013-09-28 02:00:38 +00:00
|
|
|
|
container_class->child_type = gtk_list_box_child_type;
|
|
|
|
|
klass->activate_cursor_row = gtk_list_box_activate_cursor_row;
|
|
|
|
|
klass->toggle_cursor_row = gtk_list_box_toggle_cursor_row;
|
|
|
|
|
klass->move_cursor = gtk_list_box_move_cursor;
|
2014-03-29 01:34:39 +00:00
|
|
|
|
klass->select_all = gtk_list_box_select_all;
|
|
|
|
|
klass->unselect_all = gtk_list_box_unselect_all;
|
|
|
|
|
klass->selected_rows_changed = gtk_list_box_selected_rows_changed;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
properties[PROP_SELECTION_MODE] =
|
|
|
|
|
g_param_spec_enum ("selection-mode",
|
2013-06-15 16:13:28 +00:00
|
|
|
|
P_("Selection mode"),
|
|
|
|
|
P_("The selection mode"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_SELECTION_MODE,
|
|
|
|
|
GTK_SELECTION_SINGLE,
|
2014-06-07 03:46:32 +00:00
|
|
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
properties[PROP_ACTIVATE_ON_SINGLE_CLICK] =
|
|
|
|
|
g_param_spec_boolean ("activate-on-single-click",
|
2013-06-15 16:13:28 +00:00
|
|
|
|
P_("Activate on Single Click"),
|
|
|
|
|
P_("Activate row on a single click"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
TRUE,
|
2014-06-07 03:46:32 +00:00
|
|
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
g_object_class_install_properties (object_class, LAST_PROPERTY, properties);
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkListBox::row-selected:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: the #GtkListBox
|
2014-05-26 16:13:02 +00:00
|
|
|
|
* @row: (nullable): the selected row
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* The ::row-selected signal is emitted when a new row is selected, or
|
|
|
|
|
* (with a %NULL @row) when the selection is cleared.
|
|
|
|
|
*
|
2014-05-08 11:33:01 +00:00
|
|
|
|
* When the @box is using #GTK_SELECTION_MULTIPLE, this signal will not
|
|
|
|
|
* give you the full picture of selection changes, and you should use
|
|
|
|
|
* the #GtkListBox::selected-rows-changed signal instead.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
signals[ROW_SELECTED] =
|
2015-09-12 13:13:00 +00:00
|
|
|
|
g_signal_new (I_("row-selected"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, row_selected),
|
|
|
|
|
NULL, NULL,
|
2019-05-31 18:12:29 +00:00
|
|
|
|
NULL,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
G_TYPE_NONE, 1,
|
2013-06-11 10:59:32 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX_ROW);
|
2013-06-15 16:13:28 +00:00
|
|
|
|
|
2014-03-28 23:21:57 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkListBox::selected-rows-changed:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: the #GtkListBox on wich the signal is emitted
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* The ::selected-rows-changed signal is emitted when the
|
|
|
|
|
* set of selected rows changes.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
2015-09-12 13:13:00 +00:00
|
|
|
|
signals[SELECTED_ROWS_CHANGED] = g_signal_new (I_("selected-rows-changed"),
|
2014-03-28 23:21:57 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, selected_rows_changed),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:27:53 +00:00
|
|
|
|
NULL,
|
2014-03-28 23:21:57 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkListBox::select-all:
|
|
|
|
|
* @box: the #GtkListBox on which the signal is emitted
|
|
|
|
|
*
|
|
|
|
|
* The ::select-all signal is a [keybinding signal][GtkBindingSignal]
|
|
|
|
|
* which gets emitted to select all children of the box, if the selection
|
|
|
|
|
* mode permits it.
|
|
|
|
|
*
|
|
|
|
|
* The default bindings for this signal is Ctrl-a.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
2015-09-12 13:13:00 +00:00
|
|
|
|
signals[SELECT_ALL] = g_signal_new (I_("select-all"),
|
2014-03-28 23:21:57 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, select_all),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:27:53 +00:00
|
|
|
|
NULL,
|
2014-03-28 23:21:57 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkListBox::unselect-all:
|
|
|
|
|
* @box: the #GtkListBox on which the signal is emitted
|
|
|
|
|
*
|
|
|
|
|
* The ::unselect-all signal is a [keybinding signal][GtkBindingSignal]
|
|
|
|
|
* which gets emitted to unselect all children of the box, if the selection
|
|
|
|
|
* mode permits it.
|
|
|
|
|
*
|
|
|
|
|
* The default bindings for this signal is Ctrl-Shift-a.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
2015-09-12 13:13:00 +00:00
|
|
|
|
signals[UNSELECT_ALL] = g_signal_new (I_("unselect-all"),
|
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, unselect_all),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:27:53 +00:00
|
|
|
|
NULL,
|
2015-09-12 13:13:00 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkListBox::row-activated:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: the #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @row: the activated row
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* The ::row-activated signal is emitted when a row has been activated by the user.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
signals[ROW_ACTIVATED] =
|
2015-09-12 13:13:00 +00:00
|
|
|
|
g_signal_new (I_("row-activated"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, row_activated),
|
|
|
|
|
NULL, NULL,
|
2019-05-31 18:12:29 +00:00
|
|
|
|
NULL,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
G_TYPE_NONE, 1,
|
2013-06-11 10:59:32 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX_ROW);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
signals[ACTIVATE_CURSOR_ROW] =
|
2015-09-12 13:13:00 +00:00
|
|
|
|
g_signal_new (I_("activate-cursor-row"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, activate_cursor_row),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:27:53 +00:00
|
|
|
|
NULL,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
signals[TOGGLE_CURSOR_ROW] =
|
2015-09-12 13:13:00 +00:00
|
|
|
|
g_signal_new (I_("toggle-cursor-row"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, toggle_cursor_row),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:27:53 +00:00
|
|
|
|
NULL,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
signals[MOVE_CURSOR] =
|
2015-09-12 13:13:00 +00:00
|
|
|
|
g_signal_new (I_("move-cursor"),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_TYPE_LIST_BOX,
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxClass, move_cursor),
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
_gtk_marshal_VOID__ENUM_INT,
|
|
|
|
|
G_TYPE_NONE, 2,
|
|
|
|
|
GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT);
|
2019-05-31 22:49:32 +00:00
|
|
|
|
g_signal_set_va_marshaller (signals[MOVE_CURSOR],
|
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
|
|
|
|
_gtk_marshal_VOID__ENUM_INTv);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
widget_class->activate_signal = signals[ACTIVATE_CURSOR_ROW];
|
|
|
|
|
|
|
|
|
|
binding_set = gtk_binding_set_by_class (klass);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_Home, 0,
|
|
|
|
|
GTK_MOVEMENT_BUFFER_ENDS, -1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
|
|
|
|
|
GTK_MOVEMENT_BUFFER_ENDS, -1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_End, 0,
|
|
|
|
|
GTK_MOVEMENT_BUFFER_ENDS, 1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_End, 0,
|
|
|
|
|
GTK_MOVEMENT_BUFFER_ENDS, 1);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_Up, 0,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_MOVEMENT_DISPLAY_LINES, -1);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_Up, 0,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_MOVEMENT_DISPLAY_LINES, -1);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_Down, 0,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_MOVEMENT_DISPLAY_LINES, 1);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_Down, 0,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_MOVEMENT_DISPLAY_LINES, 1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_Page_Up, 0,
|
|
|
|
|
GTK_MOVEMENT_PAGES, -1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0,
|
|
|
|
|
GTK_MOVEMENT_PAGES, -1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_Page_Down, 0,
|
|
|
|
|
GTK_MOVEMENT_PAGES, 1);
|
|
|
|
|
gtk_list_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0,
|
|
|
|
|
GTK_MOVEMENT_PAGES, 1);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK,
|
|
|
|
|
"toggle-cursor-row", 0, NULL);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK,
|
|
|
|
|
"toggle-cursor-row", 0, NULL);
|
|
|
|
|
|
|
|
|
|
gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
|
|
|
|
|
"select-all", 0);
|
|
|
|
|
gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
|
|
|
|
|
"unselect-all", 0);
|
2015-11-05 18:48:02 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_class_set_css_name (widget_class, "list");
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_init (GtkListBox *box)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
GtkWidget *widget = GTK_WIDGET (box);
|
|
|
|
|
GtkCssNode *widget_node;
|
|
|
|
|
|
|
|
|
|
gtk_widget_set_has_window (widget, TRUE);
|
|
|
|
|
priv->selection_mode = GTK_SELECTION_SINGLE;
|
|
|
|
|
priv->activate_single_click = TRUE;
|
|
|
|
|
|
|
|
|
|
priv->children = g_sequence_new (NULL);
|
|
|
|
|
priv->header_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
|
|
|
|
|
|
|
|
|
|
priv->multipress_gesture = gtk_gesture_multi_press_new (widget);
|
|
|
|
|
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->multipress_gesture),
|
|
|
|
|
GTK_PHASE_BUBBLE);
|
|
|
|
|
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->multipress_gesture),
|
|
|
|
|
FALSE);
|
|
|
|
|
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->multipress_gesture),
|
|
|
|
|
GDK_BUTTON_PRIMARY);
|
|
|
|
|
g_signal_connect (priv->multipress_gesture, "pressed",
|
|
|
|
|
G_CALLBACK (gtk_list_box_multipress_gesture_pressed), box);
|
|
|
|
|
g_signal_connect (priv->multipress_gesture, "released",
|
|
|
|
|
G_CALLBACK (gtk_list_box_multipress_gesture_released), box);
|
|
|
|
|
|
|
|
|
|
widget_node = gtk_widget_get_css_node (GTK_WIDGET (box));
|
|
|
|
|
priv->gadget = gtk_css_custom_gadget_new_for_node (widget_node,
|
|
|
|
|
GTK_WIDGET (box),
|
|
|
|
|
gtk_list_box_measure,
|
|
|
|
|
gtk_list_box_allocate,
|
|
|
|
|
gtk_list_box_render,
|
|
|
|
|
NULL,
|
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_selected_row:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the selected row.
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Note that the box may allow multiple selection, in which
|
|
|
|
|
* case you should use gtk_list_box_selected_foreach() to
|
|
|
|
|
* find all selected rows.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the selected row
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_selected_row (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
return BOX_PRIV (box)->selected_row;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_row_at_index:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @index_: the index of the row
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Gets the n-th child in the list (not counting headers).
|
2014-05-04 17:38:31 +00:00
|
|
|
|
* If @_index is negative or larger than the number of items in the
|
|
|
|
|
* list, %NULL is returned.
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2015-12-01 12:40:46 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): the child #GtkWidget or %NULL
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_row_at_index (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gint index_)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), NULL);
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
iter = g_sequence_get_iter_at_pos (BOX_PRIV (box)->children, index_);
|
2014-05-04 17:38:31 +00:00
|
|
|
|
if (!g_sequence_iter_is_end (iter))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return g_sequence_get (iter);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-06 09:58:08 +00:00
|
|
|
|
static int
|
|
|
|
|
row_y_cmp_func (gconstpointer a,
|
|
|
|
|
gconstpointer b,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
int y = GPOINTER_TO_INT (b);
|
|
|
|
|
GtkListBoxRowPrivate *row_priv = ROW_PRIV (a);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (y < row_priv->y)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (y >= row_priv->y + row_priv->height)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_row_at_y:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-10 09:17:10 +00:00
|
|
|
|
* @y: position
|
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* Gets the row at the @y position.
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2016-01-06 09:46:29 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): the row or %NULL
|
|
|
|
|
* in case no row exists for the given y coordinate.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_row_at_y (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gint y)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-01-06 09:58:08 +00:00
|
|
|
|
iter = g_sequence_lookup (BOX_PRIV (box)->children,
|
|
|
|
|
GINT_TO_POINTER (y),
|
|
|
|
|
row_y_cmp_func,
|
|
|
|
|
NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-01-06 09:58:08 +00:00
|
|
|
|
if (iter)
|
|
|
|
|
return GTK_LIST_BOX_ROW (g_sequence_get (iter));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-01-06 09:58:08 +00:00
|
|
|
|
return NULL;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_select_row:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-10 09:17:10 +00:00
|
|
|
|
* @row: (allow-none): The row to select or %NULL
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Make @row the currently selected row.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_row (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-05-08 09:42:56 +00:00
|
|
|
|
gboolean dirty = FALSE;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2014-03-28 23:21:57 +00:00
|
|
|
|
g_return_if_fail (row == NULL || GTK_IS_LIST_BOX_ROW (row));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (row)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_row_internal (box, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
else
|
2014-05-08 09:42:56 +00:00
|
|
|
|
dirty = gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
|
|
|
|
|
if (dirty)
|
|
|
|
|
{
|
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, NULL);
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-28 23:21:57 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_unselect_row:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
* @row: the row to unselected
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Unselects a single row of @box, if the selection mode allows it.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_unselect_row (GtkListBox *box,
|
2014-03-28 23:21:57 +00:00
|
|
|
|
GtkListBoxRow *row)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2014-03-28 23:21:57 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_unselect_row_internal (box, row);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_select_all:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Select all children of @box, if the selection mode allows it.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_all (GtkListBox *box)
|
2014-03-28 23:21:57 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (g_sequence_get_length (BOX_PRIV (box)->children) > 0)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_all_between (box, NULL, NULL, FALSE);
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
2014-03-28 23:21:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_unselect_all:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Unselect all children of @box, if the selection mode allows it.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_unselect_all (GtkListBox *box)
|
2014-03-28 23:21:57 +00:00
|
|
|
|
{
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gboolean dirty = FALSE;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2014-03-28 23:21:57 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_BROWSE)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
dirty = gtk_list_box_unselect_all_internal (box);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
|
|
|
|
if (dirty)
|
2014-05-08 09:42:56 +00:00
|
|
|
|
{
|
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, NULL);
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_selected_rows_changed (GtkListBox *box)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
_gtk_list_box_accessible_selection_changed (box);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkListBoxForeachFunc:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
* @user_data: (closure): user data
|
|
|
|
|
*
|
|
|
|
|
* A function used by gtk_list_box_selected_foreach().
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* It will be called on every selected child of the @box.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_selected_foreach:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
* @func: (scope call): the function to call for each selected child
|
|
|
|
|
* @data: user data to pass to the function
|
|
|
|
|
*
|
|
|
|
|
* Calls a function for each selected child.
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Note that the selection cannot be modified from within this function.
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_selected_foreach (GtkListBox *box,
|
2014-03-28 23:21:57 +00:00
|
|
|
|
GtkListBoxForeachFunc func,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2014-03-28 23:21:57 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (gtk_list_box_row_is_selected (row))
|
2014-03-29 03:07:41 +00:00
|
|
|
|
(*func) (box, row, data);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2014-04-13 20:55:28 +00:00
|
|
|
|
* gtk_list_box_get_selected_rows:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2014-03-28 23:21:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Creates a list of all selected children.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (element-type GtkListBoxRow) (transfer container):
|
|
|
|
|
* A #GList containing the #GtkWidget for each selected child.
|
|
|
|
|
* Free with g_list_free() when done.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
GList *
|
2014-04-13 20:55:28 +00:00
|
|
|
|
gtk_list_box_get_selected_rows (GtkListBox *box)
|
2014-03-28 23:21:57 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
GList *selected = NULL;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), NULL);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (gtk_list_box_row_is_selected (row))
|
|
|
|
|
selected = g_list_prepend (selected, row);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return g_list_reverse (selected);
|
|
|
|
|
}
|
2013-06-11 14:53:31 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_placeholder:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 14:53:31 +00:00
|
|
|
|
* @placeholder: (allow-none): a #GtkWidget or %NULL
|
|
|
|
|
*
|
|
|
|
|
* Sets the placeholder widget that is shown in the list when
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* it doesn't display any visible children.
|
2013-06-11 14:53:31 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_placeholder (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkWidget *placeholder)
|
2013-06-11 14:53:31 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-11 14:53:31 +00:00
|
|
|
|
|
|
|
|
|
if (priv->placeholder)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_unparent (priv->placeholder);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-11 14:53:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
priv->placeholder = placeholder;
|
|
|
|
|
|
|
|
|
|
if (placeholder)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_set_parent (GTK_WIDGET (placeholder), GTK_WIDGET (box));
|
2013-06-11 14:53:31 +00:00
|
|
|
|
gtk_widget_set_child_visible (GTK_WIDGET (placeholder),
|
|
|
|
|
priv->n_visible_rows == 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_adjustment:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @adjustment: (allow-none): the adjustment, or %NULL
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Sets the adjustment (if any) that the widget uses to
|
|
|
|
|
* for vertical scrolling. For instance, this is used
|
|
|
|
|
* to get the page size for PageUp/Down key handling.
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* In the normal case when the @box is packed inside
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* a #GtkScrolledWindow the adjustment from that will
|
|
|
|
|
* be picked up automatically, so there is no need
|
|
|
|
|
* to manually do that.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_adjustment (GtkListBox *box,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkAdjustment *adjustment)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2015-07-20 02:08:36 +00:00
|
|
|
|
g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-07-20 02:08:36 +00:00
|
|
|
|
if (adjustment)
|
|
|
|
|
g_object_ref_sink (adjustment);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (priv->adjustment)
|
|
|
|
|
g_object_unref (priv->adjustment);
|
|
|
|
|
priv->adjustment = adjustment;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_adjustment:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the adjustment (if any) that the widget uses to
|
|
|
|
|
* for vertical scrolling.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: (transfer none): the adjustment
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkAdjustment *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_adjustment (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
return BOX_PRIV (box)->adjustment;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 02:08:36 +00:00
|
|
|
|
static void
|
|
|
|
|
adjustment_changed (GObject *object,
|
|
|
|
|
GParamSpec *pspec,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkAdjustment *adjustment;
|
|
|
|
|
|
|
|
|
|
adjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (object));
|
|
|
|
|
gtk_list_box_set_adjustment (GTK_LIST_BOX (data), adjustment);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 14:07:20 +00:00
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_parent_set (GtkWidget *widget,
|
|
|
|
|
GtkWidget *prev_parent)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-06-10 14:07:20 +00:00
|
|
|
|
GtkWidget *parent;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-10 14:07:20 +00:00
|
|
|
|
parent = gtk_widget_get_parent (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-07-20 02:08:36 +00:00
|
|
|
|
if (prev_parent && GTK_IS_SCROLLABLE (prev_parent))
|
|
|
|
|
g_signal_handlers_disconnect_by_func (prev_parent,
|
|
|
|
|
G_CALLBACK (adjustment_changed), widget);
|
|
|
|
|
|
2013-06-10 14:07:20 +00:00
|
|
|
|
if (parent && GTK_IS_SCROLLABLE (parent))
|
|
|
|
|
{
|
2015-07-20 02:08:36 +00:00
|
|
|
|
adjustment_changed (G_OBJECT (parent), NULL, widget);
|
|
|
|
|
g_signal_connect (parent, "notify::vadjustment",
|
|
|
|
|
G_CALLBACK (adjustment_changed), widget);
|
2013-06-10 14:07:20 +00:00
|
|
|
|
}
|
2015-07-20 02:08:36 +00:00
|
|
|
|
else
|
|
|
|
|
gtk_list_box_set_adjustment (GTK_LIST_BOX (widget), NULL);
|
2013-06-10 14:07:20 +00:00
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_selection_mode:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @mode: The #GtkSelectionMode
|
|
|
|
|
*
|
|
|
|
|
* Sets how selection works in the listbox.
|
|
|
|
|
* See #GtkSelectionMode for details.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_selection_mode (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkSelectionMode mode)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gboolean dirty = FALSE;
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (priv->selection_mode == mode)
|
|
|
|
|
return;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (mode == GTK_SELECTION_NONE ||
|
|
|
|
|
priv->selection_mode == GTK_SELECTION_MULTIPLE)
|
2015-07-26 06:40:26 +00:00
|
|
|
|
dirty = gtk_list_box_unselect_all_internal (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
priv->selection_mode = mode;
|
|
|
|
|
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gtk_list_box_update_row_styles (box);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (box), properties[PROP_SELECTION_MODE]);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
|
|
|
|
if (dirty)
|
2014-04-13 20:51:49 +00:00
|
|
|
|
{
|
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, NULL);
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_selection_mode:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the selection mode of the listbox.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a #GtkSelectionMode
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkSelectionMode
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_selection_mode (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), GTK_SELECTION_NONE);
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
return BOX_PRIV (box)->selection_mode;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_filter_func:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @filter_func: (closure user_data) (allow-none): callback that lets you filter which rows to show
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @user_data: user data passed to @filter_func
|
|
|
|
|
* @destroy: destroy notifier for @user_data
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* By setting a filter function on the @box one can decide dynamically which
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* of the rows to show. For instance, to implement a search function on a list that
|
|
|
|
|
* filters the original list to only show the matching rows.
|
|
|
|
|
*
|
|
|
|
|
* The @filter_func will be called for each row after the call, and it will
|
|
|
|
|
* continue to be called each time a row changes (via gtk_list_box_row_changed()) or
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* when gtk_list_box_invalidate_filter() is called.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
2015-08-25 17:20:53 +00:00
|
|
|
|
* Note that using a filter function is incompatible with using a model
|
|
|
|
|
* (see gtk_list_box_bind_model()).
|
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_filter_func (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxFilterFunc filter_func,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GDestroyNotify destroy)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->filter_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->filter_func_target_destroy_notify (priv->filter_func_target);
|
|
|
|
|
|
|
|
|
|
priv->filter_func = filter_func;
|
|
|
|
|
priv->filter_func_target = user_data;
|
|
|
|
|
priv->filter_func_target_destroy_notify = destroy;
|
|
|
|
|
|
2015-08-25 17:16:24 +00:00
|
|
|
|
gtk_list_box_check_model_compat (box);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_filter (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* gtk_list_box_set_header_func:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @update_header: (closure user_data) (allow-none): callback that lets you add row headers
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* @user_data: user data passed to @update_header
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @destroy: destroy notifier for @user_data
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* By setting a header function on the @box one can dynamically add headers
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* in front of rows, depending on the contents of the row and its position in the list.
|
|
|
|
|
* For instance, one could use it to add headers in front of the first item of a
|
|
|
|
|
* new kind, in a list sorted by the kind.
|
|
|
|
|
*
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* The @update_header can look at the current header widget using gtk_list_box_row_get_header()
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* and either update the state of the widget as needed, or set a new one using
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* gtk_list_box_row_set_header(). If no header is needed, set the header to %NULL.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* Note that you may get many calls @update_header to this for a particular row when e.g.
|
2014-02-07 18:32:47 +00:00
|
|
|
|
* changing things that don’t affect the header. In this case it is important for performance
|
2014-07-12 18:46:00 +00:00
|
|
|
|
* to not blindly replace an existing header with an identical one.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* The @update_header function will be called for each row after the call, and it will
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* continue to be called each time a row changes (via gtk_list_box_row_changed()) and when
|
|
|
|
|
* the row before changes (either by gtk_list_box_row_changed() on the previous row, or when
|
|
|
|
|
* the previous row becomes a different row). It is also called for all rows when
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* gtk_list_box_invalidate_headers() is called.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_header_func (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxUpdateHeaderFunc update_header,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GDestroyNotify destroy)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (priv->update_header_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->update_header_func_target_destroy_notify (priv->update_header_func_target);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 12:09:19 +00:00
|
|
|
|
priv->update_header_func = update_header;
|
|
|
|
|
priv->update_header_func_target = user_data;
|
|
|
|
|
priv->update_header_func_target_destroy_notify = destroy;
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_headers (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* gtk_list_box_invalidate_filter:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Update the filtering for all rows. Call this when result
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* of the filter function on the @box is changed due
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* to an external factor. For instance, this would be used
|
|
|
|
|
* if the filter function just looked for a specific search
|
|
|
|
|
* string and the entry with the search string has changed.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_filter (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_apply_filter_all (box);
|
|
|
|
|
gtk_list_box_invalidate_headers (box);
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gint
|
|
|
|
|
do_sort (GtkListBoxRow *a,
|
|
|
|
|
GtkListBoxRow *b,
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
return priv->sort_func (a, b, priv->sort_func_target);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-30 03:03:11 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_css_node_foreach (gpointer data,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget **previous = user_data;
|
|
|
|
|
GtkWidget *row = data;
|
|
|
|
|
GtkCssNode *row_node;
|
|
|
|
|
GtkCssNode *prev_node;
|
|
|
|
|
|
|
|
|
|
if (*previous)
|
|
|
|
|
{
|
|
|
|
|
prev_node = gtk_widget_get_css_node (*previous);
|
|
|
|
|
row_node = gtk_widget_get_css_node (row);
|
2015-07-12 19:39:49 +00:00
|
|
|
|
gtk_css_node_insert_after (gtk_css_node_get_parent (row_node),
|
|
|
|
|
row_node,
|
|
|
|
|
prev_node);
|
2015-05-30 03:03:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*previous = row;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* gtk_list_box_invalidate_sort:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Update the sorting for all rows. Call this when result
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* of the sort function on the @box is changed due
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* to an external factor.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_sort (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2015-05-30 03:03:11 +00:00
|
|
|
|
GtkWidget *previous = NULL;
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-06-20 22:17:00 +00:00
|
|
|
|
if (priv->sort_func == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_sequence_sort (priv->children, (GCompareDataFunc)do_sort, box);
|
2015-05-30 03:03:11 +00:00
|
|
|
|
g_sequence_foreach (priv->children, gtk_list_box_css_node_foreach, &previous);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_headers (box);
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 14:04:58 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_do_reseparate (GtkListBox *box)
|
2013-06-11 14:04:58 +00:00
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
2013-06-11 14:04:58 +00:00
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_header (box, iter);
|
2013-06-11 14:04:58 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-11 14:04:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* gtk_list_box_invalidate_headers:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Update the separators for all rows. Call this when result
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* of the header function on the @box is changed due
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* to an external factor.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_headers (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (!gtk_widget_get_visible (GTK_WIDGET (box)))
|
2013-06-11 14:04:58 +00:00
|
|
|
|
return;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_do_reseparate (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_sort_func:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @sort_func: (closure user_data) (allow-none): the sort function
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @user_data: user data passed to @sort_func
|
|
|
|
|
* @destroy: destroy notifier for @user_data
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* By setting a sort function on the @box one can dynamically reorder the rows
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* of the list, based on the contents of the rows.
|
|
|
|
|
*
|
|
|
|
|
* The @sort_func will be called for each row after the call, and will continue to
|
|
|
|
|
* be called each time a row changes (via gtk_list_box_row_changed()) and when
|
2013-06-11 14:58:22 +00:00
|
|
|
|
* gtk_list_box_invalidate_sort() is called.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
2015-08-25 17:20:53 +00:00
|
|
|
|
* Note that using a sort function is incompatible with using a model
|
|
|
|
|
* (see gtk_list_box_bind_model()).
|
|
|
|
|
*
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_sort_func (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxSortFunc sort_func,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GDestroyNotify destroy)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->sort_func_target_destroy_notify != NULL)
|
|
|
|
|
priv->sort_func_target_destroy_notify (priv->sort_func_target);
|
|
|
|
|
|
|
|
|
|
priv->sort_func = sort_func;
|
|
|
|
|
priv->sort_func_target = user_data;
|
|
|
|
|
priv->sort_func_target_destroy_notify = destroy;
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2015-08-25 17:16:24 +00:00
|
|
|
|
gtk_list_box_check_model_compat (box);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_invalidate_sort (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_got_row_changed (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
GtkListBoxRowPrivate *row_priv = ROW_PRIV (row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GSequenceIter *prev_next, *next;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-09-28 01:39:10 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
prev_next = gtk_list_box_get_next_visible (box, row_priv->iter);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (priv->sort_func != NULL)
|
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_sequence_sort_changed (row_priv->iter,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
(GCompareDataFunc)do_sort,
|
2014-03-29 03:07:41 +00:00
|
|
|
|
box);
|
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_apply_filter (box, row);
|
|
|
|
|
if (gtk_widget_get_visible (GTK_WIDGET (box)))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
next = gtk_list_box_get_next_visible (box, row_priv->iter);
|
|
|
|
|
gtk_list_box_update_header (box, row_priv->iter);
|
|
|
|
|
gtk_list_box_update_header (box, next);
|
|
|
|
|
gtk_list_box_update_header (box, prev_next);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_set_activate_on_single_click:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @single: a boolean
|
|
|
|
|
*
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* If @single is %TRUE, rows will be activated when you click on them,
|
|
|
|
|
* otherwise you need to double-click.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_set_activate_on_single_click (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gboolean single)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
single = single != FALSE;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (BOX_PRIV (box)->activate_single_click == single)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
BOX_PRIV (box)->activate_single_click = single;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (box), properties[PROP_ACTIVATE_ON_SINGLE_CLICK]);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-12 07:40:06 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_get_activate_on_single_click:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-12 07:40:06 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns whether rows activate on single clicks.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if rows are activated on single click, %FALSE otherwise
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_activate_on_single_click (GtkListBox *box)
|
2013-06-12 07:40:06 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX (box), FALSE);
|
2013-06-12 07:40:06 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
return BOX_PRIV (box)->activate_single_click;
|
2013-06-12 07:40:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gtk_list_box_add_move_binding (GtkBindingSet *binding_set,
|
|
|
|
|
guint keyval,
|
|
|
|
|
GdkModifierType modmask,
|
|
|
|
|
GtkMovementStep step,
|
|
|
|
|
gint count)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 01:34:39 +00:00
|
|
|
|
GdkDisplay *display;
|
|
|
|
|
GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
|
|
|
|
|
GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
display = gdk_display_get_default ();
|
|
|
|
|
if (display)
|
|
|
|
|
{
|
|
|
|
|
extend_mod_mask = gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
|
|
|
|
|
GDK_MODIFIER_INTENT_EXTEND_SELECTION);
|
|
|
|
|
modify_mod_mask = gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
|
|
|
|
|
GDK_MODIFIER_INTENT_MODIFY_SELECTION);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_binding_entry_add_signal (binding_set, keyval, modmask,
|
|
|
|
|
"move-cursor", 2,
|
|
|
|
|
GTK_TYPE_MOVEMENT_STEP, step,
|
|
|
|
|
G_TYPE_INT, count,
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_binding_entry_add_signal (binding_set, keyval, modmask | extend_mod_mask,
|
|
|
|
|
"move-cursor", 2,
|
|
|
|
|
GTK_TYPE_MOVEMENT_STEP, step,
|
|
|
|
|
G_TYPE_INT, count,
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_binding_entry_add_signal (binding_set, keyval, modmask | modify_mod_mask,
|
|
|
|
|
"move-cursor", 2,
|
|
|
|
|
GTK_TYPE_MOVEMENT_STEP, step,
|
|
|
|
|
G_TYPE_INT, count,
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_binding_entry_add_signal (binding_set, keyval, modmask | extend_mod_mask | modify_mod_mask,
|
|
|
|
|
"move-cursor", 2,
|
|
|
|
|
GTK_TYPE_MOVEMENT_STEP, step,
|
|
|
|
|
G_TYPE_INT, count,
|
|
|
|
|
NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-13 16:31:28 +00:00
|
|
|
|
static void
|
|
|
|
|
ensure_row_visible (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
GtkWidget *header;
|
2015-07-20 02:18:58 +00:00
|
|
|
|
gint y, height;
|
2014-07-13 16:31:28 +00:00
|
|
|
|
GtkAllocation allocation;
|
|
|
|
|
|
2014-07-13 19:51:03 +00:00
|
|
|
|
if (!priv->adjustment)
|
|
|
|
|
return;
|
|
|
|
|
|
2015-07-20 02:18:58 +00:00
|
|
|
|
gtk_widget_get_allocation (GTK_WIDGET (row), &allocation);
|
|
|
|
|
y = allocation.y;
|
|
|
|
|
height = allocation.height;
|
|
|
|
|
|
2014-07-13 16:31:28 +00:00
|
|
|
|
/* If the row has a header, we want to ensure that it is visible as well. */
|
|
|
|
|
header = ROW_PRIV (row)->header;
|
|
|
|
|
if (GTK_IS_WIDGET (header) && gtk_widget_is_drawable (header))
|
2015-07-20 02:18:58 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_get_allocation (header, &allocation);
|
|
|
|
|
y = allocation.y;
|
|
|
|
|
height += allocation.height;
|
|
|
|
|
}
|
2014-07-13 16:31:28 +00:00
|
|
|
|
|
2015-07-20 02:18:58 +00:00
|
|
|
|
gtk_adjustment_clamp_page (priv->adjustment, y, y + height);
|
2014-07-13 16:31:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_cursor (GtkListBox *box,
|
2015-02-10 19:02:08 +00:00
|
|
|
|
GtkListBoxRow *row,
|
|
|
|
|
gboolean grab_focus)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
BOX_PRIV (box)->cursor_row = row;
|
2015-02-10 19:02:08 +00:00
|
|
|
|
ensure_row_visible (box, row);
|
|
|
|
|
if (grab_focus)
|
|
|
|
|
gtk_widget_grab_focus (GTK_WIDGET (row));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_widget_queue_draw (GTK_WIDGET (row));
|
2014-03-29 03:07:41 +00:00
|
|
|
|
_gtk_list_box_accessible_update_cursor (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static GtkListBox *
|
|
|
|
|
gtk_list_box_row_get_box (GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 01:34:39 +00:00
|
|
|
|
GtkWidget *parent;
|
|
|
|
|
|
|
|
|
|
parent = gtk_widget_get_parent (GTK_WIDGET (row));
|
|
|
|
|
if (parent && GTK_IS_LIST_BOX (parent))
|
|
|
|
|
return GTK_LIST_BOX (parent);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
row_is_visible (GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
return ROW_PRIV (row)->visible;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_list_box_row_set_selected (GtkListBoxRow *row,
|
|
|
|
|
gboolean selected)
|
|
|
|
|
{
|
2014-07-16 03:14:28 +00:00
|
|
|
|
if (!ROW_PRIV (row)->selectable)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
2014-03-29 05:03:06 +00:00
|
|
|
|
if (ROW_PRIV (row)->selected != selected)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 05:03:06 +00:00
|
|
|
|
ROW_PRIV (row)->selected = selected;
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (selected)
|
|
|
|
|
gtk_widget_set_state_flags (GTK_WIDGET (row),
|
|
|
|
|
GTK_STATE_FLAG_SELECTED, FALSE);
|
|
|
|
|
else
|
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (row),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GTK_STATE_FLAG_SELECTED);
|
2014-03-28 23:21:57 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
return TRUE;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_list_box_unselect_all_internal (GtkListBox *box)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
gboolean dirty = FALSE;
|
|
|
|
|
|
|
|
|
|
if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
dirty |= gtk_list_box_row_set_selected (row, FALSE);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-01 02:34:09 +00:00
|
|
|
|
BOX_PRIV (box)->selected_row = NULL;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
return dirty;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_unselect_row_internal (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
if (!ROW_PRIV (row)->selected)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
|
|
|
|
|
return;
|
|
|
|
|
else if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
|
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
else
|
|
|
|
|
gtk_list_box_row_set_selected (row, FALSE);
|
|
|
|
|
|
2014-05-08 09:42:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, NULL);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_select_row_internal (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-07-16 03:14:28 +00:00
|
|
|
|
if (!ROW_PRIV (row)->selectable)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (ROW_PRIV (row)->selected)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
|
|
|
|
|
return;
|
2014-07-16 03:14:28 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
|
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
|
|
|
|
|
gtk_list_box_row_set_selected (row, TRUE);
|
|
|
|
|
BOX_PRIV (box)->selected_row = row;
|
|
|
|
|
|
2014-04-08 03:17:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_select_all_between (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row1,
|
|
|
|
|
GtkListBoxRow *row2,
|
|
|
|
|
gboolean modify)
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter, *iter1, *iter2;
|
|
|
|
|
|
|
|
|
|
if (row1)
|
|
|
|
|
iter1 = ROW_PRIV (row1)->iter;
|
|
|
|
|
else
|
|
|
|
|
iter1 = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
|
|
|
|
|
|
|
|
|
if (row2)
|
|
|
|
|
iter2 = ROW_PRIV (row2)->iter;
|
|
|
|
|
else
|
|
|
|
|
iter2 = g_sequence_get_end_iter (BOX_PRIV (box)->children);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (g_sequence_iter_compare (iter2, iter1) < 0)
|
|
|
|
|
{
|
|
|
|
|
iter = iter1;
|
|
|
|
|
iter1 = iter2;
|
|
|
|
|
iter2 = iter;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (iter = iter1;
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
|
|
|
|
row = GTK_LIST_BOX_ROW (g_sequence_get (iter));
|
|
|
|
|
if (row_is_visible (row))
|
|
|
|
|
{
|
|
|
|
|
if (modify)
|
|
|
|
|
gtk_list_box_row_set_selected (row, !ROW_PRIV (row)->selected);
|
|
|
|
|
else
|
|
|
|
|
gtk_list_box_row_set_selected (row, TRUE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (g_sequence_iter_compare (iter, iter2) == 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-23 20:43:11 +00:00
|
|
|
|
#define gtk_list_box_update_selection(b,r,m,e) \
|
|
|
|
|
gtk_list_box_update_selection_full((b), (r), (m), (e), TRUE)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static void
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_update_selection_full (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row,
|
|
|
|
|
gboolean modify,
|
|
|
|
|
gboolean extend,
|
|
|
|
|
gboolean grab_cursor)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_update_cursor (box, row, grab_cursor);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
|
|
|
|
if (priv->selection_mode == GTK_SELECTION_NONE)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-07-16 03:14:28 +00:00
|
|
|
|
if (!ROW_PRIV (row)->selectable)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (priv->selection_mode == GTK_SELECTION_BROWSE)
|
|
|
|
|
{
|
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
gtk_list_box_row_set_selected (row, TRUE);
|
|
|
|
|
priv->selected_row = row;
|
2019-01-01 23:14:17 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
else if (priv->selection_mode == GTK_SELECTION_SINGLE)
|
|
|
|
|
{
|
|
|
|
|
gboolean was_selected;
|
|
|
|
|
|
|
|
|
|
was_selected = ROW_PRIV (row)->selected;
|
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
gtk_list_box_row_set_selected (row, modify ? !was_selected : TRUE);
|
|
|
|
|
priv->selected_row = ROW_PRIV (row)->selected ? row : NULL;
|
2014-05-08 09:42:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, priv->selected_row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
else /* GTK_SELECTION_MULTIPLE */
|
|
|
|
|
{
|
|
|
|
|
if (extend)
|
|
|
|
|
{
|
2015-07-26 06:40:26 +00:00
|
|
|
|
GtkListBoxRow *selected_row;
|
|
|
|
|
|
|
|
|
|
selected_row = priv->selected_row;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
2015-07-26 06:40:26 +00:00
|
|
|
|
|
|
|
|
|
if (selected_row == NULL)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_list_box_row_set_selected (row, TRUE);
|
|
|
|
|
priv->selected_row = row;
|
2014-05-08 09:42:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2021-04-20 19:16:00 +00:00
|
|
|
|
{
|
|
|
|
|
priv->selected_row = selected_row;
|
|
|
|
|
gtk_list_box_select_all_between (box, selected_row, row, FALSE);
|
|
|
|
|
}
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (modify)
|
|
|
|
|
{
|
|
|
|
|
gtk_list_box_row_set_selected (row, !ROW_PRIV (row)->selected);
|
2014-05-08 09:42:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, ROW_PRIV (row)->selected ? row
|
|
|
|
|
: NULL);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gtk_list_box_unselect_all_internal (box);
|
|
|
|
|
gtk_list_box_row_set_selected (row, !ROW_PRIV (row)->selected);
|
|
|
|
|
priv->selected_row = row;
|
2014-05-08 09:42:56 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_activate (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row)
|
|
|
|
|
{
|
2017-11-24 13:33:42 +00:00
|
|
|
|
GtkListBoxRowPrivate *priv = ROW_PRIV (row);
|
|
|
|
|
|
|
|
|
|
if (!gtk_list_box_row_get_activatable (row))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (priv->action_helper)
|
|
|
|
|
gtk_action_helper_activate (priv->action_helper);
|
|
|
|
|
else
|
2014-07-13 00:37:41 +00:00
|
|
|
|
g_signal_emit (box, signals[ROW_ACTIVATED], 0, row);
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-23 20:43:11 +00:00
|
|
|
|
#define gtk_list_box_select_and_activate(b,r) \
|
|
|
|
|
gtk_list_box_select_and_activate_full ((b), (r), TRUE)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static void
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_select_and_activate_full (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row,
|
|
|
|
|
gboolean grab_focus)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (row != NULL)
|
2014-03-29 01:34:39 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_list_box_select_row_internal (box, row);
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_update_cursor (box, row, grab_focus);
|
2014-07-13 00:37:41 +00:00
|
|
|
|
gtk_list_box_activate (box, row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_prelight (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (row != priv->prelight_row)
|
|
|
|
|
{
|
|
|
|
|
if (priv->prelight_row)
|
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (priv->prelight_row),
|
|
|
|
|
GTK_STATE_FLAG_PRELIGHT);
|
2013-07-29 09:23:58 +00:00
|
|
|
|
|
|
|
|
|
if (row != NULL && gtk_widget_is_sensitive (GTK_WIDGET (row)))
|
|
|
|
|
{
|
|
|
|
|
priv->prelight_row = row;
|
|
|
|
|
gtk_widget_set_state_flags (GTK_WIDGET (priv->prelight_row),
|
|
|
|
|
GTK_STATE_FLAG_PRELIGHT,
|
|
|
|
|
FALSE);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
priv->prelight_row = NULL;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_active (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gboolean val;
|
|
|
|
|
|
|
|
|
|
val = priv->active_row == row;
|
|
|
|
|
if (priv->active_row != NULL &&
|
|
|
|
|
val != priv->active_row_active)
|
|
|
|
|
{
|
|
|
|
|
priv->active_row_active = val;
|
|
|
|
|
if (priv->active_row_active)
|
|
|
|
|
gtk_widget_set_state_flags (GTK_WIDGET (priv->active_row),
|
|
|
|
|
GTK_STATE_FLAG_ACTIVE,
|
|
|
|
|
FALSE);
|
|
|
|
|
else
|
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (priv->active_row),
|
|
|
|
|
GTK_STATE_FLAG_ACTIVE);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_enter_notify_event (GtkWidget *widget,
|
|
|
|
|
GdkEventCrossing *event)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (event->window != gtk_widget_get_window (widget))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
BOX_PRIV (box)->in_widget = TRUE;
|
2013-06-17 13:13:17 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
row = gtk_list_box_get_row_at_y (box, event->y);
|
|
|
|
|
gtk_list_box_update_prelight (box, row);
|
|
|
|
|
gtk_list_box_update_active (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_leave_notify_event (GtkWidget *widget,
|
|
|
|
|
GdkEventCrossing *event)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row = NULL;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (event->window != gtk_widget_get_window (widget))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
if (event->detail != GDK_NOTIFY_INFERIOR)
|
2013-06-17 13:13:17 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
BOX_PRIV (box)->in_widget = FALSE;
|
2013-06-17 13:13:17 +00:00
|
|
|
|
row = NULL;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
else
|
2014-03-29 03:07:41 +00:00
|
|
|
|
row = gtk_list_box_get_row_at_y (box, event->y);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_prelight (box, row);
|
|
|
|
|
gtk_list_box_update_active (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_motion_notify_event (GtkWidget *widget,
|
|
|
|
|
GdkEventMotion *event)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GdkWindow *window, *event_window;
|
|
|
|
|
gint relative_y;
|
|
|
|
|
gdouble parent_y;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (!BOX_PRIV (box)->in_widget)
|
2013-06-17 13:13:17 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
window = gtk_widget_get_window (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
event_window = event->window;
|
|
|
|
|
relative_y = event->y;
|
|
|
|
|
|
|
|
|
|
while ((event_window != NULL) && (event_window != window))
|
|
|
|
|
{
|
|
|
|
|
gdk_window_coords_to_parent (event_window, 0, relative_y, NULL, &parent_y);
|
|
|
|
|
relative_y = parent_y;
|
|
|
|
|
event_window = gdk_window_get_effective_parent (event_window);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
row = gtk_list_box_get_row_at_y (box, relative_y);
|
|
|
|
|
gtk_list_box_update_prelight (box, row);
|
|
|
|
|
gtk_list_box_update_active (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_multipress_gesture_pressed (GtkGestureMultiPress *gesture,
|
|
|
|
|
guint n_press,
|
|
|
|
|
gdouble x,
|
|
|
|
|
gdouble y,
|
|
|
|
|
GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2014-06-05 13:40:02 +00:00
|
|
|
|
GtkListBoxRow *row;
|
2013-06-11 13:04:02 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
priv->active_row = NULL;
|
|
|
|
|
row = gtk_list_box_get_row_at_y (box, y);
|
2013-06-17 12:52:05 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
if (row != NULL && gtk_widget_is_sensitive (GTK_WIDGET (row)))
|
|
|
|
|
{
|
|
|
|
|
priv->active_row = row;
|
|
|
|
|
priv->active_row_active = TRUE;
|
|
|
|
|
gtk_widget_set_state_flags (GTK_WIDGET (priv->active_row),
|
|
|
|
|
GTK_STATE_FLAG_ACTIVE,
|
|
|
|
|
FALSE);
|
2013-06-17 12:52:05 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
if (n_press == 2 && !priv->activate_single_click)
|
2014-07-13 00:37:41 +00:00
|
|
|
|
gtk_list_box_activate (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
static void
|
|
|
|
|
get_current_selection_modifiers (GtkWidget *widget,
|
|
|
|
|
gboolean *modify,
|
|
|
|
|
gboolean *extend)
|
|
|
|
|
{
|
|
|
|
|
GdkModifierType state = 0;
|
|
|
|
|
GdkModifierType mask;
|
|
|
|
|
|
|
|
|
|
*modify = FALSE;
|
|
|
|
|
*extend = FALSE;
|
|
|
|
|
|
|
|
|
|
if (gtk_get_current_event_state (&state))
|
|
|
|
|
{
|
|
|
|
|
mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
|
|
|
|
|
if ((state & mask) == mask)
|
|
|
|
|
*modify = TRUE;
|
|
|
|
|
mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
|
|
|
|
|
if ((state & mask) == mask)
|
|
|
|
|
*extend = TRUE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_multipress_gesture_released (GtkGestureMultiPress *gesture,
|
|
|
|
|
guint n_press,
|
|
|
|
|
gdouble x,
|
|
|
|
|
gdouble y,
|
|
|
|
|
GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
/* Take a ref to protect against reentrancy
|
|
|
|
|
* (the activation may destroy the widget)
|
|
|
|
|
*/
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_object_ref (box);
|
2013-06-12 11:20:15 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
if (priv->active_row != NULL && priv->active_row_active)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-11-25 00:05:04 +00:00
|
|
|
|
gboolean focus_on_click = gtk_widget_get_focus_on_click (GTK_WIDGET (priv->active_row));
|
2015-10-23 20:43:11 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (priv->active_row),
|
|
|
|
|
GTK_STATE_FLAG_ACTIVE);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
if (n_press == 1 && priv->activate_single_click)
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_select_and_activate_full (box, priv->active_row, focus_on_click);
|
2014-06-05 13:40:02 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
GdkEventSequence *sequence;
|
|
|
|
|
GdkInputSource source;
|
|
|
|
|
const GdkEvent *event;
|
|
|
|
|
gboolean modify;
|
|
|
|
|
gboolean extend;
|
|
|
|
|
|
|
|
|
|
get_current_selection_modifiers (GTK_WIDGET (box), &modify, &extend);
|
|
|
|
|
/* With touch, we default to modifying the selection.
|
|
|
|
|
* You can still clear the selection and start over
|
|
|
|
|
* by holding Ctrl.
|
|
|
|
|
*/
|
|
|
|
|
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
|
|
|
|
|
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
|
|
|
|
|
source = gdk_device_get_source (gdk_event_get_source_device (event));
|
|
|
|
|
|
|
|
|
|
if (source == GDK_SOURCE_TOUCHSCREEN)
|
|
|
|
|
modify = !modify;
|
|
|
|
|
|
2015-10-23 20:43:11 +00:00
|
|
|
|
gtk_list_box_update_selection_full (box, priv->active_row, modify, extend, focus_on_click);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2014-06-05 13:40:02 +00:00
|
|
|
|
}
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2014-06-05 13:40:02 +00:00
|
|
|
|
priv->active_row = NULL;
|
|
|
|
|
priv->active_row_active = FALSE;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_object_unref (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_show (GtkWidget *widget)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_do_reseparate (GTK_LIST_BOX (widget));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_parent_class)->show (widget);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_focus (GtkWidget *widget,
|
|
|
|
|
GtkDirectionType direction)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (widget);
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkWidget *focus_child;
|
|
|
|
|
GtkListBoxRow *next_focus_row;
|
2015-08-22 00:51:03 +00:00
|
|
|
|
GtkWidget *row;
|
|
|
|
|
GtkWidget *header;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
focus_child = gtk_container_get_focus_child ((GtkContainer *)box);
|
2015-08-22 00:51:03 +00:00
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
next_focus_row = NULL;
|
|
|
|
|
if (focus_child != NULL)
|
|
|
|
|
{
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GSequenceIter *i;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (gtk_widget_child_focus (focus_child, direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
if (direction == GTK_DIR_UP || direction == GTK_DIR_TAB_BACKWARD)
|
|
|
|
|
{
|
2015-08-22 00:51:03 +00:00
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (focus_child))
|
|
|
|
|
{
|
|
|
|
|
header = ROW_PRIV (GTK_LIST_BOX_ROW (focus_child))->header;
|
|
|
|
|
if (header && gtk_widget_child_focus (header, direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (focus_child))
|
|
|
|
|
row = focus_child;
|
|
|
|
|
else
|
|
|
|
|
row = g_hash_table_lookup (priv->header_hash, focus_child);
|
|
|
|
|
|
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (row))
|
|
|
|
|
i = gtk_list_box_get_previous_visible (box, ROW_PRIV (GTK_LIST_BOX_ROW (row))->iter);
|
|
|
|
|
else
|
|
|
|
|
i = NULL;
|
|
|
|
|
|
2013-09-15 20:31:12 +00:00
|
|
|
|
while (i != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (gtk_widget_get_sensitive (g_sequence_get (i)))
|
|
|
|
|
{
|
|
|
|
|
next_focus_row = g_sequence_get (i);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
i = gtk_list_box_get_previous_visible (box, i);
|
2013-09-15 20:31:12 +00:00
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
else if (direction == GTK_DIR_DOWN || direction == GTK_DIR_TAB_FORWARD)
|
|
|
|
|
{
|
2015-08-22 00:51:03 +00:00
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (focus_child))
|
|
|
|
|
i = gtk_list_box_get_next_visible (box, ROW_PRIV (GTK_LIST_BOX_ROW (focus_child))->iter);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
row = g_hash_table_lookup (priv->header_hash, focus_child);
|
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (row))
|
|
|
|
|
i = ROW_PRIV (GTK_LIST_BOX_ROW (row))->iter;
|
|
|
|
|
else
|
|
|
|
|
i = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-15 20:31:12 +00:00
|
|
|
|
while (!g_sequence_iter_is_end (i))
|
|
|
|
|
{
|
|
|
|
|
if (gtk_widget_get_sensitive (g_sequence_get (i)))
|
|
|
|
|
{
|
|
|
|
|
next_focus_row = g_sequence_get (i);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
i = gtk_list_box_get_next_visible (box, i);
|
2013-09-15 20:31:12 +00:00
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* No current focus row */
|
|
|
|
|
switch (direction)
|
|
|
|
|
{
|
|
|
|
|
case GTK_DIR_UP:
|
|
|
|
|
case GTK_DIR_TAB_BACKWARD:
|
|
|
|
|
next_focus_row = priv->selected_row;
|
|
|
|
|
if (next_focus_row == NULL)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
next_focus_row = gtk_list_box_get_last_focusable (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
next_focus_row = priv->selected_row;
|
|
|
|
|
if (next_focus_row == NULL)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
next_focus_row = gtk_list_box_get_first_focusable (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (next_focus_row == NULL)
|
|
|
|
|
{
|
|
|
|
|
if (direction == GTK_DIR_UP || direction == GTK_DIR_DOWN)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (gtk_widget_keynav_failed (GTK_WIDGET (box), direction))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-22 00:51:03 +00:00
|
|
|
|
if (direction == GTK_DIR_DOWN || direction == GTK_DIR_TAB_FORWARD)
|
|
|
|
|
{
|
|
|
|
|
header = ROW_PRIV (next_focus_row)->header;
|
|
|
|
|
if (header && gtk_widget_child_focus (header, direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (gtk_widget_child_focus (GTK_WIDGET (next_focus_row), direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
2015-08-22 00:51:03 +00:00
|
|
|
|
return FALSE;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_draw (GtkWidget *widget,
|
|
|
|
|
cairo_t *cr)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_css_gadget_draw (BOX_PRIV (widget)->gadget, cr);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_list_box_render (GtkCssGadget *gadget,
|
|
|
|
|
cairo_t *cr,
|
|
|
|
|
int x,
|
|
|
|
|
int y,
|
|
|
|
|
int width,
|
|
|
|
|
int height,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_parent_class)->draw (widget, cr);
|
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
return FALSE;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_realize (GtkWidget *widget)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAllocation allocation;
|
2013-09-28 02:00:38 +00:00
|
|
|
|
GdkWindowAttr attributes = { 0, };
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkWindow *window;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_get_allocation (widget, &allocation);
|
|
|
|
|
gtk_widget_set_realized (widget, TRUE);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
attributes.x = allocation.x;
|
|
|
|
|
attributes.y = allocation.y;
|
|
|
|
|
attributes.width = allocation.width;
|
|
|
|
|
attributes.height = allocation.height;
|
|
|
|
|
attributes.window_type = GDK_WINDOW_CHILD;
|
2014-03-29 03:07:41 +00:00
|
|
|
|
attributes.event_mask = gtk_widget_get_events (widget) |
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK |
|
2015-09-14 08:56:13 +00:00
|
|
|
|
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
attributes.wclass = GDK_INPUT_OUTPUT;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
window = gdk_window_new (gtk_widget_get_parent_window (widget),
|
2013-06-10 09:17:10 +00:00
|
|
|
|
&attributes, GDK_WA_X | GDK_WA_Y);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gdk_window_set_user_data (window, (GObject*) widget);
|
|
|
|
|
gtk_widget_set_window (widget, window); /* Passes ownership */
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 14:53:31 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
list_box_add_visible_rows (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
gint n)
|
2013-06-11 14:53:31 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-11 14:53:31 +00:00
|
|
|
|
int was_zero;
|
|
|
|
|
|
|
|
|
|
was_zero = priv->n_visible_rows == 0;
|
|
|
|
|
priv->n_visible_rows += n;
|
|
|
|
|
|
|
|
|
|
if (priv->placeholder &&
|
|
|
|
|
(was_zero || priv->n_visible_rows == 0))
|
|
|
|
|
gtk_widget_set_child_visible (GTK_WIDGET (priv->placeholder),
|
|
|
|
|
priv->n_visible_rows == 0);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 14:13:00 +00:00
|
|
|
|
/* Children are visible if they are shown by the app (visible)
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* and not filtered out (child_visible) by the listbox
|
|
|
|
|
*/
|
2013-06-11 14:13:00 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
update_row_is_visible (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-11 14:13:00 +00:00
|
|
|
|
{
|
2013-09-28 01:39:10 +00:00
|
|
|
|
GtkListBoxRowPrivate *row_priv = ROW_PRIV (row);
|
2013-06-11 14:20:45 +00:00
|
|
|
|
gboolean was_visible;
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
was_visible = row_priv->visible;
|
2013-06-11 14:20:45 +00:00
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
row_priv->visible =
|
2013-06-11 14:20:45 +00:00
|
|
|
|
gtk_widget_get_visible (GTK_WIDGET (row)) &&
|
|
|
|
|
gtk_widget_get_child_visible (GTK_WIDGET (row));
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (was_visible && !row_priv->visible)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
list_box_add_visible_rows (box, -1);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (!was_visible && row_priv->visible)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
list_box_add_visible_rows (box, 1);
|
2013-06-11 14:13:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_apply_filter (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gboolean do_show;
|
|
|
|
|
|
|
|
|
|
do_show = TRUE;
|
|
|
|
|
if (priv->filter_func != NULL)
|
|
|
|
|
do_show = priv->filter_func (row, priv->filter_func_target);
|
|
|
|
|
|
|
|
|
|
gtk_widget_set_child_visible (GTK_WIDGET (row), do_show);
|
2013-06-11 14:13:00 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
update_row_is_visible (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_apply_filter_all (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_apply_filter (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GtkListBoxRow *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_first_focusable (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
2013-09-15 20:31:12 +00:00
|
|
|
|
if (row_is_visible (row) && gtk_widget_is_sensitive (GTK_WIDGET (row)))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return row;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GtkListBoxRow *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_last_focusable (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
iter = g_sequence_get_end_iter (BOX_PRIV (box)->children);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
while (!g_sequence_iter_is_begin (iter))
|
|
|
|
|
{
|
|
|
|
|
iter = g_sequence_iter_prev (iter);
|
|
|
|
|
row = g_sequence_get (iter);
|
2013-09-15 20:31:12 +00:00
|
|
|
|
if (row_is_visible (row) && gtk_widget_is_sensitive (GTK_WIDGET (row)))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return row;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-15 16:13:28 +00:00
|
|
|
|
static GSequenceIter *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_previous_visible (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GSequenceIter *iter)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
|
|
|
|
if (g_sequence_iter_is_begin (iter))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
iter = g_sequence_iter_prev (iter);
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (row_is_visible (row))
|
|
|
|
|
return iter;
|
|
|
|
|
}
|
|
|
|
|
while (!g_sequence_iter_is_begin (iter));
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-15 16:13:28 +00:00
|
|
|
|
static GSequenceIter *
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_get_next_visible (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GSequenceIter *iter)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
|
|
|
|
if (g_sequence_iter_is_end (iter))
|
|
|
|
|
return iter;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
iter = g_sequence_iter_next (iter);
|
|
|
|
|
if (!g_sequence_iter_is_end (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (row_is_visible (row))
|
|
|
|
|
return iter;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
while (!g_sequence_iter_is_end (iter));
|
|
|
|
|
|
|
|
|
|
return iter;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-01 11:25:23 +00:00
|
|
|
|
static GSequenceIter *
|
|
|
|
|
gtk_list_box_get_last_visible (GtkListBox *box,
|
|
|
|
|
GSequenceIter *iter)
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *next = NULL;
|
|
|
|
|
|
|
|
|
|
if (g_sequence_iter_is_end (iter))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
next = gtk_list_box_get_next_visible (box, iter);
|
|
|
|
|
|
|
|
|
|
if (!g_sequence_iter_is_end (next))
|
|
|
|
|
iter = next;
|
|
|
|
|
}
|
|
|
|
|
while (!g_sequence_iter_is_end (next));
|
|
|
|
|
|
|
|
|
|
return iter;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_header (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GSequenceIter *iter)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *before_iter;
|
|
|
|
|
GtkListBoxRow *before_row;
|
2013-06-11 12:09:19 +00:00
|
|
|
|
GtkWidget *old_header;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (iter == NULL || g_sequence_iter_is_end (iter))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
row = g_sequence_get (iter);
|
2015-07-17 22:40:11 +00:00
|
|
|
|
g_object_ref (row);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
before_iter = gtk_list_box_get_previous_visible (box, iter);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
before_row = NULL;
|
|
|
|
|
if (before_iter != NULL)
|
|
|
|
|
{
|
|
|
|
|
before_row = g_sequence_get (before_iter);
|
|
|
|
|
if (before_row)
|
|
|
|
|
g_object_ref (before_row);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (priv->update_header_func != NULL &&
|
2013-06-10 09:17:10 +00:00
|
|
|
|
row_is_visible (row))
|
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
old_header = ROW_PRIV (row)->header;
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (old_header)
|
|
|
|
|
g_object_ref (old_header);
|
|
|
|
|
priv->update_header_func (row,
|
|
|
|
|
before_row,
|
|
|
|
|
priv->update_header_func_target);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (old_header != ROW_PRIV (row)->header)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2019-10-04 17:25:34 +00:00
|
|
|
|
if (old_header != NULL &&
|
|
|
|
|
g_hash_table_lookup (priv->header_hash, old_header) == row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2019-10-04 17:25:34 +00:00
|
|
|
|
/* Only unparent the @old_header if it hasn’t been re-used as the
|
|
|
|
|
* header for a different row. */
|
2013-06-11 12:09:19 +00:00
|
|
|
|
gtk_widget_unparent (old_header);
|
|
|
|
|
g_hash_table_remove (priv->header_hash, old_header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_hash_table_insert (priv->header_hash, ROW_PRIV (row)->header, row);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_set_parent (ROW_PRIV (row)->header, GTK_WIDGET (box));
|
2013-07-02 11:44:17 +00:00
|
|
|
|
gtk_widget_show (ROW_PRIV (row)->header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (old_header)
|
|
|
|
|
g_object_unref (old_header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_hash_table_remove (priv->header_hash, ROW_PRIV (row)->header);
|
|
|
|
|
gtk_widget_unparent (ROW_PRIV (row)->header);
|
2013-06-11 12:09:19 +00:00
|
|
|
|
gtk_list_box_row_set_header (row, NULL);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (before_row)
|
|
|
|
|
g_object_unref (before_row);
|
2015-07-17 22:40:11 +00:00
|
|
|
|
g_object_unref (row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_row_visibility_changed (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
update_row_is_visible (box, row);
|
2013-06-11 14:13:00 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (gtk_widget_get_visible (GTK_WIDGET (box)))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_header (box, ROW_PRIV (row)->iter);
|
|
|
|
|
gtk_list_box_update_header (box,
|
|
|
|
|
gtk_list_box_get_next_visible (box, ROW_PRIV (row)->iter));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 12:57:22 +00:00
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_add (GtkContainer *container,
|
|
|
|
|
GtkWidget *child)
|
2013-08-06 12:57:22 +00:00
|
|
|
|
{
|
2013-08-07 10:36:03 +00:00
|
|
|
|
gtk_list_box_insert (GTK_LIST_BOX (container), child, -1);
|
2013-08-06 12:57:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_remove (GtkContainer *container,
|
|
|
|
|
GtkWidget *child)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkWidget *widget = GTK_WIDGET (container);
|
|
|
|
|
GtkListBox *box = GTK_LIST_BOX (container);
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gboolean was_visible;
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gboolean was_selected;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *next;
|
|
|
|
|
|
|
|
|
|
was_visible = gtk_widget_get_visible (child);
|
|
|
|
|
|
|
|
|
|
if (!GTK_IS_LIST_BOX_ROW (child))
|
|
|
|
|
{
|
2013-06-11 12:09:19 +00:00
|
|
|
|
row = g_hash_table_lookup (priv->header_hash, child);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (row != NULL)
|
|
|
|
|
{
|
2013-06-11 12:09:19 +00:00
|
|
|
|
g_hash_table_remove (priv->header_hash, child);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_clear_object (&ROW_PRIV (row)->header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_widget_unparent (child);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (was_visible && gtk_widget_get_visible (widget))
|
|
|
|
|
gtk_widget_queue_resize (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-02-28 16:06:25 +00:00
|
|
|
|
g_warning ("Tried to remove non-child %p", child);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
row = GTK_LIST_BOX_ROW (child);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (g_sequence_iter_get_sequence (ROW_PRIV (row)->iter) != priv->children)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2016-02-28 16:06:25 +00:00
|
|
|
|
g_warning ("Tried to remove non-child %p", child);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
was_selected = ROW_PRIV (row)->selected;
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->visible)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
list_box_add_visible_rows (box, -1);
|
2013-06-11 14:20:45 +00:00
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_hash_table_remove (priv->header_hash, ROW_PRIV (row)->header);
|
|
|
|
|
gtk_widget_unparent (ROW_PRIV (row)->header);
|
|
|
|
|
g_clear_object (&ROW_PRIV (row)->header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (row == priv->selected_row)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
priv->selected_row = NULL;
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (row == priv->prelight_row)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (row), GTK_STATE_FLAG_PRELIGHT);
|
|
|
|
|
priv->prelight_row = NULL;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (row == priv->cursor_row)
|
|
|
|
|
priv->cursor_row = NULL;
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (row == priv->active_row)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_unset_state_flags (GTK_WIDGET (row), GTK_STATE_FLAG_ACTIVE);
|
|
|
|
|
priv->active_row = NULL;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-10 13:15:22 +00:00
|
|
|
|
if (row == priv->drag_highlighted_row)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_drag_unhighlight_row (box);
|
2013-06-10 13:15:22 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
next = gtk_list_box_get_next_visible (box, ROW_PRIV (row)->iter);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_widget_unparent (child);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
g_sequence_remove (ROW_PRIV (row)->iter);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (gtk_widget_get_visible (widget))
|
|
|
|
|
gtk_list_box_update_header (box, next);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (was_visible && gtk_widget_get_visible (GTK_WIDGET (box)))
|
|
|
|
|
gtk_widget_queue_resize (widget);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2016-12-18 08:43:38 +00:00
|
|
|
|
if (was_selected && !gtk_widget_in_destruction (widget))
|
2014-04-13 20:51:49 +00:00
|
|
|
|
{
|
|
|
|
|
g_signal_emit (box, signals[ROW_SELECTED], 0, NULL);
|
|
|
|
|
g_signal_emit (box, signals[SELECTED_ROWS_CHANGED], 0);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-16 22:11:50 +00:00
|
|
|
|
gtk_list_box_forall (GtkContainer *container,
|
|
|
|
|
gboolean include_internals,
|
|
|
|
|
GtkCallback callback,
|
|
|
|
|
gpointer callback_target)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (container);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
2017-05-11 19:01:05 +00:00
|
|
|
|
if (priv->placeholder != NULL && include_internals)
|
2013-06-11 14:53:31 +00:00
|
|
|
|
callback (priv->placeholder, callback_target);
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
iter = g_sequence_get_begin_iter (priv->children);
|
|
|
|
|
while (!g_sequence_iter_is_end (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter);
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL && include_internals)
|
|
|
|
|
callback (ROW_PRIV (row)->header, callback_target);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
callback (GTK_WIDGET (row), callback_target);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-16 22:11:50 +00:00
|
|
|
|
gtk_list_box_compute_expand (GtkWidget *widget,
|
|
|
|
|
gboolean *hexpand,
|
|
|
|
|
gboolean *vexpand)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_parent_class)->compute_expand (widget,
|
|
|
|
|
hexpand, vexpand);
|
|
|
|
|
|
|
|
|
|
/* We don't expand vertically beyound the minimum size */
|
|
|
|
|
if (vexpand)
|
|
|
|
|
*vexpand = FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GType
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_child_type (GtkContainer *container)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-06-15 16:13:28 +00:00
|
|
|
|
/* We really support any type but we wrap it in a row. But that is
|
|
|
|
|
* more like a C helper function, in an abstract sense we only support
|
|
|
|
|
* row children, so that is what tools accessing this should use.
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
return GTK_TYPE_LIST_BOX_ROW;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GtkSizeRequestMode
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_get_request_mode (GtkWidget *widget)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_get_preferred_height (GtkWidget *widget,
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (BOX_PRIV (widget)->gadget,
|
|
|
|
|
GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
-1,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_get_preferred_height_for_width (GtkWidget *widget,
|
|
|
|
|
gint width,
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (BOX_PRIV (widget)->gadget,
|
|
|
|
|
GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
width,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_get_preferred_width (GtkWidget *widget,
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (BOX_PRIV (widget)->gadget,
|
|
|
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
-1,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_get_preferred_width_for_height (GtkWidget *widget,
|
|
|
|
|
gint height,
|
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
|
|
|
|
{
|
|
|
|
|
gtk_css_gadget_get_preferred_size (BOX_PRIV (widget)->gadget,
|
|
|
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
height,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_measure (GtkCssGadget *gadget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
gint for_size,
|
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural,
|
|
|
|
|
gint *minimum_baseline,
|
|
|
|
|
gint *natural_baseline,
|
|
|
|
|
gpointer unused)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
if (orientation == GTK_ORIENTATION_HORIZONTAL)
|
|
|
|
|
{
|
|
|
|
|
*minimum = 0;
|
|
|
|
|
*natural = 0;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
if (priv->placeholder && gtk_widget_get_child_visible (priv->placeholder))
|
|
|
|
|
gtk_widget_get_preferred_width (priv->placeholder, minimum, natural);
|
2013-06-11 14:53:31 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (priv->children);
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
gint row_min;
|
|
|
|
|
gint row_nat;
|
2013-06-13 08:47:52 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
row = g_sequence_get (iter);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
/* We *do* take visible but filtered rows into account here so that
|
|
|
|
|
* the list width doesn't change during filtering
|
|
|
|
|
*/
|
|
|
|
|
if (!gtk_widget_get_visible (GTK_WIDGET (row)))
|
|
|
|
|
continue;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_widget_get_preferred_width (GTK_WIDGET (row), &row_min, &row_nat);
|
|
|
|
|
*minimum = MAX (*minimum, row_min);
|
|
|
|
|
*natural = MAX (*natural, row_nat);
|
|
|
|
|
|
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_get_preferred_width (ROW_PRIV (row)->header, &row_min, &row_nat);
|
|
|
|
|
*minimum = MAX (*minimum, row_min);
|
|
|
|
|
*natural = MAX (*natural, row_nat);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-12-12 04:48:34 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (for_size < 0)
|
|
|
|
|
gtk_css_gadget_get_preferred_size (priv->gadget,
|
|
|
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
-1,
|
|
|
|
|
NULL, &for_size,
|
|
|
|
|
NULL, NULL);
|
|
|
|
|
|
|
|
|
|
*minimum = 0;
|
|
|
|
|
|
|
|
|
|
if (priv->placeholder && gtk_widget_get_child_visible (priv->placeholder))
|
|
|
|
|
gtk_widget_get_preferred_height_for_width (priv->placeholder, for_size,
|
|
|
|
|
minimum, NULL);
|
|
|
|
|
|
|
|
|
|
for (iter = g_sequence_get_begin_iter (priv->children);
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
gint row_min = 0;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (!row_is_visible (row))
|
|
|
|
|
continue;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_get_preferred_height_for_width (ROW_PRIV (row)->header, for_size, &row_min, NULL);
|
|
|
|
|
*minimum += row_min;
|
|
|
|
|
}
|
|
|
|
|
gtk_widget_get_preferred_height_for_width (GTK_WIDGET (row), for_size, &row_min, NULL);
|
|
|
|
|
*minimum += row_min;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We always allocate the minimum height, since handling expanding rows
|
|
|
|
|
* is way too costly, and unlikely to be used, as lists are generally put
|
|
|
|
|
* inside a scrolling window anyway.
|
|
|
|
|
*/
|
|
|
|
|
*natural = *minimum;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_size_allocate (GtkWidget *widget,
|
|
|
|
|
GtkAllocation *allocation)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-12 04:48:34 +00:00
|
|
|
|
GtkAllocation clip;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GdkWindow *window;
|
2015-12-12 04:48:34 +00:00
|
|
|
|
GtkAllocation child_allocation;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_set_allocation (widget, allocation);
|
2015-12-12 04:48:34 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
window = gtk_widget_get_window (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (window != NULL)
|
|
|
|
|
gdk_window_move_resize (window,
|
|
|
|
|
allocation->x, allocation->y,
|
|
|
|
|
allocation->width, allocation->height);
|
|
|
|
|
|
|
|
|
|
child_allocation.x = 0;
|
|
|
|
|
child_allocation.y = 0;
|
|
|
|
|
child_allocation.width = allocation->width;
|
2015-12-12 04:48:34 +00:00
|
|
|
|
child_allocation.height = allocation->height;
|
|
|
|
|
|
|
|
|
|
gtk_css_gadget_allocate (BOX_PRIV (widget)->gadget,
|
|
|
|
|
&child_allocation,
|
|
|
|
|
gtk_widget_get_allocated_baseline (widget),
|
|
|
|
|
&clip);
|
|
|
|
|
|
|
|
|
|
_gtk_widget_set_simple_clip (widget, &clip);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_allocate (GtkCssGadget *gadget,
|
|
|
|
|
const GtkAllocation *allocation,
|
|
|
|
|
int baseline,
|
|
|
|
|
GtkAllocation *out_clip,
|
|
|
|
|
gpointer unused)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (widget);
|
|
|
|
|
GtkAllocation child_allocation;
|
|
|
|
|
GtkAllocation header_allocation;
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
int child_min;
|
|
|
|
|
|
|
|
|
|
child_allocation.x = allocation->x;
|
|
|
|
|
child_allocation.y = allocation->y;
|
|
|
|
|
child_allocation.width = allocation->width;
|
|
|
|
|
child_allocation.height = 0;
|
|
|
|
|
|
|
|
|
|
header_allocation.x = allocation->x;
|
|
|
|
|
header_allocation.y = allocation->y;
|
2013-06-11 12:09:19 +00:00
|
|
|
|
header_allocation.width = allocation->width;
|
2015-12-12 04:48:34 +00:00
|
|
|
|
header_allocation.height = 0;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-12 04:48:34 +00:00
|
|
|
|
if (priv->placeholder && gtk_widget_get_child_visible (priv->placeholder))
|
2013-06-11 14:53:31 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_get_preferred_height_for_width (priv->placeholder,
|
|
|
|
|
allocation->width, &child_min, NULL);
|
2013-11-01 11:30:07 +00:00
|
|
|
|
header_allocation.height = allocation->height;
|
2013-06-11 14:53:31 +00:00
|
|
|
|
header_allocation.y = child_allocation.y;
|
2015-12-12 04:48:34 +00:00
|
|
|
|
gtk_widget_size_allocate (priv->placeholder, &header_allocation);
|
2013-06-11 14:53:31 +00:00
|
|
|
|
child_allocation.y += child_min;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
for (iter = g_sequence_get_begin_iter (priv->children);
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
if (!row_is_visible (row))
|
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
ROW_PRIV (row)->y = child_allocation.y;
|
|
|
|
|
ROW_PRIV (row)->height = 0;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (ROW_PRIV (row)->header != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
gtk_widget_get_preferred_height_for_width (ROW_PRIV (row)->header,
|
2013-06-10 09:17:10 +00:00
|
|
|
|
allocation->width, &child_min, NULL);
|
2013-06-11 12:09:19 +00:00
|
|
|
|
header_allocation.height = child_min;
|
|
|
|
|
header_allocation.y = child_allocation.y;
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_widget_size_allocate (ROW_PRIV (row)->header, &header_allocation);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
child_allocation.y += child_min;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
ROW_PRIV (row)->y = child_allocation.y;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_widget_get_preferred_height_for_width (GTK_WIDGET (row),
|
|
|
|
|
child_allocation.width, &child_min, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
child_allocation.height = child_min;
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
ROW_PRIV (row)->height = child_allocation.height;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_widget_size_allocate (GTK_WIDGET (row), &child_allocation);
|
|
|
|
|
child_allocation.y += child_min;
|
|
|
|
|
}
|
2015-12-12 04:48:34 +00:00
|
|
|
|
|
|
|
|
|
gtk_container_get_children_clip (GTK_CONTAINER (widget), out_clip);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-08-06 12:57:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_prepend:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-08-06 12:57:22 +00:00
|
|
|
|
* @child: the #GtkWidget to add
|
|
|
|
|
*
|
|
|
|
|
* Prepend a widget to the list. If a sort function is set, the widget will
|
|
|
|
|
* actually be inserted at the calculated position and this function has the
|
|
|
|
|
* same effect of gtk_container_add().
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_prepend (GtkListBox *box,
|
2013-08-06 12:57:22 +00:00
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_insert (box, child, 0);
|
2013-08-06 12:57:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-30 03:03:11 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_insert_css_node (GtkListBox *box,
|
|
|
|
|
GtkWidget *child,
|
|
|
|
|
GSequenceIter *iter)
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *prev_iter;
|
2016-04-11 11:52:39 +00:00
|
|
|
|
GtkCssNode *sibling;
|
2015-05-30 03:03:11 +00:00
|
|
|
|
|
|
|
|
|
prev_iter = g_sequence_iter_prev (iter);
|
|
|
|
|
|
|
|
|
|
if (prev_iter != iter)
|
2016-04-11 11:52:39 +00:00
|
|
|
|
sibling = gtk_widget_get_css_node (g_sequence_get (prev_iter));
|
|
|
|
|
else
|
|
|
|
|
sibling = NULL;
|
|
|
|
|
|
|
|
|
|
gtk_css_node_insert_after (gtk_widget_get_css_node (GTK_WIDGET (box)),
|
|
|
|
|
gtk_widget_get_css_node (child),
|
|
|
|
|
sibling);
|
2015-05-30 03:03:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-08-08 06:06:27 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_insert:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-08-08 06:06:27 +00:00
|
|
|
|
* @child: the #GtkWidget to add
|
|
|
|
|
* @position: the position to insert @child in
|
|
|
|
|
*
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* Insert the @child into the @box at @position. If a sort function is
|
2013-08-08 06:06:27 +00:00
|
|
|
|
* set, the widget will actually be inserted at the calculated position and
|
|
|
|
|
* this function has the same effect of gtk_container_add().
|
|
|
|
|
*
|
|
|
|
|
* If @position is -1, or larger than the total number of items in the
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box, then the @child will be appended to the end.
|
2013-08-08 06:06:27 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_insert (GtkListBox *box,
|
2013-08-08 06:06:27 +00:00
|
|
|
|
GtkWidget *child,
|
|
|
|
|
gint position)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-08-08 06:06:27 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
GSequenceIter *iter = NULL;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-09-28 01:39:10 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
2013-08-08 06:06:27 +00:00
|
|
|
|
|
|
|
|
|
if (GTK_IS_LIST_BOX_ROW (child))
|
|
|
|
|
row = GTK_LIST_BOX_ROW (child);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
row = GTK_LIST_BOX_ROW (gtk_list_box_row_new ());
|
|
|
|
|
gtk_widget_show (GTK_WIDGET (row));
|
|
|
|
|
gtk_container_add (GTK_CONTAINER (row), child);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (priv->sort_func != NULL)
|
|
|
|
|
iter = g_sequence_insert_sorted (priv->children, row,
|
2014-03-29 03:07:41 +00:00
|
|
|
|
(GCompareDataFunc)do_sort, box);
|
2013-08-08 06:06:27 +00:00
|
|
|
|
else if (position == 0)
|
|
|
|
|
iter = g_sequence_prepend (priv->children, row);
|
|
|
|
|
else if (position == -1)
|
|
|
|
|
iter = g_sequence_append (priv->children, row);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *current_iter;
|
|
|
|
|
|
|
|
|
|
current_iter = g_sequence_get_iter_at_pos (priv->children, position);
|
|
|
|
|
iter = g_sequence_insert_before (current_iter, row);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-30 03:03:11 +00:00
|
|
|
|
gtk_list_box_insert_css_node (box, GTK_WIDGET (row), iter);
|
|
|
|
|
|
2013-08-08 06:06:27 +00:00
|
|
|
|
ROW_PRIV (row)->iter = iter;
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_widget_set_parent (GTK_WIDGET (row), GTK_WIDGET (box));
|
2013-08-08 06:06:27 +00:00
|
|
|
|
gtk_widget_set_child_visible (GTK_WIDGET (row), TRUE);
|
|
|
|
|
ROW_PRIV (row)->visible = gtk_widget_get_visible (GTK_WIDGET (row));
|
|
|
|
|
if (ROW_PRIV (row)->visible)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
list_box_add_visible_rows (box, 1);
|
|
|
|
|
gtk_list_box_apply_filter (box, row);
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gtk_list_box_update_row_style (box, row);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (gtk_widget_get_visible (GTK_WIDGET (box)))
|
2013-08-08 06:06:27 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_header (box, ROW_PRIV (row)->iter);
|
|
|
|
|
gtk_list_box_update_header (box,
|
|
|
|
|
gtk_list_box_get_next_visible (box, ROW_PRIV (row)->iter));
|
2013-08-08 06:06:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_drag_unhighlight_row:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* If a row has previously been highlighted via gtk_list_box_drag_highlight_row()
|
|
|
|
|
* it will have the highlight removed.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_drag_unhighlight_row (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->drag_highlighted_row == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
gtk_drag_unhighlight (GTK_WIDGET (priv->drag_highlighted_row));
|
|
|
|
|
g_clear_object (&priv->drag_highlighted_row);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_drag_highlight_row:
|
2014-03-29 03:07:41 +00:00
|
|
|
|
* @box: a #GtkListBox
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* This is a helper function for implementing DnD onto a #GtkListBox.
|
|
|
|
|
* The passed in @row will be highlighted via gtk_drag_highlight(),
|
|
|
|
|
* and any previously highlighted row will be unhighlighted.
|
|
|
|
|
*
|
|
|
|
|
* The row will also be unhighlighted when the widget gets
|
|
|
|
|
* a drag leave event.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-15 16:13:28 +00:00
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_drag_highlight_row (GtkListBox *box,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
2013-09-28 01:39:10 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->drag_highlighted_row == row)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_drag_unhighlight_row (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
gtk_drag_highlight (GTK_WIDGET (row));
|
|
|
|
|
priv->drag_highlighted_row = g_object_ref (row);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 02:00:38 +00:00
|
|
|
|
gtk_list_box_drag_leave (GtkWidget *widget,
|
|
|
|
|
GdkDragContext *context,
|
|
|
|
|
guint time_)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_drag_unhighlight_row (GTK_LIST_BOX (widget));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_activate_cursor_row (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_and_activate (box, BOX_PRIV (box)->cursor_row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_toggle_cursor_row (GtkListBox *box)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (priv->cursor_row == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if ((priv->selection_mode == GTK_SELECTION_SINGLE ||
|
|
|
|
|
priv->selection_mode == GTK_SELECTION_MULTIPLE) &&
|
|
|
|
|
ROW_PRIV (priv->cursor_row)->selected)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_unselect_row_internal (box, priv->cursor_row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
else
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_select_and_activate (box, priv->cursor_row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_move_cursor (GtkListBox *box,
|
2013-09-28 02:00:38 +00:00
|
|
|
|
GtkMovementStep step,
|
|
|
|
|
gint count)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gboolean modify;
|
|
|
|
|
gboolean extend;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
gint page_size;
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
gint start_y;
|
|
|
|
|
gint end_y;
|
2016-04-19 15:12:00 +00:00
|
|
|
|
int height;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
row = NULL;
|
|
|
|
|
switch (step)
|
|
|
|
|
{
|
|
|
|
|
case GTK_MOVEMENT_BUFFER_ENDS:
|
|
|
|
|
if (count < 0)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
row = gtk_list_box_get_first_focusable (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
else
|
2014-03-29 03:07:41 +00:00
|
|
|
|
row = gtk_list_box_get_last_focusable (box);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
break;
|
|
|
|
|
case GTK_MOVEMENT_DISPLAY_LINES:
|
|
|
|
|
if (priv->cursor_row != NULL)
|
|
|
|
|
{
|
2014-07-13 16:31:28 +00:00
|
|
|
|
gint i = count;
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
iter = ROW_PRIV (priv->cursor_row)->iter;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-10-08 21:56:19 +00:00
|
|
|
|
while (i < 0 && iter != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
iter = gtk_list_box_get_previous_visible (box, iter);
|
2013-10-08 21:56:19 +00:00
|
|
|
|
i = i + 1;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2013-10-08 21:56:19 +00:00
|
|
|
|
while (i > 0 && iter != NULL)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
iter = gtk_list_box_get_next_visible (box, iter);
|
2013-10-08 21:56:19 +00:00
|
|
|
|
i = i - 1;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (iter != NULL && !g_sequence_iter_is_end (iter))
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GTK_MOVEMENT_PAGES:
|
|
|
|
|
page_size = 100;
|
|
|
|
|
if (priv->adjustment != NULL)
|
|
|
|
|
page_size = gtk_adjustment_get_page_increment (priv->adjustment);
|
|
|
|
|
|
|
|
|
|
if (priv->cursor_row != NULL)
|
|
|
|
|
{
|
2013-07-02 11:44:17 +00:00
|
|
|
|
start_y = ROW_PRIV (priv->cursor_row)->y;
|
2016-04-19 15:12:00 +00:00
|
|
|
|
height = gtk_widget_get_allocated_height (GTK_WIDGET (box));
|
|
|
|
|
end_y = CLAMP (start_y + page_size * count, 0, height - 1);
|
|
|
|
|
row = gtk_list_box_get_row_at_y (box, end_y);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-09-01 11:25:23 +00:00
|
|
|
|
if (!row)
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *cursor_iter;
|
|
|
|
|
GSequenceIter *next_iter;
|
|
|
|
|
|
2017-12-15 23:46:21 +00:00
|
|
|
|
if (count > 0)
|
|
|
|
|
{
|
|
|
|
|
cursor_iter = ROW_PRIV (priv->cursor_row)->iter;
|
|
|
|
|
next_iter = gtk_list_box_get_last_visible (box, cursor_iter);
|
|
|
|
|
|
|
|
|
|
if (next_iter)
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (next_iter);
|
|
|
|
|
end_y = ROW_PRIV (row)->y;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
2016-09-01 11:25:23 +00:00
|
|
|
|
{
|
2017-12-15 23:46:21 +00:00
|
|
|
|
row = gtk_list_box_get_row_at_index (box, 0);
|
2016-09-01 11:25:23 +00:00
|
|
|
|
end_y = ROW_PRIV (row)->y;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (row == priv->cursor_row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2016-09-01 11:23:14 +00:00
|
|
|
|
iter = ROW_PRIV (row)->iter;
|
|
|
|
|
|
2016-04-19 15:12:00 +00:00
|
|
|
|
/* Move at least one row. This is important when the cursor_row's height is
|
|
|
|
|
* greater than page_size */
|
|
|
|
|
if (count < 0)
|
|
|
|
|
iter = g_sequence_iter_prev (iter);
|
|
|
|
|
else
|
|
|
|
|
iter = g_sequence_iter_next (iter);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2016-04-19 15:12:00 +00:00
|
|
|
|
if (!g_sequence_iter_is_begin (iter) && !g_sequence_iter_is_end (iter))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2016-04-19 15:12:00 +00:00
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
end_y = ROW_PRIV (row)->y;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-04-19 15:12:00 +00:00
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
if (end_y != start_y && priv->adjustment != NULL)
|
2016-04-19 15:12:00 +00:00
|
|
|
|
gtk_adjustment_animate_to_value (priv->adjustment, end_y);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (row == NULL || row == priv->cursor_row)
|
|
|
|
|
{
|
|
|
|
|
GtkDirectionType direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (!gtk_widget_keynav_failed (GTK_WIDGET (box), direction))
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (box));
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
if (toplevel)
|
|
|
|
|
gtk_widget_child_focus (toplevel,
|
|
|
|
|
direction == GTK_DIR_UP ?
|
|
|
|
|
GTK_DIR_TAB_BACKWARD :
|
|
|
|
|
GTK_DIR_TAB_FORWARD);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
get_current_selection_modifiers (GTK_WIDGET (box), &modify, &extend);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
|
2015-02-10 19:02:08 +00:00
|
|
|
|
gtk_list_box_update_cursor (box, row, TRUE);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (!modify)
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_selection (box, row, FALSE, extend);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_new:
|
|
|
|
|
*
|
|
|
|
|
* Creates a new #GtkListBoxRow, to be used as a child of a #GtkListBox.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
GtkWidget *
|
|
|
|
|
gtk_list_box_row_new (void)
|
|
|
|
|
{
|
|
|
|
|
return g_object_new (GTK_TYPE_LIST_BOX_ROW, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_set_focus (GtkListBoxRow *row)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box = gtk_list_box_row_get_box (row);
|
2014-03-29 01:34:39 +00:00
|
|
|
|
gboolean modify;
|
|
|
|
|
gboolean extend;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
if (!box)
|
2013-10-03 12:00:30 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
get_current_selection_modifiers (GTK_WIDGET (row), &modify, &extend);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2014-03-29 01:34:39 +00:00
|
|
|
|
if (modify)
|
2015-02-10 19:02:08 +00:00
|
|
|
|
gtk_list_box_update_cursor (box, row, TRUE);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
else
|
2014-03-29 03:07:41 +00:00
|
|
|
|
gtk_list_box_update_selection (box, row, FALSE, FALSE);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_focus (GtkWidget *widget,
|
|
|
|
|
GtkDirectionType direction)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (widget);
|
|
|
|
|
gboolean had_focus = FALSE;
|
|
|
|
|
GtkWidget *child;
|
|
|
|
|
|
|
|
|
|
child = gtk_bin_get_child (GTK_BIN (widget));
|
|
|
|
|
|
|
|
|
|
g_object_get (widget, "has-focus", &had_focus, NULL);
|
|
|
|
|
if (had_focus)
|
|
|
|
|
{
|
|
|
|
|
/* If on row, going right, enter into possible container */
|
|
|
|
|
if (child &&
|
|
|
|
|
(direction == GTK_DIR_RIGHT || direction == GTK_DIR_TAB_FORWARD))
|
|
|
|
|
{
|
|
|
|
|
if (gtk_widget_child_focus (GTK_WIDGET (child), direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
else if (gtk_container_get_focus_child (GTK_CONTAINER (row)) != NULL)
|
|
|
|
|
{
|
|
|
|
|
/* Child has focus, always navigate inside it first */
|
|
|
|
|
if (gtk_widget_child_focus (child, direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
/* If exiting child container to the left, select row */
|
|
|
|
|
if (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD)
|
|
|
|
|
{
|
|
|
|
|
gtk_list_box_row_set_focus (row);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* If coming from the left, enter into possible container */
|
|
|
|
|
if (child &&
|
|
|
|
|
(direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD))
|
|
|
|
|
{
|
|
|
|
|
if (gtk_widget_child_focus (child, direction))
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gtk_list_box_row_set_focus (row);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-10 12:12:07 +00:00
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_activate (GtkListBoxRow *row)
|
2013-09-10 12:12:07 +00:00
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box;
|
2013-09-10 12:12:07 +00:00
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
box = gtk_list_box_row_get_box (row);
|
|
|
|
|
if (box)
|
|
|
|
|
gtk_list_box_select_and_activate (box, row);
|
2013-09-10 12:12:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_show (GtkWidget *widget)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (widget);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_row_parent_class)->show (widget);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
box = gtk_list_box_row_get_box (row);
|
|
|
|
|
if (box)
|
|
|
|
|
gtk_list_box_row_visibility_changed (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_hide (GtkWidget *widget)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (widget);
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_row_parent_class)->hide (widget);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
box = gtk_list_box_row_get_box (row);
|
|
|
|
|
if (box)
|
|
|
|
|
gtk_list_box_row_visibility_changed (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_draw (GtkWidget *widget,
|
|
|
|
|
cairo_t *cr)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_draw (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget, cr);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
return GDK_EVENT_PROPAGATE;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_list_box_row_render (GtkCssGadget *gadget,
|
|
|
|
|
cairo_t *cr,
|
|
|
|
|
int x,
|
|
|
|
|
int y,
|
|
|
|
|
int width,
|
|
|
|
|
int height,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget;
|
2015-11-14 14:51:37 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
widget = gtk_css_gadget_get_owner (gadget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_row_parent_class)->draw (widget, cr);
|
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
return gtk_widget_has_visible_focus (widget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_list_box_row_measure (GtkCssGadget *gadget,
|
|
|
|
|
GtkOrientation orientation,
|
|
|
|
|
int for_size,
|
|
|
|
|
int *minimum,
|
|
|
|
|
int *natural,
|
|
|
|
|
int *minimum_baseline,
|
|
|
|
|
int *natural_baseline,
|
|
|
|
|
gpointer data)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
GtkWidget *child;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
widget = gtk_css_gadget_get_owner (gadget);
|
|
|
|
|
child = gtk_bin_get_child (GTK_BIN (widget));
|
2014-05-04 18:42:04 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
if (orientation == GTK_ORIENTATION_VERTICAL)
|
|
|
|
|
{
|
|
|
|
|
if (child && gtk_widget_get_visible (child))
|
|
|
|
|
{
|
|
|
|
|
if (for_size < 0)
|
|
|
|
|
gtk_widget_get_preferred_height (child, minimum, natural);
|
|
|
|
|
else
|
|
|
|
|
gtk_widget_get_preferred_height_for_width (child, for_size, minimum, natural);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*minimum = *natural = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (child && gtk_widget_get_visible (child))
|
|
|
|
|
gtk_widget_get_preferred_width (child, minimum, natural);
|
|
|
|
|
else
|
|
|
|
|
*minimum = *natural = 0;
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_get_preferred_height (GtkWidget *widget,
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget,
|
|
|
|
|
GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
-1,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_get_preferred_height_for_width (GtkWidget *widget,
|
|
|
|
|
gint width,
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget,
|
|
|
|
|
GTK_ORIENTATION_VERTICAL,
|
|
|
|
|
width,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_get_preferred_width (GtkWidget *widget,
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget,
|
|
|
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
-1,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_get_preferred_width_for_height (GtkWidget *widget,
|
|
|
|
|
gint height,
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gint *minimum,
|
|
|
|
|
gint *natural)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_get_preferred_size (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget,
|
|
|
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
|
|
|
height,
|
|
|
|
|
minimum, natural,
|
|
|
|
|
NULL, NULL);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2013-09-28 01:39:10 +00:00
|
|
|
|
gtk_list_box_row_size_allocate (GtkWidget *widget,
|
|
|
|
|
GtkAllocation *allocation)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2015-12-10 05:43:58 +00:00
|
|
|
|
GtkAllocation clip;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_set_allocation (widget, allocation);
|
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_css_gadget_allocate (ROW_PRIV (GTK_LIST_BOX_ROW (widget))->gadget,
|
|
|
|
|
allocation,
|
|
|
|
|
gtk_widget_get_allocated_baseline (widget),
|
|
|
|
|
&clip);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
gtk_widget_set_clip (widget, &clip);
|
|
|
|
|
}
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_allocate (GtkCssGadget *gadget,
|
|
|
|
|
const GtkAllocation *allocation,
|
|
|
|
|
int baseline,
|
|
|
|
|
GtkAllocation *out_clip,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
GtkWidget *child;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
widget = gtk_css_gadget_get_owner (gadget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
child = gtk_bin_get_child (GTK_BIN (widget));
|
|
|
|
|
if (child && gtk_widget_get_visible (child))
|
|
|
|
|
gtk_widget_size_allocate (child, (GtkAllocation *)allocation);
|
2014-08-13 09:32:47 +00:00
|
|
|
|
|
2015-12-15 19:12:30 +00:00
|
|
|
|
gtk_container_get_children_clip (GTK_CONTAINER (widget), out_clip);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 10:59:32 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_changed:
|
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Marks @row as changed, causing any state that depends on this
|
2013-06-24 13:58:10 +00:00
|
|
|
|
* to be updated. This affects sorting, filtering and headers.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Note that calls to this method must be in sync with the data
|
|
|
|
|
* used for the row functions. For instance, if the list is
|
|
|
|
|
* mirroring some external data set, and *two* rows changed in the
|
|
|
|
|
* external data set then when you call gtk_list_box_row_changed()
|
|
|
|
|
* on the first row the sort function must only read the new data
|
|
|
|
|
* for the first of the two changed rows, otherwise the resorting
|
|
|
|
|
* of the rows will be wrong.
|
|
|
|
|
*
|
2014-02-07 18:32:47 +00:00
|
|
|
|
* This generally means that if you don’t fully control the data
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* model you have to duplicate the data that affects the listbox
|
|
|
|
|
* row functions into the row widgets themselves. Another alternative
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* is to call gtk_list_box_invalidate_sort() on any model change,
|
|
|
|
|
* but that is more expensive.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-06-10 09:17:10 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_list_box_row_changed (GtkListBoxRow *row)
|
|
|
|
|
{
|
2014-03-29 03:07:41 +00:00
|
|
|
|
GtkListBox *box;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-07-04 13:50:09 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
box = gtk_list_box_row_get_box (row);
|
|
|
|
|
if (box)
|
|
|
|
|
gtk_list_box_got_row_changed (box, row);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* gtk_list_box_row_get_header:
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* Returns the current header of the @row. This can be used
|
2013-06-24 13:58:10 +00:00
|
|
|
|
* in a #GtkListBoxUpdateHeaderFunc to see if there is a header
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* set already, and if so to update the state of it.
|
|
|
|
|
*
|
2015-12-01 12:40:46 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): the current header, or %NULL if none
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
GtkWidget *
|
2013-06-11 12:09:19 +00:00
|
|
|
|
gtk_list_box_row_get_header (GtkListBoxRow *row)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-07-04 13:50:09 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX_ROW (row), NULL);
|
|
|
|
|
|
2013-09-28 01:39:10 +00:00
|
|
|
|
return ROW_PRIV (row)->header;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* gtk_list_box_row_set_header:
|
2013-06-11 10:59:32 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
2013-06-15 16:13:28 +00:00
|
|
|
|
* @header: (allow-none): the header, or %NULL
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* Sets the current header of the @row. This is only allowed to be called
|
2013-06-24 13:58:10 +00:00
|
|
|
|
* from a #GtkListBoxUpdateHeaderFunc. It will replace any existing
|
2013-06-11 12:09:19 +00:00
|
|
|
|
* header in the row, and be shown in front of the row in the listbox.
|
2013-06-11 10:59:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
2013-06-10 09:17:10 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
2013-06-11 12:09:19 +00:00
|
|
|
|
gtk_list_box_row_set_header (GtkListBoxRow *row,
|
2013-06-15 16:13:28 +00:00
|
|
|
|
GtkWidget *header)
|
2013-06-10 09:17:10 +00:00
|
|
|
|
{
|
2013-09-28 01:39:10 +00:00
|
|
|
|
GtkListBoxRowPrivate *priv;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-07-04 13:50:09 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
g_return_if_fail (header == NULL || GTK_IS_WIDGET (header));
|
|
|
|
|
|
2013-09-28 01:39:10 +00:00
|
|
|
|
priv = ROW_PRIV (row);
|
|
|
|
|
|
2013-07-02 11:44:17 +00:00
|
|
|
|
if (priv->header)
|
|
|
|
|
g_object_unref (priv->header);
|
|
|
|
|
|
|
|
|
|
priv->header = header;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-06-11 12:09:19 +00:00
|
|
|
|
if (header)
|
2013-09-04 19:00:23 +00:00
|
|
|
|
g_object_ref_sink (header);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-07-04 11:40:21 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_get_index:
|
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Gets the current index of the @row in its #GtkListBox container.
|
|
|
|
|
*
|
|
|
|
|
* Returns: the index of the @row, or -1 if the @row is not in a listbox
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
|
|
|
|
gint
|
|
|
|
|
gtk_list_box_row_get_index (GtkListBoxRow *row)
|
|
|
|
|
{
|
2013-09-28 01:39:10 +00:00
|
|
|
|
GtkListBoxRowPrivate *priv;
|
2013-07-04 11:40:21 +00:00
|
|
|
|
|
2013-07-04 13:50:09 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX_ROW (row), -1);
|
|
|
|
|
|
2013-09-28 01:39:10 +00:00
|
|
|
|
priv = ROW_PRIV (row);
|
|
|
|
|
|
2013-07-04 11:40:21 +00:00
|
|
|
|
if (priv->iter != NULL)
|
|
|
|
|
return g_sequence_iter_get_position (priv->iter);
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-28 23:21:57 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_is_selected:
|
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Returns whether the child is currently selected in its
|
|
|
|
|
* #GtkListBox container.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if @row is selected
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_list_box_row_is_selected (GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX_ROW (row), FALSE);
|
|
|
|
|
|
2014-03-29 03:07:41 +00:00
|
|
|
|
return ROW_PRIV (row)->selected;
|
2014-03-28 23:21:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-16 02:42:29 +00:00
|
|
|
|
static void
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gtk_list_box_update_row_style (GtkListBox *box,
|
|
|
|
|
GtkListBoxRow *row)
|
2014-07-16 02:42:29 +00:00
|
|
|
|
{
|
|
|
|
|
GtkStyleContext *context;
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gboolean can_select;
|
|
|
|
|
|
|
|
|
|
if (box && BOX_PRIV (box)->selection_mode != GTK_SELECTION_NONE)
|
|
|
|
|
can_select = TRUE;
|
|
|
|
|
else
|
|
|
|
|
can_select = FALSE;
|
2014-07-16 02:42:29 +00:00
|
|
|
|
|
|
|
|
|
context = gtk_widget_get_style_context (GTK_WIDGET (row));
|
2014-07-16 03:13:43 +00:00
|
|
|
|
if (ROW_PRIV (row)->activatable ||
|
|
|
|
|
(ROW_PRIV (row)->selectable && can_select))
|
2015-08-25 00:08:29 +00:00
|
|
|
|
gtk_style_context_add_class (context, "activatable");
|
2014-07-16 02:42:29 +00:00
|
|
|
|
else
|
2015-08-25 00:08:29 +00:00
|
|
|
|
gtk_style_context_remove_class (context, "activatable");
|
2014-07-16 02:42:29 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-16 03:13:43 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_update_row_styles (GtkListBox *box)
|
|
|
|
|
{
|
|
|
|
|
GSequenceIter *iter;
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
|
|
|
|
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
|
|
|
|
|
!g_sequence_iter_is_end (iter);
|
|
|
|
|
iter = g_sequence_iter_next (iter))
|
|
|
|
|
{
|
|
|
|
|
row = g_sequence_get (iter);
|
|
|
|
|
gtk_list_box_update_row_style (box, row);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_set_activatable:
|
2015-02-18 10:57:05 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
2014-07-16 03:18:27 +00:00
|
|
|
|
* @activatable: %TRUE to mark the row as activatable
|
2014-07-13 00:37:41 +00:00
|
|
|
|
*
|
|
|
|
|
* Set the #GtkListBoxRow:activatable property for this row.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_list_box_row_set_activatable (GtkListBoxRow *row,
|
|
|
|
|
gboolean activatable)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
|
|
|
|
|
activatable = activatable != FALSE;
|
|
|
|
|
|
2014-07-16 02:42:29 +00:00
|
|
|
|
if (ROW_PRIV (row)->activatable != activatable)
|
|
|
|
|
{
|
|
|
|
|
ROW_PRIV (row)->activatable = activatable;
|
2014-07-13 00:37:41 +00:00
|
|
|
|
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gtk_list_box_update_row_style (gtk_list_box_row_get_box (row), row);
|
2015-09-06 14:39:57 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (row), row_properties[ROW_PROP_ACTIVATABLE]);
|
2014-07-16 02:42:29 +00:00
|
|
|
|
}
|
2014-07-13 00:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_get_activatable:
|
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Gets the value of the #GtkListBoxRow:activatable property
|
|
|
|
|
* for this row.
|
|
|
|
|
*
|
2014-07-16 03:18:27 +00:00
|
|
|
|
* Returns: %TRUE if the row is activatable
|
2014-07-13 00:37:41 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_list_box_row_get_activatable (GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX_ROW (row), TRUE);
|
|
|
|
|
|
2014-07-16 02:42:29 +00:00
|
|
|
|
return ROW_PRIV (row)->activatable;
|
2014-07-13 00:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-07-16 03:10:51 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_set_selectable:
|
2016-02-08 21:49:01 +00:00
|
|
|
|
* @row: a #GtkListBoxRow
|
2014-07-16 03:10:51 +00:00
|
|
|
|
* @selectable: %TRUE to mark the row as selectable
|
|
|
|
|
*
|
|
|
|
|
* Set the #GtkListBoxRow:selectable property for this row.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_list_box_row_set_selectable (GtkListBoxRow *row,
|
|
|
|
|
gboolean selectable)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX_ROW (row));
|
|
|
|
|
|
|
|
|
|
selectable = selectable != FALSE;
|
|
|
|
|
|
|
|
|
|
if (ROW_PRIV (row)->selectable != selectable)
|
|
|
|
|
{
|
|
|
|
|
if (!selectable)
|
|
|
|
|
gtk_list_box_row_set_selected (row, FALSE);
|
|
|
|
|
|
|
|
|
|
ROW_PRIV (row)->selectable = selectable;
|
|
|
|
|
|
2014-07-16 03:13:43 +00:00
|
|
|
|
gtk_list_box_update_row_style (gtk_list_box_row_get_box (row), row);
|
2015-09-06 14:39:57 +00:00
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (row), row_properties[ROW_PROP_SELECTABLE]);
|
2014-07-16 03:10:51 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_row_get_selectable:
|
|
|
|
|
* @row: a #GtkListBoxRow
|
|
|
|
|
*
|
|
|
|
|
* Gets the value of the #GtkListBoxRow:selectable property
|
|
|
|
|
* for this row.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the row is selectable
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_list_box_row_get_selectable (GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_LIST_BOX_ROW (row), TRUE);
|
|
|
|
|
|
|
|
|
|
return ROW_PRIV (row)->selectable;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_set_action_name (GtkActionable *actionable,
|
|
|
|
|
const gchar *action_name)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (actionable);
|
|
|
|
|
GtkListBoxRowPrivate *priv = ROW_PRIV (row);
|
|
|
|
|
|
|
|
|
|
if (!priv->action_helper)
|
|
|
|
|
priv->action_helper = gtk_action_helper_new (actionable);
|
|
|
|
|
|
|
|
|
|
gtk_action_helper_set_action_name (priv->action_helper, action_name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_set_action_target_value (GtkActionable *actionable,
|
|
|
|
|
GVariant *action_target)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (actionable);
|
|
|
|
|
GtkListBoxRowPrivate *priv = ROW_PRIV (row);
|
|
|
|
|
|
|
|
|
|
if (!priv->action_helper)
|
|
|
|
|
priv->action_helper = gtk_action_helper_new (actionable);
|
|
|
|
|
|
|
|
|
|
gtk_action_helper_set_action_target_value (priv->action_helper, action_target);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_get_property (GObject *obj,
|
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (obj);
|
|
|
|
|
|
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
|
|
|
|
case ROW_PROP_ACTIVATABLE:
|
|
|
|
|
g_value_set_boolean (value, gtk_list_box_row_get_activatable (row));
|
|
|
|
|
break;
|
2014-07-16 03:10:51 +00:00
|
|
|
|
case ROW_PROP_SELECTABLE:
|
|
|
|
|
g_value_set_boolean (value, gtk_list_box_row_get_selectable (row));
|
|
|
|
|
break;
|
2017-11-24 13:33:42 +00:00
|
|
|
|
case ROW_PROP_ACTION_NAME:
|
|
|
|
|
g_value_set_string (value, gtk_action_helper_get_action_name (ROW_PRIV (row)->action_helper));
|
|
|
|
|
break;
|
|
|
|
|
case ROW_PROP_ACTION_TARGET:
|
|
|
|
|
g_value_set_variant (value, gtk_action_helper_get_action_target_value (ROW_PRIV (row)->action_helper));
|
|
|
|
|
break;
|
2014-07-13 00:37:41 +00:00
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_set_property (GObject *obj,
|
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (obj);
|
|
|
|
|
|
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
|
|
|
|
case ROW_PROP_ACTIVATABLE:
|
|
|
|
|
gtk_list_box_row_set_activatable (row, g_value_get_boolean (value));
|
|
|
|
|
break;
|
2014-07-16 03:10:51 +00:00
|
|
|
|
case ROW_PROP_SELECTABLE:
|
|
|
|
|
gtk_list_box_row_set_selectable (row, g_value_get_boolean (value));
|
|
|
|
|
break;
|
2017-11-24 13:33:42 +00:00
|
|
|
|
case ROW_PROP_ACTION_NAME:
|
|
|
|
|
gtk_list_box_row_set_action_name (GTK_ACTIONABLE (row), g_value_get_string (value));
|
|
|
|
|
break;
|
|
|
|
|
case ROW_PROP_ACTION_TARGET:
|
|
|
|
|
gtk_list_box_row_set_action_target_value (GTK_ACTIONABLE (row), g_value_get_variant (value));
|
|
|
|
|
break;
|
2014-07-13 00:37:41 +00:00
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
static const gchar *
|
|
|
|
|
gtk_list_box_row_get_action_name (GtkActionable *actionable)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (actionable);
|
|
|
|
|
|
|
|
|
|
return gtk_action_helper_get_action_name (ROW_PRIV (row)->action_helper);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GVariant *
|
|
|
|
|
gtk_list_box_row_get_action_target_value (GtkActionable *actionable)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (actionable);
|
|
|
|
|
|
|
|
|
|
return gtk_action_helper_get_action_target_value (ROW_PRIV (row)->action_helper);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_actionable_iface_init (GtkActionableInterface *iface)
|
|
|
|
|
{
|
|
|
|
|
iface->get_action_name = gtk_list_box_row_get_action_name;
|
|
|
|
|
iface->set_action_name = gtk_list_box_row_set_action_name;
|
|
|
|
|
iface->get_action_target_value = gtk_list_box_row_get_action_target_value;
|
|
|
|
|
iface->set_action_target_value = gtk_list_box_row_set_action_target_value;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_finalize (GObject *obj)
|
|
|
|
|
{
|
2013-09-28 01:39:10 +00:00
|
|
|
|
g_clear_object (&ROW_PRIV (GTK_LIST_BOX_ROW (obj))->header);
|
2015-12-10 05:43:58 +00:00
|
|
|
|
g_clear_object (&ROW_PRIV (GTK_LIST_BOX_ROW (obj))->gadget);
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_list_box_row_parent_class)->finalize (obj);
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_dispose (GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (object);
|
|
|
|
|
GtkListBoxRowPrivate *priv = ROW_PRIV (row);
|
|
|
|
|
|
|
|
|
|
g_clear_object (&priv->action_helper);
|
|
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_list_box_row_parent_class)->dispose (object);
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-10 19:02:08 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_grab_focus (GtkWidget *widget)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row = GTK_LIST_BOX_ROW (widget);
|
|
|
|
|
GtkListBox *box = gtk_list_box_row_get_box (row);
|
|
|
|
|
|
2015-02-26 01:15:18 +00:00
|
|
|
|
g_return_if_fail (box != NULL);
|
|
|
|
|
|
2015-02-10 19:02:08 +00:00
|
|
|
|
if (BOX_PRIV (box)->cursor_row != row)
|
|
|
|
|
gtk_list_box_update_cursor (box, row, FALSE);
|
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_list_box_row_parent_class)->grab_focus (widget);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 09:17:10 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_class_init (GtkListBoxRowClass *klass)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
|
|
2013-09-22 00:49:18 +00:00
|
|
|
|
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE);
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
object_class->get_property = gtk_list_box_row_get_property;
|
|
|
|
|
object_class->set_property = gtk_list_box_row_set_property;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
object_class->finalize = gtk_list_box_row_finalize;
|
2017-11-24 13:33:42 +00:00
|
|
|
|
object_class->dispose = gtk_list_box_row_dispose;
|
2013-06-10 09:17:10 +00:00
|
|
|
|
|
2013-09-28 01:39:10 +00:00
|
|
|
|
widget_class->show = gtk_list_box_row_show;
|
|
|
|
|
widget_class->hide = gtk_list_box_row_hide;
|
|
|
|
|
widget_class->draw = gtk_list_box_row_draw;
|
|
|
|
|
widget_class->get_preferred_height = gtk_list_box_row_get_preferred_height;
|
|
|
|
|
widget_class->get_preferred_height_for_width = gtk_list_box_row_get_preferred_height_for_width;
|
|
|
|
|
widget_class->get_preferred_width = gtk_list_box_row_get_preferred_width;
|
|
|
|
|
widget_class->get_preferred_width_for_height = gtk_list_box_row_get_preferred_width_for_height;
|
|
|
|
|
widget_class->size_allocate = gtk_list_box_row_size_allocate;
|
|
|
|
|
widget_class->focus = gtk_list_box_row_focus;
|
2015-02-10 19:02:08 +00:00
|
|
|
|
widget_class->grab_focus = gtk_list_box_row_grab_focus;
|
2013-09-28 01:39:10 +00:00
|
|
|
|
|
|
|
|
|
klass->activate = gtk_list_box_row_activate;
|
2013-09-10 12:12:07 +00:00
|
|
|
|
|
2018-03-12 16:08:29 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkListBoxRow::activate:
|
|
|
|
|
*
|
|
|
|
|
* This is a keybinding signal, which will cause this row to be activated.
|
|
|
|
|
*
|
|
|
|
|
* If you want to be notified when the user activates a row (by key or not),
|
|
|
|
|
* use the #GtkListBox::row-activated signal on the row’s parent #GtkListBox.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.10
|
|
|
|
|
*/
|
2013-09-10 12:12:07 +00:00
|
|
|
|
row_signals[ROW__ACTIVATE] =
|
|
|
|
|
g_signal_new (I_("activate"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkListBoxRowClass, activate),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2013-09-10 12:12:07 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
2014-07-13 00:37:41 +00:00
|
|
|
|
|
2013-09-10 12:12:07 +00:00
|
|
|
|
widget_class->activate_signal = row_signals[ROW__ACTIVATE];
|
2014-07-13 00:37:41 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkListBoxRow:activatable:
|
|
|
|
|
*
|
|
|
|
|
* The property determines whether the #GtkListBox::row-activated
|
|
|
|
|
* signal will be emitted for this row.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
row_properties[ROW_PROP_ACTIVATABLE] =
|
|
|
|
|
g_param_spec_boolean ("activatable",
|
|
|
|
|
P_("Activatable"),
|
|
|
|
|
P_("Whether this row can be activated"),
|
|
|
|
|
TRUE,
|
|
|
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
|
|
2014-07-16 03:10:51 +00:00
|
|
|
|
/**
|
2014-08-16 20:39:51 +00:00
|
|
|
|
* GtkListBoxRow:selectable:
|
2014-07-16 03:10:51 +00:00
|
|
|
|
*
|
|
|
|
|
* The property determines whether this row can be selected.
|
|
|
|
|
*
|
|
|
|
|
* Since: 3.14
|
|
|
|
|
*/
|
|
|
|
|
row_properties[ROW_PROP_SELECTABLE] =
|
|
|
|
|
g_param_spec_boolean ("selectable",
|
|
|
|
|
P_("Selectable"),
|
|
|
|
|
P_("Whether this row can be selected"),
|
|
|
|
|
TRUE,
|
|
|
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
|
|
2014-07-13 00:37:41 +00:00
|
|
|
|
g_object_class_install_properties (object_class, LAST_ROW_PROPERTY, row_properties);
|
|
|
|
|
|
2017-11-24 13:33:42 +00:00
|
|
|
|
g_object_class_override_property (object_class, ROW_PROP_ACTION_NAME, "action-name");
|
|
|
|
|
g_object_class_override_property (object_class, ROW_PROP_ACTION_TARGET, "action-target");
|
|
|
|
|
|
2015-11-05 18:48:02 +00:00
|
|
|
|
gtk_widget_class_set_css_name (widget_class, "row");
|
2013-06-10 09:17:10 +00:00
|
|
|
|
}
|
2014-10-12 22:54:44 +00:00
|
|
|
|
|
2015-12-10 05:43:58 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_row_init (GtkListBoxRow *row)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_set_can_focus (GTK_WIDGET (row), TRUE);
|
|
|
|
|
|
|
|
|
|
ROW_PRIV (row)->activatable = TRUE;
|
|
|
|
|
ROW_PRIV (row)->selectable = TRUE;
|
|
|
|
|
|
|
|
|
|
ROW_PRIV (row)->gadget = gtk_css_custom_gadget_new_for_node (gtk_widget_get_css_node (GTK_WIDGET (row)),
|
|
|
|
|
GTK_WIDGET (row),
|
|
|
|
|
gtk_list_box_row_measure,
|
|
|
|
|
gtk_list_box_row_allocate,
|
|
|
|
|
gtk_list_box_row_render,
|
|
|
|
|
NULL,
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_css_gadget_add_class (ROW_PRIV (row)->gadget, "activatable");
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-12 22:54:44 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_buildable_add_child (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
|
|
|
|
const gchar *type)
|
|
|
|
|
{
|
|
|
|
|
if (type && strcmp (type, "placeholder") == 0)
|
|
|
|
|
gtk_list_box_set_placeholder (GTK_LIST_BOX (buildable), GTK_WIDGET (child));
|
|
|
|
|
else if (!type)
|
|
|
|
|
gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
|
|
|
|
|
else
|
|
|
|
|
GTK_BUILDER_WARN_INVALID_CHILD_TYPE (buildable, type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_buildable_interface_init (GtkBuildableIface *iface)
|
|
|
|
|
{
|
|
|
|
|
iface->add_child = gtk_list_box_buildable_add_child;
|
|
|
|
|
}
|
2015-02-09 10:49:31 +00:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_bound_model_changed (GListModel *list,
|
|
|
|
|
guint position,
|
|
|
|
|
guint removed,
|
|
|
|
|
guint added,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkListBox *box = user_data;
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (user_data);
|
2016-04-16 11:57:08 +00:00
|
|
|
|
guint i;
|
2015-02-09 10:49:31 +00:00
|
|
|
|
|
|
|
|
|
while (removed--)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxRow *row;
|
|
|
|
|
|
|
|
|
|
row = gtk_list_box_get_row_at_index (box, position);
|
|
|
|
|
gtk_widget_destroy (GTK_WIDGET (row));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < added; i++)
|
|
|
|
|
{
|
|
|
|
|
GObject *item;
|
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
|
|
|
|
|
item = g_list_model_get_item (list, position + i);
|
|
|
|
|
widget = priv->create_widget_func (item, priv->create_widget_func_data);
|
2015-03-27 15:57:38 +00:00
|
|
|
|
|
|
|
|
|
/* We allow the create_widget_func to either return a full
|
|
|
|
|
* reference or a floating reference. If we got the floating
|
|
|
|
|
* reference, then turn it into a full reference now. That means
|
|
|
|
|
* that gtk_list_box_insert() will take another full reference.
|
|
|
|
|
* Finally, we'll release this full reference below, leaving only
|
|
|
|
|
* the one held by the box.
|
|
|
|
|
*/
|
|
|
|
|
if (g_object_is_floating (widget))
|
|
|
|
|
g_object_ref_sink (widget);
|
|
|
|
|
|
2015-08-08 14:33:42 +00:00
|
|
|
|
gtk_widget_show (widget);
|
2015-02-09 10:49:31 +00:00
|
|
|
|
gtk_list_box_insert (box, widget, position + i);
|
|
|
|
|
|
2015-03-27 15:57:38 +00:00
|
|
|
|
g_object_unref (widget);
|
2015-02-09 10:49:31 +00:00
|
|
|
|
g_object_unref (item);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-25 17:16:24 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_list_box_check_model_compat (GtkListBox *box)
|
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
|
|
|
|
|
if (priv->bound_model &&
|
|
|
|
|
(priv->sort_func || priv->filter_func))
|
|
|
|
|
g_warning ("GtkListBox with a model will ignore sort and filter functions");
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-09 10:49:31 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_list_box_bind_model:
|
|
|
|
|
* @box: a #GtkListBox
|
2015-09-01 08:41:42 +00:00
|
|
|
|
* @model: (nullable): the #GListModel to be bound to @box
|
|
|
|
|
* @create_widget_func: (nullable): a function that creates widgets for items
|
|
|
|
|
* or %NULL in case you also passed %NULL as @model
|
2015-02-09 10:49:31 +00:00
|
|
|
|
* @user_data: user data passed to @create_widget_func
|
|
|
|
|
* @user_data_free_func: function for freeing @user_data
|
|
|
|
|
*
|
|
|
|
|
* Binds @model to @box.
|
|
|
|
|
*
|
|
|
|
|
* If @box was already bound to a model, that previous binding is
|
|
|
|
|
* destroyed.
|
|
|
|
|
*
|
|
|
|
|
* The contents of @box are cleared and then filled with widgets that
|
|
|
|
|
* represent items from @model. @box is updated whenever @model changes.
|
|
|
|
|
* If @model is %NULL, @box is left empty.
|
|
|
|
|
*
|
|
|
|
|
* It is undefined to add or remove widgets directly (for example, with
|
|
|
|
|
* gtk_list_box_insert() or gtk_container_add()) while @box is bound to a
|
|
|
|
|
* model.
|
|
|
|
|
*
|
2015-08-25 17:20:53 +00:00
|
|
|
|
* Note that using a model is incompatible with the filtering and sorting
|
|
|
|
|
* functionality in GtkListBox. When using a model, filtering and sorting
|
|
|
|
|
* should be implemented by the model.
|
|
|
|
|
*
|
2015-02-09 10:49:31 +00:00
|
|
|
|
* Since: 3.16
|
|
|
|
|
*/
|
|
|
|
|
void
|
2015-08-25 17:16:24 +00:00
|
|
|
|
gtk_list_box_bind_model (GtkListBox *box,
|
|
|
|
|
GListModel *model,
|
|
|
|
|
GtkListBoxCreateWidgetFunc create_widget_func,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GDestroyNotify user_data_free_func)
|
2015-02-09 10:49:31 +00:00
|
|
|
|
{
|
|
|
|
|
GtkListBoxPrivate *priv = BOX_PRIV (box);
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_LIST_BOX (box));
|
|
|
|
|
g_return_if_fail (model == NULL || G_IS_LIST_MODEL (model));
|
|
|
|
|
g_return_if_fail (model == NULL || create_widget_func != NULL);
|
|
|
|
|
|
|
|
|
|
if (priv->bound_model)
|
|
|
|
|
{
|
|
|
|
|
if (priv->create_widget_func_data_destroy)
|
|
|
|
|
priv->create_widget_func_data_destroy (priv->create_widget_func_data);
|
|
|
|
|
|
|
|
|
|
g_signal_handlers_disconnect_by_func (priv->bound_model, gtk_list_box_bound_model_changed, box);
|
|
|
|
|
g_clear_object (&priv->bound_model);
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 22:11:50 +00:00
|
|
|
|
gtk_list_box_forall (GTK_CONTAINER (box), FALSE, (GtkCallback) gtk_widget_destroy, NULL);
|
2015-02-09 10:49:31 +00:00
|
|
|
|
|
|
|
|
|
if (model == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
priv->bound_model = g_object_ref (model);
|
|
|
|
|
priv->create_widget_func = create_widget_func;
|
|
|
|
|
priv->create_widget_func_data = user_data;
|
|
|
|
|
priv->create_widget_func_data_destroy = user_data_free_func;
|
|
|
|
|
|
2015-08-25 17:16:24 +00:00
|
|
|
|
gtk_list_box_check_model_compat (box);
|
|
|
|
|
|
2015-02-09 10:49:31 +00:00
|
|
|
|
g_signal_connect (priv->bound_model, "items-changed", G_CALLBACK (gtk_list_box_bound_model_changed), box);
|
|
|
|
|
gtk_list_box_bound_model_changed (model, 0, 0, g_list_model_get_n_items (model), box);
|
|
|
|
|
}
|