AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
791bf0c2eb
gtk2/gtk/gtkcssnodeprivate.h

171 lines
10 KiB
C
Raw Normal View History

stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
/* GTK - The GIMP Toolkit
* Copyright (C) 2014 Benjamin Otte <otte@gnome.org>
*
* 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/>.
*/
#ifndef __GTK_CSS_NODE_PRIVATE_H__
#define __GTK_CSS_NODE_PRIVATE_H__
#include "gtkcssnodedeclarationprivate.h"
cssnode: Split out the style cache For now, the split out style cache doesn't cache anything. This is mostly to make sure that bisections of wrong caching behavior will bisect down to the commit that actually adds caching.
2016-01-15 22:27:51 +00:00
#include "gtkcssnodestylecacheprivate.h"
cssnode: Change style-changed signal Instead of having old and new style, now have a GtkCssStyleChange opaque object that will compute the changes you are interested in for you. This simplifies change signal handlers quite a bit and avoids lots of repeated computation in every signal handler.
2015-12-12 01:02:04 +00:00
#include "gtkcssstylechangeprivate.h"
cssnode: Split out a function So far the vfunc is kinda quirky (the path argument is an out argument for something you have to free when you're done with the matcher), but I'm about to change that.
2015-02-09 08:41:48 +00:00
#include "gtkbitmaskprivate.h"
#include "gtkcsstypesprivate.h"
stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
G_BEGIN_DECLS
cssnode: Turn into a GObject This will allow us to use subclasses.
2015-01-10 22:49:04 +00:00
#define GTK_TYPE_CSS_NODE (gtk_css_node_get_type ())
#define GTK_CSS_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_CSS_NODE, GtkCssNode))
#define GTK_CSS_NODE_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_CSS_NODE, GtkCssNodeClass))
#define GTK_IS_CSS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_CSS_NODE))
#define GTK_IS_CSS_NODE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_CSS_NODE))
#define GTK_CSS_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CSS_NODE, GtkCssNodeClass))
cssnode: Change style-changed signal Instead of having old and new style, now have a GtkCssStyleChange opaque object that will compute the changes you are interested in for you. This simplifies change signal handlers quite a bit and avoids lots of repeated computation in every signal handler.
2015-12-12 01:02:04 +00:00
typedef struct _GtkCssNodeClass GtkCssNodeClass;
cssnode: Turn into a GObject This will allow us to use subclasses.
2015-01-10 22:49:04 +00:00
struct _GtkCssNode
{
GObject object;
stylecontext: Handle parent in CssNode code Make CssNode a real tree with a DOM-like API.
2015-01-26 01:18:06 +00:00
GtkCssNode *parent;
GtkCssNode *previous_sibling;
GtkCssNode *next_sibling;
GtkCssNode *first_child;
GtkCssNode *last_child;
cssnode: Turn into a GObject This will allow us to use subclasses.
2015-01-10 22:49:04 +00:00
GtkCssNodeDeclaration *decl;
GtkCssStyle *style;
cssnode: Split out the style cache For now, the split out style cache doesn't cache anything. This is mostly to make sure that bisections of wrong caching behavior will bisect down to the commit that actually adds caching.
2016-01-15 22:27:51 +00:00
GtkCssNodeStyleCache *cache; /* cache for children to look up styles */
cssnode: Track invalid flag Remove it from GtkStyleContext.
2015-01-28 04:14:47 +00:00
cssnode: Track pending changes here ... instead of GtkCssWidgetNode.
2015-02-03 14:36:01 +00:00
GtkCssChange pending_changes; /* changes that accumulated since the style was last computed */
cssnode: Add visibility concept This allows hiding nodes of invisible widgets. And that in turn makes sure :nth-child() works as expected.
2015-02-10 01:50:57 +00:00
guint visible :1; /* node will be skipped when validating or computing styles */
stylecontext: Don't queue animate tick callbacks anymore Instead, just mark nodes permanently as invalid.
2015-02-07 18:03:37 +00:00
guint invalid :1; /* node or a child needs to be validated (even if just for animation) */
cssnode: Track invalid children We need to properly track if a node needs to propagate invalidation state information to its children. We didn't do this properly before and that could lead to us forgetting to invalidate nodes in corner cases.
2015-03-01 12:14:01 +00:00
guint needs_propagation :1; /* children have state changes that need to be propagated to their siblings */
cssnode: Implement a way to properly track invalidations See the comment in gtkcssnodeprivate.h for how this works.
2015-02-17 04:01:09 +00:00
/* Two invariants hold for this variable:
* style_is_invalid == TRUE => next_sibling->style_is_invalid == TRUE
* style_is_invalid == FALSE => first_child->style_is_invalid == TRUE
* So if a valid style is computed, one has to previously ensure that the parent's and the previous sibling's style
* are valid. This allows both validation and invalidation to run in O(nodes-in-tree) */
guint style_is_invalid :1; /* the style needs to be recomputed */
cssnode: Turn into a GObject This will allow us to use subclasses.
2015-01-10 22:49:04 +00:00
};
struct _GtkCssNodeClass
{
GObjectClass object_class;
cssnode: Split into 3 objects - GtkCssWidgetNode for style contexts owned by a widget - GtkCssPathNode for style contexts using a GtkWidgetPath - GtkCssTransientNode for nodes created with gtk_style_context_save()/restore()
2015-01-12 02:58:21 +00:00
cssnode: Add node-added and node-removed signal This allows monitoring the CSS tree. For now, moving a child to a different position relative to its siblings while keeping the same parent will cause a child-added + child-removed emission.
2015-03-01 20:33:54 +00:00
void (* node_added) (GtkCssNode *cssnode,
GtkCssNode *child,
GtkCssNode *previous);
void (* node_removed) (GtkCssNode *cssnode,
GtkCssNode *child,
GtkCssNode *previous);
cssnode: Add a style-changed signal The signal gets emitted whenever the style needs to be changed.
2015-03-05 16:35:57 +00:00
void (* style_changed) (GtkCssNode *cssnode,
cssnode: Change style-changed signal Instead of having old and new style, now have a GtkCssStyleChange opaque object that will compute the changes you are interested in for you. This simplifies change signal handlers quite a bit and avoids lots of repeated computation in every signal handler.
2015-12-12 01:02:04 +00:00
GtkCssStyleChange *style_change);
cssnode: Add node-added and node-removed signal This allows monitoring the CSS tree. For now, moving a child to a different position relative to its siblings while keeping the same parent will cause a child-added + child-removed emission.
2015-03-01 20:33:54 +00:00
cssnode: Split out a function So far the vfunc is kinda quirky (the path argument is an out argument for something you have to free when you're done with the matcher), but I'm about to change that.
2015-02-09 08:41:48 +00:00
gboolean (* init_matcher) (GtkCssNode *cssnode,
cssnode: Remove now unused arg from vfunc
2015-02-09 16:26:07 +00:00
GtkCssMatcher *matcher);
cssnode: Split into 3 objects - GtkCssWidgetNode for style contexts owned by a widget - GtkCssPathNode for style contexts using a GtkWidgetPath - GtkCssTransientNode for nodes created with gtk_style_context_save()/restore()
2015-01-12 02:58:21 +00:00
GtkWidgetPath * (* create_widget_path) (GtkCssNode *cssnode);
const GtkWidgetPath * (* get_widget_path) (GtkCssNode *cssnode);
cssnode: Change get_style_provider() vfunc Instead of always returning a provider, allow the vfunc to return NULL to mane "use same provider as parent". This allows a bunch of optimizations.
2015-02-17 14:18:32 +00:00
/* get style provider to use or NULL to use parent's */
css: Merge GtkStyleProviderPrivate into GtkStyleProvider This is just lots of renaming. The interface remains private, so the public API does not change, apart from removing the definition of the Interface object to avoid subclassing.
2017-10-31 03:31:46 +00:00
GtkStyleProvider * (* get_style_provider) (GtkCssNode *cssnode);
cssnode: Add API to query the timestamp ... and pass it to the API that computes new styles. A special timestamp of 0 means "please don't animate" and is used when no frame clock is available for a node.
2015-02-18 23:54:14 +00:00
/* get frame clock or NULL (only relevant for root node) */
GdkFrameClock * (* get_frame_clock) (GtkCssNode *cssnode);
cssnode: Automatically recreate style on get_style() call When the style is invalid, redo it. Make this a vfunc, so the widget nodes can opt out.
2015-02-04 03:43:55 +00:00
GtkCssStyle * (* update_style) (GtkCssNode *cssnode,
GtkCssChange pending_changes,
cssnode: Add API to query the timestamp ... and pass it to the API that computes new styles. A special timestamp of 0 means "please don't animate" and is used when no frame clock is available for a node.
2015-02-18 23:54:14 +00:00
gint64 timestamp,
cssnode: Automatically recreate style on get_style() call When the style is invalid, redo it. Make this a vfunc, so the widget nodes can opt out.
2015-02-04 03:43:55 +00:00
GtkCssStyle *old_style);
void (* invalidate) (GtkCssNode *node);
cssnode: Change way invalidation is handled Have a queue_validate() vfunc and a dequeue_validate() vfunc that are called only on root nodes so they can queue a validation on their frame clocks.
2015-02-07 16:19:07 +00:00
void (* queue_validate) (GtkCssNode *node);
void (* dequeue_validate) (GtkCssNode *node);
cssnode: Merge the 2 places that compute styles Now that the widget node recomputes styles on update_style() we can just call it during validate(). That way, we don't need the widget node to manually compute its style.
2015-02-22 22:28:04 +00:00
void (* validate) (GtkCssNode *node);
cssnode: Turn into a GObject This will allow us to use subclasses.
2015-01-10 22:49:04 +00:00
};
GType gtk_css_node_get_type (void) G_GNUC_CONST;
stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
switch: Port to GtkCssNode This is a simple port, no code modifications so far other than replacing gtk_style_context_save() with gtk_style_context_save_to_node().
2015-02-16 22:05:05 +00:00
GtkCssNode * gtk_css_node_new (void);
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
void gtk_css_node_set_parent (GtkCssNode *cssnode,
GtkCssNode *parent);
cssnode: Change API of some functions gtk_css_node_set_after/before() are now called gtk_css_node_insert_after/before(). This brings them in line with other similar APIs (ie GtkListStore). And it allows easier usage of the API (see changes to gtkbox.c).
2015-07-12 19:39:49 +00:00
void gtk_css_node_insert_after (GtkCssNode *parent,
GtkCssNode *cssnode,
box: Use CSS nodes instead of widget paths This is a very simple patch that causes a bunch of overhead. But it works.
2015-02-09 21:51:28 +00:00
GtkCssNode *previous_sibling);
cssnode: Change API of some functions gtk_css_node_set_after/before() are now called gtk_css_node_insert_after/before(). This brings them in line with other similar APIs (ie GtkListStore). And it allows easier usage of the API (see changes to gtkbox.c).
2015-07-12 19:39:49 +00:00
void gtk_css_node_insert_before (GtkCssNode *parent,
GtkCssNode *cssnode,
box: Use CSS nodes instead of widget paths This is a very simple patch that causes a bunch of overhead. But it works.
2015-02-09 21:51:28 +00:00
GtkCssNode *next_sibling);
cssnode: Add gtk_css_node_reverse_children()
2015-07-12 21:11:11 +00:00
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
GtkCssNode * gtk_css_node_get_parent (GtkCssNode *cssnode) G_GNUC_PURE;
GtkCssNode * gtk_css_node_get_first_child (GtkCssNode *cssnode) G_GNUC_PURE;
GtkCssNode * gtk_css_node_get_last_child (GtkCssNode *cssnode) G_GNUC_PURE;
GtkCssNode * gtk_css_node_get_previous_sibling(GtkCssNode *cssnode) G_GNUC_PURE;
GtkCssNode * gtk_css_node_get_next_sibling (GtkCssNode *cssnode) G_GNUC_PURE;
stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
cssnode: Add visibility concept This allows hiding nodes of invisible widgets. And that in turn makes sure :nth-child() works as expected.
2015-02-10 01:50:57 +00:00
void gtk_css_node_set_visible (GtkCssNode *cssnode,
gboolean visible);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
gboolean gtk_css_node_get_visible (GtkCssNode *cssnode) G_GNUC_PURE;
cssnode: Add visibility concept This allows hiding nodes of invisible widgets. And that in turn makes sure :nth-child() works as expected.
2015-02-10 01:50:57 +00:00
cssnode: Add setters/getters for name
2015-09-05 04:31:32 +00:00
void gtk_css_node_set_name (GtkCssNode *cssnode,
/*interned*/const char*name);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
/*interned*/const char *gtk_css_node_get_name (GtkCssNode *cssnode) G_GNUC_PURE;
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
void gtk_css_node_set_widget_type (GtkCssNode *cssnode,
GType widget_type);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
GType gtk_css_node_get_widget_type (GtkCssNode *cssnode) G_GNUC_PURE;
cssnode: Handle invalidation Handle invalidation of node inside the CssNode code, don't do it in the stylecontext.
2015-01-25 01:40:40 +00:00
void gtk_css_node_set_id (GtkCssNode *cssnode,
Add some api annotations Nothing is using the /*interned*/ annotations currently, but if we are doing this, we should be consistent.
2015-10-27 03:35:22 +00:00
/*interned*/const char*id);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
/*interned*/const char *gtk_css_node_get_id (GtkCssNode *cssnode) G_GNUC_PURE;
cssnode: Handle invalidation Handle invalidation of node inside the CssNode code, don't do it in the stylecontext.
2015-01-25 01:40:40 +00:00
void gtk_css_node_set_state (GtkCssNode *cssnode,
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
GtkStateFlags state_flags);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
GtkStateFlags gtk_css_node_get_state (GtkCssNode *cssnode) G_GNUC_PURE;
cssnode: Add properties
2015-03-05 19:29:37 +00:00
void gtk_css_node_set_classes (GtkCssNode *cssnode,
const char **classes);
char ** gtk_css_node_get_classes (GtkCssNode *cssnode);
cssnode: Handle invalidation Handle invalidation of node inside the CssNode code, don't do it in the stylecontext.
2015-01-25 01:40:40 +00:00
void gtk_css_node_add_class (GtkCssNode *cssnode,
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
GQuark style_class);
cssnode: Handle invalidation Handle invalidation of node inside the CssNode code, don't do it in the stylecontext.
2015-01-25 01:40:40 +00:00
void gtk_css_node_remove_class (GtkCssNode *cssnode,
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
GQuark style_class);
gboolean gtk_css_node_has_class (GtkCssNode *cssnode,
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
GQuark style_class) G_GNUC_PURE;
cssnode: Optimize listing of classes Avoid creating the GList of strings when the GQuarks will just be determined again. Instead have gtk_style_context_list_classes() do it specifically.
2015-09-11 15:49:59 +00:00
const GQuark * gtk_css_node_list_classes (GtkCssNode *cssnode,
guint *n_classes);
stylecontext: Turn CssNode accesses into getters/setters That way we can hide the struct in the source file.
2015-01-10 21:35:38 +00:00
const GtkCssNodeDeclaration *
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
gtk_css_node_get_declaration (GtkCssNode *cssnode) G_GNUC_PURE;
GtkCssStyle * gtk_css_node_get_style (GtkCssNode *cssnode) G_GNUC_PURE;
stylecontext: Call get_style(), not create_style() We want to ensure that the style is created properly. This also allows making the create_Style() function private.
2015-02-23 02:06:02 +00:00
stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
cssnode: Add gtk_css_node_invalidate_style_provider() This function not just invalidates the current node, but also all children.
2015-02-17 15:11:38 +00:00
void gtk_css_node_invalidate_style_provider
(GtkCssNode *cssnode);
cssnode: Add API to query the timestamp ... and pass it to the API that computes new styles. A special timestamp of 0 means "please don't animate" and is used when no frame clock is available for a node.
2015-02-18 23:54:14 +00:00
void gtk_css_node_invalidate_frame_clock
(GtkCssNode *cssnode,
gboolean just_timestamp);
cssnode: Handle invalidation Handle invalidation of node inside the CssNode code, don't do it in the stylecontext.
2015-01-25 01:40:40 +00:00
void gtk_css_node_invalidate (GtkCssNode *cssnode,
GtkCssChange change);
cssnode: Remove timestamp from gtk_css_node_validate() GtkCssNode knows its own timestamp.
2015-02-20 16:28:23 +00:00
void gtk_css_node_validate (GtkCssNode *cssnode);
cssnode: Split out a function So far the vfunc is kinda quirky (the path argument is an out argument for something you have to free when you're done with the matcher), but I'm about to change that.
2015-02-09 08:41:48 +00:00
gboolean gtk_css_node_init_matcher (GtkCssNode *cssnode,
cssnode: Remove now unused arg from vfunc
2015-02-09 16:26:07 +00:00
GtkCssMatcher *matcher);
cssnode: Split into 3 objects - GtkCssWidgetNode for style contexts owned by a widget - GtkCssPathNode for style contexts using a GtkWidgetPath - GtkCssTransientNode for nodes created with gtk_style_context_save()/restore()
2015-01-12 02:58:21 +00:00
GtkWidgetPath * gtk_css_node_create_widget_path (GtkCssNode *cssnode);
css: Mark some hot functions as G_GNUC_PURE By doing that, gcc will generate code that avoids calling these functions when not needed.
2019-02-15 03:06:22 +00:00
const GtkWidgetPath * gtk_css_node_get_widget_path (GtkCssNode *cssnode) G_GNUC_PURE;
GtkStyleProvider * gtk_css_node_get_style_provider (GtkCssNode *cssnode) G_GNUC_PURE;
cssnode: Split into 3 objects - GtkCssWidgetNode for style contexts owned by a widget - GtkCssPathNode for style contexts using a GtkWidgetPath - GtkCssTransientNode for nodes created with gtk_style_context_save()/restore()
2015-01-12 02:58:21 +00:00
Add a function to dump CSS nodes and styles Add a gtk_style_context_to_string function that can serialize a CSS node or tree of nodes, optionally including CSS properties as well. This will be useful in writing tests.
2015-12-28 06:09:54 +00:00
void gtk_css_node_print (GtkCssNode *cssnode,
GtkStyleContextPrintFlags flags,
GString *string,
guint indent);
stylecontext: Split out GtkCssNode into own file The functionality of it is supposed to grow, so better put it in a custom file early. This is just a naive split so far, the next patches will split things further.
2015-01-09 23:47:32 +00:00
G_END_DECLS
#endif /* __GTK_CSS_NODE_PRIVATE_H__ */
Reference in New Issue Copy Permalink