[gtk/wip/otte/transform: 27/41] transform: Move to GSK
- From: Benjamin Otte <otte src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/wip/otte/transform: 27/41] transform: Move to GSK
- Date: Mon, 4 Mar 2019 22:24:26 +0000 (UTC)
commit 0e1a50366a738389cce5d92b978ce0d07a5ab951
Author: Benjamin Otte <otte redhat com>
Date: Thu Feb 28 09:52:49 2019 +0100
transform: Move to GSK
The renaming of the prefix makes this a large patch.
docs/reference/gsk/gsk4-docs.xml | 1 +
docs/reference/gsk/gsk4-sections.txt | 33 ++
docs/reference/gtk/gtk4-docs.xml | 1 -
docs/reference/gtk/gtk4-sections.txt | 32 --
gsk/gsk.h | 1 +
gtk/gtktransform.c => gsk/gsktransform.c | 570 ++++++++++-----------
gtk/gtktransform.h => gsk/gsktransform.h | 69 ++-
.../gsktransformprivate.h | 14 +-
gsk/gsktypes.h | 1 +
gsk/meson.build | 4 +-
gtk/gtk.h | 1 -
gtk/gtkcsstransformvalue.c | 36 +-
gtk/gtkcsstransformvalueprivate.h | 2 +-
gtk/gtkrendericon.c | 10 +-
gtk/gtksnapshot.c | 38 +-
gtk/gtksnapshot.h | 2 +-
gtk/gtksnapshotprivate.h | 2 +-
gtk/gtktypes.h | 1 -
gtk/gtkwidget.c | 32 +-
gtk/gtkwidget.h | 2 +-
gtk/gtkwidgetprivate.h | 2 +-
gtk/meson.build | 2 -
tests/testwidgettransforms.c | 10 +-
23 files changed, 433 insertions(+), 433 deletions(-)
---
diff --git a/docs/reference/gsk/gsk4-docs.xml b/docs/reference/gsk/gsk4-docs.xml
index 329dc01dd2..8fcc239cfa 100644
--- a/docs/reference/gsk/gsk4-docs.xml
+++ b/docs/reference/gsk/gsk4-docs.xml
@@ -18,6 +18,7 @@
<title>API Reference</title>
<xi:include href="xml/GskRenderer.xml" />
<xi:include href="xml/GskRenderNode.xml" />
+ <xi:include href="xml/GskTransform.xml" />
</reference>
<index id="api-index-full">
diff --git a/docs/reference/gsk/gsk4-sections.txt b/docs/reference/gsk/gsk4-sections.txt
index af9b7a55a7..0b4b4e1de5 100644
--- a/docs/reference/gsk/gsk4-sections.txt
+++ b/docs/reference/gsk/gsk4-sections.txt
@@ -144,3 +144,36 @@ gsk_rounded_rect_contains_point
gsk_rounded_rect_contains_rect
gsk_rounded_rect_intersects_rect
</SECTION>
+
+<SECTION>
+<FILE>GskTransform</FILE>
+<TITLE>3D transformations</TITLE>
+GskTransformType
+GskTransform
+gsk_transform_ref
+gsk_transform_unref
+<SUBSECTION>
+gsk_transform_print
+gsk_transform_to_string
+gsk_transform_to_matrix
+<SUBSECTION>
+gsk_transform_identity
+gsk_transform_transform
+gsk_transform_matrix
+gsk_transform_translate
+gsk_transform_translate_3d
+gsk_transform_rotate
+gsk_transform_rotate_3d
+gsk_transform_scale
+gsk_transform_scale_3d
+<SUBSECTION>
+gsk_transform_equal
+<SUBSECTION>
+gsk_transform_get_transform_type
+gsk_transform_get_next
+<SUBSECTION Private>
+GSK_TYPE_TRANSFORM
+gsk_transform_get_type
+gsk_transform_new
+</SECTION>
+
diff --git a/docs/reference/gtk/gtk4-docs.xml b/docs/reference/gtk/gtk4-docs.xml
index d530df9878..37febf3d67 100644
--- a/docs/reference/gtk/gtk4-docs.xml
+++ b/docs/reference/gtk/gtk4-docs.xml
@@ -345,7 +345,6 @@
<xi:include href="xml/gtkselection.xml" />
<xi:include href="xml/gtktesting.xml" />
<xi:include href="xml/filesystem.xml" />
- <xi:include href="xml/gtktransform.xml" />
</part>
<part id="theming">
diff --git a/docs/reference/gtk/gtk4-sections.txt b/docs/reference/gtk/gtk4-sections.txt
index 7a7793f002..2b15df5708 100644
--- a/docs/reference/gtk/gtk4-sections.txt
+++ b/docs/reference/gtk/gtk4-sections.txt
@@ -5867,38 +5867,6 @@ gtk_mount_operation_get_type
GtkMountOperationPrivate
</SECTION>
-<SECTION>
-<FILE>gtktransform</FILE>
-<TITLE>3D transformations</TITLE>
-GtkTransformType
-GtkTransform
-gtk_transform_ref
-gtk_transform_unref
-<SUBSECTION>
-gtk_transform_print
-gtk_transform_to_string
-gtk_transform_to_matrix
-<SUBSECTION>
-gtk_transform_identity
-gtk_transform_transform
-gtk_transform_matrix
-gtk_transform_translate
-gtk_transform_translate_3d
-gtk_transform_rotate
-gtk_transform_rotate_3d
-gtk_transform_scale
-gtk_transform_scale_3d
-<SUBSECTION>
-gtk_transform_equal
-<SUBSECTION>
-gtk_transform_get_transform_type
-gtk_transform_get_next
-<SUBSECTION Private>
-GTK_TYPE_TRANSFORM
-gdk_transform_get_type
-gtk_transform_new
-</SECTION>
-
<SECTION>
<FILE>gtkorientable</FILE>
<TITLE>Orientable</TITLE>
diff --git a/gsk/gsk.h b/gsk/gsk.h
index 33fd9fb27c..88f312c210 100644
--- a/gsk/gsk.h
+++ b/gsk/gsk.h
@@ -24,6 +24,7 @@
#include <gsk/gskrenderer.h>
#include <gsk/gskrendernode.h>
#include <gsk/gskroundedrect.h>
+#include <gsk/gsktransform.h>
#include <gsk/gsktypes.h>
#include <gsk/gskenumtypes.h>
diff --git a/gtk/gtktransform.c b/gsk/gsktransform.c
similarity index 58%
rename from gtk/gtktransform.c
rename to gsk/gsktransform.c
index db15668d37..c7a3c72229 100644
--- a/gtk/gtktransform.c
+++ b/gsk/gsktransform.c
@@ -19,72 +19,72 @@
/**
- * SECTION:gtktransform
- * @Title: GtkTransform
+ * SECTION:gsktransform
+ * @Title: GskTransform
* @Short_description: A description for transform operations
*
- * #GtkTransform is an object to describe transform matrices. Unlike
- * #graphene_matrix_t, #GtkTransform retains the steps in how a transform was
+ * #GskTransform is an object to describe transform matrices. Unlike
+ * #graphene_matrix_t, #GskTransform retains the steps in how a transform was
* constructed, and allows inspecting them. It is modeled after the way
* CSS describes transforms.
*
- * #GtkTransform objects are immutable and cannot be changed after creation.
+ * #GskTransform objects are immutable and cannot be changed after creation.
* This means code can safely expose them as properties of objects without
* having to worry about others changing them.
*/
#include "config.h"
-#include "gtktransformprivate.h"
+#include "gsktransformprivate.h"
-typedef struct _GtkTransformClass GtkTransformClass;
+typedef struct _GskTransformClass GskTransformClass;
-#define GTK_IS_TRANSFORM_TYPE(self,type) ((self) == NULL ? (type) == GTK_TRANSFORM_TYPE_IDENTITY :
(self)->transform_class->transform_type == (type))
+#define GSK_IS_TRANSFORM_TYPE(self,type) ((self) == NULL ? (type) == GSK_TRANSFORM_TYPE_IDENTITY :
(self)->transform_class->transform_type == (type))
-struct _GtkTransform
+struct _GskTransform
{
- const GtkTransformClass *transform_class;
+ const GskTransformClass *transform_class;
volatile int ref_count;
- GtkTransform *next;
+ GskTransform *next;
};
-struct _GtkTransformClass
+struct _GskTransformClass
{
- GtkTransformType transform_type;
+ GskTransformType transform_type;
gsize struct_size;
const char *type_name;
- void (* finalize) (GtkTransform *transform);
- GskMatrixCategory (* categorize) (GtkTransform *transform);
- void (* to_matrix) (GtkTransform *transform,
+ void (* finalize) (GskTransform *transform);
+ GskMatrixCategory (* categorize) (GskTransform *transform);
+ void (* to_matrix) (GskTransform *transform,
graphene_matrix_t *out_matrix);
- gboolean (* apply_affine) (GtkTransform *transform,
+ gboolean (* apply_affine) (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
float *out_dy);
- void (* print) (GtkTransform *transform,
+ void (* print) (GskTransform *transform,
GString *string);
- GtkTransform * (* apply) (GtkTransform *transform,
- GtkTransform *apply_to);
+ GskTransform * (* apply) (GskTransform *transform,
+ GskTransform *apply_to);
/* both matrices have the same type */
- gboolean (* equal) (GtkTransform *first_transform,
- GtkTransform *second_transform);
+ gboolean (* equal) (GskTransform *first_transform,
+ GskTransform *second_transform);
};
/**
- * GtkTransform: (ref-func gtk_transform_ref) (unref-func gtk_transform_unref)
+ * GskTransform: (ref-func gsk_transform_ref) (unref-func gsk_transform_unref)
*
- * The `GtkTransform` structure contains only private data.
+ * The `GskTransform` structure contains only private data.
*/
-G_DEFINE_BOXED_TYPE (GtkTransform, gtk_transform,
- gtk_transform_ref,
- gtk_transform_unref)
+G_DEFINE_BOXED_TYPE (GskTransform, gsk_transform,
+ gsk_transform_ref,
+ gsk_transform_unref)
/*<private>
- * gtk_transform_is_identity:
+ * gsk_transform_is_identity:
* @transform: (allow-none): A transform or %NULL
*
* Checks if the transform is a representation of the identity
@@ -97,24 +97,24 @@ G_DEFINE_BOXED_TYPE (GtkTransform, gtk_transform,
* the identity transform
**/
static gboolean
-gtk_transform_is_identity (GtkTransform *self)
+gsk_transform_is_identity (GskTransform *self)
{
return self == NULL ||
- (GTK_IS_TRANSFORM_TYPE (self, GTK_TRANSFORM_TYPE_IDENTITY) && gtk_transform_is_identity
(self->next));
+ (GSK_IS_TRANSFORM_TYPE (self, GSK_TRANSFORM_TYPE_IDENTITY) && gsk_transform_is_identity
(self->next));
}
/*< private >
- * gtk_transform_alloc:
+ * gsk_transform_alloc:
* @transform_class: class structure for this self
* @next: (transfer full) Next matrix to multiply with or %NULL if none
*
- * Returns: (transfer full): the newly created #GtkTransform
+ * Returns: (transfer full): the newly created #GskTransform
*/
static gpointer
-gtk_transform_alloc (const GtkTransformClass *transform_class,
- GtkTransform *next)
+gsk_transform_alloc (const GskTransformClass *transform_class,
+ GskTransform *next)
{
- GtkTransform *self;
+ GskTransform *self;
g_return_val_if_fail (transform_class != NULL, NULL);
@@ -122,7 +122,7 @@ gtk_transform_alloc (const GtkTransformClass *transform_class,
self->transform_class = transform_class;
self->ref_count = 1;
- self->next = gtk_transform_is_identity (next) ? NULL : next;
+ self->next = gsk_transform_is_identity (next) ? NULL : next;
return self;
}
@@ -130,25 +130,25 @@ gtk_transform_alloc (const GtkTransformClass *transform_class,
/*** IDENTITY ***/
static void
-gtk_identity_transform_finalize (GtkTransform *transform)
+gsk_identity_transform_finalize (GskTransform *transform)
{
}
static GskMatrixCategory
-gtk_identity_transform_categorize (GtkTransform *transform)
+gsk_identity_transform_categorize (GskTransform *transform)
{
return GSK_MATRIX_CATEGORY_IDENTITY;
}
static void
-gtk_identity_transform_to_matrix (GtkTransform *transform,
+gsk_identity_transform_to_matrix (GskTransform *transform,
graphene_matrix_t *out_matrix)
{
graphene_matrix_init_identity (out_matrix);
}
static gboolean
-gtk_identity_transform_apply_affine (GtkTransform *transform,
+gsk_identity_transform_apply_affine (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
@@ -158,42 +158,42 @@ gtk_identity_transform_apply_affine (GtkTransform *transform,
}
static void
-gtk_identity_transform_print (GtkTransform *transform,
+gsk_identity_transform_print (GskTransform *transform,
GString *string)
{
g_string_append (string, "identity");
}
-static GtkTransform *
-gtk_identity_transform_apply (GtkTransform *transform,
- GtkTransform *apply_to)
+static GskTransform *
+gsk_identity_transform_apply (GskTransform *transform,
+ GskTransform *apply_to)
{
- return gtk_transform_identity (apply_to);
+ return gsk_transform_identity (apply_to);
}
static gboolean
-gtk_identity_transform_equal (GtkTransform *first_transform,
- GtkTransform *second_transform)
+gsk_identity_transform_equal (GskTransform *first_transform,
+ GskTransform *second_transform)
{
return TRUE;
}
-static const GtkTransformClass GTK_IDENTITY_TRANSFORM_CLASS =
-{
- GTK_TRANSFORM_TYPE_IDENTITY,
- sizeof (GtkTransform),
- "GtkIdentityMatrix",
- gtk_identity_transform_finalize,
- gtk_identity_transform_categorize,
- gtk_identity_transform_to_matrix,
- gtk_identity_transform_apply_affine,
- gtk_identity_transform_print,
- gtk_identity_transform_apply,
- gtk_identity_transform_equal,
+static const GskTransformClass GSK_IDENTITY_TRANSFORM_CLASS =
+{
+ GSK_TRANSFORM_TYPE_IDENTITY,
+ sizeof (GskTransform),
+ "GskIdentityMatrix",
+ gsk_identity_transform_finalize,
+ gsk_identity_transform_categorize,
+ gsk_identity_transform_to_matrix,
+ gsk_identity_transform_apply_affine,
+ gsk_identity_transform_print,
+ gsk_identity_transform_apply,
+ gsk_identity_transform_equal,
};
/**
- * gtk_transform_identity:
+ * gsk_transform_identity:
* @next: (allow-none): the next transform operation or %NULL
*
* Adds an identity multiplication into the list of matrix operations.
@@ -205,57 +205,57 @@ static const GtkTransformClass GTK_IDENTITY_TRANSFORM_CLASS =
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_identity (GtkTransform *next)
+GskTransform *
+gsk_transform_identity (GskTransform *next)
{
- if (gtk_transform_is_identity (next))
+ if (gsk_transform_is_identity (next))
return next;
- return gtk_transform_alloc (>K_IDENTITY_TRANSFORM_CLASS, next);
+ return gsk_transform_alloc (&GSK_IDENTITY_TRANSFORM_CLASS, next);
}
/*** MATRIX ***/
-typedef struct _GtkMatrixTransform GtkMatrixTransform;
+typedef struct _GskMatrixTransform GskMatrixTransform;
-struct _GtkMatrixTransform
+struct _GskMatrixTransform
{
- GtkTransform parent;
+ GskTransform parent;
graphene_matrix_t matrix;
GskMatrixCategory category;
};
static void
-gtk_matrix_transform_finalize (GtkTransform *self)
+gsk_matrix_transform_finalize (GskTransform *self)
{
}
static GskMatrixCategory
-gtk_matrix_transform_categorize (GtkTransform *transform)
+gsk_matrix_transform_categorize (GskTransform *transform)
{
- GtkMatrixTransform *self = (GtkMatrixTransform *) transform;
+ GskMatrixTransform *self = (GskMatrixTransform *) transform;
return self->category;
}
static void
-gtk_matrix_transform_to_matrix (GtkTransform *transform,
+gsk_matrix_transform_to_matrix (GskTransform *transform,
graphene_matrix_t *out_matrix)
{
- GtkMatrixTransform *self = (GtkMatrixTransform *) transform;
+ GskMatrixTransform *self = (GskMatrixTransform *) transform;
graphene_matrix_init_from_matrix (out_matrix, &self->matrix);
}
static gboolean
-gtk_matrix_transform_apply_affine (GtkTransform *transform,
+gsk_matrix_transform_apply_affine (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
float *out_dy)
{
- GtkMatrixTransform *self = (GtkMatrixTransform *) transform;
+ GskMatrixTransform *self = (GskMatrixTransform *) transform;
switch (self->category)
{
@@ -293,10 +293,10 @@ string_append_double (GString *string,
}
static void
-gtk_matrix_transform_print (GtkTransform *transform,
+gsk_matrix_transform_print (GskTransform *transform,
GString *string)
{
- GtkMatrixTransform *self = (GtkMatrixTransform *) transform;
+ GskMatrixTransform *self = (GskMatrixTransform *) transform;
guint i;
float f[16];
@@ -311,48 +311,48 @@ gtk_matrix_transform_print (GtkTransform *transform,
g_string_append (string, ")");
}
-static GtkTransform *
-gtk_matrix_transform_apply (GtkTransform *transform,
- GtkTransform *apply_to)
+static GskTransform *
+gsk_matrix_transform_apply (GskTransform *transform,
+ GskTransform *apply_to)
{
- GtkMatrixTransform *self = (GtkMatrixTransform *) transform;
+ GskMatrixTransform *self = (GskMatrixTransform *) transform;
- return gtk_transform_matrix_with_category (apply_to,
+ return gsk_transform_matrix_with_category (apply_to,
&self->matrix,
self->category);
}
static gboolean
-gtk_matrix_transform_equal (GtkTransform *first_transform,
- GtkTransform *second_transform)
+gsk_matrix_transform_equal (GskTransform *first_transform,
+ GskTransform *second_transform)
{
- GtkMatrixTransform *first = (GtkMatrixTransform *) first_transform;
- GtkMatrixTransform *second = (GtkMatrixTransform *) second_transform;
+ GskMatrixTransform *first = (GskMatrixTransform *) first_transform;
+ GskMatrixTransform *second = (GskMatrixTransform *) second_transform;
/* Crude, but better than just returning FALSE */
return memcmp (&first->matrix, &second->matrix, sizeof (graphene_matrix_t)) == 0;
}
-static const GtkTransformClass GTK_TRANSFORM_TRANSFORM_CLASS =
-{
- GTK_TRANSFORM_TYPE_TRANSFORM,
- sizeof (GtkMatrixTransform),
- "GtkMatrixTransform",
- gtk_matrix_transform_finalize,
- gtk_matrix_transform_categorize,
- gtk_matrix_transform_to_matrix,
- gtk_matrix_transform_apply_affine,
- gtk_matrix_transform_print,
- gtk_matrix_transform_apply,
- gtk_matrix_transform_equal,
+static const GskTransformClass GSK_TRANSFORM_TRANSFORM_CLASS =
+{
+ GSK_TRANSFORM_TYPE_TRANSFORM,
+ sizeof (GskMatrixTransform),
+ "GskMatrixTransform",
+ gsk_matrix_transform_finalize,
+ gsk_matrix_transform_categorize,
+ gsk_matrix_transform_to_matrix,
+ gsk_matrix_transform_apply_affine,
+ gsk_matrix_transform_print,
+ gsk_matrix_transform_apply,
+ gsk_matrix_transform_equal,
};
-GtkTransform *
-gtk_transform_matrix_with_category (GtkTransform *next,
+GskTransform *
+gsk_transform_matrix_with_category (GskTransform *next,
const graphene_matrix_t *matrix,
GskMatrixCategory category)
{
- GtkMatrixTransform *result = gtk_transform_alloc (>K_TRANSFORM_TRANSFORM_CLASS, next);
+ GskMatrixTransform *result = gsk_transform_alloc (&GSK_TRANSFORM_TRANSFORM_CLASS, next);
graphene_matrix_init_from_matrix (&result->matrix, matrix);
result->category = category;
@@ -361,7 +361,7 @@ gtk_transform_matrix_with_category (GtkTransform *next,
}
/**
- * gtk_transform_matrix:
+ * gsk_transform_matrix:
* @next: (allow-none): the next transform
* @matrix: the matrix to multiply @next with
*
@@ -369,33 +369,33 @@ gtk_transform_matrix_with_category (GtkTransform *next,
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_matrix (GtkTransform *next,
+GskTransform *
+gsk_transform_matrix (GskTransform *next,
const graphene_matrix_t *matrix)
{
- return gtk_transform_matrix_with_category (next, matrix, GSK_MATRIX_CATEGORY_UNKNOWN);
+ return gsk_transform_matrix_with_category (next, matrix, GSK_MATRIX_CATEGORY_UNKNOWN);
}
/*** TRANSLATE ***/
-typedef struct _GtkTranslateTransform GtkTranslateTransform;
+typedef struct _GskTranslateTransform GskTranslateTransform;
-struct _GtkTranslateTransform
+struct _GskTranslateTransform
{
- GtkTransform parent;
+ GskTransform parent;
graphene_point3d_t point;
};
static void
-gtk_translate_transform_finalize (GtkTransform *self)
+gsk_translate_transform_finalize (GskTransform *self)
{
}
static GskMatrixCategory
-gtk_translate_transform_categorize (GtkTransform *transform)
+gsk_translate_transform_categorize (GskTransform *transform)
{
- GtkTranslateTransform *self = (GtkTranslateTransform *) transform;
+ GskTranslateTransform *self = (GskTranslateTransform *) transform;
if (self->point.z != 0.0)
return GSK_MATRIX_CATEGORY_INVERTIBLE;
@@ -404,22 +404,22 @@ gtk_translate_transform_categorize (GtkTransform *transform)
}
static void
-gtk_translate_transform_to_matrix (GtkTransform *transform,
+gsk_translate_transform_to_matrix (GskTransform *transform,
graphene_matrix_t *out_matrix)
{
- GtkTranslateTransform *self = (GtkTranslateTransform *) transform;
+ GskTranslateTransform *self = (GskTranslateTransform *) transform;
graphene_matrix_init_translate (out_matrix, &self->point);
}
static gboolean
-gtk_translate_transform_apply_affine (GtkTransform *transform,
+gsk_translate_transform_apply_affine (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
float *out_dy)
{
- GtkTranslateTransform *self = (GtkTranslateTransform *) transform;
+ GskTranslateTransform *self = (GskTranslateTransform *) transform;
if (self->point.z != 0.0)
return FALSE;
@@ -430,30 +430,30 @@ gtk_translate_transform_apply_affine (GtkTransform *transform,
return TRUE;
}
-static GtkTransform *
-gtk_translate_transform_apply (GtkTransform *transform,
- GtkTransform *apply_to)
+static GskTransform *
+gsk_translate_transform_apply (GskTransform *transform,
+ GskTransform *apply_to)
{
- GtkTranslateTransform *self = (GtkTranslateTransform *) transform;
+ GskTranslateTransform *self = (GskTranslateTransform *) transform;
- return gtk_transform_translate_3d (apply_to, &self->point);
+ return gsk_transform_translate_3d (apply_to, &self->point);
}
static gboolean
-gtk_translate_transform_equal (GtkTransform *first_transform,
- GtkTransform *second_transform)
+gsk_translate_transform_equal (GskTransform *first_transform,
+ GskTransform *second_transform)
{
- GtkTranslateTransform *first = (GtkTranslateTransform *) first_transform;
- GtkTranslateTransform *second = (GtkTranslateTransform *) second_transform;
+ GskTranslateTransform *first = (GskTranslateTransform *) first_transform;
+ GskTranslateTransform *second = (GskTranslateTransform *) second_transform;
return graphene_point3d_equal (&first->point, &second->point);
}
static void
-gtk_translate_transform_print (GtkTransform *transform,
+gsk_translate_transform_print (GskTransform *transform,
GString *string)
{
- GtkTranslateTransform *self = (GtkTranslateTransform *) transform;
+ GskTranslateTransform *self = (GskTranslateTransform *) transform;
if (self->point.z == 0)
g_string_append (string, "translate(");
@@ -471,22 +471,22 @@ gtk_translate_transform_print (GtkTransform *transform,
g_string_append (string, ")");
}
-static const GtkTransformClass GTK_TRANSLATE_TRANSFORM_CLASS =
-{
- GTK_TRANSFORM_TYPE_TRANSLATE,
- sizeof (GtkTranslateTransform),
- "GtkTranslateTransform",
- gtk_translate_transform_finalize,
- gtk_translate_transform_categorize,
- gtk_translate_transform_to_matrix,
- gtk_translate_transform_apply_affine,
- gtk_translate_transform_print,
- gtk_translate_transform_apply,
- gtk_translate_transform_equal,
+static const GskTransformClass GSK_TRANSLATE_TRANSFORM_CLASS =
+{
+ GSK_TRANSFORM_TYPE_TRANSLATE,
+ sizeof (GskTranslateTransform),
+ "GskTranslateTransform",
+ gsk_translate_transform_finalize,
+ gsk_translate_transform_categorize,
+ gsk_translate_transform_to_matrix,
+ gsk_translate_transform_apply_affine,
+ gsk_translate_transform_print,
+ gsk_translate_transform_apply,
+ gsk_translate_transform_equal,
};
/**
- * gtk_transform_translate:
+ * gsk_transform_translate:
* @next: (allow-none): the next transform
* @point: the point to translate the matrix by
*
@@ -494,19 +494,19 @@ static const GtkTransformClass GTK_TRANSLATE_TRANSFORM_CLASS =
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_translate (GtkTransform *next,
+GskTransform *
+gsk_transform_translate (GskTransform *next,
const graphene_point_t *point)
{
graphene_point3d_t point3d;
graphene_point3d_init (&point3d, point->x, point->y, 0);
- return gtk_transform_translate_3d (next, &point3d);
+ return gsk_transform_translate_3d (next, &point3d);
}
/**
- * gtk_transform_translate_3d:
+ * gsk_transform_translate_3d:
* @next: (allow-none): the next transform
* @point: the point to translate the matrix by
*
@@ -514,11 +514,11 @@ gtk_transform_translate (GtkTransform *next,
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_translate_3d (GtkTransform *next,
+GskTransform *
+gsk_transform_translate_3d (GskTransform *next,
const graphene_point3d_t *point)
{
- GtkTranslateTransform *result = gtk_transform_alloc (>K_TRANSLATE_TRANSFORM_CLASS, next);
+ GskTranslateTransform *result = gsk_transform_alloc (&GSK_TRANSLATE_TRANSFORM_CLASS, next);
graphene_point3d_init_from_point (&result->point, point);
@@ -527,38 +527,38 @@ gtk_transform_translate_3d (GtkTransform *next,
/*** ROTATE ***/
-typedef struct _GtkRotateTransform GtkRotateTransform;
+typedef struct _GskRotateTransform GskRotateTransform;
-struct _GtkRotateTransform
+struct _GskRotateTransform
{
- GtkTransform parent;
+ GskTransform parent;
float angle;
graphene_vec3_t axis;
};
static void
-gtk_rotate_transform_finalize (GtkTransform *self)
+gsk_rotate_transform_finalize (GskTransform *self)
{
}
static GskMatrixCategory
-gtk_rotate_transform_categorize (GtkTransform *transform)
+gsk_rotate_transform_categorize (GskTransform *transform)
{
return GSK_MATRIX_CATEGORY_INVERTIBLE;
}
static void
-gtk_rotate_transform_to_matrix (GtkTransform *transform,
+gsk_rotate_transform_to_matrix (GskTransform *transform,
graphene_matrix_t *out_matrix)
{
- GtkRotateTransform *self = (GtkRotateTransform *) transform;
+ GskRotateTransform *self = (GskRotateTransform *) transform;
graphene_matrix_init_rotate (out_matrix, self->angle, &self->axis);
}
static gboolean
-gtk_rotate_transform_apply_affine (GtkTransform *transform,
+gsk_rotate_transform_apply_affine (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
@@ -567,31 +567,31 @@ gtk_rotate_transform_apply_affine (GtkTransform *transform,
return FALSE;
}
-static GtkTransform *
-gtk_rotate_transform_apply (GtkTransform *transform,
- GtkTransform *apply_to)
+static GskTransform *
+gsk_rotate_transform_apply (GskTransform *transform,
+ GskTransform *apply_to)
{
- GtkRotateTransform *self = (GtkRotateTransform *) transform;
+ GskRotateTransform *self = (GskRotateTransform *) transform;
- return gtk_transform_rotate_3d (apply_to, self->angle, &self->axis);
+ return gsk_transform_rotate_3d (apply_to, self->angle, &self->axis);
}
static gboolean
-gtk_rotate_transform_equal (GtkTransform *first_transform,
- GtkTransform *second_transform)
+gsk_rotate_transform_equal (GskTransform *first_transform,
+ GskTransform *second_transform)
{
- GtkRotateTransform *first = (GtkRotateTransform *) first_transform;
- GtkRotateTransform *second = (GtkRotateTransform *) second_transform;
+ GskRotateTransform *first = (GskRotateTransform *) first_transform;
+ GskRotateTransform *second = (GskRotateTransform *) second_transform;
return first->angle == second->angle
&& graphene_vec3_equal (&first->axis, &second->axis);
}
static void
-gtk_rotate_transform_print (GtkTransform *transform,
+gsk_rotate_transform_print (GskTransform *transform,
GString *string)
{
- GtkRotateTransform *self = (GtkRotateTransform *) transform;
+ GskRotateTransform *self = (GskRotateTransform *) transform;
graphene_vec3_t default_axis;
graphene_vec3_init_from_vec3 (&default_axis, graphene_vec3_z_axis ());
@@ -618,22 +618,22 @@ gtk_rotate_transform_print (GtkTransform *transform,
}
}
-static const GtkTransformClass GTK_ROTATE_TRANSFORM_CLASS =
-{
- GTK_TRANSFORM_TYPE_ROTATE,
- sizeof (GtkRotateTransform),
- "GtkRotateTransform",
- gtk_rotate_transform_finalize,
- gtk_rotate_transform_categorize,
- gtk_rotate_transform_to_matrix,
- gtk_rotate_transform_apply_affine,
- gtk_rotate_transform_print,
- gtk_rotate_transform_apply,
- gtk_rotate_transform_equal,
+static const GskTransformClass GSK_ROTATE_TRANSFORM_CLASS =
+{
+ GSK_TRANSFORM_TYPE_ROTATE,
+ sizeof (GskRotateTransform),
+ "GskRotateTransform",
+ gsk_rotate_transform_finalize,
+ gsk_rotate_transform_categorize,
+ gsk_rotate_transform_to_matrix,
+ gsk_rotate_transform_apply_affine,
+ gsk_rotate_transform_print,
+ gsk_rotate_transform_apply,
+ gsk_rotate_transform_equal,
};
/**
- * gtk_transform_rotate:
+ * gsk_transform_rotate:
* @next: (allow-none): the next transform
* @angle: the rotation angle, in degrees (clockwise)
*
@@ -641,31 +641,31 @@ static const GtkTransformClass GTK_ROTATE_TRANSFORM_CLASS =
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_rotate (GtkTransform *next,
+GskTransform *
+gsk_transform_rotate (GskTransform *next,
float angle)
{
- return gtk_transform_rotate_3d (next, angle, graphene_vec3_z_axis ());
+ return gsk_transform_rotate_3d (next, angle, graphene_vec3_z_axis ());
}
/**
- * gtk_transform_rotate_3d:
+ * gsk_transform_rotate_3d:
* @next: (allow-none): the next transform
* @angle: the rotation angle, in degrees (clockwise)
* @axis: The rotation axis
*
* Rotates @next @angle degrees around @axis.
*
- * For a rotation in 2D space, use gtk_transform_rotate().
+ * For a rotation in 2D space, use gsk_transform_rotate().
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_rotate_3d (GtkTransform *next,
+GskTransform *
+gsk_transform_rotate_3d (GskTransform *next,
float angle,
const graphene_vec3_t *axis)
{
- GtkRotateTransform *result = gtk_transform_alloc (>K_ROTATE_TRANSFORM_CLASS, next);
+ GskRotateTransform *result = gsk_transform_alloc (&GSK_ROTATE_TRANSFORM_CLASS, next);
result->angle = angle;
graphene_vec3_init_from_vec3 (&result->axis, axis);
@@ -675,11 +675,11 @@ gtk_transform_rotate_3d (GtkTransform *next,
/*** SCALE ***/
-typedef struct _GtkScaleTransform GtkScaleTransform;
+typedef struct _GskScaleTransform GskScaleTransform;
-struct _GtkScaleTransform
+struct _GskScaleTransform
{
- GtkTransform parent;
+ GskTransform parent;
float factor_x;
float factor_y;
@@ -687,14 +687,14 @@ struct _GtkScaleTransform
};
static void
-gtk_scale_transform_finalize (GtkTransform *self)
+gsk_scale_transform_finalize (GskTransform *self)
{
}
static GskMatrixCategory
-gtk_scale_transform_categorize (GtkTransform *transform)
+gsk_scale_transform_categorize (GskTransform *transform)
{
- GtkScaleTransform *self = (GtkScaleTransform *) transform;
+ GskScaleTransform *self = (GskScaleTransform *) transform;
if (self->factor_z != 1.0)
return GSK_MATRIX_CATEGORY_INVERTIBLE;
@@ -703,22 +703,22 @@ gtk_scale_transform_categorize (GtkTransform *transform)
}
static void
-gtk_scale_transform_to_matrix (GtkTransform *transform,
+gsk_scale_transform_to_matrix (GskTransform *transform,
graphene_matrix_t *out_matrix)
{
- GtkScaleTransform *self = (GtkScaleTransform *) transform;
+ GskScaleTransform *self = (GskScaleTransform *) transform;
graphene_matrix_init_scale (out_matrix, self->factor_x, self->factor_y, self->factor_z);
}
static gboolean
-gtk_scale_transform_apply_affine (GtkTransform *transform,
+gsk_scale_transform_apply_affine (GskTransform *transform,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
float *out_dy)
{
- GtkScaleTransform *self = (GtkScaleTransform *) transform;
+ GskScaleTransform *self = (GskScaleTransform *) transform;
if (self->factor_z != 1.0)
return FALSE;
@@ -729,21 +729,21 @@ gtk_scale_transform_apply_affine (GtkTransform *transform,
return TRUE;
}
-static GtkTransform *
-gtk_scale_transform_apply (GtkTransform *transform,
- GtkTransform *apply_to)
+static GskTransform *
+gsk_scale_transform_apply (GskTransform *transform,
+ GskTransform *apply_to)
{
- GtkScaleTransform *self = (GtkScaleTransform *) transform;
+ GskScaleTransform *self = (GskScaleTransform *) transform;
- return gtk_transform_scale_3d (apply_to, self->factor_x, self->factor_y, self->factor_z);
+ return gsk_transform_scale_3d (apply_to, self->factor_x, self->factor_y, self->factor_z);
}
static gboolean
-gtk_scale_transform_equal (GtkTransform *first_transform,
- GtkTransform *second_transform)
+gsk_scale_transform_equal (GskTransform *first_transform,
+ GskTransform *second_transform)
{
- GtkScaleTransform *first = (GtkScaleTransform *) first_transform;
- GtkScaleTransform *second = (GtkScaleTransform *) second_transform;
+ GskScaleTransform *first = (GskScaleTransform *) first_transform;
+ GskScaleTransform *second = (GskScaleTransform *) second_transform;
return first->factor_x == second->factor_x
&& first->factor_y == second->factor_y
@@ -751,10 +751,10 @@ gtk_scale_transform_equal (GtkTransform *first_transform,
}
static void
-gtk_scale_transform_print (GtkTransform *transform,
+gsk_scale_transform_print (GskTransform *transform,
GString *string)
{
- GtkScaleTransform *self = (GtkScaleTransform *) transform;
+ GskScaleTransform *self = (GskScaleTransform *) transform;
if (self->factor_z == 1.0)
{
@@ -779,41 +779,41 @@ gtk_scale_transform_print (GtkTransform *transform,
}
}
-static const GtkTransformClass GTK_SCALE_TRANSFORM_CLASS =
-{
- GTK_TRANSFORM_TYPE_SCALE,
- sizeof (GtkScaleTransform),
- "GtkScaleTransform",
- gtk_scale_transform_finalize,
- gtk_scale_transform_categorize,
- gtk_scale_transform_to_matrix,
- gtk_scale_transform_apply_affine,
- gtk_scale_transform_print,
- gtk_scale_transform_apply,
- gtk_scale_transform_equal,
+static const GskTransformClass GSK_SCALE_TRANSFORM_CLASS =
+{
+ GSK_TRANSFORM_TYPE_SCALE,
+ sizeof (GskScaleTransform),
+ "GskScaleTransform",
+ gsk_scale_transform_finalize,
+ gsk_scale_transform_categorize,
+ gsk_scale_transform_to_matrix,
+ gsk_scale_transform_apply_affine,
+ gsk_scale_transform_print,
+ gsk_scale_transform_apply,
+ gsk_scale_transform_equal,
};
/**
- * gtk_transform_scale:
+ * gsk_transform_scale:
* @next: (allow-none): the next transform
* @factor_x: scaling factor on the X axis
* @factor_y: scaling factor on the Y axis
*
* Scales @next in 2-dimensional space by the given factors.
- * Use gtk_transform_scale_3d() to scale in all 3 dimensions.
+ * Use gsk_transform_scale_3d() to scale in all 3 dimensions.
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_scale (GtkTransform *next,
+GskTransform *
+gsk_transform_scale (GskTransform *next,
float factor_x,
float factor_y)
{
- return gtk_transform_scale_3d (next, factor_x, factor_y, 1.0);
+ return gsk_transform_scale_3d (next, factor_x, factor_y, 1.0);
}
/**
- * gtk_transform_scale_3d:
+ * gsk_transform_scale_3d:
* @next: (allow-none): the next transform
* @factor_x: scaling factor on the X axis
* @factor_y: scaling factor on the Y axis
@@ -823,13 +823,13 @@ gtk_transform_scale (GtkTransform *next,
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_scale_3d (GtkTransform *next,
+GskTransform *
+gsk_transform_scale_3d (GskTransform *next,
float factor_x,
float factor_y,
float factor_z)
{
- GtkScaleTransform *result = gtk_transform_alloc (>K_SCALE_TRANSFORM_CLASS, next);
+ GskScaleTransform *result = gsk_transform_alloc (&GSK_SCALE_TRANSFORM_CLASS, next);
result->factor_x = factor_x;
result->factor_y = factor_y;
@@ -841,25 +841,25 @@ gtk_transform_scale_3d (GtkTransform *next,
/*** PUBLIC API ***/
static void
-gtk_transform_finalize (GtkTransform *self)
+gsk_transform_finalize (GskTransform *self)
{
self->transform_class->finalize (self);
- gtk_transform_unref (self->next);
+ gsk_transform_unref (self->next);
g_free (self);
}
/**
- * gtk_transform_ref:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_ref:
+ * @self: (allow-none): a #GskTransform
*
- * Acquires a reference on the given #GtkTransform.
+ * Acquires a reference on the given #GskTransform.
*
- * Returns: (transfer none): the #GtkTransform with an additional reference
+ * Returns: (transfer none): the #GskTransform with an additional reference
*/
-GtkTransform *
-gtk_transform_ref (GtkTransform *self)
+GskTransform *
+gsk_transform_ref (GskTransform *self)
{
if (self == NULL)
return NULL;
@@ -870,34 +870,34 @@ gtk_transform_ref (GtkTransform *self)
}
/**
- * gtk_transform_unref:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_unref:
+ * @self: (allow-none): a #GskTransform
*
- * Releases a reference on the given #GtkTransform.
+ * Releases a reference on the given #GskTransform.
*
* If the reference was the last, the resources associated to the @self are
* freed.
*/
void
-gtk_transform_unref (GtkTransform *self)
+gsk_transform_unref (GskTransform *self)
{
if (self == NULL)
return;
if (g_atomic_int_dec_and_test (&self->ref_count))
- gtk_transform_finalize (self);
+ gsk_transform_finalize (self);
}
/**
- * gtk_transform_print:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_print:
+ * @self: (allow-none): a #GskTransform
* @string: The string to print into
*
* Converts @self into a string representation suitable for printing that
- * can later be parsed with gtk_transform_parse().
+ * can later be parsed with gsk_transform_parse().
**/
void
-gtk_transform_print (GtkTransform *self,
+gsk_transform_print (GskTransform *self,
GString *string)
{
g_return_if_fail (string != NULL);
@@ -910,7 +910,7 @@ gtk_transform_print (GtkTransform *self,
if (self->next != NULL)
{
- gtk_transform_print (self->next, string);
+ gsk_transform_print (self->next, string);
g_string_append (string, " ");
}
@@ -918,57 +918,57 @@ gtk_transform_print (GtkTransform *self,
}
/**
- * gtk_transform_to_string:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_to_string:
+ * @self: (allow-none): a #GskTransform
*
* Converts a matrix into a string that is suitable for
- * printing and can later be parsed with gtk_transform_parse().
+ * printing and can later be parsed with gsk_transform_parse().
*
- * This is a wrapper around gtk_transform_print(), see that function
+ * This is a wrapper around gsk_transform_print(), see that function
* for details.
*
* Returns: A new string for @self
**/
char *
-gtk_transform_to_string (GtkTransform *self)
+gsk_transform_to_string (GskTransform *self)
{
GString *string;
string = g_string_new ("");
- gtk_transform_print (self, string);
+ gsk_transform_print (self, string);
return g_string_free (string, FALSE);
}
/**
- * gtk_transform_get_transform_type:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_get_transform_type:
+ * @self: (allow-none): a #GskTransform
*
* Returns the type of the @self.
*
- * Returns: the type of the #GtkTransform
+ * Returns: the type of the #GskTransform
*/
-GtkTransformType
-gtk_transform_get_transform_type (GtkTransform *self)
+GskTransformType
+gsk_transform_get_transform_type (GskTransform *self)
{
if (self == NULL)
- return GTK_TRANSFORM_TYPE_IDENTITY;
+ return GSK_TRANSFORM_TYPE_IDENTITY;
return self->transform_class->transform_type;
}
/**
- * gtk_transform_get_next:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_get_next:
+ * @self: (allow-none): a #GskTransform
*
* Gets the rest of the matrix in the chain of operations.
*
* Returns: (transfer none) (nullable): The next transform or
* %NULL if this was the last operation.
**/
-GtkTransform *
-gtk_transform_get_next (GtkTransform *self)
+GskTransform *
+gsk_transform_get_next (GskTransform *self)
{
if (self == NULL)
return NULL;
@@ -977,15 +977,15 @@ gtk_transform_get_next (GtkTransform *self)
}
/**
- * gtk_transform_to_matrix:
- * @self: (allow-none): a #GtkTransform
+ * gsk_transform_to_matrix:
+ * @self: (allow-none): a #GskTransform
* @out_matrix: (out caller-allocates): The matrix to set
*
* Computes the actual value of @self and stores it in @out_matrix.
* The previous value of @out_matrix will be ignored.
**/
void
-gtk_transform_to_matrix (GtkTransform *self,
+gsk_transform_to_matrix (GskTransform *self,
graphene_matrix_t *out_matrix)
{
graphene_matrix_t m;
@@ -996,13 +996,13 @@ gtk_transform_to_matrix (GtkTransform *self,
return;
}
- gtk_transform_to_matrix (self->next, out_matrix);
+ gsk_transform_to_matrix (self->next, out_matrix);
self->transform_class->to_matrix (self, &m);
graphene_matrix_multiply (&m, out_matrix, out_matrix);
}
gboolean
-gtk_transform_to_affine (GtkTransform *self,
+gsk_transform_to_affine (GskTransform *self,
float *out_scale_x,
float *out_scale_y,
float *out_dx,
@@ -1017,7 +1017,7 @@ gtk_transform_to_affine (GtkTransform *self,
return TRUE;
}
- if (!gtk_transform_to_affine (self->next,
+ if (!gsk_transform_to_affine (self->next,
out_scale_x, out_scale_y,
out_dx, out_dy))
return FALSE;
@@ -1028,7 +1028,7 @@ gtk_transform_to_affine (GtkTransform *self,
}
/**
- * gtk_transform_transform:
+ * gsk_transform_transform:
* @next: (allow-none) (transfer full): Transform to apply @other to
* @other: (allow-none): Transform to apply
*
@@ -1036,31 +1036,31 @@ gtk_transform_to_affine (GtkTransform *self,
*
* Returns: The new matrix
**/
-GtkTransform *
-gtk_transform_transform (GtkTransform *next,
- GtkTransform *other)
+GskTransform *
+gsk_transform_transform (GskTransform *next,
+ GskTransform *other)
{
if (other == NULL)
return next;
- next = gtk_transform_transform (next, other->next);
+ next = gsk_transform_transform (next, other->next);
return other->transform_class->apply (other, next);
}
/**
- * gtk_transform_equal:
+ * gsk_transform_equal:
* @first: the first matrix
* @second: the second matrix
*
* Checks two matrices for equality. Note that matrices need to be literally
* identical in their operations, it is not enough that they return the
- * same result in gtk_transform_to_matrix().
+ * same result in gsk_transform_to_matrix().
*
* Returns: %TRUE if the two matrices can be proven to be equal
**/
gboolean
-gtk_transform_equal (GtkTransform *first,
- GtkTransform *second)
+gsk_transform_equal (GskTransform *first,
+ GskTransform *second)
{
if (first == second)
return TRUE;
@@ -1068,7 +1068,7 @@ gtk_transform_equal (GtkTransform *first,
if (first == NULL || second == NULL)
return FALSE;
- if (!gtk_transform_equal (first->next, second->next))
+ if (!gsk_transform_equal (first->next, second->next))
return FALSE;
if (first->transform_class != second->transform_class)
@@ -1078,7 +1078,7 @@ gtk_transform_equal (GtkTransform *first,
}
/*<private>
- * gtk_transform_categorize:
+ * gsk_transform_categorize:
* @self: (allow-none): A matrix
*
*
@@ -1086,28 +1086,28 @@ gtk_transform_equal (GtkTransform *first,
* Returns: The category this matrix belongs to
**/
GskMatrixCategory
-gtk_transform_categorize (GtkTransform *self)
+gsk_transform_categorize (GskTransform *self)
{
if (self == NULL)
return GSK_MATRIX_CATEGORY_IDENTITY;
- return MIN (gtk_transform_categorize (self->next),
+ return MIN (gsk_transform_categorize (self->next),
self->transform_class->categorize (self));
}
/*
- * gtk_transform_new: (constructor):
+ * gsk_transform_new: (constructor):
*
* Creates a new identity matrix. This function is meant to be used by language
* bindings. For C code, this equivalent to using %NULL.
*
- * See also gtk_transform_identity() for inserting identity matrix operations
+ * See also gsk_transform_identity() for inserting identity matrix operations
* when constructing matrices.
*
* Returns: A new identity matrix
**/
-GtkTransform *
-gtk_transform_new (void)
+GskTransform *
+gsk_transform_new (void)
{
- return gtk_transform_alloc (>K_IDENTITY_TRANSFORM_CLASS, NULL);
+ return gsk_transform_alloc (&GSK_IDENTITY_TRANSFORM_CLASS, NULL);
}
diff --git a/gtk/gtktransform.h b/gsk/gsktransform.h
similarity index 52%
rename from gtk/gtktransform.h
rename to gsk/gsktransform.h
index b62b044978..b8393aca60 100644
--- a/gtk/gtktransform.h
+++ b/gsk/gsktransform.h
@@ -18,87 +18,86 @@
*/
-#ifndef __GTK_TRANSFORM_H__
-#define __GTK_TRANSFORM_H__
+#ifndef __GSK_TRANSFORM_H__
+#define __GSK_TRANSFORM_H__
-#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gtk/gtk.h> can be included directly."
+#if !defined (__GSK_H_INSIDE__) && !defined (GSK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
#endif
-#include <graphene.h>
-#include <gtk/gtktypes.h>
+#include <gsk/gsktypes.h>
G_BEGIN_DECLS
-#define GTK_TYPE_MATRIX (gtk_transform_get_type ())
+#define GSK_TYPE_TRANSFORM (gsk_transform_get_type ())
typedef enum
{
- GTK_TRANSFORM_TYPE_IDENTITY,
- GTK_TRANSFORM_TYPE_TRANSFORM,
- GTK_TRANSFORM_TYPE_TRANSLATE,
- GTK_TRANSFORM_TYPE_ROTATE,
- GTK_TRANSFORM_TYPE_SCALE
-} GtkTransformType;
+ GSK_TRANSFORM_TYPE_IDENTITY,
+ GSK_TRANSFORM_TYPE_TRANSFORM,
+ GSK_TRANSFORM_TYPE_TRANSLATE,
+ GSK_TRANSFORM_TYPE_ROTATE,
+ GSK_TRANSFORM_TYPE_SCALE
+} GskTransformType;
GDK_AVAILABLE_IN_ALL
-GType gtk_transform_get_type (void) G_GNUC_CONST;
+GType gsk_transform_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_ref (GtkTransform *self);
+GskTransform * gsk_transform_ref (GskTransform *self);
GDK_AVAILABLE_IN_ALL
-void gtk_transform_unref (GtkTransform *self);
+void gsk_transform_unref (GskTransform *self);
GDK_AVAILABLE_IN_ALL
-void gtk_transform_print (GtkTransform *self,
+void gsk_transform_print (GskTransform *self,
GString *string);
GDK_AVAILABLE_IN_ALL
-char * gtk_transform_to_string (GtkTransform *self);
+char * gsk_transform_to_string (GskTransform *self);
GDK_AVAILABLE_IN_ALL
-void gtk_transform_to_matrix (GtkTransform *self,
+void gsk_transform_to_matrix (GskTransform *self,
graphene_matrix_t *out_matrix);
GDK_AVAILABLE_IN_ALL
-gboolean gtk_transform_equal (GtkTransform *first,
- GtkTransform *second)
G_GNUC_PURE;
+gboolean gsk_transform_equal (GskTransform *first,
+ GskTransform *second)
G_GNUC_PURE;
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_new (void);
+GskTransform * gsk_transform_new (void);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_identity (GtkTransform *next);
+GskTransform * gsk_transform_identity (GskTransform *next);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_transform (GtkTransform *next,
- GtkTransform *other);
+GskTransform * gsk_transform_transform (GskTransform *next,
+ GskTransform *other);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_matrix (GtkTransform *next,
+GskTransform * gsk_transform_matrix (GskTransform *next,
const graphene_matrix_t *matrix);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_translate (GtkTransform *next,
+GskTransform * gsk_transform_translate (GskTransform *next,
const graphene_point_t *point);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_translate_3d (GtkTransform *next,
+GskTransform * gsk_transform_translate_3d (GskTransform *next,
const graphene_point3d_t *point);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_rotate (GtkTransform *next,
+GskTransform * gsk_transform_rotate (GskTransform *next,
float angle);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_rotate_3d (GtkTransform *next,
+GskTransform * gsk_transform_rotate_3d (GskTransform *next,
float angle,
const graphene_vec3_t *axis);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_scale (GtkTransform *next,
+GskTransform * gsk_transform_scale (GskTransform *next,
float factor_x,
float factor_y);
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_scale_3d (GtkTransform *next,
+GskTransform * gsk_transform_scale_3d (GskTransform *next,
float factor_x,
float factor_y,
float factor_z);
GDK_AVAILABLE_IN_ALL
-GtkTransformType gtk_transform_get_transform_type (GtkTransform *self)
G_GNUC_PURE;
+GskTransformType gsk_transform_get_transform_type (GskTransform *self)
G_GNUC_PURE;
GDK_AVAILABLE_IN_ALL
-GtkTransform * gtk_transform_get_next (GtkTransform *self)
G_GNUC_PURE;
+GskTransform * gsk_transform_get_next (GskTransform *self)
G_GNUC_PURE;
G_END_DECLS
-#endif /* __GTK_TRANSFORM_H__ */
+#endif /* __GSK_TRANSFORM_H__ */
diff --git a/gtk/gtktransformprivate.h b/gsk/gsktransformprivate.h
similarity index 77%
rename from gtk/gtktransformprivate.h
rename to gsk/gsktransformprivate.h
index 5aef0b001d..68eacaf786 100644
--- a/gtk/gtktransformprivate.h
+++ b/gsk/gsktransformprivate.h
@@ -18,29 +18,29 @@
*/
-#ifndef __GTK_TRANSFORM_PRIVATE_H__
-#define __GTK_TRANSFORM_PRIVATE_H__
+#ifndef __GSK_TRANSFORM_PRIVATE_H__
+#define __GSK_TRANSFORM_PRIVATE_H__
-#include "gtktransform.h"
+#include "gsktransform.h"
#include <gsk/gsk.h>
#include "gsk/gskrendernodeprivate.h"
G_BEGIN_DECLS
-GskMatrixCategory gtk_transform_categorize (GtkTransform *self);
+GskMatrixCategory gsk_transform_categorize (GskTransform *self);
-gboolean gtk_transform_to_affine (GtkTransform *self,
+gboolean gsk_transform_to_affine (GskTransform *self,
float *scale_x,
float *scale_y,
float *dx,
float *dy)
G_GNUC_WARN_UNUSED_RESULT;
-GtkTransform * gtk_transform_matrix_with_category (GtkTransform *next,
+GskTransform * gsk_transform_matrix_with_category (GskTransform *next,
const graphene_matrix_t*matrix,
GskMatrixCategory category);
G_END_DECLS
-#endif /* __GTK_TRANSFORM_PRIVATE_H__ */
+#endif /* __GSK_TRANSFORM_PRIVATE_H__ */
diff --git a/gsk/gsktypes.h b/gsk/gsktypes.h
index eae1591dad..2afe720c93 100644
--- a/gsk/gsktypes.h
+++ b/gsk/gsktypes.h
@@ -27,5 +27,6 @@
#include <gsk/gskenums.h>
typedef struct _GskRenderer GskRenderer;
+typedef struct _GskTransform GskTransform;
#endif /* __GSK_TYPES_H__ */
diff --git a/gsk/meson.build b/gsk/meson.build
index 46c578454b..e4b4ca46b7 100644
--- a/gsk/meson.build
+++ b/gsk/meson.build
@@ -24,7 +24,8 @@ gsk_public_sources = files([
'gskrenderer.c',
'gskrendernode.c',
'gskrendernodeimpl.c',
- 'gskroundedrect.c'
+ 'gskroundedrect.c',
+ 'gsktransform.c',
])
gsk_private_sources = files([
@@ -49,6 +50,7 @@ gsk_public_headers = files([
'gskrenderer.h',
'gskrendernode.h',
'gskroundedrect.h',
+ 'gsktransform.h',
'gsktypes.h',
'gsk-autocleanup.h'
])
diff --git a/gtk/gtk.h b/gtk/gtk.h
index 62a3bb3d7f..34fff24a3f 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -228,7 +228,6 @@
#include <gtk/gtktoolshell.h>
#include <gtk/gtktooltip.h>
#include <gtk/gtktestutils.h>
-#include <gtk/gtktransform.h>
#include <gtk/gtktreednd.h>
#include <gtk/gtktreelistmodel.h>
#include <gtk/gtktreemodel.h>
diff --git a/gtk/gtkcsstransformvalue.c b/gtk/gtkcsstransformvalue.c
index 5868627025..83aadfcf37 100644
--- a/gtk/gtkcsstransformvalue.c
+++ b/gtk/gtkcsstransformvalue.c
@@ -23,7 +23,7 @@
#include <string.h>
#include "gtkcssnumbervalueprivate.h"
-#include "gtktransform.h"
+#include "gsktransform.h"
typedef union _GtkCssTransform GtkCssTransform;
@@ -161,19 +161,19 @@ gtk_css_transform_init_identity (GtkCssTransform *transform,
transform->type = type;
}
-static GtkTransform *
+static GskTransform *
gtk_css_transform_apply (const GtkCssTransform *transform,
- GtkTransform *next)
+ GskTransform *next)
{
graphene_matrix_t skew;
switch (transform->type)
{
case GTK_CSS_TRANSFORM_MATRIX:
- return gtk_transform_matrix (next, &transform->matrix.matrix);
+ return gsk_transform_matrix (next, &transform->matrix.matrix);
case GTK_CSS_TRANSFORM_TRANSLATE:
- return gtk_transform_translate_3d (next,
+ return gsk_transform_translate_3d (next,
&GRAPHENE_POINT3D_INIT (
_gtk_css_number_value_get (transform->translate.x, 100),
_gtk_css_number_value_get (transform->translate.y, 100),
@@ -188,13 +188,13 @@ gtk_css_transform_apply (const GtkCssTransform *transform,
_gtk_css_number_value_get (transform->rotate.x, 1),
_gtk_css_number_value_get (transform->rotate.y, 1),
_gtk_css_number_value_get (transform->rotate.z, 1));
- return gtk_transform_rotate_3d (next,
+ return gsk_transform_rotate_3d (next,
_gtk_css_number_value_get (transform->rotate.angle, 100),
&axis);
}
case GTK_CSS_TRANSFORM_SCALE:
- return gtk_transform_scale_3d (next,
+ return gsk_transform_scale_3d (next,
_gtk_css_number_value_get (transform->scale.x, 1),
_gtk_css_number_value_get (transform->scale.y, 1),
_gtk_css_number_value_get (transform->scale.z, 1));
@@ -203,19 +203,19 @@ gtk_css_transform_apply (const GtkCssTransform *transform,
graphene_matrix_init_skew (&skew,
_gtk_css_number_value_get (transform->skew.x, 100) / 180.0f * G_PI,
_gtk_css_number_value_get (transform->skew.y, 100) / 180.0f * G_PI);
- return gtk_transform_matrix (next, &skew);
+ return gsk_transform_matrix (next, &skew);
case GTK_CSS_TRANSFORM_SKEW_X:
graphene_matrix_init_skew (&skew,
_gtk_css_number_value_get (transform->skew_x.skew, 100) / 180.0f * G_PI,
0);
- return gtk_transform_matrix (next, &skew);
+ return gsk_transform_matrix (next, &skew);
case GTK_CSS_TRANSFORM_SKEW_Y:
graphene_matrix_init_skew (&skew,
0,
_gtk_css_number_value_get (transform->skew_y.skew, 100) / 180.0f * G_PI);
- return gtk_transform_matrix (next, &skew);
+ return gsk_transform_matrix (next, &skew);
case GTK_CSS_TRANSFORM_NONE:
default:
@@ -225,10 +225,10 @@ gtk_css_transform_apply (const GtkCssTransform *transform,
}
/* NB: The returned matrix may be invalid */
-static GtkTransform *
+static GskTransform *
gtk_css_transform_value_compute_transform (const GtkCssValue *value)
{
- GtkTransform *transform;
+ GskTransform *transform;
guint i;
transform = NULL;
@@ -512,16 +512,16 @@ gtk_css_value_transform_transition (GtkCssValue *start,
{
if (start->transforms[i].type != end->transforms[i].type)
{
- GtkTransform *transform;
+ GskTransform *transform;
graphene_matrix_t start_matrix, end_matrix;
transform = gtk_css_transform_value_compute_transform (start);
- gtk_transform_to_matrix (transform, &start_matrix);
- gtk_transform_unref (transform);
+ gsk_transform_to_matrix (transform, &start_matrix);
+ gsk_transform_unref (transform);
transform = gtk_css_transform_value_compute_transform (end);
- gtk_transform_to_matrix (transform, &end_matrix);
- gtk_transform_unref (transform);
+ gsk_transform_to_matrix (transform, &end_matrix);
+ gsk_transform_unref (transform);
result = gtk_css_transform_value_alloc (1);
result->transforms[0].type = GTK_CSS_TRANSFORM_MATRIX;
@@ -1098,7 +1098,7 @@ _gtk_css_transform_value_parse (GtkCssParser *parser)
return value;
}
-GtkTransform *
+GskTransform *
gtk_css_transform_value_get_transform (const GtkCssValue *transform)
{
g_return_val_if_fail (transform->class == >K_CSS_VALUE_TRANSFORM, FALSE);
diff --git a/gtk/gtkcsstransformvalueprivate.h b/gtk/gtkcsstransformvalueprivate.h
index 77114cd6b4..143dd87868 100644
--- a/gtk/gtkcsstransformvalueprivate.h
+++ b/gtk/gtkcsstransformvalueprivate.h
@@ -28,7 +28,7 @@ G_BEGIN_DECLS
GtkCssValue * _gtk_css_transform_value_new_none (void);
GtkCssValue * _gtk_css_transform_value_parse (GtkCssParser *parser);
-GtkTransform * gtk_css_transform_value_get_transform (const GtkCssValue *transform);
+GskTransform * gtk_css_transform_value_get_transform (const GtkCssValue *transform);
G_END_DECLS
diff --git a/gtk/gtkrendericon.c b/gtk/gtkrendericon.c
index df855a853c..aa2368b4ab 100644
--- a/gtk/gtkrendericon.c
+++ b/gtk/gtkrendericon.c
@@ -29,7 +29,7 @@
#include "gtkcsstransformvalueprivate.h"
#include "gtkiconthemeprivate.h"
#include "gtksnapshot.h"
-#include "gtktransform.h"
+#include "gsktransform.h"
#include <math.h>
@@ -41,7 +41,7 @@ gtk_css_style_snapshot_icon (GtkCssStyle *style,
GtkCssImageBuiltinType builtin_type)
{
const GtkCssValue *shadows_value, *transform_value, *filter_value;
- GtkTransform *transform;
+ GskTransform *transform;
GtkCssImage *image;
gboolean has_shadow;
@@ -92,7 +92,7 @@ gtk_css_style_snapshot_icon (GtkCssStyle *style,
gtk_snapshot_pop (snapshot);
- gtk_transform_unref (transform);
+ gsk_transform_unref (transform);
}
void
@@ -104,7 +104,7 @@ gtk_css_style_snapshot_icon_paintable (GtkCssStyle *style,
gboolean recolor)
{
const GtkCssValue *shadows_value, *transform_value, *filter_value;
- GtkTransform *transform;
+ GskTransform *transform;
gboolean has_shadow;
g_return_if_fail (GTK_IS_CSS_STYLE (style));
@@ -172,5 +172,5 @@ gtk_css_style_snapshot_icon_paintable (GtkCssStyle *style,
transparent:
gtk_css_filter_value_pop_snapshot (filter_value, snapshot);
- gtk_transform_unref (transform);
+ gsk_transform_unref (transform);
}
diff --git a/gtk/gtksnapshot.c b/gtk/gtksnapshot.c
index 0f2973d4a3..89ed04af6f 100644
--- a/gtk/gtksnapshot.c
+++ b/gtk/gtksnapshot.c
@@ -28,7 +28,7 @@
#include "gtkrendericonprivate.h"
#include "gtkrendernodepaintableprivate.h"
#include "gtkstylecontextprivate.h"
-#include "gtktransformprivate.h"
+#include "gsktransformprivate.h"
#include "gsk/gskrendernodeprivate.h"
@@ -109,7 +109,7 @@ gtk_snapshot_collect_default (GtkSnapshot *snapshot,
static GtkSnapshotState *
gtk_snapshot_push_state (GtkSnapshot *snapshot,
- GtkTransform *transform,
+ GskTransform *transform,
GtkSnapshotCollectFunc collect_func)
{
const gsize n_states = snapshot->state_stack->len;
@@ -118,7 +118,7 @@ gtk_snapshot_push_state (GtkSnapshot *snapshot,
g_array_set_size (snapshot->state_stack, n_states + 1);
state = &g_array_index (snapshot->state_stack, GtkSnapshotState, n_states);
- state->transform = gtk_transform_ref (transform);
+ state->transform = gsk_transform_ref (transform);
state->collect_func = collect_func;
state->start_node_index = snapshot->nodes->len;
state->n_nodes = 0;
@@ -145,7 +145,7 @@ gtk_snapshot_get_previous_state (const GtkSnapshot *snapshot)
static void
gtk_snapshot_state_clear (GtkSnapshotState *state)
{
- gtk_transform_unref (state->transform);
+ gsk_transform_unref (state->transform);
}
/**
@@ -268,8 +268,8 @@ gtk_snapshot_autopush_transform (GtkSnapshot *snapshot)
previous_state = gtk_snapshot_get_previous_state (snapshot);
- gtk_transform_to_matrix (previous_state->transform, &state->data.transform.transform);
- state->data.transform.category = gtk_transform_categorize (previous_state->transform);
+ gsk_transform_to_matrix (previous_state->transform, &state->data.transform.transform);
+ state->data.transform.category = gsk_transform_categorize (previous_state->transform);
}
static gboolean
@@ -584,7 +584,7 @@ gtk_snapshot_ensure_affine (GtkSnapshot *snapshot,
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
- if (gtk_transform_to_affine (current_state->transform, scale_x, scale_y, dx, dy))
+ if (gsk_transform_to_affine (current_state->transform, scale_x, scale_y, dx, dy))
return;
gtk_snapshot_autopush_transform (snapshot);
@@ -601,7 +601,7 @@ gtk_snapshot_ensure_translate (GtkSnapshot *snapshot,
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
float scale_x, scale_y;
- if (gtk_transform_to_affine (current_state->transform, &scale_x, &scale_y, dx, dy) &&
+ if (gsk_transform_to_affine (current_state->transform, &scale_x, &scale_y, dx, dy) &&
scale_x == 1.0f && scale_y == 1.0f)
return;
@@ -1244,14 +1244,14 @@ gtk_snapshot_restore (GtkSnapshot *snapshot)
**/
void
gtk_snapshot_transform (GtkSnapshot *snapshot,
- GtkTransform *transform)
+ GskTransform *transform)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_transform (state->transform, transform);
+ state->transform = gsk_transform_transform (state->transform, transform);
}
/**
@@ -1271,7 +1271,7 @@ gtk_snapshot_transform_matrix (GtkSnapshot *snapshot,
g_return_if_fail (matrix != NULL);
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_matrix (state->transform, matrix);
+ state->transform = gsk_transform_matrix (state->transform, matrix);
}
void
@@ -1285,7 +1285,7 @@ gtk_snapshot_transform_matrix_with_category (GtkSnapshot *snapshot,
g_return_if_fail (matrix != NULL);
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_matrix_with_category (state->transform, matrix, category);
+ state->transform = gsk_transform_matrix_with_category (state->transform, matrix, category);
}
/**
@@ -1305,7 +1305,7 @@ gtk_snapshot_translate (GtkSnapshot *snapshot,
g_return_if_fail (point != NULL);
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_translate (state->transform, point);
+ state->transform = gsk_transform_translate (state->transform, point);
}
/**
@@ -1325,7 +1325,7 @@ gtk_snapshot_translate_3d (GtkSnapshot *snapshot,
g_return_if_fail (point != NULL);
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_translate_3d (state->transform, point);
+ state->transform = gsk_transform_translate_3d (state->transform, point);
}
/**
@@ -1345,7 +1345,7 @@ gtk_snapshot_rotate (GtkSnapshot *snapshot,
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_rotate (state->transform, angle);
+ state->transform = gsk_transform_rotate (state->transform, angle);
}
/**
@@ -1356,7 +1356,7 @@ gtk_snapshot_rotate (GtkSnapshot *snapshot,
*
* Rotates @snapshot's coordinate system by @angle degrees around @axis.
*
- * For a rotation in 2D space, use gtk_transform_rotate().
+ * For a rotation in 2D space, use gsk_transform_rotate().
*/
void
gtk_snapshot_rotate_3d (GtkSnapshot *snapshot,
@@ -1369,7 +1369,7 @@ gtk_snapshot_rotate_3d (GtkSnapshot *snapshot,
g_return_if_fail (axis != NULL);
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_rotate_3d (state->transform, angle, axis);
+ state->transform = gsk_transform_rotate_3d (state->transform, angle, axis);
}
/**
@@ -1393,7 +1393,7 @@ gtk_snapshot_scale (GtkSnapshot *snapshot,
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_scale (state->transform, factor_x, factor_y);
+ state->transform = gsk_transform_scale (state->transform, factor_x, factor_y);
}
/**
@@ -1416,7 +1416,7 @@ gtk_snapshot_scale_3d (GtkSnapshot *snapshot,
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
- state->transform = gtk_transform_scale_3d (state->transform, factor_x, factor_y, factor_z);
+ state->transform = gsk_transform_scale_3d (state->transform, factor_x, factor_y, factor_z);
}
void
diff --git a/gtk/gtksnapshot.h b/gtk/gtksnapshot.h
index 162addf28e..d0e8dd9a4f 100644
--- a/gtk/gtksnapshot.h
+++ b/gtk/gtksnapshot.h
@@ -107,7 +107,7 @@ GDK_AVAILABLE_IN_ALL
void gtk_snapshot_restore (GtkSnapshot *snapshot);
GDK_AVAILABLE_IN_ALL
void gtk_snapshot_transform (GtkSnapshot *snapshot,
- GtkTransform *transform);
+ GskTransform *transform);
GDK_AVAILABLE_IN_ALL
void gtk_snapshot_transform_matrix (GtkSnapshot *snapshot,
const graphene_matrix_t*matrix);
diff --git a/gtk/gtksnapshotprivate.h b/gtk/gtksnapshotprivate.h
index f43f6a3c5d..7853803067 100644
--- a/gtk/gtksnapshotprivate.h
+++ b/gtk/gtksnapshotprivate.h
@@ -35,7 +35,7 @@ struct _GtkSnapshotState {
guint start_node_index;
guint n_nodes;
- GtkTransform * transform;
+ GskTransform * transform;
GtkSnapshotCollectFunc collect_func;
union {
diff --git a/gtk/gtktypes.h b/gtk/gtktypes.h
index 9876bed3a5..5d1218f189 100644
--- a/gtk/gtktypes.h
+++ b/gtk/gtktypes.h
@@ -45,7 +45,6 @@ typedef struct _GtkSettings GtkSettings;
typedef GdkSnapshot GtkSnapshot;
typedef struct _GtkStyleContext GtkStyleContext;
typedef struct _GtkTooltip GtkTooltip;
-typedef struct _GtkTransform GtkTransform;
typedef struct _GtkWidget GtkWidget;
typedef struct _GtkWidgetPath GtkWidgetPath;
typedef struct _GtkWindow GtkWindow;
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 56f26387a9..c4eb7c51ec 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -62,7 +62,7 @@
#include "gtksnapshotprivate.h"
#include "gtkstylecontextprivate.h"
#include "gtktooltipprivate.h"
-#include "gtktransformprivate.h"
+#include "gsktransformprivate.h"
#include "gtktypebuiltins.h"
#include "gtkversion.h"
#include "gtkwidgetpaintableprivate.h"
@@ -4136,10 +4136,10 @@ gtk_widget_size_allocate (GtkWidget *widget,
const GtkAllocation *allocation,
int baseline)
{
- GtkTransform *transform;
+ GskTransform *transform;
if (allocation->x || allocation->y)
- transform = gtk_transform_translate (NULL, &GRAPHENE_POINT_INIT (allocation->x, allocation->y));
+ transform = gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (allocation->x, allocation->y));
else
transform = NULL;
@@ -4149,7 +4149,7 @@ gtk_widget_size_allocate (GtkWidget *widget,
baseline,
transform);
- gtk_transform_unref (transform);
+ gsk_transform_unref (transform);
}
/**
@@ -4174,7 +4174,7 @@ gtk_widget_allocate (GtkWidget *widget,
int width,
int height,
int baseline,
- GtkTransform *transform)
+ GskTransform *transform)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GdkRectangle adjusted;
@@ -4187,7 +4187,7 @@ gtk_widget_allocate (GtkWidget *widget,
GtkCssStyle *style;
GtkBorder margin, border, padding;
graphene_matrix_t transform_matrix;
- GtkTransform *css_transform;
+ GskTransform *css_transform;
#ifdef G_ENABLE_DEBUG
GdkDisplay *display;
#endif
@@ -4223,11 +4223,11 @@ gtk_widget_allocate (GtkWidget *widget,
baseline_changed = priv->allocated_size_baseline != baseline;
size_changed = (priv->allocated_width != width ||
priv->allocated_height != height);
- transform_changed = !gtk_transform_equal (priv->allocated_transform, transform);
+ transform_changed = !gsk_transform_equal (priv->allocated_transform, transform);
/* order is important, sometimes priv->allocated_transform == transform */
- gtk_transform_ref (transform);
- gtk_transform_unref (priv->allocated_transform);
+ gsk_transform_ref (transform);
+ gsk_transform_unref (priv->allocated_transform);
priv->allocated_transform = transform;
priv->allocated_width = width;
priv->allocated_height = height;
@@ -4308,12 +4308,12 @@ gtk_widget_allocate (GtkWidget *widget,
if (css_transform)
{
- transform = gtk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.x, adjusted.y));
+ transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.x, adjusted.y));
adjusted.x = adjusted.y = 0;
- transform = gtk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.width / 2,
adjusted.height / 2));
- transform = gtk_transform_transform (transform, css_transform);
- transform = gtk_transform_translate (transform, &GRAPHENE_POINT_INIT (- adjusted.width / 2, -
adjusted.height / 2));
+ transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (adjusted.width / 2,
adjusted.height / 2));
+ transform = gsk_transform_transform (transform, css_transform);
+ transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (- adjusted.width / 2, -
adjusted.height / 2));
}
get_box_margin (style, &margin);
@@ -4332,9 +4332,9 @@ gtk_widget_allocate (GtkWidget *widget,
baseline -= margin.top + border.top + padding.top;
graphene_matrix_init_translate (&priv->transform, &GRAPHENE_POINT3D_INIT (adjusted.x, adjusted.y, 0));
- gtk_transform_to_matrix (transform, &transform_matrix);
+ gsk_transform_to_matrix (transform, &transform_matrix);
graphene_matrix_multiply (&priv->transform, &transform_matrix, &priv->transform);
- priv->transform_category = gtk_transform_categorize (transform);
+ priv->transform_category = gsk_transform_categorize (transform);
if (adjusted.x || adjusted.y)
priv->transform_category = MIN (priv->transform_category, GSK_MATRIX_CATEGORY_2D_TRANSLATE);
@@ -6220,7 +6220,7 @@ _gtk_widget_set_visible_flag (GtkWidget *widget,
if (!visible)
{
- g_clear_pointer (&priv->allocated_transform, gtk_transform_unref);
+ g_clear_pointer (&priv->allocated_transform, gsk_transform_unref);
priv->allocated_width = 0;
priv->allocated_height = 0;
priv->allocated_size_baseline = 0;
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index db4a81272c..f3012b07a4 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -407,7 +407,7 @@ void gtk_widget_allocate (GtkWidget *widget,
int width,
int height,
int baseline,
- GtkTransform *transform);
+ GskTransform *transform);
GDK_AVAILABLE_IN_ALL
GtkSizeRequestMode gtk_widget_get_request_mode (GtkWidget *widget);
diff --git a/gtk/gtkwidgetprivate.h b/gtk/gtkwidgetprivate.h
index 49c4d19de0..569268ae2b 100644
--- a/gtk/gtkwidgetprivate.h
+++ b/gtk/gtkwidgetprivate.h
@@ -144,7 +144,7 @@ struct _GtkWidgetPrivate
GtkStyleContext *context;
/* The widget's allocated size */
- GtkTransform *allocated_transform;
+ GskTransform *allocated_transform;
int allocated_width;
int allocated_height;
gint allocated_size_baseline;
diff --git a/gtk/meson.build b/gtk/meson.build
index 2c705982a9..714c0eab65 100644
--- a/gtk/meson.build
+++ b/gtk/meson.build
@@ -375,7 +375,6 @@ gtk_public_sources = files([
'gtktoolshell.c',
'gtktooltip.c',
'gtktooltipwindow.c',
- 'gtktransform.c',
'gtktreednd.c',
'gtktreelistmodel.c',
'gtktreemenu.c',
@@ -606,7 +605,6 @@ gtk_public_headers = files([
'gtktoolitem.h',
'gtktoolshell.h',
'gtktooltip.h',
- 'gtktransform.h',
'gtktreednd.h',
'gtktreelistmodel.h',
'gtktreemodel.h',
diff --git a/tests/testwidgettransforms.c b/tests/testwidgettransforms.c
index 1c3048d886..1dd8d2c1ad 100644
--- a/tests/testwidgettransforms.c
+++ b/tests/testwidgettransforms.c
@@ -104,7 +104,7 @@ gtk_transform_tester_size_allocate (GtkWidget *widget,
int baseline)
{
GtkTransformTester *self = (GtkTransformTester *)widget;
- GtkTransform *global_transform;
+ GskTransform *global_transform;
int w, h;
if (!self->test_widget)
@@ -121,16 +121,16 @@ gtk_transform_tester_size_allocate (GtkWidget *widget,
global_transform = NULL;
- global_transform = gtk_transform_translate (global_transform, &GRAPHENE_POINT_INIT (width / 2.0f, height /
2.0f));
- global_transform = gtk_transform_rotate (global_transform, scale);
- global_transform = gtk_transform_translate (global_transform, &GRAPHENE_POINT_INIT (-w / 2.0f, -h / 2.0f));
+ global_transform = gsk_transform_translate (global_transform, &GRAPHENE_POINT_INIT (width / 2.0f, height /
2.0f));
+ global_transform = gsk_transform_rotate (global_transform, scale);
+ global_transform = gsk_transform_translate (global_transform, &GRAPHENE_POINT_INIT (-w / 2.0f, -h / 2.0f));
gtk_widget_allocate (self->test_widget,
w, h,
-1,
global_transform);
- gtk_transform_unref (global_transform);
+ gsk_transform_unref (global_transform);
}
static void
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
