transform: Move to GSK

The renaming of the prefix makes this a large patch.

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
@@ -5868,38 +5868,6 @@ 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>
 GtkOrientable
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
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 (&GTK_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 (&GTK_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 (&GTK_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 (&GTK_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 (&GTK_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 (&GTK_IDENTITY_TRANSFORM_CLASS, NULL);
+  return gsk_transform_alloc (&GSK_IDENTITY_TRANSFORM_CLASS, NULL);
 }
diff --git a/gtk/gtktransform.h b/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
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 == &GTK_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