AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
bbca4c38df
gtk2/gtk/gtkwidget.c
Alexander Mikhaylenko 28f5d26719 windowhandle: Don't drag on capture phase 
This was needed to work around widgets claiming event sequences on press,
by ignoring them and starting the drag anyway unless they have certain
event controllers on them.

The most visible offender was GtkButton, but since the last commit it
doesn't claim the sequence anymore and we can remove the hack.
2021-01-29 12:00:10 +05:00

12700 lines
387 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 "gtkwidgetprivate.h"
#include "gtkaccelgroupprivate.h"
#include "gtkaccessibleprivate.h"
#include "gtkactionobserverprivate.h"
#include "gtkapplicationprivate.h"
#include "gtkbuildable.h"
#include "gtkbuilderprivate.h"
#include "gtkconstraint.h"
#include "gtkcssboxesprivate.h"
#include "gtkcssfiltervalueprivate.h"
#include "gtkcsstransformvalueprivate.h"
#include "gtkcsspositionvalueprivate.h"
#include "gtkcssfontvariationsvalueprivate.h"
#include "gtkcssnumbervalueprivate.h"
#include "gtkcsswidgetnodeprivate.h"
#include "gtkdebug.h"
#include "gtkgesturedrag.h"
#include "gtkgestureprivate.h"
#include "gtkgesturesingle.h"
#include "gtkgestureswipe.h"
#include "gtkgestureprivate.h"
#include "gtkintl.h"
#include "gtklayoutmanagerprivate.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtknative.h"
#include "gtkpopover.h"
#include "gtkprivate.h"
#include "gtkrenderbackgroundprivate.h"
#include "gtkrenderborderprivate.h"
#include "gtkrootprivate.h"
#include "gtknativeprivate.h"
#include "gtkscrollable.h"
#include "gtksettingsprivate.h"
#include "gtkshortcut.h"
#include "gtkshortcutcontrollerprivate.h"
#include "gtkshortcutmanager.h"
#include "gtkshortcutmanagerprivate.h"
#include "gtkshortcuttrigger.h"
#include "gtksizegroup-private.h"
#include "gtksnapshotprivate.h"
#include "gtkstylecontextprivate.h"
#include "gtktooltipprivate.h"
#include "gsktransformprivate.h"
#include "gtktypebuiltins.h"
#include "gtkversion.h"
#include "gtkwidgetpaintableprivate.h"
#include "gtkwindowgroup.h"
#include "gtkwindowprivate.h"
#include "inspector/window.h"
#include "gdk/gdkeventsprivate.h"
#include "gdk/gdkprofilerprivate.h"
#include "gsk/gskdebugprivate.h"
#include "gsk/gskrendererprivate.h"
#include <cairo-gobject.h>
#include <locale.h>
#include <math.h>
#include <stdarg.h>
#include <string.h>
/**
* SECTION:gtkwidget
* @Short_description: Base class for all widgets
* @Title: GtkWidget
*
* GtkWidget is the base class all widgets in GTK derive from. It manages the
* widget lifecycle, states and style.
*
* # Height-for-width Geometry Management # {#geometry-management}
*
* GTK uses a height-for-width (and width-for-height) geometry management
* system. Height-for-width means that a widget can change how much
* vertical space it needs, depending on the amount of horizontal space
* that it is given (and similar for width-for-height). The most common
* example is a label that reflows to fill up the available width, wraps
* to fewer lines, and therefore needs less height.
*
* Height-for-width geometry management is implemented in GTK by way
* of two virtual methods:
*
* - #GtkWidgetClass.get_request_mode()
* - #GtkWidgetClass.measure()
*
* There are some important things to keep in mind when implementing
* height-for-width and when using it in widget implementations.
*
* If you implement a direct #GtkWidget subclass that supports
* height-for-width or width-for-height geometry management for
* itself or its child widgets, the #GtkWidgetClass.get_request_mode()
* virtual function must be implemented as well and return the widget's
* preferred request mode. The default implementation of this virtual function
* returns %GTK_SIZE_REQUEST_CONSTANT_SIZE, which means that the widget will
* only ever get -1 passed as the for_size value to its #GtkWidgetClass.measure()
* implementation.
*
* The geometry management system will query a widget hierarchy in
* only one orientation at a time. When widgets are initially queried
* for their minimum sizes it is generally done in two initial passes
* in the #GtkSizeRequestMode chosen by the toplevel.
*
* For example, when queried in the normal
* %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
* First, the default minimum and natural width for each widget
* in the interface will be computed using gtk_widget_measure() with an
* orientation of %GTK_ORIENTATION_HORIZONTAL and a for_size of -1.
* Because the preferred widths for each widget depend on the preferred
* widths of their children, this information propagates up the hierarchy,
* and finally a minimum and natural width is determined for the entire
* toplevel. Next, the toplevel will use the minimum width to query for the
* minimum height contextual to that width using gtk_widget_measure() with an
* orientation of %GTK_ORIENTATION_VERTICAL and a for_size of the just computed
* width. This will also be a highly recursive operation. The minimum height
* for the minimum width is normally used to set the minimum size constraint
* on the toplevel.
*
* After the toplevel window has initially requested its size in both
* dimensions it can go on to allocate itself a reasonable size (or a size
* previously specified with gtk_window_set_default_size()). During the
* recursive allocation process it’s important to note that request cycles
* will be recursively executed while widgets allocate their children.
* Each widget, once allocated a size, will go on to first share the
* space in one orientation among its children and then request each child's
* height for its target allocated width or its width for allocated height,
* depending. In this way a #GtkWidget will typically be requested its size
* a number of times before actually being allocated a size. The size a
* widget is finally allocated can of course differ from the size it has
* requested. For this reason, #GtkWidget caches a small number of results
* to avoid re-querying for the same sizes in one allocation cycle.
*
* If a widget does move content around to intelligently use up the
* allocated size then it must support the request in both
* #GtkSizeRequestModes even if the widget in question only
* trades sizes in a single orientation.
*
* For instance, a #GtkLabel that does height-for-width word wrapping
* will not expect to have #GtkWidgetClass.measure() with an orientation of
* %GTK_ORIENTATION_VERTICAL called because that call is specific to a
* width-for-height request. In this
* case the label must return the height required for its own minimum
* possible width. By following this rule any widget that handles
* height-for-width or width-for-height requests will always be allocated
* at least enough space to fit its own content.
*
* Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
* generally deals with width-for-height requests:
*
* |[<!-- language="C" -->
* static void
* foo_widget_measure (GtkWidget *widget,
* GtkOrientation orientation,
* int for_size,
* int *minimum_size,
* int *natural_size,
* int *minimum_baseline,
* int *natural_baseline)
* {
* if (orientation == GTK_ORIENTATION_HORIZONTAL)
* {
* // Calculate minimum and natural width
* }
* else // VERTICAL
* {
* if (i_am_in_height_for_width_mode)
* {
* int min_width, dummy;
*
* // First, get the minimum width of our widget
* GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
* &min_width, &dummy, &dummy, &dummy);
*
* // Now use the minimum width to retrieve the minimum and natural height to display
* // that width.
* GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
* minimum_size, natural_size, &dummy, &dummy);
* }
* else
* {
* // ... some widgets do both.
* }
* }
* }
* ]|
*
* Often a widget needs to get its own request during size request or
* allocation. For example, when computing height it may need to also
* compute width. Or when deciding how to use an allocation, the widget
* may need to know its natural size. In these cases, the widget should
* be careful to call its virtual methods directly, like in the code
* example above.
*
* It will not work to use the wrapper function gtk_widget_measure()
* inside your own #GtkWidgetClass.size-allocate() implementation.
* These return a request adjusted by #GtkSizeGroup, the widget's align and expand flags
* as well as its CSS style.
* If a widget used the wrappers inside its virtual method implementations,
* then the adjustments (such as widget margins) would be applied
* twice. GTK therefore does not allow this and will warn if you try
* to do it.
*
* Of course if you are getting the size request for
* another widget, such as a child widget, you must use gtk_widget_measure().
* Otherwise, you would not properly consider widget margins,
* #GtkSizeGroup, and so forth.
*
* GTK also supports baseline vertical alignment of widgets. This
* means that widgets are positioned such that the typographical baseline of
* widgets in the same row are aligned. This happens if a widget supports baselines,
* has a vertical alignment of %GTK_ALIGN_BASELINE, and is inside a widget
* that supports baselines and has a natural “row” that it aligns to the baseline,
* or a baseline assigned to it by the grandparent.
*
* Baseline alignment support for a widget is also done by the #GtkWidgetClass.measure()
* virtual function. It allows you to report both a minimum and natural size.
*
* If a widget ends up baseline aligned it will be allocated all the space in the parent
* as if it was %GTK_ALIGN_FILL, but the selected baseline can be found via gtk_widget_get_allocated_baseline().
* If this has a value other than -1 you need to align the widget such that the baseline
* appears at the position.
*
* # GtkWidget as GtkBuildable
*
* The GtkWidget implementation of the #GtkBuildable interface supports a
* custom elements to specify various aspects of widgets that are not
* directly expressed as properties.
*
* If the parent widget uses a #GtkLayoutManager, #GtkWidget supports a
* custom `<layout>` element, used to define layout properties:
*
* |[
* <object class="MyGrid" id="grid1">
* <child>
* <object class="GtkLabel" id="label1">
* <property name="label">Description</property>
* <layout>
* <property name="column">0</property>
* <property name="row">0</property>
* <property name="row-span">1</property>
* <property name="column-span">1</property>
* </layout>
* </object>
* </child>
* <child>
* <object class="GtkEntry" id="description_entry">
* <layout>
* <property name="column">1</property>
* <property name="row">0</property>
* <property name="row-span">1</property>
* <property name="column-span">1</property>
* </layout>
* </object>
* </child>
* </object>
* ]|
*
* GtkWidget allows style information such as style classes to
* be associated with widgets, using the custom `<style>` element:
* |[
* <object class="GtkButton" id="button1">
* <style>
* <class name="my-special-button-class"/>
* <class name="dark-button"/>
* </style>
* </object>
* ]|
*
* GtkWidget allows defining accessibility information, such as properties,
* relations, and states, using the custom `<accessibility>` element:
* |[
* <object class="GtkButton" id="button1">
* <accessibility>
* <property name="label">Download</property>
* <relation name="labelled-by">label1</relation>
* </accessibility>
* </object>
* ]|
*
* # Building composite widgets from template XML ## {#composite-templates}
*
* GtkWidget exposes some facilities to automate the procedure
* of creating composite widgets using #GtkBuilder interface description
* language.
*
* To create composite widgets with #GtkBuilder XML, one must associate
* the interface description with the widget class at class initialization
* time using gtk_widget_class_set_template().
*
* The interface description semantics expected in composite template descriptions
* is slightly different from regular #GtkBuilder XML.
*
* Unlike regular interface descriptions, gtk_widget_class_set_template() will
* expect a <template> tag as a direct child of the toplevel <interface>
* tag. The <template> tag must specify the “class” attribute which must be
* the type name of the widget. Optionally, the “parent” attribute may be
* specified to specify the direct parent type of the widget type, this is
* ignored by the GtkBuilder but required for Glade to introspect what kind
* of properties and internal children exist for a given type when the actual
* type does not exist.
*
* The XML which is contained inside the <template> tag behaves as if it were
* added to the <object> tag defining @widget itself. You may set properties
* on @widget by inserting <property> tags into the <template> tag, and also
* add <child> tags to add children and extend @widget in the normal way you
* would with <object> tags.
*
* Additionally, <object> tags can also be added before and after the initial
* <template> tag in the normal way, allowing one to define auxiliary objects
* which might be referenced by other widgets declared as children of the
* <template> tag.
*
* An example of a GtkBuilder Template Definition:
* |[
* <interface>
* <template class="FooWidget" parent="GtkBox">
* <property name="orientation">horizontal</property>
* <property name="spacing">4</property>
* <child>
* <object class="GtkButton" id="hello_button">
* <property name="label">Hello World</property>
* <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
* </object>
* </child>
* <child>
* <object class="GtkButton" id="goodbye_button">
* <property name="label">Goodbye World</property>
* </object>
* </child>
* </template>
* </interface>
* ]|
*
* Typically, you'll place the template fragment into a file that is
* bundled with your project, using #GResource. In order to load the
* template, you need to call gtk_widget_class_set_template_from_resource()
* from the class initialization of your #GtkWidget type:
*
* |[<!-- language="C" -->
* static void
* foo_widget_class_init (FooWidgetClass *klass)
* {
* // ...
*
* gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
* "/com/example/ui/foowidget.ui");
* }
* ]|
*
* You will also need to call gtk_widget_init_template() from the instance
* initialization function:
*
* |[<!-- language="C" -->
* static void
* foo_widget_init (FooWidget *self)
* {
* // ...
* gtk_widget_init_template (GTK_WIDGET (self));
* }
* ]|
*
* You can access widgets defined in the template using the
* gtk_widget_get_template_child() function, but you will typically declare
* a pointer in the instance private data structure of your type using the same
* name as the widget in the template definition, and call
* gtk_widget_class_bind_template_child_private() with that name, e.g.
*
* |[<!-- language="C" -->
* typedef struct {
* GtkWidget *hello_button;
* GtkWidget *goodbye_button;
* } FooWidgetPrivate;
*
* G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
*
* static void
* foo_widget_class_init (FooWidgetClass *klass)
* {
* // ...
* gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
* "/com/example/ui/foowidget.ui");
* gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
* FooWidget, hello_button);
* gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
* FooWidget, goodbye_button);
* }
*
* static void
* foo_widget_init (FooWidget *widget)
* {
*
* }
* ]|
*
* You can also use gtk_widget_class_bind_template_callback() to connect a signal
* callback defined in the template with a function visible in the scope of the
* class, e.g.
*
* |[<!-- language="C" -->
* // the signal handler has the instance and user data swapped
* // because of the swapped="yes" attribute in the template XML
* static void
* hello_button_clicked (FooWidget *self,
* GtkButton *button)
* {
* g_print ("Hello, world!\n");
* }
*
* static void
* foo_widget_class_init (FooWidgetClass *klass)
* {
* // ...
* gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
* "/com/example/ui/foowidget.ui");
* gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
* }
* ]|
*/
#define GTK_STATE_FLAGS_DO_SET_PROPAGATE (GTK_STATE_FLAG_INSENSITIVE | \
GTK_STATE_FLAG_BACKDROP)
#define GTK_STATE_FLAGS_DO_UNSET_PROPAGATE (GTK_STATE_FLAG_INSENSITIVE | \
GTK_STATE_FLAG_BACKDROP | \
GTK_STATE_FLAG_PRELIGHT | \
GTK_STATE_FLAG_ACTIVE)
typedef struct {
char *name; /* Name of the template automatic child */
gboolean internal_child; /* Whether the automatic widget should be exported as an <internal-child> */
gssize offset; /* Instance private data offset where to set the automatic child (or 0) */
} AutomaticChildClass;
enum {
DESTROY,
SHOW,
HIDE,
MAP,
UNMAP,
REALIZE,
UNREALIZE,
STATE_FLAGS_CHANGED,
DIRECTION_CHANGED,
MNEMONIC_ACTIVATE,
MOVE_FOCUS,
KEYNAV_FAILED,
QUERY_TOOLTIP,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_NAME,
PROP_PARENT,
PROP_ROOT,
PROP_WIDTH_REQUEST,
PROP_HEIGHT_REQUEST,
PROP_VISIBLE,
PROP_SENSITIVE,
PROP_CAN_FOCUS,
PROP_HAS_FOCUS,
PROP_CAN_TARGET,
PROP_FOCUS_ON_CLICK,
PROP_FOCUSABLE,
PROP_HAS_DEFAULT,
PROP_RECEIVES_DEFAULT,
PROP_CURSOR,
PROP_HAS_TOOLTIP,
PROP_TOOLTIP_MARKUP,
PROP_TOOLTIP_TEXT,
PROP_OPACITY,
PROP_OVERFLOW,
PROP_HALIGN,
PROP_VALIGN,
PROP_MARGIN_START,
PROP_MARGIN_END,
PROP_MARGIN_TOP,
PROP_MARGIN_BOTTOM,
PROP_HEXPAND,
PROP_VEXPAND,
PROP_HEXPAND_SET,
PROP_VEXPAND_SET,
PROP_SCALE_FACTOR,
PROP_CSS_NAME,
PROP_CSS_CLASSES,
PROP_LAYOUT_MANAGER,
NUM_PROPERTIES,
/* GtkAccessible */
PROP_ACCESSIBLE_ROLE
};
typedef struct
{
guint flags_to_set;
guint flags_to_unset;
int old_scale_factor;
} GtkStateData;
static void gtk_widget_base_class_init (gpointer g_class);
static void gtk_widget_class_init (GtkWidgetClass *klass);
static void gtk_widget_base_class_finalize (GtkWidgetClass *klass);
static void gtk_widget_init (GTypeInstance *instance,
gpointer g_class);
static void gtk_widget_dispose (GObject *object);
static void gtk_widget_finalize (GObject *object);
static void gtk_widget_real_destroy (GtkWidget *object);
static gboolean gtk_widget_real_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_widget_real_show (GtkWidget *widget);
static void gtk_widget_real_hide (GtkWidget *widget);
static void gtk_widget_real_map (GtkWidget *widget);
static void gtk_widget_real_unmap (GtkWidget *widget);
static void gtk_widget_real_realize (GtkWidget *widget);
static void gtk_widget_real_unrealize (GtkWidget *widget);
static void gtk_widget_real_direction_changed (GtkWidget *widget,
GtkTextDirection previous_direction);
static void gtk_widget_real_css_changed (GtkWidget *widget,
GtkCssStyleChange *change);
static void gtk_widget_real_system_setting_changed (GtkWidget *widget,
GtkSystemSetting setting);
static void gtk_widget_real_set_focus_child (GtkWidget *widget,
GtkWidget *child);
static void gtk_widget_real_move_focus (GtkWidget *widget,
GtkDirectionType direction);
static gboolean gtk_widget_real_keynav_failed (GtkWidget *widget,
GtkDirectionType direction);
#ifdef G_ENABLE_CONSISTENCY_CHECKS
static void gtk_widget_verify_invariants (GtkWidget *widget);
static void gtk_widget_push_verify_invariants (GtkWidget *widget);
static void gtk_widget_pop_verify_invariants (GtkWidget *widget);
#else
#define gtk_widget_verify_invariants(widget)
#define gtk_widget_push_verify_invariants(widget)
#define gtk_widget_pop_verify_invariants(widget)
#endif
static PangoContext* gtk_widget_peek_pango_context (GtkWidget *widget);
static void gtk_widget_update_pango_context (GtkWidget *widget);
static void gtk_widget_propagate_state (GtkWidget *widget,
const GtkStateData *data);
static gboolean gtk_widget_real_mnemonic_activate (GtkWidget *widget,
gboolean group_cycling);
static void gtk_widget_accessible_interface_init (GtkAccessibleInterface *iface);
static void gtk_widget_buildable_interface_init (GtkBuildableIface *iface);
static void gtk_widget_buildable_set_id (GtkBuildable *buildable,
const char *id);
static const char * gtk_widget_buildable_get_id (GtkBuildable *buildable);
static GObject * gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,
GtkBuilder *builder,
const char *childname);
static gboolean gtk_widget_buildable_custom_tag_start (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
GtkBuildableParser *parser,
gpointer *data);
static void gtk_widget_buildable_custom_tag_end (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer data);
static void gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer data);
static void gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
GtkBuilder *builder);
static void gtk_widget_set_usize_internal (GtkWidget *widget,
int width,
int height);
static void remove_parent_surface_transform_changed_listener (GtkWidget *widget);
static void add_parent_surface_transform_changed_listener (GtkWidget *widget);
static void gtk_widget_queue_compute_expand (GtkWidget *widget);
static int GtkWidget_private_offset = 0;
static gpointer gtk_widget_parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
static GParamSpec *widget_props[NUM_PROPERTIES] = { NULL, };
GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR;
static GQuark quark_pango_context = 0;
static GQuark quark_mnemonic_labels = 0;
static GQuark quark_size_groups = 0;
static GQuark quark_auto_children = 0;
static GQuark quark_action_muxer = 0;
static GQuark quark_font_options = 0;
static GQuark quark_font_map = 0;
static GQuark quark_builder_set_id = 0;
GType
gtk_widget_get_type (void)
{
static GType widget_type = 0;
if (G_UNLIKELY (widget_type == 0))
{
const GTypeInfo widget_info =
{
sizeof (GtkWidgetClass),
gtk_widget_base_class_init,
(GBaseFinalizeFunc) gtk_widget_base_class_finalize,
(GClassInitFunc) gtk_widget_class_init,
NULL, /* class_finalize */
NULL, /* class_init */
sizeof (GtkWidget),
0, /* n_preallocs */
gtk_widget_init,
NULL, /* value_table */
};
const GInterfaceInfo accessible_info =
{
(GInterfaceInitFunc) gtk_widget_accessible_interface_init,
(GInterfaceFinalizeFunc) NULL,
NULL,
};
const GInterfaceInfo buildable_info =
{
(GInterfaceInitFunc) gtk_widget_buildable_interface_init,
(GInterfaceFinalizeFunc) NULL,
NULL /* interface data */
};
const GInterfaceInfo constraint_target_info =
{
(GInterfaceInitFunc) NULL,
(GInterfaceFinalizeFunc) NULL,
NULL /* interface data */
};
widget_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, g_intern_static_string ("GtkWidget"),
&widget_info, G_TYPE_FLAG_ABSTRACT);
g_type_add_class_private (widget_type, sizeof (GtkWidgetClassPrivate));
GtkWidget_private_offset = g_type_add_instance_private (widget_type, sizeof (GtkWidgetPrivate));
g_type_add_interface_static (widget_type, GTK_TYPE_ACCESSIBLE,
&accessible_info);
g_type_add_interface_static (widget_type, GTK_TYPE_BUILDABLE,
&buildable_info);
g_type_add_interface_static (widget_type, GTK_TYPE_CONSTRAINT_TARGET,
&constraint_target_info);
}
return widget_type;
}
static inline gpointer
gtk_widget_get_instance_private (GtkWidget *self)
{
return (G_STRUCT_MEMBER_P (self, GtkWidget_private_offset));
}
static void
gtk_widget_base_class_init (gpointer g_class)
{
GtkWidgetClass *klass = g_class;
GtkWidgetClassPrivate *priv;
priv = klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_WIDGET, GtkWidgetClassPrivate);
priv->template = NULL;
if (priv->shortcuts == NULL)
{
priv->shortcuts = g_list_store_new (GTK_TYPE_SHORTCUT);
}
else
{
GListModel *parent_shortcuts = G_LIST_MODEL (priv->shortcuts);
guint i, p;
priv->shortcuts = g_list_store_new (GTK_TYPE_SHORTCUT);
for (i = 0, p = g_list_model_get_n_items (parent_shortcuts); i < p; i++)
{
GtkShortcut *shortcut = g_list_model_get_item (parent_shortcuts, i);
g_list_store_append (priv->shortcuts, shortcut);
g_object_unref (shortcut);
}
}
}
static void
gtk_widget_real_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkWidget *child;
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
gtk_widget_snapshot_child (widget, child, snapshot);
}
static gboolean
gtk_widget_real_contains (GtkWidget *widget,
double x,
double y)
{
GtkCssBoxes boxes;
gtk_css_boxes_init (&boxes, widget);
return gsk_rounded_rect_contains_point (gtk_css_boxes_get_border_box (&boxes),
&GRAPHENE_POINT_INIT (x, y));
}
/**
* _gtk_widget_grab_notify:
* @widget: a #GtkWidget
* @was_grabbed: whether a grab is now in effect
*
* Emits the #GtkWidget::grab-notify signal on @widget.
**/
void
_gtk_widget_grab_notify (GtkWidget *widget,
gboolean was_grabbed)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
if (was_grabbed)
return;
for (l = g_list_last (priv->event_controllers); l; l = l->prev)
{
GtkEventController *controller = l->data;
gtk_event_controller_reset (controller);
}
if (GTK_IS_NATIVE (widget))
gtk_widget_hide (widget);
}
static void
gtk_widget_real_root (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
gtk_widget_forall (widget, (GtkCallback) gtk_widget_root, NULL);
for (l = priv->event_controllers; l; l = l->next)
{
if (GTK_IS_SHORTCUT_CONTROLLER (l->data))
gtk_shortcut_controller_root (GTK_SHORTCUT_CONTROLLER (l->data));
}
}
static void
gtk_widget_real_unroot (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
for (l = priv->event_controllers; l; l = l->next)
{
if (GTK_IS_SHORTCUT_CONTROLLER (l->data))
gtk_shortcut_controller_unroot (GTK_SHORTCUT_CONTROLLER (l->data));
}
gtk_widget_forall (widget, (GtkCallback) gtk_widget_unroot, NULL);
}
static void
gtk_widget_constructed (GObject *object)
{
G_OBJECT_CLASS (gtk_widget_parent_class)->constructed (object);
if (GTK_WIDGET_GET_CLASS (object)->priv->actions)
{
GtkActionMuxer *muxer;
muxer = _gtk_widget_get_action_muxer (GTK_WIDGET (object), TRUE);
gtk_action_muxer_connect_class_actions (muxer);
}
}
static void
gtk_widget_real_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
*minimum = 0;
*natural = 0;
}
static GtkSizeRequestMode
gtk_widget_real_get_request_mode (GtkWidget *widget)
{
/* By default widgets don't trade size at all. */
return GTK_SIZE_REQUEST_CONSTANT_SIZE;
}
static void
gtk_widget_real_state_flags_changed (GtkWidget *widget,
GtkStateFlags old_state)
{
}
static gboolean
gtk_widget_real_query_tooltip (GtkWidget *widget,
int x,
int y,
gboolean keyboard_tip,
GtkTooltip *tooltip)
{
const char *tooltip_markup;
gboolean has_tooltip;
has_tooltip = gtk_widget_get_has_tooltip (widget);
tooltip_markup = gtk_widget_get_tooltip_markup (widget);
if (tooltip_markup == NULL)
tooltip_markup = gtk_widget_get_tooltip_text (widget);
if (has_tooltip && tooltip_markup != NULL)
{
gtk_tooltip_set_markup (tooltip, tooltip_markup);
return TRUE;
}
return FALSE;
}
static void
gtk_widget_real_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
{
}
static void
gtk_widget_set_accessible_role (GtkWidget *self,
GtkAccessibleRole role)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (self);
if (priv->at_context == NULL || !gtk_at_context_is_realized (priv->at_context))
{
priv->accessible_role = role;
if (priv->at_context != NULL)
gtk_at_context_set_accessible_role (priv->at_context, role);
g_object_notify (G_OBJECT (self), "accessible-role");
}
else
{
char *role_str = g_enum_to_string (GTK_TYPE_ACCESSIBLE_ROLE, priv->accessible_role);
g_critical ("Widget of type “%s” already has an accessible role of type “%s”",
G_OBJECT_TYPE_NAME (self),
role_str);
g_free (role_str);
}
}
static GtkAccessibleRole
gtk_widget_get_accessible_role (GtkWidget *self)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (self);
GtkATContext *context = gtk_accessible_get_at_context (GTK_ACCESSIBLE (self));
GtkWidgetClassPrivate *class_priv;
if (context != NULL && gtk_at_context_is_realized (context))
return gtk_at_context_get_accessible_role (context);
if (priv->accessible_role != GTK_ACCESSIBLE_ROLE_WIDGET)
return priv->accessible_role;
class_priv = GTK_WIDGET_GET_CLASS (self)->priv;
return class_priv->accessible_role;
}
static void
gtk_widget_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
switch (prop_id)
{
case PROP_NAME:
gtk_widget_set_name (widget, g_value_get_string (value));
break;
case PROP_WIDTH_REQUEST:
gtk_widget_set_usize_internal (widget, g_value_get_int (value), -2);
break;
case PROP_HEIGHT_REQUEST:
gtk_widget_set_usize_internal (widget, -2, g_value_get_int (value));
break;
case PROP_VISIBLE:
gtk_widget_set_visible (widget, g_value_get_boolean (value));
break;
case PROP_SENSITIVE:
gtk_widget_set_sensitive (widget, g_value_get_boolean (value));
break;
case PROP_CAN_FOCUS:
gtk_widget_set_can_focus (widget, g_value_get_boolean (value));
break;
case PROP_FOCUSABLE:
gtk_widget_set_focusable (widget, g_value_get_boolean (value));
break;
case PROP_CAN_TARGET:
gtk_widget_set_can_target (widget, g_value_get_boolean (value));
break;
case PROP_FOCUS_ON_CLICK:
gtk_widget_set_focus_on_click (widget, g_value_get_boolean (value));
break;
case PROP_RECEIVES_DEFAULT:
gtk_widget_set_receives_default (widget, g_value_get_boolean (value));
break;
case PROP_CURSOR:
gtk_widget_set_cursor (widget, g_value_get_object (value));
break;
case PROP_HAS_TOOLTIP:
gtk_widget_set_has_tooltip (widget, g_value_get_boolean (value));
break;
case PROP_TOOLTIP_MARKUP:
gtk_widget_set_tooltip_markup (widget, g_value_get_string (value));
break;
case PROP_TOOLTIP_TEXT:
gtk_widget_set_tooltip_text (widget, g_value_get_string (value));
break;
case PROP_HALIGN:
gtk_widget_set_halign (widget, g_value_get_enum (value));
break;
case PROP_VALIGN:
gtk_widget_set_valign (widget, g_value_get_enum (value));
break;
case PROP_MARGIN_START:
gtk_widget_set_margin_start (widget, g_value_get_int (value));
break;
case PROP_MARGIN_END:
gtk_widget_set_margin_end (widget, g_value_get_int (value));
break;
case PROP_MARGIN_TOP:
gtk_widget_set_margin_top (widget, g_value_get_int (value));
break;
case PROP_MARGIN_BOTTOM:
gtk_widget_set_margin_bottom (widget, g_value_get_int (value));
break;
case PROP_HEXPAND:
gtk_widget_set_hexpand (widget, g_value_get_boolean (value));
break;
case PROP_HEXPAND_SET:
gtk_widget_set_hexpand_set (widget, g_value_get_boolean (value));
break;
case PROP_VEXPAND:
gtk_widget_set_vexpand (widget, g_value_get_boolean (value));
break;
case PROP_VEXPAND_SET:
gtk_widget_set_vexpand_set (widget, g_value_get_boolean (value));
break;
case PROP_OPACITY:
gtk_widget_set_opacity (widget, g_value_get_double (value));
break;
case PROP_OVERFLOW:
gtk_widget_set_overflow (widget, g_value_get_enum (value));
break;
case PROP_CSS_NAME:
if (g_value_get_string (value) != NULL)
gtk_css_node_set_name (priv->cssnode, g_quark_from_string (g_value_get_string (value)));
break;
case PROP_CSS_CLASSES:
gtk_widget_set_css_classes (widget, g_value_get_boxed (value));
break;
case PROP_LAYOUT_MANAGER:
gtk_widget_set_layout_manager (widget, g_value_dup_object (value));
break;
case PROP_ACCESSIBLE_ROLE:
gtk_widget_set_accessible_role (widget, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_widget_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
switch (prop_id)
{
case PROP_NAME:
if (priv->name)
g_value_set_string (value, priv->name);
else
g_value_set_static_string (value, "");
break;
case PROP_PARENT:
g_value_set_object (value, priv->parent);
break;
case PROP_ROOT:
g_value_set_object (value, priv->root);
break;
case PROP_WIDTH_REQUEST:
{
int w;
gtk_widget_get_size_request (widget, &w, NULL);
g_value_set_int (value, w);
}
break;
case PROP_HEIGHT_REQUEST:
{
int h;
gtk_widget_get_size_request (widget, NULL, &h);
g_value_set_int (value, h);
}
break;
case PROP_VISIBLE:
g_value_set_boolean (value, _gtk_widget_get_visible (widget));
break;
case PROP_SENSITIVE:
g_value_set_boolean (value, gtk_widget_get_sensitive (widget));
break;
case PROP_CAN_FOCUS:
g_value_set_boolean (value, gtk_widget_get_can_focus (widget));
break;
case PROP_FOCUSABLE:
g_value_set_boolean (value, gtk_widget_get_focusable (widget));
break;
case PROP_HAS_FOCUS:
g_value_set_boolean (value, gtk_widget_has_focus (widget));
break;
case PROP_CAN_TARGET:
g_value_set_boolean (value, gtk_widget_get_can_target (widget));
break;
case PROP_FOCUS_ON_CLICK:
g_value_set_boolean (value, gtk_widget_get_focus_on_click (widget));
break;
case PROP_HAS_DEFAULT:
g_value_set_boolean (value, gtk_widget_has_default (widget));
break;
case PROP_RECEIVES_DEFAULT:
g_value_set_boolean (value, gtk_widget_get_receives_default (widget));
break;
case PROP_CURSOR:
g_value_set_object (value, gtk_widget_get_cursor (widget));
break;
case PROP_HAS_TOOLTIP:
g_value_set_boolean (value, gtk_widget_get_has_tooltip (widget));
break;
case PROP_TOOLTIP_TEXT:
g_value_set_string (value, gtk_widget_get_tooltip_text (widget));
break;
case PROP_TOOLTIP_MARKUP:
g_value_set_string (value, gtk_widget_get_tooltip_markup (widget));
break;
case PROP_HALIGN:
g_value_set_enum (value, gtk_widget_get_halign (widget));
break;
case PROP_VALIGN:
g_value_set_enum (value, gtk_widget_get_valign (widget));
break;
case PROP_MARGIN_START:
g_value_set_int (value, gtk_widget_get_margin_start (widget));
break;
case PROP_MARGIN_END:
g_value_set_int (value, gtk_widget_get_margin_end (widget));
break;
case PROP_MARGIN_TOP:
g_value_set_int (value, gtk_widget_get_margin_top (widget));
break;
case PROP_MARGIN_BOTTOM:
g_value_set_int (value, gtk_widget_get_margin_bottom (widget));
break;
case PROP_HEXPAND:
g_value_set_boolean (value, gtk_widget_get_hexpand (widget));
break;
case PROP_HEXPAND_SET:
g_value_set_boolean (value, gtk_widget_get_hexpand_set (widget));
break;
case PROP_VEXPAND:
g_value_set_boolean (value, gtk_widget_get_vexpand (widget));
break;
case PROP_VEXPAND_SET:
g_value_set_boolean (value, gtk_widget_get_vexpand_set (widget));
break;
case PROP_OPACITY:
g_value_set_double (value, gtk_widget_get_opacity (widget));
break;
case PROP_OVERFLOW:
g_value_set_enum (value, gtk_widget_get_overflow (widget));
break;
case PROP_SCALE_FACTOR:
g_value_set_int (value, gtk_widget_get_scale_factor (widget));
break;
case PROP_CSS_NAME:
g_value_set_string (value, gtk_widget_get_css_name (widget));
break;
case PROP_CSS_CLASSES:
g_value_take_boxed (value, gtk_widget_get_css_classes (widget));
break;
case PROP_LAYOUT_MANAGER:
g_value_set_object (value, gtk_widget_get_layout_manager (widget));
break;
case PROP_ACCESSIBLE_ROLE:
g_value_set_enum (value, gtk_widget_get_accessible_role (widget));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_widget_class_init (GtkWidgetClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_adjust_private_offset (klass, &GtkWidget_private_offset);
gtk_widget_parent_class = g_type_class_peek_parent (klass);
quark_pango_context = g_quark_from_static_string ("gtk-pango-context");
quark_mnemonic_labels = g_quark_from_static_string ("gtk-mnemonic-labels");
quark_size_groups = g_quark_from_static_string ("gtk-widget-size-groups");
quark_auto_children = g_quark_from_static_string ("gtk-widget-auto-children");
quark_action_muxer = g_quark_from_static_string ("gtk-widget-action-muxer");
quark_font_options = g_quark_from_static_string ("gtk-widget-font-options");
quark_font_map = g_quark_from_static_string ("gtk-widget-font-map");
gobject_class->constructed = gtk_widget_constructed;
gobject_class->dispose = gtk_widget_dispose;
gobject_class->finalize = gtk_widget_finalize;
gobject_class->set_property = gtk_widget_set_property;
gobject_class->get_property = gtk_widget_get_property;
klass->show = gtk_widget_real_show;
klass->hide = gtk_widget_real_hide;
klass->map = gtk_widget_real_map;
klass->unmap = gtk_widget_real_unmap;
klass->realize = gtk_widget_real_realize;
klass->unrealize = gtk_widget_real_unrealize;
klass->root = gtk_widget_real_root;
klass->unroot = gtk_widget_real_unroot;
klass->size_allocate = gtk_widget_real_size_allocate;
klass->get_request_mode = gtk_widget_real_get_request_mode;
klass->measure = gtk_widget_real_measure;
klass->state_flags_changed = gtk_widget_real_state_flags_changed;
klass->direction_changed = gtk_widget_real_direction_changed;
klass->snapshot = gtk_widget_real_snapshot;
klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
klass->grab_focus = gtk_widget_grab_focus_self;
klass->focus = gtk_widget_real_focus;
klass->set_focus_child = gtk_widget_real_set_focus_child;
klass->move_focus = gtk_widget_real_move_focus;
klass->keynav_failed = gtk_widget_real_keynav_failed;
klass->query_tooltip = gtk_widget_real_query_tooltip;
klass->css_changed = gtk_widget_real_css_changed;
klass->system_setting_changed = gtk_widget_real_system_setting_changed;
klass->contains = gtk_widget_real_contains;
widget_props[PROP_NAME] =
g_param_spec_string ("name",
P_("Widget name"),
P_("The name of the widget"),
NULL,
GTK_PARAM_READWRITE);
widget_props[PROP_PARENT] =
g_param_spec_object ("parent",
P_("Parent widget"),
P_("The parent widget of this widget."),
GTK_TYPE_WIDGET,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:root:
*
* The #GtkRoot widget of the widget tree containing this widget or %NULL if
* the widget is not contained in a root widget.
*/
widget_props[PROP_ROOT] =
g_param_spec_object ("root",
P_("Root widget"),
P_("The root widget in the widget tree."),
GTK_TYPE_ROOT,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_WIDTH_REQUEST] =
g_param_spec_int ("width-request",
P_("Width request"),
P_("Override for width request of the widget, or -1 if natural request should be used"),
-1, G_MAXINT,
-1,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_HEIGHT_REQUEST] =
g_param_spec_int ("height-request",
P_("Height request"),
P_("Override for height request of the widget, or -1 if natural request should be used"),
-1, G_MAXINT,
-1,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_VISIBLE] =
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether the widget is visible"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_SENSITIVE] =
g_param_spec_boolean ("sensitive",
P_("Sensitive"),
P_("Whether the widget responds to input"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:can-focus:
*
* Whether the widget or any of its descendents can accept
* the input focus.
*
* This property is meant to be set by widget implementations,
* typically in their instance init function.
*/
widget_props[PROP_CAN_FOCUS] =
g_param_spec_boolean ("can-focus",
P_("Can focus"),
P_("Whether the widget can accept the input focus"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:focusable:
*
* Whether this widget itself will accept the input focus.
*/
widget_props[PROP_FOCUSABLE] =
g_param_spec_boolean ("focusable",
P_("Focusable"),
P_("Whether the widget can accept the input focus"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_HAS_FOCUS] =
g_param_spec_boolean ("has-focus",
P_("Has focus"),
P_("Whether the widget has the input focus"),
FALSE,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_CAN_TARGET] =
g_param_spec_boolean ("can-target",
P_("Can target"),
P_("Whether the widget can receive pointer events"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:focus-on-click:
*
* Whether the widget should grab focus when it is clicked with the mouse.
*
* This property is only relevant for widgets that can take focus.
*/
widget_props[PROP_FOCUS_ON_CLICK] =
g_param_spec_boolean ("focus-on-click",
P_("Focus on click"),
P_("Whether the widget should grab focus when it is clicked with the mouse"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_HAS_DEFAULT] =
g_param_spec_boolean ("has-default",
P_("Has default"),
P_("Whether the widget is the default widget"),
FALSE,
GTK_PARAM_READABLE|G_PARAM_EXPLICIT_NOTIFY);
widget_props[PROP_RECEIVES_DEFAULT] =
g_param_spec_boolean ("receives-default",
P_("Receives default"),
P_("If TRUE, the widget will receive the default action when it is focused"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:cursor:
*
* The cursor used by @widget. See gtk_widget_set_cursor() for details.
*/
widget_props[PROP_CURSOR] =
g_param_spec_object("cursor",
P_("Cursor"),
P_("The cursor to show when hovering above widget"),
GDK_TYPE_CURSOR,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:has-tooltip:
*
* Enables or disables the emission of #GtkWidget::query-tooltip on @widget.
* A value of %TRUE indicates that @widget can have a tooltip, in this case
* the widget will be queried using #GtkWidget::query-tooltip to determine
* whether it will provide a tooltip or not.
*/
widget_props[PROP_HAS_TOOLTIP] =
g_param_spec_boolean ("has-tooltip",
P_("Has tooltip"),
P_("Whether this widget has a tooltip"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:tooltip-text:
*
* Sets the text of tooltip to be the given string.
*
* Also see gtk_tooltip_set_text().
*
* This is a convenience property which will take care of getting the
* tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
* will automatically be set to %TRUE and there will be taken care of
* #GtkWidget::query-tooltip in the default signal handler.
*
* Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
* are set, the last one wins.
*/
widget_props[PROP_TOOLTIP_TEXT] =
g_param_spec_string ("tooltip-text",
P_("Tooltip Text"),
P_("The contents of the tooltip for this widget"),
NULL,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:tooltip-markup:
*
* Sets the text of tooltip to be the given string, which is marked up
* with the [Pango text markup language][PangoMarkupFormat].
* Also see gtk_tooltip_set_markup().
*
* This is a convenience property which will take care of getting the
* tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
* will automatically be set to %TRUE and there will be taken care of
* #GtkWidget::query-tooltip in the default signal handler.
*
* Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
* are set, the last one wins.
*/
widget_props[PROP_TOOLTIP_MARKUP] =
g_param_spec_string ("tooltip-markup",
P_("Tooltip markup"),
P_("The contents of the tooltip for this widget"),
NULL,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:halign:
*
* How to distribute horizontal space if widget gets extra space, see #GtkAlign
*/
widget_props[PROP_HALIGN] =
g_param_spec_enum ("halign",
P_("Horizontal Alignment"),
P_("How to position in extra horizontal space"),
GTK_TYPE_ALIGN,
GTK_ALIGN_FILL,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:valign:
*
* How to distribute vertical space if widget gets extra space, see #GtkAlign
*/
widget_props[PROP_VALIGN] =
g_param_spec_enum ("valign",
P_("Vertical Alignment"),
P_("How to position in extra vertical space"),
GTK_TYPE_ALIGN,
GTK_ALIGN_FILL,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:margin-start:
*
* Margin on start of widget, horizontally. This property supports
* left-to-right and right-to-left text directions.
*
* This property adds margin outside of the widget's normal size
* request, the margin will be added in addition to the size from
* gtk_widget_set_size_request() for example.
*/
widget_props[PROP_MARGIN_START] =
g_param_spec_int ("margin-start",
P_("Margin on Start"),
P_("Pixels of extra space on the start"),
0, G_MAXINT16,
0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:margin-end:
*
* Margin on end of widget, horizontally. This property supports
* left-to-right and right-to-left text directions.
*
* This property adds margin outside of the widget's normal size
* request, the margin will be added in addition to the size from
* gtk_widget_set_size_request() for example.
*/
widget_props[PROP_MARGIN_END] =
g_param_spec_int ("margin-end",
P_("Margin on End"),
P_("Pixels of extra space on the end"),
0, G_MAXINT16,
0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:margin-top:
*
* Margin on top side of widget.
*
* This property adds margin outside of the widget's normal size
* request, the margin will be added in addition to the size from
* gtk_widget_set_size_request() for example.
*/
widget_props[PROP_MARGIN_TOP] =
g_param_spec_int ("margin-top",
P_("Margin on Top"),
P_("Pixels of extra space on the top side"),
0, G_MAXINT16,
0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:margin-bottom:
*
* Margin on bottom side of widget.
*
* This property adds margin outside of the widget's normal size
* request, the margin will be added in addition to the size from
* gtk_widget_set_size_request() for example.
*/
widget_props[PROP_MARGIN_BOTTOM] =
g_param_spec_int ("margin-bottom",
P_("Margin on Bottom"),
P_("Pixels of extra space on the bottom side"),
0, G_MAXINT16,
0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:hexpand:
*
* Whether to expand horizontally. See gtk_widget_set_hexpand().
*/
widget_props[PROP_HEXPAND] =
g_param_spec_boolean ("hexpand",
P_("Horizontal Expand"),
P_("Whether widget wants more horizontal space"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:hexpand-set:
*
* Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
*/
widget_props[PROP_HEXPAND_SET] =
g_param_spec_boolean ("hexpand-set",
P_("Horizontal Expand Set"),
P_("Whether to use the hexpand property"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:vexpand:
*
* Whether to expand vertically. See gtk_widget_set_vexpand().
*/
widget_props[PROP_VEXPAND] =
g_param_spec_boolean ("vexpand",
P_("Vertical Expand"),
P_("Whether widget wants more vertical space"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:vexpand-set:
*
* Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
*/
widget_props[PROP_VEXPAND_SET] =
g_param_spec_boolean ("vexpand-set",
P_("Vertical Expand Set"),
P_("Whether to use the vexpand property"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:opacity:
*
* The requested opacity of the widget. See gtk_widget_set_opacity() for
* more details about window opacity.
*/
widget_props[PROP_OPACITY] =
g_param_spec_double ("opacity",
P_("Opacity for Widget"),
P_("The opacity of the widget, from 0 to 1"),
0.0, 1.0,
1.0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:overflow:
*
* How content outside the widget's content area is treated.
*
* This property is meant to be set by widget implementations,
* typically in their instance init function.
*/
widget_props[PROP_OVERFLOW] =
g_param_spec_enum ("overflow",
P_("Overflow"),
P_("How content outside the widget’s content area is treated"),
GTK_TYPE_OVERFLOW,
GTK_OVERFLOW_VISIBLE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkWidget:scale-factor:
*
* The scale factor of the widget. See gtk_widget_get_scale_factor() for
* more details about widget scaling.
*/
widget_props[PROP_SCALE_FACTOR] =
g_param_spec_int ("scale-factor",
P_("Scale factor"),
P_("The scaling factor of the window"),
1, G_MAXINT,
1,
GTK_PARAM_READABLE);
/**
* GtkWidget:css-name:
*
* The name of this widget in the CSS tree.
*
* This property is meant to be set by widget implementations,
* typically in their instance init function.
*/
widget_props[PROP_CSS_NAME] =
g_param_spec_string ("css-name",
P_("CSS Name"),
P_("The name of this widget in the CSS tree"),
NULL,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
/**
* GtkWidget:css-classes:
*
* A list of css classes applied to this widget.
*/
widget_props[PROP_CSS_CLASSES] =
g_param_spec_boxed ("css-classes",
P_("CSS Style Classes"),
P_("List of CSS classes"),
G_TYPE_STRV,
GTK_PARAM_READWRITE);
/**
* GtkWidget:layout-manager:
*
* The #GtkLayoutManager instance to use to compute the preferred size
* of the widget, and allocate its children.
*
* This property is meant to be set by widget implementations,
* typically in their instance init function.
*/
widget_props[PROP_LAYOUT_MANAGER] =
g_param_spec_object ("layout-manager",
P_("Layout Manager"),
P_("The layout manager used to layout children of the widget"),
GTK_TYPE_LAYOUT_MANAGER,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
g_object_class_install_properties (gobject_class, NUM_PROPERTIES, widget_props);
g_object_class_override_property (gobject_class, PROP_ACCESSIBLE_ROLE, "accessible-role");
/**
* GtkWidget::destroy:
* @object: the object which received the signal
*
* Signals that all holders of a reference to the widget should release
* the reference that they hold. May result in finalization of the widget
* if all references are released.
*
* This signal is not suitable for saving widget state.
*/
widget_signals[DESTROY] =
g_signal_new (I_("destroy"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
0,
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::show:
* @widget: the object which received the signal.
*
* The ::show signal is emitted when @widget is shown, for example with
* gtk_widget_show().
*/
widget_signals[SHOW] =
g_signal_new (I_("show"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, show),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::hide:
* @widget: the object which received the signal.
*
* The ::hide signal is emitted when @widget is hidden, for example with
* gtk_widget_hide().
*/
widget_signals[HIDE] =
g_signal_new (I_("hide"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, hide),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::map:
* @widget: the object which received the signal.
*
* The ::map signal is emitted when @widget is going to be mapped, that is
* when the widget is visible (which is controlled with
* gtk_widget_set_visible()) and all its parents up to the toplevel widget
* are also visible.
*
* The ::map signal can be used to determine whether a widget will be drawn,
* for instance it can resume an animation that was stopped during the
* emission of #GtkWidget::unmap.
*/
widget_signals[MAP] =
g_signal_new (I_("map"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, map),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::unmap:
* @widget: the object which received the signal.
*
* The ::unmap signal is emitted when @widget is going to be unmapped, which
* means that either it or any of its parents up to the toplevel widget have
* been set as hidden.
*
* As ::unmap indicates that a widget will not be shown any longer, it can be
* used to, for example, stop an animation on the widget.
*/
widget_signals[UNMAP] =
g_signal_new (I_("unmap"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, unmap),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::realize:
* @widget: the object which received the signal.
*
* The ::realize signal is emitted when @widget is associated with a
* #GdkSurface, which means that gtk_widget_realize() has been called or the
* widget has been mapped (that is, it is going to be drawn).
*/
widget_signals[REALIZE] =
g_signal_new (I_("realize"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, realize),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::unrealize:
* @widget: the object which received the signal.
*
* The ::unrealize signal is emitted when the #GdkSurface associated with
* @widget is destroyed, which means that gtk_widget_unrealize() has been
* called or the widget has been unmapped (that is, it is going to be
* hidden).
*/
widget_signals[UNREALIZE] =
g_signal_new (I_("unrealize"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, unrealize),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GtkWidget::state-flags-changed:
* @widget: the object which received the signal.
* @flags: The previous state flags.
*
* The ::state-flags-changed signal is emitted when the widget state
* changes, see gtk_widget_get_state_flags().
*/
widget_signals[STATE_FLAGS_CHANGED] =
g_signal_new (I_("state-flags-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, state_flags_changed),
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
GTK_TYPE_STATE_FLAGS);
/**
* GtkWidget::direction-changed:
* @widget: the object on which the signal is emitted
* @previous_direction: the previous text direction of @widget
*
* The ::direction-changed signal is emitted when the text direction
* of a widget changes.
*/
widget_signals[DIRECTION_CHANGED] =
g_signal_new (I_("direction-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, direction_changed),
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_DIRECTION);
/**
* GtkWidget::mnemonic-activate:
* @widget: the object which received the signal.
* @group_cycling: %TRUE if there are other widgets with the same mnemonic
*
* The default handler for this signal activates @widget if @group_cycling
* is %FALSE, or just makes @widget grab focus if @group_cycling is %TRUE.
*
* Returns: %TRUE to stop other handlers from being invoked for the event.
* %FALSE to propagate the event further.
*/
widget_signals[MNEMONIC_ACTIVATE] =
g_signal_new (I_("mnemonic-activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, mnemonic_activate),
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__BOOLEAN,
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
g_signal_set_va_marshaller (widget_signals[MNEMONIC_ACTIVATE],
G_TYPE_FROM_CLASS (gobject_class),
_gtk_marshal_BOOLEAN__BOOLEANv);
/**
* GtkWidget::move-focus:
* @widget: the object which received the signal.
* @direction: the direction of the focus move
*
* Emitted when the focus is moved.
*/
widget_signals[MOVE_FOCUS] =
g_signal_new (I_("move-focus"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, move_focus),
NULL, NULL,
NULL,
G_TYPE_NONE,
1,
GTK_TYPE_DIRECTION_TYPE);
/**
* GtkWidget::keynav-failed:
* @widget: the object which received the signal
* @direction: the direction of movement
*
* Gets emitted if keyboard navigation fails.
* See gtk_widget_keynav_failed() for details.
*
* Returns: %TRUE if stopping keyboard navigation is fine, %FALSE
* if the emitting widget should try to handle the keyboard
* navigation attempt in its parent widget(s).
**/
widget_signals[KEYNAV_FAILED] =
g_signal_new (I_("keynav-failed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, keynav_failed),
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__ENUM,
G_TYPE_BOOLEAN, 1,
GTK_TYPE_DIRECTION_TYPE);
g_signal_set_va_marshaller (widget_signals[KEYNAV_FAILED],
G_TYPE_FROM_CLASS (klass),
_gtk_marshal_BOOLEAN__ENUMv);
/**
* GtkWidget::query-tooltip:
* @widget: the object which received the signal
* @x: the x coordinate of the cursor position where the request has
* been emitted, relative to @widget's left side
* @y: the y coordinate of the cursor position where the request has
* been emitted, relative to @widget's top
* @keyboard_mode: %TRUE if the tooltip was triggered using the keyboard
* @tooltip: a #GtkTooltip
*
* Emitted when #GtkWidget:has-tooltip is %TRUE and the hover timeout
* has expired with the cursor hovering "above" @widget; or emitted when @widget got
* focus in keyboard mode.
*
* Using the given coordinates, the signal handler should determine
* whether a tooltip should be shown for @widget. If this is the case
* %TRUE should be returned, %FALSE otherwise. Note that if
* @keyboard_mode is %TRUE, the values of @x and @y are undefined and
* should not be used.
*
* The signal handler is free to manipulate @tooltip with the therefore
* destined function calls.
*
* Returns: %TRUE if @tooltip should be shown right now, %FALSE otherwise.
*/
widget_signals[QUERY_TOOLTIP] =
g_signal_new (I_("query-tooltip"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, query_tooltip),
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT,
G_TYPE_BOOLEAN, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN,
GTK_TYPE_TOOLTIP);
g_signal_set_va_marshaller (widget_signals[QUERY_TOOLTIP],
G_TYPE_FROM_CLASS (klass),
_gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECTv);
gtk_widget_class_set_css_name (klass, I_("widget"));
gtk_widget_class_set_accessible_role (klass, GTK_ACCESSIBLE_ROLE_WIDGET);
}
static void
template_child_class_free (AutomaticChildClass *child_class)
{
if (child_class)
{
g_free (child_class->name);
g_slice_free (AutomaticChildClass, child_class);
}
}
static void
gtk_widget_base_class_finalize (GtkWidgetClass *klass)
{
GtkWidgetTemplate *template_data = klass->priv->template;
if (template_data)
{
g_bytes_unref (template_data->data);
g_slist_free_full (template_data->children, (GDestroyNotify)template_child_class_free);
g_object_unref (template_data->scope);
g_slice_free (GtkWidgetTemplate, template_data);
}
g_object_unref (klass->priv->shortcuts);
}
static void
_gtk_widget_emulate_press (GtkWidget *widget,
GdkEvent *event,
GtkWidget *event_widget)
{
GtkWidget *next_child, *parent;
GdkEvent *press;
double x, y;
graphene_point_t p;
if (event_widget == widget)
return;
switch ((guint) gdk_event_get_event_type (event))
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
case GDK_TOUCH_END:
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_MOTION_NOTIFY:
gdk_event_get_position (event, &x, &y);
if (!gtk_widget_compute_point (event_widget,
GTK_WIDGET (gtk_widget_get_root (event_widget)),
&GRAPHENE_POINT_INIT (x, y),
&p))
return;
break;
default:
return;
}
switch ((guint) gdk_event_get_event_type (event))
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
case GDK_TOUCH_END:
press = gdk_touch_event_new (GDK_TOUCH_BEGIN,
gdk_event_get_event_sequence (event),
gdk_event_get_surface (event),
gdk_event_get_device (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
p.x, p.y,
NULL,
gdk_touch_event_get_emulating_pointer (event));
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
press = gdk_button_event_new (GDK_BUTTON_PRESS,
gdk_event_get_surface (event),
gdk_event_get_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
gdk_button_event_get_button (event),
p.x, p.y,
NULL);
break;
case GDK_MOTION_NOTIFY:
{
GdkModifierType state = gdk_event_get_modifier_state (event);
int button;
if (state & GDK_BUTTON3_MASK)
button = 3;
else if (state & GDK_BUTTON2_MASK)
button = 2;
else
{
if ((state & GDK_BUTTON1_MASK) == 0)
g_critical ("Guessing button number 1 on generated button press event");
button = 1;
}
press = gdk_button_event_new (GDK_BUTTON_PRESS,
gdk_event_get_surface (event),
gdk_event_get_device (event),
gdk_event_get_device_tool (event),
gdk_event_get_time (event),
gdk_event_get_modifier_state (event),
button,
p.x, p.y,
NULL);
}
break;
default:
g_assert_not_reached ();
}
next_child = event_widget;
parent = _gtk_widget_get_parent (next_child);
while (parent && parent != widget)
{
next_child = parent;
parent = _gtk_widget_get_parent (parent);
}
/* Perform propagation state starting from the next child in the chain */
gtk_propagate_event_internal (event_widget, press, next_child);
gdk_event_unref (press);
}
static GdkEvent *
_gtk_widget_get_last_event (GtkWidget *widget,
GdkEventSequence *sequence,
GtkWidget **target)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkEventController *controller;
GdkEvent *event;
GList *l;
for (l = priv->event_controllers; l; l = l->next)
{
controller = l->data;
if (!GTK_IS_GESTURE (controller))
continue;
event = gtk_gesture_get_last_event (GTK_GESTURE (controller), sequence);
if (event)
{
*target = gtk_gesture_get_last_target (GTK_GESTURE (controller), sequence);
return event;
}
}
*target = NULL;
return NULL;
}
static gboolean
_gtk_widget_get_emulating_sequence (GtkWidget *widget,
GdkEventSequence *sequence,
GdkEventSequence **sequence_out)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*sequence_out = sequence;
if (sequence)
{
GdkEvent *last_event;
GtkWidget *target;
last_event = _gtk_widget_get_last_event (widget, sequence, &target);
if (last_event &&
(gdk_event_get_event_type (last_event) == GDK_TOUCH_BEGIN ||
gdk_event_get_event_type (last_event) == GDK_TOUCH_UPDATE ||
gdk_event_get_event_type (last_event) == GDK_TOUCH_END) &&
gdk_touch_event_get_emulating_pointer (last_event))
return TRUE;
}
else
{
GList *l;
/* For a NULL(pointer) sequence, find the pointer emulating one */
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
if (!GTK_IS_GESTURE (controller))
continue;
if (_gtk_gesture_get_pointer_emulating_sequence (GTK_GESTURE (controller),
sequence_out))
return TRUE;
}
}
return FALSE;
}
static gboolean
gtk_widget_needs_press_emulation (GtkWidget *widget,
GdkEventSequence *sequence)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean sequence_press_handled = FALSE;
GList *l;
/* Check whether there is any remaining gesture in
* the capture phase that handled the press event
*/
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
GtkPropagationPhase phase;
GtkGesture *gesture;
phase = gtk_event_controller_get_propagation_phase (controller);
if (phase != GTK_PHASE_CAPTURE)
continue;
if (!GTK_IS_GESTURE (controller))
continue;
gesture = GTK_GESTURE (controller);
sequence_press_handled |=
(gtk_gesture_handles_sequence (gesture, sequence) &&
_gtk_gesture_handled_sequence_press (gesture, sequence));
}
return !sequence_press_handled;
}
static int
_gtk_widget_set_sequence_state_internal (GtkWidget *widget,
GdkEventSequence *sequence,
GtkEventSequenceState state,
GtkGesture *emitter)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean emulates_pointer, sequence_handled = FALSE;
GdkEvent *mimic_event;
GtkWidget *target;
GList *group = NULL, *l;
GdkEventSequence *seq;
int n_handled = 0;
if (!priv->event_controllers && state != GTK_EVENT_SEQUENCE_CLAIMED)
return TRUE;
if (emitter)
group = gtk_gesture_get_group (emitter);
emulates_pointer = _gtk_widget_get_emulating_sequence (widget, sequence, &seq);
mimic_event = _gtk_widget_get_last_event (widget, seq, &target);
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller;
GtkEventSequenceState gesture_state;
GtkGesture *gesture;
gboolean retval;
seq = sequence;
controller = l->data;
gesture_state = state;
if (!GTK_IS_GESTURE (controller))
continue;
gesture = GTK_GESTURE (controller);
if (gesture == emitter)
{
sequence_handled |=
_gtk_gesture_handled_sequence_press (gesture, sequence);
n_handled++;
continue;
}
if (seq && emulates_pointer &&
!gtk_gesture_handles_sequence (gesture, seq))
seq = NULL;
if (group && !g_list_find (group, controller))
{
/* If a group is provided, ensure only gestures pertaining to the group
* get a "claimed" state, all other claiming gestures must deny the sequence.
*/
if (state == GTK_EVENT_SEQUENCE_CLAIMED)
gesture_state = GTK_EVENT_SEQUENCE_DENIED;
else
continue;
}
else if (!group &&
gtk_gesture_get_sequence_state (gesture, sequence) != GTK_EVENT_SEQUENCE_CLAIMED)
continue;
retval = gtk_gesture_set_sequence_state (gesture, seq, gesture_state);
if (retval || gesture == emitter)
{
sequence_handled |=
_gtk_gesture_handled_sequence_press (gesture, seq);
n_handled++;
}
}
/* If the sequence goes denied, check whether this is a controller attached
* to the capture phase, that additionally handled the button/touch press (i.e.
* it was consumed), the corresponding press will be emulated for widgets
* beneath, so the widgets beneath get a coherent stream of events from now on.
*/
if (n_handled > 0 && sequence_handled &&
state == GTK_EVENT_SEQUENCE_DENIED &&
gtk_widget_needs_press_emulation (widget, sequence))
_gtk_widget_emulate_press (widget, mimic_event, target);
g_list_free (group);
return n_handled;
}
static gboolean
_gtk_widget_cancel_sequence (GtkWidget *widget,
GdkEventSequence *sequence)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean emulates_pointer;
gboolean handled = FALSE;
GdkEventSequence *seq;
GList *l;
emulates_pointer = _gtk_widget_get_emulating_sequence (widget, sequence, &seq);
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller;
GtkGesture *gesture;
seq = sequence;
controller = l->data;
if (!GTK_IS_GESTURE (controller))
continue;
gesture = GTK_GESTURE (controller);
if (seq && emulates_pointer &&
!gtk_gesture_handles_sequence (gesture, seq))
seq = NULL;
if (!gtk_gesture_handles_sequence (gesture, seq))
continue;
handled |= _gtk_gesture_cancel_sequence (gesture, seq);
}
return handled;
}
static gboolean
gtk_widget_class_get_visible_by_default (GtkWidgetClass *widget_class)
{
return !g_type_is_a (G_TYPE_FROM_CLASS (widget_class), GTK_TYPE_NATIVE);
}
static void
gtk_widget_init (GTypeInstance *instance, gpointer g_class)
{
GtkWidget *widget = GTK_WIDGET (instance);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GType layout_manager_type;
GtkEventController *controller;
widget->priv = priv;
priv->visible = gtk_widget_class_get_visible_by_default (g_class);
priv->child_visible = TRUE;
priv->name = NULL;
priv->user_alpha = 255;
priv->parent = NULL;
priv->first_child = NULL;
priv->last_child = NULL;
priv->prev_sibling = NULL;
priv->next_sibling = NULL;
priv->baseline = -1;
priv->allocated_size_baseline = -1;
priv->sensitive = TRUE;
priv->alloc_needed = TRUE;
priv->alloc_needed_on_child = TRUE;
priv->draw_needed = TRUE;
priv->focus_on_click = TRUE;
priv->can_focus = TRUE;
priv->focusable = FALSE;
priv->can_target = TRUE;
switch (_gtk_widget_get_direction (widget))
{
case GTK_TEXT_DIR_LTR:
priv->state_flags = GTK_STATE_FLAG_DIR_LTR;
break;
case GTK_TEXT_DIR_RTL:
priv->state_flags = GTK_STATE_FLAG_DIR_RTL;
break;
case GTK_TEXT_DIR_NONE:
default:
g_assert_not_reached ();
break;
}
/* this will be set to TRUE if the widget gets a child or if the
* expand flag is set on the widget, but until one of those happen
* we know the expand is already properly FALSE.
*
* We really want to default FALSE here to avoid computing expand
* all over the place while initially building a widget tree.
*/
priv->need_compute_expand = FALSE;
priv->halign = GTK_ALIGN_FILL;
priv->valign = GTK_ALIGN_FILL;
priv->accessible_role = GTK_ACCESSIBLE_ROLE_WIDGET;
priv->width_request = -1;
priv->height_request = -1;
_gtk_size_request_cache_init (&priv->requests);
priv->cssnode = gtk_css_widget_node_new (widget);
gtk_css_node_set_state (priv->cssnode, priv->state_flags);
gtk_css_node_set_visible (priv->cssnode, priv->visible);
/* need to set correct name here, and only class has the correct type here */
gtk_css_node_set_name (priv->cssnode, GTK_WIDGET_CLASS (g_class)->priv->css_name);
if (g_type_is_a (G_TYPE_FROM_CLASS (g_class), GTK_TYPE_ROOT))
priv->root = (GtkRoot *) widget;
if (g_type_is_a (G_TYPE_FROM_CLASS (g_class), GTK_TYPE_SHORTCUT_MANAGER))
gtk_shortcut_manager_create_controllers (widget);
layout_manager_type = gtk_widget_class_get_layout_manager_type (g_class);
if (layout_manager_type != G_TYPE_INVALID)
gtk_widget_set_layout_manager (widget, g_object_new (layout_manager_type, NULL));
if (g_list_model_get_n_items (G_LIST_MODEL (GTK_WIDGET_CLASS (g_class)->priv->shortcuts)) > 0)
{
controller = gtk_shortcut_controller_new_for_model (G_LIST_MODEL (GTK_WIDGET_CLASS (g_class)->priv->shortcuts));
gtk_event_controller_set_name (controller, "gtk-widget-class-shortcuts");
gtk_widget_add_controller (widget, controller);
}
priv->at_context = gtk_accessible_get_at_context (GTK_ACCESSIBLE (widget));
}
void
gtk_widget_realize_at_context (GtkWidget *self)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (self);
GtkAccessibleRole role = priv->accessible_role;
if (priv->at_context == NULL || gtk_at_context_is_realized (priv->at_context))
return;
/* Reset the accessible role to its current value */
if (role == GTK_ACCESSIBLE_ROLE_WIDGET)
{
GtkWidgetClassPrivate *class_priv = GTK_WIDGET_GET_CLASS (self)->priv;
role = class_priv->accessible_role;
}
gtk_at_context_set_accessible_role (priv->at_context, role);
gtk_at_context_set_display (priv->at_context, gtk_root_get_display (priv->root));
gtk_at_context_realize (priv->at_context);
}
void
gtk_widget_unrealize_at_context (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->at_context != NULL)
{
gtk_at_context_set_display (priv->at_context, gdk_display_get_default ());
gtk_at_context_unrealize (priv->at_context);
}
}
void
gtk_widget_root (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_assert (!priv->realized);
if (GTK_IS_ROOT (widget))
{
g_assert (priv->root == GTK_ROOT (widget));
}
else
{
g_assert (priv->root == NULL);
priv->root = priv->parent->priv->root;
}
if (priv->context)
gtk_style_context_set_display (priv->context, gtk_root_get_display (priv->root));
if (priv->surface_transform_data)
add_parent_surface_transform_changed_listener (widget);
_gtk_widget_update_parent_muxer (widget);
if (priv->layout_manager)
gtk_layout_manager_set_root (priv->layout_manager, priv->root);
GTK_WIDGET_GET_CLASS (widget)->root (widget);
if (!GTK_IS_ROOT (widget))
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_ROOT]);
}
void
gtk_widget_unroot (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data;
g_assert (priv->root);
g_assert (!priv->realized);
surface_transform_data = priv->surface_transform_data;
if (surface_transform_data &&
surface_transform_data->tracked_parent)
remove_parent_surface_transform_changed_listener (widget);
_gtk_widget_update_parent_muxer (widget);
GTK_WIDGET_GET_CLASS (widget)->unroot (widget);
if (priv->context)
gtk_style_context_set_display (priv->context, gdk_display_get_default ());
if (priv->layout_manager)
gtk_layout_manager_set_root (priv->layout_manager, NULL);
if (g_object_get_qdata (G_OBJECT (widget), quark_pango_context))
g_object_set_qdata (G_OBJECT (widget), quark_pango_context, NULL);
_gtk_tooltip_hide (widget);
if (!GTK_IS_ROOT (widget))
{
priv->root = NULL;
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_ROOT]);
}
}
/**
* gtk_widget_unparent:
* @widget: a #GtkWidget
*
* This function is only for use in widget implementations.
* It should be called by parent widgets to dissociate @widget
* from the parent, typically in dispose.
**/
void
gtk_widget_unparent (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidget *old_parent;
GtkWidget *old_prev_sibling;
GtkRoot *root;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->parent == NULL)
return;
gtk_widget_push_verify_invariants (widget);
g_object_freeze_notify (G_OBJECT (widget));
gtk_accessible_update_children (GTK_ACCESSIBLE (priv->parent),
GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_CHILD_STATE_REMOVED);
root = _gtk_widget_get_root (widget);
if (GTK_IS_WINDOW (root))
_gtk_window_unset_focus_and_default (GTK_WINDOW (root), widget);
if (gtk_widget_get_focus_child (priv->parent) == widget)
gtk_widget_set_focus_child (priv->parent, NULL);
if (_gtk_widget_get_mapped (priv->parent))
gtk_widget_queue_draw (priv->parent);
if (priv->visible && _gtk_widget_get_visible (priv->parent))
gtk_widget_queue_resize (priv->parent);
/* Reset the width and height here, to force reallocation if we
* get added back to a new parent.
*/
priv->width = 0;
priv->height = 0;
if (_gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
if (priv->root)
gtk_widget_unroot (widget);
root = NULL;
/* Removing a widget from a container restores the child visible
* flag to the default state, so it doesn't affect the child
* in the next parent.
*/
priv->child_visible = TRUE;
old_parent = priv->parent;
if (old_parent)
{
if (old_parent->priv->first_child == widget)
old_parent->priv->first_child = priv->next_sibling;
if (old_parent->priv->last_child == widget)
old_parent->priv->last_child = priv->prev_sibling;
if (priv->prev_sibling)
priv->prev_sibling->priv->next_sibling = priv->next_sibling;
if (priv->next_sibling)
priv->next_sibling->priv->prev_sibling = priv->prev_sibling;
}
old_prev_sibling = priv->prev_sibling;
priv->parent = NULL;
priv->prev_sibling = NULL;
priv->next_sibling = NULL;
/* parent may no longer expand if the removed
* child was expand=TRUE and could therefore
* be forcing it to.
*/
if (_gtk_widget_get_visible (widget) &&
(priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand))
{
gtk_widget_queue_compute_expand (old_parent);
}
/* Unset BACKDROP since we are no longer inside a toplevel window */
gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_BACKDROP);
gtk_css_node_set_parent (priv->cssnode, NULL);
_gtk_widget_update_parent_muxer (widget);
if (old_parent->priv->children_observer)
gtk_list_list_model_item_removed (old_parent->priv->children_observer, old_prev_sibling);
if (old_parent->priv->layout_manager)
gtk_layout_manager_remove_layout_child (old_parent->priv->layout_manager, widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_PARENT]);
g_object_thaw_notify (G_OBJECT (widget));
gtk_widget_pop_verify_invariants (widget);
g_object_unref (widget);
}
static void
gtk_widget_update_paintables (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *l;
for (l = priv->paintables; l; l = l->next)
gtk_widget_paintable_update_image (l->data);
}
static void
gtk_widget_push_paintables (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *l;
for (l = priv->paintables; l; l = l->next)
gtk_widget_paintable_push_snapshot_count (l->data);
}
static void
gtk_widget_pop_paintables (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *l;
for (l = priv->paintables; l; l = l->next)
gtk_widget_paintable_pop_snapshot_count (l->data);
}
/**
* gtk_widget_show:
* @widget: a #GtkWidget
*
* Flags a widget to be displayed. Any widget that isn’t shown will
* not appear on the screen.
*
* Remember that you have to show the containers containing a widget,
* in addition to the widget itself, before it will appear onscreen.
*
* When a toplevel container is shown, it is immediately realized and
* mapped; other shown widgets are realized and mapped when their
* toplevel container is realized and mapped.
**/
void
gtk_widget_show (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (!_gtk_widget_get_visible (widget))
{
GtkWidget *parent;
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
parent = _gtk_widget_get_parent (widget);
if (parent)
{
gtk_widget_queue_resize (parent);
/* see comment in set_parent() for why this should and can be
* conditional
*/
if (priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand)
gtk_widget_queue_compute_expand (parent);
}
gtk_css_node_set_visible (priv->cssnode, TRUE);
g_signal_emit (widget, widget_signals[SHOW], 0);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_VISIBLE]);
gtk_accessible_update_state (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_STATE_HIDDEN, FALSE,
-1);
gtk_widget_pop_verify_invariants (widget);
g_object_unref (widget);
}
}
static void
gtk_widget_real_show (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (!_gtk_widget_get_visible (widget));
priv->visible = TRUE;
if (priv->parent &&
_gtk_widget_get_mapped (priv->parent) &&
_gtk_widget_get_child_visible (widget) &&
!_gtk_widget_get_mapped (widget))
gtk_widget_map (widget);
}
/**
* gtk_widget_hide:
* @widget: a #GtkWidget
*
* Reverses the effects of gtk_widget_show(), causing the widget to be
* hidden (invisible to the user).
**/
void
gtk_widget_hide (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (_gtk_widget_get_visible (widget))
{
GtkWidget *parent;
GtkRoot *root;
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
root = _gtk_widget_get_root (widget);
if (GTK_WIDGET (root) != widget && GTK_IS_WINDOW (root))
_gtk_window_unset_focus_and_default (GTK_WINDOW (root), widget);
/* a parent may now be expand=FALSE since we're hidden. */
if (priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand)
{
gtk_widget_queue_compute_expand (widget);
}
gtk_css_node_set_visible (priv->cssnode, FALSE);
g_signal_emit (widget, widget_signals[HIDE], 0);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_VISIBLE]);
gtk_accessible_update_state (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_STATE_HIDDEN, TRUE,
-1);
parent = gtk_widget_get_parent (widget);
if (parent)
gtk_widget_queue_resize (parent);
gtk_widget_queue_allocate (widget);
gtk_widget_pop_verify_invariants (widget);
g_object_unref (widget);
}
}
static void
gtk_widget_real_hide (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (_gtk_widget_get_visible (widget));
priv->visible = FALSE;
if (_gtk_widget_get_mapped (widget))
gtk_widget_unmap (widget);
g_clear_pointer (&priv->allocated_transform, gsk_transform_unref);
priv->allocated_width = 0;
priv->allocated_height = 0;
priv->allocated_size_baseline = 0;
g_clear_pointer (&priv->transform, gsk_transform_unref);
priv->width = 0;
priv->height = 0;
gtk_widget_update_paintables (widget);
}
static void
update_cursor_on_state_change (GtkWidget *widget)
{
GtkRoot *root;
root = _gtk_widget_get_root (widget);
if (GTK_IS_WINDOW (root))
gtk_window_update_pointer_focus_on_state_change (GTK_WINDOW (root), widget);
}
/**
* gtk_widget_map:
* @widget: a #GtkWidget
*
* This function is only for use in widget implementations. Causes
* a widget to be mapped if it isn’t already.
**/
void
gtk_widget_map (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (_gtk_widget_get_visible (widget));
g_return_if_fail (_gtk_widget_get_child_visible (widget));
if (!_gtk_widget_get_mapped (widget))
{
gtk_widget_push_verify_invariants (widget);
if (!_gtk_widget_get_realized (widget))
gtk_widget_realize (widget);
g_signal_emit (widget, widget_signals[MAP], 0);
update_cursor_on_state_change (widget);
gtk_widget_queue_draw (widget);
gtk_widget_pop_verify_invariants (widget);
}
}
/**
* gtk_widget_unmap:
* @widget: a #GtkWidget
*
* This function is only for use in widget implementations. Causes
* a widget to be unmapped if it’s currently mapped.
**/
void
gtk_widget_unmap (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (_gtk_widget_get_mapped (widget))
{
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
gtk_widget_queue_draw (widget);
_gtk_tooltip_hide (widget);
g_signal_emit (widget, widget_signals[UNMAP], 0);
update_cursor_on_state_change (widget);
gtk_widget_pop_verify_invariants (widget);
g_object_unref (widget);
}
}
typedef struct _GtkTickCallbackInfo GtkTickCallbackInfo;
struct _GtkTickCallbackInfo
{
guint refcount;
guint id;
GtkTickCallback callback;
gpointer user_data;
GDestroyNotify notify;
guint destroyed : 1;
};
static void
ref_tick_callback_info (GtkTickCallbackInfo *info)
{
info->refcount++;
}
static void
unref_tick_callback_info (GtkWidget *widget,
GtkTickCallbackInfo *info,
GList *link)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
info->refcount--;
if (info->refcount == 0)
{
priv->tick_callbacks = g_list_delete_link (priv->tick_callbacks, link);
if (info->notify)
info->notify (info->user_data);
g_slice_free (GtkTickCallbackInfo, info);
}
if (priv->tick_callbacks == NULL && priv->clock_tick_id)
{
GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
g_signal_handler_disconnect (frame_clock, priv->clock_tick_id);
priv->clock_tick_id = 0;
gdk_frame_clock_end_updating (frame_clock);
}
}
static void
destroy_tick_callback_info (GtkWidget *widget,
GtkTickCallbackInfo *info,
GList *link)
{
if (!info->destroyed)
{
info->destroyed = TRUE;
unref_tick_callback_info (widget, info, link);
}
}
static void
destroy_tick_callbacks (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
for (l = priv->tick_callbacks; l;)
{
GList *next = l->next;
destroy_tick_callback_info (widget, l->data, l);
l = next;
}
}
static void
gtk_widget_on_frame_clock_update (GdkFrameClock *frame_clock,
GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
g_object_ref (widget);
for (l = priv->tick_callbacks; l;)
{
GtkTickCallbackInfo *info = l->data;
GList *next;
ref_tick_callback_info (info);
if (!info->destroyed)
{
if (info->callback (widget,
frame_clock,
info->user_data) == G_SOURCE_REMOVE)
{
destroy_tick_callback_info (widget, info, l);
}
}
next = l->next;
unref_tick_callback_info (widget, info, l);
l = next;
}
g_object_unref (widget);
}
static guint tick_callback_id;
/**
* gtk_widget_add_tick_callback:
* @widget: a #GtkWidget
* @callback: function to call for updating animations
* @user_data: (closure): data to pass to @callback
* @notify: function to call to free @user_data when the callback is removed.
*
* Queues an animation frame update and adds a callback to be called
* before each frame. Until the tick callback is removed, it will be
* called frequently (usually at the frame rate of the output device
* or as quickly as the application can be repainted, whichever is
* slower). For this reason, is most suitable for handling graphics
* that change every frame or every few frames. The tick callback does
* not automatically imply a relayout or repaint. If you want a
* repaint or relayout, and aren’t changing widget properties that
* would trigger that (for example, changing the text of a #GtkLabel),
* then you will have to call gtk_widget_queue_resize() or
* gtk_widget_queue_draw() yourself.
*
* gdk_frame_clock_get_frame_time() should generally be used for timing
* continuous animations and
* gdk_frame_timings_get_predicted_presentation_time() if you are
* trying to display isolated frames at particular times.
*
* This is a more convenient alternative to connecting directly to the
* #GdkFrameClock::update signal of #GdkFrameClock, since you don't
* have to worry about when a #GdkFrameClock is assigned to a widget.
*
* Returns: an id for the connection of this callback. Remove the callback
* by passing the id returned from this function to
* gtk_widget_remove_tick_callback()
*/
guint
gtk_widget_add_tick_callback (GtkWidget *widget,
GtkTickCallback callback,
gpointer user_data,
GDestroyNotify notify)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkTickCallbackInfo *info;
GdkFrameClock *frame_clock;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
if (priv->realized && !priv->clock_tick_id)
{
frame_clock = gtk_widget_get_frame_clock (widget);
if (frame_clock)
{
priv->clock_tick_id = g_signal_connect (frame_clock, "update",
G_CALLBACK (gtk_widget_on_frame_clock_update),
widget);
gdk_frame_clock_begin_updating (frame_clock);
}
}
info = g_slice_new0 (GtkTickCallbackInfo);
info->refcount = 1;
info->id = ++tick_callback_id;
info->callback = callback;
info->user_data = user_data;
info->notify = notify;
priv->tick_callbacks = g_list_prepend (priv->tick_callbacks,
info);
return info->id;
}
/**
* gtk_widget_remove_tick_callback:
* @widget: a #GtkWidget
* @id: an id returned by gtk_widget_add_tick_callback()
*
* Removes a tick callback previously registered with
* gtk_widget_add_tick_callback().
*/
void
gtk_widget_remove_tick_callback (GtkWidget *widget,
guint id)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
g_return_if_fail (GTK_IS_WIDGET (widget));
for (l = priv->tick_callbacks; l; l = l->next)
{
GtkTickCallbackInfo *info = l->data;
if (info->id == id)
{
destroy_tick_callback_info (widget, info, l);
return;
}
}
}
gboolean
gtk_widget_has_tick_callback (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->tick_callbacks != NULL;
}
typedef struct _GtkSurfaceTransformChangedCallbackInfo GtkSurfaceTransformChangedCallbackInfo;
struct _GtkSurfaceTransformChangedCallbackInfo
{
guint id;
GtkSurfaceTransformChangedCallback callback;
gpointer user_data;
GDestroyNotify notify;
};
static void
surface_transform_changed_callback_info_destroy (GtkSurfaceTransformChangedCallbackInfo *info)
{
if (info->notify)
info->notify (info->user_data);
g_slice_free (GtkSurfaceTransformChangedCallbackInfo, info);
}
static void
notify_surface_transform_changed (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data =
priv->surface_transform_data;
graphene_matrix_t *surface_transform;
GList *l;
if (surface_transform_data->cached_surface_transform_valid)
surface_transform = &surface_transform_data->cached_surface_transform;
else
surface_transform = NULL;
for (l = surface_transform_data->callbacks; l;)
{
GtkSurfaceTransformChangedCallbackInfo *info = l->data;
GList *l_next = l->next;
if (info->callback (widget,
surface_transform,
info->user_data) == G_SOURCE_REMOVE)
{
surface_transform_data->callbacks =
g_list_delete_link (surface_transform_data->callbacks, l);
surface_transform_changed_callback_info_destroy (info);
}
l = l_next;
}
}
static void
destroy_surface_transform_data (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data;
surface_transform_data = priv->surface_transform_data;
if (!surface_transform_data)
return;
g_list_free_full (surface_transform_data->callbacks,
(GDestroyNotify) surface_transform_changed_callback_info_destroy);
g_slice_free (GtkWidgetSurfaceTransformData, surface_transform_data);
priv->surface_transform_data = NULL;
}
static void
sync_widget_surface_transform (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data =
priv->surface_transform_data;
gboolean was_valid;
graphene_matrix_t prev_transform;
was_valid = surface_transform_data->cached_surface_transform_valid;
prev_transform = surface_transform_data->cached_surface_transform;
if (GTK_IS_NATIVE (widget))
{
gsk_transform_to_matrix (priv->transform,
&surface_transform_data->cached_surface_transform);
surface_transform_data->cached_surface_transform_valid = TRUE;
}
else if (!priv->root)
{
surface_transform_data->cached_surface_transform_valid = FALSE;
}
else
{
GtkWidget *native = GTK_WIDGET (gtk_widget_get_native (widget));
if (gtk_widget_compute_transform (widget, native,
&surface_transform_data->cached_surface_transform))
{
surface_transform_data->cached_surface_transform_valid = TRUE;
}
else
{
g_warning ("Could not compute surface transform");
surface_transform_data->cached_surface_transform_valid = FALSE;
}
}
if (was_valid != surface_transform_data->cached_surface_transform_valid ||
(was_valid && surface_transform_data->cached_surface_transform_valid &&
!graphene_matrix_equal (&surface_transform_data->cached_surface_transform,
&prev_transform)))
notify_surface_transform_changed (widget);
}
static guint surface_transform_changed_callback_id;
static gboolean
parent_surface_transform_changed_cb (GtkWidget *parent,
const graphene_matrix_t *transform,
gpointer user_data)
{
GtkWidget *widget = GTK_WIDGET (user_data);
sync_widget_surface_transform (widget);
return G_SOURCE_CONTINUE;
}
static void
remove_parent_surface_transform_changed_listener (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data =
priv->surface_transform_data;
g_assert (surface_transform_data->tracked_parent);
gtk_widget_remove_surface_transform_changed_callback (
surface_transform_data->tracked_parent,
surface_transform_data->parent_surface_transform_changed_id);
surface_transform_data->parent_surface_transform_changed_id = 0;
g_clear_object (&surface_transform_data->tracked_parent);
}
static void
add_parent_surface_transform_changed_listener (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidgetSurfaceTransformData *surface_transform_data =
priv->surface_transform_data;
GtkWidget *parent;
g_assert (!surface_transform_data->tracked_parent);
parent = priv->parent;
surface_transform_data->parent_surface_transform_changed_id =
gtk_widget_add_surface_transform_changed_callback (
parent,
parent_surface_transform_changed_cb,
widget,
NULL);
surface_transform_data->tracked_parent = g_object_ref (parent);
}
static GtkWidgetSurfaceTransformData *
ensure_surface_transform_data (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->surface_transform_data)
priv->surface_transform_data = g_slice_new0 (GtkWidgetSurfaceTransformData);
return priv->surface_transform_data;
}
/**
* gtk_widget_add_surface_transform_changed_callback:
* @widget: a #GtkWidget
* @callback: a function to call when the surface transform changes
* @user_data: (closure): data to pass to @callback
* @notify: function to call to free @user_data when the callback is removed
*
* Invokes the callback whenever the surface relative transform of the widget
* changes.
*
* Returns: an id for the connection of this callback. Remove the callback by
* passing the id returned from this funcction to
* gtk_widget_remove_surface_transform_changed_callback()
*/
guint
gtk_widget_add_surface_transform_changed_callback (GtkWidget *widget,
GtkSurfaceTransformChangedCallback callback,
gpointer user_data,
GDestroyNotify notify)
{
GtkWidgetPrivate *priv;
GtkWidgetSurfaceTransformData *surface_transform_data;
GtkSurfaceTransformChangedCallbackInfo *info;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
g_return_val_if_fail (callback, 0);
priv = gtk_widget_get_instance_private (widget);
surface_transform_data = ensure_surface_transform_data (widget);
if (priv->parent &&
!surface_transform_data->parent_surface_transform_changed_id)
add_parent_surface_transform_changed_listener (widget);
if (!surface_transform_data->callbacks)
sync_widget_surface_transform (widget);
info = g_slice_new0 (GtkSurfaceTransformChangedCallbackInfo);
info->id = ++surface_transform_changed_callback_id;
info->callback = callback;
info->user_data = user_data;
info->notify = notify;
surface_transform_data->callbacks =
g_list_prepend (surface_transform_data->callbacks, info);
return info->id;
}
/**
* gtk_widget_remove_surface_transform_changed_callback:
* @widget: a #GtkWidget
* @id: an id returned by gtk_widget_add_surface_transform_changed_callback()
*
* Removes a surface transform changed callback previously registered with
* gtk_widget_add_surface_transform_changed_callback().
*/
void
gtk_widget_remove_surface_transform_changed_callback (GtkWidget *widget,
guint id)
{
GtkWidgetPrivate *priv;
GtkWidgetSurfaceTransformData *surface_transform_data;
GList *l;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (id);
priv = gtk_widget_get_instance_private (widget);
surface_transform_data = priv->surface_transform_data;
g_return_if_fail (surface_transform_data);
for (l = surface_transform_data->callbacks; l; l = l->next)
{
GtkSurfaceTransformChangedCallbackInfo *info = l->data;
if (info->id == id)
{
surface_transform_data->callbacks =
g_list_delete_link (surface_transform_data->callbacks, l);
surface_transform_changed_callback_info_destroy (info);
break;
}
}
if (!surface_transform_data->callbacks)
{
if (surface_transform_data->tracked_parent)
remove_parent_surface_transform_changed_listener (widget);
g_slice_free (GtkWidgetSurfaceTransformData, surface_transform_data);
priv->surface_transform_data = NULL;
}
}
GdkSurface *
gtk_widget_get_surface (GtkWidget *widget)
{
GtkNative *native = gtk_widget_get_native (widget);
if (native)
return gtk_native_get_surface (native);
return NULL;
}
/**
* gtk_widget_realize:
* @widget: a #GtkWidget
*
* Creates the GDK (windowing system) resources associated with a
* widget. Normally realization happens implicitly; if you show
* a widget and all its parent containers, then the widget will be
* realized and mapped automatically.
*
* Realizing a widget requires all
* the widget’s parent widgets to be realized; calling
* gtk_widget_realize() realizes the widget’s parents in addition to
* @widget itself. If a widget is not yet inside a toplevel window
* when you realize it, bad things will happen.
*
* This function is primarily used in widget implementations, and
* isn’t very useful otherwise. Many times when you think you might
* need it, a better approach is to connect to a signal that will be
* called after the widget is realized automatically, such as
* #GtkWidget::realize.
**/
void
gtk_widget_realize (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->realized)
return;
gtk_widget_push_verify_invariants (widget);
/*
if (GTK_IS_CONTAINER (widget) && _gtk_widget_get_has_surface (widget))
g_message ("gtk_widget_realize(%s)", G_OBJECT_TYPE_NAME (widget));
*/
if (priv->parent == NULL && !GTK_IS_ROOT (widget))
g_warning ("Calling gtk_widget_realize() on a widget that isn't "
"inside a toplevel window is not going to work very well. "
"Widgets must be inside a toplevel container before realizing them.");
if (priv->parent && !_gtk_widget_get_realized (priv->parent))
gtk_widget_realize (priv->parent);
g_signal_emit (widget, widget_signals[REALIZE], 0);
if (priv->context)
gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget));
else
gtk_widget_get_style_context (widget);
gtk_widget_pop_verify_invariants (widget);
}
/**
* gtk_widget_unrealize:
* @widget: a #GtkWidget
*
* This function is only useful in widget implementations.
* Causes a widget to be unrealized (frees all GDK resources
* associated with the widget).
**/
void
gtk_widget_unrealize (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
if (_gtk_widget_get_realized (widget))
{
if (priv->mapped)
gtk_widget_unmap (widget);
g_signal_emit (widget, widget_signals[UNREALIZE], 0);
g_assert (!priv->mapped);
g_assert (!priv->realized);
}
gtk_widget_pop_verify_invariants (widget);
g_object_unref (widget);
}
void
gtk_widget_get_surface_allocation (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkNative *native;
graphene_rect_t bounds;
double nx, ny;
native = gtk_widget_get_native (widget);
g_assert (GTK_IS_WINDOW (native) || GTK_IS_POPOVER (native));
gtk_native_get_surface_transform (native, &nx, &ny);
if (gtk_widget_compute_bounds (widget, GTK_WIDGET (native), &bounds))
{
*allocation = (GtkAllocation) {
floorf (bounds.origin.x) + nx,
floorf (bounds.origin.y) + ny,
ceilf (bounds.size.width),
ceilf (bounds.size.height)
};
}
else
{
*allocation = (GtkAllocation) { 0, 0, 0, 0 };
}
}
/**
* gtk_widget_queue_draw:
* @widget: a #GtkWidget
*
* Schedules this widget to be redrawn in paint phase of the
* current or the next frame. This means @widget's GtkWidgetClass.snapshot()
* implementation will be called.
**/
void
gtk_widget_queue_draw (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
/* Just return if the widget isn't mapped */
if (!_gtk_widget_get_mapped (widget))
return;
for (; widget; widget = _gtk_widget_get_parent (widget))
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->draw_needed)
break;
priv->draw_needed = TRUE;
g_clear_pointer (&priv->render_node, gsk_render_node_unref);
if (GTK_IS_NATIVE (widget) && _gtk_widget_get_realized (widget))
gdk_surface_queue_render (gtk_native_get_surface (GTK_NATIVE (widget)));
}
}
static void
gtk_widget_set_alloc_needed (GtkWidget *widget);
/**
* gtk_widget_queue_allocate:
* @widget: a #GtkWidget
*
* This function is only for use in widget implementations.
*
* Flags the widget for a rerun of the GtkWidgetClass::size_allocate
* function. Use this function instead of gtk_widget_queue_resize()
* when the @widget's size request didn't change but it wants to
* reposition its contents.
*
* An example user of this function is gtk_widget_set_halign().
*/
void
gtk_widget_queue_allocate (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (_gtk_widget_get_realized (widget))
gtk_widget_queue_draw (widget);
gtk_widget_set_alloc_needed (widget);
}
static inline gboolean
gtk_widget_get_resize_needed (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->resize_needed;
}
/*
* gtk_widget_queue_resize_internal:
* @widget: a #GtkWidget
*
* Queue a resize on a widget, and on all other widgets grouped with this widget.
*/
static void
gtk_widget_queue_resize_internal (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *groups, *l, *widgets;
if (gtk_widget_get_resize_needed (widget))
return;
priv->resize_needed = TRUE;
gtk_widget_set_alloc_needed (widget);
if (priv->resize_func)
priv->resize_func (widget);
groups = _gtk_widget_get_sizegroups (widget);
for (l = groups; l; l = l->next)
{
for (widgets = gtk_size_group_get_widgets (l->data); widgets; widgets = widgets->next)
gtk_widget_queue_resize_internal (widgets->data);
}
if (_gtk_widget_get_visible (widget))
{
GtkWidget *parent = _gtk_widget_get_parent (widget);
if (parent)
{
if (GTK_IS_NATIVE (widget))
gtk_widget_queue_allocate (parent);
else
gtk_widget_queue_resize_internal (parent);
}
}
}
/**
* gtk_widget_queue_resize:
* @widget: a #GtkWidget
*
* This function is only for use in widget implementations.
* Flags a widget to have its size renegotiated; should
* be called when a widget for some reason has a new size request.
* For example, when you change the text in a #GtkLabel, #GtkLabel
* queues a resize to ensure there’s enough space for the new text.
*
* Note that you cannot call gtk_widget_queue_resize() on a widget
* from inside its implementation of the GtkWidgetClass::size_allocate
* virtual method. Calls to gtk_widget_queue_resize() from inside
* GtkWidgetClass::size_allocate will be silently ignored.
**/
void
gtk_widget_queue_resize (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (_gtk_widget_get_realized (widget))
gtk_widget_queue_draw (widget);
gtk_widget_queue_resize_internal (widget);
}
/**
* gtk_widget_get_frame_clock:
* @widget: a #GtkWidget
*
* Obtains the frame clock for a widget. The frame clock is a global
* “ticker” that can be used to drive animations and repaints. The
* most common reason to get the frame clock is to call
* gdk_frame_clock_get_frame_time(), in order to get a time to use for
* animating. For example you might record the start of the animation
* with an initial value from gdk_frame_clock_get_frame_time(), and
* then update the animation by calling
* gdk_frame_clock_get_frame_time() again during each repaint.
*
* gdk_frame_clock_request_phase() will result in a new frame on the
* clock, but won’t necessarily repaint any widgets. To repaint a
* widget, you have to use gtk_widget_queue_draw() which invalidates
* the widget (thus scheduling it to receive a draw on the next
* frame). gtk_widget_queue_draw() will also end up requesting a frame
* on the appropriate frame clock.
*
* A widget’s frame clock will not change while the widget is
* mapped. Reparenting a widget (which implies a temporary unmap) can
* change the widget’s frame clock.
*
* Unrealized widgets do not have a frame clock.
*
* Returns: (nullable) (transfer none): a #GdkFrameClock,
* or %NULL if widget is unrealized
*/
GdkFrameClock*
gtk_widget_get_frame_clock (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (priv->realized)
{
GdkSurface *surface = gtk_widget_get_surface (widget);
return gdk_surface_get_frame_clock (surface);
}
else
{
return NULL;
}
}
static int
get_number (GtkCssValue *value)
{
double d = _gtk_css_number_value_get (value, 100);
if (d < 1)
return ceil (d);
else
return floor (d);
}
static void
get_box_margin (GtkCssStyle *style,
GtkBorder *margin)
{
margin->top = get_number (style->size->margin_top);
margin->left = get_number (style->size->margin_left);
margin->bottom = get_number (style->size->margin_bottom);
margin->right = get_number (style->size->margin_right);
}
static void
get_box_border (GtkCssStyle *style,
GtkBorder *border)
{
border->top = get_number (style->border->border_top_width);
border->left = get_number (style->border->border_left_width);
border->bottom = get_number (style->border->border_bottom_width);
border->right = get_number (style->border->border_right_width);
}
static void
get_box_padding (GtkCssStyle *style,
GtkBorder *border)
{
border->top = get_number (style->size->padding_top);
border->left = get_number (style->size->padding_left);
border->bottom = get_number (style->size->padding_bottom);
border->right = get_number (style->size->padding_right);
}
/**
* gtk_widget_size_allocate:
* @widget: a #GtkWidget
* @allocation: position and size to be allocated to @widget
* @baseline: The baseline of the child, or -1
*
* This is a simple form of gtk_widget_allocate() that takes the new position
* of @widget as part of @allocation.
*/
void
gtk_widget_size_allocate (GtkWidget *widget,
const GtkAllocation *allocation,
int baseline)
{
GskTransform *transform;
if (allocation->x || allocation->y)
transform = gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (allocation->x, allocation->y));
else
transform = NULL;
gtk_widget_allocate (widget,
allocation->width,
allocation->height,
baseline,
transform);
}
/* translate initial/final into start/end */
static GtkAlign
effective_align (GtkAlign align,
GtkTextDirection direction)
{
switch (align)
{
case GTK_ALIGN_START:
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
case GTK_ALIGN_END:
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
case GTK_ALIGN_FILL:
case GTK_ALIGN_CENTER:
case GTK_ALIGN_BASELINE:
default:
return align;
}
}
static void
adjust_for_align (GtkAlign align,
int natural_size,
int *allocated_pos,
int *allocated_size)
{
switch (align)
{
case GTK_ALIGN_BASELINE:
case GTK_ALIGN_FILL:
default:
/* change nothing */
break;
case GTK_ALIGN_START:
/* keep *allocated_pos where it is */
*allocated_size = MIN (*allocated_size, natural_size);
break;
case GTK_ALIGN_END:
if (*allocated_size > natural_size)
{
*allocated_pos += (*allocated_size - natural_size);
*allocated_size = natural_size;
}
break;
case GTK_ALIGN_CENTER:
if (*allocated_size > natural_size)
{
*allocated_pos += (*allocated_size - natural_size) / 2;
*allocated_size = MIN (*allocated_size, natural_size);
}
break;
}
}
static inline void
gtk_widget_adjust_size_allocation (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
int natural_width, natural_height;
int min_width, min_height;
if (priv->halign == GTK_ALIGN_FILL && priv->valign == GTK_ALIGN_FILL)
return;
if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
{
/* Go ahead and request the height for allocated width, note that the internals
* of get_height_for_width will internally limit the for_size to natural size
* when aligning implicitly.
*/
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
&min_width, &natural_width, NULL, NULL);
gtk_widget_measure (widget, GTK_ORIENTATION_VERTICAL,
allocation->width + priv->margin.left + priv->margin.right,
&min_height, &natural_height, NULL, NULL);
}
else
{
/* Go ahead and request the width for allocated height, note that the internals
* of get_width_for_height will internally limit the for_size to natural size
* when aligning implicitly.
*/
gtk_widget_measure (widget, GTK_ORIENTATION_VERTICAL, -1,
&min_height, &natural_height, NULL, NULL);
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL,
allocation->height + priv->margin.top + priv->margin.bottom,
&min_width, &natural_width, NULL, NULL);
}
#ifdef G_ENABLE_CONSISTENCY_CHECKS
if ((min_width > allocation->width + priv->margin.left + priv->margin.right ||
min_height > allocation->height + priv->margin.top + priv->margin.bottom) &&
!GTK_IS_SCROLLABLE (widget))
g_warning ("gtk_widget_size_allocate(): attempt to underallocate %s%s %s %p. "
"Allocation is %dx%d, but minimum required size is %dx%d.",
priv->parent ? G_OBJECT_TYPE_NAME (priv->parent) : "", priv->parent ? "'s child" : "toplevel",
G_OBJECT_TYPE_NAME (widget), widget,
allocation->width, allocation->height,
min_width, min_height);
#endif
/* Now that we have the right natural height and width, go ahead and remove any margins from the
* allocated sizes and possibly limit them to the natural sizes */
adjust_for_align (effective_align (priv->halign, _gtk_widget_get_direction (widget)),
natural_width - priv->margin.left - priv->margin.right,
&allocation->x,
&allocation->width);
adjust_for_align (priv->valign,
natural_height - priv->margin.top - priv->margin.bottom,
&allocation->y,
&allocation->height);
}
/**
* gtk_widget_allocate:
* @widget: A #GtkWidget
* @width: New width of @widget
* @height: New height of @widget
* @baseline: New baseline of @widget, or -1
* @transform: (transfer full) (allow-none): Transformation to be applied to @widget
*
* This function is only used by #GtkWidget subclasses, to assign a size,
* position and (optionally) baseline to their child widgets.
*
* In this function, the allocation and baseline may be adjusted. The given
* allocation will be forced to be bigger than the widget's minimum size,
* as well as at least 0×0 in size.
*
* For a version that does not take a transform, see gtk_widget_size_allocate()
*/
void
gtk_widget_allocate (GtkWidget *widget,
int width,
int height,
int baseline,
GskTransform *transform)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GdkRectangle adjusted;
gboolean alloc_needed;
gboolean size_changed;
gboolean baseline_changed;
gboolean transform_changed;
GtkCssStyle *style;
GtkBorder margin, border, padding;
GskTransform *css_transform;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (baseline >= -1);
gtk_widget_push_verify_invariants (widget);
if (!priv->visible && !GTK_IS_ROOT (widget))
{
gsk_transform_unref (transform);
goto out;
}
#ifdef G_ENABLE_DEBUG
if (gtk_widget_get_resize_needed (widget))
{
g_warning ("Allocating size to %s %p without calling gtk_widget_measure(). "
"How does the code know the size to allocate?",
gtk_widget_get_name (widget), widget);
}
if (!GTK_IS_SCROLLABLE (widget))
{
int min;
gtk_widget_measure (widget, GTK_ORIENTATION_VERTICAL, width, &min, NULL, NULL, NULL);
if (min > height)
{
g_critical ("Allocation height too small. Tried to allocate %dx%d, but %s %p needs "
"at least %dx%d.",
width, height,
gtk_widget_get_name (widget), widget,
width, min);
}
gtk_widget_measure (widget, GTK_ORIENTATION_HORIZONTAL, height, &min, NULL, NULL, NULL);
if (min > width)
{
g_critical ("Allocation width too small. Tried to allocate %dx%d, but %s %p needs "
"at least %dx%d.",
width, height,
gtk_widget_get_name (widget), widget,
min, height);
}
}
#endif /* G_ENABLE_DEBUG */
alloc_needed = priv->alloc_needed;
/* Preserve request/allocate ordering */
priv->alloc_needed = FALSE;
baseline_changed = priv->allocated_size_baseline != baseline;
transform_changed = !gsk_transform_equal (priv->allocated_transform, transform);
gsk_transform_unref (priv->allocated_transform);
priv->allocated_transform = gsk_transform_ref (transform);
priv->allocated_width = width;
priv->allocated_height = height;
priv->allocated_size_baseline = baseline;
if (_gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
adjusted.x = priv->margin.left;
else
adjusted.x = priv->margin.right;
adjusted.y = priv->margin.top;
adjusted.width = width - priv->margin.left - priv->margin.right;
adjusted.height = height - priv->margin.top - priv->margin.bottom;
if (baseline >= 0)
baseline -= priv->margin.top;
gtk_widget_adjust_size_allocation (widget, &adjusted);
if (adjusted.width < 0 || adjusted.height < 0)
{
g_warning ("gtk_widget_size_allocate(): attempt to allocate %s %s %p with width %d and height %d",
G_OBJECT_TYPE_NAME (widget), g_quark_to_string (gtk_css_node_get_name (priv->cssnode)), widget,
adjusted.width,
adjusted.height);
adjusted.width = 0;
adjusted.height = 0;
}
style = gtk_css_node_get_style (priv->cssnode);
get_box_margin (style, &margin);
get_box_border (style, &border);
get_box_padding (style, &padding);
/* Apply CSS transformation */
adjusted.x += margin.left;
adjusted.y += margin.top;
adjusted.width -= margin.left + margin.right;
adjusted.height -= margin.top + margin.bottom;
css_transform = gtk_css_transform_value_get_transform (style->other->transform);
if (css_transform)
{
double origin_x, origin_y;
origin_x = _gtk_css_position_value_get_x (style->other->transform_origin, adjusted.width);
origin_y = _gtk_css_position_value_get_y (style->other->transform_origin, adjusted.height);
transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.x, adjusted.y));
adjusted.x = adjusted.y = 0;
transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (origin_x, origin_y));
transform = gsk_transform_transform (transform, css_transform);
transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (- origin_x, - origin_y));
gsk_transform_unref (css_transform);
}
adjusted.x += border.left + padding.left;
adjusted.y += border.top + padding.top;
if (baseline >= 0)
baseline -= margin.top + border.top + padding.top;
if (adjusted.x || adjusted.y)
transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.x, adjusted.y));
gsk_transform_unref (priv->transform);
priv->transform = transform;
if (priv->surface_transform_data)
sync_widget_surface_transform (widget);
/* Since gtk_widget_measure does it for us, we can be sure here that
* the given alloaction is large enough for the css margin/bordder/padding */
adjusted.width -= border.left + padding.left +
border.right + padding.right;
adjusted.height -= border.top + padding.top +
border.bottom + padding.bottom;
size_changed = (priv->width != adjusted.width) || (priv->height != adjusted.height);
if (!alloc_needed && !size_changed && !baseline_changed)
goto skip_allocate;
priv->width = adjusted.width;
priv->height = adjusted.height;
priv->baseline = baseline;
if (priv->layout_manager != NULL)
{
gtk_layout_manager_allocate (priv->layout_manager, widget,
priv->width,
priv->height,
baseline);
}
else
{
GTK_WIDGET_GET_CLASS (widget)->size_allocate (widget,
priv->width,
priv->height,
baseline);
}
/* Size allocation is god... after consulting god, no further requests or allocations are needed */
#ifdef G_ENABLE_DEBUG
if (GTK_DISPLAY_DEBUG_CHECK (_gtk_widget_get_display (widget), GEOMETRY) &&
gtk_widget_get_resize_needed (widget))
{
g_warning ("%s %p or a child called gtk_widget_queue_resize() during size_allocate().",
gtk_widget_get_name (widget), widget);
}
#endif
gtk_widget_ensure_resize (widget);
priv->alloc_needed = FALSE;
priv->alloc_needed_on_child = FALSE;
gtk_widget_update_paintables (widget);
if (size_changed)
gtk_accessible_bounds_changed (GTK_ACCESSIBLE (widget));
skip_allocate:
if (size_changed || baseline_changed)
gtk_widget_queue_draw (widget);
else if (transform_changed && priv->parent)
gtk_widget_queue_draw (priv->parent);
out:
if (priv->alloc_needed_on_child)
gtk_widget_ensure_allocate (widget);
gtk_widget_pop_verify_invariants (widget);
}
/**
* gtk_widget_common_ancestor:
* @widget_a: a #GtkWidget
* @widget_b: a #GtkWidget
*
* Find the common ancestor of @widget_a and @widget_b that
* is closest to the two widgets.
*
* Returns: (nullable): the closest common ancestor of @widget_a and
* @widget_b or %NULL if @widget_a and @widget_b do not
* share a common ancestor.
**/
GtkWidget *
gtk_widget_common_ancestor (GtkWidget *widget_a,
GtkWidget *widget_b)
{
GtkWidget *parent_a;
GtkWidget *parent_b;
int depth_a = 0;
int depth_b = 0;
parent_a = widget_a;
while (parent_a->priv->parent)
{
parent_a = parent_a->priv->parent;
depth_a++;
}
parent_b = widget_b;
while (parent_b->priv->parent)
{
parent_b = parent_b->priv->parent;
depth_b++;
}
if (parent_a != parent_b)
return NULL;
while (depth_a > depth_b)
{
widget_a = widget_a->priv->parent;
depth_a--;
}
while (depth_b > depth_a)
{
widget_b = widget_b->priv->parent;
depth_b--;
}
while (widget_a != widget_b)
{
widget_a = widget_a->priv->parent;
widget_b = widget_b->priv->parent;
}
return widget_a;
}
/**
* gtk_widget_translate_coordinates:
* @src_widget: a #GtkWidget
* @dest_widget: a #GtkWidget
* @src_x: X position relative to @src_widget
* @src_y: Y position relative to @src_widget
* @dest_x: (out) (optional): location to store X position relative to @dest_widget
* @dest_y: (out) (optional): location to store Y position relative to @dest_widget
*
* Translate coordinates relative to @src_widget’s allocation to coordinates
* relative to @dest_widget’s allocations. In order to perform this
* operation, both widget must share a common toplevel.
*
* Returns: %FALSE if @src_widget and @dest_widget have no common
* ancestor. In this case, 0 is stored in
* *@dest_x and *@dest_y. Otherwise %TRUE.
**/
gboolean
gtk_widget_translate_coordinates (GtkWidget *src_widget,
GtkWidget *dest_widget,
double src_x,
double src_y,
double *dest_x,
double *dest_y)
{
graphene_point_t p;
if (!gtk_widget_compute_point (src_widget, dest_widget,
&GRAPHENE_POINT_INIT (src_x, src_y),
&p))
return FALSE;
if (dest_x)
*dest_x = p.x;
if (dest_y)
*dest_y = p.y;
return TRUE;
}
/**
* gtk_widget_compute_point:
* @widget: the #GtkWidget to query
* @target: the #GtkWidget to transform into
* @point: a point in @widget's coordinate system
* @out_point: (out caller-allocates): Set to the corresponding coordinates in
* @target's coordinate system
*
* Translates the given @point in @widget's coordinates to coordinates
* relative to @target’s coordinate system. In order to perform this
* operation, both widgets must share a common root.
*
* Returns: %TRUE if the point could be determined, %FALSE on failure.
* In this case, 0 is stored in @out_point.
**/
gboolean
gtk_widget_compute_point (GtkWidget *widget,
GtkWidget *target,
const graphene_point_t *point,
graphene_point_t *out_point)
{
graphene_matrix_t transform;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (target), FALSE);
if (!gtk_widget_compute_transform (widget, target, &transform))
{
graphene_point_init (out_point, 0, 0);
return FALSE;
}
gsk_matrix_transform_point (&transform, point, out_point);
return TRUE;
}
/**
* gtk_widget_class_add_binding: (skip)
* @widget_class: the class to add the binding to
* @keyval: key value of binding to install
* @mods: key modifier of binding to install
* @callback: the callback to call upon activation
* @format_string: (nullable): GVariant format string for arguments or %NULL for
* no arguments
* @...: arguments, as given by format string.
*
* Creates a new shortcut for @widget_class that calls the given @callback
* with arguments read according to @format_string.
* The arguments and format string must be provided in the same way as
* with g_variant_new().
*
* This function is a convenience wrapper around
* gtk_widget_class_add_shortcut() and must be called during class
* initialization. It does not provide for user_data, if you need that,
* you will have to use gtk_widget_class_add_shortcut() with a custom
* shortcut.
**/
void
gtk_widget_class_add_binding (GtkWidgetClass *widget_class,
guint keyval,
GdkModifierType mods,
GtkShortcutFunc callback,
const char *format_string,
...)
{
GtkShortcut *shortcut;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
shortcut = gtk_shortcut_new (gtk_keyval_trigger_new (keyval, mods),
gtk_callback_action_new (callback, NULL, NULL));
if (format_string)
{
va_list args;
va_start (args, format_string);
gtk_shortcut_set_arguments (shortcut,
g_variant_new_va (format_string, NULL, &args));
va_end (args);
}
gtk_widget_class_add_shortcut (widget_class, shortcut);
g_object_unref (shortcut);
}
/**
* gtk_widget_class_add_binding_signal: (skip)
* @widget_class: the class to add the binding to
* @keyval: key value of binding to install
* @mods: key modifier of binding to install
* @signal: the signal to execute
* @format_string: (nullable): GVariant format string for arguments or %NULL for
* no arguments
* @...: arguments, as given by format string.
*
* Creates a new shortcut for @widget_class that emits the given action
* @signal with arguments read according to @format_string.
* The arguments and format string must be provided in the same way as
* with g_variant_new().
*
* This function is a convenience wrapper around
* gtk_widget_class_add_shortcut() and must be called during class
* initialization.
*/
void
gtk_widget_class_add_binding_signal (GtkWidgetClass *widget_class,
guint keyval,
GdkModifierType mods,
const char *signal,
const char *format_string,
...)
{
GtkShortcut *shortcut;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (g_signal_lookup (signal, G_TYPE_FROM_CLASS (widget_class)));
/* XXX: validate variant format for signal */
shortcut = gtk_shortcut_new (gtk_keyval_trigger_new (keyval, mods),
gtk_signal_action_new (signal));
if (format_string)
{
va_list args;
va_start (args, format_string);
gtk_shortcut_set_arguments (shortcut,
g_variant_new_va (format_string, NULL, &args));
va_end (args);
}
gtk_widget_class_add_shortcut (widget_class, shortcut);
g_object_unref (shortcut);
}
/**
* gtk_widget_class_add_binding_action: (skip)
* @widget_class: the class to add the binding to
* @keyval: key value of binding to install
* @mods: key modifier of binding to install
* @action_name: the action to activate
* @format_string: (nullable): GVariant format string for arguments or %NULL for
* no arguments
* @...: arguments, as given by format string.
*
* Creates a new shortcut for @widget_class that activates the given
* @action_name with arguments read according to @format_string.
* The arguments and format string must be provided in the same way as
* with g_variant_new().
*
* This function is a convenience wrapper around
* gtk_widget_class_add_shortcut() and must be called during class
* initialization.
*/
void
gtk_widget_class_add_binding_action (GtkWidgetClass *widget_class,
guint keyval,
GdkModifierType mods,
const char *action_name,
const char *format_string,
...)
{
GtkShortcut *shortcut;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
/* XXX: validate variant format for action */
shortcut = gtk_shortcut_new (gtk_keyval_trigger_new (keyval, mods),
gtk_named_action_new (action_name));
if (format_string)
{
va_list args;
va_start (args, format_string);
gtk_shortcut_set_arguments (shortcut,
g_variant_new_va (format_string, NULL, &args));
va_end (args);
}
gtk_widget_class_add_shortcut (widget_class, shortcut);
g_object_unref (shortcut);
}
/**
* gtk_widget_class_add_shortcut:
* @widget_class: the class to add the shortcut to
* @shortcut: (transfer none): the #GtkShortcut to add
*
* Installs a shortcut in @widget_class. Every instance created for
* @widget_class or its subclasses will inherit this shortcut and
* trigger it.
*
* Shortcuts added this way will be triggered in the @GTK_PHASE_BUBBLE
* phase, which means they may also trigger if child widgets have focus.
*
* This function must only be used in class initialization functions
* otherwise it is not guaranteed that the shortcut will be installed.
**/
void
gtk_widget_class_add_shortcut (GtkWidgetClass *widget_class,
GtkShortcut *shortcut)
{
GtkWidgetClassPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (GTK_IS_SHORTCUT (shortcut));
priv = widget_class->priv;
g_list_store_append (priv->shortcuts, shortcut);
}
/**
* gtk_widget_mnemonic_activate:
* @widget: a #GtkWidget
* @group_cycling: %TRUE if there are other widgets with the same mnemonic
*
* Emits the #GtkWidget::mnemonic-activate signal.
*
* Returns: %TRUE if the signal has been handled
*/
gboolean
gtk_widget_mnemonic_activate (GtkWidget *widget,
gboolean group_cycling)
{
gboolean handled;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
group_cycling = group_cycling != FALSE;
if (!gtk_widget_is_sensitive (widget))
handled = TRUE;
else
g_signal_emit (widget,
widget_signals[MNEMONIC_ACTIVATE],
0,
group_cycling,
&handled);
return handled;
}
/*< private >
* gtk_widget_can_activate:
* @self: a #GtkWidget
*
* Checks whether a #GtkWidget can be activated using
* gtk_widget_activate().
*/
gboolean
gtk_widget_can_activate (GtkWidget *self)
{
g_return_val_if_fail (GTK_IS_WIDGET (self), FALSE);
GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS (self);
if (widget_class->priv->activate_signal != 0)
return TRUE;
return FALSE;
}
static gboolean
get_effective_can_focus (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->can_focus)
return FALSE;
if (priv->parent)
return get_effective_can_focus (priv->parent);
return TRUE;
}
static gboolean
gtk_widget_real_mnemonic_activate (GtkWidget *widget,
gboolean group_cycling)
{
if (!group_cycling && gtk_widget_can_activate (widget))
gtk_widget_activate (widget);
else if (get_effective_can_focus (widget))
return gtk_widget_grab_focus (widget);
else
{
g_warning ("widget '%s' isn't suitable for mnemonic activation",
G_OBJECT_TYPE_NAME (widget));
gtk_widget_error_bell (widget);
}
return TRUE;
}
#define WIDGET_REALIZED_FOR_EVENT(widget, event) \
(gdk_event_get_event_type (event) == GDK_FOCUS_CHANGE || _gtk_widget_get_realized (widget))
gboolean
gtk_widget_run_controllers (GtkWidget *widget,
GdkEvent *event,
GtkWidget *target,
double x,
double y,
GtkPropagationPhase phase)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkEventController *controller;
gboolean handled = FALSE;
GList *l;
g_object_ref (widget);
l = priv->event_controllers;
while (l != NULL)
{
GList *next = l->next;
if (!WIDGET_REALIZED_FOR_EVENT (widget, event))
break;
controller = l->data;
if (controller == NULL)
{
priv->event_controllers = g_list_delete_link (priv->event_controllers, l);
}
else
{
GtkPropagationPhase controller_phase;
controller_phase = gtk_event_controller_get_propagation_phase (controller);
if (controller_phase == phase)
{
gboolean this_handled;
gboolean is_gesture;
is_gesture = GTK_IS_GESTURE (controller);
this_handled = gtk_event_controller_handle_event (controller, event, target, x, y);
#ifdef G_ENABLE_DEBUG
if (GTK_DEBUG_CHECK (KEYBINDINGS))
{
GdkEventType type = gdk_event_get_event_type (event);
if (this_handled &&
(type == GDK_KEY_PRESS || type == GDK_KEY_RELEASE))
{
g_message ("key %s (keyval %d) handled at widget %s by controller %s",
type == GDK_KEY_PRESS ? "press" : "release",
gdk_key_event_get_keyval (event),
G_OBJECT_TYPE_NAME (widget),
gtk_event_controller_get_name (controller));
}
}
#endif
handled |= this_handled;
/* Non-gesture controllers are basically unique entities not meant
* to collaborate with anything else. Break early if any such event
* controller handled the event.
*/
if (this_handled && !is_gesture)
break;
}
}
l = next;
}
g_object_unref (widget);
return handled;
}
void
gtk_widget_handle_crossing (GtkWidget *widget,
const GtkCrossingData *crossing,
double x,
double y)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
g_object_ref (widget);
if (crossing->old_target)
g_object_ref (crossing->old_target);
if (crossing->new_target)
g_object_ref (crossing->new_target);
if (crossing->old_descendent)
g_object_ref (crossing->old_descendent);
if (crossing->new_descendent)
g_object_ref (crossing->new_descendent);
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
gtk_event_controller_handle_crossing (controller, crossing, x, y);
}
if (crossing->old_target)
g_object_unref (crossing->old_target);
if (crossing->new_target)
g_object_unref (crossing->new_target);
if (crossing->old_descendent)
g_object_unref (crossing->old_descendent);
if (crossing->new_descendent)
g_object_unref (crossing->new_descendent);
g_object_unref (widget);
}
static gboolean
event_surface_is_still_viewable (GdkEvent *event)
{
/* Check that we think the event's window is viewable before
* delivering the event, to prevent surprises. We do this here
* at the last moment, since the event may have been queued
* up behind other events, held over a recursive main loop, etc.
*/
switch ((guint) gdk_event_get_event_type (event))
{
case GDK_MOTION_NOTIFY:
case GDK_BUTTON_PRESS:
case GDK_KEY_PRESS:
case GDK_ENTER_NOTIFY:
case GDK_PROXIMITY_IN:
case GDK_SCROLL:
return gdk_surface_get_mapped (gdk_event_get_surface (event));
#if 0
/* The following events are the second half of paired events;
* we always deliver them to deal with widgets that clean up
* on the second half.
*/
case GDK_BUTTON_RELEASE:
case GDK_KEY_RELEASE:
case GDK_LEAVE_NOTIFY:
case GDK_PROXIMITY_OUT:
#endif
default:
/* Remaining events would make sense on a not-viewable window,
* or don't have an associated window.
*/
return TRUE;
}
}
static gboolean
translate_event_coordinates (GdkEvent *event,
double *x,
double *y,
GtkWidget *widget)
{
GtkWidget *event_widget;
graphene_point_t p;
double event_x, event_y;
GtkNative *native;
double nx, ny;
*x = *y = 0;
if (!gdk_event_get_position (event, &event_x, &event_y))
return FALSE;
event_widget = gtk_get_event_widget (event);
native = gtk_widget_get_native (event_widget);
gtk_native_get_surface_transform (native, &nx, &ny);
event_x -= nx;
event_y -= ny;
if (!gtk_widget_compute_point (event_widget,
widget,
&GRAPHENE_POINT_INIT (event_x, event_y),
&p))
return FALSE;
*x = p.x;
*y = p.y;
return TRUE;
}
gboolean
_gtk_widget_captured_event (GtkWidget *widget,
GdkEvent *event,
GtkWidget *target)
{
gboolean return_val = FALSE;
double x, y;
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
if (!event_surface_is_still_viewable (event))
return TRUE;
translate_event_coordinates (event, &x, &y, widget);
return_val = gtk_widget_run_controllers (widget, event, target, x, y, GTK_PHASE_CAPTURE);
return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
return return_val;
}
gboolean
gtk_widget_event (GtkWidget *widget,
GdkEvent *event,
GtkWidget *target)
{
gboolean return_val = FALSE;
double x, y;
/* We check only once for is-still-visible; if someone
* hides the window in one of the signals on the widget,
* they are responsible for returning TRUE to terminate
* handling.
*/
if (!event_surface_is_still_viewable (event))
return TRUE;
if (!_gtk_widget_get_mapped (widget))
return FALSE;
translate_event_coordinates (event, &x, &y, widget);
if (widget == target)
return_val |= gtk_widget_run_controllers (widget, event, target, x, y, GTK_PHASE_TARGET);
if (return_val == FALSE)
return_val |= gtk_widget_run_controllers (widget, event, target, x, y, GTK_PHASE_BUBBLE);
return return_val;
}
/**
* gtk_widget_class_get_activate_signal:
* @widget_class: a #GtkWidgetClass
*
* Retrieves the signal id for the activation signal set using
* gtk_widget_class_set_activate_signal().
*
* Returns: a signal id, or 0 if the widget class does not
* specify an activation signal
*/
guint
gtk_widget_class_get_activate_signal (GtkWidgetClass *widget_class)
{
g_return_val_if_fail (GTK_IS_WIDGET_CLASS (widget_class), 0);
return widget_class->priv->activate_signal;
}
/**
* gtk_widget_class_set_activate_signal:
* @widget_class: a #GtkWidgetClass
* @signal_id: the id for the activate signal
*
* Sets the #GtkWidgetClass.activate_signal field with the
* given @signal_id; the signal will be emitted when calling
* gtk_widget_activate().
*
* The @signal_id must have been registered with g_signal_new()
* or g_signal_newv() before calling this function.
*/
void
gtk_widget_class_set_activate_signal (GtkWidgetClass *widget_class,
guint signal_id)
{
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (signal_id != 0);
widget_class->priv->activate_signal = signal_id;
}
/**
* gtk_widget_class_set_activate_signal_from_name:
* @widget_class: a #GtkWidgetClass
* @signal_name: the name of the activate signal of @widget_type
*
* Sets the #GtkWidgetClass.activate_signal field with the signal id for
* the given @signal_name; the signal will be emitted when calling
* gtk_widget_activate().
*
* The @signal_name of @widget_type must have been registered with
* g_signal_new() or g_signal_newv() before calling this function.
*/
void
gtk_widget_class_set_activate_signal_from_name (GtkWidgetClass *widget_class,
const char *signal_name)
{
guint signal_id;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (signal_name != NULL);
signal_id = g_signal_lookup (signal_name, G_TYPE_FROM_CLASS (widget_class));
if (signal_id == 0)
{
g_critical ("Widget type “%s” does not have a “%s” signal",
G_OBJECT_CLASS_NAME (widget_class),
signal_name);
return;
}
widget_class->priv->activate_signal = signal_id;
}
/**
* gtk_widget_activate:
* @widget: a #GtkWidget that’s activatable
*
* For widgets that can be “activated” (buttons, menu items, etc.)
* this function activates them. The activation will emit the signal
* set using gtk_widget_class_set_activate_signal() during class
* initialization.
*
* Activation is what happens when you press Enter on a widget during
* key navigation.
*
* If you wish to handle the activation keybinding yourself, it is
* recommended to use gtk_widget_class_add_shortcut() with an action
* created with gtk_signal_action_new().
*
* If @widget isn't activatable, the function returns %FALSE.
*
* Returns: %TRUE if the widget was activatable
**/
gboolean
gtk_widget_activate (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (gtk_widget_can_activate (widget))
{
GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS (widget);
/* FIXME: we should eventually check the signals signature here */
g_signal_emit (widget, widget_class->priv->activate_signal, 0);
return TRUE;
}
else
return FALSE;
}
/**
* gtk_widget_grab_focus:
* @widget: a #GtkWidget
*
* Causes @widget (or one of its descendents) to have the keyboard focus
* for the #GtkWindow it's inside.
*
* If @widget is not focusable, or its ::grab_focus implementation cannot
* transfer the focus to a descendant of @widget that is focusable, it will
* not take focus and %FALSE will be returned.
*
* Calling gtk_widget_grab_focus() on an already focused widget is allowed,
* should not have an effect, and return %TRUE.
*
* Returns: %TRUE if focus is now inside @widget.
**/
gboolean
gtk_widget_grab_focus (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (!gtk_widget_is_sensitive (widget) ||
!get_effective_can_focus (widget) ||
widget->priv->root == NULL)
return FALSE;
return GTK_WIDGET_GET_CLASS (widget)->grab_focus (widget);
}
gboolean
gtk_widget_grab_focus_self (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->focusable)
return FALSE;
gtk_root_set_focus (priv->root, widget);
return TRUE;
}
gboolean
gtk_widget_grab_focus_child (GtkWidget *widget)
{
GtkWidget *child;
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
if (gtk_widget_grab_focus (child))
return TRUE;
}
return FALSE;
}
gboolean
gtk_widget_query_tooltip (GtkWidget *widget,
int x,
int y,
gboolean keyboard_mode,
GtkTooltip *tooltip)
{
gboolean retval = FALSE;
g_signal_emit (widget,
widget_signals[QUERY_TOOLTIP],
0,
x, y,
keyboard_mode,
tooltip,
&retval);
return retval;
}
static void
gtk_widget_real_css_changed (GtkWidget *widget,
GtkCssStyleChange *change)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (change)
{
const gboolean has_text = gtk_widget_peek_pango_context (widget) != NULL;
if (has_text && gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT))
gtk_widget_update_pango_context (widget);
if (priv->root)
{
if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SIZE) ||
(has_text && gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_SIZE)))
{
gtk_widget_queue_resize (widget);
}
else if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TRANSFORM))
{
gtk_widget_queue_allocate (priv->parent);
}
if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_REDRAW) ||
(has_text && gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_CONTENT)))
{
gtk_widget_queue_draw (widget);
}
}
}
else
{
gtk_widget_update_pango_context (widget);
if (priv->root)
gtk_widget_queue_resize (widget);
}
}
static void
gtk_widget_real_system_setting_changed (GtkWidget *widget,
GtkSystemSetting setting)
{
GtkWidget *child;
if (setting == GTK_SYSTEM_SETTING_DPI ||
setting == GTK_SYSTEM_SETTING_FONT_NAME ||
setting == GTK_SYSTEM_SETTING_FONT_CONFIG)
{
gtk_widget_update_pango_context (widget);
if (gtk_widget_peek_pango_context (widget))
gtk_widget_queue_resize (widget);
}
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_system_setting_changed (child, setting);
}
}
static gboolean
direction_is_forward (GtkDirectionType direction)
{
switch (direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_RIGHT:
case GTK_DIR_DOWN:
return TRUE;
case GTK_DIR_TAB_BACKWARD:
case GTK_DIR_LEFT:
case GTK_DIR_UP:
return FALSE;
default:
g_assert_not_reached ();
}
}
static gboolean
gtk_widget_real_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkWidget *focus;
/* For focusable widgets, we want to focus the widget
* before its children. We differentiate 3 cases:
* 1) focus is currently on widget
* 2) focus is on some child
* 3) focus is outside
*/
if (gtk_widget_is_focus (widget))
{
if (direction_is_forward (direction) &&
gtk_widget_focus_move (widget, direction))
return TRUE;
return FALSE;
}
focus = gtk_window_get_focus (GTK_WINDOW (gtk_widget_get_root (widget)));
if (focus && gtk_widget_is_ancestor (focus, widget))
{
if (gtk_widget_focus_move (widget, direction))
return TRUE;
if (direction_is_forward (direction))
return FALSE;
else
return gtk_widget_grab_focus (widget);
}
if (!direction_is_forward (direction))
{
if (gtk_widget_focus_move (widget, direction))
return TRUE;
return gtk_widget_grab_focus (widget);
}
else
{
if (gtk_widget_grab_focus (widget))
return TRUE;
return gtk_widget_focus_move (widget, direction);
}
}
gboolean
gtk_widget_focus_self (GtkWidget *widget,
GtkDirectionType direction)
{
if (!gtk_widget_is_focus (widget))
{
gtk_widget_grab_focus (widget);
return TRUE;
}
return FALSE;
}
gboolean
gtk_widget_focus_child (GtkWidget *widget,
GtkDirectionType direction)
{
return gtk_widget_focus_move (widget, direction);
}
static void
gtk_widget_real_move_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkRoot *root;
root = _gtk_widget_get_root (widget);
if (widget != GTK_WIDGET (root))
g_signal_emit (root, widget_signals[MOVE_FOCUS], 0, direction);
}
static gboolean
gtk_widget_real_keynav_failed (GtkWidget *widget,
GtkDirectionType direction)
{
switch (direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_TAB_BACKWARD:
return FALSE;
case GTK_DIR_UP:
case GTK_DIR_DOWN:
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
default:
break;
}
gtk_widget_error_bell (widget);
return TRUE;
}
/**
* gtk_widget_set_can_focus:
* @widget: a #GtkWidget
* @can_focus: whether or not the input focus can enter
* the widget or any of its children
*
* Specifies whether the input focus can enter the widget
* or any of its children.
*
* Applications should set @can_focus to %FALSE to mark a
* widget as for pointer/touch use only.
*
* Note that having @can_focus be %TRUE is only one of the
* necessary conditions for being focusable. A widget must
* also be sensitive and focusable and not have an ancestor
* that is marked as not can-focus in order to receive input
* focus.
*
* See gtk_widget_grab_focus() for actually setting the input
* focus on a widget.
**/
void
gtk_widget_set_can_focus (GtkWidget *widget,
gboolean can_focus)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->can_focus != can_focus)
{
priv->can_focus = can_focus;
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CAN_FOCUS]);
}
}
/**
* gtk_widget_get_can_focus:
* @widget: a #GtkWidget
*
* Determines whether the input focus can enter @widget or any
* of its children.
*
* See gtk_widget_set_focusable().
*
* Returns: %TRUE if the input focus can enter @widget, %FALSE otherwise
**/
gboolean
gtk_widget_get_can_focus (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
return priv->can_focus;
}
/**
* gtk_widget_set_focusable:
* @widget: a #GtkWidget
* @focusable: whether or not @widget can own the input focus
*
* Specifies whether @widget can own the input focus.
*
* Widget implementations should set @focusable to %TRUE in
* their init() function if they want to receive keyboard input.
*
* Note that having @focusable be %TRUE is only one of the
* necessary conditions for being focusable. A widget must
* also be sensitive and can-focus and not have an ancestor
* that is marked as not can-focus in order to receive input
* focus.
*
* See gtk_widget_grab_focus() for actually setting the input
* focus on a widget.
**/
void
gtk_widget_set_focusable (GtkWidget *widget,
gboolean focusable)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->focusable == focusable)
return;
priv->focusable = focusable;
gtk_widget_queue_resize (widget);
gtk_accessible_platform_changed (GTK_ACCESSIBLE (widget), GTK_ACCESSIBLE_PLATFORM_CHANGE_FOCUSABLE);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_FOCUSABLE]);
}
/**
* gtk_widget_get_focusable:
* @widget: a #GtkWidget
*
* Determines whether @widget can own the input focus.
* See gtk_widget_set_focusable().
*
* Returns: %TRUE if @widget can own the input focus, %FALSE otherwise
**/
gboolean
gtk_widget_get_focusable (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->focusable;
}
/**
* gtk_widget_has_focus:
* @widget: a #GtkWidget
*
* Determines if the widget has the global input focus. See
* gtk_widget_is_focus() for the difference between having the global
* input focus, and only having the focus within a toplevel.
*
* Returns: %TRUE if the widget has the global input focus.
**/
gboolean
gtk_widget_has_focus (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->has_focus;
}
/**
* gtk_widget_has_visible_focus:
* @widget: a #GtkWidget
*
* Determines if the widget should show a visible indication that
* it has the global input focus. This is a convenience function
* that takes into account whether focus indication should currently
* be shown in the toplevel window of @widget.
* See gtk_window_get_focus_visible() for more information
* about focus indication.
*
* To find out if the widget has the global input focus, use
* gtk_widget_has_focus().
*
* Returns: %TRUE if the widget should display a “focus rectangle”
*/
gboolean
gtk_widget_has_visible_focus (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean draw_focus;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (priv->has_focus)
{
GtkRoot *root = _gtk_widget_get_root (widget);
if (GTK_IS_WINDOW (root))
draw_focus = gtk_window_get_focus_visible (GTK_WINDOW (root));
else
draw_focus = TRUE;
}
else
draw_focus = FALSE;
return draw_focus;
}
/**
* gtk_widget_is_focus:
* @widget: a #GtkWidget
*
* Determines if the widget is the focus widget within its
* toplevel. (This does not mean that the #GtkWidget:has-focus property is
* necessarily set; #GtkWidget:has-focus will only be set if the
* toplevel widget additionally has the global input focus.)
*
* Returns: %TRUE if the widget is the focus widget.
**/
gboolean
gtk_widget_is_focus (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (priv->root)
return widget == gtk_root_get_focus (priv->root);
return FALSE;
}
/**
* gtk_widget_set_focus_on_click:
* @widget: a #GtkWidget
* @focus_on_click: whether the widget should grab focus when clicked with the mouse
*
* Sets whether the widget should grab focus when it is clicked with the mouse.
* Making mouse clicks not grab focus is useful in places like toolbars where
* you don’t want the keyboard focus removed from the main area of the
* application.
**/
void
gtk_widget_set_focus_on_click (GtkWidget *widget,
gboolean focus_on_click)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
focus_on_click = focus_on_click != FALSE;
if (priv->focus_on_click != focus_on_click)
{
priv->focus_on_click = focus_on_click;
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_FOCUS_ON_CLICK]);
}
}
/**
* gtk_widget_get_focus_on_click:
* @widget: a #GtkWidget
*
* Returns whether the widget should grab focus when it is clicked with the mouse.
* See gtk_widget_set_focus_on_click().
*
* Returns: %TRUE if the widget should grab focus when it is clicked with
* the mouse.
**/
gboolean
gtk_widget_get_focus_on_click (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->focus_on_click;
}
/**
* gtk_widget_has_default:
* @widget: a #GtkWidget
*
* Determines whether @widget is the current default widget within its
* toplevel.
*
* Returns: %TRUE if @widget is the current default widget within
* its toplevel, %FALSE otherwise
*/
gboolean
gtk_widget_has_default (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->has_default;
}
void
_gtk_widget_set_has_default (GtkWidget *widget,
gboolean has_default)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->has_default = has_default;
if (has_default)
gtk_widget_add_css_class (widget, "default");
else
gtk_widget_remove_css_class (widget, "default");
}
/**
* gtk_widget_set_receives_default:
* @widget: a #GtkWidget
* @receives_default: whether or not @widget can be a default widget.
*
* Specifies whether @widget will be treated as the default
* widget within its toplevel when it has the focus, even if
* another widget is the default.
**/
void
gtk_widget_set_receives_default (GtkWidget *widget,
gboolean receives_default)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->receives_default != receives_default)
{
priv->receives_default = receives_default;
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_RECEIVES_DEFAULT]);
}
}
/**
* gtk_widget_get_receives_default:
* @widget: a #GtkWidget
*
* Determines whether @widget is always treated as the default widget
* within its toplevel when it has the focus, even if another widget
* is the default.
*
* See gtk_widget_set_receives_default().
*
* Returns: %TRUE if @widget acts as the default widget when focused,
* %FALSE otherwise
**/
gboolean
gtk_widget_get_receives_default (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->receives_default;
}
/*< private >
* gtk_widget_has_grab:
* @widget: a #GtkWidget
*
* Determines whether the widget is currently grabbing events, so it
* is the only widget receiving input events (keyboard and mouse).
*
* See also gtk_grab_add().
*
* Returns: %TRUE if the widget is in the grab_widgets stack
**/
gboolean
gtk_widget_has_grab (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!GTK_IS_WIDGET (widget)) return FALSE;
return priv->has_grab;
}
void
_gtk_widget_set_has_grab (GtkWidget *widget,
gboolean has_grab)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->has_grab = has_grab;
}
/**
* gtk_widget_set_name:
* @widget: a #GtkWidget
* @name: name for the widget
*
* Widgets can be named, which allows you to refer to them from a
* CSS file. You can apply a style to widgets with a particular name
* in the CSS file. See the documentation for the CSS syntax (on the
* same page as the docs for #GtkStyleContext).
*
* Note that the CSS syntax has certain special characters to delimit
* and represent elements in a selector (period, #, >, *...), so using
* these will make your widget impossible to match by name. Any combination
* of alphanumeric symbols, dashes and underscores will suffice.
*/
void
gtk_widget_set_name (GtkWidget *widget,
const char *name)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_free (priv->name);
priv->name = g_strdup (name);
gtk_css_node_set_id (priv->cssnode, g_quark_from_string (priv->name));
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_NAME]);
}
/**
* gtk_widget_get_name:
* @widget: a #GtkWidget
*
* Retrieves the name of a widget. See gtk_widget_set_name() for the
* significance of widget names.
*
* Returns: name of the widget. This string is owned by GTK and
* should not be modified or freed
**/
const char *
gtk_widget_get_name (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (priv->name)
return priv->name;
return G_OBJECT_TYPE_NAME (widget);
}
static void
gtk_widget_update_state_flags (GtkWidget *widget,
GtkStateFlags flags_to_set,
GtkStateFlags flags_to_unset)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
/* Handle insensitive first, since it is propagated
* differently throughout the widget hierarchy.
*/
if ((priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_unset & GTK_STATE_FLAG_INSENSITIVE))
gtk_widget_set_sensitive (widget, TRUE);
else if (!(priv->state_flags & GTK_STATE_FLAG_INSENSITIVE) && (flags_to_set & GTK_STATE_FLAG_INSENSITIVE))
gtk_widget_set_sensitive (widget, FALSE);
flags_to_set &= ~(GTK_STATE_FLAG_INSENSITIVE);
flags_to_unset &= ~(GTK_STATE_FLAG_INSENSITIVE);
if (flags_to_set != 0 || flags_to_unset != 0)
{
GtkStateData data;
data.old_scale_factor = gtk_widget_get_scale_factor (widget);
data.flags_to_set = flags_to_set;
data.flags_to_unset = flags_to_unset;
gtk_widget_propagate_state (widget, &data);
}
}
/**
* gtk_widget_set_state_flags:
* @widget: a #GtkWidget
* @flags: State flags to turn on
* @clear: Whether to clear state before turning on @flags
*
* This function is for use in widget implementations. Turns on flag
* values in the current widget state (insensitive, prelighted, etc.).
*
* This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
* %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
* the widget's direction, use gtk_widget_set_direction().
**/
void
gtk_widget_set_state_flags (GtkWidget *widget,
GtkStateFlags flags,
gboolean clear)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
#define ALLOWED_FLAGS (~(GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL))
g_return_if_fail (GTK_IS_WIDGET (widget));
if ((!clear && (priv->state_flags & flags) == flags) ||
(clear && priv->state_flags == flags))
return;
if (clear)
gtk_widget_update_state_flags (widget, flags & ALLOWED_FLAGS, ~flags & ALLOWED_FLAGS);
else
gtk_widget_update_state_flags (widget, flags & ALLOWED_FLAGS, 0);
#undef ALLOWED_FLAGS
}
/**
* gtk_widget_unset_state_flags:
* @widget: a #GtkWidget
* @flags: State flags to turn off
*
* This function is for use in widget implementations. Turns off flag
* values for the current widget state (insensitive, prelighted, etc.).
* See gtk_widget_set_state_flags().
**/
void
gtk_widget_unset_state_flags (GtkWidget *widget,
GtkStateFlags flags)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if ((priv->state_flags & flags) == 0)
return;
gtk_widget_update_state_flags (widget, 0, flags);
}
/**
* gtk_widget_get_state_flags:
* @widget: a #GtkWidget
*
* Returns the widget state as a flag set. It is worth mentioning
* that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
* returned, that is, also based on parent insensitivity, even if
* @widget itself is sensitive.
*
* Also note that if you are looking for a way to obtain the
* #GtkStateFlags to pass to a #GtkStyleContext method, you
* should look at gtk_style_context_get_state().
*
* Returns: The state flags for widget
**/
GtkStateFlags
gtk_widget_get_state_flags (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->state_flags;
}
/**
* gtk_widget_set_visible:
* @widget: a #GtkWidget
* @visible: whether the widget should be shown or not
*
* Sets the visibility state of @widget. Note that setting this to
* %TRUE doesn’t mean the widget is actually viewable, see
* gtk_widget_get_visible().
*
* This function simply calls gtk_widget_show() or gtk_widget_hide()
* but is nicer to use when the visibility of the widget depends on
* some condition.
**/
void
gtk_widget_set_visible (GtkWidget *widget,
gboolean visible)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (visible)
gtk_widget_show (widget);
else
gtk_widget_hide (widget);
}
void
_gtk_widget_set_visible_flag (GtkWidget *widget,
gboolean visible)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->visible = visible;
if (!visible)
{
g_clear_pointer (&priv->allocated_transform, gsk_transform_unref);
priv->allocated_width = 0;
priv->allocated_height = 0;
priv->allocated_size_baseline = 0;
g_clear_pointer (&priv->transform, gsk_transform_unref);
priv->width = 0;
priv->height = 0;
gtk_widget_update_paintables (widget);
}
}
/**
* gtk_widget_get_visible:
* @widget: a #GtkWidget
*
* Determines whether the widget is visible. If you want to
* take into account whether the widget’s parent is also marked as
* visible, use gtk_widget_is_visible() instead.
*
* This function does not check if the widget is obscured in any way.
*
* See gtk_widget_set_visible().
*
* Returns: %TRUE if the widget is visible
**/
gboolean
gtk_widget_get_visible (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->visible;
}
/**
* gtk_widget_is_visible:
* @widget: a #GtkWidget
*
* Determines whether the widget and all its parents are marked as
* visible.
*
* This function does not check if the widget is obscured in any way.
*
* See also gtk_widget_get_visible() and gtk_widget_set_visible()
*
* Returns: %TRUE if the widget and all its parents are visible
**/
gboolean
gtk_widget_is_visible (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
while (widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->visible)
return FALSE;
widget = priv->parent;
}
return TRUE;
}
/**
* gtk_widget_is_drawable:
* @widget: a #GtkWidget
*
* Determines whether @widget can be drawn to. A widget can be drawn
* if it is mapped and visible.
*
* Returns: %TRUE if @widget is drawable, %FALSE otherwise
**/
gboolean
gtk_widget_is_drawable (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return (_gtk_widget_get_visible (widget) &&
_gtk_widget_get_mapped (widget));
}
/**
* gtk_widget_get_realized:
* @widget: a #GtkWidget
*
* Determines whether @widget is realized.
*
* Returns: %TRUE if @widget is realized, %FALSE otherwise
**/
gboolean
gtk_widget_get_realized (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->realized;
}
/**
* gtk_widget_get_mapped:
* @widget: a #GtkWidget
*
* Whether the widget is mapped.
*
* Returns: %TRUE if the widget is mapped, %FALSE otherwise.
*/
gboolean
gtk_widget_get_mapped (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->mapped;
}
/**
* gtk_widget_set_sensitive:
* @widget: a #GtkWidget
* @sensitive: %TRUE to make the widget sensitive
*
* Sets the sensitivity of a widget. A widget is sensitive if the user
* can interact with it. Insensitive widgets are “grayed out” and the
* user can’t interact with them. Insensitive widgets are known as
* “inactive”, “disabled”, or “ghosted” in some other toolkits.
**/
void
gtk_widget_set_sensitive (GtkWidget *widget,
gboolean sensitive)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
g_return_if_fail (GTK_IS_WIDGET (widget));
sensitive = (sensitive != FALSE);
if (priv->sensitive == sensitive)
return;
priv->sensitive = sensitive;
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
gtk_event_controller_reset (controller);
}
gtk_accessible_update_state (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_STATE_DISABLED, !sensitive,
-1);
if (priv->parent == NULL
|| gtk_widget_is_sensitive (priv->parent))
{
GtkStateData data;
data.old_scale_factor = gtk_widget_get_scale_factor (widget);
if (sensitive)
{
data.flags_to_set = 0;
data.flags_to_unset = GTK_STATE_FLAG_INSENSITIVE;
}
else
{
data.flags_to_set = GTK_STATE_FLAG_INSENSITIVE;
data.flags_to_unset = GTK_STATE_FLAG_PRELIGHT |
GTK_STATE_FLAG_ACTIVE;
}
gtk_widget_propagate_state (widget, &data);
update_cursor_on_state_change (widget);
}
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_SENSITIVE]);
}
/**
* gtk_widget_get_sensitive:
* @widget: a #GtkWidget
*
* Returns the widget’s sensitivity (in the sense of returning
* the value that has been set using gtk_widget_set_sensitive()).
*
* The effective sensitivity of a widget is however determined by both its
* own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
*
* Returns: %TRUE if the widget is sensitive
*/
gboolean
gtk_widget_get_sensitive (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->sensitive;
}
/**
* gtk_widget_is_sensitive:
* @widget: a #GtkWidget
*
* Returns the widget’s effective sensitivity, which means
* it is sensitive itself and also its parent widget is sensitive
*
* Returns: %TRUE if the widget is effectively sensitive
*/
gboolean
gtk_widget_is_sensitive (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return _gtk_widget_is_sensitive (widget);
}
/* Insert @widget into the children list of @parent,
* after @previous_sibling */
static void
gtk_widget_reposition_after (GtkWidget *widget,
GtkWidget *parent,
GtkWidget *previous_sibling)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkStateFlags parent_flags;
GtkWidget *prev_parent, *prev_previous;
GtkStateData data;
prev_parent = priv->parent;
prev_previous = priv->prev_sibling;
if (priv->parent != NULL && priv->parent != parent)
{
g_warning ("Can't set new parent %s %p on widget %s %p, "
"which already has parent %s %p",
gtk_widget_get_name (parent), (void *)parent,
gtk_widget_get_name (widget), (void *)widget,
gtk_widget_get_name (priv->parent), (void *)priv->parent);
return;
}
data.old_scale_factor = gtk_widget_get_scale_factor (widget);
if (priv->parent == NULL)
g_object_ref_sink (widget);
gtk_widget_push_verify_invariants (widget);
priv->parent = parent;
if (previous_sibling)
{
if (previous_sibling->priv->next_sibling)
previous_sibling->priv->next_sibling->priv->prev_sibling = widget;
if (priv->prev_sibling)
priv->prev_sibling->priv->next_sibling = priv->next_sibling;
if (priv->next_sibling)
priv->next_sibling->priv->prev_sibling = priv->prev_sibling;
if (parent->priv->first_child == widget)
parent->priv->first_child = priv->next_sibling;
if (parent->priv->last_child == widget)
parent->priv->last_child = priv->prev_sibling;
priv->prev_sibling = previous_sibling;
priv->next_sibling = previous_sibling->priv->next_sibling;
previous_sibling->priv->next_sibling = widget;
if (parent->priv->last_child == previous_sibling)
parent->priv->last_child = widget;
else if (parent->priv->last_child == widget)
parent->priv->last_child = priv->next_sibling;
}
else
{
/* Beginning */
if (parent->priv->last_child == widget)
{
parent->priv->last_child = priv->prev_sibling;
if (priv->prev_sibling)
priv->prev_sibling->priv->next_sibling = NULL;
}
if (priv->prev_sibling)
priv->prev_sibling->priv->next_sibling = priv->next_sibling;
if (priv->next_sibling)
priv->next_sibling->priv->prev_sibling = priv->prev_sibling;
priv->prev_sibling = NULL;
priv->next_sibling = parent->priv->first_child;
if (parent->priv->first_child)
parent->priv->first_child->priv->prev_sibling = widget;
parent->priv->first_child = widget;
if (parent->priv->last_child == NULL)
parent->priv->last_child = widget;
}
parent_flags = _gtk_widget_get_state_flags (parent);
/* Merge both old state and current parent state,
* making sure to only propagate the right states */
data.flags_to_set = parent_flags & GTK_STATE_FLAGS_DO_SET_PROPAGATE;
data.flags_to_unset = 0;
gtk_widget_propagate_state (widget, &data);
gtk_css_node_insert_after (parent->priv->cssnode,
priv->cssnode,
previous_sibling ? previous_sibling->priv->cssnode : NULL);
_gtk_widget_update_parent_muxer (widget);
if (parent->priv->root && priv->root == NULL)
gtk_widget_root (widget);
if (parent->priv->children_observer)
{
if (prev_previous)
gtk_list_list_model_item_moved (parent->priv->children_observer, widget, prev_previous);
else
gtk_list_list_model_item_added (parent->priv->children_observer, widget);
}
if (prev_parent == NULL)
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_PARENT]);
/* Enforce mapped invariants */
if (_gtk_widget_get_visible (priv->parent) &&
_gtk_widget_get_visible (widget))
{
if (_gtk_widget_get_child_visible (widget) &&
_gtk_widget_get_mapped (priv->parent))
gtk_widget_map (widget);
gtk_widget_queue_resize (priv->parent);
}
/* child may cause parent's expand to change, if the child is
* expanded. If child is not expanded, then it can't modify the
* parent's expand. If the child becomes expanded later then it will
* queue compute_expand then. This optimization plus defaulting
* newly-constructed widgets to need_compute_expand=FALSE should
* mean that initially building a widget tree doesn't have to keep
* walking up setting need_compute_expand on parents over and over.
*
* We can't change a parent to need to expand unless we're visible.
*/
if (_gtk_widget_get_visible (widget) &&
(priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand))
{
gtk_widget_queue_compute_expand (parent);
}
if (prev_parent == NULL)
gtk_accessible_update_children (GTK_ACCESSIBLE (parent),
GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_CHILD_STATE_ADDED);
gtk_widget_pop_verify_invariants (widget);
}
/**
* gtk_widget_set_parent:
* @widget: a #GtkWidget
* @parent: parent widget
*
* This function is useful only when implementing subclasses of
* #GtkWidget.
*
* Sets @parent as the parent widget of @widget, and takes care of
* some details such as updating the state and style of the child
* to reflect its new location and resizing the parent. The opposite
* function is gtk_widget_unparent().
**/
void
gtk_widget_set_parent (GtkWidget *widget,
GtkWidget *parent)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_WIDGET (parent));
g_return_if_fail (_gtk_widget_get_parent (widget) == NULL);
gtk_widget_reposition_after (widget,
parent,
_gtk_widget_get_last_child (parent));
}
/**
* gtk_widget_get_parent:
* @widget: a #GtkWidget
*
* Returns the parent widget of @widget.
*
* Returns: (transfer none) (nullable): the parent widget of @widget, or %NULL
**/
GtkWidget *
gtk_widget_get_parent (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->parent;
}
/**
* gtk_widget_get_root:
* @widget: a #GtkWidget
*
* Returns the #GtkRoot widget of @widget or %NULL if the widget is not contained
* inside a widget tree with a root widget.
*
* #GtkRoot widgets will return themselves here.
*
* Returns: (transfer none) (nullable): the root widget of @widget, or %NULL
**/
GtkRoot *
gtk_widget_get_root (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return _gtk_widget_get_root (widget);
}
/**
* gtk_widget_get_native:
* @widget: a #GtkWidget
*
* Returns the GtkNative widget that contains @widget,
* or %NULL if the widget is not contained inside a
* widget tree with a native ancestor.
*
* #GtkNative widgets will return themselves here.
*
* Returns: (transfer none) (nullable): the #GtkNative
* widget of @widget, or %NULL
*/
GtkNative *
gtk_widget_get_native (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return (GtkNative *)gtk_widget_get_ancestor (widget, GTK_TYPE_NATIVE);
}
static void
gtk_widget_real_direction_changed (GtkWidget *widget,
GtkTextDirection previous_direction)
{
gtk_widget_queue_resize (widget);
}
#ifdef G_ENABLE_CONSISTENCY_CHECKS
/* Verify invariants, see docs/widget_system.txt for notes on much of
* this. Invariants may be temporarily broken while we’re in the
* process of updating state, of course, so you can only
* verify_invariants() after a given operation is complete.
* Use push/pop_verify_invariants to help with that.
*/
static void
gtk_widget_verify_invariants (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidget *parent;
if (priv->verifying_invariants_count > 0)
return;
parent = priv->parent;
if (priv->mapped)
{
/* Mapped implies ... */
if (!priv->realized)
g_warning ("%s %p is mapped but not realized",
gtk_widget_get_name (widget), widget);
if (!priv->visible)
g_warning ("%s %p is mapped but not visible",
gtk_widget_get_name (widget), widget);
if (!priv->child_visible && !GTK_IS_ROOT (widget))
g_warning ("%s %p is mapped but not child_visible",
gtk_widget_get_name (widget), widget);
}
else
{
/* Not mapped implies... */
#if 0
/* This check makes sense for normal toplevels, but for
* something like a toplevel that is embedded within a clutter
* state, mapping may depend on external factors.
*/
if (widget->priv->toplevel)
{
if (widget->priv->visible)
g_warning ("%s %p toplevel is visible but not mapped",
G_OBJECT_TYPE_NAME (widget), widget);
}
#endif
}
/* Parent related checks aren't possible if parent has
* verifying_invariants_count > 0 because parent needs to recurse
* children first before the invariants will hold.
*/
if (parent == NULL || parent->priv->verifying_invariants_count == 0)
{
if (parent &&
parent->priv->realized)
{
/* Parent realized implies... */
#if 0
/* This is in widget_system.txt but appears to fail
* because there's no gtk_container_realize() that
* realizes all children... instead we just lazily
* wait for map to fix things up.
*/
if (!widget->priv->realized)
g_warning ("%s %p is realized but child %s %p is not realized",
G_OBJECT_TYPE_NAME (parent), parent,
G_OBJECT_TYPE_NAME (widget), widget);
#endif
}
else if (priv->realized && !GTK_IS_ROOT (widget))
{
/* No parent or parent not realized on non-toplevel implies... */
g_warning ("%s %p is not realized but child %s %p is realized",
parent ? gtk_widget_get_name (parent) : "no parent", parent,
gtk_widget_get_name (widget), widget);
}
if (parent &&
parent->priv->mapped &&
priv->visible &&
priv->child_visible)
{
/* Parent mapped and we are visible implies... */
if (!priv->mapped)
g_warning ("%s %p is mapped but visible child %s %p is not mapped",
gtk_widget_get_name (parent), parent,
gtk_widget_get_name (widget), widget);
}
else if (priv->mapped && !GTK_IS_ROOT (widget))
{
/* No parent or parent not mapped on non-toplevel implies... */
g_warning ("%s %p is mapped but visible=%d child_visible=%d parent %s %p mapped=%d",
gtk_widget_get_name (widget), widget,
priv->visible,
priv->child_visible,
parent ? gtk_widget_get_name (parent) : "no parent", parent,
parent ? parent->priv->mapped : FALSE);
}
}
if (!priv->realized)
{
/* Not realized implies... */
#if 0
/* widget_system.txt says these hold, but they don't. */
if (widget->priv->alloc_needed)
g_warning ("%s %p alloc needed but not realized",
G_OBJECT_TYPE_NAME (widget), widget);
if (widget->priv->width_request_needed)
g_warning ("%s %p width request needed but not realized",
G_OBJECT_TYPE_NAME (widget), widget);
if (widget->priv->height_request_needed)
g_warning ("%s %p height request needed but not realized",
G_OBJECT_TYPE_NAME (widget), widget);
#endif
}
}
/* The point of this push/pop is that invariants may not hold while
* we’re busy making changes. So we only check at the outermost call
* on the call stack, after we finish updating everything.
*/
static void
gtk_widget_push_verify_invariants (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->verifying_invariants_count += 1;
}
static void
gtk_widget_pop_verify_invariants (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_assert (priv->verifying_invariants_count > 0);
priv->verifying_invariants_count -= 1;
if (priv->verifying_invariants_count == 0)
{
GtkWidget *child;
gtk_widget_verify_invariants (widget);
/* Check one level of children, because our
* push_verify_invariants() will have prevented some of the
* checks. This does not recurse because if recursion is
* needed, it will happen naturally as each child has a
* push/pop on that child. For example if we're recursively
* mapping children, we'll push/pop on each child as we map
* it.
*/
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_verify_invariants (child);
}
}
}
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
static PangoContext *
gtk_widget_peek_pango_context (GtkWidget *widget)
{
return g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
}
/**
* gtk_widget_get_pango_context:
* @widget: a #GtkWidget
*
* Gets a #PangoContext with the appropriate font map, font description,
* and base direction for this widget. Unlike the context returned
* by gtk_widget_create_pango_context(), this context is owned by
* the widget (it can be used until the screen for the widget changes
* or the widget is removed from its toplevel), and will be updated to
* match any changes to the widget’s attributes. This can be tracked
* by listening to changes of the #GtkWidget:root property on the widget.
*
* Returns: (transfer none): the #PangoContext for the widget.
**/
PangoContext *
gtk_widget_get_pango_context (GtkWidget *widget)
{
PangoContext *context;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context);
if (!context)
{
context = gtk_widget_create_pango_context (GTK_WIDGET (widget));
g_object_set_qdata_full (G_OBJECT (widget),
quark_pango_context,
context,
g_object_unref);
}
return context;
}
static PangoFontMap *
gtk_widget_get_effective_font_map (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
PangoFontMap *font_map;
font_map = PANGO_FONT_MAP (g_object_get_qdata (G_OBJECT (widget), quark_font_map));
if (font_map)
return font_map;
else if (priv->parent)
return gtk_widget_get_effective_font_map (priv->parent);
else
return pango_cairo_font_map_get_default ();
}
static void
update_pango_context (GtkWidget *widget,
PangoContext *context)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkCssStyle *style = gtk_css_node_get_style (priv->cssnode);
PangoFontDescription *font_desc;
GtkSettings *settings;
cairo_font_options_t *font_options;
font_desc = gtk_css_style_get_pango_font (style);
pango_context_set_font_description (context, font_desc);
pango_font_description_free (font_desc);
if (cairo_version () >= CAIRO_VERSION_ENCODE (1, 17, 4))
pango_context_set_round_glyph_positions (context, FALSE);
pango_context_set_base_dir (context,
_gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ?
PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
pango_cairo_context_set_resolution (context, _gtk_css_number_value_get (style->core->dpi, 100));
settings = gtk_widget_get_settings (widget);
font_options = (cairo_font_options_t*)g_object_get_qdata (G_OBJECT (widget), quark_font_options);
if (settings && font_options)
{
cairo_font_options_t *options;
options = cairo_font_options_copy (gtk_settings_get_font_options (settings));
cairo_font_options_merge (options, font_options);
pango_cairo_context_set_font_options (context, options);
cairo_font_options_destroy (options);
}
else if (settings)
{
pango_cairo_context_set_font_options (context,
gtk_settings_get_font_options (settings));
}
pango_context_set_font_map (context, gtk_widget_get_effective_font_map (widget));
}
static void
gtk_widget_update_pango_context (GtkWidget *widget)
{
PangoContext *context = gtk_widget_peek_pango_context (widget);
if (context)
update_pango_context (widget, context);
}
/**
* gtk_widget_set_font_options:
* @widget: a #GtkWidget
* @options: (allow-none): a #cairo_font_options_t, or %NULL to unset any
* previously set default font options.
*
* Sets the #cairo_font_options_t used for Pango rendering in this widget.
* When not set, the default font options for the #GdkDisplay will be used.
**/
void
gtk_widget_set_font_options (GtkWidget *widget,
const cairo_font_options_t *options)
{
cairo_font_options_t *font_options;
g_return_if_fail (GTK_IS_WIDGET (widget));
font_options = (cairo_font_options_t *)g_object_get_qdata (G_OBJECT (widget), quark_font_options);
if (font_options != options)
{
g_object_set_qdata_full (G_OBJECT (widget),
quark_font_options,
options ? cairo_font_options_copy (options) : NULL,
(GDestroyNotify)cairo_font_options_destroy);
gtk_widget_update_pango_context (widget);
}
}
/**
* gtk_widget_get_font_options:
* @widget: a #GtkWidget
*
* Returns the #cairo_font_options_t used for Pango rendering. When not set,
* the defaults font options for the #GdkDisplay will be used.
*
* Returns: (transfer none) (nullable): the #cairo_font_options_t or %NULL if not set
**/
const cairo_font_options_t *
gtk_widget_get_font_options (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return (cairo_font_options_t *)g_object_get_qdata (G_OBJECT (widget), quark_font_options);
}
static void
gtk_widget_set_font_map_recurse (GtkWidget *widget, gpointer user_data)
{
if (g_object_get_qdata (G_OBJECT (widget), quark_font_map))
return;
gtk_widget_update_pango_context (widget);
gtk_widget_forall (widget, gtk_widget_set_font_map_recurse, user_data);
}
/**
* gtk_widget_set_font_map:
* @widget: a #GtkWidget
* @font_map: (allow-none): a #PangoFontMap, or %NULL to unset any previously
* set font map
*
* Sets the font map to use for Pango rendering. The font map is the
* object that is used to look up fonts. Setting a custom font map
* can be useful in special situations, e.g. when you need to add
* application-specific fonts to the set of available fonts.
*
* When not set, the widget will inherit the font map from its parent.
*/
void
gtk_widget_set_font_map (GtkWidget *widget,
PangoFontMap *font_map)
{
PangoFontMap *map;
g_return_if_fail (GTK_IS_WIDGET (widget));
map = PANGO_FONT_MAP (g_object_get_qdata (G_OBJECT (widget), quark_font_map));
if (map == font_map)
return;
g_object_set_qdata_full (G_OBJECT (widget),
quark_font_map,
g_object_ref (font_map),
g_object_unref);
gtk_widget_update_pango_context (widget);
gtk_widget_forall (widget, gtk_widget_set_font_map_recurse, NULL);
}
/**
* gtk_widget_get_font_map:
* @widget: a #GtkWidget
*
* Gets the font map that has been set with gtk_widget_set_font_map().
*
* Returns: (transfer none) (nullable): A #PangoFontMap, or %NULL
*/
PangoFontMap *
gtk_widget_get_font_map (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return PANGO_FONT_MAP (g_object_get_qdata (G_OBJECT (widget), quark_font_map));
}
/**
* gtk_widget_create_pango_context:
* @widget: a #GtkWidget
*
* Creates a new #PangoContext with the appropriate font map,
* font options, font description, and base direction for drawing
* text for this widget. See also gtk_widget_get_pango_context().
*
* Returns: (transfer full): the new #PangoContext
**/
PangoContext *
gtk_widget_create_pango_context (GtkWidget *widget)
{
PangoContext *context;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
context = pango_font_map_create_context (pango_cairo_font_map_get_default ());
update_pango_context (widget, context);
pango_context_set_language (context, gtk_get_default_language ());
return context;
}
/**
* gtk_widget_create_pango_layout:
* @widget: a #GtkWidget
* @text: (nullable): text to set on the layout (can be %NULL)
*
* Creates a new #PangoLayout with the appropriate font map,
* font description, and base direction for drawing text for
* this widget.
*
* If you keep a #PangoLayout created in this way around, you need
* to re-create it when the widget #PangoContext is replaced.
* This can be tracked by listening to changes of the #GtkWidget:root property
* on the widget.
*
* Returns: (transfer full): the new #PangoLayout
**/
PangoLayout *
gtk_widget_create_pango_layout (GtkWidget *widget,
const char *text)
{
PangoLayout *layout;
PangoContext *context;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
context = gtk_widget_get_pango_context (widget);
layout = pango_layout_new (context);
if (text)
pango_layout_set_text (layout, text, -1);
return layout;
}
/**
* gtk_widget_set_child_visible:
* @widget: a #GtkWidget
* @child_visible: if %TRUE, @widget should be mapped along with its parent.
*
* Sets whether @widget should be mapped along with its when its parent
* is mapped and @widget has been shown with gtk_widget_show().
*
* The child visibility can be set for widget before it is added to
* a container with gtk_widget_set_parent(), to avoid mapping
* children unnecessary before immediately unmapping them. However
* it will be reset to its default state of %TRUE when the widget
* is removed from a container.
*
* Note that changing the child visibility of a widget does not
* queue a resize on the widget. Most of the time, the size of
* a widget is computed from all visible children, whether or
* not they are mapped. If this is not the case, the container
* can queue a resize itself.
*
* This function is only useful for container implementations and
* never should be called by an application.
**/
void
gtk_widget_set_child_visible (GtkWidget *widget,
gboolean child_visible)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (!GTK_IS_ROOT (widget));
child_visible = !!child_visible;
if (priv->child_visible == child_visible)
return;
g_object_ref (widget);
gtk_widget_verify_invariants (widget);
if (child_visible)
priv->child_visible = TRUE;
else
{
GtkRoot *root;
priv->child_visible = FALSE;
root = _gtk_widget_get_root (widget);
if (GTK_WIDGET (root) != widget && GTK_IS_WINDOW (root))
_gtk_window_unset_focus_and_default (GTK_WINDOW (root), widget);
}
if (priv->parent && _gtk_widget_get_realized (priv->parent))
{
if (_gtk_widget_get_mapped (priv->parent) &&
priv->child_visible &&
_gtk_widget_get_visible (widget))
gtk_widget_map (widget);
else
gtk_widget_unmap (widget);
}
gtk_widget_verify_invariants (widget);
g_object_unref (widget);
}
/**
* gtk_widget_get_child_visible:
* @widget: a #GtkWidget
*
* Gets the value set with gtk_widget_set_child_visible().
* If you feel a need to use this function, your code probably
* needs reorganization.
*
* This function is only useful for container implementations and
* never should be called by an application.
*
* Returns: %TRUE if the widget is mapped with the parent.
**/
gboolean
gtk_widget_get_child_visible (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->child_visible;
}
void
_gtk_widget_scale_changed (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->context)
gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget));
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_SCALE_FACTOR]);
gtk_widget_queue_draw (widget);
gtk_widget_forall (widget, (GtkCallback)_gtk_widget_scale_changed, NULL);
}
/**
* gtk_widget_get_scale_factor:
* @widget: a #GtkWidget
*
* Retrieves the internal scale factor that maps from window coordinates
* to the actual device pixels. On traditional systems this is 1, on
* high density outputs, it can be a higher value (typically 2).
*
* See gdk_surface_get_scale_factor().
*
* Returns: the scale factor for @widget
*/
int
gtk_widget_get_scale_factor (GtkWidget *widget)
{
GtkRoot *root;
GdkDisplay *display;
GdkMonitor *monitor;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 1);
if (_gtk_widget_get_realized (widget))
{
GdkSurface *surface = gtk_widget_get_surface (widget);
if (surface)
return gdk_surface_get_scale_factor (surface);
}
root = _gtk_widget_get_root (widget);
if (root && GTK_WIDGET (root) != widget)
return gtk_widget_get_scale_factor (GTK_WIDGET (root));
/* else fall back to something that is more likely to be right than
* just returning 1:
*/
display = _gtk_widget_get_display (widget);
if (display)
{
monitor = g_list_model_get_item (gdk_display_get_monitors (display), 0);
if (monitor)
{
int result = gdk_monitor_get_scale_factor (monitor);
g_object_unref (monitor);
return result;
}
}
return 1;
}
/**
* gtk_widget_get_display:
* @widget: a #GtkWidget
*
* Get the #GdkDisplay for the toplevel window associated with
* this widget. This function can only be called after the widget
* has been added to a widget hierarchy with a #GtkWindow at the top.
*
* In general, you should only create display specific
* resources when a widget has been realized, and you should
* free those resources when the widget is unrealized.
*
* Returns: (transfer none): the #GdkDisplay for the toplevel for this widget.
**/
GdkDisplay*
gtk_widget_get_display (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return _gtk_widget_get_display (widget);
}
/**
* gtk_widget_child_focus:
* @widget: a #GtkWidget
* @direction: direction of focus movement
*
* This function is used by custom widget implementations; if you're
* writing an app, you’d use gtk_widget_grab_focus() to move the focus
* to a particular widget.
*
* gtk_widget_child_focus() is called by widgets as the user moves
* around the window using keyboard shortcuts. @direction indicates
* what kind of motion is taking place (up, down, left, right, tab
* forward, tab backward). gtk_widget_child_focus() calls the
* #GtkWidgetClass.focus() vfunc; widgets override this vfunc
* in order to implement appropriate focus behavior.
*
* The default focus() vfunc for a widget should return %TRUE if
* moving in @direction left the focus on a focusable location inside
* that widget, and %FALSE if moving in @direction moved the focus
* outside the widget. If returning %TRUE, widgets normally
* call gtk_widget_grab_focus() to place the focus accordingly;
* if returning %FALSE, they don’t modify the current focus location.
*
* Returns: %TRUE if focus ended up inside @widget
**/
gboolean
gtk_widget_child_focus (GtkWidget *widget,
GtkDirectionType direction)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (!_gtk_widget_get_visible (widget) ||
!gtk_widget_is_sensitive (widget) ||
!gtk_widget_get_can_focus (widget))
return FALSE;
/* Emit ::focus in any case, even if focusable is FALSE,
* since any widget might have child widgets that will take
* focus
*/
return GTK_WIDGET_GET_CLASS (widget)->focus (widget, direction);
}
/**
* gtk_widget_keynav_failed:
* @widget: a #GtkWidget
* @direction: direction of focus movement
*
* This function should be called whenever keyboard navigation within
* a single widget hits a boundary. The function emits the
* #GtkWidget::keynav-failed signal on the widget and its return
* value should be interpreted in a way similar to the return value of
* gtk_widget_child_focus():
*
* When %TRUE is returned, stay in the widget, the failed keyboard
* navigation is OK and/or there is nowhere we can/should move the
* focus to.
*
* When %FALSE is returned, the caller should continue with keyboard
* navigation outside the widget, e.g. by calling
* gtk_widget_child_focus() on the widget’s toplevel.
*
* The default ::keynav-failed handler returns %FALSE for
* %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
* values of #GtkDirectionType it returns %TRUE.
*
* Whenever the default handler returns %TRUE, it also calls
* gtk_widget_error_bell() to notify the user of the failed keyboard
* navigation.
*
* A use case for providing an own implementation of ::keynav-failed
* (either by connecting to it or by overriding it) would be a row of
* #GtkEntry widgets where the user should be able to navigate the
* entire row with the cursor keys, as e.g. known from user interfaces
* that require entering license keys.
*
* Returns: %TRUE if stopping keyboard navigation is fine, %FALSE
* if the emitting widget should try to handle the keyboard
* navigation attempt in its parent container(s).
**/
gboolean
gtk_widget_keynav_failed (GtkWidget *widget,
GtkDirectionType direction)
{
gboolean return_val;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_signal_emit (widget, widget_signals[KEYNAV_FAILED], 0,
direction, &return_val);
return return_val;
}
/**
* gtk_widget_error_bell:
* @widget: a #GtkWidget
*
* Notifies the user about an input-related error on this widget.
* If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
* gdk_surface_beep(), otherwise it does nothing.
*
* Note that the effect of gdk_surface_beep() can be configured in many
* ways, depending on the windowing backend and the desktop environment
* or window manager that is used.
**/
void
gtk_widget_error_bell (GtkWidget *widget)
{
GtkSettings* settings;
gboolean beep;
GdkSurface *surface;
g_return_if_fail (GTK_IS_WIDGET (widget));
settings = gtk_widget_get_settings (widget);
if (!settings)
return;
surface = gtk_widget_get_surface (widget);
g_object_get (settings,
"gtk-error-bell", &beep,
NULL);
if (beep && surface)
gdk_surface_beep (surface);
}
static void
gtk_widget_set_usize_internal (GtkWidget *widget,
int width,
int height)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean changed = FALSE;
g_object_freeze_notify (G_OBJECT (widget));
if (width > -2 && priv->width_request != width)
{
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_WIDTH_REQUEST]);
priv->width_request = width;
changed = TRUE;
}
if (height > -2 && priv->height_request != height)
{
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_HEIGHT_REQUEST]);
priv->height_request = height;
changed = TRUE;
}
if (_gtk_widget_get_visible (widget) && changed)
{
gtk_widget_queue_resize (widget);
}
g_object_thaw_notify (G_OBJECT (widget));
}
/**
* gtk_widget_set_size_request:
* @widget: a #GtkWidget
* @width: width @widget should request, or -1 to unset
* @height: height @widget should request, or -1 to unset
*
* Sets the minimum size of a widget; that is, the widget’s size
* request will be at least @width by @height. You can use this
* function to force a widget to be larger than it normally would be.
*
* In most cases, gtk_window_set_default_size() is a better choice for
* toplevel windows than this function; setting the default size will
* still allow users to shrink the window. Setting the size request
* will force them to leave the window at least as large as the size
* request. When dealing with window sizes,
* gtk_window_set_geometry_hints() can be a useful function as well.
*
* Note the inherent danger of setting any fixed size - themes,
* translations into other languages, different fonts, and user action
* can all change the appropriate size for a given widget. So, it's
* basically impossible to hardcode a size that will always be
* correct.
*
* The size request of a widget is the smallest size a widget can
* accept while still functioning well and drawing itself correctly.
* However in some strange cases a widget may be allocated less than
* its requested size, and in many cases a widget may be allocated more
* space than it requested.
*
* If the size request in a given direction is -1 (unset), then
* the “natural” size request of the widget will be used instead.
*
* The size request set here does not include any margin from the
* #GtkWidget properties margin-left, margin-right, margin-top, and
* margin-bottom, but it does include pretty much all other padding
* or border properties set by any subclass of #GtkWidget.
**/
void
gtk_widget_set_size_request (GtkWidget *widget,
int width,
int height)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (width >= -1);
g_return_if_fail (height >= -1);
gtk_widget_set_usize_internal (widget, width, height);
}
/**
* gtk_widget_get_size_request:
* @widget: a #GtkWidget
* @width: (out) (allow-none): return location for width, or %NULL
* @height: (out) (allow-none): return location for height, or %NULL
*
* Gets the size request that was explicitly set for the widget using
* gtk_widget_set_size_request(). A value of -1 stored in @width or
* @height indicates that that dimension has not been set explicitly
* and the natural requisition of the widget will be used instead. See
* gtk_widget_set_size_request(). To get the size a widget will
* actually request, call gtk_widget_measure() instead of
* this function.
**/
void
gtk_widget_get_size_request (GtkWidget *widget,
int *width,
int *height)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (width)
*width = priv->width_request;
if (height)
*height = priv->height_request;
}
/*< private >
* gtk_widget_has_size_request:
* @widget: a #GtkWidget
*
* Returns if the widget has a size request set (anything besides -1 for height
* or width)
*/
gboolean
gtk_widget_has_size_request (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return !(priv->width_request == -1 && priv->height_request == -1);
}
/**
* gtk_widget_get_ancestor:
* @widget: a #GtkWidget
* @widget_type: ancestor type
*
* Gets the first ancestor of @widget with type @widget_type. For example,
* `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
* the first #GtkBox that’s an ancestor of @widget. No reference will be
* added to the returned widget; it should not be unreferenced.
*
* Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
* considers @widget to be an ancestor of itself.
*
* Returns: (transfer none) (nullable): the ancestor widget, or %NULL if not found
**/
GtkWidget*
gtk_widget_get_ancestor (GtkWidget *widget,
GType widget_type)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
while (widget && !g_type_is_a (G_OBJECT_TYPE (widget), widget_type))
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
widget = priv->parent;
}
return widget;
}
/**
* gtk_widget_get_settings:
* @widget: a #GtkWidget
*
* Gets the settings object holding the settings used for this widget.
*
* Note that this function can only be called when the #GtkWidget
* is attached to a toplevel, since the settings object is specific
* to a particular #GdkDisplay. If you want to monitor the widget for
* changes in its settings, connect to notify::display.
*
* Returns: (transfer none): the relevant #GtkSettings object
*/
GtkSettings*
gtk_widget_get_settings (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return gtk_settings_get_for_display (_gtk_widget_get_display (widget));
}
/**
* gtk_widget_is_ancestor:
* @widget: a #GtkWidget
* @ancestor: another #GtkWidget
*
* Determines whether @widget is somewhere inside @ancestor, possibly with
* intermediate containers.
*
* Returns: %TRUE if @ancestor contains @widget as a child,
* grandchild, great grandchild, etc.
**/
gboolean
gtk_widget_is_ancestor (GtkWidget *widget,
GtkWidget *ancestor)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (ancestor != NULL, FALSE);
while (widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->parent == ancestor)
return TRUE;
widget = priv->parent;
}
return FALSE;
}
static void
gtk_widget_emit_direction_changed (GtkWidget *widget,
GtkTextDirection old_dir)
{
GtkTextDirection direction;
GtkStateFlags state;
gtk_widget_update_pango_context (widget);
direction = _gtk_widget_get_direction (widget);
switch (direction)
{
case GTK_TEXT_DIR_LTR:
state = GTK_STATE_FLAG_DIR_LTR;
break;
case GTK_TEXT_DIR_RTL:
state = GTK_STATE_FLAG_DIR_RTL;
break;
case GTK_TEXT_DIR_NONE:
default:
g_assert_not_reached ();
break;
}
gtk_widget_update_state_flags (widget,
state,
state ^ (GTK_STATE_FLAG_DIR_LTR | GTK_STATE_FLAG_DIR_RTL));
g_signal_emit (widget, widget_signals[DIRECTION_CHANGED], 0, old_dir);
}
/**
* gtk_widget_set_direction:
* @widget: a #GtkWidget
* @dir: the new direction
*
* Sets the reading direction on a particular widget. This direction
* controls the primary direction for widgets containing text,
* and also the direction in which the children of a container are
* packed. The ability to set the direction is present in order
* so that correct localization into languages with right-to-left
* reading directions can be done. Generally, applications will
* let the default reading direction present, except for containers
* where the containers are arranged in an order that is explicitly
* visual rather than logical (such as buttons for text justification).
*
* If the direction is set to %GTK_TEXT_DIR_NONE, then the value
* set by gtk_widget_set_default_direction() will be used.
**/
void
gtk_widget_set_direction (GtkWidget *widget,
GtkTextDirection dir)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkTextDirection old_dir;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (dir >= GTK_TEXT_DIR_NONE && dir <= GTK_TEXT_DIR_RTL);
old_dir = _gtk_widget_get_direction (widget);
priv->direction = dir;
if (old_dir != _gtk_widget_get_direction (widget))
gtk_widget_emit_direction_changed (widget, old_dir);
}
/**
* gtk_widget_get_direction:
* @widget: a #GtkWidget
*
* Gets the reading direction for a particular widget. See
* gtk_widget_set_direction().
*
* Returns: the reading direction for the widget.
**/
GtkTextDirection
gtk_widget_get_direction (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_TEXT_DIR_LTR);
if (priv->direction == GTK_TEXT_DIR_NONE)
return gtk_default_direction;
else
return priv->direction;
}
static void
gtk_widget_set_default_direction_recurse (GtkWidget *widget,
GtkTextDirection old_dir)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidget *child;
g_object_ref (widget);
if (priv->direction == GTK_TEXT_DIR_NONE)
gtk_widget_emit_direction_changed (widget, old_dir);
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_set_default_direction_recurse (child, old_dir);
}
g_object_unref (widget);
}
/**
* gtk_widget_set_default_direction:
* @dir: the new default direction. This cannot be
* %GTK_TEXT_DIR_NONE.
*
* Sets the default reading direction for widgets where the
* direction has not been explicitly set by gtk_widget_set_direction().
**/
void
gtk_widget_set_default_direction (GtkTextDirection dir)
{
g_return_if_fail (dir == GTK_TEXT_DIR_RTL || dir == GTK_TEXT_DIR_LTR);
if (dir != gtk_default_direction)
{
GList *toplevels, *tmp_list;
GtkTextDirection old_dir = gtk_default_direction;
gtk_default_direction = dir;
tmp_list = toplevels = gtk_window_list_toplevels ();
g_list_foreach (toplevels, (GFunc)g_object_ref, NULL);
while (tmp_list)
{
gtk_widget_set_default_direction_recurse (tmp_list->data, old_dir);
g_object_unref (tmp_list->data);
tmp_list = tmp_list->next;
}
g_list_free (toplevels);
}
}
/**
* gtk_widget_get_default_direction:
*
* Obtains the current default reading direction. See
* gtk_widget_set_default_direction().
*
* Returns: the current default direction.
**/
GtkTextDirection
gtk_widget_get_default_direction (void)
{
return gtk_default_direction;
}
static void
gtk_widget_dispose (GObject *object)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *sizegroups;
GtkActionMuxer *muxer;
GtkATContext *at_context;
muxer = g_object_get_qdata (G_OBJECT (widget), quark_action_muxer);
if (muxer != NULL)
g_object_run_dispose (G_OBJECT (muxer));
if (priv->children_observer)
gtk_list_list_model_clear (priv->children_observer);
if (priv->controller_observer)
gtk_list_list_model_clear (priv->controller_observer);
if (priv->parent)
{
g_critical ("%s %p has a parent %s %p during dispose. Parents hold a reference, so this should not happen.\n"
"Did you call g_object_unref() instead of gtk_widget_unparent()?",
G_OBJECT_TYPE_NAME (widget), widget,
G_OBJECT_TYPE_NAME (priv->parent), priv->parent);
priv->parent = NULL;
}
while (priv->paintables)
gtk_widget_paintable_set_widget (priv->paintables->data, NULL);
if (priv->layout_manager != NULL)
gtk_layout_manager_set_widget (priv->layout_manager, NULL);
g_clear_object (&priv->layout_manager);
priv->visible = FALSE;
if (_gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
g_clear_object (&priv->cursor);
if (!priv->in_destruction)
{
priv->in_destruction = TRUE;
g_signal_emit (object, widget_signals[DESTROY], 0);
priv->in_destruction = FALSE;
gtk_widget_real_destroy (widget);
}
sizegroups = _gtk_widget_get_sizegroups (widget);
while (sizegroups)
{
GtkSizeGroup *size_group;
size_group = sizegroups->data;
sizegroups = sizegroups->next;
gtk_size_group_remove_widget (size_group, widget);
}
at_context = gtk_accessible_get_at_context (GTK_ACCESSIBLE (widget));
if (at_context != NULL)
gtk_at_context_unrealize (at_context);
g_object_set_qdata (object, quark_action_muxer, NULL);
G_OBJECT_CLASS (gtk_widget_parent_class)->dispose (object);
}
#ifdef G_ENABLE_CONSISTENCY_CHECKS
typedef struct {
AutomaticChildClass *child_class;
GType widget_type;
GObject *object;
gboolean did_finalize;
} FinalizeAssertion;
static void
finalize_assertion_weak_ref (gpointer data,
GObject *where_the_object_was)
{
FinalizeAssertion *assertion = (FinalizeAssertion *)data;
assertion->did_finalize = TRUE;
}
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
static void
gtk_widget_real_destroy (GtkWidget *object)
{
GtkWidget *widget = GTK_WIDGET (object);
if (g_object_get_qdata (G_OBJECT (widget), quark_auto_children))
{
GtkWidgetClass *class;
GSList *l;
#ifdef G_ENABLE_CONSISTENCY_CHECKS
GSList *assertions = NULL;
/* Note, GTK_WIDGET_ASSERT_COMPONENTS is very useful
* to catch ref counting bugs, but can only be used in
* test cases which simply create and destroy a composite
* widget.
*
* This is because some API can expose components explicitly,
* and so we cannot assert that a component is expected to finalize
* in a full application ecosystem.
*/
if (g_getenv ("GTK_WIDGET_ASSERT_COMPONENTS") != NULL)
{
GType class_type;
for (class = GTK_WIDGET_GET_CLASS (widget);
GTK_IS_WIDGET_CLASS (class);
class = g_type_class_peek_parent (class))
{
if (!class->priv->template)
continue;
class_type = G_OBJECT_CLASS_TYPE (class);
for (l = class->priv->template->children; l; l = l->next)
{
AutomaticChildClass *child_class = l->data;
GObject *child_object = gtk_widget_get_template_child (widget,
class_type,
child_class->name);
g_assert (child_object);
if (!G_IS_OBJECT (child_object))
{
g_critical ("Automated component '%s' of class '%s' seems to"
" have been prematurely finalized",
child_class->name, g_type_name (class_type));
}
else
{
FinalizeAssertion *assertion = g_slice_new0 (FinalizeAssertion);
assertion->child_class = child_class;
assertion->widget_type = class_type;
assertion->object = child_object;
g_object_weak_ref (child_object, finalize_assertion_weak_ref, assertion);
assertions = g_slist_prepend (assertions, assertion);
}
}
}
}
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
/* Release references to all automated children */
g_object_set_qdata (G_OBJECT (widget), quark_auto_children, NULL);
#ifdef G_ENABLE_CONSISTENCY_CHECKS
for (l = assertions; l; l = l->next)
{
FinalizeAssertion *assertion = l->data;
if (!assertion->did_finalize)
g_critical ("Automated component '%s' of class '%s' did not finalize in dispose()"
"Current reference count is %d",
assertion->child_class->name,
g_type_name (assertion->widget_type),
assertion->object->ref_count);
g_slice_free (FinalizeAssertion, assertion);
}
g_slist_free (assertions);
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
/* Set any automatic private data pointers to NULL */
for (class = GTK_WIDGET_GET_CLASS (widget);
GTK_IS_WIDGET_CLASS (class);
class = g_type_class_peek_parent (class))
{
if (!class->priv->template)
continue;
for (l = class->priv->template->children; l; l = l->next)
{
AutomaticChildClass *child_class = l->data;
if (child_class->offset != 0)
{
gpointer field_p;
/* Nullify instance private data for internal children */
field_p = G_STRUCT_MEMBER_P (widget, child_class->offset);
(* (gpointer *) field_p) = NULL;
}
}
}
}
/* Callers of add_mnemonic_label() should disconnect on ::destroy */
g_object_set_qdata (G_OBJECT (widget), quark_mnemonic_labels, NULL);
gtk_grab_remove (widget);
destroy_tick_callbacks (widget);
destroy_surface_transform_data (widget);
}
static void
gtk_widget_finalize (GObject *object)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
gtk_grab_remove (widget);
g_free (priv->name);
g_free (priv->tooltip_markup);
g_free (priv->tooltip_text);
g_clear_pointer (&priv->transform, gsk_transform_unref);
g_clear_pointer (&priv->allocated_transform, gsk_transform_unref);
gtk_css_widget_node_widget_destroyed (GTK_CSS_WIDGET_NODE (priv->cssnode));
g_object_unref (priv->cssnode);
g_clear_object (&priv->context);
g_clear_object (&priv->at_context);
_gtk_size_request_cache_free (&priv->requests);
l = priv->event_controllers;
while (l)
{
GList *next = l->next;
GtkEventController *controller = l->data;
if (controller)
gtk_widget_remove_controller (widget, controller);
l = next;
}
g_assert (priv->event_controllers == NULL);
if (_gtk_widget_get_first_child (widget) != NULL)
{
GtkWidget *child;
g_warning ("Finalizing %s %p, but it still has children left:",
gtk_widget_get_name (widget), widget);
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
g_warning (" - %s %p", gtk_widget_get_name (child), child);
}
}
if (g_object_is_floating (object))
g_warning ("A floating object was finalized. This means that someone\n"
"called g_object_unref() on an object that had only a floating\n"
"reference; the initial floating reference is not owned by anyone\n"
"and must be removed with g_object_ref_sink().");
G_OBJECT_CLASS (gtk_widget_parent_class)->finalize (object);
}
/*****************************************
* gtk_widget_real_map:
*
* arguments:
*
* results:
*****************************************/
static void
gtk_widget_real_map (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_assert (_gtk_widget_get_realized (widget));
if (!_gtk_widget_get_mapped (widget))
{
GtkWidget *p;
priv->mapped = TRUE;
for (p = gtk_widget_get_first_child (widget);
p != NULL;
p = gtk_widget_get_next_sibling (p))
{
if (_gtk_widget_get_visible (p) &&
_gtk_widget_get_child_visible (p) &&
!_gtk_widget_get_mapped (p))
gtk_widget_map (p);
}
}
}
/*****************************************
* gtk_widget_real_unmap:
*
* arguments:
*
* results:
*****************************************/
static void
gtk_widget_real_unmap (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (_gtk_widget_get_mapped (widget))
{
GtkWidget *child;
priv->mapped = FALSE;
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_unmap (child);
}
gtk_widget_update_paintables (widget);
gtk_widget_unset_state_flags (widget,
GTK_STATE_FLAG_PRELIGHT |
GTK_STATE_FLAG_ACTIVE);
}
}
/*****************************************
* gtk_widget_real_realize:
*
* arguments:
*
* results:
*****************************************/
static void
gtk_widget_real_realize (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->realized = TRUE;
/* Connect frame clock */
if (priv->tick_callbacks != NULL && !priv->clock_tick_id)
{
GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
priv->clock_tick_id = g_signal_connect (frame_clock, "update",
G_CALLBACK (gtk_widget_on_frame_clock_update),
widget);
gdk_frame_clock_begin_updating (frame_clock);
}
gtk_css_node_invalidate_frame_clock (priv->cssnode, FALSE);
}
/*****************************************
* gtk_widget_real_unrealize:
*
* arguments:
*
* results:
*****************************************/
static void
gtk_widget_real_unrealize (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_assert (!priv->mapped);
/* We must do unrealize child widget BEFORE container widget.
* gdk_surface_destroy() destroys specified xwindow and its sub-xwindows.
* So, unrealizing container widget before its children causes the problem
* (for example, gdk_ic_destroy () with destroyed window causes crash.)
*/
gtk_widget_forall (widget, (GtkCallback)gtk_widget_unrealize, NULL);
/* Disconnect frame clock */
gtk_css_node_invalidate_frame_clock (priv->cssnode, FALSE);
if (priv->clock_tick_id)
{
GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (widget);
g_signal_handler_disconnect (frame_clock, priv->clock_tick_id);
priv->clock_tick_id = 0;
gdk_frame_clock_end_updating (frame_clock);
}
priv->realized = FALSE;
}
void
gtk_widget_adjust_size_request (GtkWidget *widget,
GtkOrientation orientation,
int *minimum_size,
int *natural_size)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (orientation == GTK_ORIENTATION_HORIZONTAL && priv->width_request > 0)
*minimum_size = MAX (*minimum_size, priv->width_request);
else if (orientation == GTK_ORIENTATION_VERTICAL && priv->height_request > 0)
*minimum_size = MAX (*minimum_size, priv->height_request);
/* Fix it if set_size_request made natural size smaller than min size.
* This would also silently fix broken widgets, but we warn about them
* in gtksizerequest.c when calling their size request vfuncs.
*/
*natural_size = MAX (*natural_size, *minimum_size);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
*minimum_size += priv->margin.left + priv->margin.right;
*natural_size += priv->margin.left + priv->margin.right;
}
else
{
*minimum_size += priv->margin.top + priv->margin.bottom;
*natural_size += priv->margin.top + priv->margin.bottom;
}
}
void
gtk_widget_adjust_baseline_request (GtkWidget *widget,
int *minimum_baseline,
int *natural_baseline)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->height_request >= 0)
{
/* No baseline support for explicitly set height */
*minimum_baseline = -1;
*natural_baseline = -1;
}
else
{
*minimum_baseline += priv->margin.top;
*natural_baseline += priv->margin.top;
}
}
/*
* _gtk_widget_list_devices:
* @widget: a #GtkWidget
*
* Returns the list of pointer #GdkDevices that are currently
* on top of @widget. Free the list
* with g_free(), the elements are owned by GTK and must
* not be freed.
*/
static GdkDevice **
_gtk_widget_list_devices (GtkWidget *widget,
guint *out_n_devices)
{
GtkRoot *root;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
g_assert (out_n_devices);
if (!_gtk_widget_get_mapped (widget))
{
*out_n_devices = 0;
return NULL;
}
root = gtk_widget_get_root (widget);
if (!root)
{
*out_n_devices = 0;
return NULL;
}
return gtk_window_get_foci_on_widget (GTK_WINDOW (root),
widget, out_n_devices);
}
/*
* _gtk_widget_synthesize_crossing:
* @from: the #GtkWidget the virtual pointer is leaving.
* @to: the #GtkWidget the virtual pointer is moving to.
* @mode: the #GdkCrossingMode to place on the synthesized events.
*
* Generate crossing event(s) on widget state (sensitivity) or GTK grab change.
*/
void
_gtk_widget_synthesize_crossing (GtkWidget *from,
GtkWidget *to,
GdkDevice *device,
GdkCrossingMode mode)
{
GdkSurface *from_surface = NULL, *to_surface = NULL;
GtkCrossingData crossing;
double x, y;
g_return_if_fail (from != NULL || to != NULL);
crossing.type = GTK_CROSSING_POINTER;
crossing.mode = mode;
crossing.old_target = from;
crossing.old_descendent = NULL;
crossing.new_target = to;
crossing.new_descendent = NULL;
if (from)
{
crossing.direction = GTK_CROSSING_OUT;
from_surface = gtk_widget_get_surface (from);
gdk_surface_get_device_position (from_surface, device, &x, &y, NULL);
gtk_widget_handle_crossing (from, &crossing, x, y);
}
if (to)
{
to_surface = gtk_widget_get_surface (to);
crossing.direction = GTK_CROSSING_IN;
gdk_surface_get_device_position (to_surface, device, &x, &y, NULL);
gtk_widget_handle_crossing (to, &crossing, x, y);
}
}
static void
gtk_widget_propagate_state (GtkWidget *widget,
const GtkStateData *data)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkStateFlags new_flags, old_flags = priv->state_flags;
GtkStateData child_data;
GtkWidget *child;
int new_scale_factor = gtk_widget_get_scale_factor (widget);
priv->state_flags |= data->flags_to_set;
priv->state_flags &= ~(data->flags_to_unset);
/* make insensitivity unoverridable */
if (!priv->sensitive)
priv->state_flags |= GTK_STATE_FLAG_INSENSITIVE;
if (gtk_widget_is_focus (widget) && !gtk_widget_is_sensitive (widget))
gtk_root_set_focus (priv->root, NULL);
new_flags = priv->state_flags;
if (data->old_scale_factor != new_scale_factor)
_gtk_widget_scale_changed (widget);
if (old_flags != new_flags)
{
GtkWindowGroup *window_group;
GtkRoot *root;
GtkWidget *grab;
gboolean shadowed;
g_object_ref (widget);
root = gtk_widget_get_root (widget);
window_group = gtk_window_get_group (GTK_WINDOW (root));
grab = gtk_window_group_get_current_grab (window_group);
shadowed = grab && grab != widget && !gtk_widget_is_ancestor (widget, grab);
if (!gtk_widget_is_sensitive (widget) && gtk_widget_has_grab (widget))
gtk_grab_remove (widget);
gtk_css_node_set_state (priv->cssnode, new_flags);
g_signal_emit (widget, widget_signals[STATE_FLAGS_CHANGED], 0, old_flags);
if (!shadowed &&
(new_flags & GTK_STATE_FLAG_INSENSITIVE) != (old_flags & GTK_STATE_FLAG_INSENSITIVE))
{
guint i, n_devices;
GdkDevice **devices;
devices = _gtk_widget_list_devices (widget, &n_devices);
for (i = 0; i < n_devices; i++)
{
GdkDevice *device;
device = devices[i];
if (!gtk_widget_is_sensitive (widget))
_gtk_widget_synthesize_crossing (widget, NULL, device,
GDK_CROSSING_STATE_CHANGED);
else
_gtk_widget_synthesize_crossing (NULL, widget, device,
GDK_CROSSING_STATE_CHANGED);
}
g_free (devices);
}
if (!gtk_widget_is_sensitive (widget))
gtk_widget_reset_controllers (widget);
/* Make sure to only propagate the right states further */
child_data.old_scale_factor = new_scale_factor;
child_data.flags_to_set = data->flags_to_set & GTK_STATE_FLAGS_DO_SET_PROPAGATE;
child_data.flags_to_unset = data->flags_to_unset & GTK_STATE_FLAGS_DO_UNSET_PROPAGATE;
if (child_data.flags_to_set != 0 ||
child_data.flags_to_unset != 0)
{
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_propagate_state (child, &child_data);
}
}
g_object_unref (widget);
}
}
/**
* gtk_requisition_new:
*
* Allocates a new #GtkRequisition-struct and initializes its elements to zero.
*
* Returns: a new empty #GtkRequisition. The newly allocated #GtkRequisition should
* be freed with gtk_requisition_free().
*/
GtkRequisition *
gtk_requisition_new (void)
{
return g_slice_new0 (GtkRequisition);
}
/**
* gtk_requisition_copy:
* @requisition: a #GtkRequisition
*
* Copies a #GtkRequisition.
*
* Returns: a copy of @requisition
**/
GtkRequisition *
gtk_requisition_copy (const GtkRequisition *requisition)
{
return g_slice_dup (GtkRequisition, requisition);
}
/**
* gtk_requisition_free:
* @requisition: a #GtkRequisition
*
* Frees a #GtkRequisition.
**/
void
gtk_requisition_free (GtkRequisition *requisition)
{
g_slice_free (GtkRequisition, requisition);
}
G_DEFINE_BOXED_TYPE (GtkRequisition, gtk_requisition,
gtk_requisition_copy,
gtk_requisition_free)
/*
* Expand flag management
*/
static void
gtk_widget_update_computed_expand (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->need_compute_expand)
{
gboolean h, v;
if (priv->hexpand_set)
h = priv->hexpand;
else
h = FALSE;
if (priv->vexpand_set)
v = priv->vexpand;
else
v = FALSE;
/* we don't need to use compute_expand if both expands are
* forced by the app
*/
if (!(priv->hexpand_set && priv->vexpand_set))
{
if (GTK_WIDGET_GET_CLASS (widget)->compute_expand != NULL)
{
gboolean ignored;
GTK_WIDGET_GET_CLASS (widget)->compute_expand (widget,
priv->hexpand_set ? &ignored : &h,
priv->vexpand_set ? &ignored : &v);
}
}
priv->need_compute_expand = FALSE;
priv->computed_hexpand = h != FALSE;
priv->computed_vexpand = v != FALSE;
}
}
/**
* gtk_widget_queue_compute_expand:
* @widget: a #GtkWidget
*
* Mark @widget as needing to recompute its expand flags. Call
* this function when setting legacy expand child properties
* on the child of a container.
*
* See gtk_widget_compute_expand().
*/
static void
gtk_widget_queue_compute_expand (GtkWidget *widget)
{
GtkWidget *parent;
gboolean changed_anything;
if (widget->priv->need_compute_expand)
return;
changed_anything = FALSE;
parent = widget;
while (parent != NULL)
{
if (!parent->priv->need_compute_expand)
{
parent->priv->need_compute_expand = TRUE;
changed_anything = TRUE;
}
/* Note: if we had an invariant that "if a child needs to
* compute expand, its parents also do" then we could stop going
* up when we got to a parent that already needed to
* compute. However, in general we compute expand lazily (as
* soon as we see something in a subtree that is expand, we know
* we're expanding) and so this invariant does not hold and we
* have to always walk all the way up in case some ancestor
* is not currently need_compute_expand.
*/
parent = parent->priv->parent;
}
/* recomputing expand always requires
* a relayout as well
*/
if (changed_anything)
gtk_widget_queue_resize (widget);
}
/**
* gtk_widget_compute_expand:
* @widget: the widget
* @orientation: expand direction
*
* Computes whether a container should give this widget extra space
* when possible. Containers should check this, rather than
* looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
*
* This function already checks whether the widget is visible, so
* visibility does not need to be checked separately. Non-visible
* widgets are not expanded.
*
* The computed expand value uses either the expand setting explicitly
* set on the widget itself, or, if none has been explicitly set,
* the widget may expand if some of its children do.
*
* Returns: whether widget tree rooted here should be expanded
*/
gboolean
gtk_widget_compute_expand (GtkWidget *widget,
GtkOrientation orientation)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
/* We never make a widget expand if not even showing. */
if (!_gtk_widget_get_visible (widget))
return FALSE;
gtk_widget_update_computed_expand (widget);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
return priv->computed_hexpand;
else
return priv->computed_vexpand;
}
static void
gtk_widget_set_expand (GtkWidget *widget,
GtkOrientation orientation,
gboolean expand)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
int expand_prop;
int expand_set_prop;
g_return_if_fail (GTK_IS_WIDGET (widget));
expand = expand != FALSE;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
if (priv->hexpand_set &&
priv->hexpand == expand)
return;
priv->hexpand_set = TRUE;
priv->hexpand = expand;
expand_prop = PROP_HEXPAND;
expand_set_prop = PROP_HEXPAND_SET;
}
else
{
if (priv->vexpand_set &&
priv->vexpand == expand)
return;
priv->vexpand_set = TRUE;
priv->vexpand = expand;
expand_prop = PROP_VEXPAND;
expand_set_prop = PROP_VEXPAND_SET;
}
gtk_widget_queue_compute_expand (widget);
g_object_freeze_notify (G_OBJECT (widget));
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[expand_prop]);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[expand_set_prop]);
g_object_thaw_notify (G_OBJECT (widget));
}
static void
gtk_widget_set_expand_set (GtkWidget *widget,
GtkOrientation orientation,
gboolean set)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
int prop;
set = set != FALSE;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
if (set == priv->hexpand_set)
return;
priv->hexpand_set = set;
prop = PROP_HEXPAND_SET;
}
else
{
if (set == priv->vexpand_set)
return;
priv->vexpand_set = set;
prop = PROP_VEXPAND_SET;
}
gtk_widget_queue_compute_expand (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[prop]);
}
/**
* gtk_widget_get_hexpand:
* @widget: the widget
*
* Gets whether the widget would like any available extra horizontal
* space. When a user resizes a #GtkWindow, widgets with expand=TRUE
* generally receive the extra space. For example, a list or
* scrollable area or document in your window would often be set to
* expand.
*
* Containers should use gtk_widget_compute_expand() rather than
* this function, to see whether a widget, or any of its children,
* has the expand flag set. If any child of a widget wants to
* expand, the parent may ask to expand also.
*
* This function only looks at the widget’s own hexpand flag, rather
* than computing whether the entire widget tree rooted at this widget
* wants to expand.
*
* Returns: whether hexpand flag is set
*/
gboolean
gtk_widget_get_hexpand (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->hexpand;
}
/**
* gtk_widget_set_hexpand:
* @widget: the widget
* @expand: whether to expand
*
* Sets whether the widget would like any available extra horizontal
* space. When a user resizes a #GtkWindow, widgets with expand=TRUE
* generally receive the extra space. For example, a list or
* scrollable area or document in your window would often be set to
* expand.
*
* Call this function to set the expand flag if you would like your
* widget to become larger horizontally when the window has extra
* room.
*
* By default, widgets automatically expand if any of their children
* want to expand. (To see if a widget will automatically expand given
* its current children and state, call gtk_widget_compute_expand(). A
* container can decide how the expandability of children affects the
* expansion of the container by overriding the compute_expand virtual
* method on #GtkWidget.).
*
* Setting hexpand explicitly with this function will override the
* automatic expand behavior.
*
* This function forces the widget to expand or not to expand,
* regardless of children. The override occurs because
* gtk_widget_set_hexpand() sets the hexpand-set property (see
* gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
* value to be used, rather than looking at children and widget state.
*/
void
gtk_widget_set_hexpand (GtkWidget *widget,
gboolean expand)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_widget_set_expand (widget, GTK_ORIENTATION_HORIZONTAL, expand);
}
/**
* gtk_widget_get_hexpand_set:
* @widget: the widget
*
* Gets whether gtk_widget_set_hexpand() has been used to
* explicitly set the expand flag on this widget.
*
* If hexpand is set, then it overrides any computed
* expand value based on child widgets. If hexpand is not
* set, then the expand value depends on whether any
* children of the widget would like to expand.
*
* There are few reasons to use this function, but it’s here
* for completeness and consistency.
*
* Returns: whether hexpand has been explicitly set
*/
gboolean
gtk_widget_get_hexpand_set (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->hexpand_set;
}
/**
* gtk_widget_set_hexpand_set:
* @widget: the widget
* @set: value for hexpand-set property
*
* Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
* be used.
*
* The hexpand-set property will be set automatically when you call
* gtk_widget_set_hexpand() to set hexpand, so the most likely
* reason to use this function would be to unset an explicit expand
* flag.
*
* If hexpand is set, then it overrides any computed
* expand value based on child widgets. If hexpand is not
* set, then the expand value depends on whether any
* children of the widget would like to expand.
*
* There are few reasons to use this function, but it’s here
* for completeness and consistency.
*/
void
gtk_widget_set_hexpand_set (GtkWidget *widget,
gboolean set)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_widget_set_expand_set (widget, GTK_ORIENTATION_HORIZONTAL, set);
}
/**
* gtk_widget_get_vexpand:
* @widget: the widget
*
* Gets whether the widget would like any available extra vertical
* space.
*
* See gtk_widget_get_hexpand() for more detail.
*
* Returns: whether vexpand flag is set
*/
gboolean
gtk_widget_get_vexpand (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->vexpand;
}
/**
* gtk_widget_set_vexpand:
* @widget: the widget
* @expand: whether to expand
*
* Sets whether the widget would like any available extra vertical
* space.
*
* See gtk_widget_set_hexpand() for more detail.
*/
void
gtk_widget_set_vexpand (GtkWidget *widget,
gboolean expand)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_widget_set_expand (widget, GTK_ORIENTATION_VERTICAL, expand);
}
/**
* gtk_widget_get_vexpand_set:
* @widget: the widget
*
* Gets whether gtk_widget_set_vexpand() has been used to
* explicitly set the expand flag on this widget.
*
* See gtk_widget_get_hexpand_set() for more detail.
*
* Returns: whether vexpand has been explicitly set
*/
gboolean
gtk_widget_get_vexpand_set (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->vexpand_set;
}
/**
* gtk_widget_set_vexpand_set:
* @widget: the widget
* @set: value for vexpand-set property
*
* Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
* be used.
*
* See gtk_widget_set_hexpand_set() for more detail.
*/
void
gtk_widget_set_vexpand_set (GtkWidget *widget,
gboolean set)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_widget_set_expand_set (widget, GTK_ORIENTATION_VERTICAL, set);
}
/*
* GtkAccessible implementation
*/
static GtkATContext *
gtk_widget_accessible_get_at_context (GtkAccessible *accessible)
{
GtkWidget *self = GTK_WIDGET (accessible);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (self);
GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS (self);
GtkWidgetClassPrivate *class_priv = widget_class->priv;
GtkAccessibleRole role;
if (priv->in_destruction)
{
GTK_NOTE (A11Y, g_message ("ATContext for widget “%s” [%p] accessed during destruction",
G_OBJECT_TYPE_NAME (self),
self));
return NULL;
}
if (priv->at_context != NULL)
return priv->at_context;
/* Widgets have two options to set the accessible role: either they
* define it in their class_init() function, and the role applies to
* all instances; or an instance is created with the :accessible-role
* property (from GtkAccessible) set to anything other than the default
* GTK_ACCESSIBLE_ROLE_WIDGET value.
*
* In either case, the accessible role cannot be set post-construction.
*/
if (priv->accessible_role != GTK_ACCESSIBLE_ROLE_WIDGET)
role = priv->accessible_role;
else
role = class_priv->accessible_role;
priv->accessible_role = role;
priv->at_context = gtk_at_context_create (role, accessible, gdk_display_get_default ());
return priv->at_context;
}
static gboolean
gtk_widget_accessible_get_platform_state (GtkAccessible *self,
GtkAccessiblePlatformState state)
{
switch (state)
{
case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE:
return gtk_widget_get_focusable (GTK_WIDGET (self));
case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED:
return gtk_widget_has_focus (GTK_WIDGET (self));
default:
g_assert_not_reached ();
}
}
static void
gtk_widget_accessible_interface_init (GtkAccessibleInterface *iface)
{
iface->get_at_context = gtk_widget_accessible_get_at_context;
iface->get_platform_state = gtk_widget_accessible_get_platform_state;
}
static void
gtk_widget_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *type)
{
if (type != NULL)
{
GTK_BUILDER_WARN_INVALID_CHILD_TYPE (buildable, type);
}
if (GTK_IS_WIDGET (child))
{
gtk_widget_set_parent (GTK_WIDGET (child), GTK_WIDGET (buildable));
}
else if (GTK_IS_EVENT_CONTROLLER (child))
{
gtk_widget_add_controller (GTK_WIDGET (buildable), g_object_ref (GTK_EVENT_CONTROLLER (child)));
}
else
{
g_warning ("Cannot add an object of type %s to a widget of type %s",
g_type_name (G_OBJECT_TYPE (child)), g_type_name (G_OBJECT_TYPE (buildable)));
}
}
static void
gtk_widget_buildable_interface_init (GtkBuildableIface *iface)
{
quark_builder_set_id = g_quark_from_static_string ("gtk-builder-set-id");
iface->set_id = gtk_widget_buildable_set_id;
iface->get_id = gtk_widget_buildable_get_id;
iface->get_internal_child = gtk_widget_buildable_get_internal_child;
iface->parser_finished = gtk_widget_buildable_parser_finished;
iface->custom_tag_start = gtk_widget_buildable_custom_tag_start;
iface->custom_tag_end = gtk_widget_buildable_custom_tag_end;
iface->custom_finished = gtk_widget_buildable_custom_finished;
iface->add_child = gtk_widget_buildable_add_child;
}
static void
gtk_widget_buildable_set_id (GtkBuildable *buildable,
const char *id)
{
g_object_set_qdata_full (G_OBJECT (buildable), quark_builder_set_id,
g_strdup (id), g_free);
}
static const char *
gtk_widget_buildable_get_id (GtkBuildable *buildable)
{
return g_object_get_qdata (G_OBJECT (buildable), quark_builder_set_id);
}
static GObject *
gtk_widget_buildable_get_internal_child (GtkBuildable *buildable,
GtkBuilder *builder,
const char *childname)
{
GtkWidgetClass *class;
GSList *l;
GType internal_child_type = 0;
/* Find a widget type which has declared an automated child as internal by
* the name 'childname', if any.
*/
for (class = GTK_WIDGET_GET_CLASS (buildable);
GTK_IS_WIDGET_CLASS (class);
class = g_type_class_peek_parent (class))
{
GtkWidgetTemplate *template = class->priv->template;
if (!template)
continue;
for (l = template->children; l && internal_child_type == 0; l = l->next)
{
AutomaticChildClass *child_class = l->data;
if (child_class->internal_child && strcmp (childname, child_class->name) == 0)
internal_child_type = G_OBJECT_CLASS_TYPE (class);
}
}
/* Now return the 'internal-child' from the class which declared it, note
* that gtk_widget_get_template_child() an API used to access objects
* which are in the private scope of a given class.
*/
if (internal_child_type != 0)
return gtk_widget_get_template_child (GTK_WIDGET (buildable), internal_child_type, childname);
return NULL;
}
static void
gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
GtkBuilder *builder)
{
}
typedef struct
{
GtkBuilder *builder;
GSList *classes;
} StyleParserData;
static void
style_start_element (GtkBuildableParseContext *context,
const char *element_name,
const char **names,
const char **values,
gpointer user_data,
GError **error)
{
StyleParserData *data = (StyleParserData *)user_data;
if (strcmp (element_name, "class") == 0)
{
const char *name;
if (!_gtk_builder_check_parent (data->builder, context, "style", error))
return;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_STRING, "name", &name,
G_MARKUP_COLLECT_INVALID))
{
_gtk_builder_prefix_error (data->builder, context, error);
return;
}
data->classes = g_slist_prepend (data->classes, g_strdup (name));
}
else if (strcmp (element_name, "style") == 0)
{
if (!_gtk_builder_check_parent (data->builder, context, "object", error))
return;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_INVALID, NULL, NULL,
G_MARKUP_COLLECT_INVALID))
_gtk_builder_prefix_error (data->builder, context, error);
}
else
{
_gtk_builder_error_unhandled_tag (data->builder, context,
"GtkWidget", element_name,
error);
}
}
static const GtkBuildableParser style_parser =
{
style_start_element,
};
typedef struct
{
char *name;
GString *value;
char *context;
gboolean translatable;
} LayoutPropertyInfo;
typedef struct
{
GObject *object;
GtkBuilder *builder;
LayoutPropertyInfo *cur_property;
/* SList<LayoutPropertyInfo> */
GSList *properties;
} LayoutParserData;
static void
layout_property_info_free (gpointer data)
{
LayoutPropertyInfo *pinfo = data;
if (pinfo == NULL)
return;
g_free (pinfo->name);
g_free (pinfo->context);
g_string_free (pinfo->value, TRUE);
g_free (pinfo);
}
static void
layout_start_element (GtkBuildableParseContext *context,
const char *element_name,
const char **names,
const char **values,
gpointer user_data,
GError **error)
{
LayoutParserData *layout_data = user_data;
if (strcmp (element_name, "property") == 0)
{
const char *name = NULL;
const char *ctx = NULL;
gboolean translatable = FALSE;
LayoutPropertyInfo *pinfo;
if (!_gtk_builder_check_parent (layout_data->builder, context, "layout", error))
return;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_STRING, "name", &name,
G_MARKUP_COLLECT_BOOLEAN | G_MARKUP_COLLECT_OPTIONAL, "translatable", &translatable,
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "context", &ctx,
G_MARKUP_COLLECT_INVALID))
{
_gtk_builder_prefix_error (layout_data->builder, context, error);
return;
}
pinfo = g_new0 (LayoutPropertyInfo, 1);
pinfo->name = g_strdup (name);
pinfo->translatable = translatable;
pinfo->context = g_strdup (ctx);
pinfo->value = g_string_new (NULL);
layout_data->cur_property = pinfo;
}
else if (strcmp (element_name, "layout") == 0)
{
if (!_gtk_builder_check_parent (layout_data->builder, context, "object", error))
return;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_INVALID, NULL, NULL,
G_MARKUP_COLLECT_INVALID))
_gtk_builder_prefix_error (layout_data->builder, context, error);
}
else
{
_gtk_builder_error_unhandled_tag (layout_data->builder, context,
"GtkWidget", element_name,
error);
}
}
static void
layout_text (GtkBuildableParseContext *context,
const char *text,
gsize text_len,
gpointer user_data,
GError **error)
{
LayoutParserData *layout_data = user_data;
if (layout_data->cur_property != NULL)
g_string_append_len (layout_data->cur_property->value, text, text_len);
}
static void
layout_end_element (GtkBuildableParseContext *context,
const char *element_name,
gpointer user_data,
GError **error)
{
LayoutParserData *layout_data = user_data;
if (layout_data->cur_property != NULL)
{
LayoutPropertyInfo *pinfo = g_steal_pointer (&layout_data->cur_property);
/* Translate the string, if needed */
if (pinfo->value->len != 0 && pinfo->translatable)
{
const char *translated;
const char *domain;
domain = gtk_builder_get_translation_domain (layout_data->builder);
translated = _gtk_builder_parser_translate (domain, pinfo->context, pinfo->value->str);
g_string_assign (pinfo->value, translated);
}
/* We assign all properties at the end of the `layout` section */
layout_data->properties = g_slist_prepend (layout_data->properties, pinfo);
}
}
static const GtkBuildableParser layout_parser =
{
layout_start_element,
layout_end_element,
layout_text,
};
typedef struct
{
char *name;
GString *value;
char *context;
gboolean translatable;
} AccessibilityAttributeInfo;
typedef struct
{
GObject *object;
GtkBuilder *builder;
AccessibilityAttributeInfo *cur_attribute;
/* SList<AccessibilityAttributeInfo> */
GSList *properties;
GSList *states;
GSList *relations;
} AccessibilityParserData;
static void
accessibility_attribute_info_free (gpointer data)
{
AccessibilityAttributeInfo *pinfo = data;
if (pinfo == NULL)
return;
g_free (pinfo->name);
g_free (pinfo->context);
g_string_free (pinfo->value, TRUE);
g_free (pinfo);
}
static void
accessibility_start_element (GtkBuildableParseContext *context,
const char *element_name,
const char **names,
const char **values,
gpointer user_data,
GError **error)
{
AccessibilityParserData *accessibility_data = user_data;
if (strcmp (element_name, "property") == 0 ||
strcmp (element_name, "relation") == 0 ||
strcmp (element_name, "state") == 0)
{
const char *name = NULL;
const char *ctx = NULL;
gboolean translatable = FALSE;
AccessibilityAttributeInfo *pinfo;
if (!_gtk_builder_check_parent (accessibility_data->builder,
context,
"accessibility",
error))
return;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_STRING, "name", &name,
G_MARKUP_COLLECT_BOOLEAN | G_MARKUP_COLLECT_OPTIONAL, "translatable", &translatable,
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "context", &ctx,
G_MARKUP_COLLECT_INVALID))
{
_gtk_builder_prefix_error (accessibility_data->builder, context, error);
return;
}
pinfo = g_new0 (AccessibilityAttributeInfo, 1);
pinfo->name = g_strdup (name);
pinfo->translatable = translatable;
pinfo->context = g_strdup (ctx);
pinfo->value = g_string_new (NULL);
accessibility_data->cur_attribute = pinfo;
}
else if (strcmp (element_name, "accessibility") == 0)
{
if (!_gtk_builder_check_parent (accessibility_data->builder,
context,
"object",
error))
return;
}
else
{
_gtk_builder_error_unhandled_tag (accessibility_data->builder, context,
"GtkWidget", element_name,
error);
}
}
static void
accessibility_text (GtkBuildableParseContext *context,
const char *text,
gsize text_len,
gpointer user_data,
GError **error)
{
AccessibilityParserData *accessibility_data = user_data;
if (accessibility_data->cur_attribute != NULL)
g_string_append_len (accessibility_data->cur_attribute->value, text, text_len);
}
static void
accessibility_end_element (GtkBuildableParseContext *context,
const char *element_name,
gpointer user_data,
GError **error)
{
AccessibilityParserData *accessibility_data = user_data;
if (accessibility_data->cur_attribute != NULL)
{
AccessibilityAttributeInfo *pinfo = g_steal_pointer (&accessibility_data->cur_attribute);
/* Translate the string, if needed */
if (pinfo->value->len != 0 && pinfo->translatable)
{
const char *translated;
const char *domain;
domain = gtk_builder_get_translation_domain (accessibility_data->builder);
translated = _gtk_builder_parser_translate (domain, pinfo->context, pinfo->value->str);
g_string_assign (pinfo->value, translated);
}
/* We assign all properties at the end of the `accessibility` section */
if (strcmp (element_name, "property") == 0)
accessibility_data->properties = g_slist_prepend (accessibility_data->properties, pinfo);
else if (strcmp (element_name, "relation") == 0)
accessibility_data->relations = g_slist_prepend (accessibility_data->relations, pinfo);
else if (strcmp (element_name, "state") == 0)
accessibility_data->states = g_slist_prepend (accessibility_data->states, pinfo);
else
{
_gtk_builder_error_unhandled_tag (accessibility_data->builder, context,
"GtkWidget", element_name,
error);
accessibility_attribute_info_free (pinfo);
}
}
}
static const GtkBuildableParser accessibility_parser = {
accessibility_start_element,
accessibility_end_element,
accessibility_text,
};
static gboolean
gtk_widget_buildable_custom_tag_start (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
GtkBuildableParser *parser,
gpointer *parser_data)
{
if (strcmp (tagname, "style") == 0)
{
StyleParserData *data;
data = g_slice_new0 (StyleParserData);
data->builder = builder;
*parser = style_parser;
*parser_data = data;
return TRUE;
}
if (strcmp (tagname, "layout") == 0)
{
LayoutParserData *data;
data = g_slice_new0 (LayoutParserData);
data->builder = builder;
data->object = (GObject *) g_object_ref (buildable);
*parser = layout_parser;
*parser_data = data;
return TRUE;
}
if (strcmp (tagname, "accessibility") == 0)
{
AccessibilityParserData *data;
data = g_slice_new0 (AccessibilityParserData);
data->builder = builder;
data->object = (GObject *) g_object_ref (buildable);
*parser = accessibility_parser;
*parser_data = data;
return TRUE;
}
return FALSE;
}
static void
gtk_widget_buildable_custom_tag_end (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer data)
{
}
static void
gtk_widget_buildable_finish_layout_properties (GtkWidget *widget,
GtkWidget *parent,
gpointer data)
{
LayoutParserData *layout_data = data;
GtkLayoutManager *layout_manager;
GtkLayoutChild *layout_child;
GObject *gobject;
GObjectClass *gobject_class;
GSList *layout_properties, *l;
layout_manager = gtk_widget_get_layout_manager (parent);
if (layout_manager == NULL)
return;
layout_child = gtk_layout_manager_get_layout_child (layout_manager, widget);
if (layout_child == NULL)
return;
gobject = G_OBJECT (layout_child);
gobject_class = G_OBJECT_GET_CLASS (layout_child);
layout_properties = g_slist_reverse (layout_data->properties);
layout_data->properties = NULL;
for (l = layout_properties; l != NULL; l = l->next)
{
LayoutPropertyInfo *pinfo = l->data;
GParamSpec *pspec;
GValue value = G_VALUE_INIT;
GError *error = NULL;
pspec = g_object_class_find_property (gobject_class, pinfo->name);
if (pspec == NULL)
{
g_warning ("Unable to find layout property “%s” for children "
"of layout managers of type “%s”",
pinfo->name,
G_OBJECT_TYPE_NAME (layout_manager));
continue;
}
gtk_builder_value_from_string (layout_data->builder,
pspec,
pinfo->value->str,
&value,
&error);
if (error != NULL)
{
g_warning ("Failed to set property “%s.%s” to “%s”: %s",
G_OBJECT_TYPE_NAME (layout_child),
pinfo->name,
pinfo->value->str,
error->message);
g_error_free (error);
continue;
}
g_object_set_property (gobject, pinfo->name, &value);
g_value_unset (&value);
}
g_slist_free_full (layout_properties, layout_property_info_free);
}
static void
gtk_widget_buildable_finish_accessibility_properties (GtkWidget *widget,
gpointer data)
{
AccessibilityParserData *accessibility_data = data;
GSList *attributes, *l;
GtkATContext *context;
context = gtk_accessible_get_at_context (GTK_ACCESSIBLE (widget));
if (context == NULL)
return;
attributes = g_slist_reverse (accessibility_data->properties);
accessibility_data->properties = NULL;
for (l = attributes; l != NULL; l = l->next)
{
AccessibilityAttributeInfo *pinfo = l->data;
int property;
GError *error = NULL;
GtkAccessibleValue *value;
_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_PROPERTY,
pinfo->name,
&property,
&error);
if (error != NULL)
{
g_warning ("Failed to find accessible property “%s”: %s",
pinfo->name,
error->message);
g_error_free (error);
continue;
}
value = gtk_accessible_value_parse_for_property (property,
pinfo->value->str,
pinfo->value->len,
&error);
if (error != NULL)
{
g_warning ("Failed to set accessible property “%s” to “%s”: %s",
pinfo->name,
pinfo->value->str,
error->message);
g_error_free (error);
continue;
}
gtk_at_context_set_accessible_property (context, property, value);
gtk_accessible_value_unref (value);
}
g_slist_free_full (attributes, accessibility_attribute_info_free);
attributes = g_slist_reverse (accessibility_data->relations);
accessibility_data->relations = NULL;
for (l = attributes; l != NULL; l = l->next)
{
AccessibilityAttributeInfo *pinfo = l->data;
int relation;
GError *error = NULL;
GtkAccessibleValue *value;
_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_RELATION,
pinfo->name,
&relation,
&error);
if (error != NULL)
{
g_warning ("Failed to find accessible relation “%s”: %s",
pinfo->name,
error->message);
g_error_free (error);
continue;
}
value = gtk_accessible_value_parse_for_relation (relation,
pinfo->value->str,
pinfo->value->len,
&error);
if (error != NULL)
{
g_warning ("Failed to set accessible relation “%s” to “%s”: %s",
pinfo->name,
pinfo->value->str,
error->message);
g_error_free (error);
continue;
}
if (value == NULL)
{
GObject *obj = gtk_builder_get_object (accessibility_data->builder,
pinfo->value->str);
if (obj == NULL)
{
g_warning ("Failed to find accessible object “%s” for relation “%s”",
pinfo->value->str,
pinfo->name);
continue;
}
/* FIXME: Need to distinguish between refs and refslist types */
value = gtk_reference_list_accessible_value_new (g_list_append (NULL, obj));
}
gtk_at_context_set_accessible_relation (context, relation, value);
gtk_accessible_value_unref (value);
}
g_slist_free_full (attributes, accessibility_attribute_info_free);
attributes = g_slist_reverse (accessibility_data->states);
accessibility_data->states = NULL;
for (l = attributes; l != NULL; l = l->next)
{
AccessibilityAttributeInfo *pinfo = l->data;
int state;
GError *error = NULL;
GtkAccessibleValue *value;
_gtk_builder_enum_from_string (GTK_TYPE_ACCESSIBLE_STATE,
pinfo->name,
&state,
&error);
if (error != NULL)
{
g_warning ("Failed to find accessible state “%s”: %s",
pinfo->name,
error->message);
g_error_free (error);
continue;
}
value = gtk_accessible_value_parse_for_state (state,
pinfo->value->str,
pinfo->value->len,
&error);
if (error != NULL)
{
g_warning ("Failed to set accessible state “%s” to “%s”: %s",
pinfo->name,
pinfo->value->str,
error->message);
g_error_free (error);
continue;
}
gtk_at_context_set_accessible_state (context, state, value);
gtk_accessible_value_unref (value);
}
g_slist_free_full (attributes, accessibility_attribute_info_free);
}
static void
gtk_widget_buildable_custom_finished (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer user_data)
{
if (strcmp (tagname, "style") == 0)
{
StyleParserData *style_data = (StyleParserData *)user_data;
GSList *l;
for (l = style_data->classes; l; l = l->next)
gtk_widget_add_css_class (GTK_WIDGET (buildable), (const char *)l->data);
g_slist_free_full (style_data->classes, g_free);
g_slice_free (StyleParserData, style_data);
}
else if (strcmp (tagname, "layout") == 0)
{
LayoutParserData *layout_data = (LayoutParserData *) user_data;
GtkWidget *parent = _gtk_widget_get_parent (GTK_WIDGET (buildable));
if (parent != NULL)
gtk_widget_buildable_finish_layout_properties (GTK_WIDGET (buildable),
parent,
layout_data);
/* Free the unapplied properties, if any */
g_slist_free_full (layout_data->properties, layout_property_info_free);
g_object_unref (layout_data->object);
g_slice_free (LayoutParserData, layout_data);
}
else if (strcmp (tagname, "accessibility") == 0)
{
AccessibilityParserData *accessibility_data = user_data;
gtk_widget_buildable_finish_accessibility_properties (GTK_WIDGET (buildable),
accessibility_data);
g_slist_free_full (accessibility_data->properties,
accessibility_attribute_info_free);
g_slist_free_full (accessibility_data->relations,
accessibility_attribute_info_free);
g_slist_free_full (accessibility_data->states,
accessibility_attribute_info_free);
g_object_unref (accessibility_data->object);
g_slice_free (AccessibilityParserData, accessibility_data);
}
}
/**
* gtk_widget_get_halign:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:halign property.
*
* For backwards compatibility reasons this method will never return
* %GTK_ALIGN_BASELINE, but instead it will convert it to
* %GTK_ALIGN_FILL. Baselines are not supported for horizontal
* alignment.
*
* Returns: the horizontal alignment of @widget
*/
GtkAlign
gtk_widget_get_halign (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
if (priv->halign == GTK_ALIGN_BASELINE)
return GTK_ALIGN_FILL;
return priv->halign;
}
/**
* gtk_widget_set_halign:
* @widget: a #GtkWidget
* @align: the horizontal alignment
*
* Sets the horizontal alignment of @widget.
* See the #GtkWidget:halign property.
*/
void
gtk_widget_set_halign (GtkWidget *widget,
GtkAlign align)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->halign == align)
return;
priv->halign = align;
gtk_widget_queue_allocate (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_HALIGN]);
}
/**
* gtk_widget_get_valign:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:valign property.
*
* Returns: the vertical alignment of @widget
*/
GtkAlign
gtk_widget_get_valign (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_ALIGN_FILL);
return priv->valign;
}
/**
* gtk_widget_set_valign:
* @widget: a #GtkWidget
* @align: the vertical alignment
*
* Sets the vertical alignment of @widget.
* See the #GtkWidget:valign property.
*/
void
gtk_widget_set_valign (GtkWidget *widget,
GtkAlign align)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->valign == align)
return;
priv->valign = align;
gtk_widget_queue_allocate (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_VALIGN]);
}
/**
* gtk_widget_get_margin_start:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:margin-start property.
*
* Returns: The start margin of @widget
*/
int
gtk_widget_get_margin_start (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->margin.left;
}
/**
* gtk_widget_set_margin_start:
* @widget: a #GtkWidget
* @margin: the start margin
*
* Sets the start margin of @widget.
* See the #GtkWidget:margin-start property.
*/
void
gtk_widget_set_margin_start (GtkWidget *widget,
int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (margin <= G_MAXINT16);
/* We always save margin-start as .left */
if (priv->margin.left == margin)
return;
priv->margin.left = margin;
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_MARGIN_START]);
}
/**
* gtk_widget_get_margin_end:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:margin-end property.
*
* Returns: The end margin of @widget
*/
int
gtk_widget_get_margin_end (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->margin.right;
}
/**
* gtk_widget_set_margin_end:
* @widget: a #GtkWidget
* @margin: the end margin
*
* Sets the end margin of @widget.
* See the #GtkWidget:margin-end property.
*/
void
gtk_widget_set_margin_end (GtkWidget *widget,
int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (margin <= G_MAXINT16);
/* We always set margin-end as .right */
if (priv->margin.right == margin)
return;
priv->margin.right = margin;
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_MARGIN_END]);
}
/**
* gtk_widget_get_margin_top:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:margin-top property.
*
* Returns: The top margin of @widget
*/
int
gtk_widget_get_margin_top (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->margin.top;
}
/**
* gtk_widget_set_margin_top:
* @widget: a #GtkWidget
* @margin: the top margin
*
* Sets the top margin of @widget.
* See the #GtkWidget:margin-top property.
*/
void
gtk_widget_set_margin_top (GtkWidget *widget,
int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (margin <= G_MAXINT16);
if (priv->margin.top == margin)
return;
priv->margin.top = margin;
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_MARGIN_TOP]);
}
/**
* gtk_widget_get_margin_bottom:
* @widget: a #GtkWidget
*
* Gets the value of the #GtkWidget:margin-bottom property.
*
* Returns: The bottom margin of @widget
*/
int
gtk_widget_get_margin_bottom (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->margin.bottom;
}
/**
* gtk_widget_set_margin_bottom:
* @widget: a #GtkWidget
* @margin: the bottom margin
*
* Sets the bottom margin of @widget.
* See the #GtkWidget:margin-bottom property.
*/
void
gtk_widget_set_margin_bottom (GtkWidget *widget,
int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (margin <= G_MAXINT16);
if (priv->margin.bottom == margin)
return;
priv->margin.bottom = margin;
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_MARGIN_BOTTOM]);
}
/**
* gtk_widget_get_clipboard:
* @widget: a #GtkWidget
*
* This is a utility function to get the clipboard object for the
* #GdkDisplay that @widget is using.
*
* Note that this function always works, even when @widget is not
* realized yet.
*
* Returns: (transfer none): the appropriate clipboard object.
**/
GdkClipboard *
gtk_widget_get_clipboard (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return gdk_display_get_clipboard (_gtk_widget_get_display (widget));
}
/**
* gtk_widget_get_primary_clipboard:
* @widget: a #GtkWidget
*
* This is a utility function to get the primary clipboard object
* for the #GdkDisplay that @widget is using.
*
* Note that this function always works, even when @widget is not
* realized yet.
*
* Returns: (transfer none): the appropriate clipboard object.
**/
GdkClipboard *
gtk_widget_get_primary_clipboard (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return gdk_display_get_primary_clipboard (_gtk_widget_get_display (widget));
}
/**
* gtk_widget_list_mnemonic_labels:
* @widget: a #GtkWidget
*
* Returns a newly allocated list of the widgets, normally labels, for
* which this widget is the target of a mnemonic (see for example,
* gtk_label_set_mnemonic_widget()).
* The widgets in the list are not individually referenced. If you
* want to iterate through the list and perform actions involving
* callbacks that might destroy the widgets, you
* must call `g_list_foreach (result,
* (GFunc)g_object_ref, NULL)` first, and then unref all the
* widgets afterwards.
* Returns: (element-type GtkWidget) (transfer container): the list of
* mnemonic labels; free this list
* with g_list_free() when you are done with it.
**/
GList *
gtk_widget_list_mnemonic_labels (GtkWidget *widget)
{
GList *list = NULL;
GSList *l;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
for (l = g_object_get_qdata (G_OBJECT (widget), quark_mnemonic_labels); l; l = l->next)
list = g_list_prepend (list, l->data);
return list;
}
/**
* gtk_widget_add_mnemonic_label:
* @widget: a #GtkWidget
* @label: a #GtkWidget that acts as a mnemonic label for @widget
*
* Adds a widget to the list of mnemonic labels for
* this widget. (See gtk_widget_list_mnemonic_labels()). Note the
* list of mnemonic labels for the widget is cleared when the
* widget is destroyed, so the caller must make sure to update
* its internal state at this point as well, by using a connection
* to the #GtkWidget::destroy signal or a weak notifier.
**/
void
gtk_widget_add_mnemonic_label (GtkWidget *widget,
GtkWidget *label)
{
GSList *old_list, *new_list;
GtkAccessibleRelation relation = GTK_ACCESSIBLE_RELATION_LABELLED_BY;
GValue value = G_VALUE_INIT;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_WIDGET (label));
old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
new_list = g_slist_prepend (old_list, label);
g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
new_list, (GDestroyNotify) g_slist_free);
/* The ATContext takes ownership of the GList returned by list_mnemonic_labels(),
* so we don't need to free it
*/
gtk_accessible_relation_init_value (relation, &value);
g_value_set_pointer (&value, gtk_widget_list_mnemonic_labels (widget));
gtk_accessible_update_relation_value (GTK_ACCESSIBLE (widget), 1, &relation, &value);
g_value_unset (&value);
}
/**
* gtk_widget_remove_mnemonic_label:
* @widget: a #GtkWidget
* @label: a #GtkWidget that was previously set as a mnemonic label for
* @widget with gtk_widget_add_mnemonic_label().
*
* Removes a widget from the list of mnemonic labels for
* this widget. (See gtk_widget_list_mnemonic_labels()). The widget
* must have previously been added to the list with
* gtk_widget_add_mnemonic_label().
**/
void
gtk_widget_remove_mnemonic_label (GtkWidget *widget,
GtkWidget *label)
{
GSList *old_list, *new_list;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_WIDGET (label));
old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels);
new_list = g_slist_remove (old_list, label);
if (new_list)
g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels,
new_list, (GDestroyNotify) g_slist_free);
if (new_list != NULL && new_list->data != NULL)
{
GtkAccessibleRelation relation = GTK_ACCESSIBLE_RELATION_LABELLED_BY;
GValue value = G_VALUE_INIT;
/* The ATContext takes ownership of the GList returned by list_mnemonic_labels(),
* so we don't need to free it
*/
gtk_accessible_relation_init_value (relation, &value);
g_value_set_pointer (&value, gtk_widget_list_mnemonic_labels (widget));
gtk_accessible_update_relation_value (GTK_ACCESSIBLE (widget), 1, &relation, &value);
g_value_unset (&value);
}
else
{
gtk_accessible_reset_relation (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_RELATION_LABELLED_BY);
}
}
/**
* gtk_widget_trigger_tooltip_query:
* @widget: a #GtkWidget
*
* Triggers a tooltip query on the display where the toplevel
* of @widget is located.
*/
void
gtk_widget_trigger_tooltip_query (GtkWidget *widget)
{
gtk_tooltip_trigger_tooltip_query (widget);
}
/**
* gtk_widget_set_tooltip_text:
* @widget: a #GtkWidget
* @text: (nullable): the contents of the tooltip for @widget
*
* Sets @text as the contents of the tooltip.
*
* If @text contains any markup, it will be escaped.
*
* This function will take care of setting #GtkWidget:has-tooltip
* as a side effect, and of the default handler for the
* #GtkWidget::query-tooltip signal.
*
* See also the #GtkWidget:tooltip-text property and
* gtk_tooltip_set_text().
*/
void
gtk_widget_set_tooltip_text (GtkWidget *widget,
const char *text)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GObject *object = G_OBJECT (widget);
char *tooltip_text, *tooltip_markup;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_object_freeze_notify (object);
/* Treat an empty string as a NULL string,
* because an empty string would be useless for a tooltip:
*/
if (text != NULL && *text == '\0')
{
tooltip_text = NULL;
tooltip_markup = NULL;
}
else
{
tooltip_text = g_strdup (text);
tooltip_markup = text != NULL ? g_markup_escape_text (text, -1) : NULL;
}
g_clear_pointer (&priv->tooltip_markup, g_free);
g_clear_pointer (&priv->tooltip_text, g_free);
priv->tooltip_text = tooltip_text;
priv->tooltip_markup = tooltip_markup;
gtk_accessible_update_property (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_PROPERTY_DESCRIPTION, priv->tooltip_text,
-1);
gtk_widget_set_has_tooltip (widget, priv->tooltip_text != NULL);
if (_gtk_widget_get_visible (widget))
gtk_widget_trigger_tooltip_query (widget);
g_object_notify_by_pspec (object, widget_props[PROP_TOOLTIP_TEXT]);
g_object_notify_by_pspec (object, widget_props[PROP_TOOLTIP_MARKUP]);
g_object_notify_by_pspec (object, widget_props[PROP_HAS_TOOLTIP]);
g_object_thaw_notify (object);
}
/**
* gtk_widget_get_tooltip_text:
* @widget: a #GtkWidget
*
* Gets the contents of the tooltip for @widget.
*
* If the @widget's tooltip was set using gtk_widget_set_tooltip_markup(),
* this function will return the escaped text.
*
* Returns: (nullable): the tooltip text
*/
const char *
gtk_widget_get_tooltip_text (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->tooltip_text;
}
/**
* gtk_widget_set_tooltip_markup:
* @widget: a #GtkWidget
* @markup: (nullable): the contents of the tooltip for @widget
*
* Sets @markup as the contents of the tooltip, which is marked up with
* the [Pango text markup language][PangoMarkupFormat].
*
* This function will take care of setting the #GtkWidget:has-tooltip as
* a side effect, and of the default handler for the #GtkWidget::query-tooltip signal.
*
* See also the #GtkWidget:tooltip-markup property and
* gtk_tooltip_set_markup().
*/
void
gtk_widget_set_tooltip_markup (GtkWidget *widget,
const char *markup)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GObject *object = G_OBJECT (widget);
char *tooltip_markup;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_object_freeze_notify (object);
/* Treat an empty string as a NULL string,
* because an empty string would be useless for a tooltip:
*/
if (markup != NULL && *markup == '\0')
tooltip_markup = NULL;
else
tooltip_markup = g_strdup (markup);
g_clear_pointer (&priv->tooltip_text, g_free);
g_clear_pointer (&priv->tooltip_markup, g_free);
priv->tooltip_markup = tooltip_markup;
/* Store the tooltip without markup, as we might end up using
* it for widget descriptions in the accessibility layer
*/
if (priv->tooltip_markup != NULL)
{
pango_parse_markup (priv->tooltip_markup, -1, 0, NULL,
&priv->tooltip_text,
NULL,
NULL);
}
gtk_accessible_update_property (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_PROPERTY_DESCRIPTION, priv->tooltip_text,
-1);
gtk_widget_set_has_tooltip (widget, tooltip_markup != NULL);
if (_gtk_widget_get_visible (widget))
gtk_widget_trigger_tooltip_query (widget);
g_object_notify_by_pspec (object, widget_props[PROP_TOOLTIP_TEXT]);
g_object_notify_by_pspec (object, widget_props[PROP_TOOLTIP_MARKUP]);
g_object_notify_by_pspec (object, widget_props[PROP_HAS_TOOLTIP]);
g_object_thaw_notify (object);
}
/**
* gtk_widget_get_tooltip_markup:
* @widget: a #GtkWidget
*
* Gets the contents of the tooltip for @widget set using
* gtk_widget_set_tooltip_markup().
*
* Returns: (nullable): the tooltip text
*/
const char *
gtk_widget_get_tooltip_markup (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->tooltip_markup;
}
/**
* gtk_widget_set_has_tooltip:
* @widget: a #GtkWidget
* @has_tooltip: whether or not @widget has a tooltip.
*
* Sets the has-tooltip property on @widget to @has_tooltip. See
* #GtkWidget:has-tooltip for more information.
*/
void
gtk_widget_set_has_tooltip (GtkWidget *widget,
gboolean has_tooltip)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
has_tooltip = !!has_tooltip;
if (priv->has_tooltip != has_tooltip)
{
priv->has_tooltip = has_tooltip;
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_HAS_TOOLTIP]);
}
}
/**
* gtk_widget_get_has_tooltip:
* @widget: a #GtkWidget
*
* Returns the current value of the has-tooltip property. See
* #GtkWidget:has-tooltip for more information.
*
* Returns: current value of has-tooltip on @widget.
*/
gboolean
gtk_widget_get_has_tooltip (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
return priv->has_tooltip;
}
/**
* gtk_widget_get_allocation:
* @widget: a #GtkWidget
* @allocation: (out): a pointer to a #GtkAllocation to copy to
*
* Retrieves the widget’s allocation.
*
* Note, when implementing a layout container: a widget’s allocation
* will be its “adjusted” allocation, that is, the widget’s parent
* typically calls gtk_widget_size_allocate() with an allocation,
* and that allocation is then adjusted (to handle margin
* and alignment for example) before assignment to the widget.
* gtk_widget_get_allocation() returns the adjusted allocation that
* was actually assigned to the widget. The adjusted allocation is
* guaranteed to be completely contained within the
* gtk_widget_size_allocate() allocation, however.
*
* So a layout container is guaranteed that its children stay inside
* the assigned bounds, but not that they have exactly the bounds the
* container assigned.
*/
void
gtk_widget_get_allocation (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
const graphene_rect_t *margin_rect;
float dx, dy;
GtkCssBoxes boxes;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (allocation != NULL);
gtk_css_boxes_init (&boxes, widget);
margin_rect = gtk_css_boxes_get_margin_rect (&boxes);
if (gsk_transform_get_category (priv->transform) >= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE)
gsk_transform_to_translate (priv->transform, &dx, &dy);
else
dx = dy = 0;
allocation->x = dx + ceil (margin_rect->origin.x);
allocation->y = dy + ceil (margin_rect->origin.y);
allocation->width = ceil (margin_rect->size.width);
allocation->height = ceil (margin_rect->size.height);
}
/**
* gtk_widget_contains:
* @widget: the widget to query
* @x: X coordinate to test, relative to @widget's origin
* @y: Y coordinate to test, relative to @widget's origin
*
* Tests if the point at (@x, @y) is contained in @widget.
*
* The coordinates for (@x, @y) must be in widget coordinates, so
* (0, 0) is assumed to be the top left of @widget's content area.
*
* Returns: %TRUE if @widget contains (@x, @y).
**/
gboolean
gtk_widget_contains (GtkWidget *widget,
double x,
double y)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (!_gtk_widget_get_mapped (widget))
return FALSE;
return GTK_WIDGET_GET_CLASS (widget)->contains (widget, x, y);
}
/* do the checks for gtk_widget_pick that do not depend on position */
static gboolean
gtk_widget_can_be_picked (GtkWidget *widget,
GtkPickFlags flags)
{
if (!_gtk_widget_get_mapped (widget))
return FALSE;
if (!(flags & GTK_PICK_NON_TARGETABLE) &&
!gtk_widget_get_can_target (widget))
return FALSE;
if (!(flags & GTK_PICK_INSENSITIVE) &&
!_gtk_widget_is_sensitive (widget))
return FALSE;
return TRUE;
}
static GtkWidget *
gtk_widget_do_pick (GtkWidget *widget,
double x,
double y,
GtkPickFlags flags)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkWidget *child;
if (priv->overflow == GTK_OVERFLOW_HIDDEN)
{
GtkCssBoxes boxes;
gtk_css_boxes_init (&boxes, widget);
if (!gsk_rounded_rect_contains_point (gtk_css_boxes_get_padding_box (&boxes),
&GRAPHENE_POINT_INIT (x, y)))
return NULL;
}
for (child = _gtk_widget_get_last_child (widget);
child;
child = _gtk_widget_get_prev_sibling (child))
{
GtkWidgetPrivate *child_priv = gtk_widget_get_instance_private (child);
GtkWidget *picked;
graphene_point3d_t res;
if (!gtk_widget_can_be_picked (child, flags))
continue;
if (GTK_IS_NATIVE (child))
continue;
if (child_priv->transform)
{
if (gsk_transform_get_category (child_priv->transform) >= GSK_TRANSFORM_CATEGORY_2D_AFFINE)
{
graphene_point_t transformed_p;
gsk_transform_transform_point (child_priv->transform,
&(graphene_point_t) { 0, 0 },
&transformed_p);
graphene_point3d_init (&res, x - transformed_p.x, y - transformed_p.y, 0.);
}
else
{
GskTransform *transform;
graphene_matrix_t inv;
graphene_point3d_t p0, p1;
transform = gsk_transform_invert (gsk_transform_ref (child_priv->transform));
if (transform == NULL)
continue;
gsk_transform_to_matrix (transform, &inv);
gsk_transform_unref (transform);
graphene_point3d_init (&p0, x, y, 0);
graphene_point3d_init (&p1, x, y, 1);
graphene_matrix_transform_point3d (&inv, &p0, &p0);
graphene_matrix_transform_point3d (&inv, &p1, &p1);
if (fabs (p0.z - p1.z) < 1.f / 4096)
continue;
graphene_point3d_interpolate (&p0, &p1, p0.z / (p0.z - p1.z), &res);
}
}
else
{
graphene_point3d_init (&res, x, y, 0);
}
picked = gtk_widget_do_pick (child, res.x, res.y, flags);
if (picked)
return picked;
}
if (!GTK_WIDGET_GET_CLASS (widget)->contains (widget, x, y))
return NULL;
return widget;
}
/**
* gtk_widget_pick:
* @widget: the widget to query
* @x: X coordinate to test, relative to @widget's origin
* @y: Y coordinate to test, relative to @widget's origin
* @flags: Flags to influence what is picked
*
* Finds the descendant of @widget (including @widget itself) closest
* to the screen at the point (@x, @y). The point must be given in
* widget coordinates, so (0, 0) is assumed to be the top left of
* @widget's content area.
*
* Usually widgets will return %NULL if the given coordinate is not
* contained in @widget checked via gtk_widget_contains(). Otherwise
* they will recursively try to find a child that does not return %NULL.
* Widgets are however free to customize their picking algorithm.
*
* This function is used on the toplevel to determine the widget below
* the mouse cursor for purposes of hover highlighting and delivering events.
*
* Returns: (nullable) (transfer none): The widget descendant at the given
* coordinate or %NULL if none.
**/
GtkWidget *
gtk_widget_pick (GtkWidget *widget,
double x,
double y,
GtkPickFlags flags)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (!gtk_widget_can_be_picked (widget, flags))
return NULL;
return gtk_widget_do_pick (widget, x, y, flags);
}
/**
* gtk_widget_compute_transform:
* @widget: a #GtkWidget
* @target: the target widget that the matrix will transform to
* @out_transform: (out caller-allocates): location to
* store the final transformation
*
* Computes a matrix suitable to describe a transformation from
* @widget's coordinate system into @target's coordinate system.
*
* Returns: %TRUE if the transform could be computed, %FALSE otherwise.
* The transform can not be computed in certain cases, for example when
* @widget and @target do not share a common ancestor. In that
* case @out_transform gets set to the identity matrix.
*/
gboolean
gtk_widget_compute_transform (GtkWidget *widget,
GtkWidget *target,
graphene_matrix_t *out_transform)
{
GtkWidget *ancestor, *iter;
graphene_matrix_t transform, inverse, tmp;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (target), FALSE);
g_return_val_if_fail (out_transform != NULL, FALSE);
if (widget->priv->root != target->priv->root)
return FALSE;
/* optimization for common case: parent wants coordinates of a direct child */
if (target == widget->priv->parent)
{
gsk_transform_to_matrix (widget->priv->transform, out_transform);
return TRUE;
}
ancestor = gtk_widget_common_ancestor (widget, target);
if (ancestor == NULL)
{
graphene_matrix_init_identity (out_transform);
return FALSE;
}
graphene_matrix_init_identity (&transform);
for (iter = widget; iter != ancestor; iter = iter->priv->parent)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (iter);
gsk_transform_to_matrix (priv->transform, &tmp);
graphene_matrix_multiply (&transform, &tmp, &transform);
}
/* optimization for common case: parent wants coordinates of a non-direct child */
if (ancestor == target)
{
graphene_matrix_init_from_matrix (out_transform, &transform);
return TRUE;
}
graphene_matrix_init_identity (&inverse);
for (iter = target; iter != ancestor; iter = iter->priv->parent)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (iter);
gsk_transform_to_matrix (priv->transform, &tmp);
graphene_matrix_multiply (&inverse, &tmp, &inverse);
}
if (!graphene_matrix_inverse (&inverse, &inverse))
{
graphene_matrix_init_identity (out_transform);
return FALSE;
}
graphene_matrix_multiply (&transform, &inverse, out_transform);
return TRUE;
}
/**
* gtk_widget_compute_bounds:
* @widget: the #GtkWidget to query
* @target: the #GtkWidget
* @out_bounds: (out caller-allocates): the rectangle taking the bounds
*
* Computes the bounds for @widget in the coordinate space of @target.
* FIXME: Explain what "bounds" are.
*
* If the operation is successful, %TRUE is returned. If @widget has no
* bounds or the bounds cannot be expressed in @target's coordinate space
* (for example if both widgets are in different windows), %FALSE is
* returned and @bounds is set to the zero rectangle.
*
* It is valid for @widget and @target to be the same widget.
*
* Returns: %TRUE if the bounds could be computed
**/
gboolean
gtk_widget_compute_bounds (GtkWidget *widget,
GtkWidget *target,
graphene_rect_t *out_bounds)
{
graphene_matrix_t transform;
GtkCssBoxes boxes;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (target), FALSE);
g_return_val_if_fail (out_bounds != NULL, FALSE);
if (!gtk_widget_compute_transform (widget, target, &transform))
{
graphene_rect_init_from_rect (out_bounds, graphene_rect_zero ());
return FALSE;
}
gtk_css_boxes_init (&boxes, widget);
gsk_matrix_transform_bounds (&transform,
gtk_css_boxes_get_border_rect (&boxes),
out_bounds);
return TRUE;
}
/**
* gtk_widget_get_allocated_width:
* @widget: the widget to query
*
* Returns the width that has currently been allocated to @widget.
*
* Returns: the width of the @widget
**/
int
gtk_widget_get_allocated_width (GtkWidget *widget)
{
GtkCssBoxes boxes;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
gtk_css_boxes_init (&boxes, widget);
return gtk_css_boxes_get_margin_rect (&boxes)->size.width;
}
/**
* gtk_widget_get_allocated_height:
* @widget: the widget to query
*
* Returns the height that has currently been allocated to @widget.
*
* Returns: the height of the @widget
**/
int
gtk_widget_get_allocated_height (GtkWidget *widget)
{
GtkCssBoxes boxes;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
gtk_css_boxes_init (&boxes, widget);
return gtk_css_boxes_get_margin_rect (&boxes)->size.height;
}
/**
* gtk_widget_get_allocated_baseline:
* @widget: the widget to query
*
* Returns the baseline that has currently been allocated to @widget.
* This function is intended to be used when implementing handlers
* for the #GtkWidgetClass.snapshot() function, and when allocating child
* widgets in #GtkWidgetClass.size_allocate().
*
* Returns: the baseline of the @widget, or -1 if none
**/
int
gtk_widget_get_allocated_baseline (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkCssStyle *style;
GtkBorder margin, border, padding;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
if (priv->baseline == -1)
return -1;
style = gtk_css_node_get_style (priv->cssnode);
get_box_margin (style, &margin);
get_box_border (style, &border);
get_box_padding (style, &padding);
return priv->baseline - margin.top - border.top - padding.top;
}
/**
* gtk_widget_set_opacity:
* @widget: a #GtkWidget
* @opacity: desired opacity, between 0 and 1
*
* Request the @widget to be rendered partially transparent, with
* opacity 0 being fully transparent and 1 fully opaque. (Opacity
* values are clamped to the [0,1] range).
*
* Opacity works on both toplevel widgets and child widgets, although
* there are some limitations: For toplevel widgets, applying opacity
* depends on the capabilities of the windowing system. On X11, this
* has any effect only on X displays with a compositing manager,
* see gdk_display_is_composited(). On Windows and Wayland it should
* always work, although setting a window’s opacity after the window
* has been shown may cause some flicker.
*
* Note that the opacity is inherited through inclusion — if you set
* a toplevel to be partially translucent, all of its content will
* appear translucent, since it is ultimatively rendered on that
* toplevel. The opacity value itself is not inherited by child
* widgets (since that would make widgets deeper in the hierarchy
* progressively more translucent). As a consequence, #GtkPopovers
* and other #GtkNative widgets with their own surface will use their
* own opacity value, and thus by default appear non-translucent,
* even if they are attached to a toplevel that is translucent.
*/
void
gtk_widget_set_opacity (GtkWidget *widget,
double opacity)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
guint8 alpha;
g_return_if_fail (GTK_IS_WIDGET (widget));
opacity = CLAMP (opacity, 0.0, 1.0);
alpha = round (opacity * 255);
if (alpha == priv->user_alpha)
return;
priv->user_alpha = alpha;
gtk_widget_queue_draw (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_OPACITY]);
}
/**
* gtk_widget_get_opacity:
* @widget: a #GtkWidget
*
* Fetches the requested opacity for this widget.
* See gtk_widget_set_opacity().
*
* Returns: the requested opacity for this widget.
**/
double
gtk_widget_get_opacity (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0.0);
return priv->user_alpha / 255.0;
}
/**
* gtk_widget_set_overflow:
* @widget: a #GtkWidget
* @overflow: desired overflow
*
* Sets how @widget treats content that is drawn outside the widget's content area.
* See the definition of #GtkOverflow for details.
*
* This setting is provided for widget implementations and should not be used by
* application code.
*
* The default value is %GTK_OVERFLOW_VISIBLE.
**/
void
gtk_widget_set_overflow (GtkWidget *widget,
GtkOverflow overflow)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (priv->overflow == overflow)
return;
priv->overflow = overflow;
gtk_widget_queue_draw (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_OVERFLOW]);
}
/**
* gtk_widget_get_overflow:
* @widget: a #GtkWidget
*
* Returns the value set via gtk_widget_set_overflow().
*
* Returns: The widget's overflow.
**/
GtkOverflow
gtk_widget_get_overflow (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_OVERFLOW_VISIBLE);
return priv->overflow;
}
void
gtk_widget_set_has_focus (GtkWidget *widget,
gboolean has_focus)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->has_focus == has_focus)
return;
priv->has_focus = has_focus;
gtk_accessible_platform_changed (GTK_ACCESSIBLE (widget), GTK_ACCESSIBLE_PLATFORM_CHANGE_FOCUSED);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_HAS_FOCUS]);
}
/**
* gtk_widget_in_destruction:
* @widget: a #GtkWidget
*
* Returns whether the widget is currently being destroyed.
* This information can sometimes be used to avoid doing
* unnecessary work.
*
* Returns: %TRUE if @widget is being destroyed
*/
gboolean
gtk_widget_in_destruction (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->in_destruction;
}
gboolean
_gtk_widget_get_alloc_needed (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->alloc_needed;
}
static void
gtk_widget_set_alloc_needed (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->alloc_needed = TRUE;
do
{
if (priv->alloc_needed_on_child)
break;
priv->alloc_needed_on_child = TRUE;
if (!priv->visible)
break;
if (GTK_IS_NATIVE (widget))
gtk_native_queue_relayout (GTK_NATIVE (widget));
if (!priv->parent && GTK_IS_ROOT (widget))
{
break;
}
widget = priv->parent;
if (widget == NULL)
break;
priv = widget->priv;
}
while (TRUE);
}
gboolean
gtk_widget_needs_allocate (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->visible || !priv->child_visible)
return FALSE;
if (priv->resize_needed || priv->alloc_needed || priv->alloc_needed_on_child)
return TRUE;
return FALSE;
}
void
gtk_widget_ensure_allocate (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!gtk_widget_needs_allocate (widget))
return;
gtk_widget_ensure_resize (widget);
/* This code assumes that we only reach here if the previous
* allocation is still valid (ie no resize was queued).
* If that wasn't true, the parent would have taken care of
* things.
*/
if (priv->alloc_needed)
{
gtk_widget_allocate (widget,
priv->allocated_width,
priv->allocated_height,
priv->allocated_size_baseline,
gsk_transform_ref (priv->allocated_transform));
}
else if (priv->alloc_needed_on_child)
{
GtkWidget *child;
priv->alloc_needed_on_child = FALSE;
for (child = _gtk_widget_get_first_child (widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
gtk_widget_ensure_allocate (child);
}
}
}
void
gtk_widget_ensure_resize (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->resize_needed)
return;
priv->resize_needed = FALSE;
_gtk_size_request_cache_clear (&priv->requests);
}
void
_gtk_widget_add_sizegroup (GtkWidget *widget,
gpointer group)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *groups;
groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
groups = g_slist_prepend (groups, group);
g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
priv->have_size_groups = TRUE;
}
void
_gtk_widget_remove_sizegroup (GtkWidget *widget,
gpointer group)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GSList *groups;
groups = g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
groups = g_slist_remove (groups, group);
g_object_set_qdata (G_OBJECT (widget), quark_size_groups, groups);
priv->have_size_groups = groups != NULL;
}
GSList *
_gtk_widget_get_sizegroups (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (priv->have_size_groups)
return g_object_get_qdata (G_OBJECT (widget), quark_size_groups);
return NULL;
}
/**
* gtk_widget_class_set_css_name:
* @widget_class: class to set the name on
* @name: name to use
*
* Sets the name to be used for CSS matching of widgets.
*
* If this function is not called for a given class, the name
* set on the parent class is used. By default, GtkWidget uses
* the name "widget".
*/
void
gtk_widget_class_set_css_name (GtkWidgetClass *widget_class,
const char *name)
{
GtkWidgetClassPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (name != NULL);
priv = widget_class->priv;
priv->css_name = g_quark_from_string (name);
}
/**
* gtk_widget_class_get_css_name:
* @widget_class: class to set the name on
*
* Gets the name used by this class for matching in CSS code. See
* gtk_widget_class_set_css_name() for details.
*
* Returns: the CSS name of the given class
*/
const char *
gtk_widget_class_get_css_name (GtkWidgetClass *widget_class)
{
g_return_val_if_fail (GTK_IS_WIDGET_CLASS (widget_class), NULL);
return g_quark_to_string (widget_class->priv->css_name);
}
void
gtk_widget_css_changed (GtkWidget *widget,
GtkCssStyleChange *change)
{
GTK_WIDGET_GET_CLASS (widget)->css_changed (widget, change);
}
void
gtk_widget_system_setting_changed (GtkWidget *widget,
GtkSystemSetting setting)
{
GTK_WIDGET_GET_CLASS (widget)->system_setting_changed (widget, setting);
}
void
gtk_system_setting_changed (GdkDisplay *display,
GtkSystemSetting setting)
{
GList *list, *toplevels;
toplevels = gtk_window_list_toplevels ();
g_list_foreach (toplevels, (GFunc) g_object_ref, NULL);
for (list = toplevels; list; list = list->next)
{
if (gtk_widget_get_display (list->data) == display)
gtk_widget_system_setting_changed (list->data, setting);
g_object_unref (list->data);
}
g_list_free (toplevels);
}
GtkCssNode *
gtk_widget_get_css_node (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->cssnode;
}
GtkStyleContext *
_gtk_widget_peek_style_context (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->context;
}
/**
* gtk_widget_get_style_context:
* @widget: a #GtkWidget
*
* Returns the style context associated to @widget. The returned object is
* guaranteed to be the same for the lifetime of @widget.
*
* Returns: (transfer none): a #GtkStyleContext. This memory is owned by @widget and
* must not be freed.
**/
GtkStyleContext *
gtk_widget_get_style_context (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (G_UNLIKELY (priv->context == NULL))
{
GdkDisplay *display;
priv->context = gtk_style_context_new_for_node (priv->cssnode);
gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget));
display = _gtk_widget_get_display (widget);
if (display)
gtk_style_context_set_display (priv->context, display);
}
return priv->context;
}
static GtkActionMuxer *
gtk_widget_get_parent_muxer (GtkWidget *widget,
gboolean create)
{
GtkWidget *parent;
if (GTK_IS_WINDOW (widget))
return gtk_application_get_parent_muxer_for_window (GTK_WINDOW (widget));
parent = _gtk_widget_get_parent (widget);
if (parent)
return _gtk_widget_get_action_muxer (parent, create);
return NULL;
}
void
_gtk_widget_update_parent_muxer (GtkWidget *widget)
{
GtkActionMuxer *muxer;
GtkWidget *child;
muxer = (GtkActionMuxer*)g_object_get_qdata (G_OBJECT (widget), quark_action_muxer);
if (muxer == NULL)
return;
gtk_action_muxer_set_parent (muxer,
gtk_widget_get_parent_muxer (widget, FALSE));
for (child = gtk_widget_get_first_child (widget);
child != NULL;
child = gtk_widget_get_next_sibling (child))
_gtk_widget_update_parent_muxer (child);
}
GtkActionMuxer *
_gtk_widget_get_action_muxer (GtkWidget *widget,
gboolean create)
{
GtkActionMuxer *muxer;
GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS (widget);
GtkWidgetClassPrivate *priv = widget_class->priv;
muxer = (GtkActionMuxer*)g_object_get_qdata (G_OBJECT (widget), quark_action_muxer);
if (muxer)
return muxer;
if (create || priv->actions)
{
muxer = gtk_action_muxer_new (widget);
g_object_set_qdata_full (G_OBJECT (widget),
quark_action_muxer,
muxer,
g_object_unref);
_gtk_widget_update_parent_muxer (widget);
return muxer;
}
else
return gtk_widget_get_parent_muxer (widget, FALSE);
}
/**
* gtk_widget_insert_action_group:
* @widget: a #GtkWidget
* @name: the prefix for actions in @group
* @group: (allow-none): a #GActionGroup, or %NULL
*
* Inserts @group into @widget. Children of @widget that implement
* #GtkActionable can then be associated with actions in @group by
* setting their “action-name” to @prefix.`action-name`.
*
* Note that inheritance is defined for individual actions. I.e.
* even if you insert a group with prefix @prefix, actions with
* the same prefix will still be inherited from the parent, unless
* the group contains an action with the same name.
*
* If @group is %NULL, a previously inserted group for @name is
* removed from @widget.
*/
void
gtk_widget_insert_action_group (GtkWidget *widget,
const char *name,
GActionGroup *group)
{
GtkActionMuxer *muxer;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (name != NULL);
muxer = _gtk_widget_get_action_muxer (widget, TRUE);
if (group)
gtk_action_muxer_insert (muxer, name, group);
else
gtk_action_muxer_remove (muxer, name);
}
/****************************************************************
* GtkBuilder automated templates *
****************************************************************/
static AutomaticChildClass *
template_child_class_new (const char *name,
gboolean internal_child,
gssize offset)
{
AutomaticChildClass *child_class = g_slice_new0 (AutomaticChildClass);
child_class->name = g_strdup (name);
child_class->internal_child = internal_child;
child_class->offset = offset;
return child_class;
}
static GHashTable *
get_auto_child_hash (GtkWidget *widget,
GType type,
gboolean create)
{
GHashTable *auto_children;
GHashTable *auto_child_hash;
auto_children = (GHashTable *)g_object_get_qdata (G_OBJECT (widget), quark_auto_children);
if (auto_children == NULL)
{
if (!create)
return NULL;
auto_children = g_hash_table_new_full (g_direct_hash,
NULL,
NULL, (GDestroyNotify)g_hash_table_destroy);
g_object_set_qdata_full (G_OBJECT (widget),
quark_auto_children,
auto_children,
(GDestroyNotify)g_hash_table_destroy);
}
auto_child_hash =
g_hash_table_lookup (auto_children, GSIZE_TO_POINTER (type));
if (!auto_child_hash && create)
{
auto_child_hash = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
(GDestroyNotify)g_object_unref);
g_hash_table_insert (auto_children,
GSIZE_TO_POINTER (type),
auto_child_hash);
}
return auto_child_hash;
}
/**
* gtk_widget_init_template:
* @widget: a #GtkWidget
*
* Creates and initializes child widgets defined in templates. This
* function must be called in the instance initializer for any
* class which assigned itself a template using gtk_widget_class_set_template()
*
* It is important to call this function in the instance initializer
* of a #GtkWidget subclass and not in #GObject.constructed() or
* #GObject.constructor() for two reasons.
*
* One reason is that generally derived widgets will assume that parent
* class composite widgets have been created in their instance
* initializers.
*
* Another reason is that when calling g_object_new() on a widget with
* composite templates, it’s important to build the composite widgets
* before the construct properties are set. Properties passed to g_object_new()
* should take precedence over properties set in the private template XML.
*/
void
gtk_widget_init_template (GtkWidget *widget)
{
GtkWidgetTemplate *template;
GtkBuilder *builder;
GError *error = NULL;
GObject *object;
GSList *l;
GType class_type;
g_return_if_fail (GTK_IS_WIDGET (widget));
object = G_OBJECT (widget);
class_type = G_OBJECT_TYPE (widget);
template = GTK_WIDGET_GET_CLASS (widget)->priv->template;
g_return_if_fail (template != NULL);
builder = gtk_builder_new ();
if (template->scope)
gtk_builder_set_scope (builder, template->scope);
gtk_builder_set_current_object (builder, object);
/* This will build the template XML as children to the widget instance, also it
* will validate that the template is created for the correct GType and assert that
* there is no infinite recursion.
*/
if (!gtk_builder_extend_with_template (builder, object, class_type,
(const char *)g_bytes_get_data (template->data, NULL),
g_bytes_get_size (template->data),
&error))
{
/* This should never happen, if the template XML cannot be built
* then it is a critical programming error.
*/
g_critical ("Error building template class '%s' for an instance of type '%s': %s",
g_type_name (class_type), G_OBJECT_TYPE_NAME (object), error->message);
g_error_free (error);
goto out;
}
/* Build the automatic child data */
for (l = template->children; l; l = l->next)
{
AutomaticChildClass *child_class = l->data;
GHashTable *auto_child_hash;
GObject *child;
/* This will setup the pointer of an automated child, and cause
* it to be available in any GtkBuildable.get_internal_child()
* invocations which may follow by reference in child classes. */
child = gtk_builder_get_object (builder, child_class->name);
if (!child)
{
g_critical ("Unable to retrieve child object '%s' from class "
"template for type '%s' while building a '%s'",
child_class->name, g_type_name (class_type), G_OBJECT_TYPE_NAME (widget));
goto out;
}
/* Insert into the hash so that it can be fetched with
* gtk_widget_get_template_child() and also in automated
* implementations of GtkBuildable.get_internal_child() */
auto_child_hash = get_auto_child_hash (widget, class_type, TRUE);
g_hash_table_insert (auto_child_hash, child_class->name, g_object_ref (child));
if (child_class->offset != 0)
{
gpointer field_p;
/* Assign 'object' to the specified offset in the instance (or private) data */
field_p = G_STRUCT_MEMBER_P (widget, child_class->offset);
(* (gpointer *) field_p) = child;
}
}
out:
g_object_unref (builder);
}
/**
* gtk_widget_class_set_template:
* @widget_class: A #GtkWidgetClass
* @template_bytes: A #GBytes holding the #GtkBuilder XML
*
* This should be called at class initialization time to specify
* the GtkBuilder XML to be used to extend a widget.
*
* For convenience, gtk_widget_class_set_template_from_resource() is also provided.
*
* Note that any class that installs templates must call gtk_widget_init_template()
* in the widget’s instance initializer.
*/
void
gtk_widget_class_set_template (GtkWidgetClass *widget_class,
GBytes *template_bytes)
{
GError *error = NULL;
GBytes *data = NULL;
gconstpointer bytes_data;
gsize bytes_size;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (widget_class->priv->template == NULL);
g_return_if_fail (template_bytes != NULL);
widget_class->priv->template = g_slice_new0 (GtkWidgetTemplate);
bytes_data = g_bytes_get_data (template_bytes, &bytes_size);
if (_gtk_buildable_parser_is_precompiled (bytes_data, bytes_size))
{
widget_class->priv->template->data = g_bytes_ref (template_bytes);
return;
}
data = _gtk_buildable_parser_precompile (bytes_data, bytes_size, &error);
if (data == NULL)
{
g_warning ("Failed to precompile template for class %s: %s", G_OBJECT_CLASS_NAME (widget_class), error->message);
g_error_free (error);
return;
}
widget_class->priv->template->data = data;
}
/**
* gtk_widget_class_set_template_from_resource:
* @widget_class: A #GtkWidgetClass
* @resource_name: The name of the resource to load the template from
*
* A convenience function to call gtk_widget_class_set_template().
*
* Note that any class that installs templates must call gtk_widget_init_template()
* in the widget’s instance initializer.
*/
void
gtk_widget_class_set_template_from_resource (GtkWidgetClass *widget_class,
const char *resource_name)
{
GError *error = NULL;
GBytes *bytes = NULL;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (widget_class->priv->template == NULL);
g_return_if_fail (resource_name && resource_name[0]);
/* This is a hack, because class initializers now access resources
* and GIR/gtk-doc initializes classes without initializing GTK,
* we ensure that our base resources are registered here and
* avoid warnings which building GIRs/documentation.
*/
_gtk_ensure_resources ();
bytes = g_resources_lookup_data (resource_name, 0, &error);
if (!bytes)
{
g_critical ("Unable to load resource for composite template for type '%s': %s",
G_OBJECT_CLASS_NAME (widget_class), error->message);
g_error_free (error);
return;
}
gtk_widget_class_set_template (widget_class, bytes);
g_bytes_unref (bytes);
}
/**
* gtk_widget_class_bind_template_callback_full:
* @widget_class: A #GtkWidgetClass
* @callback_name: The name of the callback as expected in the template XML
* @callback_symbol: (scope async): The callback symbol
*
* Declares a @callback_symbol to handle @callback_name from the template XML
* defined for @widget_type. This function is not supported after
* gtk_widget_class_set_template_scope() has been used on @widget_class.
* See gtk_builder_cscope_add_callback_symbol().
*
* Note that this must be called from a composite widget classes class
* initializer after calling gtk_widget_class_set_template().
*/
void
gtk_widget_class_bind_template_callback_full (GtkWidgetClass *widget_class,
const char *callback_name,
GCallback callback_symbol)
{
GtkWidgetTemplate *template;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (widget_class->priv->template != NULL);
g_return_if_fail (callback_name && callback_name[0]);
g_return_if_fail (callback_symbol != NULL);
template = widget_class->priv->template;
if (template->scope == NULL)
template->scope = gtk_builder_cscope_new ();
if (GTK_IS_BUILDER_CSCOPE (template->scope))
{
gtk_builder_cscope_add_callback_symbol (GTK_BUILDER_CSCOPE (template->scope),
callback_name,
callback_symbol);
}
else
{
g_critical ("Adding a callback to %s, but scope is not a GtkBuilderCScope.", G_OBJECT_CLASS_NAME (widget_class));
}
}
/**
* gtk_widget_class_set_template_scope:
* @widget_class: A #GtkWidgetClass
* @scope: (transfer none): The #GtkBuilderScope to use when loading the class template
*
* For use in language bindings, this will override the default #GtkBuilderScope to be
* used when parsing GtkBuilder XML from this class’s template data.
*
* Note that this must be called from a composite widget classes class
* initializer after calling gtk_widget_class_set_template().
*/
void
gtk_widget_class_set_template_scope (GtkWidgetClass *widget_class,
GtkBuilderScope *scope)
{
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (widget_class->priv->template != NULL);
g_return_if_fail (GTK_IS_BUILDER_SCOPE (scope));
/* Defensive, destroy any previously set data */
g_set_object (&widget_class->priv->template->scope, scope);
}
/**
* gtk_widget_class_bind_template_child_full:
* @widget_class: A #GtkWidgetClass
* @name: The “id” of the child defined in the template XML
* @internal_child: Whether the child should be accessible as an “internal-child”
* when this class is used in GtkBuilder XML
* @struct_offset: The structure offset into the composite widget’s instance public or private structure
* where the automated child pointer should be set, or 0 to not assign the pointer.
*
* Automatically assign an object declared in the class template XML to be set to a location
* on a freshly built instance’s private data, or alternatively accessible via gtk_widget_get_template_child().
*
* The struct can point either into the public instance, then you should use G_STRUCT_OFFSET(WidgetType, member)
* for @struct_offset, or in the private struct, then you should use G_PRIVATE_OFFSET(WidgetType, member).
*
* An explicit strong reference will be held automatically for the duration of your
* instance’s life cycle, it will be released automatically when #GObjectClass.dispose() runs
* on your instance and if a @struct_offset that is != 0 is specified, then the automatic location
* in your instance public or private data will be set to %NULL. You can however access an automated child
* pointer the first time your classes #GObjectClass.dispose() runs, or alternatively in
* #GtkWidgetClass.destroy().
*
* If @internal_child is specified, #GtkBuildableIface.get_internal_child() will be automatically
* implemented by the #GtkWidget class so there is no need to implement it manually.
*
* The wrapper macros gtk_widget_class_bind_template_child(), gtk_widget_class_bind_template_child_internal(),
* gtk_widget_class_bind_template_child_private() and gtk_widget_class_bind_template_child_internal_private()
* might be more convenient to use.
*
* Note that this must be called from a composite widget classes class
* initializer after calling gtk_widget_class_set_template().
*/
void
gtk_widget_class_bind_template_child_full (GtkWidgetClass *widget_class,
const char *name,
gboolean internal_child,
gssize struct_offset)
{
AutomaticChildClass *child_class;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (widget_class->priv->template != NULL);
g_return_if_fail (name && name[0]);
child_class = template_child_class_new (name,
internal_child,
struct_offset);
widget_class->priv->template->children =
g_slist_prepend (widget_class->priv->template->children, child_class);
}
/**
* gtk_widget_get_template_child:
* @widget: A #GtkWidget
* @widget_type: The #GType to get a template child for
* @name: The “id” of the child defined in the template XML
*
* Fetch an object build from the template XML for @widget_type in this @widget instance.
*
* This will only report children which were previously declared with
* gtk_widget_class_bind_template_child_full() or one of its
* variants.
*
* This function is only meant to be called for code which is private to the @widget_type which
* declared the child and is meant for language bindings which cannot easily make use
* of the GObject structure offsets.
*
* Returns: (transfer none): The object built in the template XML with the id @name
*/
GObject *
gtk_widget_get_template_child (GtkWidget *widget,
GType widget_type,
const char *name)
{
GHashTable *auto_child_hash;
GObject *ret = NULL;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
g_return_val_if_fail (g_type_name (widget_type) != NULL, NULL);
g_return_val_if_fail (name && name[0], NULL);
auto_child_hash = get_auto_child_hash (widget, widget_type, FALSE);
if (auto_child_hash)
ret = g_hash_table_lookup (auto_child_hash, name);
return ret;
}
/**
* gtk_widget_activate_action_variant: (rename-to gtk_widget_activate_action)
* @widget: a #GtkWidget
* @name: the name of the action to activate
* @args: (allow-none): parameters to use, or %NULL
*
* Looks up the action in the action groups associated
* with @widget and its ancestors, and activates it.
*
* If the action is in an action group added with
* gtk_widget_insert_action_group(), the @name is
* expected to be prefixed with the prefix that was
* used when the group was inserted.
*
* The arguments must match the actions expected parameter
* type, as returned by g_action_get_parameter_type().
*
* Returns: %TRUE if the action was activated, %FALSE if the action does
* not exist.
*/
gboolean
gtk_widget_activate_action_variant (GtkWidget *widget,
const char *name,
GVariant *args)
{
GtkActionMuxer *muxer;
muxer = _gtk_widget_get_action_muxer (widget, FALSE);
if (muxer == NULL)
return FALSE;
if (!gtk_action_muxer_has_action (muxer, name))
return FALSE;
gtk_action_muxer_activate_action (muxer, name, args);
return TRUE;
}
/**
* gtk_widget_activate_action:
* @widget: a #GtkWidget
* @name: the name of the action to activate
* @format_string: GVariant format string for arguments or %NULL
* for no arguments
* @...: arguments, as given by format string
*
* Looks up the action in the action groups associated
* with @widget and its ancestors, and activates it.
*
* This is a wrapper around gtk_widget_activate_action_variant()
* that constructs the @args variant according to @format_string.
*
* Returns: %TRUE if the action was activated, %FALSE if the action does
* not exist.
*/
gboolean
gtk_widget_activate_action (GtkWidget *widget,
const char *name,
const char *format_string,
...)
{
GVariant *parameters = NULL;
gboolean result;
if (format_string != NULL)
{
va_list args;
va_start (args, format_string);
parameters = g_variant_new_va (format_string, NULL, &args);
va_end (args);
g_variant_ref_sink (parameters);
}
result = gtk_widget_activate_action_variant (widget, name, parameters);
g_clear_pointer (&parameters, g_variant_unref);
return result;
}
/**
* gtk_widget_activate_default:
* @widget: a #GtkWidget
*
* Activate the default.activate action from @widget.
*/
void
gtk_widget_activate_default (GtkWidget *widget)
{
gtk_widget_activate_action (widget, "default.activate", NULL);
}
void
gtk_widget_cancel_event_sequence (GtkWidget *widget,
GtkGesture *gesture,
GdkEventSequence *sequence,
GtkEventSequenceState state)
{
gboolean handled = FALSE;
GtkWidget *event_widget;
gboolean cancel = TRUE;
GdkEvent *event;
handled = _gtk_widget_set_sequence_state_internal (widget, sequence,
state, gesture);
if (!handled || state != GTK_EVENT_SEQUENCE_CLAIMED)
return;
event = _gtk_widget_get_last_event (widget, sequence, &event_widget);
if (!event)
return;
while (event_widget)
{
if (event_widget == widget)
cancel = FALSE;
else if (cancel)
_gtk_widget_cancel_sequence (event_widget, sequence);
else
_gtk_widget_set_sequence_state_internal (event_widget, sequence,
GTK_EVENT_SEQUENCE_DENIED,
NULL);
event_widget = _gtk_widget_get_parent (event_widget);
}
}
/**
* gtk_widget_add_controller:
* @widget: a #GtkWidget
* @controller: (transfer full): a #GtkEventController that hasn't been
* added to a widget yet
*
* Adds @controller to @widget so that it will receive events. You will
* usually want to call this function right after creating any kind of
* #GtkEventController.
**/
void
gtk_widget_add_controller (GtkWidget *widget,
GtkEventController *controller)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
g_return_if_fail (gtk_event_controller_get_widget (controller) == NULL);
GTK_EVENT_CONTROLLER_GET_CLASS (controller)->set_widget (controller, widget);
priv->event_controllers = g_list_prepend (priv->event_controllers, controller);
if (priv->controller_observer)
gtk_list_list_model_item_added_at (priv->controller_observer, 0);
}
/**
* gtk_widget_remove_controller:
* @widget: a #GtkWidget
* @controller: (transfer none): a #GtkEventController
*
* Removes @controller from @widget, so that it doesn't process
* events anymore. It should not be used again.
*
* Widgets will remove all event controllers automatically when they
* are destroyed, there is normally no need to call this function.
**/
void
gtk_widget_remove_controller (GtkWidget *widget,
GtkEventController *controller)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *before, *list;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
g_return_if_fail (gtk_event_controller_get_widget (controller) == widget);
GTK_EVENT_CONTROLLER_GET_CLASS (controller)->unset_widget (controller);
list = g_list_find (priv->event_controllers, controller);
before = list->prev;
priv->event_controllers = g_list_delete_link (priv->event_controllers, list);
g_object_unref (controller);
if (priv->controller_observer)
gtk_list_list_model_item_removed (priv->controller_observer, before);
}
void
gtk_widget_reset_controllers (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GList *l;
/* Reset all controllers */
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
if (controller == NULL)
continue;
gtk_event_controller_reset (controller);
}
}
GtkEventController **
gtk_widget_list_controllers (GtkWidget *widget,
GtkPropagationPhase phase,
guint *out_n_controllers)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GPtrArray *controllers = g_ptr_array_new ();
GList *l;
g_assert (out_n_controllers);
for (l = priv->event_controllers; l; l = l->next)
{
GtkEventController *controller = l->data;
if (gtk_event_controller_get_propagation_phase (controller) == phase)
g_ptr_array_add (controllers, controller);
}
*out_n_controllers = controllers->len;
return (GtkEventController **)g_ptr_array_free (controllers, FALSE);
}
static GskRenderNode *
gtk_widget_create_render_node (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (widget);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkCssBoxes boxes;
GtkCssValue *filter_value;
double css_opacity, opacity;
GtkCssStyle *style;
style = gtk_css_node_get_style (priv->cssnode);
css_opacity = _gtk_css_number_value_get (style->other->opacity, 100);
opacity = CLAMP (css_opacity, 0.0, 1.0) * priv->user_alpha / 255.0;
if (opacity <= 0.0)
return NULL;
gtk_css_boxes_init (&boxes, widget);
gtk_snapshot_push_collect (snapshot);
gtk_snapshot_push_debug (snapshot,
"RenderNode for %s %p",
G_OBJECT_TYPE_NAME (widget), widget);
filter_value = style->other->filter;
gtk_css_filter_value_push_snapshot (filter_value, snapshot);
if (opacity < 1.0)
gtk_snapshot_push_opacity (snapshot, opacity);
gtk_css_style_snapshot_background (&boxes, snapshot);
gtk_css_style_snapshot_border (&boxes, snapshot);
if (priv->overflow == GTK_OVERFLOW_HIDDEN)
{
gtk_snapshot_push_rounded_clip (snapshot, gtk_css_boxes_get_padding_box (&boxes));
klass->snapshot (widget, snapshot);
gtk_snapshot_pop (snapshot);
}
else
{
klass->snapshot (widget, snapshot);
}
gtk_css_style_snapshot_outline (&boxes, snapshot);
if (opacity < 1.0)
gtk_snapshot_pop (snapshot);
gtk_css_filter_value_pop_snapshot (filter_value, snapshot);
gtk_snapshot_pop (snapshot);
return gtk_snapshot_pop_collect (snapshot);
}
static void
gtk_widget_do_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GskRenderNode *render_node;
if (!priv->draw_needed)
return;
g_assert (priv->mapped);
if (_gtk_widget_get_alloc_needed (widget))
{
g_warning ("Trying to snapshot %s %p without a current allocation", gtk_widget_get_name (widget), widget);
return;
}
gtk_widget_push_paintables (widget);
render_node = gtk_widget_create_render_node (widget, snapshot);
/* This can happen when nested drawing happens and a widget contains itself
* or when we replace a clipped area */
g_clear_pointer (&priv->render_node, gsk_render_node_unref);
priv->render_node = render_node;
priv->draw_needed = FALSE;
gtk_widget_pop_paintables (widget);
gtk_widget_update_paintables (widget);
}
void
gtk_widget_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!_gtk_widget_get_mapped (widget))
return;
gtk_widget_do_snapshot (widget, snapshot);
if (priv->render_node)
gtk_snapshot_append_node (snapshot, priv->render_node);
}
void
gtk_widget_render (GtkWidget *widget,
GdkSurface *surface,
const cairo_region_t *region)
{
GtkSnapshot *snapshot;
GskRenderer *renderer;
GskRenderNode *root;
double x, y;
gint64 before_snapshot G_GNUC_UNUSED;
gint64 before_render G_GNUC_UNUSED;
before_snapshot = GDK_PROFILER_CURRENT_TIME;
before_render = 0;
if (!GTK_IS_NATIVE (widget))
return;
renderer = gtk_native_get_renderer (GTK_NATIVE (widget));
if (renderer == NULL)
return;
snapshot = gtk_snapshot_new ();
gtk_native_get_surface_transform (GTK_NATIVE (widget), &x, &y);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (x, y));
gtk_widget_snapshot (widget, snapshot);
root = gtk_snapshot_free_to_node (snapshot);
if (GDK_PROFILER_IS_RUNNING)
{
before_render = GDK_PROFILER_CURRENT_TIME;
gdk_profiler_add_mark (before_snapshot, (before_render - before_snapshot), "widget snapshot", "");
}
if (root != NULL)
{
root = gtk_inspector_prepare_render (widget,
renderer,
surface,
region,
root);
gsk_renderer_render (renderer, root, region);
gsk_render_node_unref (root);
gdk_profiler_end_mark (before_render, "widget render", "");
}
}
static void
gtk_widget_child_observer_destroyed (gpointer widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->children_observer = NULL;
}
/**
* gtk_widget_observe_children:
* @widget: a #GtkWidget
*
* Returns a #GListModel to track the children of @widget.
*
* Calling this function will enable extra internal bookkeeping to track
* children and emit signals on the returned listmodel. It may slow down
* operations a lot.
*
* Applications should try hard to avoid calling this function because of
* the slowdowns.
*
* Returns: (transfer full) (attributes element-type=GtkWidget): a #GListModel
* tracking @widget's children
**/
GListModel *
gtk_widget_observe_children (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (priv->children_observer)
return g_object_ref (G_LIST_MODEL (priv->children_observer));
priv->children_observer = gtk_list_list_model_new ((gpointer) gtk_widget_get_first_child,
(gpointer) gtk_widget_get_next_sibling,
(gpointer) gtk_widget_get_prev_sibling,
(gpointer) gtk_widget_get_last_child,
(gpointer) g_object_ref,
widget,
gtk_widget_child_observer_destroyed);
return G_LIST_MODEL (priv->children_observer);
}
static void
gtk_widget_controller_observer_destroyed (gpointer widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
priv->controller_observer = NULL;
}
static gpointer
gtk_widget_controller_list_get_first (gpointer widget)
{
return GTK_WIDGET (widget)->priv->event_controllers;
}
static gpointer
gtk_widget_controller_list_get_next (gpointer item,
gpointer widget)
{
return g_list_next (item);
}
static gpointer
gtk_widget_controller_list_get_prev (gpointer item,
gpointer widget)
{
return g_list_previous (item);
}
static gpointer
gtk_widget_controller_list_get_item (gpointer item,
gpointer widget)
{
return g_object_ref (((GList *) item)->data);
}
/**
* gtk_widget_observe_controllers:
* @widget: a #GtkWidget
*
* Returns a #GListModel to track the #GtkEventControllers of @widget.
*
* Calling this function will enable extra internal bookkeeping to track
* controllers and emit signals on the returned listmodel. It may slow down
* operations a lot.
*
* Applications should try hard to avoid calling this function because of
* the slowdowns.
*
* Returns: (transfer full) (attributes element-type=GtkEventController): a
* #GListModel tracking @widget's controllers
**/
GListModel *
gtk_widget_observe_controllers (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
if (priv->controller_observer)
return g_object_ref (G_LIST_MODEL (priv->controller_observer));
priv->controller_observer = gtk_list_list_model_new (gtk_widget_controller_list_get_first,
gtk_widget_controller_list_get_next,
gtk_widget_controller_list_get_prev,
NULL,
gtk_widget_controller_list_get_item,
widget,
gtk_widget_controller_observer_destroyed);
return G_LIST_MODEL (priv->controller_observer);
}
/**
* gtk_widget_get_first_child:
* @widget: a #GtkWidget
*
* Returns the widgets first child.
*
* This API is primarily meant for widget implementations.
*
* Returns: (transfer none) (nullable): The widget's first child
*/
GtkWidget *
gtk_widget_get_first_child (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->first_child;
}
/**
* gtk_widget_get_last_child:
* @widget: a #GtkWidget
*
* Returns the widgets last child.
*
* This API is primarily meant for widget implementations.
*
* Returns: (transfer none) (nullable): The widget's last child
*/
GtkWidget *
gtk_widget_get_last_child (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->last_child;
}
/**
* gtk_widget_get_next_sibling:
* @widget: a #GtkWidget
*
* Returns the widgets next sibling.
*
* This API is primarily meant for widget implementations.
*
* Returns: (transfer none) (nullable): The widget's next sibling
*/
GtkWidget *
gtk_widget_get_next_sibling (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->next_sibling;
}
/**
* gtk_widget_get_prev_sibling:
* @widget: a #GtkWidget
*
* Returns the widgets previous sibling.
*
* This API is primarily meant for widget implementations.
*
* Returns: (transfer none) (nullable): The widget's previous sibling
*/
GtkWidget *
gtk_widget_get_prev_sibling (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->prev_sibling;
}
/**
* gtk_widget_insert_after:
* @widget: a #GtkWidget
* @parent: the parent #GtkWidget to insert @widget into
* @previous_sibling: (nullable): the new previous sibling of @widget or %NULL
*
* Inserts @widget into the child widget list of @parent.
*
* It will be placed after @previous_sibling, or at the beginning if
* @previous_sibling is %NULL.
*
* After calling this function, gtk_widget_get_prev_sibling(widget) will
* return @previous_sibling.
*
* If @parent is already set as the parent widget of @widget, this function
* can also be used to reorder @widget in the child widget list of @parent.
*
* This API is primarily meant for widget implementations; if you are
* just using a widget, you *must* use its own API for adding children.
*/
void
gtk_widget_insert_after (GtkWidget *widget,
GtkWidget *parent,
GtkWidget *previous_sibling)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_WIDGET (parent));
g_return_if_fail (previous_sibling == NULL || GTK_IS_WIDGET (previous_sibling));
g_return_if_fail (previous_sibling == NULL || _gtk_widget_get_parent (previous_sibling) == parent);
if (widget == previous_sibling ||
(previous_sibling && _gtk_widget_get_prev_sibling (widget) == previous_sibling))
return;
if (!previous_sibling && _gtk_widget_get_first_child (parent) == widget)
return;
gtk_widget_reposition_after (widget,
parent,
previous_sibling);
}
/**
* gtk_widget_insert_before:
* @widget: a #GtkWidget
* @parent: the parent #GtkWidget to insert @widget into
* @next_sibling: (nullable): the new next sibling of @widget or %NULL
*
* Inserts @widget into the child widget list of @parent.
*
* It will be placed before @next_sibling, or at the end if
* @next_sibling is %NULL.
*
* After calling this function, gtk_widget_get_next_sibling(widget)
* will return @next_sibling.
*
* If @parent is already set as the parent widget of @widget, this function
* can also be used to reorder @widget in the child widget list of @parent.
*
* This API is primarily meant for widget implementations; if you are
* just using a widget, you *must* use its own API for adding children.
*/
void
gtk_widget_insert_before (GtkWidget *widget,
GtkWidget *parent,
GtkWidget *next_sibling)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_WIDGET (parent));
g_return_if_fail (next_sibling == NULL || GTK_IS_WIDGET (next_sibling));
g_return_if_fail (next_sibling == NULL || _gtk_widget_get_parent (next_sibling) == parent);
if (widget == next_sibling ||
(next_sibling && _gtk_widget_get_next_sibling (widget) == next_sibling))
return;
if (!next_sibling && _gtk_widget_get_last_child (parent) == widget)
return;
gtk_widget_reposition_after (widget, parent,
next_sibling ? _gtk_widget_get_prev_sibling (next_sibling) :
_gtk_widget_get_last_child (parent));
}
void
gtk_widget_forall (GtkWidget *widget,
GtkCallback callback,
gpointer user_data)
{
GtkWidget *child;
g_return_if_fail (GTK_IS_WIDGET (widget));
child = _gtk_widget_get_first_child (widget);
while (child)
{
GtkWidget *next = _gtk_widget_get_next_sibling (child);
callback(child, user_data);
child = next;
}
}
/**
* gtk_widget_snapshot_child:
* @widget: a #GtkWidget
* @child: a child of @widget
* @snapshot: #GtkSnapshot as passed to the widget. In particular, no
* calls to gtk_snapshot_translate() or other transform calls should
* have been made.
*
* When a widget receives a call to the snapshot function, it must send
* synthetic #GtkWidgetClass.snapshot() calls to all children. This function
* provides a convenient way of doing this. A widget, when it receives
* a call to its #GtkWidgetClass.snapshot() function, calls
* gtk_widget_snapshot_child() once for each child, passing in
* the @snapshot the widget received.
*
* gtk_widget_snapshot_child() takes care of translating the origin of
* @snapshot, and deciding whether the child needs to be snapshot.
*
* This function does nothing for children that implement #GtkNative.
**/
void
gtk_widget_snapshot_child (GtkWidget *widget,
GtkWidget *child,
GtkSnapshot *snapshot)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (child);
g_return_if_fail (_gtk_widget_get_parent (child) == widget);
g_return_if_fail (snapshot != NULL);
if (!_gtk_widget_get_mapped (child))
return;
if (GTK_IS_NATIVE (child))
return;
gtk_widget_do_snapshot (child, snapshot);
if (!priv->render_node)
return;
if (priv->transform)
{
GskRenderNode *transform_node = gsk_transform_node_new (priv->render_node,
priv->transform);
gtk_snapshot_append_node (snapshot, transform_node);
gsk_render_node_unref (transform_node);
}
else
{
gtk_snapshot_append_node (snapshot, priv->render_node);
}
}
/**
* gtk_widget_set_focus_child:
* @widget: a #GtkWidget
* @child: (nullable): a direct child widget of @widget or %NULL
* to unset the focus child of @widget
*
* Set @child as the current focus child of @widget. The previous
* focus child will be unset.
*
* This function is only suitable for widget implementations.
* If you want a certain widget to get the input focus, call
* gtk_widget_grab_focus() on it.
*/
void
gtk_widget_set_focus_child (GtkWidget *widget,
GtkWidget *child)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (child != NULL)
{
g_return_if_fail (GTK_IS_WIDGET (child));
g_return_if_fail (gtk_widget_get_parent (child) == widget);
}
GTK_WIDGET_GET_CLASS (widget)->set_focus_child (widget, child);
}
static void
gtk_widget_real_set_focus_child (GtkWidget *widget,
GtkWidget *child)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_set_object (&priv->focus_child, child);
}
/**
* gtk_widget_get_focus_child:
* @widget: a #GtkWidget
*
* Returns the current focus child of @widget.
*
* Returns: (nullable) (transfer none): The current focus child of @widget,
* or %NULL in case the focus child is unset.
*/
GtkWidget *
gtk_widget_get_focus_child (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->focus_child;
}
/**
* gtk_widget_set_cursor:
* @widget: a #GtkWidget
* @cursor: (allow-none): the new cursor or %NULL to use the default
* cursor
*
* Sets the cursor to be shown when pointer devices point towards @widget.
*
* If the @cursor is NULL, @widget will use the cursor inherited from the
* parent widget.
**/
void
gtk_widget_set_cursor (GtkWidget *widget,
GdkCursor *cursor)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkRoot *root;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (cursor == NULL || GDK_IS_CURSOR (cursor));
if (!g_set_object (&priv->cursor, cursor))
return;
root = _gtk_widget_get_root (widget);
if (root)
gtk_window_maybe_update_cursor (GTK_WINDOW (root), widget, NULL);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CURSOR]);
}
/**
* gtk_widget_set_cursor_from_name:
* @widget: a #GtkWidget
* @name: (nullable): The name of the cursor or %NULL to use the default
* cursor
*
* Sets a named cursor to be shown when pointer devices point towards @widget.
*
* This is a utility function that creates a cursor via
* gdk_cursor_new_from_name() and then sets it on @widget with
* gtk_widget_set_cursor(). See those 2 functions for details.
*
* On top of that, this function allows @name to be %NULL, which will
* do the same as calling gtk_widget_set_cursor() with a %NULL cursor.
**/
void
gtk_widget_set_cursor_from_name (GtkWidget *widget,
const char *name)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (name)
{
GdkCursor *cursor;
cursor = gdk_cursor_new_from_name (name, NULL);
gtk_widget_set_cursor (widget, cursor);
g_object_unref (cursor);
}
else
{
gtk_widget_set_cursor (widget, NULL);
}
}
/**
* gtk_widget_get_cursor:
* @widget: a #GtkWidget
*
* Queries the cursor set via gtk_widget_set_cursor(). See that function for
* details.
*
* Returns: (nullable) (transfer none): the cursor currently in use or %NULL
* to use the default.
**/
GdkCursor *
gtk_widget_get_cursor (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->cursor;
}
/**
* gtk_widget_set_can_target:
* @widget: a #GtkWidget
* @can_target: whether this widget should be able to receive pointer events
*
* Sets whether @widget can be the target of pointer events.
*/
void
gtk_widget_set_can_target (GtkWidget *widget,
gboolean can_target)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
can_target = !!can_target;
if (priv->can_target == can_target)
return;
priv->can_target = can_target;
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CAN_TARGET]);
}
/**
* gtk_widget_get_can_target:
* @widget: a #GtkWidget
*
* Queries whether @widget can be the target of pointer events.
*
* Returns: %TRUE if @widget can receive pointer events
*/
gboolean
gtk_widget_get_can_target (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
return priv->can_target;
}
/**
* gtk_widget_get_width:
* @widget: a #GtkWidget
*
* Returns the content width of the widget, as passed to its size-allocate implementation.
* This is the size you should be using in GtkWidgetClass.snapshot(). For pointer
* events, see gtk_widget_contains().
*
* Returns: The width of @widget
*/
int
gtk_widget_get_width (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->width;
}
/**
* gtk_widget_get_height:
* @widget: a #GtkWidget
*
* Returns the content height of the widget, as passed to its size-allocate implementation.
* This is the size you should be using in GtkWidgetClass.snapshot(). For pointer
* events, see gtk_widget_contains().
*
* Returns: The height of @widget
*/
int
gtk_widget_get_height (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
return priv->height;
}
/**
* gtk_widget_get_size:
* @widget: a #GtkWidget
* @orientation: the orientation to query
*
* Returns the content width or height of the widget, depending on @orientation.
* This is equivalent to calling gtk_widget_get_width() for %GTK_ORIENTATION_HORIZONTAL
* or gtk_widget_get_height() for %GTK_ORIENTATION_VERTICAL, but can be used when
* writing orientation-independent code, such as when implementing #GtkOrientable
* widgets.
*
* Returns: The size of @widget in @orientation.
*/
int
gtk_widget_get_size (GtkWidget *widget,
GtkOrientation orientation)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
return gtk_widget_get_width (widget);
else
return gtk_widget_get_height (widget);
}
/**
* gtk_widget_class_set_layout_manager_type:
* @widget_class: class to set the layout manager type for
* @type: The object type that implements the #GtkLayoutManager for @widget_class
*
* Sets the type to be used for creating layout managers for widgets of
* @widget_class. The given @type must be a subtype of #GtkLayoutManager.
*
* This function should only be called from class init functions of widgets.
**/
void
gtk_widget_class_set_layout_manager_type (GtkWidgetClass *widget_class,
GType type)
{
GtkWidgetClassPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
g_return_if_fail (g_type_is_a (type, GTK_TYPE_LAYOUT_MANAGER));
priv = widget_class->priv;
priv->layout_manager_type = type;
}
/**
* gtk_widget_class_get_layout_manager_type:
* @widget_class: a #GtkWidgetClass
*
* Retrieves the type of the #GtkLayoutManager used by the #GtkWidget class.
*
* See also: gtk_widget_class_set_layout_manager_type()
*
* Returns: a #GtkLayoutManager subclass, or %G_TYPE_INVALID
*/
GType
gtk_widget_class_get_layout_manager_type (GtkWidgetClass *widget_class)
{
GtkWidgetClassPrivate *priv;
g_return_val_if_fail (GTK_IS_WIDGET_CLASS (widget_class), G_TYPE_INVALID);
priv = widget_class->priv;
return priv->layout_manager_type;
}
/**
* gtk_widget_set_layout_manager:
* @widget: a #GtkWidget
* @layout_manager: (nullable) (transfer full): a #GtkLayoutManager
*
* Sets the layout manager delegate instance that provides an implementation
* for measuring and allocating the children of @widget.
*/
void
gtk_widget_set_layout_manager (GtkWidget *widget,
GtkLayoutManager *layout_manager)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (layout_manager == NULL || GTK_IS_LAYOUT_MANAGER (layout_manager));
g_return_if_fail (layout_manager == NULL || gtk_layout_manager_get_widget (layout_manager) == NULL);
if (priv->layout_manager == layout_manager)
return;
if (priv->layout_manager)
{
gtk_layout_manager_set_widget (priv->layout_manager, NULL);
g_object_unref (priv->layout_manager);
}
priv->layout_manager = layout_manager;
if (priv->layout_manager != NULL)
gtk_layout_manager_set_widget (priv->layout_manager, widget);
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_LAYOUT_MANAGER]);
}
/**
* gtk_widget_get_layout_manager:
* @widget: a #GtkWidget
*
* Retrieves the layout manager set using gtk_widget_set_layout_manager().
*
* Returns: (transfer none) (nullable): a #GtkLayoutManager
*/
GtkLayoutManager *
gtk_widget_get_layout_manager (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
return priv->layout_manager;
}
/**
* gtk_widget_should_layout:
* @widget: a widget
*
* Returns whether @widget should contribute to
* the measuring and allocation of its parent.
* This is %FALSE for invisible children, but also
* for children that have their own surface.
*
* Returns: %TRUE if child should be included in
* measuring and allocating
*/
gboolean
gtk_widget_should_layout (GtkWidget *widget)
{
if (!_gtk_widget_get_visible (widget))
return FALSE;
if (GTK_IS_NATIVE (widget))
return FALSE;
return TRUE;
}
static void
gtk_widget_class_add_action (GtkWidgetClass *widget_class,
GtkWidgetAction *action)
{
GtkWidgetClassPrivate *priv = widget_class->priv;
GTK_NOTE(ACTIONS, g_message ("%sClass: Adding %s action\n",
g_type_name (G_TYPE_FROM_CLASS (widget_class)),
action->name));
action->next = priv->actions;
priv->actions = action;
}
/**
* gtk_widget_class_install_action:
* @widget_class: a #GtkWidgetClass
* @action_name: a prefixed action name, such as "clipboard.paste"
* @parameter_type: (nullable): the parameter type, or %NULL
* @activate: (scope call): callback to use when the action is activated
*
* This should be called at class initialization time to specify
* actions to be added for all instances of this class.
*
* Actions installed by this function are stateless. The only state
* they have is whether they are enabled or not.
*/
void
gtk_widget_class_install_action (GtkWidgetClass *widget_class,
const char *action_name,
const char *parameter_type,
GtkWidgetActionActivateFunc activate)
{
GtkWidgetAction *action;
action = g_new0 (GtkWidgetAction, 1);
action->owner = G_TYPE_FROM_CLASS (widget_class);
action->name = g_strdup (action_name);
if (parameter_type)
action->parameter_type = g_variant_type_new (parameter_type);
else
action->parameter_type = NULL;
action->activate = activate;
gtk_widget_class_add_action (widget_class, action);
}
static const GVariantType *
determine_type (GParamSpec *pspec)
{
if (G_TYPE_IS_ENUM (pspec->value_type))
return G_VARIANT_TYPE_STRING;
switch (pspec->value_type)
{
case G_TYPE_BOOLEAN:
return G_VARIANT_TYPE_BOOLEAN;
case G_TYPE_INT:
return G_VARIANT_TYPE_INT32;
case G_TYPE_UINT:
return G_VARIANT_TYPE_UINT32;
case G_TYPE_DOUBLE:
case G_TYPE_FLOAT:
return G_VARIANT_TYPE_DOUBLE;
case G_TYPE_STRING:
return G_VARIANT_TYPE_STRING;
default:
g_critical ("Unable to use gtk_widget_class_install_property_action with property '%s:%s' of type '%s'",
g_type_name (pspec->owner_type), pspec->name, g_type_name (pspec->value_type));
return NULL;
}
}
/**
* gtk_widget_class_install_property_action:
* @widget_class: a #GtkWidgetClass
* @action_name: name of the action
* @property_name: name of the property in instances of @widget_class
* or any parent class.
*
* Installs an action called @action_name on @widget_class and binds its
* state to the value of the @property_name property.
*
* This function will perform a few santity checks on the property selected
* via @property_name. Namely, the property must exist, must be readable,
* writable and must not be construct-only. There are also restrictions
* on the type of the given property, it must be boolean, int, unsigned int,
* double or string. If any of these conditions are not met, a critical
* warning will be printed and no action will be added.
*
* The state type of the action matches the property type.
*
* If the property is boolean, the action will have no parameter and
* toggle the property value. Otherwise, the action will have a parameter
* of the same type as the property.
*/
void
gtk_widget_class_install_property_action (GtkWidgetClass *widget_class,
const char *action_name,
const char *property_name)
{
GParamSpec *pspec;
GtkWidgetAction *action;
const GVariantType *state_type;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
pspec = g_object_class_find_property (G_OBJECT_CLASS (widget_class), property_name);
if (pspec == NULL)
{
g_critical ("Attempted to use non-existent property '%s:%s' for gtk_widget_class_install_property_action",
g_type_name (G_TYPE_FROM_CLASS (widget_class)), property_name);
return;
}
if (~pspec->flags & G_PARAM_READABLE || ~pspec->flags & G_PARAM_WRITABLE || pspec->flags & G_PARAM_CONSTRUCT_ONLY)
{
g_critical ("Property '%s:%s' used with gtk_widget_class_install_property_action must be readable, writable, and not construct-only",
g_type_name (G_TYPE_FROM_CLASS (widget_class)), property_name);
return;
}
state_type = determine_type (pspec);
if (!state_type)
return;
action = g_new0 (GtkWidgetAction, 1);
action->owner = G_TYPE_FROM_CLASS (widget_class);
action->name = g_strdup (action_name);
action->pspec = pspec;
action->state_type = state_type;
if (action->pspec->value_type == G_TYPE_BOOLEAN)
action->parameter_type = NULL;
else
action->parameter_type = action->state_type;
action->activate = NULL;
gtk_widget_class_add_action (widget_class, action);
}
/**
* gtk_widget_action_set_enabled:
* @widget: a #GtkWidget
* @action_name: action name, such as "clipboard.paste"
* @enabled: whether the action is now enabled
*
* Enable or disable an action installed with
* gtk_widget_class_install_action().
*/
void
gtk_widget_action_set_enabled (GtkWidget *widget,
const char *action_name,
gboolean enabled)
{
GtkActionMuxer *muxer;
g_return_if_fail (GTK_IS_WIDGET (widget));
muxer = _gtk_widget_get_action_muxer (widget, TRUE);
gtk_action_muxer_action_enabled_changed (muxer, action_name, enabled);
}
/**
* gtk_widget_class_query_action:
* @widget_class: a #GtkWidgetClass
* @index_: position of the action to query
* @owner: (out): return location for the type where the action was defined
* @action_name: (out): return location for the action name
* @parameter_type: (out): return location for the parameter type
* @property_name: (out): return location for the property name
*
* Queries the actions that have been installed for
* a widget class using gtk_widget_class_install_action()
* during class initialization.
*
* Note that this function will also return actions defined
* by parent classes. You can identify those by looking
* at @owner.
*
* Returns: %TRUE if the action was found,
* %FALSE if @index_ is out of range
*/
gboolean
gtk_widget_class_query_action (GtkWidgetClass *widget_class,
guint index_,
GType *owner,
const char **action_name,
const GVariantType **parameter_type,
const char **property_name)
{
GtkWidgetClassPrivate *priv = widget_class->priv;
GtkWidgetAction *action = priv->actions;
for (; index_ > 0 && action != NULL; index_--)
action = action->next;
if (action != NULL && index_ == 0)
{
*owner = action->owner;
*action_name = action->name;
*parameter_type = action->parameter_type;
if (action->pspec)
*property_name = action->pspec->name;
else
*property_name = NULL;
return TRUE;
}
return FALSE;
}
/**
* gtk_widget_get_css_name:
* @self: a #GtkWidget
*
* Returns the CSS name that is used for @self.
*
* Returns: (transfer none): the CSS name
**/
const char *
gtk_widget_get_css_name (GtkWidget *self)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (self);
g_return_val_if_fail (GTK_IS_WIDGET (self), NULL);
return g_quark_to_string (gtk_css_node_get_name (priv->cssnode));
}
/**
* gtk_widget_add_css_class:
* @widget: a #GtkWidget
* @css_class: The style class to add to @widget, without
* the leading '.' used for notation of style classes
*
* Adds @css_class to @widget. After calling this function, @widget's
* style will match for @css_class, after the CSS matching rules.
*/
void
gtk_widget_add_css_class (GtkWidget *widget,
const char *css_class)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (css_class != NULL);
g_return_if_fail (css_class[0] != '\0');
g_return_if_fail (css_class[0] != '.');
gtk_css_node_add_class (priv->cssnode, g_quark_from_string (css_class));
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CSS_CLASSES]);
}
/**
* gtk_widget_remove_css_class:
* @widget: a #GtkWidget
* @css_class: The style class to remove from @widget, without
* the leading '.' used for notation of style classes
*
* Removes @css_class from @widget. After this, the style of @widget
* will stop matching for @css_class.
*/
void
gtk_widget_remove_css_class (GtkWidget *widget,
const char *css_class)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GQuark class_quark;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (css_class != NULL);
g_return_if_fail (css_class[0] != '\0');
g_return_if_fail (css_class[0] != '.');
class_quark = g_quark_try_string (css_class);
if (!class_quark)
return;
gtk_css_node_remove_class (priv->cssnode, class_quark);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CSS_CLASSES]);
}
/**
* gtk_widget_has_css_class:
* @widget: a #GtkWidget
* @css_class: A CSS style class, without the leading '.'
* used for notation of style classes
*
* Returns whether @css_class is currently applied to @widget.
*
* Returns: %TRUE if @css_class is currently applied to @widget,
* %FALSE otherwise.
*/
gboolean
gtk_widget_has_css_class (GtkWidget *widget,
const char *css_class)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GQuark class_quark;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (css_class != NULL, FALSE);
g_return_val_if_fail (css_class[0] != '\0', FALSE);
g_return_val_if_fail (css_class[0] != '.', FALSE);
class_quark = g_quark_try_string (css_class);
if (!class_quark)
return FALSE;
return gtk_css_node_has_class (priv->cssnode, class_quark);
}
/**
* gtk_widget_get_css_classes:
* @widget: a #GtkWidget
*
* Returns the list of css classes applied to @widget.
*
* Returns: (transfer full): a %NULL-terminated list of
* css classes currently applied to @widget. The returned
* list can be freed using g_strfreev().
*/
char **
gtk_widget_get_css_classes (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
const GQuark *classes;
guint n_classes;
char **strv;
guint i;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
classes = gtk_css_node_list_classes (priv->cssnode, &n_classes);
strv = g_new (char *, n_classes + 1);
for (i = 0; i < n_classes; i++)
strv[i] = g_strdup (g_quark_to_string (classes[i]));
strv[n_classes] = NULL;
return strv;
}
/**
* gtk_widget_set_css_classes:
* @widget: a #GtkWidget
* @classes: (transfer none) (array zero-terminated=1): %NULL-terminated list
* of css classes to apply to @widget.
*
* Will clear all css classes applied to @widget
* and replace them with @classes.
*/
void
gtk_widget_set_css_classes (GtkWidget *widget,
const char **classes)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_css_node_set_classes (priv->cssnode, classes);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_CSS_CLASSES]);
}
/*< private >
* gtk_widget_update_orientation:
* @widget: a #GtkWidget implementing #GtkOrientable
* @orientation: the orientation
*
* Update the internal state associated to the given @orientation of a
* #GtkWidget.
*/
void
gtk_widget_update_orientation (GtkWidget *widget,
GtkOrientation orientation)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gtk_widget_add_css_class (widget, "horizontal");
gtk_widget_remove_css_class (widget, "vertical");
}
else
{
gtk_widget_add_css_class (widget, "vertical");
gtk_widget_remove_css_class (widget, "horizontal");
}
gtk_accessible_update_property (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_PROPERTY_ORIENTATION, orientation,
-1);
}
/**
* gtk_widget_class_set_accessible_role:
* @widget_class: a #GtkWidgetClass
* @accessible_role: the #GtkAccessibleRole used by the @widget_class
*
* Sets the accessible role used by the given #GtkWidget class.
*
* Different accessible roles have different states, and are rendered
* differently by assistive technologies.
*/
void
gtk_widget_class_set_accessible_role (GtkWidgetClass *widget_class,
GtkAccessibleRole accessible_role)
{
GtkWidgetClassPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
priv = widget_class->priv;
priv->accessible_role = accessible_role;
}
/**
* gtk_widget_class_get_accessible_role:
* @widget_class: a #GtkWidgetClass
*
* Retrieves the accessible role used by the given #GtkWidget class.
*
* Different accessible roles have different states, and are rendered
* differently by assistive technologies.
*
* See also: gtk_accessible_get_accessible_role()
*
* Returns: the accessible role for the widget class
*/
GtkAccessibleRole
gtk_widget_class_get_accessible_role (GtkWidgetClass *widget_class)
{
GtkWidgetClassPrivate *priv;
g_return_val_if_fail (GTK_IS_WIDGET_CLASS (widget_class), GTK_ACCESSIBLE_ROLE_WIDGET);
priv = widget_class->priv;
return priv->accessible_role;
}
void
gtk_widget_set_active_state (GtkWidget *widget,
gboolean active)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (active)
{
priv->n_active++;
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_ACTIVE, FALSE);
}
else
{
if (priv->n_active == 0)
{
g_warning ("Broken accounting of active state for widget %p(%s)",
widget, G_OBJECT_TYPE_NAME (widget));
}
else
priv->n_active--;
if (priv->n_active == 0)
gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_ACTIVE);
}
}
Reference in New Issue View Git Blame Copy Permalink