AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
5eee1dfcd1
gtk2/gtk/gtkwidgetprivate.h

487 lines
18 KiB
C
Raw Normal View History

Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
/* 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
Port gtk_draw_insertion_cursor to GtkStyleContext
2011-01-24 05:24:12 +00:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
*/
/*
* 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/.
*/
#ifndef __GTK_WIDGET_PRIVATE_H__
#define __GTK_WIDGET_PRIVATE_H__
widget: Add _gtk_widget_invalidate_style_context() This is supposed to replace gtk_widget_reset_style().
2012-03-20 14:40:53 +00:00
#include "gtkwidget.h"
a11y: Don't include gtk.h Also add missing includes and sort them for all the widgets that relied on that before.
2018-02-08 13:39:45 +00:00
#include "gtkactionmuxerprivate.h"
Have GtkWidget implement GtkAccessible Each widget type has an accessible role associated to its class, as roles cannot change during the life time of a widget instance. Each widget is also responsible for creating an ATContext, to proxy state changes to the underlying accessibility infrastructure.
2020-07-08 15:58:11 +00:00
#include "gtkatcontextprivate.h"
a11y: Don't include gtk.h Also add missing includes and sort them for all the widgets that relied on that before.
2018-02-08 13:39:45 +00:00
#include "gtkcsstypesprivate.h"
Keep more event controller api private We don't want to expose the GtkCrossingData struct, and manually feeding events to event controllers is not something we want to encourage, going forward.
2020-02-20 22:22:03 +00:00
#include "gtkeventcontrollerprivate.h"
widget: Add gtk_widget_observe_children() This creates a listmodel that tracks a widget's children. Doing so turns adding/removing children from O(1) to O(N) though, so use with caution.
2018-08-27 17:50:01 +00:00
#include "gtklistlistmodelprivate.h"
root: Add GtkRoot:get_display vfunc And use it.
2018-07-29 02:11:14 +00:00
#include "gtkrootprivate.h"
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
#include "gtksizerequestcacheprivate.h"
widget: Add static inline version of gtk_widget_display() Due to the few type checks in gtk_widget_get_display(), it was the slowest part of a call to gtk_widget_query_size_for_orientation if the in case of a cache hit.
2018-04-21 15:03:31 +00:00
#include "gtkwindowprivate.h"
widget: Remove controller sequence-state-changed signal connection We can avoid a signal connection per event controller (and the EventControllerData struct) since every event controller knows the widget it's attached to.
2018-05-14 17:03:17 +00:00
#include "gtkgesture.h"
widget: Add _gtk_widget_invalidate_style_context() This is supposed to replace gtk_widget_reset_style().
2012-03-20 14:40:53 +00:00
widget: Store category of widget transform And pass that category through to the transform node that we create for it.
2019-02-19 07:24:59 +00:00
#include "gsk/gskrendernodeprivate.h"
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
G_BEGIN_DECLS
widget: Add surface relative transform changed callback Added two new private GtkWidget API: * gtk_widget_add_surface_transform_changed_callback() * gtk_widget_remove_surface_transform_changed_callback() The intention is to let the user know when a widget transform relative to the surface changes. It works by calculating the surface relative transform during allocation, and notifying the callbacks if it changed since last time. Each widget adds itself as a listener to its parent widget, thus will be triggered if a parents surface relative transform changes.
2019-04-18 16:55:13 +00:00
typedef gboolean (*GtkSurfaceTransformChangedCallback) (GtkWidget *widget,
const graphene_matrix_t *surface_transform,
gpointer user_data);
Add a focus-within state This is used for widgets that contain the focus widget, reserving the focused state for the focus location itself. This aligns our focus state handling with https://www.w3.org/TR/selectors-4/
2020-04-16 05:36:13 +00:00
#define GTK_STATE_FLAGS_BITS 15
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
widget: Move surface relative transform fields into its own struct The purpose being to reduce the size of GtkWidgetPrivate. What is left is a pointer to the allocated struct.
2019-04-25 13:39:06 +00:00
typedef struct _GtkWidgetSurfaceTransformData
{
GtkWidget *tracked_parent;
guint parent_surface_transform_changed_id;
gboolean cached_surface_transform_valid;
gtk: Improve struct packing in places Plug some holes in our structs by rearranging a few fields. This is was done looking at pahole output.
2020-07-25 02:57:34 +00:00
widget: Move surface relative transform fields into its own struct The purpose being to reduce the size of GtkWidgetPrivate. What is left is a pointer to the allocated struct.
2019-04-25 13:39:06 +00:00
graphene_matrix_t cached_surface_transform;
gtk: Improve struct packing in places Plug some holes in our structs by rearranging a few fields. This is was done looking at pahole output.
2020-07-25 02:57:34 +00:00
GList *callbacks;
widget: Move surface relative transform fields into its own struct The purpose being to reduce the size of GtkWidgetPrivate. What is left is a pointer to the allocated struct.
2019-04-25 13:39:06 +00:00
} GtkWidgetSurfaceTransformData;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
struct _GtkWidgetPrivate
{
/* The state of the widget. Needs to be able to hold all GtkStateFlags bits
* (defined in "gtkenums.h").
*/
guint state_flags : GTK_STATE_FLAGS_BITS;
guint direction : 2;
guint in_destruction : 1;
guint realized : 1;
guint mapped : 1;
guint visible : 1;
guint sensitive : 1;
guint can_focus : 1;
widget: Add a :focusable property Add back a property that determines whether an individual widget will accept focus or not. :can-focus prevents the focus from ever entering the entire widget hierarchy below a widget, and :focusable just determines if grabbing the focus to the widget itself will succeed. See #2686
2020-05-05 18:57:21 +00:00
guint focusable : 1;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
guint has_focus : 1;
widget: Add :focus-on-click property There are currently three widget that implement such a property, and there are other widgets for which the behavior can make sense. It seems like a good time to add the property to GtkWidget itself so subclasses can choose to respect it without adding their own property. https://bugzilla.gnome.org/show_bug.cgi?id=757269
2015-10-23 16:07:41 +00:00
guint focus_on_click : 1;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
guint has_default : 1;
guint receives_default : 1;
guint has_grab : 1;
guint child_visible : 1;
Rename things Rename the can-pick property to can-target, and redo the pick flags with more descriptive names.
2019-04-07 21:36:40 +00:00
guint can_target : 1;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* Queue-resize related flags */
widget: Add a function that does actual resize It's just shuffling code around.
2015-09-27 10:29:05 +00:00
guint resize_needed : 1; /* queue_resize() has been called but no get_preferred_size() yet */
widget: Track if a child needs an allocation This is not used so far.
2015-09-29 19:04:07 +00:00
guint alloc_needed : 1; /* this widget needs a size_allocate() call */
guint alloc_needed_on_child : 1; /* 0 or more children - or this widget - need a size_allocate() call */
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
widget: Cache the render node This requires a bunch of refactorings: 1. Don't pass the current clip region to gtk_widget_snapshot() so we don't create full widget contents 3. Have a widget->priv->draw_needed that we invalidate on every queue_draw() call and set on every snapshot() 2. In queue_draw(), walk the widget chain to invalidate the render nodes of all parents
2018-03-20 17:55:33 +00:00
/* Queue-draw related flags */
guint draw_needed : 1;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* Expand-related flags */
guint need_compute_expand : 1; /* Need to recompute computed_[hv]_expand */
guint computed_hexpand : 1; /* computed results (composite of child flags) */
guint computed_vexpand : 1;
guint hexpand : 1; /* application-forced expand */
guint vexpand : 1;
guint hexpand_set : 1; /* whether to use application-forced */
guint vexpand_set : 1; /* instead of computing from children */
Stop storing has-tooltip in qdata This is queried quite a bit, and we have room for an extra bit in GtkWidgetPrivate.
2016-05-06 13:38:18 +00:00
guint has_tooltip : 1;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* SizeGroup related flags */
guint have_size_groups : 1;
Drop GtkWidgetAuxInfo Merge it into GtkWidgetPrivate. In my measurements, about half of all widgets have a non-default auxinfo struct, and we use this information in size allocation, so it is nice to avoid the gdata overhead.
2015-09-13 03:56:39 +00:00
/* Alignment */
guint halign : 4;
guint valign : 4;
gtk: Improve struct packing in places Plug some holes in our structs by rearranging a few fields. This is was done looking at pahole output.
2020-07-25 02:57:34 +00:00
guint user_alpha : 8;
widget: Add gtk_widget_set_overflow() This adds a simple abilities for widget implementations to clip their content. See future commits for users of this.
2019-02-08 17:02:40 +00:00
GtkOverflow overflow;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
Drop GtkWidgetAuxInfo Merge it into GtkWidgetPrivate. In my measurements, about half of all widgets have a non-default auxinfo struct, and we use this information in size allocation, so it is nice to avoid the gdata overhead.
2015-09-13 03:56:39 +00:00
#ifdef G_ENABLE_CONSISTENCY_CHECKS
/* Number of gtk_widget_push_verify_invariants () */
guint8 verifying_invariants_count;
#endif
gtk/main: Stack ::active calls We may have the situation of multiple touchpoints in the same widget, or combinations with other devices. Stack those ::active states are preserved on widgets on all but the last pointer/touch going away.
2020-11-12 23:23:52 +00:00
guint8 n_active;
widget: Rename width and height member to {width,height}_request Because that's much closer to the meaning of those values.
2018-07-21 10:28:14 +00:00
int width_request;
int height_request;
Drop GtkWidgetAuxInfo Merge it into GtkWidgetPrivate. In my measurements, about half of all widgets have a non-default auxinfo struct, and we use this information in size allocation, so it is nice to avoid the gdata overhead.
2015-09-13 03:56:39 +00:00
/* Animations and other things to update on clock ticks */
guint clock_tick_id;
GList *tick_callbacks;
gtk: Improve struct packing in places Plug some holes in our structs by rearranging a few fields. This is was done looking at pahole output.
2020-07-25 02:57:34 +00:00
void (* resize_func) (GtkWidget *);
GtkBorder margin;
widget: Add surface relative transform changed callback Added two new private GtkWidget API: * gtk_widget_add_surface_transform_changed_callback() * gtk_widget_remove_surface_transform_changed_callback() The intention is to let the user know when a widget transform relative to the surface changes. It works by calculating the surface relative transform during allocation, and notifying the callbacks if it changed since last time. Each widget adds itself as a listener to its parent widget, thus will be triggered if a parents surface relative transform changes.
2019-04-18 16:55:13 +00:00
/* Surface relative transform updates callbacks */
widget: Move surface relative transform fields into its own struct The purpose being to reduce the size of GtkWidgetPrivate. What is left is a pointer to the allocated struct.
2019-04-25 13:39:06 +00:00
GtkWidgetSurfaceTransformData *surface_transform_data;
widget: Add surface relative transform changed callback Added two new private GtkWidget API: * gtk_widget_add_surface_transform_changed_callback() * gtk_widget_remove_surface_transform_changed_callback() The intention is to let the user know when a widget transform relative to the surface changes. It works by calculating the surface relative transform during allocation, and notifying the callbacks if it changed since last time. Each widget adds itself as a listener to its parent widget, thus will be triggered if a parents surface relative transform changes.
2019-04-18 16:55:13 +00:00
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* The widget's name. If the widget does not have a name
* (the name is NULL), then its name (as returned by
* "gtk_widget_get_name") is its class's name.
* Among other things, the widget name is used to determine
* the style to use for a widget.
*/
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *name;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
widget: Add GtkWidgetClass:root and :unroot functions They get added whenever a widget gets added into a hierarchy with a root widget.
2018-07-29 01:31:36 +00:00
/* The root this widget belongs to or %NULL if widget is not
* rooted or is a #GtkRoot itself.
*/
GtkRoot *root;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* The style for the widget. The style contains the
* colors the widget should be drawn in for each state
* along with graphics contexts used to draw with and
* the font to use for text.
*/
GtkCssNode *cssnode;
GtkStyleContext *context;
/* The widget's allocated size */
transform: Move to GSK The renaming of the prefix makes this a large patch.
2019-02-28 08:52:49 +00:00
GskTransform *allocated_transform;
widget: Save transform as matrix The transform matrix is a translation matrix from the parent's origin to the widget origin. We will later allow more transformations than just translations.
2019-02-16 13:40:49 +00:00
int allocated_width;
int allocated_height;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int allocated_size_baseline;
widget: Save transform as matrix The transform matrix is a translation matrix from the parent's origin to the widget origin. We will later allow more transformations than just translations.
2019-02-16 13:40:49 +00:00
widget: Split up priv->allocation It's not priv->transform (to be turned into a graphene matrix), priv->width and priv->height. The numbers are still the same. The only difference is that unallocated widgets will now have x/y set to 0, not to -1.
2019-02-09 02:03:59 +00:00
int width;
int height;
int baseline;
gtk: Improve struct packing in places Plug some holes in our structs by rearranging a few fields. This is was done looking at pahole output.
2020-07-25 02:57:34 +00:00
GskTransform *transform;
Pack GtkWidgetPrivate a bit better This makes it shrink from 240 to 232 bytes.
2015-09-12 22:54:38 +00:00
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* The widget's requested sizes */
SizeRequestCache requests;
widget: Cache clip from creating render node When the clip changes that is passed to a snapshot function, we need to create eventual cached render nodes because they might not have drawn their whole area before. Fixes issues with redrawing when scrolling.
2018-03-31 15:52:47 +00:00
/* The render node we draw or %NULL if not yet created.*/
widget: Cache the render node This requires a bunch of refactorings: 1. Don't pass the current clip region to gtk_widget_snapshot() so we don't create full widget contents 3. Have a widget->priv->draw_needed that we invalidate on every queue_draw() call and set on every snapshot() 2. In queue_draw(), walk the widget chain to invalidate the render nodes of all parents
2018-03-20 17:55:33 +00:00
GskRenderNode *render_node;
Hook GtkLayoutManager into GtkWidget We delegate the size request mode, the measuring, and the allocation of a widget through a GtkLayoutManager instance, if one has been attached to the widget; otherwise, we fall back to the widget's own implementation.
2018-12-12 17:20:28 +00:00
/* The layout manager, or %NULL */
GtkLayoutManager *layout_manager;
gtk: Add GtkWidgetPaintable A GtkWidgetPaintable is a paintable that observes a given GtkWidget and renders that widget into a paintable.
2018-03-22 19:47:28 +00:00
GSList *paintables;
Go back to keeping a list of event controllers This reverts 4b9e5304cc1f675d2. It caused a number of regressions, such as event controller ordering changes.
2020-08-02 16:00:46 +00:00
GList *event_controllers;
widget: Store accessible in GtkWidgetPrivate Every widget may have one of these, and they are accessed somewhat frequently.
2016-05-06 10:42:43 +00:00
widget: Add children and sibling pointers and a (private) way to access them. We will later use these pointers to manage children of non-container widgets and containers alike.
2016-11-18 08:29:52 +00:00
/* Widget tree */
GtkWidget *parent;
GtkWidget *prev_sibling;
GtkWidget *next_sibling;
GtkWidget *first_child;
GtkWidget *last_child;
widget: Save pointer to focus child Do the same thing GtkContainer does.
2017-02-08 08:00:29 +00:00
widget: Add gtk_widget_observe_children() This creates a listmodel that tracks a widget's children. Doing so turns adding/removing children from O(1) to O(N) though, so use with caution.
2018-08-27 17:50:01 +00:00
/* only created on-demand */
GtkListListModel *children_observer;
GtkListListModel *controller_observer;
widget: Save pointer to focus child Do the same thing GtkContainer does.
2017-02-08 08:00:29 +00:00
GtkWidget *focus_child;
gtkwidget: Add private cursor setter/getter This should be eventually replaced by CSS cursors, but at the moment it must be handled on the gtk/ side.
2017-03-31 15:19:37 +00:00
/* Pointer cursor */
GdkCursor *cursor;
Make tooltip properties idiomatic The tooltip handling in GtkWidget is "special": - the string is stored inside the qdata instead of the private instance data - the accessors call g_object_set() and g_object_get(), and the logic is all inside the property implementation, instead of being the other way around - the getters return a copy of the string - the setters don't really notify all the involved properties The GtkWidgetAccessible uses the (escaped) tooltip text as a source for the accessible object description, which means it has to store the tooltip inside the object qdata, and update its copy at construction and property notification time. We can simplify this whole circus by making the tooltip properties (text and markup) more idiomatic: - notify all side-effect properties - return a constant string from the getter - if tooltip-text is set: - store the text as is - escape the markup and store it separately for the markup getter - if tooltip-markup is set: - store the markup as is - parse the markup and store it separately for the text getter The part of the testtooltips interactive test that checks that the getters are doing the right thing is now part of the gtk testsuite, so we ensure we don't regress in behaviour.
2020-04-22 18:32:17 +00:00
/* Tooltip */
char *tooltip_markup;
char *tooltip_text;
Have GtkWidget implement GtkAccessible Each widget type has an accessible role associated to its class, as roles cannot change during the life time of a widget instance. Each widget is also responsible for creating an ATContext, to proxy state changes to the underlying accessibility infrastructure.
2020-07-08 15:58:11 +00:00
Allow setting the accessible role at construction Some widgets have different accessible roles depending on some parameter, so we cannot set the role at class init time. For those widgets, we add an "accessible-role" property to GtkAccessible, and we allow setting it (only) at construction time.
2020-07-13 14:20:19 +00:00
/* Accessibility */
GtkAccessibleRole accessible_role;
Have GtkWidget implement GtkAccessible Each widget type has an accessible role associated to its class, as roles cannot change during the life time of a widget instance. Each widget is also responsible for creating an ATContext, to proxy state changes to the underlying accessibility infrastructure.
2020-07-08 15:58:11 +00:00
GtkATContext *at_context;
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
};
widget: move class private data to gtkwidgetprivate.h We want access to the private data from the action muxer so we can just move the structures to the gtkwidgetprivate.h header. Alternatively we could create accessors, but given that we'll probably need to use this in other areas, seems reasonable to just put it there.
2020-03-20 16:16:30 +00:00
typedef struct
{
GBytes *data;
GSList *children;
GtkBuilderScope *scope;
} GtkWidgetTemplate;
struct _GtkWidgetClassPrivate
{
GtkWidgetTemplate *template;
widget: Keep keybindings as a GListStore This way, we can use shortcut_controller_new_for_model() and avoid all the special casing about run_class.
2018-08-20 02:18:28 +00:00
GListStore *shortcuts;
widget: move class private data to gtkwidgetprivate.h We want access to the private data from the action muxer so we can just move the structures to the gtkwidgetprivate.h header. Alternatively we could create accessors, but given that we'll probably need to use this in other areas, seems reasonable to just put it there.
2020-03-20 16:16:30 +00:00
GQuark css_name;
GType layout_manager_type;
GtkWidgetAction *actions;
Have GtkWidget implement GtkAccessible Each widget type has an accessible role associated to its class, as roles cannot change during the life time of a widget instance. Each widget is also responsible for creating an ATContext, to proxy state changes to the underlying accessibility infrastructure.
2020-07-08 15:58:11 +00:00
GtkAccessibleRole accessible_role;
widget: move class private data to gtkwidgetprivate.h We want access to the private data from the action muxer so we can just move the structures to the gtkwidgetprivate.h header. Alternatively we could create accessors, but given that we'll probably need to use this in other areas, seems reasonable to just put it there.
2020-03-20 16:16:30 +00:00
};
window: Implement display change via root/unroot Export gtk_widget_root/unroot privately, make them work on roots, and use them in gtk_window_set_display. This gets us to a single way to listen for display changes, the root property.
2019-05-01 22:41:20 +00:00
void gtk_widget_root (GtkWidget *widget);
void gtk_widget_unroot (GtkWidget *widget);
widget: Add gtk_widget_get_css_node() and replace gtk_style_context_get_root() with it.
2015-02-09 21:27:44 +00:00
GtkCssNode * gtk_widget_get_css_node (GtkWidget *widget);
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
void _gtk_widget_set_visible_flag (GtkWidget *widget,
gboolean visible);
gboolean _gtk_widget_get_alloc_needed (GtkWidget *widget);
container: Don't keep our own variable trying to track need for resize Insteaad, introduce gtk_widget_needs_allocate() and use that.
2015-10-08 11:41:50 +00:00
gboolean gtk_widget_needs_allocate (GtkWidget *widget);
widget: Add a resize_needed flag ... and API to set and unset it. It is set when gtk_widget_queue_resize() is called. It is unset when gtk_widget_get_preferred_width/height() is called. So far it is not used.
2015-09-28 00:19:25 +00:00
void gtk_widget_ensure_resize (GtkWidget *widget);
widget: Make gtk_widget_queue_allocate() not resize This commit toggles the big switch. We now don't run size_allocate() from the toplevel up anymore in cases where we don't need to. Things might be broken in subtle ways as a result of this commit. We'll have to find them and fix them.
2015-09-29 21:19:07 +00:00
void gtk_widget_ensure_allocate (GtkWidget *widget);
widget: Track when the window scale factor changes and notify The scale-factor property on the widgets will be notified, and the scale will change on the style property, causing us to pick up new css assets.
2013-06-28 08:39:52 +00:00
void _gtk_widget_scale_changed (GtkWidget *widget);
Pass the layout signal via GdkSurface to GtkRoot Don't have GtkRoot listen directly to the layout signal on the frame clock, but let it pass through GdkSurface. This will allow GdkSurface to be more involved in the layout phase.
2020-11-24 21:02:53 +00:00
GdkSurface * gtk_widget_get_surface (GtkWidget *widget);
Export gtk_widget_render privately We need it in gtkwindow.c and gtkpopover.c.
2019-05-19 03:41:08 +00:00
void gtk_widget_render (GtkWidget *widget,
GdkSurface *surface,
const cairo_region_t *region);
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
Optimize queue_resize_on_widget() Optimized GtkSizeGroup code that is invoked for every queued resize and every request that is not previously cached by trading qdata on widgets for 3 extra bitfields on the GtkWidgetPrivate structure.
2011-02-07 07:55:25 +00:00
void _gtk_widget_add_sizegroup (GtkWidget *widget,
gpointer group);
void _gtk_widget_remove_sizegroup (GtkWidget *widget,
gpointer group);
GSList *_gtk_widget_get_sizegroups (GtkWidget *widget);
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
void _gtk_widget_set_has_default (GtkWidget *widget,
gboolean has_default);
void _gtk_widget_set_has_grab (GtkWidget *widget,
gboolean has_grab);
Drop gtk_widget_has_grab This was just a leftover in our public api. All other grab-related apis are gone.
2020-04-23 17:23:24 +00:00
gboolean gtk_widget_has_grab (GtkWidget *widget);
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
void _gtk_widget_grab_notify (GtkWidget *widget,
gboolean was_grabbed);
widget: Turn screen-changed signal into display-changed
2017-10-30 21:19:02 +00:00
void _gtk_widget_propagate_display_changed (GtkWidget *widget,
GdkDisplay *previous_display);
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
void _gtk_widget_set_device_surface (GtkWidget *widget,
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
GdkDevice *device,
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
GdkSurface *pointer_window);
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
void _gtk_widget_synthesize_crossing (GtkWidget *from,
GtkWidget *to,
GdkDevice *device,
GdkCrossingMode mode);
csswidgetnode: Avoid creating a stylecontext If the widget doesn't have a style context, don't create one. Instead, call functions on the widget directly.
2015-03-05 05:23:35 +00:00
GtkStyleContext * _gtk_widget_peek_style_context (GtkWidget *widget);
Move deprecated gtkwidget style api to gtkstyle
2011-11-02 10:45:10 +00:00
widget: Don't duplicate events to translate coordinates
2019-08-13 10:29:00 +00:00
gboolean _gtk_widget_captured_event (GtkWidget *widget,
Explicitly pass the target to handle_event Pass the event propagation target explicitly down to the event controllers. This is a step towards getting rid of gdk_event_set_target.
2020-02-16 07:20:34 +00:00
GdkEvent *event,
GtkWidget *target);
gtkwidget: Move private functions to private header https://bugzilla.gnome.org/show_bug.cgi?id=651707
2011-06-02 13:25:12 +00:00
widget: Replace style-updated signal with css_changed vfunc 1. Rename the thing 2. Turn it from a signal to a vfunc 3. Pass the GtkCssStyleChange to it We don't export any public API about the GtkCssStyleChange yet, it's just a boring opaque struct.
2020-02-05 01:46:13 +00:00
void gtk_widget_css_changed (GtkWidget *widget,
GtkCssStyleChange *change);
widget: Add a system_setting_changed vfunc This gives us a hook to walk the widget tree whenever a global setting changes and do per-widget invalidations. This will replace gtk_style_context_reset_widgets().
2020-04-21 16:05:45 +00:00
void gtk_widget_system_setting_changed (GtkWidget *widget,
GtkSystemSetting setting);
void gtk_system_setting_changed (GdkDisplay *display,
GtkSystemSetting setting);
stylecontext: Notify widget directly of changes This way, we don't need to g_signal_connect(), which saves a bunch of memory and performance.
2012-03-18 23:25:31 +00:00
GtkWidget: Add gtk_widget_insert_action_group() This allows adding a GActionGroup with a given name at an arbitrary point in the widget tree. This patch also adds an internal _get_action_muxer() API. Calling this will create a GActionMuxer associated with the widget. The parent of the muxer will be the muxer of the widget's conceptual parent. For non-menus, that is the normal parent. For menus, it is the attach widget. In this way, we end up with a hierarchy of GActionMuxer that largely reflects the hierarchy of GtkWidget, but only in places that the action context has been requested. These muxers are the ones on which the inserted actions groups are installed. A following patch will add a user of this API.
2012-08-17 22:09:35 +00:00
void _gtk_widget_update_parent_muxer (GtkWidget *widget);
gtkwindow: Use actions from focused widget to activate accel Currently we only take into account the window GActionGroup for activating the accels. However, the application could have some custom GActionGroup in the chain of focused widgets that could want to activate some action if some accel is activated while that widget is focused. To allow applications to set accels on widgets that use custom GActionGroups, simply use the muxer of the focused widget, which already contains the actions of the parents. https://bugzilla.gnome.org/show_bug.cgi?id=740682
2014-12-03 14:53:59 +00:00
GtkActionMuxer * _gtk_widget_get_action_muxer (GtkWidget *widget,
gboolean create);
GtkWidget: Add gtk_widget_insert_action_group() This allows adding a GActionGroup with a given name at an arbitrary point in the widget tree. This patch also adds an internal _get_action_muxer() API. Calling this will create a GActionMuxer associated with the widget. The parent of the muxer will be the muxer of the widget's conceptual parent. For non-menus, that is the normal parent. For menus, it is the attach widget. In this way, we end up with a hierarchy of GActionMuxer that largely reflects the hierarchy of GtkWidget, but only in places that the action context has been requested. These muxers are the ones on which the inserted actions groups are installed. A following patch will add a user of this API.
2012-08-17 22:09:35 +00:00
widget: Pass parent to gtk_widget_consumes_motion() Right now it assumes that the parent is a GtkWindow. This will break when window dragging is handled by another widget.
2020-05-02 15:34:15 +00:00
gboolean gtk_widget_consumes_motion (GtkWidget *widget,
GtkWidget *parent,
GdkEventSequence *sequence);
gtkwindow: Move window dragging to a standalone drag gesture The gesture is hooked to the capture phase, so it works for buttons in header bars and whatnot. In order to be friendly to the widget it is capturing events from, an ugly hack is in place to avoid capturing events when the target widget has a gesture that would consume motion events.
2015-02-25 19:34:12 +00:00
Add private API to query tick callbacks This information can be useful for debugging purposes.
2014-10-24 12:00:41 +00:00
gboolean gtk_widget_has_tick_callback (GtkWidget *widget);
gesture: Simplify gesture/widget interaction public API The propagation phase property/methods in GtkEventController are gone, This is now set directly on the GtkWidget add/remove controller API, which has been made private. The only public bit now are the new functions gtk_gesture_attach() and gtk_gesture_detach() that will use the private API underneath. All callers have been updated.
2014-05-06 13:50:01 +00:00
GtkWindow: don't increase the preferred size for empty windows if there is a size request set. This fixes a reftest broken by commit 84e99b20ac806ee5f https://bugzilla.gnome.org/show_bug.cgi?id=751341
2015-06-29 11:46:36 +00:00
gboolean gtk_widget_has_size_request (GtkWidget *widget);
gtk: Add private gtk_widget_reset_controllers() This is a one-shot call that can be called on the places we know we're taking input away.
2016-01-13 19:53:54 +00:00
void gtk_widget_reset_controllers (GtkWidget *widget);
widget: Return an array from list_controllers Minimize the GList usage throughout the code base.
2020-03-28 19:37:29 +00:00
GtkEventController **gtk_widget_list_controllers (GtkWidget *widget,
GtkPropagationPhase phase,
guint *out_n_controllers);
widget: Add private accessor to event controllers
2020-02-06 14:21:10 +00:00
Don't emit ::query-tooltip by name This signal is emitted quite a bit, and we can easily avoid it.
2016-05-06 13:54:24 +00:00
gboolean gtk_widget_query_tooltip (GtkWidget *widget,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int x,
int y,
Don't emit ::query-tooltip by name This signal is emitted quite a bit, and we can easily avoid it.
2016-05-06 13:54:24 +00:00
gboolean keyboard_mode,
GtkTooltip *tooltip);
snapshot: Completely reengineer API We now try to emulate cairo_t: We keep a stack of nodes via push/pop and a transform matrix. So whenever a new node is added to the snapshot, we transform it by the current transform matrix and append it to the current node.
2016-11-11 23:37:54 +00:00
void gtk_widget_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot);
widget: Remove unused adjust_* vfuncs Expose them privately to gtksizerequest.c using normal functions instead.
2016-11-23 16:46:44 +00:00
void gtk_widget_adjust_size_request (GtkWidget *widget,
GtkOrientation orientation,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *minimum_size,
int *natural_size);
widget: Remove unused adjust_* vfuncs Expose them privately to gtksizerequest.c using normal functions instead.
2016-11-23 16:46:44 +00:00
void gtk_widget_adjust_baseline_request (GtkWidget *widget,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *minimum_baseline,
int *natural_baseline);
gtk: Use GskRenderNode to render widgets We need a virtual function to retrieve the GskRenderNode for each widget, which is supposed to attach its own children's GskRenderNodes. Additionally, we want to maintain the existing GtkWidget::draw mechanism for widgets that do not implement get_render_node() — as well as widgets that have handlers connected to the ::draw signal.
2016-06-23 16:35:42 +00:00
Drop GtkCallback It is no longer used in any of our public APIs.
2020-08-05 02:17:52 +00:00
typedef void (*GtkCallback) (GtkWidget *widget,
gpointer data);
widget: Add children and sibling pointers and a (private) way to access them. We will later use these pointers to manage children of non-container widgets and containers alike.
2016-11-18 08:29:52 +00:00
void gtk_widget_forall (GtkWidget *widget,
GtkCallback callback,
gpointer user_data);
Implement tab/up-down/left-right focus sorting for widgets basically do what GtkContainer already did.
2017-02-10 20:21:38 +00:00
void gtk_widget_focus_sort (GtkWidget *widget,
GtkDirectionType direction,
GPtrArray *focus_order);
gboolean gtk_widget_focus_move (GtkWidget *widget,
Simplify the move_focus api No need to pass the array in from the outside.
2019-03-02 17:52:56 +00:00
GtkDirectionType direction);
widget: Add a private setter for has-focus
2019-03-07 03:26:27 +00:00
void gtk_widget_set_has_focus (GtkWidget *widget,
gboolean has_focus);
GtkWidget: Start renaming widget->window This is an automated change doing these command: git sed -f g gtk_widget_set_has_window gtk_widget_set_has_surface git sed -f g gtk_widget_get_has_window gtk_widget_get_has_surface git sed -f g gtk_widget_set_parent_window gtk_widget_set_parent_surface git sed -f g gtk_widget_get_parent_window gtk_widget_get_parent_surface git sed -f g gtk_widget_set_window gtk_widget_set_surface git sed -f g gtk_widget_get_window gtk_widget_get_surface git sed -f g gtk_widget_register_window gtk_widget_register_surface git sed -f g gtk_widget_unregister_window gtk_widget_unregister_surface git checkout NEWS*
2018-03-20 14:21:12 +00:00
void gtk_widget_get_surface_allocation (GtkWidget *widget,
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
GtkAllocation *allocation);
widget: Fix drawing invalidation with windowed widgets E.g. popovers. Find the parent of the given widget with the window and invalidate the given region in that window.
2017-06-21 10:15:47 +00:00
gtkwidget: Expose gtk_widget_common_ancestor() This function will be useful in other places, such as determining the widgets that must receive crossing events after pointer picking points to another widget.
2017-03-31 15:16:47 +00:00
GtkWidget * gtk_widget_common_ancestor (GtkWidget *widget_a,
GtkWidget *widget_b);
gtk/main: Stack ::active calls We may have the situation of multiple touchpoints in the same widget, or combinations with other devices. Stack those ::active states are preserved on widgets on all but the last pointer/touch going away.
2020-11-12 23:23:52 +00:00
void gtk_widget_set_active_state (GtkWidget *widget,
gboolean active);
widget: Remove controller sequence-state-changed signal connection We can avoid a signal connection per event controller (and the EventControllerData struct) since every event controller knows the widget it's attached to.
2018-05-14 17:03:17 +00:00
void gtk_widget_cancel_event_sequence (GtkWidget *widget,
GtkGesture *gesture,
GdkEventSequence *sequence,
GtkEventSequenceState state);
Drop gtk_widget_event from API We don't want events to be injected randomly from the outside. Plus, there's no way to create such events from the outside now.
2020-02-17 12:40:31 +00:00
gboolean gtk_widget_event (GtkWidget *widget,
GdkEvent *event,
GtkWidget *target);
gtkwidget: Expose gtk_widget_run_controllers() in private header Allows for more fine grained access than gtk_widget(_captured)_event which are meant to work across a hierarchy.
2019-02-20 11:41:00 +00:00
gboolean gtk_widget_run_controllers (GtkWidget *widget,
Strip const from GdkEvent Events are refcounted structs, and we generally don't pass these as const.
2020-02-16 16:09:02 +00:00
GdkEvent *event,
Explicitly pass the target to handle_event Pass the event propagation target explicitly down to the event controllers. This is a step towards getting rid of gdk_event_set_target.
2020-02-16 07:20:34 +00:00
GtkWidget *target,
Pass translated coordinates outside the event We want to make events readonly, so stop translating their coordinates and instead pass the translated coordinates separately, when propagating events.
2020-02-13 05:08:49 +00:00
double x,
double y,
gtkwidget: Expose gtk_widget_run_controllers() in private header Allows for more fine grained access than gtk_widget(_captured)_event which are meant to work across a hierarchy.
2019-02-20 11:41:00 +00:00
GtkPropagationPhase phase);
New focus change handling Instead of relying on gdk's antiquated crossing events, create a new GtkCrossingData struct that contains the actual widgets, and a new event controller vfunc that expects this struct. This also saves us from making sense of X's crossing modes and details, and makes for a generally simpler api. The ::focus-in and ::focus-out signals of GtkEventControllerKey have been replaced by a single ::focus-change signal that takes GtkCrossingData as an argument. All callers have been updated.
2020-02-13 01:26:29 +00:00
void gtk_widget_handle_crossing (GtkWidget *widget,
const GtkCrossingData *crossing,
double x,
double y);
gtk: Run GtkWidgetClass event signals inside a GtkEventController This will allow further cleanups and optimizations in capture/target/bubble event delivery. For simplicity, ATM every widget will receive its own GtkEventControllerLegacy, it could be desirable to add finer control over this in the future, so widgets that fully use event controllers for input management can do away without this legacy piece.
2017-05-26 16:55:30 +00:00
Drop gtk_widget_send_focus_change Replace this with gtk_widget_set_has_focus + gtk_widget_event.
2019-03-03 02:03:38 +00:00
widget: Add surface relative transform changed callback Added two new private GtkWidget API: * gtk_widget_add_surface_transform_changed_callback() * gtk_widget_remove_surface_transform_changed_callback() The intention is to let the user know when a widget transform relative to the surface changes. It works by calculating the surface relative transform during allocation, and notifying the callbacks if it changed since last time. Each widget adds itself as a listener to its parent widget, thus will be triggered if a parents surface relative transform changes.
2019-04-18 16:55:13 +00:00
guint gtk_widget_add_surface_transform_changed_callback (GtkWidget *widget,
GtkSurfaceTransformChangedCallback callback,
gpointer user_data,
GDestroyNotify notify);
void gtk_widget_remove_surface_transform_changed_callback (GtkWidget *widget,
guint id);
widget: Add common focus vfunc implementations Privately export a number of implementations for the focus and grab_focus vfuncs that cover many common cases.
2020-04-08 11:42:27 +00:00
/* focus vfuncs for non-focusable containers with focusable children */
gboolean gtk_widget_grab_focus_child (GtkWidget *widget);
gboolean gtk_widget_focus_child (GtkWidget *widget,
GtkDirectionType direction);
/* focus vfuncs for focusable widgets with children that don't receive focus */
gboolean gtk_widget_grab_focus_self (GtkWidget *widget);
gboolean gtk_widget_focus_self (GtkWidget *widget,
GtkDirectionType direction);
widget: Add surface relative transform changed callback Added two new private GtkWidget API: * gtk_widget_add_surface_transform_changed_callback() * gtk_widget_remove_surface_transform_changed_callback() The intention is to let the user know when a widget transform relative to the surface changes. It works by calculating the surface relative transform during allocation, and notifying the callbacks if it changed since last time. Each widget adds itself as a listener to its parent widget, thus will be triggered if a parents surface relative transform changes.
2019-04-18 16:55:13 +00:00
Move orientable style classes into GtkWidget It feels slightly wrong to have GtkOrientable operate on widgets, but at least what happens when an orientable widget changes orientation should be part of GtkWidget. This will allow to add more state changes without accessing widget state from the outside of gtkwidget.c.
2020-04-23 16:48:29 +00:00
void gtk_widget_update_orientation (GtkWidget *widget,
GtkOrientation orientation);
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
/* inline getters */
static inline GtkWidget *
_gtk_widget_get_parent (GtkWidget *widget)
{
return widget->priv->parent;
}
static inline gboolean
_gtk_widget_get_visible (GtkWidget *widget)
{
return widget->priv->visible;
}
static inline gboolean
_gtk_widget_get_child_visible (GtkWidget *widget)
{
return widget->priv->child_visible;
}
static inline gboolean
_gtk_widget_get_mapped (GtkWidget *widget)
{
return widget->priv->mapped;
}
static inline gboolean
_gtk_widget_get_realized (GtkWidget *widget)
{
return widget->priv->realized;
}
widget: Add more inline getters Add a getter for state flags, and use it where appropriate.
2015-09-07 16:23:09 +00:00
static inline GtkStateFlags
_gtk_widget_get_state_flags (GtkWidget *widget)
{
return widget->priv->state_flags;
}
Use a getter for widget direction
2015-09-09 00:30:22 +00:00
extern GtkTextDirection gtk_default_direction;
static inline GtkTextDirection
_gtk_widget_get_direction (GtkWidget *widget)
{
if (widget->priv->direction == GTK_TEXT_DIR_NONE)
return gtk_default_direction;
else
return widget->priv->direction;
}
widget: Add a GtkWidget::root property and gtk_widget_get_root() The property is just for API completeness, the getter is meant to replace toplevel usage.
2018-07-29 01:40:52 +00:00
static inline GtkRoot *
_gtk_widget_get_root (GtkWidget *widget)
{
return widget->priv->root;
}
widget: Add static inline version of gtk_widget_display() Due to the few type checks in gtk_widget_get_display(), it was the slowest part of a call to gtk_widget_query_size_for_orientation if the in case of a cache hit.
2018-04-21 15:03:31 +00:00
static inline GdkDisplay *
_gtk_widget_get_display (GtkWidget *widget)
{
root: Add GtkRoot:get_display vfunc And use it.
2018-07-29 02:11:14 +00:00
GtkRoot *root = _gtk_widget_get_root (widget);
widget: Add static inline version of gtk_widget_display() Due to the few type checks in gtk_widget_get_display(), it was the slowest part of a call to gtk_widget_query_size_for_orientation if the in case of a cache hit.
2018-04-21 15:03:31 +00:00
root: Add GtkRoot:get_display vfunc And use it.
2018-07-29 02:11:14 +00:00
if (root == NULL)
return gdk_display_get_default ();
widget: Add static inline version of gtk_widget_display() Due to the few type checks in gtk_widget_get_display(), it was the slowest part of a call to gtk_widget_query_size_for_orientation if the in case of a cache hit.
2018-04-21 15:03:31 +00:00
root: Add GtkRoot:get_display vfunc And use it.
2018-07-29 02:11:14 +00:00
return gtk_root_get_display (root);
widget: Add static inline version of gtk_widget_display() Due to the few type checks in gtk_widget_get_display(), it was the slowest part of a call to gtk_widget_query_size_for_orientation if the in case of a cache hit.
2018-04-21 15:03:31 +00:00
}
Move GtkWidgetPrivate to gtkwidgetprivate.h This lets us use inlined getters for members in there, avoiding the type checks in the public getters.
2015-09-06 23:58:03 +00:00
static inline GtkStyleContext *
_gtk_widget_get_style_context (GtkWidget *widget)
{
if (G_LIKELY (widget->priv->context))
return widget->priv->context;
return gtk_widget_get_style_context (widget);
}
widget: Move _gtk_widget_peek_request_cache to private.h
2015-09-11 13:07:37 +00:00
static inline gpointer
_gtk_widget_peek_request_cache (GtkWidget *widget)
{
return &widget->priv->requests;
}
widget: Add children and sibling pointers and a (private) way to access them. We will later use these pointers to manage children of non-container widgets and containers alike.
2016-11-18 08:29:52 +00:00
static inline GtkWidget *
_gtk_widget_get_prev_sibling (GtkWidget *widget)
{
return widget->priv->prev_sibling;
}
static inline GtkWidget *
_gtk_widget_get_next_sibling (GtkWidget *widget)
{
return widget->priv->next_sibling;
}
static inline GtkWidget *
_gtk_widget_get_first_child (GtkWidget *widget)
{
return widget->priv->first_child;
}
static inline GtkWidget *
_gtk_widget_get_last_child (GtkWidget *widget)
{
return widget->priv->last_child;
}
widget: Add typecheck-less _is_sensitive It adds up to a whopping 3% in gtk_widget_pick
2019-02-19 07:24:43 +00:00
static inline gboolean
_gtk_widget_is_sensitive (GtkWidget *widget)
{
return !(widget->priv->state_flags & GTK_STATE_FLAG_INSENSITIVE);
}
Split off gtkprivate.h The gtkprivate.h header contains GtkWidget-specific private symbols that are not useful except in a handful of cases. Basically everything includes gtkprivate.h for the GTK_PARAM_* macros. https://bugzilla.gnome.org/show_bug.cgi?id=632539
2010-10-19 17:14:46 +00:00
G_END_DECLS
#endif /* __GTK_WIDGET_PRIVATE_H__ */
Reference in New Issue Copy Permalink