2019-12-26 05:06:48 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2019 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* 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 licence, 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/>.
|
|
|
|
*
|
|
|
|
* Author: Matthias Clasen
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include "gtktreepopoverprivate.h"
|
|
|
|
|
|
|
|
#include "gtktreemodel.h"
|
|
|
|
#include "gtkcellarea.h"
|
|
|
|
#include "gtkcelllayout.h"
|
|
|
|
#include "gtkcellview.h"
|
|
|
|
#include "gtkprivate.h"
|
|
|
|
#include "gtkgizmoprivate.h"
|
2021-08-03 03:49:05 +00:00
|
|
|
#include "gtkwidgetprivate.h"
|
2020-01-28 14:03:42 +00:00
|
|
|
#include "gtkbuiltiniconprivate.h"
|
2022-07-17 19:24:51 +00:00
|
|
|
#include "gtkscrolledwindow.h"
|
|
|
|
#include "gtkviewport.h"
|
2019-12-26 05:06:48 +00:00
|
|
|
|
2022-10-07 21:47:28 +00:00
|
|
|
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
// TODO
|
|
|
|
// positioning + sizing
|
|
|
|
|
|
|
|
struct _GtkTreePopover
|
|
|
|
{
|
|
|
|
GtkPopover parent_instance;
|
|
|
|
|
|
|
|
GtkTreeModel *model;
|
|
|
|
|
|
|
|
GtkCellArea *area;
|
|
|
|
GtkCellAreaContext *context;
|
|
|
|
|
|
|
|
gulong size_changed_id;
|
|
|
|
gulong row_inserted_id;
|
|
|
|
gulong row_deleted_id;
|
|
|
|
gulong row_changed_id;
|
|
|
|
gulong row_reordered_id;
|
|
|
|
gulong apply_attributes_id;
|
|
|
|
|
|
|
|
GtkTreeViewRowSeparatorFunc row_separator_func;
|
|
|
|
gpointer row_separator_data;
|
|
|
|
GDestroyNotify row_separator_destroy;
|
|
|
|
|
|
|
|
GtkWidget *active_item;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
PROP_0,
|
|
|
|
PROP_MODEL,
|
|
|
|
PROP_CELL_AREA,
|
|
|
|
|
|
|
|
NUM_PROPERTIES
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
MENU_ACTIVATE,
|
|
|
|
NUM_SIGNALS
|
|
|
|
};
|
|
|
|
|
|
|
|
static guint signals[NUM_SIGNALS];
|
|
|
|
|
|
|
|
static void gtk_tree_popover_cell_layout_init (GtkCellLayoutIface *iface);
|
|
|
|
static void gtk_tree_popover_set_area (GtkTreePopover *popover,
|
|
|
|
GtkCellArea *area);
|
|
|
|
static void rebuild_menu (GtkTreePopover *popover);
|
|
|
|
static void context_size_changed_cb (GtkCellAreaContext *context,
|
|
|
|
GParamSpec *pspec,
|
|
|
|
GtkWidget *popover);
|
|
|
|
static GtkWidget * gtk_tree_popover_create_item (GtkTreePopover *popover,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
gboolean header_item);
|
|
|
|
static GtkWidget * gtk_tree_popover_get_path_item (GtkTreePopover *popover,
|
|
|
|
GtkTreePath *search);
|
|
|
|
static void gtk_tree_popover_set_active_item (GtkTreePopover *popover,
|
|
|
|
GtkWidget *item);
|
|
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkTreePopover, gtk_tree_popover, GTK_TYPE_POPOVER,
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
|
|
|
|
gtk_tree_popover_cell_layout_init));
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_constructed (GObject *object)
|
|
|
|
{
|
|
|
|
GtkTreePopover *popover = GTK_TREE_POPOVER (object);
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_tree_popover_parent_class)->constructed (object);
|
|
|
|
|
|
|
|
if (!popover->area)
|
|
|
|
{
|
|
|
|
GtkCellArea *area = gtk_cell_area_box_new ();
|
|
|
|
gtk_tree_popover_set_area (popover, area);
|
|
|
|
}
|
|
|
|
|
|
|
|
popover->context = gtk_cell_area_create_context (popover->area);
|
|
|
|
|
|
|
|
popover->size_changed_id = g_signal_connect (popover->context, "notify",
|
|
|
|
G_CALLBACK (context_size_changed_cb), popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_dispose (GObject *object)
|
|
|
|
{
|
|
|
|
GtkTreePopover *popover = GTK_TREE_POPOVER (object);
|
|
|
|
|
|
|
|
gtk_tree_popover_set_model (popover, NULL);
|
|
|
|
gtk_tree_popover_set_area (popover, NULL);
|
|
|
|
|
|
|
|
if (popover->context)
|
|
|
|
{
|
|
|
|
g_signal_handler_disconnect (popover->context, popover->size_changed_id);
|
|
|
|
popover->size_changed_id = 0;
|
|
|
|
|
|
|
|
g_clear_object (&popover->context);
|
|
|
|
}
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_tree_popover_parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_finalize (GObject *object)
|
|
|
|
{
|
|
|
|
GtkTreePopover *popover = GTK_TREE_POPOVER (object);
|
|
|
|
|
|
|
|
if (popover->row_separator_destroy)
|
|
|
|
popover->row_separator_destroy (popover->row_separator_data);
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_tree_popover_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_set_property (GObject *object,
|
|
|
|
guint prop_id,
|
|
|
|
const GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
GtkTreePopover *popover = GTK_TREE_POPOVER (object);
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
{
|
|
|
|
case PROP_MODEL:
|
|
|
|
gtk_tree_popover_set_model (popover, g_value_get_object (value));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PROP_CELL_AREA:
|
|
|
|
gtk_tree_popover_set_area (popover, g_value_get_object (value));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_get_property (GObject *object,
|
|
|
|
guint prop_id,
|
|
|
|
GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
GtkTreePopover *popover = GTK_TREE_POPOVER (object);
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
{
|
|
|
|
case PROP_MODEL:
|
|
|
|
g_value_set_object (value, popover->model);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PROP_CELL_AREA:
|
|
|
|
g_value_set_object (value, popover->area);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_class_init (GtkTreePopoverClass *class)
|
|
|
|
{
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
|
|
|
|
object_class->constructed = gtk_tree_popover_constructed;
|
|
|
|
object_class->dispose = gtk_tree_popover_dispose;
|
|
|
|
object_class->finalize = gtk_tree_popover_finalize;
|
|
|
|
object_class->set_property = gtk_tree_popover_set_property;
|
|
|
|
object_class->get_property = gtk_tree_popover_get_property;
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_MODEL,
|
2022-05-11 12:19:39 +00:00
|
|
|
g_param_spec_object ("model", NULL, NULL,
|
2019-12-26 05:06:48 +00:00
|
|
|
GTK_TYPE_TREE_MODEL,
|
|
|
|
GTK_PARAM_READWRITE));
|
|
|
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_CELL_AREA,
|
2022-05-11 12:19:39 +00:00
|
|
|
g_param_spec_object ("cell-area", NULL, NULL,
|
2019-12-26 05:06:48 +00:00
|
|
|
GTK_TYPE_CELL_AREA,
|
|
|
|
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
|
|
|
|
signals[MENU_ACTIVATE] =
|
|
|
|
g_signal_new (I_("menu-activate"),
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
0,
|
|
|
|
NULL, NULL,
|
|
|
|
NULL,
|
|
|
|
G_TYPE_NONE, 1, G_TYPE_STRING);
|
|
|
|
}
|
|
|
|
|
2022-07-17 19:24:51 +00:00
|
|
|
static GtkWidget *
|
|
|
|
gtk_tree_popover_get_stack (GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
GtkWidget *sw = gtk_popover_get_child (GTK_POPOVER (popover));
|
|
|
|
GtkWidget *vp = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (sw));
|
|
|
|
GtkWidget *stack = gtk_viewport_get_child (GTK_VIEWPORT (vp));
|
|
|
|
|
|
|
|
return stack;
|
|
|
|
}
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
static void
|
|
|
|
gtk_tree_popover_add_submenu (GtkTreePopover *popover,
|
|
|
|
GtkWidget *submenu,
|
|
|
|
const char *name)
|
|
|
|
{
|
2022-07-17 19:24:51 +00:00
|
|
|
GtkWidget *stack = gtk_tree_popover_get_stack (popover);
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_stack_add_named (GTK_STACK (stack), submenu, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static GtkWidget *
|
|
|
|
gtk_tree_popover_get_submenu (GtkTreePopover *popover,
|
|
|
|
const char *name)
|
|
|
|
{
|
2022-07-17 19:24:51 +00:00
|
|
|
GtkWidget *stack = gtk_tree_popover_get_stack (popover);
|
2019-12-26 05:06:48 +00:00
|
|
|
return gtk_stack_get_child_by_name (GTK_STACK (stack), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_tree_popover_open_submenu (GtkTreePopover *popover,
|
|
|
|
const char *name)
|
|
|
|
{
|
2022-07-17 19:24:51 +00:00
|
|
|
GtkWidget *stack = gtk_tree_popover_get_stack (popover);
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_stack_set_visible_child_name (GTK_STACK (stack), name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_init (GtkTreePopover *popover)
|
|
|
|
{
|
2022-07-17 19:24:51 +00:00
|
|
|
GtkWidget *sw;
|
2019-12-26 05:06:48 +00:00
|
|
|
GtkWidget *stack;
|
|
|
|
|
2022-07-17 19:24:51 +00:00
|
|
|
sw = gtk_scrolled_window_new ();
|
|
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
2022-10-26 10:58:10 +00:00
|
|
|
gtk_scrolled_window_set_propagate_natural_width (GTK_SCROLLED_WINDOW (sw), TRUE);
|
2022-07-17 19:24:51 +00:00
|
|
|
gtk_scrolled_window_set_propagate_natural_height (GTK_SCROLLED_WINDOW (sw), TRUE);
|
|
|
|
gtk_popover_set_child (GTK_POPOVER (popover), sw);
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
stack = gtk_stack_new ();
|
|
|
|
gtk_stack_set_vhomogeneous (GTK_STACK (stack), FALSE);
|
|
|
|
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
|
|
|
|
gtk_stack_set_interpolate_size (GTK_STACK (stack), TRUE);
|
2022-07-17 19:24:51 +00:00
|
|
|
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), stack);
|
2019-12-26 05:06:48 +00:00
|
|
|
|
2020-08-13 23:49:02 +00:00
|
|
|
gtk_widget_add_css_class (GTK_WIDGET (popover), "menu");
|
2019-12-26 05:06:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static GtkCellArea *
|
|
|
|
gtk_tree_popover_cell_layout_get_area (GtkCellLayout *layout)
|
|
|
|
{
|
|
|
|
return GTK_TREE_POPOVER (layout)->area;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_cell_layout_init (GtkCellLayoutIface *iface)
|
|
|
|
{
|
|
|
|
iface->get_area = gtk_tree_popover_cell_layout_get_area;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
insert_at_position (GtkBox *box,
|
|
|
|
GtkWidget *child,
|
|
|
|
int position)
|
|
|
|
{
|
|
|
|
GtkWidget *sibling = NULL;
|
|
|
|
|
|
|
|
if (position > 0)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
sibling = gtk_widget_get_first_child (GTK_WIDGET (box));
|
|
|
|
for (i = 1; i < position; i++)
|
|
|
|
sibling = gtk_widget_get_next_sibling (sibling);
|
|
|
|
}
|
|
|
|
|
|
|
|
gtk_box_insert_child_after (box, child, sibling);
|
|
|
|
}
|
|
|
|
|
|
|
|
static GtkWidget *
|
|
|
|
ensure_submenu (GtkTreePopover *popover,
|
|
|
|
GtkTreePath *path)
|
|
|
|
{
|
|
|
|
GtkWidget *box;
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
if (path)
|
|
|
|
name = gtk_tree_path_to_string (path);
|
|
|
|
else
|
|
|
|
name = NULL;
|
|
|
|
|
|
|
|
box = gtk_tree_popover_get_submenu (popover, name ? name : "main");
|
|
|
|
if (!box)
|
|
|
|
{
|
|
|
|
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
|
|
|
|
gtk_tree_popover_add_submenu (popover, box, name ? name : "main");
|
|
|
|
if (path)
|
|
|
|
{
|
|
|
|
GtkTreeIter iter;
|
|
|
|
GtkWidget *item;
|
|
|
|
gtk_tree_model_get_iter (popover->model, &iter, path);
|
|
|
|
item = gtk_tree_popover_create_item (popover, path, &iter, TRUE);
|
2020-05-09 12:26:52 +00:00
|
|
|
gtk_box_append (GTK_BOX (box), item);
|
|
|
|
gtk_box_append (GTK_BOX (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
|
2019-12-26 05:06:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (name);
|
|
|
|
|
|
|
|
return box;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
row_inserted_cb (GtkTreeModel *model,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
2020-07-24 13:54:49 +00:00
|
|
|
int *indices, depth, index;
|
2019-12-26 05:06:48 +00:00
|
|
|
GtkWidget *item;
|
|
|
|
GtkWidget *box;
|
|
|
|
|
|
|
|
indices = gtk_tree_path_get_indices (path);
|
|
|
|
depth = gtk_tree_path_get_depth (path);
|
|
|
|
index = indices[depth - 1];
|
|
|
|
|
|
|
|
item = gtk_tree_popover_create_item (popover, path, iter, FALSE);
|
|
|
|
if (depth == 1)
|
|
|
|
{
|
|
|
|
box = ensure_submenu (popover, NULL);
|
|
|
|
insert_at_position (GTK_BOX (box), item, index);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GtkTreePath *ppath;
|
|
|
|
|
|
|
|
ppath = gtk_tree_path_copy (path);
|
|
|
|
gtk_tree_path_up (ppath);
|
|
|
|
|
|
|
|
box = ensure_submenu (popover, ppath);
|
|
|
|
insert_at_position (GTK_BOX (box), item, index + 2);
|
|
|
|
|
|
|
|
gtk_tree_path_free (ppath);
|
|
|
|
}
|
|
|
|
|
|
|
|
gtk_cell_area_context_reset (popover->context);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
row_deleted_cb (GtkTreeModel *model,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
GtkWidget *item;
|
|
|
|
|
|
|
|
item = gtk_tree_popover_get_path_item (popover, path);
|
|
|
|
|
|
|
|
if (item)
|
|
|
|
{
|
2020-05-09 14:33:02 +00:00
|
|
|
gtk_widget_unparent (item);
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_cell_area_context_reset (popover->context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
row_changed_cb (GtkTreeModel *model,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
gboolean is_separator = FALSE;
|
|
|
|
GtkWidget *item;
|
2020-07-24 13:54:49 +00:00
|
|
|
int *indices, depth, index;
|
2019-12-26 05:06:48 +00:00
|
|
|
|
|
|
|
item = gtk_tree_popover_get_path_item (popover, path);
|
|
|
|
|
|
|
|
if (!item)
|
|
|
|
return;
|
|
|
|
|
|
|
|
indices = gtk_tree_path_get_indices (path);
|
|
|
|
depth = gtk_tree_path_get_depth (path);
|
|
|
|
index = indices[depth - 1];
|
|
|
|
|
|
|
|
if (popover->row_separator_func)
|
|
|
|
is_separator = popover->row_separator_func (model, iter, popover->row_separator_data);
|
|
|
|
|
|
|
|
if (is_separator != GTK_IS_SEPARATOR (item))
|
|
|
|
{
|
2020-05-09 14:33:02 +00:00
|
|
|
GtkWidget *box = gtk_widget_get_parent (item);
|
2019-12-26 05:06:48 +00:00
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
gtk_box_remove (GTK_BOX (box), item);
|
2019-12-26 05:06:48 +00:00
|
|
|
|
|
|
|
item = gtk_tree_popover_create_item (popover, path, iter, FALSE);
|
|
|
|
|
|
|
|
if (depth == 1)
|
|
|
|
insert_at_position (GTK_BOX (box), item, index);
|
|
|
|
else
|
|
|
|
insert_at_position (GTK_BOX (box), item, index + 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
row_reordered_cb (GtkTreeModel *model,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreeIter *iter,
|
2020-07-24 13:54:49 +00:00
|
|
|
int *new_order,
|
2019-12-26 05:06:48 +00:00
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
rebuild_menu (popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
context_size_changed_cb (GtkCellAreaContext *context,
|
|
|
|
GParamSpec *pspec,
|
|
|
|
GtkWidget *popover)
|
|
|
|
{
|
|
|
|
if (!strcmp (pspec->name, "minimum-width") ||
|
|
|
|
!strcmp (pspec->name, "natural-width") ||
|
|
|
|
!strcmp (pspec->name, "minimum-height") ||
|
|
|
|
!strcmp (pspec->name, "natural-height"))
|
|
|
|
gtk_widget_queue_resize (popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
area_is_sensitive (GtkCellArea *area)
|
|
|
|
{
|
|
|
|
GList *cells, *list;
|
|
|
|
gboolean sensitive = FALSE;
|
|
|
|
|
|
|
|
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
|
|
|
|
|
|
|
|
for (list = cells; list; list = list->next)
|
|
|
|
{
|
|
|
|
g_object_get (list->data, "sensitive", &sensitive, NULL);
|
|
|
|
|
|
|
|
if (sensitive)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
g_list_free (cells);
|
|
|
|
|
|
|
|
return sensitive;
|
|
|
|
}
|
|
|
|
|
|
|
|
static GtkWidget *
|
|
|
|
gtk_tree_popover_get_path_item (GtkTreePopover *popover,
|
|
|
|
GtkTreePath *search)
|
|
|
|
{
|
2022-07-17 19:24:51 +00:00
|
|
|
GtkWidget *stack = gtk_tree_popover_get_stack (popover);
|
2019-12-26 05:06:48 +00:00
|
|
|
GtkWidget *item = NULL;
|
2020-05-10 01:03:10 +00:00
|
|
|
GtkWidget *stackchild;
|
|
|
|
GtkWidget *child;
|
2019-12-26 05:06:48 +00:00
|
|
|
|
2020-05-10 01:03:10 +00:00
|
|
|
for (stackchild = gtk_widget_get_first_child (stack);
|
|
|
|
stackchild != NULL;
|
|
|
|
stackchild = gtk_widget_get_next_sibling (stackchild))
|
2019-12-26 05:06:48 +00:00
|
|
|
{
|
2020-05-10 01:03:10 +00:00
|
|
|
for (child = gtk_widget_get_first_child (stackchild);
|
2019-12-26 05:06:48 +00:00
|
|
|
!item && child;
|
|
|
|
child = gtk_widget_get_next_sibling (child))
|
|
|
|
{
|
|
|
|
GtkTreePath *path = NULL;
|
|
|
|
|
|
|
|
if (GTK_IS_SEPARATOR (child))
|
|
|
|
{
|
|
|
|
GtkTreeRowReference *row = g_object_get_data (G_OBJECT (child), "gtk-tree-path");
|
|
|
|
|
|
|
|
if (row)
|
|
|
|
{
|
|
|
|
path = gtk_tree_row_reference_get_path (row);
|
|
|
|
if (!path)
|
|
|
|
item = child;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GtkWidget *view = GTK_WIDGET (g_object_get_data (G_OBJECT (child), "view"));
|
|
|
|
|
|
|
|
path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (view));
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
item = child;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (path)
|
|
|
|
{
|
|
|
|
if (gtk_tree_path_compare (search, path) == 0)
|
|
|
|
item = child;
|
|
|
|
gtk_tree_path_free (path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
area_apply_attributes_cb (GtkCellArea *area,
|
|
|
|
GtkTreeModel *tree_model,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
gboolean is_expander,
|
|
|
|
gboolean is_expanded,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
GtkTreePath*path;
|
|
|
|
GtkWidget *item;
|
|
|
|
gboolean sensitive;
|
|
|
|
GtkTreeIter dummy;
|
|
|
|
gboolean has_submenu = FALSE;
|
|
|
|
|
|
|
|
if (gtk_tree_model_iter_children (popover->model, &dummy, iter))
|
|
|
|
has_submenu = TRUE;
|
|
|
|
|
|
|
|
path = gtk_tree_model_get_path (tree_model, iter);
|
|
|
|
item = gtk_tree_popover_get_path_item (popover, path);
|
|
|
|
|
|
|
|
if (item)
|
|
|
|
{
|
|
|
|
sensitive = area_is_sensitive (popover->area);
|
|
|
|
gtk_widget_set_sensitive (item, sensitive || has_submenu);
|
|
|
|
}
|
|
|
|
|
|
|
|
gtk_tree_path_free (path);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_set_area (GtkTreePopover *popover,
|
|
|
|
GtkCellArea *area)
|
|
|
|
{
|
|
|
|
if (popover->area)
|
|
|
|
{
|
|
|
|
g_signal_handler_disconnect (popover->area, popover->apply_attributes_id);
|
|
|
|
popover->apply_attributes_id = 0;
|
|
|
|
g_clear_object (&popover->area);
|
|
|
|
}
|
|
|
|
|
|
|
|
popover->area = area;
|
|
|
|
|
|
|
|
if (popover->area)
|
|
|
|
{
|
|
|
|
g_object_ref_sink (popover->area);
|
|
|
|
popover->apply_attributes_id = g_signal_connect (popover->area, "apply-attributes",
|
|
|
|
G_CALLBACK (area_apply_attributes_cb), popover);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2021-08-03 03:49:05 +00:00
|
|
|
activate_item (GtkWidget *item,
|
|
|
|
GtkTreePopover *popover)
|
2019-12-26 05:06:48 +00:00
|
|
|
{
|
|
|
|
GtkCellView *view;
|
|
|
|
GtkTreePath *path;
|
2020-07-24 18:40:36 +00:00
|
|
|
char *path_str;
|
2019-12-26 05:06:48 +00:00
|
|
|
gboolean is_header = FALSE;
|
|
|
|
gboolean has_submenu = FALSE;
|
|
|
|
|
|
|
|
is_header = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "is-header"));
|
|
|
|
|
|
|
|
view = GTK_CELL_VIEW (g_object_get_data (G_OBJECT (item), "view"));
|
|
|
|
|
|
|
|
path = gtk_cell_view_get_displayed_row (view);
|
|
|
|
|
|
|
|
if (is_header)
|
|
|
|
{
|
|
|
|
gtk_tree_path_up (path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GtkTreeIter iter;
|
|
|
|
GtkTreeIter dummy;
|
|
|
|
|
|
|
|
gtk_tree_model_get_iter (popover->model, &iter, path);
|
|
|
|
if (gtk_tree_model_iter_children (popover->model, &dummy, &iter))
|
|
|
|
has_submenu = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
path_str = gtk_tree_path_to_string (path);
|
|
|
|
|
|
|
|
if (is_header || has_submenu)
|
|
|
|
{
|
|
|
|
gtk_tree_popover_open_submenu (popover, path_str ? path_str : "main");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_signal_emit (popover, signals[MENU_ACTIVATE], 0, path_str);
|
|
|
|
gtk_popover_popdown (GTK_POPOVER (popover));
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free (path_str);
|
|
|
|
gtk_tree_path_free (path);
|
|
|
|
}
|
|
|
|
|
2021-08-03 03:49:05 +00:00
|
|
|
static void
|
|
|
|
item_activated_cb (GtkGesture *gesture,
|
|
|
|
guint n_press,
|
|
|
|
double x,
|
|
|
|
double y,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
|
|
|
|
activate_item (item, popover);
|
|
|
|
}
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
static void
|
2020-02-20 03:04:28 +00:00
|
|
|
enter_cb (GtkEventController *controller,
|
|
|
|
double x,
|
|
|
|
double y,
|
|
|
|
GtkTreePopover *popover)
|
2019-12-26 05:06:48 +00:00
|
|
|
{
|
|
|
|
GtkWidget *item;
|
|
|
|
item = gtk_event_controller_get_widget (controller);
|
|
|
|
|
2020-02-20 03:04:28 +00:00
|
|
|
gtk_tree_popover_set_active_item (popover, item);
|
2019-12-26 05:06:48 +00:00
|
|
|
}
|
|
|
|
|
2021-08-03 03:49:05 +00:00
|
|
|
static void
|
|
|
|
enter_focus_cb (GtkEventController *controller,
|
|
|
|
GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
GtkWidget *item = gtk_event_controller_get_widget (controller);
|
|
|
|
|
|
|
|
gtk_tree_popover_set_active_item (popover, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
activate_shortcut (GtkWidget *widget,
|
|
|
|
GVariant *args,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
activate_item (widget, user_data);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
static GtkWidget *
|
|
|
|
gtk_tree_popover_create_item (GtkTreePopover *popover,
|
|
|
|
GtkTreePath *path,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
gboolean header_item)
|
|
|
|
{
|
|
|
|
GtkWidget *item, *view;
|
|
|
|
gboolean is_separator = FALSE;
|
|
|
|
|
|
|
|
if (popover->row_separator_func)
|
|
|
|
is_separator = popover->row_separator_func (popover->model, iter, popover->row_separator_data);
|
|
|
|
|
|
|
|
if (is_separator)
|
|
|
|
{
|
|
|
|
item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
|
|
|
|
g_object_set_data_full (G_OBJECT (item), "gtk-tree-path",
|
|
|
|
gtk_tree_row_reference_new (popover->model, path),
|
|
|
|
(GDestroyNotify)gtk_tree_row_reference_free);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GtkEventController *controller;
|
|
|
|
GtkTreeIter dummy;
|
|
|
|
gboolean has_submenu = FALSE;
|
|
|
|
GtkWidget *indicator;
|
|
|
|
|
|
|
|
if (!header_item &&
|
|
|
|
gtk_tree_model_iter_children (popover->model, &dummy, iter))
|
|
|
|
has_submenu = TRUE;
|
|
|
|
|
|
|
|
view = gtk_cell_view_new_with_context (popover->area, popover->context);
|
|
|
|
gtk_cell_view_set_model (GTK_CELL_VIEW (view), popover->model);
|
|
|
|
gtk_cell_view_set_displayed_row (GTK_CELL_VIEW (view), path);
|
|
|
|
gtk_widget_set_hexpand (view, TRUE);
|
|
|
|
|
2021-08-03 03:49:05 +00:00
|
|
|
item = gtk_gizmo_new ("modelbutton", NULL, NULL, NULL, NULL,
|
|
|
|
(GtkGizmoFocusFunc)gtk_widget_focus_self,
|
|
|
|
(GtkGizmoGrabFocusFunc)gtk_widget_grab_focus_self);
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_widget_set_layout_manager (item, gtk_box_layout_new (GTK_ORIENTATION_HORIZONTAL));
|
2021-08-03 03:49:05 +00:00
|
|
|
gtk_widget_set_focusable (item, TRUE);
|
2020-02-06 16:32:26 +00:00
|
|
|
gtk_widget_add_css_class (item, "flat");
|
2019-12-26 05:06:48 +00:00
|
|
|
|
|
|
|
if (header_item)
|
|
|
|
{
|
2020-01-28 14:03:42 +00:00
|
|
|
indicator = gtk_builtin_icon_new ("arrow");
|
2020-02-06 16:32:26 +00:00
|
|
|
gtk_widget_add_css_class (indicator, "left");
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_widget_set_parent (indicator, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
gtk_widget_set_parent (view, item);
|
|
|
|
|
2020-01-28 14:03:42 +00:00
|
|
|
indicator = gtk_builtin_icon_new (has_submenu ? "arrow" : "none");
|
2020-02-06 16:32:26 +00:00
|
|
|
gtk_widget_add_css_class (indicator, "right");
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_widget_set_parent (indicator, item);
|
|
|
|
|
|
|
|
controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
|
|
|
|
g_signal_connect (controller, "pressed", G_CALLBACK (item_activated_cb), popover);
|
|
|
|
gtk_widget_add_controller (item, GTK_EVENT_CONTROLLER (controller));
|
|
|
|
|
|
|
|
controller = gtk_event_controller_motion_new ();
|
2020-02-20 03:04:28 +00:00
|
|
|
g_signal_connect (controller, "enter", G_CALLBACK (enter_cb), popover);
|
2019-12-26 05:06:48 +00:00
|
|
|
gtk_widget_add_controller (item, controller);
|
|
|
|
|
2021-08-03 03:49:05 +00:00
|
|
|
controller = gtk_event_controller_focus_new ();
|
|
|
|
g_signal_connect (controller, "enter", G_CALLBACK (enter_focus_cb), popover);
|
|
|
|
gtk_widget_add_controller (item, controller);
|
|
|
|
|
|
|
|
{
|
|
|
|
const guint activate_keyvals[] = { GDK_KEY_space, GDK_KEY_KP_Space,
|
|
|
|
GDK_KEY_Return, GDK_KEY_ISO_Enter,
|
|
|
|
GDK_KEY_KP_Enter };
|
|
|
|
GtkShortcutTrigger *trigger;
|
|
|
|
GtkShortcut *shortcut;
|
|
|
|
|
|
|
|
trigger = g_object_ref (gtk_never_trigger_get ());
|
|
|
|
for (int i = 0; i < G_N_ELEMENTS (activate_keyvals); i++)
|
|
|
|
trigger = gtk_alternative_trigger_new (gtk_keyval_trigger_new (activate_keyvals[i], 0), trigger);
|
|
|
|
|
|
|
|
shortcut = gtk_shortcut_new (trigger, gtk_callback_action_new (activate_shortcut, popover, NULL));
|
|
|
|
controller = gtk_shortcut_controller_new ();
|
|
|
|
gtk_shortcut_controller_add_shortcut (GTK_SHORTCUT_CONTROLLER (controller), shortcut);
|
|
|
|
gtk_widget_add_controller (item, controller);
|
|
|
|
}
|
|
|
|
|
2019-12-26 05:06:48 +00:00
|
|
|
g_object_set_data (G_OBJECT (item), "is-header", GINT_TO_POINTER (header_item));
|
|
|
|
g_object_set_data (G_OBJECT (item), "view", view);
|
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
populate (GtkTreePopover *popover,
|
|
|
|
GtkTreeIter *parent)
|
|
|
|
{
|
|
|
|
GtkTreeIter iter;
|
|
|
|
gboolean valid = FALSE;
|
|
|
|
|
|
|
|
if (!popover->model)
|
|
|
|
return;
|
|
|
|
|
|
|
|
valid = gtk_tree_model_iter_children (popover->model, &iter, parent);
|
|
|
|
|
|
|
|
while (valid)
|
|
|
|
{
|
|
|
|
GtkTreePath *path;
|
|
|
|
|
|
|
|
path = gtk_tree_model_get_path (popover->model, &iter);
|
|
|
|
row_inserted_cb (popover->model, path, &iter, popover);
|
|
|
|
|
|
|
|
populate (popover, &iter);
|
|
|
|
|
|
|
|
valid = gtk_tree_model_iter_next (popover->model, &iter);
|
|
|
|
gtk_tree_path_free (path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_populate (GtkTreePopover *popover)
|
|
|
|
{
|
|
|
|
populate (popover, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rebuild_menu (GtkTreePopover *popover)
|
|
|
|
{
|
2020-05-02 02:22:20 +00:00
|
|
|
GtkWidget *stack;
|
2020-05-09 14:33:02 +00:00
|
|
|
GtkWidget *child;
|
2020-05-02 02:22:20 +00:00
|
|
|
|
2022-07-17 19:24:51 +00:00
|
|
|
stack = gtk_tree_popover_get_stack (popover);
|
2020-05-09 14:33:02 +00:00
|
|
|
while ((child = gtk_widget_get_first_child (stack)))
|
2020-05-10 01:01:24 +00:00
|
|
|
gtk_stack_remove (GTK_STACK (stack), child);
|
2019-12-26 05:06:48 +00:00
|
|
|
|
|
|
|
if (popover->model)
|
|
|
|
gtk_tree_popover_populate (popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_tree_popover_set_model (GtkTreePopover *popover,
|
|
|
|
GtkTreeModel *model)
|
|
|
|
{
|
|
|
|
if (popover->model == model)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (popover->model)
|
|
|
|
{
|
|
|
|
g_signal_handler_disconnect (popover->model, popover->row_inserted_id);
|
|
|
|
g_signal_handler_disconnect (popover->model, popover->row_deleted_id);
|
|
|
|
g_signal_handler_disconnect (popover->model, popover->row_changed_id);
|
|
|
|
g_signal_handler_disconnect (popover->model, popover->row_reordered_id);
|
|
|
|
popover->row_inserted_id = 0;
|
|
|
|
popover->row_deleted_id = 0;
|
|
|
|
popover->row_changed_id = 0;
|
|
|
|
popover->row_reordered_id = 0;
|
|
|
|
|
|
|
|
g_object_unref (popover->model);
|
|
|
|
}
|
|
|
|
|
|
|
|
popover->model = model;
|
|
|
|
|
|
|
|
if (popover->model)
|
|
|
|
{
|
|
|
|
g_object_ref (popover->model);
|
|
|
|
|
|
|
|
popover->row_inserted_id = g_signal_connect (popover->model, "row-inserted",
|
|
|
|
G_CALLBACK (row_inserted_cb), popover);
|
|
|
|
popover->row_deleted_id = g_signal_connect (popover->model, "row-deleted",
|
|
|
|
G_CALLBACK (row_deleted_cb), popover);
|
|
|
|
popover->row_changed_id = g_signal_connect (popover->model, "row-changed",
|
|
|
|
G_CALLBACK (row_changed_cb), popover);
|
|
|
|
popover->row_reordered_id = g_signal_connect (popover->model, "rows-reordered",
|
|
|
|
G_CALLBACK (row_reordered_cb), popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
rebuild_menu (popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_tree_popover_set_row_separator_func (GtkTreePopover *popover,
|
|
|
|
GtkTreeViewRowSeparatorFunc func,
|
|
|
|
gpointer data,
|
|
|
|
GDestroyNotify destroy)
|
|
|
|
{
|
|
|
|
if (popover->row_separator_destroy)
|
|
|
|
popover->row_separator_destroy (popover->row_separator_data);
|
|
|
|
|
|
|
|
popover->row_separator_func = func;
|
|
|
|
popover->row_separator_data = data;
|
|
|
|
popover->row_separator_destroy = destroy;
|
|
|
|
|
|
|
|
rebuild_menu (popover);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_tree_popover_set_active_item (GtkTreePopover *popover,
|
|
|
|
GtkWidget *item)
|
|
|
|
{
|
|
|
|
if (popover->active_item == item)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (popover->active_item)
|
|
|
|
{
|
|
|
|
gtk_widget_unset_state_flags (popover->active_item, GTK_STATE_FLAG_SELECTED);
|
|
|
|
g_object_remove_weak_pointer (G_OBJECT (popover->active_item), (gpointer *)&popover->active_item);
|
|
|
|
}
|
|
|
|
|
|
|
|
popover->active_item = item;
|
|
|
|
|
|
|
|
if (popover->active_item)
|
|
|
|
{
|
|
|
|
g_object_add_weak_pointer (G_OBJECT (popover->active_item), (gpointer *)&popover->active_item);
|
|
|
|
gtk_widget_set_state_flags (popover->active_item, GTK_STATE_FLAG_SELECTED, FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_tree_popover_set_active (GtkTreePopover *popover,
|
|
|
|
int item)
|
|
|
|
{
|
|
|
|
GtkWidget *box;
|
|
|
|
GtkWidget *child;
|
|
|
|
int pos;
|
|
|
|
|
|
|
|
if (item == -1)
|
|
|
|
{
|
|
|
|
gtk_tree_popover_set_active_item (popover, NULL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
box = gtk_tree_popover_get_submenu (popover, "main");
|
|
|
|
if (!box)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (child = gtk_widget_get_first_child (box), pos = 0;
|
|
|
|
child;
|
|
|
|
child = gtk_widget_get_next_sibling (child), pos++)
|
|
|
|
{
|
|
|
|
if (pos == item)
|
|
|
|
{
|
|
|
|
gtk_tree_popover_set_active_item (popover, child);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|