AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
9f09cfcfbd
gtk2/gtk/gtkpaned.c
Emmanuele Bassi 6e52ef96a4 Move orientable style classes into GtkWidget 
It feels slightly wrong to have GtkOrientable operate on widgets, but at
least what happens when an orientable widget changes orientation should
be part of GtkWidget.

This will allow to add more state changes without accessing widget state
from the outside of gtkwidget.c.
2020-06-05 20:35:09 +01:00

2449 lines
77 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* 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/>.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include "gtkpaned.h"
#include "gtkcssboxesprivate.h"
#include "gtkcssnodeprivate.h"
#include "gtkcssstylepropertyprivate.h"
#include "gtkeventcontrollermotion.h"
#include "gtkgesturepan.h"
#include "gtkgesturesingle.h"
#include "gtkgizmoprivate.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtkorientable.h"
#include "gtkprivate.h"
#include "gtkrendericonprivate.h"
#include "gtkstylecontextprivate.h"
#include "gtktypebuiltins.h"
#include "gtkwidgetprivate.h"
#include "gtkcssboxesprivate.h"
#include "gtkbuildable.h"
#include "a11y/gtkpanedaccessible.h"
#include <math.h>
/**
* SECTION:gtkpaned
* @Short_description: A widget with two adjustable panes
* @Title: GtkPaned
*
* #GtkPaned has two panes, arranged either
* horizontally or vertically. The division between
* the two panes is adjustable by the user by dragging
* a handle.
*
* Child widgets are added to the panes of the widget with
* gtk_paned_set_start_child() and gtk_paned_set_end_child().
* The division between the two children is set by default
* from the size requests of the children, but it can be adjusted by the
* user.
*
* A paned widget draws a separator between the two child widgets and a
* small handle that the user can drag to adjust the division. It does not
* draw any relief around the children or around the separator. (The space
* in which the separator is called the gutter.) Often, it is useful to put
* each child inside a #GtkFrame so that the gutter appears as a ridge.
* No separator is drawn if one of the children is missing.
*
* Each child has two options that can be set, @resize and @shrink. If
* @resize is true, then when the #GtkPaned is resized, that child will
* expand or shrink along with the paned widget. If @shrink is true, then
* that child can be made smaller than its requisition by the user.
* Setting @shrink to %FALSE allows the application to set a minimum size.
* If @resize is false for both children, then this is treated as if
* @resize is true for both children.
*
* The application can set the position of the slider as if it were set
* by the user, by calling gtk_paned_set_position().
*
* # CSS nodes
*
* |[<!-- language="plain" -->
* paned
* ├── <child>
* ├── separator[.wide]
* ╰── <child>
* ]|
*
* GtkPaned has a main CSS node with name paned, and a subnode for
* the separator with name separator. The subnode gets a .wide style
* class when the paned is supposed to be wide.
*
* In horizontal orientation, the nodes are arranged based on the text
* direction, so in left-to-right mode, :first-child will select the
* leftmost child, while it will select the rightmost child in
* RTL layouts.
*
* ## Creating a paned widget with minimum sizes.
*
* |[<!-- language="C" -->
* GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
* GtkWidget *frame1 = gtk_frame_new (NULL);
* GtkWidget *frame2 = gtk_frame_new (NULL);
*
* gtk_widget_set_size_request (hpaned, 200, -1);
*
* gtk_paned_pack1 (GTK_PANED (hpaned), frame1, TRUE, FALSE);
* gtk_widget_set_size_request (frame1, 50, -1);
*
* gtk_paned_pack2 (GTK_PANED (hpaned), frame2, FALSE, FALSE);
* gtk_widget_set_size_request (frame2, 50, -1);
* ]|
*/
#define HANDLE_EXTRA_SIZE 6
typedef struct _GtkPanedClass GtkPanedClass;
struct _GtkPaned
{
GtkWidget parent_instance;
GtkPaned *first_paned;
GtkWidget *start_child;
GtkWidget *end_child;
GtkWidget *last_start_child_focus;
GtkWidget *last_end_child_focus;
GtkWidget *saved_focus;
GtkOrientation orientation;
GtkWidget *handle_widget;
GtkGesture *pan_gesture; /* Used for touch */
GtkGesture *drag_gesture; /* Used for mice */
gint start_child_size;
gint drag_pos;
gint last_allocation;
gint max_position;
gint min_position;
gint original_position;
guint in_recursion : 1;
guint resize_start_child : 1;
guint shrink_start_child : 1;
guint resize_end_child : 1;
guint shrink_end_child : 1;
guint position_set : 1;
guint panning : 1;
};
struct _GtkPanedClass
{
GtkWidgetClass parent_class;
gboolean (* cycle_child_focus) (GtkPaned *paned,
gboolean reverse);
gboolean (* toggle_handle_focus) (GtkPaned *paned);
gboolean (* move_handle) (GtkPaned *paned,
GtkScrollType scroll);
gboolean (* cycle_handle_focus) (GtkPaned *paned,
gboolean reverse);
gboolean (* accept_position) (GtkPaned *paned);
gboolean (* cancel_position) (GtkPaned *paned);
};
enum {
PROP_0,
PROP_POSITION,
PROP_POSITION_SET,
PROP_MIN_POSITION,
PROP_MAX_POSITION,
PROP_WIDE_HANDLE,
PROP_RESIZE_START_CHILD,
PROP_RESIZE_END_CHILD,
PROP_SHRINK_START_CHILD,
PROP_SHRINK_END_CHILD,
PROP_START_CHILD,
PROP_END_CHILD,
LAST_PROP,
/* GtkOrientable */
PROP_ORIENTATION,
};
enum {
CYCLE_CHILD_FOCUS,
TOGGLE_HANDLE_FOCUS,
MOVE_HANDLE,
CYCLE_HANDLE_FOCUS,
ACCEPT_POSITION,
CANCEL_POSITION,
LAST_SIGNAL
};
static void gtk_paned_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_paned_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_paned_dispose (GObject *object);
static void gtk_paned_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline);
static void gtk_paned_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline);
static void gtk_paned_unrealize (GtkWidget *widget);
static void gtk_paned_css_changed (GtkWidget *widget,
GtkCssStyleChange *change);
static void gtk_paned_calc_position (GtkPaned *paned,
gint allocation,
gint start_child_req,
gint end_child_req);
static void gtk_paned_set_focus_child (GtkWidget *widget,
GtkWidget *child);
static void gtk_paned_set_saved_focus (GtkPaned *paned,
GtkWidget *widget);
static void gtk_paned_set_first_paned (GtkPaned *paned,
GtkPaned *first_paned);
static void gtk_paned_set_last_start_child_focus (GtkPaned *paned,
GtkWidget *widget);
static void gtk_paned_set_last_end_child_focus (GtkPaned *paned,
GtkWidget *widget);
static gboolean gtk_paned_cycle_child_focus (GtkPaned *paned,
gboolean reverse);
static gboolean gtk_paned_cycle_handle_focus (GtkPaned *paned,
gboolean reverse);
static gboolean gtk_paned_move_handle (GtkPaned *paned,
GtkScrollType scroll);
static gboolean gtk_paned_accept_position (GtkPaned *paned);
static gboolean gtk_paned_cancel_position (GtkPaned *paned);
static gboolean gtk_paned_toggle_handle_focus (GtkPaned *paned);
static void update_drag (GtkPaned *paned,
int xpos,
int ypos);
static void gtk_paned_buildable_iface_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkPaned, gtk_paned, GTK_TYPE_WIDGET,
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_paned_buildable_iface_init))
static guint signals[LAST_SIGNAL] = { 0 };
static GParamSpec *paned_props[LAST_PROP] = { NULL, };
static void
add_tab_bindings (GtkWidgetClass *widget_class,
GdkModifierType modifiers)
{
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_Tab, modifiers,
"toggle-handle-focus",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_KP_Tab, modifiers,
"toggle-handle-focus",
NULL);
}
static void
add_move_binding (GtkWidgetClass *widget_class,
guint keyval,
GdkModifierType mask,
GtkScrollType scroll)
{
gtk_widget_class_add_binding_signal (widget_class,
keyval, mask,
"move-handle",
"(i)", scroll);
}
static void
get_handle_area (GtkPaned *paned,
graphene_rect_t *area)
{
int extra = 0;
if (!gtk_widget_compute_bounds (paned->handle_widget, GTK_WIDGET (paned), area))
return;
if (!gtk_paned_get_wide_handle (paned))
extra = HANDLE_EXTRA_SIZE;
graphene_rect_inset (area, - extra, - extra);
}
static gboolean
gtk_paned_handle_contains (GtkGizmo *handle,
double x,
double y)
{
GtkWidget *paned;
GtkCssBoxes boxes;
graphene_rect_t area;
gtk_css_boxes_init (&boxes, GTK_WIDGET (handle));
graphene_rect_init_from_rect (&area, gtk_css_boxes_get_border_rect (&boxes));
paned = gtk_widget_get_parent (GTK_WIDGET (handle));
if (!gtk_paned_get_wide_handle (GTK_PANED (paned)))
graphene_rect_inset (&area, - HANDLE_EXTRA_SIZE, - HANDLE_EXTRA_SIZE);
return graphene_rect_contains_point (&area, &GRAPHENE_POINT_INIT (x, y));
}
static void
gtk_paned_compute_expand (GtkWidget *widget,
gboolean *hexpand,
gboolean *vexpand)
{
GtkPaned *paned = GTK_PANED (widget);
gboolean h = FALSE;
gboolean v = FALSE;
if (paned->start_child)
{
h = h || gtk_widget_compute_expand (paned->start_child, GTK_ORIENTATION_HORIZONTAL);
v = v || gtk_widget_compute_expand (paned->start_child, GTK_ORIENTATION_VERTICAL);
}
if (paned->end_child)
{
h = h || gtk_widget_compute_expand (paned->end_child, GTK_ORIENTATION_HORIZONTAL);
v = v || gtk_widget_compute_expand (paned->end_child, GTK_ORIENTATION_VERTICAL);
}
*hexpand = h;
*vexpand = v;
}
static GtkSizeRequestMode
gtk_paned_get_request_mode (GtkWidget *widget)
{
GtkPaned *paned = GTK_PANED (widget);
int wfh = 0, hfw = 0;
if (paned->start_child)
{
switch (gtk_widget_get_request_mode (paned->start_child))
{
case GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH:
hfw++;
break;
case GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT:
wfh++;
break;
case GTK_SIZE_REQUEST_CONSTANT_SIZE:
default:
break;
}
}
if (paned->end_child)
{
switch (gtk_widget_get_request_mode (paned->end_child))
{
case GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH:
hfw++;
break;
case GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT:
wfh++;
break;
case GTK_SIZE_REQUEST_CONSTANT_SIZE:
default:
break;
}
}
if (hfw == 0 && wfh == 0)
return GTK_SIZE_REQUEST_CONSTANT_SIZE;
else
return wfh > hfw ?
GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT :
GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}
static void
gtk_paned_set_orientation (GtkPaned *self,
GtkOrientation orientation)
{
if (self->orientation != orientation)
{
static const char *cursor_name[2] = {
"col-resize",
"row-resize",
};
self->orientation = orientation;
gtk_widget_update_orientation (GTK_WIDGET (self), self->orientation);
gtk_widget_set_cursor_from_name (self->handle_widget,
cursor_name[orientation]);
gtk_gesture_pan_set_orientation (GTK_GESTURE_PAN (self->pan_gesture),
orientation);
gtk_widget_queue_resize (GTK_WIDGET (self));
g_object_notify (G_OBJECT (self), "orientation");
}
}
static void
gtk_paned_class_init (GtkPanedClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
object_class->set_property = gtk_paned_set_property;
object_class->get_property = gtk_paned_get_property;
object_class->dispose = gtk_paned_dispose;
widget_class->measure = gtk_paned_measure;
widget_class->size_allocate = gtk_paned_size_allocate;
widget_class->unrealize = gtk_paned_unrealize;
widget_class->focus = gtk_widget_focus_child;
widget_class->set_focus_child = gtk_paned_set_focus_child;
widget_class->css_changed = gtk_paned_css_changed;
widget_class->get_request_mode = gtk_paned_get_request_mode;
widget_class->compute_expand = gtk_paned_compute_expand;
class->cycle_child_focus = gtk_paned_cycle_child_focus;
class->toggle_handle_focus = gtk_paned_toggle_handle_focus;
class->move_handle = gtk_paned_move_handle;
class->cycle_handle_focus = gtk_paned_cycle_handle_focus;
class->accept_position = gtk_paned_accept_position;
class->cancel_position = gtk_paned_cancel_position;
paned_props[PROP_POSITION] =
g_param_spec_int ("position",
P_("Position"),
P_("Position of paned separator in pixels (0 means all the way to the left/top)"),
0, G_MAXINT, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
paned_props[PROP_POSITION_SET] =
g_param_spec_boolean ("position-set",
P_("Position Set"),
P_("TRUE if the Position property should be used"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:min-position:
*
* The smallest possible value for the position property.
* This property is derived from the size and shrinkability
* of the widget's children.
*/
paned_props[PROP_MIN_POSITION] =
g_param_spec_int ("min-position",
P_("Minimal Position"),
P_("Smallest possible value for the “position” property"),
0, G_MAXINT, 0,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:max-position:
*
* The largest possible value for the position property.
* This property is derived from the size and shrinkability
* of the widget's children.
*/
paned_props[PROP_MAX_POSITION] =
g_param_spec_int ("max-position",
P_("Maximal Position"),
P_("Largest possible value for the “position” property"),
0, G_MAXINT, G_MAXINT,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:wide-handle:
*
* Setting this property to %TRUE indicates that the paned needs
* to provide stronger visual separation (e.g. because it separates
* between two notebooks, whose tab rows would otherwise merge visually).
*/
paned_props[PROP_WIDE_HANDLE] =
g_param_spec_boolean ("wide-handle",
P_("Wide Handle"),
P_("Whether the paned should have a prominent handle"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:resize-start-child:
*
* The "resize-start-child" property determines whether the first child expands and
* shrinks along with the paned widget.
*/
paned_props[PROP_RESIZE_START_CHILD] =
g_param_spec_boolean ("resize-start-child",
P_("Resize first child"),
P_("If TRUE, the first child expands and shrinks along with the paned widget"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:resize-end-child:
*
* The "resize-end-child" property determines whether the second child expands and
* shrinks along with the paned widget.
*/
paned_props[PROP_RESIZE_END_CHILD] =
g_param_spec_boolean ("resize-end-child",
P_("Resize second child"),
P_("If TRUE, the second child expands and shrinks along with the paned widget"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:shrink-start-child:
*
* The "shrink-start-child" property determines whether the first child can be made
* smaller than its requisition.
*/
paned_props[PROP_SHRINK_START_CHILD] =
g_param_spec_boolean ("shrink-start-child",
P_("Shrink first child"),
P_("If TRUE, the first child can be made smaller than its requisition"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkPaned:shrink-end-child:
*
* The "shrink-end-child" property determines whether the second child can be made
* smaller than its requisition.
*/
paned_props[PROP_SHRINK_END_CHILD] =
g_param_spec_boolean ("shrink-end-child",
P_("Shrink second child"),
P_("If TRUE, the second child can be made smaller than its requisition"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
paned_props[PROP_START_CHILD] =
g_param_spec_object ("start-child",
P_("First child"),
P_("The first child"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
paned_props[PROP_END_CHILD] =
g_param_spec_object ("end-child",
P_("Second child"),
P_("The second child"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
g_object_class_install_properties (object_class, LAST_PROP, paned_props);
g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation");
/**
* GtkPaned::cycle-child-focus:
* @widget: the object that received the signal
* @reversed: whether cycling backward or forward
*
* The ::cycle-child-focus signal is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to cycle the focus between the children of the paned.
*
* The default binding is f6.
*/
signals [CYCLE_CHILD_FOCUS] =
g_signal_new (I_("cycle-child-focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cycle_child_focus),
NULL, NULL,
_gtk_marshal_BOOLEAN__BOOLEAN,
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
/**
* GtkPaned::toggle-handle-focus:
* @widget: the object that received the signal
*
* The ::toggle-handle-focus is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to accept the current position of the handle and then
* move focus to the next widget in the focus chain.
*
* The default binding is Tab.
*/
signals [TOGGLE_HANDLE_FOCUS] =
g_signal_new (I_("toggle-handle-focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, toggle_handle_focus),
NULL, NULL,
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/**
* GtkPaned::move-handle:
* @widget: the object that received the signal
* @scroll_type: a #GtkScrollType
*
* The ::move-handle signal is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to move the handle when the user is using key bindings
* to move it.
*/
signals[MOVE_HANDLE] =
g_signal_new (I_("move-handle"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, move_handle),
NULL, NULL,
_gtk_marshal_BOOLEAN__ENUM,
G_TYPE_BOOLEAN, 1,
GTK_TYPE_SCROLL_TYPE);
/**
* GtkPaned::cycle-handle-focus:
* @widget: the object that received the signal
* @reversed: whether cycling backward or forward
*
* The ::cycle-handle-focus signal is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to cycle whether the paned should grab focus to allow
* the user to change position of the handle by using key bindings.
*
* The default binding for this signal is f8.
*/
signals [CYCLE_HANDLE_FOCUS] =
g_signal_new (I_("cycle-handle-focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cycle_handle_focus),
NULL, NULL,
_gtk_marshal_BOOLEAN__BOOLEAN,
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
/**
* GtkPaned::accept-position:
* @widget: the object that received the signal
*
* The ::accept-position signal is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to accept the current position of the handle when
* moving it using key bindings.
*
* The default binding for this signal is Return or Space.
*/
signals [ACCEPT_POSITION] =
g_signal_new (I_("accept-position"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, accept_position),
NULL, NULL,
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/**
* GtkPaned::cancel-position:
* @widget: the object that received the signal
*
* The ::cancel-position signal is a
* [keybinding signal][GtkBindingSignal]
* which gets emitted to cancel moving the position of the handle using key
* bindings. The position of the handle will be reset to the value prior to
* moving it.
*
* The default binding for this signal is Escape.
*/
signals [CANCEL_POSITION] =
g_signal_new (I_("cancel-position"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cancel_position),
NULL, NULL,
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
/* F6 and friends */
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_F6, 0,
"cycle-child-focus",
"(b)", FALSE);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_F6, GDK_SHIFT_MASK,
"cycle-child-focus",
"(b)", TRUE);
/* F8 and friends */
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_F8, 0,
"cycle-handle-focus",
"(b)", FALSE);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_F8, GDK_SHIFT_MASK,
"cycle-handle-focus",
"(b)", TRUE);
add_tab_bindings (widget_class, 0);
add_tab_bindings (widget_class, GDK_CONTROL_MASK);
add_tab_bindings (widget_class, GDK_SHIFT_MASK);
add_tab_bindings (widget_class, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
/* accept and cancel positions */
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_Escape, 0,
"cancel-position",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_Return, 0,
"accept-position",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_ISO_Enter, 0,
"accept-position",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_KP_Enter, 0,
"accept-position",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_space, 0,
"accept-position",
NULL);
gtk_widget_class_add_binding_signal (widget_class,
GDK_KEY_KP_Space, 0,
"accept-position",
NULL);
/* move handle */
add_move_binding (widget_class, GDK_KEY_Left, 0, GTK_SCROLL_STEP_LEFT);
add_move_binding (widget_class, GDK_KEY_KP_Left, 0, GTK_SCROLL_STEP_LEFT);
add_move_binding (widget_class, GDK_KEY_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
add_move_binding (widget_class, GDK_KEY_KP_Left, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_LEFT);
add_move_binding (widget_class, GDK_KEY_Right, 0, GTK_SCROLL_STEP_RIGHT);
add_move_binding (widget_class, GDK_KEY_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
add_move_binding (widget_class, GDK_KEY_KP_Right, 0, GTK_SCROLL_STEP_RIGHT);
add_move_binding (widget_class, GDK_KEY_KP_Right, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_RIGHT);
add_move_binding (widget_class, GDK_KEY_Up, 0, GTK_SCROLL_STEP_UP);
add_move_binding (widget_class, GDK_KEY_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
add_move_binding (widget_class, GDK_KEY_KP_Up, 0, GTK_SCROLL_STEP_UP);
add_move_binding (widget_class, GDK_KEY_KP_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_UP);
add_move_binding (widget_class, GDK_KEY_Page_Up, 0, GTK_SCROLL_PAGE_UP);
add_move_binding (widget_class, GDK_KEY_KP_Page_Up, 0, GTK_SCROLL_PAGE_UP);
add_move_binding (widget_class, GDK_KEY_Down, 0, GTK_SCROLL_STEP_DOWN);
add_move_binding (widget_class, GDK_KEY_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
add_move_binding (widget_class, GDK_KEY_KP_Down, 0, GTK_SCROLL_STEP_DOWN);
add_move_binding (widget_class, GDK_KEY_KP_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_DOWN);
add_move_binding (widget_class, GDK_KEY_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
add_move_binding (widget_class, GDK_KEY_KP_Page_Down, 0, GTK_SCROLL_PAGE_RIGHT);
add_move_binding (widget_class, GDK_KEY_Home, 0, GTK_SCROLL_START);
add_move_binding (widget_class, GDK_KEY_KP_Home, 0, GTK_SCROLL_START);
add_move_binding (widget_class, GDK_KEY_End, 0, GTK_SCROLL_END);
add_move_binding (widget_class, GDK_KEY_KP_End, 0, GTK_SCROLL_END);
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_PANED_ACCESSIBLE);
gtk_widget_class_set_css_name (widget_class, I_("paned"));
}
static GtkBuildableIface *parent_buildable_iface;
static void
gtk_paned_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *type)
{
GtkPaned *self = GTK_PANED (buildable);
if (g_strcmp0 (type, "start") == 0)
{
gtk_paned_set_start_child (self, GTK_WIDGET (child));
gtk_paned_set_resize_start_child (self, FALSE);
gtk_paned_set_shrink_start_child (self, TRUE);
}
else if (g_strcmp0 (type, "end") == 0)
{
gtk_paned_set_end_child (self, GTK_WIDGET (child));
gtk_paned_set_resize_end_child (self, TRUE);
gtk_paned_set_shrink_end_child (self, TRUE);
}
else if (type == NULL && GTK_IS_WIDGET (child))
{
if (self->start_child == NULL)
{
gtk_paned_set_start_child (self, GTK_WIDGET (child));
gtk_paned_set_resize_start_child (self, FALSE);
gtk_paned_set_shrink_start_child (self, TRUE);
}
else if (self->end_child == NULL)
{
gtk_paned_set_end_child (self, GTK_WIDGET (child));
gtk_paned_set_resize_end_child (self, TRUE);
gtk_paned_set_shrink_end_child (self, TRUE);
}
else
g_warning ("GtkPaned only accepts two widgets as children");
}
else
parent_buildable_iface->add_child (buildable, builder, child, type);
}
static void
gtk_paned_buildable_iface_init (GtkBuildableIface *iface)
{
parent_buildable_iface = g_type_interface_peek_parent (iface);
iface->add_child = gtk_paned_buildable_add_child;
}
static gboolean
initiates_touch_drag (GtkPaned *paned,
gdouble start_x,
gdouble start_y)
{
int handle_size, handle_pos, drag_pos;
graphene_rect_t handle_area;
#define TOUCH_EXTRA_AREA_WIDTH 50
get_handle_area (paned, &handle_area);
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
{
handle_pos = handle_area.origin.x;
drag_pos = start_x;
handle_size = handle_area.size.width;
}
else
{
handle_pos = handle_area.origin.y;
drag_pos = start_y;
handle_size = handle_area.size.height;
}
if (drag_pos < handle_pos - TOUCH_EXTRA_AREA_WIDTH ||
drag_pos > handle_pos + handle_size + TOUCH_EXTRA_AREA_WIDTH)
return FALSE;
#undef TOUCH_EXTRA_AREA_WIDTH
return TRUE;
}
static void
gesture_drag_begin_cb (GtkGestureDrag *gesture,
gdouble start_x,
gdouble start_y,
GtkPaned *paned)
{
GdkEventSequence *sequence;
graphene_rect_t handle_area;
GdkEvent *event;
GdkDevice *device;
gboolean is_touch;
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
device = gdk_event_get_source_device (event);
paned->panning = FALSE;
is_touch = (gdk_event_get_event_type (event) == GDK_TOUCH_BEGIN ||
gdk_device_get_source (device) == GDK_SOURCE_TOUCHSCREEN);
get_handle_area (paned, &handle_area);
if ((is_touch && GTK_GESTURE (gesture) == paned->drag_gesture) ||
(!is_touch && GTK_GESTURE (gesture) == paned->pan_gesture))
{
gtk_gesture_set_state (GTK_GESTURE (gesture),
GTK_EVENT_SEQUENCE_DENIED);
return;
}
if (graphene_rect_contains_point (&handle_area, &(graphene_point_t){start_x, start_y}) ||
(is_touch && initiates_touch_drag (paned, start_x, start_y)))
{
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
paned->drag_pos = start_x - handle_area.origin.x;
else
paned->drag_pos = start_y - handle_area.origin.y;
paned->panning = TRUE;
gtk_gesture_set_state (GTK_GESTURE (gesture),
GTK_EVENT_SEQUENCE_CLAIMED);
}
else
{
gtk_gesture_set_state (GTK_GESTURE (gesture),
GTK_EVENT_SEQUENCE_DENIED);
}
}
static void
gesture_drag_update_cb (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GtkPaned *paned)
{
gdouble start_x, start_y;
gtk_gesture_drag_get_start_point (GTK_GESTURE_DRAG (gesture),
&start_x, &start_y);
update_drag (paned, start_x + offset_x, start_y + offset_y);
}
static void
gesture_drag_end_cb (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GtkPaned *paned)
{
if (!paned->panning)
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
paned->panning = FALSE;
}
static void
gtk_paned_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkPaned *paned = GTK_PANED (object);
switch (prop_id)
{
case PROP_ORIENTATION:
gtk_paned_set_orientation (paned, g_value_get_enum (value));
break;
case PROP_POSITION:
gtk_paned_set_position (paned, g_value_get_int (value));
break;
case PROP_POSITION_SET:
if (paned->position_set != g_value_get_boolean (value))
{
paned->position_set = g_value_get_boolean (value);
gtk_widget_queue_resize (GTK_WIDGET (paned));
g_object_notify_by_pspec (object, pspec);
}
break;
case PROP_WIDE_HANDLE:
gtk_paned_set_wide_handle (paned, g_value_get_boolean (value));
break;
case PROP_RESIZE_START_CHILD:
gtk_paned_set_resize_start_child (paned, g_value_get_boolean (value));
break;
case PROP_RESIZE_END_CHILD:
gtk_paned_set_resize_end_child (paned, g_value_get_boolean (value));
break;
case PROP_SHRINK_START_CHILD:
gtk_paned_set_shrink_start_child (paned, g_value_get_boolean (value));
break;
case PROP_SHRINK_END_CHILD:
gtk_paned_set_shrink_end_child (paned, g_value_get_boolean (value));
break;
case PROP_START_CHILD:
gtk_paned_set_start_child (paned, g_value_get_object (value));
break;
case PROP_END_CHILD:
gtk_paned_set_end_child (paned, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_paned_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkPaned *paned = GTK_PANED (object);
switch (prop_id)
{
case PROP_ORIENTATION:
g_value_set_enum (value, paned->orientation);
break;
case PROP_POSITION:
g_value_set_int (value, paned->start_child_size);
break;
case PROP_POSITION_SET:
g_value_set_boolean (value, paned->position_set);
break;
case PROP_MIN_POSITION:
g_value_set_int (value, paned->min_position);
break;
case PROP_MAX_POSITION:
g_value_set_int (value, paned->max_position);
break;
case PROP_WIDE_HANDLE:
g_value_set_boolean (value, gtk_paned_get_wide_handle (paned));
break;
case PROP_RESIZE_START_CHILD:
g_value_set_boolean (value, paned->resize_start_child);
break;
case PROP_RESIZE_END_CHILD:
g_value_set_boolean (value, paned->resize_end_child);
break;
case PROP_SHRINK_START_CHILD:
g_value_set_boolean (value, paned->shrink_start_child);
break;
case PROP_SHRINK_END_CHILD:
g_value_set_boolean (value, paned->shrink_end_child);
break;
case PROP_START_CHILD:
g_value_set_object (value, gtk_paned_get_start_child (paned));
break;
case PROP_END_CHILD:
g_value_set_object (value, gtk_paned_get_end_child (paned));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_paned_dispose (GObject *object)
{
GtkPaned *paned = GTK_PANED (object);
gtk_paned_set_saved_focus (paned, NULL);
gtk_paned_set_first_paned (paned, NULL);
g_clear_pointer (&paned->start_child, gtk_widget_unparent);
g_clear_pointer (&paned->end_child, gtk_widget_unparent);
g_clear_pointer (&paned->handle_widget, gtk_widget_unparent);
G_OBJECT_CLASS (gtk_paned_parent_class)->dispose (object);
}
static void
gtk_paned_compute_position (GtkPaned *paned,
gint allocation,
gint start_child_req,
gint end_child_req,
gint *min_pos,
gint *max_pos,
gint *out_pos)
{
gint min, max, pos;
min = paned->shrink_start_child ? 0 : start_child_req;
max = allocation;
if (!paned->shrink_end_child)
max = MAX (1, max - end_child_req);
max = MAX (min, max);
if (!paned->position_set)
{
if (paned->resize_start_child && !paned->resize_end_child)
pos = MAX (0, allocation - end_child_req);
else if (!paned->resize_start_child && paned->resize_end_child)
pos = start_child_req;
else if (start_child_req + end_child_req != 0)
pos = allocation * ((gdouble)start_child_req / (start_child_req + end_child_req)) + 0.5;
else
pos = allocation * 0.5 + 0.5;
}
else
{
/* If the position was set before the initial allocation.
* (paned->last_allocation <= 0) just clamp it and leave it.
*/
if (paned->last_allocation > 0)
{
if (paned->resize_start_child && !paned->resize_end_child)
pos = paned->start_child_size + allocation - paned->last_allocation;
else if (!(!paned->resize_start_child && paned->resize_end_child))
pos = allocation * ((gdouble) paned->start_child_size / (paned->last_allocation)) + 0.5;
else
pos = paned->start_child_size;
}
else
pos = paned->start_child_size;
}
pos = CLAMP (pos, min, max);
if (min_pos)
*min_pos = min;
if (max_pos)
*max_pos = max;
if (out_pos)
*out_pos = pos;
}
static void
gtk_paned_get_preferred_size_for_orientation (GtkWidget *widget,
gint size,
gint *minimum,
gint *natural)
{
GtkPaned *paned = GTK_PANED (widget);
gint child_min, child_nat;
*minimum = *natural = 0;
if (paned->start_child && gtk_widget_get_visible (paned->start_child))
{
gtk_widget_measure (paned->start_child, paned->orientation, size, &child_min, &child_nat, NULL, NULL);
if (paned->shrink_start_child)
*minimum = 0;
else
*minimum = child_min;
*natural = child_nat;
}
if (paned->end_child && gtk_widget_get_visible (paned->end_child))
{
gtk_widget_measure (paned->end_child, paned->orientation, size, &child_min, &child_nat, NULL, NULL);
if (!paned->shrink_end_child)
*minimum += child_min;
*natural += child_nat;
}
if (paned->start_child && gtk_widget_get_visible (paned->start_child) &&
paned->end_child && gtk_widget_get_visible (paned->end_child))
{
gint handle_size;
gtk_widget_measure (paned->handle_widget,
paned->orientation,
-1,
NULL, &handle_size,
NULL, NULL);
*minimum += handle_size;
*natural += handle_size;
}
}
static void
gtk_paned_get_preferred_size_for_opposite_orientation (GtkWidget *widget,
gint size,
gint *minimum,
gint *natural)
{
GtkPaned *paned = GTK_PANED (widget);
gint for_start_child, for_end_child;
gint child_min, child_nat;
if (size > -1 &&
paned->start_child && gtk_widget_get_visible (paned->start_child) &&
paned->end_child && gtk_widget_get_visible (paned->end_child))
{
gint start_child_req, end_child_req;
gint handle_size;
gtk_widget_measure (paned->handle_widget,
OPPOSITE_ORIENTATION (paned->orientation),
-1,
NULL, &handle_size,
NULL, NULL);
gtk_widget_measure (paned->start_child, paned->orientation, -1, &start_child_req, NULL, NULL, NULL);
gtk_widget_measure (paned->end_child, paned->orientation, -1, &end_child_req, NULL, NULL, NULL);
gtk_paned_compute_position (paned,
size - handle_size, start_child_req, end_child_req,
NULL, NULL, &for_start_child);
for_end_child = size - for_start_child - handle_size;
}
else
{
for_start_child = size;
for_end_child = size;
}
*minimum = *natural = 0;
if (paned->start_child && gtk_widget_get_visible (paned->start_child))
{
gtk_widget_measure (paned->start_child,
OPPOSITE_ORIENTATION (paned->orientation),
for_start_child,
&child_min, &child_nat,
NULL, NULL);
*minimum = child_min;
*natural = child_nat;
}
if (paned->end_child && gtk_widget_get_visible (paned->end_child))
{
gtk_widget_measure (paned->end_child,
OPPOSITE_ORIENTATION (paned->orientation),
for_end_child,
&child_min, &child_nat,
NULL, NULL);
*minimum = MAX (*minimum, child_min);
*natural = MAX (*natural, child_nat);
}
}
static void
gtk_paned_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GtkPaned *paned = GTK_PANED (widget);
if (orientation == paned->orientation)
gtk_paned_get_preferred_size_for_orientation (widget, for_size, minimum, natural);
else
gtk_paned_get_preferred_size_for_opposite_orientation (widget, for_size, minimum, natural);
}
static void
flip_child (int width,
GtkAllocation *child_pos)
{
child_pos->x = width - child_pos->x - child_pos->width;
}
static void
gtk_paned_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
{
GtkPaned *paned = GTK_PANED (widget);
if (paned->start_child && gtk_widget_get_visible (paned->start_child) &&
paned->end_child && gtk_widget_get_visible (paned->end_child))
{
GtkAllocation start_child_allocation;
GtkAllocation end_child_allocation;
GtkAllocation handle_allocation;
gint handle_size;
gtk_widget_measure (paned->handle_widget,
paned->orientation,
-1,
NULL, &handle_size,
NULL, NULL);
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
{
gint start_child_width, end_child_width;
gtk_widget_measure (paned->start_child, GTK_ORIENTATION_HORIZONTAL,
height,
&start_child_width, NULL, NULL, NULL);
gtk_widget_measure (paned->end_child, GTK_ORIENTATION_HORIZONTAL,
height,
&end_child_width, NULL, NULL, NULL);
gtk_paned_calc_position (paned,
MAX (1, width - handle_size),
start_child_width,
end_child_width);
handle_allocation = (GdkRectangle){
paned->start_child_size,
0,
handle_size,
height
};
start_child_allocation.height = end_child_allocation.height = height;
start_child_allocation.width = MAX (1, paned->start_child_size);
start_child_allocation.x = 0;
start_child_allocation.y = end_child_allocation.y = 0;
end_child_allocation.x = start_child_allocation.x + paned->start_child_size + handle_size;
end_child_allocation.width = MAX (1, width - paned->start_child_size - handle_size);
if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL)
{
flip_child (width, &(end_child_allocation));
flip_child (width, &(start_child_allocation));
flip_child (width, &(handle_allocation));
}
if (start_child_width > start_child_allocation.width)
{
if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_LTR)
start_child_allocation.x -= start_child_width - start_child_allocation.width;
start_child_allocation.width = start_child_width;
}
if (end_child_width > end_child_allocation.width)
{
if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL)
end_child_allocation.x -= end_child_width - end_child_allocation.width;
end_child_allocation.width = end_child_width;
}
}
else
{
gint start_child_height, end_child_height;
gtk_widget_measure (paned->start_child, GTK_ORIENTATION_VERTICAL,
width,
&start_child_height, NULL, NULL, NULL);
gtk_widget_measure (paned->end_child, GTK_ORIENTATION_VERTICAL,
width,
&end_child_height, NULL, NULL, NULL);
gtk_paned_calc_position (paned,
MAX (1, height - handle_size),
start_child_height,
end_child_height);
handle_allocation = (GdkRectangle){
0,
paned->start_child_size,
width,
handle_size,
};
start_child_allocation.width = end_child_allocation.width = width;
start_child_allocation.height = MAX (1, paned->start_child_size);
start_child_allocation.x = end_child_allocation.x = 0;
start_child_allocation.y = 0;
end_child_allocation.y = start_child_allocation.y + paned->start_child_size + handle_size;
end_child_allocation.height = MAX (1, height - end_child_allocation.y);
if (start_child_height > start_child_allocation.height)
{
start_child_allocation.y -= start_child_height - start_child_allocation.height;
start_child_allocation.height = start_child_height;
}
if (end_child_height > end_child_allocation.height)
end_child_allocation.height = end_child_height;
}
gtk_widget_set_child_visible (paned->handle_widget, TRUE);
gtk_widget_size_allocate (paned->handle_widget, &handle_allocation, -1);
gtk_widget_size_allocate (paned->start_child, &start_child_allocation, -1);
gtk_widget_size_allocate (paned->end_child, &end_child_allocation, -1);
}
else
{
if (paned->start_child && gtk_widget_get_visible (paned->start_child))
{
gtk_widget_set_child_visible (paned->start_child, TRUE);
gtk_widget_size_allocate (paned->start_child,
&(GtkAllocation) {0, 0, width, height}, -1);
}
else if (paned->end_child && gtk_widget_get_visible (paned->end_child))
{
gtk_widget_set_child_visible (paned->end_child, TRUE);
gtk_widget_size_allocate (paned->end_child,
&(GtkAllocation) {0, 0, width, height}, -1);
}
gtk_widget_set_child_visible (paned->handle_widget, FALSE);
}
}
static void
gtk_paned_unrealize (GtkWidget *widget)
{
GtkPaned *paned = GTK_PANED (widget);
gtk_paned_set_last_start_child_focus (paned, NULL);
gtk_paned_set_last_end_child_focus (paned, NULL);
gtk_paned_set_saved_focus (paned, NULL);
gtk_paned_set_first_paned (paned, NULL);
GTK_WIDGET_CLASS (gtk_paned_parent_class)->unrealize (widget);
}
static void
gtk_paned_render_handle (GtkGizmo *gizmo,
GtkSnapshot *snapshot)
{
GtkWidget *widget = GTK_WIDGET (gizmo);
GtkCssStyle *style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
int width, height;
width = gtk_widget_get_width (widget);
height = gtk_widget_get_height (widget);
if (width > 0 && height > 0)
gtk_css_style_snapshot_icon (style, snapshot, width, height);
}
static void
connect_drag_gesture_signals (GtkPaned *paned,
GtkGesture *gesture)
{
g_signal_connect (gesture, "drag-begin",
G_CALLBACK (gesture_drag_begin_cb), paned);
g_signal_connect (gesture, "drag-update",
G_CALLBACK (gesture_drag_update_cb), paned);
g_signal_connect (gesture, "drag-end",
G_CALLBACK (gesture_drag_end_cb), paned);
}
static void
gtk_paned_init (GtkPaned *paned)
{
GtkGesture *gesture;
gtk_widget_set_focusable (GTK_WIDGET (paned), TRUE);
gtk_widget_set_overflow (GTK_WIDGET (paned), GTK_OVERFLOW_HIDDEN);
paned->orientation = GTK_ORIENTATION_HORIZONTAL;
paned->start_child = NULL;
paned->end_child = NULL;
paned->position_set = FALSE;
paned->last_allocation = -1;
paned->last_start_child_focus = NULL;
paned->last_end_child_focus = NULL;
paned->in_recursion = FALSE;
paned->original_position = -1;
paned->max_position = G_MAXINT;
paned->resize_start_child = TRUE;
paned->resize_end_child = TRUE;
paned->shrink_start_child = TRUE;
paned->shrink_end_child = TRUE;
gtk_widget_update_orientation (GTK_WIDGET (paned), paned->orientation);
/* Touch gesture */
gesture = gtk_gesture_pan_new (GTK_ORIENTATION_HORIZONTAL);
connect_drag_gesture_signals (paned, gesture);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), TRUE);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_CAPTURE);
gtk_widget_add_controller (GTK_WIDGET (paned), GTK_EVENT_CONTROLLER (gesture));
paned->pan_gesture = gesture;
/* Pointer gesture */
gesture = gtk_gesture_drag_new ();
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
GTK_PHASE_CAPTURE);
connect_drag_gesture_signals (paned, gesture);
gtk_widget_add_controller (GTK_WIDGET (paned), GTK_EVENT_CONTROLLER (gesture));
paned->drag_gesture = gesture;
paned->handle_widget = gtk_gizmo_new ("separator", NULL, NULL, gtk_paned_render_handle, gtk_paned_handle_contains, NULL, NULL);
gtk_widget_set_parent (paned->handle_widget, GTK_WIDGET (paned));
gtk_widget_set_cursor_from_name (paned->handle_widget, "col-resize");
}
static gboolean
is_rtl (GtkPaned *paned)
{
return paned->orientation == GTK_ORIENTATION_HORIZONTAL &&
gtk_widget_get_direction (GTK_WIDGET (paned)) == GTK_TEXT_DIR_RTL;
}
static void
update_drag (GtkPaned *paned,
int xpos,
int ypos)
{
gint pos;
gint handle_size;
gint size;
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
pos = xpos;
else
pos = ypos;
pos -= paned->drag_pos;
if (is_rtl (paned))
{
gtk_widget_measure (paned->handle_widget,
GTK_ORIENTATION_HORIZONTAL,
-1,
NULL, &handle_size,
NULL, NULL);
size = gtk_widget_get_width (GTK_WIDGET (paned)) - pos - handle_size;
}
else
{
size = pos;
}
size = CLAMP (size, paned->min_position, paned->max_position);
if (size != paned->start_child_size)
gtk_paned_set_position (paned, size);
}
static void
gtk_paned_css_changed (GtkWidget *widget,
GtkCssStyleChange *change)
{
GTK_WIDGET_CLASS (gtk_paned_parent_class)->css_changed (widget, change);
if (change == NULL ||
gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_ICON_SIZE))
{
gtk_widget_queue_resize (widget);
}
else if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_ICON_TEXTURE) ||
gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_ICON_REDRAW))
{
gtk_widget_queue_draw (widget);
}
}
/**
* gtk_paned_new:
* @orientation: the paned’s orientation.
*
* Creates a new #GtkPaned widget.
*
* Returns: a new #GtkPaned.
**/
GtkWidget *
gtk_paned_new (GtkOrientation orientation)
{
return g_object_new (GTK_TYPE_PANED,
"orientation", orientation,
NULL);
}
void
gtk_paned_set_start_child (GtkPaned *paned,
GtkWidget *child)
{
g_return_if_fail (GTK_IS_PANED (paned));
g_return_if_fail (child == NULL || GTK_IS_WIDGET (child));
g_clear_pointer (&paned->start_child, gtk_widget_unparent);
if (child)
{
paned->start_child = child;
gtk_widget_insert_before (child, GTK_WIDGET (paned), paned->handle_widget);
}
g_object_notify (G_OBJECT (paned), "start-child");
}
/**
* gtk_paned_get_start_child:
* @paned: a #GtkPaned
*
* Retrieves the start child of the given #GtkPaned.
*
* See also: #GtkPaned:start-child
*
* Returns: (transfer none) (nullable): the start child widget
*/
GtkWidget *
gtk_paned_get_start_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), NULL);
return paned->start_child;
}
void
gtk_paned_set_resize_start_child (GtkPaned *paned,
gboolean resize)
{
g_return_if_fail (GTK_IS_PANED (paned));
if (paned->resize_start_child == resize)
return;
paned->resize_start_child = resize;
g_object_notify (G_OBJECT (paned), "resize-start-child");
}
gboolean
gtk_paned_get_resize_start_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), FALSE);
return paned->resize_start_child;
}
void
gtk_paned_set_shrink_start_child (GtkPaned *paned,
gboolean shrink)
{
g_return_if_fail (GTK_IS_PANED (paned));
if (paned->shrink_start_child == shrink)
return;
paned->shrink_start_child = shrink;
g_object_notify (G_OBJECT (paned), "shrink-start-child");
}
gboolean
gtk_paned_get_shrink_start_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), FALSE);
return paned->shrink_start_child;
}
/**
* gtk_paned_get_end_child:
* @paned: a #GtkPaned
*
* Retrieves the end child of the given #GtkPaned.
*
* See also: #GtkPaned:end-child
*
* Returns: (transfer none) (nullable): the end child widget
*/
void
gtk_paned_set_end_child (GtkPaned *paned,
GtkWidget *child)
{
g_return_if_fail (GTK_IS_PANED (paned));
g_return_if_fail (child == NULL || GTK_IS_WIDGET (child));
g_clear_pointer (&paned->end_child, gtk_widget_unparent);
if (child)
{
paned->end_child = child;
gtk_widget_insert_after (child, GTK_WIDGET (paned), paned->handle_widget);
}
g_object_notify (G_OBJECT (paned), "end-child");
}
GtkWidget *
gtk_paned_get_end_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), NULL);
return paned->end_child;
}
void
gtk_paned_set_resize_end_child (GtkPaned *paned,
gboolean resize)
{
g_return_if_fail (GTK_IS_PANED (paned));
if (paned->resize_end_child == resize)
return;
paned->resize_end_child = resize;
g_object_notify (G_OBJECT (paned), "resize-end-child");
}
gboolean
gtk_paned_get_resize_end_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), FALSE);
return paned->resize_end_child;
}
void
gtk_paned_set_shrink_end_child (GtkPaned *paned,
gboolean shrink)
{
g_return_if_fail (GTK_IS_PANED (paned));
if (paned->shrink_end_child == shrink)
return;
paned->shrink_end_child = shrink;
g_object_notify (G_OBJECT (paned), "shrink-end-child");
}
gboolean
gtk_paned_get_shrink_end_child (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), FALSE);
return paned->shrink_end_child;
}
/**
* gtk_paned_get_position:
* @paned: a #GtkPaned widget
*
* Obtains the position of the divider between the two panes.
*
* Returns: position of the divider
**/
gint
gtk_paned_get_position (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), 0);
return paned->start_child_size;
}
/**
* gtk_paned_set_position:
* @paned: a #GtkPaned widget
* @position: pixel position of divider, a negative value means that the position
* is unset.
*
* Sets the position of the divider between the two panes.
**/
void
gtk_paned_set_position (GtkPaned *paned,
gint position)
{
g_return_if_fail (GTK_IS_PANED (paned));
g_object_freeze_notify (G_OBJECT (paned));
if (position >= 0)
{
/* We don't clamp here - the assumption is that
* if the total allocation changes at the same time
* as the position, the position set is with reference
* to the new total size. If only the position changes,
* then clamping will occur in gtk_paned_calc_position()
*/
if (!paned->position_set)
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_POSITION_SET]);
if (paned->start_child_size != position)
{
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_POSITION]);
gtk_widget_queue_allocate (GTK_WIDGET (paned));
}
paned->start_child_size = position;
paned->position_set = TRUE;
}
else
{
if (paned->position_set)
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_POSITION_SET]);
paned->position_set = FALSE;
}
g_object_thaw_notify (G_OBJECT (paned));
#ifdef G_OS_WIN32
/* Hacky work-around for bug #144269 */
if (paned->end_child != NULL)
{
gtk_widget_queue_draw (paned->end_child);
}
#endif
}
static void
gtk_paned_calc_position (GtkPaned *paned,
gint allocation,
gint start_child_req,
gint end_child_req)
{
gint old_position;
gint old_min_position;
gint old_max_position;
old_position = paned->start_child_size;
old_min_position = paned->min_position;
old_max_position = paned->max_position;
gtk_paned_compute_position (paned,
allocation, start_child_req, end_child_req,
&paned->min_position, &paned->max_position,
&paned->start_child_size);
gtk_widget_set_child_visible (paned->start_child, paned->start_child_size != 0);
gtk_widget_set_child_visible (paned->end_child, paned->start_child_size != allocation);
g_object_freeze_notify (G_OBJECT (paned));
if (paned->start_child_size != old_position)
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_POSITION]);
if (paned->min_position != old_min_position)
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_MIN_POSITION]);
if (paned->max_position != old_max_position)
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_MAX_POSITION]);
g_object_thaw_notify (G_OBJECT (paned));
paned->last_allocation = allocation;
}
static void
gtk_paned_set_saved_focus (GtkPaned *paned, GtkWidget *widget)
{
if (paned->saved_focus)
g_object_remove_weak_pointer (G_OBJECT (paned->saved_focus),
(gpointer *)&(paned->saved_focus));
paned->saved_focus = widget;
if (paned->saved_focus)
g_object_add_weak_pointer (G_OBJECT (paned->saved_focus),
(gpointer *)&(paned->saved_focus));
}
static void
gtk_paned_set_first_paned (GtkPaned *paned, GtkPaned *first_paned)
{
if (paned->first_paned)
g_object_remove_weak_pointer (G_OBJECT (paned->first_paned),
(gpointer *)&(paned->first_paned));
paned->first_paned = first_paned;
if (paned->first_paned)
g_object_add_weak_pointer (G_OBJECT (paned->first_paned),
(gpointer *)&(paned->first_paned));
}
static void
gtk_paned_set_last_start_child_focus (GtkPaned *paned, GtkWidget *widget)
{
if (paned->last_start_child_focus)
g_object_remove_weak_pointer (G_OBJECT (paned->last_start_child_focus),
(gpointer *)&(paned->last_start_child_focus));
paned->last_start_child_focus = widget;
if (paned->last_start_child_focus)
g_object_add_weak_pointer (G_OBJECT (paned->last_start_child_focus),
(gpointer *)&(paned->last_start_child_focus));
}
static void
gtk_paned_set_last_end_child_focus (GtkPaned *paned, GtkWidget *widget)
{
if (paned->last_end_child_focus)
g_object_remove_weak_pointer (G_OBJECT (paned->last_end_child_focus),
(gpointer *)&(paned->last_end_child_focus));
paned->last_end_child_focus = widget;
if (paned->last_end_child_focus)
g_object_add_weak_pointer (G_OBJECT (paned->last_end_child_focus),
(gpointer *)&(paned->last_end_child_focus));
}
static GtkWidget *
paned_get_focus_widget (GtkPaned *paned)
{
GtkWidget *toplevel;
toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (paned)));
if (GTK_IS_WINDOW (toplevel))
return gtk_window_get_focus (GTK_WINDOW (toplevel));
return NULL;
}
static void
gtk_paned_set_focus_child (GtkWidget *widget,
GtkWidget *child)
{
GtkPaned *paned = GTK_PANED (widget);
GtkWidget *focus_child;
if (child == NULL)
{
GtkWidget *last_focus;
GtkWidget *w;
last_focus = paned_get_focus_widget (paned);
if (last_focus)
{
/* If there is one or more paned widgets between us and the
* focus widget, we want the topmost of those as last_focus
*/
for (w = last_focus; w != GTK_WIDGET (paned); w = gtk_widget_get_parent (w))
if (GTK_IS_PANED (w))
last_focus = w;
focus_child = gtk_widget_get_focus_child (widget);
if (focus_child == paned->start_child)
gtk_paned_set_last_start_child_focus (paned, last_focus);
else if (focus_child == paned->end_child)
gtk_paned_set_last_end_child_focus (paned, last_focus);
}
}
GTK_WIDGET_CLASS (gtk_paned_parent_class)->set_focus_child (widget, child);
}
static void
gtk_paned_get_cycle_chain (GtkPaned *paned,
GtkDirectionType direction,
GList **widgets)
{
GtkWidget *ancestor = NULL;
GtkWidget *focus_child;
GtkWidget *parent;
GtkWidget *widget = GTK_WIDGET (paned);
GList *temp_list = NULL;
GList *list;
if (paned->in_recursion)
return;
g_assert (widgets != NULL);
if (paned->last_start_child_focus &&
!gtk_widget_is_ancestor (paned->last_start_child_focus, widget))
{
gtk_paned_set_last_start_child_focus (paned, NULL);
}
if (paned->last_end_child_focus &&
!gtk_widget_is_ancestor (paned->last_end_child_focus, widget))
{
gtk_paned_set_last_end_child_focus (paned, NULL);
}
parent = gtk_widget_get_parent (widget);
if (parent)
ancestor = gtk_widget_get_ancestor (parent, GTK_TYPE_PANED);
/* The idea here is that temp_list is a list of widgets we want to cycle
* to. The list is prioritized so that the first element is our first
* choice, the next our second, and so on.
*
* We can't just use g_list_reverse(), because we want to try
* paned->last_child?_focus before paned->child?, both when we
* are going forward and backward.
*/
focus_child = gtk_widget_get_focus_child (GTK_WIDGET (paned));
if (direction == GTK_DIR_TAB_FORWARD)
{
if (focus_child == paned->start_child)
{
temp_list = g_list_append (temp_list, paned->last_end_child_focus);
temp_list = g_list_append (temp_list, paned->end_child);
temp_list = g_list_append (temp_list, ancestor);
}
else if (focus_child == paned->end_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list = g_list_append (temp_list, paned->last_start_child_focus);
temp_list = g_list_append (temp_list, paned->start_child);
}
else
{
temp_list = g_list_append (temp_list, paned->last_start_child_focus);
temp_list = g_list_append (temp_list, paned->start_child);
temp_list = g_list_append (temp_list, paned->last_end_child_focus);
temp_list = g_list_append (temp_list, paned->end_child);
temp_list = g_list_append (temp_list, ancestor);
}
}
else
{
if (focus_child == paned->start_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list = g_list_append (temp_list, paned->last_end_child_focus);
temp_list = g_list_append (temp_list, paned->end_child);
}
else if (focus_child == paned->end_child)
{
temp_list = g_list_append (temp_list, paned->last_start_child_focus);
temp_list = g_list_append (temp_list, paned->start_child);
temp_list = g_list_append (temp_list, ancestor);
}
else
{
temp_list = g_list_append (temp_list, paned->last_end_child_focus);
temp_list = g_list_append (temp_list, paned->end_child);
temp_list = g_list_append (temp_list, paned->last_start_child_focus);
temp_list = g_list_append (temp_list, paned->start_child);
temp_list = g_list_append (temp_list, ancestor);
}
}
/* Walk the list and expand all the paned widgets. */
for (list = temp_list; list != NULL; list = list->next)
{
widget = list->data;
if (widget)
{
if (GTK_IS_PANED (widget))
{
paned->in_recursion = TRUE;
gtk_paned_get_cycle_chain (GTK_PANED (widget), direction, widgets);
paned->in_recursion = FALSE;
}
else
{
*widgets = g_list_append (*widgets, widget);
}
}
}
g_list_free (temp_list);
}
static gboolean
gtk_paned_cycle_child_focus (GtkPaned *paned,
gboolean reversed)
{
GList *cycle_chain = NULL;
GList *list;
GtkDirectionType direction = reversed? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD;
/* ignore f6 if the handle is focused */
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
return TRUE;
/* we can't just let the event propagate up the hierarchy,
* because the paned will want to cycle focus _unless_ an
* ancestor paned handles the event
*/
gtk_paned_get_cycle_chain (paned, direction, &cycle_chain);
for (list = cycle_chain; list != NULL; list = list->next)
if (gtk_widget_child_focus (GTK_WIDGET (list->data), direction))
break;
g_list_free (cycle_chain);
return TRUE;
}
static void
get_child_panes (GtkWidget *widget,
GList **panes)
{
if (!widget || !gtk_widget_get_realized (widget))
return;
if (GTK_IS_PANED (widget))
{
GtkPaned *paned = GTK_PANED (widget);
get_child_panes (paned->start_child, panes);
*panes = g_list_prepend (*panes, widget);
get_child_panes (paned->end_child, panes);
}
else
{
GtkWidget *child;
for (child = gtk_widget_get_first_child (widget);
child != NULL;
child = gtk_widget_get_next_sibling (child))
get_child_panes (child, panes);
}
}
static GList *
get_all_panes (GtkPaned *paned)
{
GtkPaned *topmost = NULL;
GList *result = NULL;
GtkWidget *w;
for (w = GTK_WIDGET (paned); w != NULL; w = gtk_widget_get_parent (w))
{
if (GTK_IS_PANED (w))
topmost = GTK_PANED (w);
}
g_assert (topmost);
get_child_panes (GTK_WIDGET (topmost), &result);
return g_list_reverse (result);
}
static void
gtk_paned_find_neighbours (GtkPaned *paned,
GtkPaned **next,
GtkPaned **prev)
{
GList *all_panes;
GList *this_link;
all_panes = get_all_panes (paned);
g_assert (all_panes);
this_link = g_list_find (all_panes, paned);
g_assert (this_link);
if (this_link->next)
*next = this_link->next->data;
else
*next = all_panes->data;
if (this_link->prev)
*prev = this_link->prev->data;
else
*prev = g_list_last (all_panes)->data;
g_list_free (all_panes);
}
static gboolean
gtk_paned_move_handle (GtkPaned *paned,
GtkScrollType scroll)
{
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
gint old_position;
gint new_position;
gint increment;
enum {
SINGLE_STEP_SIZE = 1,
PAGE_STEP_SIZE = 75
};
new_position = old_position = gtk_paned_get_position (paned);
increment = 0;
switch (scroll)
{
case GTK_SCROLL_STEP_LEFT:
case GTK_SCROLL_STEP_UP:
case GTK_SCROLL_STEP_BACKWARD:
increment = - SINGLE_STEP_SIZE;
break;
case GTK_SCROLL_STEP_RIGHT:
case GTK_SCROLL_STEP_DOWN:
case GTK_SCROLL_STEP_FORWARD:
increment = SINGLE_STEP_SIZE;
break;
case GTK_SCROLL_PAGE_LEFT:
case GTK_SCROLL_PAGE_UP:
case GTK_SCROLL_PAGE_BACKWARD:
increment = - PAGE_STEP_SIZE;
break;
case GTK_SCROLL_PAGE_RIGHT:
case GTK_SCROLL_PAGE_DOWN:
case GTK_SCROLL_PAGE_FORWARD:
increment = PAGE_STEP_SIZE;
break;
case GTK_SCROLL_START:
new_position = paned->min_position;
break;
case GTK_SCROLL_END:
new_position = paned->max_position;
break;
case GTK_SCROLL_NONE:
case GTK_SCROLL_JUMP:
default:
break;
}
if (increment)
{
if (is_rtl (paned))
increment = -increment;
new_position = old_position + increment;
}
new_position = CLAMP (new_position, paned->min_position, paned->max_position);
if (old_position != new_position)
gtk_paned_set_position (paned, new_position);
return TRUE;
}
return FALSE;
}
static void
gtk_paned_restore_focus (GtkPaned *paned)
{
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
if (paned->saved_focus &&
gtk_widget_get_sensitive (paned->saved_focus))
{
gtk_widget_grab_focus (paned->saved_focus);
}
else
{
/* the saved focus is somehow not available for focusing,
* try
* 1) tabbing into the paned widget
* if that didn't work,
* 2) unset focus for the window if there is one
*/
if (!gtk_widget_child_focus (GTK_WIDGET (paned), GTK_DIR_TAB_FORWARD))
{
GtkRoot *root = gtk_widget_get_root (GTK_WIDGET (paned));
gtk_root_set_focus (root, NULL);
}
}
gtk_paned_set_saved_focus (paned, NULL);
gtk_paned_set_first_paned (paned, NULL);
}
}
static gboolean
gtk_paned_accept_position (GtkPaned *paned)
{
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
paned->original_position = -1;
gtk_paned_restore_focus (paned);
return TRUE;
}
return FALSE;
}
static gboolean
gtk_paned_cancel_position (GtkPaned *paned)
{
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
if (paned->original_position != -1)
{
gtk_paned_set_position (paned, paned->original_position);
paned->original_position = -1;
}
gtk_paned_restore_focus (paned);
return TRUE;
}
return FALSE;
}
static gboolean
gtk_paned_cycle_handle_focus (GtkPaned *paned,
gboolean reversed)
{
GtkPaned *next, *prev;
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
GtkPaned *focus = NULL;
if (!paned->first_paned)
{
/* The first_pane has disappeared. As an ad-hoc solution,
* we make the currently focused paned the first_paned. To the
* user this will seem like the paned cycling has been reset.
*/
gtk_paned_set_first_paned (paned, paned);
}
gtk_paned_find_neighbours (paned, &next, &prev);
if (reversed && prev &&
prev != paned && paned != paned->first_paned)
{
focus = prev;
}
else if (!reversed && next &&
next != paned && next != paned->first_paned)
{
focus = next;
}
else
{
gtk_paned_accept_position (paned);
return TRUE;
}
g_assert (focus);
gtk_paned_set_saved_focus (focus, paned->saved_focus);
gtk_paned_set_first_paned (focus, paned->first_paned);
gtk_paned_set_saved_focus (paned, NULL);
gtk_paned_set_first_paned (paned, NULL);
gtk_widget_grab_focus (GTK_WIDGET (focus));
if (!gtk_widget_is_focus (GTK_WIDGET (paned)))
{
paned->original_position = -1;
paned->original_position = gtk_paned_get_position (focus);
}
}
else
{
GtkPaned *focus;
GtkPaned *first;
GtkWidget *focus_child;
gtk_paned_find_neighbours (paned, &next, &prev);
focus_child = gtk_widget_get_focus_child (GTK_WIDGET (paned));
if (focus_child == paned->start_child)
{
if (reversed)
{
focus = prev;
first = paned;
}
else
{
focus = paned;
first = paned;
}
}
else if (focus_child == paned->end_child)
{
if (reversed)
{
focus = paned;
first = next;
}
else
{
focus = next;
first = next;
}
}
else
{
/* Focus is not inside this paned, and we don't have focus.
* Presumably this happened because the application wants us
* to start keyboard navigating.
*/
focus = paned;
if (reversed)
first = paned;
else
first = next;
}
gtk_paned_set_saved_focus (focus, gtk_root_get_focus (gtk_widget_get_root (GTK_WIDGET (paned))));
gtk_paned_set_first_paned (focus, first);
paned->original_position = gtk_paned_get_position (focus);
gtk_widget_grab_focus (GTK_WIDGET (focus));
}
return TRUE;
}
static gboolean
gtk_paned_toggle_handle_focus (GtkPaned *paned)
{
/* This function/signal has the wrong name. It is called when you
* press Tab or Shift-Tab and what we do is act as if
* the user pressed Return and then Tab or Shift-Tab
*/
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
gtk_paned_accept_position (paned);
return FALSE;
}
/**
* gtk_paned_set_wide_handle:
* @paned: a #GtkPaned
* @wide: the new value for the #GtkPaned:wide-handle property
*
* Sets the #GtkPaned:wide-handle property.
*/
void
gtk_paned_set_wide_handle (GtkPaned *paned,
gboolean wide)
{
gboolean old_wide;
g_return_if_fail (GTK_IS_PANED (paned));
old_wide = gtk_paned_get_wide_handle (paned);
if (old_wide != wide)
{
if (wide)
gtk_widget_add_css_class (paned->handle_widget, GTK_STYLE_CLASS_WIDE);
else
gtk_widget_remove_css_class (paned->handle_widget, GTK_STYLE_CLASS_WIDE);
g_object_notify_by_pspec (G_OBJECT (paned), paned_props[PROP_WIDE_HANDLE]);
}
}
/**
* gtk_paned_get_wide_handle:
* @paned: a #GtkPaned
*
* Gets the #GtkPaned:wide-handle property.
*
* Returns: %TRUE if the paned should have a wide handle
*/
gboolean
gtk_paned_get_wide_handle (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), FALSE);
return gtk_widget_has_css_class (paned->handle_widget, GTK_STYLE_CLASS_WIDE);
}
Reference in New Issue View Git Blame Copy Permalink