AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
c1c1d4431d
gtk2/gtk/gtkcssimageprivate.h

152 lines
9.0 KiB
C
Raw Normal View History

css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/*
* Copyright © 2011 Red Hat Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#ifndef __GTK_CSS_IMAGE_PRIVATE_H__
#define __GTK_CSS_IMAGE_PRIVATE_H__
#include <cairo.h>
#include <glib-object.h>
css: Move _gtk_css_print_string around Move this to a separate header, since it is not parser functionality, and kill the duplicate gtkcssparserprivate.h header.
2020-10-03 02:28:17 +00:00
#include <gtk/css/gtkcss.h>
#include "gtk/css/gtkcsstokenizerprivate.h"
#include "gtk/css/gtkcssparserprivate.h"
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
#include "gtk/gtkcsstypesprivate.h"
Use GtkSnapshot getters We can avoid direct struct access and gtksnapshotprivate.h everywhere.
2018-03-11 05:29:46 +00:00
#include "gtk/gtksnapshot.h"
gtk: Don't include gtkstylecontext.h from gtkcsstypesprivate.h And make sure it's included everywhere it's needed.
2019-03-16 03:48:26 +00:00
#include "gtk/gtkstyleprovider.h"
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
G_BEGIN_DECLS
#define GTK_TYPE_CSS_IMAGE (_gtk_css_image_get_type ())
#define GTK_CSS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_CSS_IMAGE, GtkCssImage))
#define GTK_CSS_IMAGE_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_CSS_IMAGE, GtkCssImageClass))
#define GTK_IS_CSS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_CSS_IMAGE))
#define GTK_IS_CSS_IMAGE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_CSS_IMAGE))
#define GTK_CSS_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CSS_IMAGE, GtkCssImageClass))
typedef struct _GtkCssImage GtkCssImage;
typedef struct _GtkCssImageClass GtkCssImageClass;
struct _GtkCssImage
{
GObject parent;
};
struct _GtkCssImageClass
{
GObjectClass parent_class;
/* width of image or 0 if it has no width (optional) */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
int (* get_width) (GtkCssImage *image);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* height of image or 0 if it has no height (optional) */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
int (* get_height) (GtkCssImage *image);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* aspect ratio (width / height) of image or 0 if it has no aspect ratio (optional) */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
double (* get_aspect_ratio) (GtkCssImage *image);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* create "computed value" in CSS terms, returns a new reference */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
GtkCssImage *(* compute) (GtkCssImage *image,
guint property_id,
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 *provider,
css: Move scale to GtkStyleProviderPrivate This way, we can remove it as a separate argument from gtk_css_value_compute() and allow computation to only depend on one thing: the style provider.
2015-01-31 10:56:15 +00:00
GtkCssStyle *style,
cssvalue: Remove GtkCssDependencies They are not used anymore.
2015-02-14 01:27:39 +00:00
GtkCssStyle *parent_style);
cssimage: Add an equal vfunc No implementations for it exist yet.
2012-10-11 10:10:20 +00:00
/* compare two images for equality */
gboolean (* equal) (GtkCssImage *image1,
GtkCssImage *image2);
css: Add "-gtk-icon-source: builtin" ... and make it the default. This takes over the meaning from "none" for this property in that it draws the fallback builtin image. "none" now literally means no image will be drawn.
2014-10-21 03:52:05 +00:00
/* transition between start and end image (end may be NULL), returns new reference (optional) */
cssimage: Make image transition a vfunc
2012-10-02 09:31:36 +00:00
GtkCssImage *(* transition) (GtkCssImage *start,
GtkCssImage *end,
guint property_id,
double progress);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* draw to 0,0 with the given width and height */
snapshot: Add infrastructure to snapshot CSS images Use this infrastructure to render builtin images. Which means from now on, GtkCheckbutton, GtkSpinner and a few others use snapshots.
2016-11-16 19:51:53 +00:00
void (* snapshot) (GtkCssImage *image,
GtkSnapshot *snapshot,
double width,
double height);
cssimage: Add gtk_css_image_is_invalid() Use that instead of hacks to guess when an image is considered invalid according to https://drafts.csswg.org/css-images-4/#invalid-image Also add a GtkCssImageInvalid that implements the behavior of invalid images according to the CSS spec so thjat image implementations can refer to that image.
2018-02-17 19:31:14 +00:00
/* is this image to be considered invalid (see https://drafts.csswg.org/css-images-4/#invalid-image for details) */
gboolean (* is_invalid) (GtkCssImage *image);
cssimage: Implement dynamic values No image actually implements it yet, but this is the plumbing.
2018-02-13 06:04:21 +00:00
/* does this image change based on timestamp? (optional) */
gboolean (* is_dynamic) (GtkCssImage *image);
/* get image for given timestamp or @image when not dynamic (optional) */
GtkCssImage *(* get_dynamic_image) (GtkCssImage *image,
gint64 monotonic_time);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* parse CSS, return TRUE on success */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
gboolean (* parse) (GtkCssImage *image,
GtkCssParser *parser);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
/* print to CSS */
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
void (* print) (GtkCssImage *image,
GString *string);
cssimage: Add is_computed vfunc Same semantics as the is_computed field of GtkCssValue
2020-01-11 13:38:49 +00:00
gboolean (* is_computed) (GtkCssImage *image);
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
};
GType _gtk_css_image_get_type (void) G_GNUC_CONST;
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
gboolean _gtk_css_image_can_parse (GtkCssParser *parser);
GtkCssImage * _gtk_css_image_new_parse (GtkCssParser *parser);
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
int _gtk_css_image_get_width (GtkCssImage *image) G_GNUC_PURE;
int _gtk_css_image_get_height (GtkCssImage *image) G_GNUC_PURE;
double _gtk_css_image_get_aspect_ratio (GtkCssImage *image) G_GNUC_PURE;
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
GtkCssImage * _gtk_css_image_compute (GtkCssImage *image,
guint property_id,
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 *provider,
css: Move scale to GtkStyleProviderPrivate This way, we can remove it as a separate argument from gtk_css_value_compute() and allow computation to only depend on one thing: the style provider.
2015-01-31 10:56:15 +00:00
GtkCssStyle *style,
cssvalue: Remove GtkCssDependencies They are not used anymore.
2015-02-14 01:27:39 +00:00
GtkCssStyle *parent_style);
cssimage: Add an equal vfunc No implementations for it exist yet.
2012-10-11 10:10:20 +00:00
gboolean _gtk_css_image_equal (GtkCssImage *image1,
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
GtkCssImage *image2) G_GNUC_PURE;
cssimage: Make image transition a vfunc
2012-10-02 09:31:36 +00:00
GtkCssImage * _gtk_css_image_transition (GtkCssImage *start,
GtkCssImage *end,
guint property_id,
double progress);
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
void _gtk_css_image_draw (GtkCssImage *image,
cairo_t *cr,
double width,
double height);
snapshot: Add infrastructure to snapshot CSS images Use this infrastructure to render builtin images. Which means from now on, GtkCheckbutton, GtkSpinner and a few others use snapshots.
2016-11-16 19:51:53 +00:00
void gtk_css_image_snapshot (GtkCssImage *image,
GtkSnapshot *snapshot,
double width,
double height);
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
gboolean gtk_css_image_is_invalid (GtkCssImage *image) G_GNUC_PURE;
gboolean gtk_css_image_is_dynamic (GtkCssImage *image) G_GNUC_PURE;
cssimage: Implement dynamic values No image actually implements it yet, but this is the plumbing.
2018-02-13 06:04:21 +00:00
GtkCssImage * gtk_css_image_get_dynamic_image (GtkCssImage *image,
gint64 monotonic_time);
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
void _gtk_css_image_print (GtkCssImage *image,
GString *string);
cssimage: Add gtk_css_image_to_string() In line with all the other _to_string() implementations
2020-01-24 10:21:38 +00:00
char * gtk_css_image_to_string (GtkCssImage *image);
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
void _gtk_css_image_get_concrete_size (GtkCssImage *image,
double specified_width,
double specified_height,
double default_width,
double default_height,
double *concrete_width,
double *concrete_height);
cssimage: Add a few convenience functions
2011-12-21 16:40:16 +00:00
cairo_surface_t *
css: Huge refactoring to avoid computing wrong values Here's the shortest description of the bug I can come up with: When computing values, we have 3 kinds of dependencies: (1) other properties ("currentColor" or em values) (2) inherited properties ("inherit") (3) generic things from the theme (@keyframes or @define-color) Previously, we passed the GtkStyleContext as an argument, because it provided these 3 things using: (1) _gtk_style_context_peek_property() (2) _gtk_style_context_peek_property(gtk_style_context_get_parent()) (3) context->priv->cascade However, this makes it impossible to lookup values other than the ones accessible via _gtk_style_context_peek_property(). And this is exactly what we are doing in gtk_style_context_update_cache(). So when the cache updates encountered case (1), they were looking up the values from the wrong style data. So this large patch essentially does nothing but replace the context argument in all compute functions with new arguments for the 3 cases above: (1) values (2) parent_values (3) provider We apparently have a lot of computing code.
2012-09-28 16:02:46 +00:00
_gtk_css_image_get_surface (GtkCssImage *image,
cairo_surface_t *target,
int surface_width,
int surface_height);
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
gboolean gtk_css_image_is_computed (GtkCssImage *image) G_GNUC_PURE;
cssimage: Add is_computed vfunc Same semantics as the is_computed field of GtkCssValue
2020-01-11 13:38:49 +00:00
css: Add GtkCssImage class Doesn't do anything yet, just exists.
2011-12-19 21:11:20 +00:00
G_END_DECLS
#endif /* __GTK_CSS_IMAGE_PRIVATE_H__ */
Reference in New Issue Copy Permalink