Separate out CoglPath api into sub-library

This splits out the cogl_path_ api into a separate cogl-path sub-library
like cogl-pango and cogl-gst. This enables developers to build Cogl with
this sub-library disabled if they don't need it which can be useful when
its important to keep the size of an application and its dependencies
down to a minimum. The functions cogl_framebuffer_{fill,stroke}_path
have been renamed to cogl_path_{fill,stroke}.

There were a few places in core cogl and cogl-gst that referenced the
CoglPath api and these have been decoupled by using the CoglPrimitive
api instead. In the case of cogl_framebuffer_push_path_clip() the core
clip stack no longer accepts path clips directly but it's now possible
to get a CoglPrimitive for the fill of a path and so the implementation
of cogl_framebuffer_push_path_clip() now lives in cogl-path and works as
a shim that first gets a CoglPrimitive and uses
cogl_framebuffer_push_primitive_clip instead.

We may want to consider renaming cogl_framebuffer_push_path_clip to
put it in the cogl_path_ namespace.

Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit 8aadfd829239534fb4ec8255cdea813d698c5a3f)

So as to avoid breaking the 1.x API or even the ABI since we are quite
late in the 1.16 development cycle the patch was modified to build
cogl-path as a noinst_LTLIBRARY before building cogl and link the code
directly into libcogl.so as it was previously. This way we can wait
until the start of the 1.18 cycle before splitting the code into a
separate libcogl-path.so.

This also adds shims for cogl_framebuffer_fill/stroke_path() to avoid
breaking the 1.x API/ABI.

61 files changed, 735 insertions, 708 deletions

diff --git a/Makefile.am b/Makefile.am
index 308e66c2..e24041f9 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,4 +1,13 @@
-SUBDIRS = deps test-fixtures cogl tests
+SUBDIRS = deps test-fixtures
+
+# Until we can bump the cogl soname cogl-path is built as
+# a noinst_LTLIBRARY and linked into libcogl.so so it needs
+# to be built before cogl...
+if BUILD_COGL_PATH
+SUBDIRS += cogl-path
+endif
+
+SUBDIRS += cogl
 
 if BUILD_COGL_PANGO
 SUBDIRS += cogl-pango
@@ -12,7 +21,7 @@ if BUILD_COGL_GST
 SUBDIRS += cogl-gst
 endif
 
-SUBDIRS += examples doc po build
+SUBDIRS += tests examples doc po build
 
 ACLOCAL_AMFLAGS = -I build/autotools ${ACLOCAL_FLAGS}
 
diff --git a/cogl-pango/cogl-pango-display-list.c b/cogl-pango/cogl-pango-display-list.c
index e9bb684f..2b8c6ab2 100644
--- a/cogl-pango/cogl-pango-display-list.c
+++ b/cogl-pango/cogl-pango-display-list.c
@@ -30,6 +30,7 @@
 #include <string.h>
 
 #include "cogl-pango-display-list.h"
+#include "cogl-pango-pipeline-cache.h"
 #include "cogl/cogl-context-private.h"
 
 typedef enum
@@ -88,12 +89,7 @@ struct _CoglPangoDisplayListNode
 
     struct
     {
-      float y_1;
-      float x_11;
-      float x_21;
-      float y_2;
-      float x_12;
-      float x_22;
+      CoglPrimitive *primitive;
     } trapezoid;
   } d;
 };
@@ -219,19 +215,26 @@ _cogl_pango_display_list_add_trapezoid (CoglPangoDisplayList *dl,
                                         float x_12,
                                         float x_22)
 {
+  CoglContext *ctx = dl->pipeline_cache->ctx;
   CoglPangoDisplayListNode *node = g_slice_new (CoglPangoDisplayListNode);
+  CoglVertexP2 vertices[4] = {
+        { x_11, y_1 },
+        { x_12, y_2 },
+        { x_22, y_2 },
+        { x_21, y_1 }
+  };
 
   node->type = COGL_PANGO_DISPLAY_LIST_TRAPEZOID;
   node->color_override = dl->color_override;
   node->color = dl->color;
-  node->d.trapezoid.y_1 = y_1;
-  node->d.trapezoid.x_11 = x_11;
-  node->d.trapezoid.x_21 = x_21;
-  node->d.trapezoid.y_2 = y_2;
-  node->d.trapezoid.x_12 = x_12;
-  node->d.trapezoid.x_22 = x_22;
   node->pipeline = NULL;
 
+  node->d.trapezoid.primitive =
+    cogl_primitive_new_p2 (ctx,
+                           COGL_VERTICES_MODE_TRIANGLE_FAN,
+                           4,
+                           vertices);
+
   _cogl_pango_display_list_append_node (dl, node);
 }
 
@@ -448,25 +451,8 @@ _cogl_pango_display_list_render (CoglFramebuffer *fb,
           break;
 
         case COGL_PANGO_DISPLAY_LIST_TRAPEZOID:
-          {
-            float points[8];
-            CoglPath *path;
-            CoglContext *ctx = fb->context;
-
-            points[0] =  node->d.trapezoid.x_11;
-            points[1] =  node->d.trapezoid.y_1;
-            points[2] =  node->d.trapezoid.x_12;
-            points[3] =  node->d.trapezoid.y_2;
-            points[4] =  node->d.trapezoid.x_22;
-            points[5] =  node->d.trapezoid.y_2;
-            points[6] =  node->d.trapezoid.x_21;
-            points[7] =  node->d.trapezoid.y_1;
-
-            path = cogl_path_new ();
-            cogl_path_polygon (path, points, 4);
-            cogl_framebuffer_fill_path (fb, node->pipeline, path);
-            cogl_object_unref (path);
-          }
+          cogl_framebuffer_draw_primitive (fb, node->pipeline,
+                                           node->d.trapezoid.primitive);
           break;
         }
     }
@@ -483,6 +469,8 @@ _cogl_pango_display_list_node_free (CoglPangoDisplayListNode *node)
       if (node->d.texture.primitive != NULL)
         cogl_object_unref (node->d.texture.primitive);
     }
+  else if (node->type == COGL_PANGO_DISPLAY_LIST_TRAPEZOID)
+    cogl_object_unref (node->d.trapezoid.primitive);
 
   if (node->pipeline)
     cogl_object_unref (node->pipeline);
diff --git a/cogl-pango/cogl-pango-pipeline-cache.c b/cogl-pango/cogl-pango-pipeline-cache.c
index 11cbb64a..9aa32ad0 100644
--- a/cogl-pango/cogl-pango-pipeline-cache.c
+++ b/cogl-pango/cogl-pango-pipeline-cache.c
@@ -37,18 +37,6 @@
 
 typedef struct _CoglPangoPipelineCacheEntry CoglPangoPipelineCacheEntry;
 
-struct _CoglPangoPipelineCache
-{
-  CoglContext *ctx;
-
-  GHashTable *hash_table;
-
-  CoglPipeline *base_texture_alpha_pipeline;
-  CoglPipeline *base_texture_rgba_pipeline;
-
-  CoglBool use_mipmapping;
-};
-
 struct _CoglPangoPipelineCacheEntry
 {
   /* This will take a reference or it can be NULL to represent the
diff --git a/cogl-pango/cogl-pango-pipeline-cache.h b/cogl-pango/cogl-pango-pipeline-cache.h
index 615eaf99..411650bc 100644
--- a/cogl-pango/cogl-pango-pipeline-cache.h
+++ b/cogl-pango/cogl-pango-pipeline-cache.h
@@ -33,7 +33,18 @@
 
 COGL_BEGIN_DECLS
 
-typedef struct _CoglPangoPipelineCache CoglPangoPipelineCache;
+typedef struct _CoglPangoPipelineCache
+{
+  CoglContext *ctx;
+
+  GHashTable *hash_table;
+
+  CoglPipeline *base_texture_alpha_pipeline;
+  CoglPipeline *base_texture_rgba_pipeline;
+
+  CoglBool use_mipmapping;
+} CoglPangoPipelineCache;
+
 
 CoglPangoPipelineCache *
 _cogl_pango_pipeline_cache_new (CoglContext *ctx,
diff --git a/cogl-pango/cogl-pango-render.c b/cogl-pango/cogl-pango-render.c
index a5abaa64..082114dc 100644
--- a/cogl-pango/cogl-pango-render.c
+++ b/cogl-pango/cogl-pango-render.c
@@ -825,19 +825,9 @@ cogl_pango_renderer_draw_trapezoid (PangoRenderer   *renderer,
 				    double           x22)
 {
   CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
-  float points[8];
 
   _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
 
-  points[0] =  (x11);
-  points[1] =  (y1);
-  points[2] =  (x12);
-  points[3] =  (y2);
-  points[4] =  (x22);
-  points[5] = points[3];
-  points[6] =  (x21);
-  points[7] = points[1];
-
   cogl_pango_renderer_set_color_for_part (renderer, part);
 
   _cogl_pango_display_list_add_trapezoid (priv->display_list,
diff --git a/cogl-path/Makefile.am b/cogl-path/Makefile.am
new file mode 100644
index 00000000..8181b875
--- /dev/null
+++ b/cogl-path/Makefile.am
@@ -0,0 +1,92 @@
+include $(top_srcdir)/build/autotools/Makefile.am.silent
+
+NULL =
+
+BUILT_SOURCES =
+
+CLEANFILES =
+DISTCLEANFILES =
+
+EXTRA_DIST =
+
+# tesselator sources
+cogl_tesselator_sources = \
+	$(srcdir)/tesselator/dict-list.h 	\
+	$(srcdir)/tesselator/dict.c 		\
+	$(srcdir)/tesselator/dict.h 		\
+	$(srcdir)/tesselator/geom.c 		\
+	$(srcdir)/tesselator/geom.h 		\
+	$(srcdir)/tesselator/gluos.h 		\
+	$(srcdir)/tesselator/memalloc.h 	\
+	$(srcdir)/tesselator/mesh.c 		\
+	$(srcdir)/tesselator/mesh.h 		\
+	$(srcdir)/tesselator/normal.c 		\
+	$(srcdir)/tesselator/normal.h 		\
+	$(srcdir)/tesselator/priorityq-heap.h 	\
+	$(srcdir)/tesselator/priorityq-sort.h 	\
+	$(srcdir)/tesselator/priorityq.c 	\
+	$(srcdir)/tesselator/priorityq.h 	\
+	$(srcdir)/tesselator/render.c 		\
+	$(srcdir)/tesselator/render.h 		\
+	$(srcdir)/tesselator/sweep.c 		\
+	$(srcdir)/tesselator/sweep.h 		\
+	$(srcdir)/tesselator/tess.c 		\
+	$(srcdir)/tesselator/tess.h 		\
+	$(srcdir)/tesselator/tesselator.h 	\
+	$(srcdir)/tesselator/tessmono.c 	\
+	$(srcdir)/tesselator/tessmono.h 	\
+	$(srcdir)/tesselator/GL/glu.h 		\
+	$(NULL)
+
+source_c = \
+	$(cogl_tesselator_sources) \
+	cogl-path-private.h \
+	cogl1-path.c \
+	cogl-path.c \
+	$(NULL)
+
+EXTRA_DIST += \
+	$(srcdir)/tesselator/README 		\
+	$(srcdir)/tesselator/priorityq-heap.c	\
+	$(NULL)
+
+source_1_x_h = \
+	$(srcdir)/cogl-path-types.h \
+	$(srcdir)/cogl1-path-functions.h \
+	$(NULL)
+
+source_h = \
+	cogl-path.h \
+	$(source_1_x_h) \
+	cogl2-path-functions.h \
+	$(NULL)
+
+if USE_GLIB
+# glib-mkenums rules
+glib_enum_h = cogl-path-enum-types.h
+glib_enum_c = cogl-path-enum-types.c
+glib_enum_headers = $(source_1_x_h)
+include $(top_srcdir)/build/autotools/Makefile.am.enums
+endif
+
+noinst_LTLIBRARIES = libcogl-path.la
+
+libcogl_path_la_SOURCES = $(source_c) $(source_h)
+nodist_libcogl_path_la_SOURCES = $(BUILT_SOURCES)
+libcogl_path_la_CFLAGS = $(COGL_DEP_CFLAGS) $(COGL_GST_DEP_CFLAGS) $(COGL_EXTRA_CFLAGS) $(MAINTAINER_CFLAGS)
+
+AM_CPPFLAGS = \
+	-DCOGL_COMPILATION		\
+	-DG_LOG_DOMAIN=\"CoglPath\"	\
+	-I$(srcdir)/tesselator		\
+	-I$(top_srcdir)/cogl		\
+	-I$(top_builddir)/cogl		\
+	-I$(top_srcdir)/cogl/winsys	\
+	-I$(top_srcdir)			\
+	-I$(top_builddir)
+
+cogl_pathheadersdir = $(includedir)/cogl/cogl-path
+cogl_pathheaders_HEADERS = $(source_h)
+if USE_GLIB
+nodist_cogl_pathheaders_HEADERS = cogl-path-enum-types.h
+endif
diff --git a/cogl-path/cogl-path-1.0.pc.in b/cogl-path/cogl-path-1.0.pc.in
new file mode 100644
index 00000000..9cb7c972
--- /dev/null
+++ b/cogl-path/cogl-path-1.0.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+apiversion=1.0
+requires=@COGL_PKG_REQUIRES@ cogl-1.0
+
+Name: Cogl
+Description: A 2D path drawing library for Cogl
+Version: @COGL_1_VERSION@
+Libs: -L${libdir} -lcogl-path
+Cflags: -I${includedir}/cogl
+Requires: ${requires}
diff --git a/cogl-path/cogl-path-enum-types.c.in b/cogl-path/cogl-path-enum-types.c.in
new file mode 100644
index 00000000..54746076
--- /dev/null
+++ b/cogl-path/cogl-path-enum-types.c.in
@@ -0,0 +1,50 @@
+/*** BEGIN file-header ***/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+/* We need to undefine this so that we will be sure to include
+ * cogl-path.h instead of cogl2-path.h when we include the framebuffer
+ * header. Otherwise it will include both headers and it won't
+ * compile. */
+#undef COGL_ENABLE_EXPERIMENTAL_2_0_API
+
+#include "cogl-path-enum-types.h"
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+
+/* enumerations from "@filename@" */
+#include "@filename@"
+
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType
+@enum_name@_get_type (void)
+{
+  static volatile gsize g_enum_type_id__volatile = 0;
+
+  if (g_once_init_enter (&g_enum_type_id__volatile))
+    {
+      static const G@Type@Value values[] = {
+/*** END value-header ***/
+
+/*** BEGIN value-production ***/
+        { @VALUENAME@, "@VALUENAME@", "@valuenick@" },
+/*** END value-production ***/
+
+/*** BEGIN value-tail ***/
+        { 0, NULL, NULL }
+      };
+      GType g_enum_type_id;
+
+      g_enum_type_id =
+        g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
+
+      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
+    }
+
+  return g_enum_type_id__volatile;
+}
+/*** END value-tail ***/
diff --git a/cogl-path/cogl-path-enum-types.h.in b/cogl-path/cogl-path-enum-types.h.in
new file mode 100644
index 00000000..071686ac
--- /dev/null
+++ b/cogl-path/cogl-path-enum-types.h.in
@@ -0,0 +1,25 @@
+/*** BEGIN file-header ***/
+#ifndef __COGL_PATH_ENUM_TYPES_H__
+#define __COGL_PATH_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+/* enumerations from "@filename@" */
+/*** END file-production ***/
+
+/*** BEGIN file-tail ***/
+G_END_DECLS
+
+#endif /* __COGL_PATH_ENUM_TYPES_H__ */
+/*** END file-tail ***/
+
+/*** BEGIN value-header ***/
+GType @enum_name@_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
+
+/*** END value-header ***/
diff --git a/cogl/cogl-path-private.h b/cogl-path/cogl-path-private.h
index cc0b65c3..be863d4f 100644
--- a/cogl/cogl-path-private.h
+++ b/cogl-path/cogl-path-private.h
@@ -86,6 +86,7 @@ struct _CoglPathData
   CoglIndices         *fill_vbo_indices;
   unsigned int         fill_vbo_n_indices;
   CoglAttribute       *fill_attributes[COGL_PATH_N_ATTRIBUTES + 1];
+  CoglPrimitive       *fill_primitive;
 
   CoglAttributeBuffer *stroke_attribute_buffer;
   CoglAttribute      **stroke_attributes;
@@ -115,15 +116,4 @@ _cogl_path_get_bounds (CoglPath *path,
 CoglBool
 _cogl_path_is_rectangle (CoglPath *path);
 
-void
-_cogl_path_stroke_nodes (CoglPath *path,
-                         CoglFramebuffer *framebuffer,
-                         CoglPipeline *pipeline);
-
-void
-_cogl_path_fill_nodes (CoglPath *path,
-                       CoglFramebuffer *framebuffer,
-                       CoglPipeline *pipeline,
-                       CoglDrawFlags flags);
-
 #endif /* __COGL_PATH_PRIVATE_H */
diff --git a/cogl/cogl-path.h b/cogl-path/cogl-path-types.h
index e69466e2..697f687d 100644
--- a/cogl/cogl-path.h
+++ b/cogl-path/cogl-path-types.h
@@ -3,7 +3,7 @@
  *
  * An object oriented GL/GLES Abstraction/Utility Layer
  *
- * Copyright (C) 2008,2009 Intel Corporation.
+ * Copyright (C) 2008,2009,2013 Intel Corporation.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -16,7 +16,8 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
  *
  *
  */
@@ -25,32 +26,13 @@
 #error "Only <cogl/cogl.h> can be included directly."
 #endif
 
-#ifndef __COGL_PATH_H__
-#define __COGL_PATH_H__
+#ifndef __COGL_PATH_TYPES_H__
+#define __COGL_PATH_TYPES_H__
 
 #include <cogl/cogl-types.h>
 
 COGL_BEGIN_DECLS
 
-/**
- * SECTION:cogl-paths
- * @short_description: Functions for constructing and drawing 2D paths.
- *
- * There are two levels on which drawing with cogl-paths can be used.
- * The highest level functions construct various simple primitive
- * shapes to be either filled or stroked. Using a lower-level set of
- * functions more complex and arbitrary paths can be constructed by
- * concatenating straight line, bezier curve and arc segments.
- *
- * When constructing arbitrary paths, the current pen location is
- * initialized using the move_to command. The subsequent path segments
- * implicitly use the last pen location as their first vertex and move
- * the pen location to the last vertex they produce at the end. Also
- * there are special versions of functions that allow specifying the
- * vertices of the path segments relative to the last pen location
- * rather then in the absolute coordinates.
- */
-
 typedef struct _CoglPath CoglPath;
 
 #define COGL_PATH(obj) ((CoglPath *)(obj))
@@ -96,7 +78,4 @@ typedef enum {
 
 COGL_END_DECLS
 
-#include "cogl-path-functions.h"
-
-#endif /* __COGL_PATH_H__ */
-
+#endif /* __COGL_PATH_TYPES_H__ */
diff --git a/cogl/cogl2-path.c b/cogl-path/cogl-path.c
index 65350933..58146593 100644
--- a/cogl/cogl2-path.c
+++ b/cogl-path/cogl-path.c
@@ -3,7 +3,7 @@
  *
  * An object oriented GL/GLES Abstraction/Utility Layer
  *
- * Copyright (C) 2007,2008,2009,2010 Intel Corporation.
+ * Copyright (C) 2007,2008,2009,2010,2013 Intel Corporation.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -35,9 +35,8 @@
 #include "cogl-context-private.h"
 #include "cogl-journal-private.h"
 #include "cogl-pipeline-private.h"
-#include "cogl-pipeline-opengl-private.h"
 #include "cogl-framebuffer-private.h"
-#include "cogl-path-private.h"
+#include "cogl-primitive-private.h"
 #include "cogl-texture-private.h"
 #include "cogl-primitives-private.h"
 #include "cogl-private.h"
@@ -45,6 +44,9 @@
 #include "cogl1-context.h"
 #include "tesselator/tesselator.h"
 
+#include "cogl-path/cogl-path.h"
+#include "cogl-path-private.h"
+
 #include <string.h>
 #include <math.h>
 
@@ -53,6 +55,7 @@
 static void _cogl_path_free (CoglPath *path);
 
 static void _cogl_path_build_fill_attribute_buffer (CoglPath *path);
+static CoglPrimitive *_cogl_path_get_fill_primitive (CoglPath *path);
 static void _cogl_path_build_stroke_attribute_buffer (CoglPath *path);
 
 COGL_OBJECT_DEFINE (Path, path);
@@ -73,6 +76,12 @@ _cogl_path_data_clear_vbos (CoglPathData *data)
       data->fill_attribute_buffer = NULL;
     }
 
+  if (data->fill_primitive)
+    {
+      cogl_object_unref (data->fill_primitive);
+      data->fill_primitive = NULL;
+    }
+
   if (data->stroke_attribute_buffer)
     {
       cogl_object_unref (data->stroke_attribute_buffer);
@@ -119,6 +128,7 @@ _cogl_path_modify (CoglPath *path)
                            old_data->path_nodes->len);
 
       path->data->fill_attribute_buffer = NULL;
+      path->data->fill_primitive = NULL;
       path->data->stroke_attribute_buffer = NULL;
       path->data->ref_count = 1;
 
@@ -198,17 +208,23 @@ _cogl_path_add_node (CoglPath *path,
   data->is_rectangle = FALSE;
 }
 
-void
+static void
 _cogl_path_stroke_nodes (CoglPath *path,
                          CoglFramebuffer *framebuffer,
                          CoglPipeline *pipeline)
 {
-  CoglPathData *data = path->data;
+  CoglPathData *data;
   CoglPipeline *copy = NULL;
   unsigned int path_start;
   int path_num = 0;
   CoglPathNode *node;
 
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
+
+  data = path->data;
+
   if (data->path_nodes->len == 0)
     return;
 
@@ -318,7 +334,7 @@ validate_layer_cb (CoglPipelineLayer *layer, void *user_data)
   return !*needs_fallback;
 }
 
-void
+static void
 _cogl_path_fill_nodes (CoglPath *path,
                        CoglFramebuffer *framebuffer,
                        CoglPipeline *pipeline,
@@ -344,6 +360,7 @@ _cogl_path_fill_nodes (CoglPath *path,
   else
     {
       CoglBool needs_fallback = FALSE;
+      CoglPrimitive *primitive;
 
       _cogl_pipeline_foreach_layer_internal (pipeline,
                                              validate_layer_cb,
@@ -356,46 +373,31 @@ _cogl_path_fill_nodes (CoglPath *path,
           return;
         }
 
-      _cogl_path_build_fill_attribute_buffer (path);
-
-      _cogl_framebuffer_draw_indexed_attributes (framebuffer,
-                                                 pipeline,
-                                                 COGL_VERTICES_MODE_TRIANGLES,
-                                                 0, /* first_vertex */
-                                                 path->data->fill_vbo_n_indices,
-                                                 path->data->fill_vbo_indices,
-                                                 path->data->fill_attributes,
-                                                 COGL_PATH_N_ATTRIBUTES,
-                                                 flags);
+      primitive = _cogl_path_get_fill_primitive (path);
+
+      _cogl_primitive_draw (primitive, framebuffer, pipeline, flags);
     }
 }
 
+/* TODO: Update to the protoype used in the Cogl master branch.
+ * This is experimental API but not in sync with the cogl_path_fill()
+ * api in Cogl master which takes explicit framebuffer and pipeline
+ * arguments */
 void
 cogl2_path_fill (CoglPath *path)
 {
   _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
-  if (path->data->path_nodes->len == 0)
-    return;
-
-  /* If the path is a simple rectangle then we can divert to using
-     cogl_rectangle which should be faster because it can go through
-     the journal instead of uploading the geometry just for two
-     triangles */
-  if (path->data->is_rectangle)
-    {
-      float x_1, y_1, x_2, y_2;
-
-      _cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2);
-      cogl_rectangle (x_1, y_1, x_2, y_2);
-    }
-  else
-    _cogl_path_fill_nodes (path,
-                           cogl_get_draw_framebuffer (),
-                           cogl_get_source (),
-                           0);
+  _cogl_path_fill_nodes (path,
+                         cogl_get_draw_framebuffer (),
+                         cogl_get_source (),
+                         0 /* flags */);
 }
 
+/* TODO: Update to the protoype used in the Cogl master branch.
+ * This is experimental API but not in sync with the cogl_path_fill()
+ * api in Cogl master which takes explicit framebuffer and pipeline
+ * arguments */
 void
 cogl2_path_stroke (CoglPath *path)
 {
@@ -1412,6 +1414,95 @@ _cogl_path_build_fill_attribute_buffer (CoglPath *path)
   g_array_free (tess.indices, TRUE);
 }
 
+static CoglPrimitive *
+_cogl_path_get_fill_primitive (CoglPath *path)
+{
+  if (path->data->fill_primitive)
+    return path->data->fill_primitive;
+
+  _cogl_path_build_fill_attribute_buffer (path);
+
+  path->data->fill_primitive =
+    cogl_primitive_new_with_attributes (COGL_VERTICES_MODE_TRIANGLES,
+                                        path->data->fill_vbo_n_indices,
+                                        path->data->fill_attributes,
+                                        COGL_PATH_N_ATTRIBUTES);
+  cogl_primitive_set_indices (path->data->fill_primitive,
+                              path->data->fill_vbo_indices,
+                              path->data->fill_vbo_n_indices);
+
+  return path->data->fill_primitive;
+}
+
+static CoglClipStack *
+_cogl_clip_stack_push_from_path (CoglClipStack *stack,
+                                 CoglPath *path,
+                                 CoglMatrixEntry *modelview_entry,
+                                 CoglMatrixEntry *projection_entry,
+                                 const float *viewport)
+{
+  float x_1, y_1, x_2, y_2;
+
+  _cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2);
+
+  /* If the path is a simple rectangle then we can divert to pushing a
+     rectangle clip instead which usually won't involve the stencil
+     buffer */
+  if (_cogl_path_is_rectangle (path))
+    return _cogl_clip_stack_push_rectangle (stack,
+                                            x_1, y_1,
+                                            x_2, y_2,
+                                            modelview_entry,
+                                            projection_entry,
+                                            viewport);
+  else
+    {
+      return _cogl_clip_stack_push_primitive (stack,
+                                              path->data->fill_primitive,
+                                              x_1, y_1, x_2, y_2,
+                                              modelview_entry,
+                                              projection_entry,
+                                              viewport);
+    }
+}
+
+void
+cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
+                                 CoglPath *path)
+{
+  CoglClipState *clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
+  CoglMatrixEntry *modelview_entry =
+    _cogl_framebuffer_get_modelview_entry (framebuffer);
+  CoglMatrixEntry *projection_entry =
+    _cogl_framebuffer_get_projection_entry (framebuffer);
+  /* XXX: It would be nicer if we stored the private viewport as a
+   * vec4 so we could avoid this redundant copy. */
+  float viewport[] = {
+      framebuffer->viewport_x,
+      framebuffer->viewport_y,
+      framebuffer->viewport_width,
+      framebuffer->viewport_height
+  };
+
+  clip_state->stacks->data =
+    _cogl_clip_stack_push_from_path (clip_state->stacks->data,
+                                     path,
+                                     modelview_entry,
+                                     projection_entry,
+                                     viewport);
+
+  if (framebuffer->context->current_draw_buffer == framebuffer)
+    framebuffer->context->current_draw_buffer_changes |=
+      COGL_FRAMEBUFFER_STATE_CLIP;
+}
+
+/* XXX: deprecated */
+void
+cogl_clip_push_from_path (CoglPath *path)
+{
+  cogl_framebuffer_push_path_clip (cogl_get_draw_framebuffer (), path);
+}
+
 static void
 _cogl_path_build_stroke_attribute_buffer (CoglPath *path)
 {
@@ -1475,3 +1566,29 @@ _cogl_path_build_stroke_attribute_buffer (CoglPath *path)
 
   data->stroke_n_attributes = n_attributes;
 }
+
+/* XXX: deprecated */
+void
+cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
+                            CoglPipeline *pipeline,
+                            CoglPath *path)
+{
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
+
+  _cogl_path_fill_nodes (path, framebuffer, pipeline, 0 /* flags */);
+}
+
+/* XXX: deprecated */
+void
+cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
+                              CoglPipeline *pipeline,
+                              CoglPath *path)
+{
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
+
+  _cogl_path_stroke_nodes (path, framebuffer, pipeline);
+}
diff --git a/cogl-path/cogl-path.h b/cogl-path/cogl-path.h
new file mode 100644
index 00000000..2e760809
--- /dev/null
+++ b/cogl-path/cogl-path.h
@@ -0,0 +1,58 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,2013 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+#ifndef __COGL_PATH_H__
+#define __COGL_PATH_H__
+
+/**
+ * SECTION:cogl-paths
+ * @short_description: Functions for constructing and drawing 2D paths.
+ *
+ * There are two levels on which drawing with cogl-paths can be used.
+ * The highest level functions construct various simple primitive
+ * shapes to be either filled or stroked. Using a lower-level set of
+ * functions more complex and arbitrary paths can be constructed by
+ * concatenating straight line, bezier curve and arc segments.
+ *
+ * When constructing arbitrary paths, the current pen location is
+ * initialized using the move_to command. The subsequent path segments
+ * implicitly use the last pen location as their first vertex and move
+ * the pen location to the last vertex they produce at the end. Also
+ * there are special versions of functions that allow specifying the
+ * vertices of the path segments relative to the last pen location
+ * rather then in the absolute coordinates.
+ */
+
+#include <cogl-path/cogl-path-enum-types.h>
+
+#include <cogl-path/cogl-path-types.h>
+
+#ifdef COGL_ENABLE_EXPERIMENTAL_2_0_API
+#include <cogl-path/cogl2-path-functions.h>
+#else
+#include <cogl-path/cogl1-path-functions.h>
+#endif
+
+#endif /* __COGL_PATH_H__ */
+
diff --git a/cogl/cogl-path-functions.h b/cogl-path/cogl1-path-functions.h
index f953a03e..e3ea8656 100644
--- a/cogl/cogl-path-functions.h
+++ b/cogl-path/cogl1-path-functions.h
@@ -424,6 +424,36 @@ cogl_set_path (CoglPath *path);
 CoglPath *
 cogl_path_copy (CoglPath *path);
 
+/**
+ * cogl_clip_push_from_path_preserve:
+ *
+ * Sets a new clipping area using the current path. The current path
+ * is then cleared. The clipping area is intersected with the previous
+ * clipping area. To restore the previous clipping area, call
+ * cogl_clip_pop().
+ *
+ * Since: 1.0
+ * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
+ */
+void
+cogl_clip_push_from_path_preserve (void)
+     COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_path_clip);
+
+/**
+ * cogl_clip_push_from_path:
+ *
+ * Sets a new clipping area using the current path. The current path
+ * is then cleared. The clipping area is intersected with the previous
+ * clipping area. To restore the previous clipping area, call
+ * cogl_clip_pop().
+ *
+ * Since: 1.0
+ * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
+ */
+void
+cogl_clip_push_from_path (void)
+     COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_path_clip);
+
 COGL_END_DECLS
 
 #endif /* __COGL_PATH_FUNCTIONS_H__ */
diff --git a/cogl/cogl-path.c b/cogl-path/cogl1-path.c
index 8c19e8db..1a6e11f0 100644
--- a/cogl/cogl-path.c
+++ b/cogl-path/cogl1-path.c
@@ -3,7 +3,7 @@
  *
  * An object oriented GL/GLES Abstraction/Utility Layer
  *
- * Copyright (C) 2010 Intel Corporation.
+ * Copyright (C) 2010,2013 Intel Corporation.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -30,10 +30,10 @@
 #include "cogl-util.h"
 #include "cogl-object.h"
 #include "cogl-context-private.h"
-#include "cogl2-path.h"
 
-#include <string.h>
-#include <math.h>
+#include "cogl-path-types.h"
+
+#include "cogl2-path-functions.h"
 
 #undef cogl_path_set_fill_rule
 #undef cogl_path_get_fill_rule
@@ -56,15 +56,33 @@
 #undef cogl_path_round_rectangle
 #undef cogl_path_curve_to
 #undef cogl_path_rel_curve_to
+#undef cogl_clip_push_from_path
+
+#include "cogl1-path-functions.h"
+
+#include <string.h>
+#include <math.h>
 
-#include "cogl-path-functions.h"
+static void
+ensure_current_path (CoglContext *ctx)
+{
+  if (ctx->current_path == NULL)
+    ctx->current_path = cogl2_path_new ();
+}
+
+static CoglPath *
+get_current_path (CoglContext *ctx)
+{
+  ensure_current_path (ctx);
+  return ctx->current_path;
+}
 
 void
 cogl_path_set_fill_rule (CoglPathFillRule fill_rule)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_set_fill_rule (ctx->current_path, fill_rule);
+  cogl2_path_set_fill_rule (get_current_path (ctx), fill_rule);
 }
 
 CoglPathFillRule
@@ -72,7 +90,7 @@ cogl_path_get_fill_rule (void)
 {
   _COGL_GET_CONTEXT (ctx, COGL_PATH_FILL_RULE_EVEN_ODD);
 
-  return cogl2_path_get_fill_rule (ctx->current_path);
+  return cogl2_path_get_fill_rule (get_current_path (ctx));
 }
 
 void
@@ -80,9 +98,10 @@ cogl_path_fill (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_fill (ctx->current_path);
+  cogl2_path_fill (get_current_path (ctx));
 
-  cogl_object_unref (ctx->current_path);
+  if (ctx->current_path)
+    cogl_object_unref (ctx->current_path);
   ctx->current_path = cogl2_path_new ();
 }
 
@@ -91,7 +110,7 @@ cogl_path_fill_preserve (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_fill (ctx->current_path);
+  cogl2_path_fill (get_current_path (ctx));
 }
 
 void
@@ -99,9 +118,10 @@ cogl_path_stroke (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_stroke (ctx->current_path);
+  cogl2_path_stroke (get_current_path (ctx));
 
-  cogl_object_unref (ctx->current_path);
+  if (ctx->current_path)
+    cogl_object_unref (ctx->current_path);
   ctx->current_path = cogl2_path_new ();
 }
 
@@ -110,7 +130,7 @@ cogl_path_stroke_preserve (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_stroke (ctx->current_path);
+  cogl2_path_stroke (get_current_path (ctx));
 }
 
 void
@@ -119,7 +139,7 @@ cogl_path_move_to (float x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_move_to (ctx->current_path, x, y);
+  cogl2_path_move_to (get_current_path (ctx), x, y);
 }
 
 void
@@ -128,7 +148,7 @@ cogl_path_rel_move_to (float x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_rel_move_to (ctx->current_path, x, y);
+  cogl2_path_rel_move_to (get_current_path (ctx), x, y);
 }
 
 void
@@ -137,7 +157,7 @@ cogl_path_line_to (float x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_line_to (ctx->current_path, x, y);
+  cogl2_path_line_to (get_current_path (ctx), x, y);
 }
 
 void
@@ -146,7 +166,7 @@ cogl_path_rel_line_to (float x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_rel_line_to (ctx->current_path, x, y);
+  cogl2_path_rel_line_to (get_current_path (ctx), x, y);
 }
 
 void
@@ -154,7 +174,7 @@ cogl_path_close (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_close (ctx->current_path);
+  cogl2_path_close (get_current_path (ctx));
 }
 
 void
@@ -162,7 +182,8 @@ cogl_path_new (void)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl_object_unref (ctx->current_path);
+  if (ctx->current_path)
+    cogl_object_unref (ctx->current_path);
   ctx->current_path = cogl2_path_new ();
 }
 
@@ -174,7 +195,7 @@ cogl_path_line (float x_1,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_line (ctx->current_path, x_1, y_1, x_2, y_2);
+  cogl2_path_line (get_current_path (ctx), x_1, y_1, x_2, y_2);
 }
 
 void
@@ -183,7 +204,7 @@ cogl_path_polyline (const float *coords,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_polyline (ctx->current_path, coords, num_points);
+  cogl2_path_polyline (get_current_path (ctx), coords, num_points);
 }
 
 void
@@ -192,7 +213,7 @@ cogl_path_polygon (const float *coords,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_polygon (ctx->current_path, coords, num_points);
+  cogl2_path_polygon (get_current_path (ctx), coords, num_points);
 }
 
 void
@@ -203,7 +224,7 @@ cogl_path_rectangle (float x_1,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_rectangle (ctx->current_path, x_1, y_1, x_2, y_2);
+  cogl2_path_rectangle (get_current_path (ctx), x_1, y_1, x_2, y_2);
 }
 
 void
@@ -216,7 +237,7 @@ cogl_path_arc (float center_x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_arc (ctx->current_path,
+  cogl2_path_arc (get_current_path (ctx),
                   center_x,
                   center_y,
                   radius_x,
@@ -233,7 +254,7 @@ cogl_path_ellipse (float center_x,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_ellipse (ctx->current_path,
+  cogl2_path_ellipse (get_current_path (ctx),
                       center_x,
                       center_y,
                       radius_x,
@@ -250,7 +271,7 @@ cogl_path_round_rectangle (float x_1,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_round_rectangle (ctx->current_path,
+  cogl2_path_round_rectangle (get_current_path (ctx),
                               x_1, y_1, x_2, y_2, radius, arc_step);
 }
 
@@ -264,7 +285,7 @@ cogl_path_curve_to (float x_1,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_curve_to (ctx->current_path,
+  cogl2_path_curve_to (get_current_path (ctx),
                        x_1, y_1, x_2, y_2, x_3, y_3);
 }
 
@@ -278,7 +299,7 @@ cogl_path_rel_curve_to (float x_1,
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  cogl2_path_rel_curve_to (ctx->current_path,
+  cogl2_path_rel_curve_to (get_current_path (ctx),
                            x_1, y_1, x_2, y_2, x_3, y_3);
 }
 
@@ -287,7 +308,7 @@ cogl_get_path (void)
 {
   _COGL_GET_CONTEXT (ctx, NULL);
 
-  return ctx->current_path;
+  return get_current_path (ctx);
 }
 
 void
@@ -300,6 +321,27 @@ cogl_set_path (CoglPath *path)
   /* Reference the new object first in case it is the same as the old
      object */
   cogl_object_ref (path);
-  cogl_object_unref (ctx->current_path);
+  if (ctx->current_path)
+    cogl_object_unref (ctx->current_path);
   ctx->current_path = path;
 }
+
+void
+cogl_clip_push_from_path_preserve (void)
+{
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+  cogl_framebuffer_push_path_clip (cogl_get_draw_framebuffer (),
+                                   get_current_path (ctx));
+}
+
+void
+cogl_clip_push_from_path (void)
+{
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+  cogl_clip_push_from_path_preserve ();
+
+  if (ctx->current_path)
+    cogl_object_unref (ctx->current_path);
+  ctx->current_path = cogl2_path_new ();
+}
diff --git a/cogl/cogl2-path.h b/cogl-path/cogl2-path-functions.h
index a751f88f..9632ecd5 100644
--- a/cogl/cogl2-path.h
+++ b/cogl-path/cogl2-path-functions.h
@@ -3,7 +3,7 @@
  *
  * An object oriented GL/GLES Abstraction/Utility Layer
  *
- * Copyright (C) 2008,2009 Intel Corporation.
+ * Copyright (C) 2008,2009,2013 Intel Corporation.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -16,7 +16,8 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
  *
  *
  */
@@ -25,36 +26,14 @@
 #error "Only <cogl/cogl.h> can be included directly."
 #endif
 
-#ifndef __COGL2_PATH_H__
-#define __COGL2_PATH_H__
+#ifndef __COGL2_PATH_FUNCTIONS_H__
+#define __COGL2_PATH_FUNCTIONS_H__
 
 #include <cogl/cogl-types.h>
+#include <cogl/cogl.h>
 
 COGL_BEGIN_DECLS
 
-/**
- * SECTION:cogl-paths
- * @short_description: Functions for constructing and drawing 2D paths.
- *
- * There are two levels on which drawing with cogl-paths can be used.
- * The highest level functions construct various simple primitive
- * shapes to be either filled or stroked. Using a lower-level set of
- * functions more complex and arbitrary paths can be constructed by
- * concatenating straight line, bezier curve and arc segments.
- *
- * When constructing arbitrary paths, the current pen location is
- * initialized using the move_to command. The subsequent path segments
- * implicitly use the last pen location as their first vertex and move
- * the pen location to the last vertex they produce at the end. Also
- * there are special versions of functions that allow specifying the
- * vertices of the path segments relative to the last pen location
- * rather then in the absolute coordinates.
- */
-
-typedef struct _CoglPath CoglPath;
-
-#define COGL_PATH(obj) ((CoglPath *)(obj))
-
 #define cogl_path_new cogl2_path_new
 /**
  * cogl_path_new:
@@ -396,48 +375,6 @@ cogl_path_round_rectangle (CoglPath *path,
                            float radius,
                            float arc_step);
 
-/**
- * CoglPathFillRule:
- * @COGL_PATH_FILL_RULE_NON_ZERO: Each time the line crosses an edge of
- * the path from left to right one is added to a counter and each time
- * it crosses from right to left the counter is decremented. If the
- * counter is non-zero then the point will be filled. See <xref
- * linkend="fill-rule-non-zero"/>.
- * @COGL_PATH_FILL_RULE_EVEN_ODD: If the line crosses an edge of the
- * path an odd number of times then the point will filled, otherwise
- * it won't. See <xref linkend="fill-rule-even-odd"/>.
- *
- * #CoglPathFillRule is used to determine how a path is filled. There
- * are two options - 'non-zero' and 'even-odd'. To work out whether any
- * point will be filled imagine drawing an infinetely long line in any
- * direction from that point. The number of times and the direction
- * that the edges of the path crosses this line determines whether the
- * line is filled as described below. Any open sub paths are treated
- * as if there was an extra line joining the first point and the last
- * point.
- *
- * The default fill rule is %COGL_PATH_FILL_RULE_EVEN_ODD. The fill
- * rule is attached to the current path so preserving a path with
- * cogl_get_path() also preserves the fill rule. Calling
- * cogl_path_new() resets the current fill rule to the default.
- *
- * <figure id="fill-rule-non-zero">
- *   <title>Example of filling various paths using the non-zero rule</title>
- *   <graphic fileref="fill-rule-non-zero.png" format="PNG"/>
- * </figure>
- *
- * <figure id="fill-rule-even-odd">
- *   <title>Example of filling various paths using the even-odd rule</title>
- *   <graphic fileref="fill-rule-even-odd.png" format="PNG"/>
- * </figure>
- *
- * Since: 1.4
- */
-typedef enum {
-  COGL_PATH_FILL_RULE_NON_ZERO,
-  COGL_PATH_FILL_RULE_EVEN_ODD
-} CoglPathFillRule;
-
 #define cogl_path_set_fill_rule cogl2_path_set_fill_rule
 /**
  * cogl_path_set_fill_rule:
@@ -487,6 +424,32 @@ cogl_path_get_fill_rule (CoglPath *path);
 void
 cogl_path_fill (CoglPath *path);
 
+/**
+ * cogl_framebuffer_fill_path:
+ * @framebuffer: A #CoglFramebuffer
+ * @pipeline: A #CoglPipeline to render with
+ * @path: The #CoglPath to fill
+ *
+ * Fills the interior of the path using the fragment operations
+ * defined by the pipeline.
+ *
+ * The interior of the shape is determined using the fill rule of the
+ * path. See %CoglPathFillRule for details.
+ *
+ * <note>The result of referencing sliced textures in your current
+ * pipeline when filling a path are undefined. You should pass
+ * the %COGL_TEXTURE_NO_SLICING flag when loading any texture you will
+ * use while filling a path.</note>
+ *
+ * Stability: unstable
+ * Deprecated: 1.16: Use cogl_path_fill() instead
+ */
+void
+cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
+                            CoglPipeline *pipeline,
+                            CoglPath *path)
+     COGL_DEPRECATED_IN_1_16_FOR (cogl_path_fill);
+
 #define cogl_path_stroke cogl2_path_stroke
 /**
  * cogl_path_stroke:
@@ -500,7 +463,61 @@ cogl_path_fill (CoglPath *path);
 void
 cogl_path_stroke (CoglPath *path);
 
+/**
+ * cogl_framebuffer_stroke_path:
+ * @framebuffer: A #CoglFramebuffer
+ * @pipeline: A #CoglPipeline to render with
+ * @path: The #CoglPath to stroke
+ *
+ * Strokes the edge of the path using the fragment operations defined
+ * by the pipeline. The stroke line will have a width of 1 pixel
+ * regardless of the current transformation matrix.
+ *
+ * Stability: unstable
+ * Deprecated: 1.16: Use cogl_path_stroke() instead
+ */
+void
+cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
+                              CoglPipeline *pipeline,
+                              CoglPath *path)
+     COGL_DEPRECATED_IN_1_16_FOR (cogl_path_stroke);
+
+/**
+ * cogl_framebuffer_push_path_clip:
+ * @framebuffer: A #CoglFramebuffer pointer
+ * @path: The path to clip with.
+ *
+ * Sets a new clipping area using the silhouette of the specified,
+ * filled @path.  The clipping area is intersected with the previous
+ * clipping area. To restore the previous clipping area, call
+ * cogl_framebuffer_pop_clip().
+ *
+ * Since: 1.0
+ * Stability: unstable
+ */
+void
+cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
+                                 CoglPath *path);
+
+#define cogl_clip_push_from_path cogl2_clip_push_from_path
+/**
+ * cogl_clip_push_from_path:
+ * @path: The path to clip with.
+ *
+ * Sets a new clipping area using the silhouette of the specified,
+ * filled @path.  The clipping area is intersected with the previous
+ * clipping area. To restore the previous clipping area, call
+ * call cogl_clip_pop().
+ *
+ * Since: 1.8
+ * Stability: Unstable
+ * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
+ */
+void
+cogl_clip_push_from_path (CoglPath *path)
+     COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_path_clip);
+
 COGL_END_DECLS
 
-#endif /* __COGL2_PATH_H__ */
+#endif /* __COGL2_PATH_FUNCTIONS_H__ */
 
diff --git a/cogl/tesselator/GL/glu.h b/cogl-path/tesselator/GL/glu.h
index 026ca5af..026ca5af 100644
--- a/cogl/tesselator/GL/glu.h
+++ b/cogl-path/tesselator/GL/glu.h
diff --git a/cogl/tesselator/README b/cogl-path/tesselator/README
index 66a6011e..66a6011e 100644
--- a/cogl/tesselator/README
+++ b/cogl-path/tesselator/README
diff --git a/cogl/tesselator/dict-list.h b/cogl-path/tesselator/dict-list.h
index 11331a76..11331a76 100644
--- a/cogl/tesselator/dict-list.h
+++ b/cogl-path/tesselator/dict-list.h
diff --git a/cogl/tesselator/dict.c b/cogl-path/tesselator/dict.c
index 49d4f759..49d4f759 100644
--- a/cogl/tesselator/dict.c
+++ b/cogl-path/tesselator/dict.c
diff --git a/cogl/tesselator/dict.h b/cogl-path/tesselator/dict.h
index 11331a76..11331a76 100644
--- a/cogl/tesselator/dict.h
+++ b/cogl-path/tesselator/dict.h
diff --git a/cogl/tesselator/geom.c b/cogl-path/tesselator/geom.c
index 35b36a39..35b36a39 100644
--- a/cogl/tesselator/geom.c
+++ b/cogl-path/tesselator/geom.c
diff --git a/cogl/tesselator/geom.h b/cogl-path/tesselator/geom.h
index 5cb76c7d..5cb76c7d 100644
--- a/cogl/tesselator/geom.h
+++ b/cogl-path/tesselator/geom.h
diff --git a/cogl/tesselator/gluos.h b/cogl-path/tesselator/gluos.h
index d6c3ae99..d6c3ae99 100644
--- a/cogl/tesselator/gluos.h
+++ b/cogl-path/tesselator/gluos.h
diff --git a/cogl/tesselator/memalloc.h b/cogl-path/tesselator/memalloc.h
index 0293e155..0293e155 100644
--- a/cogl/tesselator/memalloc.h
+++ b/cogl-path/tesselator/memalloc.h
diff --git a/cogl/tesselator/mesh.c b/cogl-path/tesselator/mesh.c
index 36cb3a7b..36cb3a7b 100644
--- a/cogl/tesselator/mesh.c
+++ b/cogl-path/tesselator/mesh.c
diff --git a/cogl/tesselator/mesh.h b/cogl-path/tesselator/mesh.h
index 690c5f2f..690c5f2f 100644
--- a/cogl/tesselator/mesh.h
+++ b/cogl-path/tesselator/mesh.h
diff --git a/cogl/tesselator/normal.c b/cogl-path/tesselator/normal.c
index 9a3bd43d..9a3bd43d 100644
--- a/cogl/tesselator/normal.c
+++ b/cogl-path/tesselator/normal.c
diff --git a/cogl/tesselator/normal.h b/cogl-path/tesselator/normal.h
index c376ca44..c376ca44 100644
--- a/cogl/tesselator/normal.h
+++ b/cogl-path/tesselator/normal.h
diff --git a/cogl/tesselator/priorityq-heap.c b/cogl-path/tesselator/priorityq-heap.c
index 52698b59..52698b59 100644
--- a/cogl/tesselator/priorityq-heap.c
+++ b/cogl-path/tesselator/priorityq-heap.c
diff --git a/cogl/tesselator/priorityq-heap.h b/cogl-path/tesselator/priorityq-heap.h
index dc9aaef8..dc9aaef8 100644
--- a/cogl/tesselator/priorityq-heap.h
+++ b/cogl-path/tesselator/priorityq-heap.h
diff --git a/cogl/tesselator/priorityq-sort.h b/cogl-path/tesselator/priorityq-sort.h
index 746cf5fa..746cf5fa 100644
--- a/cogl/tesselator/priorityq-sort.h
+++ b/cogl-path/tesselator/priorityq-sort.h
diff --git a/cogl/tesselator/priorityq.c b/cogl-path/tesselator/priorityq.c
index db7cd595..db7cd595 100644
--- a/cogl/tesselator/priorityq.c
+++ b/cogl-path/tesselator/priorityq.c
diff --git a/cogl/tesselator/priorityq.h b/cogl-path/tesselator/priorityq.h
index 746cf5fa..746cf5fa 100644
--- a/cogl/tesselator/priorityq.h
+++ b/cogl-path/tesselator/priorityq.h
diff --git a/cogl/tesselator/render.c b/cogl-path/tesselator/render.c
index bca836f0..bca836f0 100644
--- a/cogl/tesselator/render.c
+++ b/cogl-path/tesselator/render.c
diff --git a/cogl/tesselator/render.h b/cogl-path/tesselator/render.h
index a298c9a9..a298c9a9 100644
--- a/cogl/tesselator/render.h
+++ b/cogl-path/tesselator/render.h
diff --git a/cogl/tesselator/sweep.c b/cogl-path/tesselator/sweep.c
index eca828ff..eca828ff 100644
--- a/cogl/tesselator/sweep.c
+++ b/cogl-path/tesselator/sweep.c
diff --git a/cogl/tesselator/sweep.h b/cogl-path/tesselator/sweep.h
index feb68b0f..feb68b0f 100644
--- a/cogl/tesselator/sweep.h
+++ b/cogl-path/tesselator/sweep.h
diff --git a/cogl/tesselator/tess.c b/cogl-path/tesselator/tess.c
index 4a0e8dea..4a0e8dea 100644
--- a/cogl/tesselator/tess.c
+++ b/cogl-path/tesselator/tess.c
diff --git a/cogl/tesselator/tess.h b/cogl-path/tesselator/tess.h
index 16249608..16249608 100644
--- a/cogl/tesselator/tess.h
+++ b/cogl-path/tesselator/tess.h
diff --git a/cogl/tesselator/tesselator.h b/cogl-path/tesselator/tesselator.h
index 5b651be1..5b651be1 100644
--- a/cogl/tesselator/tesselator.h
+++ b/cogl-path/tesselator/tesselator.h
diff --git a/cogl/tesselator/tessmono.c b/cogl-path/tesselator/tessmono.c
index 4d084400..4d084400 100644
--- a/cogl/tesselator/tessmono.c
+++ b/cogl-path/tesselator/tessmono.c
diff --git a/cogl/tesselator/tessmono.h b/cogl-path/tesselator/tessmono.h
index 8ee1b2fe..8ee1b2fe 100644
--- a/cogl/tesselator/tessmono.h
+++ b/cogl-path/tesselator/tessmono.h
diff --git a/cogl/Makefile.am b/cogl/Makefile.am
index 0ea41c7e..ba7239ed 100644
--- a/cogl/Makefile.am
+++ b/cogl/Makefile.am
@@ -18,7 +18,6 @@ lib_LTLIBRARIES =
 AM_CPPFLAGS = \
 	-I$(top_srcdir)				\
 	-I$(top_builddir)			\
-	-I$(srcdir)/tesselator			\
 	-I$(srcdir)/winsys 			\
 	-I$(srcdir)/driver/gl 			\
 	-I$(srcdir)/driver/gl/gl 		\
@@ -78,8 +77,6 @@ cogl_1_public_h = \
 	$(srcdir)/cogl-matrix.h 		\
 	$(srcdir)/cogl-offscreen.h 		\
 	$(srcdir)/cogl-primitives.h 		\
-	$(srcdir)/cogl-path.h 			\
-	$(srcdir)/cogl-path-functions.h         \
 	$(srcdir)/cogl-shader.h 		\
 	$(srcdir)/cogl-texture.h 		\
 	$(srcdir)/cogl-types.h 			\
@@ -101,7 +98,6 @@ cogl_experimental_h = \
 	$(srcdir)/cogl-pipeline-state.h 	\
 	$(srcdir)/cogl-pipeline-layer-state.h 	\
 	$(srcdir)/cogl-snippet.h		\
-	$(srcdir)/cogl2-path.h 			\
 	$(srcdir)/cogl-gles2.h			\
 	$(srcdir)/cogl-gles2-types.h		\
 	$(srcdir)/cogl-index-buffer.h 		\
@@ -132,7 +128,6 @@ cogl_experimental_h = \
 	$(srcdir)/cogl-buffer.h 		\
 	$(srcdir)/cogl-pixel-buffer.h		\
 	$(srcdir)/cogl2-experimental.h		\
-	$(srcdir)/cogl2-compatibility.h		\
 	$(srcdir)/cogl-macros.h			\
 	$(srcdir)/cogl-fence.h       		\
 	$(srcdir)/cogl-version.h		\
@@ -219,45 +214,10 @@ cogl_winsys_common_sources = \
 	$(srcdir)/winsys/cogl-winsys.c \
 	$(NULL)
 
-# tesselator sources
-cogl_tesselator_sources = \
-	$(srcdir)/tesselator/dict-list.h 	\
-	$(srcdir)/tesselator/dict.c 		\
-	$(srcdir)/tesselator/dict.h 		\
-	$(srcdir)/tesselator/geom.c 		\
-	$(srcdir)/tesselator/geom.h 		\
-	$(srcdir)/tesselator/gluos.h 		\
-	$(srcdir)/tesselator/memalloc.h 	\
-	$(srcdir)/tesselator/mesh.c 		\
-	$(srcdir)/tesselator/mesh.h 		\
-	$(srcdir)/tesselator/normal.c 		\
-	$(srcdir)/tesselator/normal.h 		\
-	$(srcdir)/tesselator/priorityq-heap.h 	\
-	$(srcdir)/tesselator/priorityq-sort.h 	\
-	$(srcdir)/tesselator/priorityq.c 	\
-	$(srcdir)/tesselator/priorityq.h 	\
-	$(srcdir)/tesselator/render.c 		\
-	$(srcdir)/tesselator/render.h 		\
-	$(srcdir)/tesselator/sweep.c 		\
-	$(srcdir)/tesselator/sweep.h 		\
-	$(srcdir)/tesselator/tess.c 		\
-	$(srcdir)/tesselator/tess.h 		\
-	$(srcdir)/tesselator/tesselator.h 	\
-	$(srcdir)/tesselator/tessmono.c 	\
-	$(srcdir)/tesselator/tessmono.h 	\
-	$(srcdir)/tesselator/GL/glu.h 		\
-	$(NULL)
-
-EXTRA_DIST += \
-	$(srcdir)/tesselator/README 		\
-	$(srcdir)/tesselator/priorityq-heap.c	\
-	$(NULL)
-
 # sources
 cogl_sources_c = \
 	$(cogl_driver_sources)				\
 	$(cogl_winsys_common_sources)			\
-	$(cogl_tesselator_sources)			\
 	$(srcdir)/cogl-private.h			\
 	$(srcdir)/cogl-i18n-private.h 			\
 	$(srcdir)/cogl-debug.h 				\
@@ -292,11 +252,6 @@ cogl_sources_c = \
 	$(srcdir)/cogl-primitives-private.h 		\
 	$(srcdir)/cogl-primitives.h 			\
 	$(srcdir)/cogl-primitives.c 			\
-	$(srcdir)/cogl-path-private.h 			\
-	$(srcdir)/cogl-path.h 				\
-	$(srcdir)/cogl-path.c 				\
-	$(srcdir)/cogl2-path.h 				\
-	$(srcdir)/cogl2-path.c 				\
 	$(srcdir)/cogl-bitmap-pixbuf.c 			\
 	$(srcdir)/cogl-clip-stack.h 			\
 	$(srcdir)/cogl-clip-stack.c			\
@@ -572,13 +527,16 @@ endif
 if UNIT_TESTS
 libcogl_la_LIBADD += $(top_builddir)/test-fixtures/libtest-fixtures.la
 endif
+if BUILD_COGL_PATH
+libcogl_la_LIBADD += $(top_builddir)/cogl-path/libcogl-path.la
+endif
 # XXX: The aim is to eventually get rid of all private API exports
 # for cogl-pango.
 libcogl_la_LDFLAGS = \
 	-no-undefined \
 	-version-info @COGL_LT_CURRENT@:@COGL_LT_REVISION@:@COGL_LT_AGE@ \
 	-export-dynamic \
-	-export-symbols-regex "^(cogl|_cogl_debug_flags|_cogl_atlas_new|_cogl_atlas_add_reorganize_callback|_cogl_atlas_reserve_space|_cogl_callback|_cogl_util_get_eye_planes_for_screen_poly|_cogl_atlas_texture_remove_reorganize_callback|_cogl_atlas_texture_add_reorganize_callback|_cogl_texture_foreach_sub_texture_in_region|_cogl_profile_trace_message|_cogl_context_get_default|test_|unit_test_).*"
+	-export-symbols-regex "^(cogl|_cogl_debug_flags|_cogl_atlas_new|_cogl_atlas_add_reorganize_callback|_cogl_atlas_reserve_space|_cogl_callback|_cogl_util_get_eye_planes_for_screen_poly|_cogl_atlas_texture_remove_reorganize_callback|_cogl_atlas_texture_add_reorganize_callback|_cogl_texture_foreach_sub_texture_in_region|_cogl_profile_trace_message|_cogl_context_get_default|_cogl_framebuffer_get_stencil_bits|_cogl_clip_stack_push_rectangle|_cogl_framebuffer_get_modelview_stack|_cogl_object_default_unref|_cogl_pipeline_foreach_layer_internal|_cogl_clip_stack_push_primitive|_cogl_buffer_unmap_for_fill_or_fallback|_cogl_framebuffer_draw_primitive|_cogl_debug_instances|_cogl_framebuffer_get_projection_stack|_cogl_pipeline_layer_get_texture|_cogl_buffer_map_for_fill_or_fallback|_cogl_framebuffer_get_clip_state|_cogl_texture_can_hardware_repeat|_cogl_pipeline_prune_to_n_layers|_cogl_primitive_draw|test_|unit_test_).*"
 
 libcogl_la_SOURCES = $(cogl_sources_c)
 nodist_libcogl_la_SOURCES = $(BUILT_SOURCES)
@@ -699,6 +657,12 @@ if UNIT_TESTS
 Cogl_1_0_gir_LIBS += $(top_builddir)/test-fixtures/libtest-fixtures.la
 endif
 Cogl_1_0_gir_FILES = $(cogl_1_public_h) cogl-enum-types.h
+if BUILD_COGL_PATH
+Cogl_1_0_gir_FILES += \
+	$(top_builddir)/cogl-path/cogl-path-enum-types.h \
+	$(top_srcdir)/cogl-path/cogl-path-types.h \
+	$(top_srcdir)/cogl-path/cogl1-path-functions.h
+endif
 Cogl_1_0_gir_CFLAGS = $(AM_CPPFLAGS) $(COGL_DEP_CFLAGS) -UCOGL_ENABLE_EXPERIMENTAL_API -UCOGL_ENABLE_EXPERIMENTAL_2_0_API
 Cogl_1_0_gir_INCLUDES = GL-1.0 GObject-2.0
 Cogl_1_0_gir_EXPORT_PACKAGES = cogl-1.0
diff --git a/cogl/cogl-clip-stack.c b/cogl/cogl-clip-stack.c
index eb0df198..69c066ef 100644
--- a/cogl/cogl-clip-stack.c
+++ b/cogl/cogl-clip-stack.c
@@ -37,7 +37,6 @@
 #include "cogl-framebuffer-private.h"
 #include "cogl-journal-private.h"
 #include "cogl-util.h"
-#include "cogl-path-private.h"
 #include "cogl-matrix-private.h"
 #include "cogl-primitives-private.h"
 #include "cogl-private.h"
@@ -250,57 +249,6 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
 }
 
 CoglClipStack *
-_cogl_clip_stack_push_from_path (CoglClipStack *stack,
-                                 CoglPath *path,
-                                 CoglMatrixEntry *modelview_entry,
-                                 CoglMatrixEntry *projection_entry,
-                                 const float *viewport)
-{
-  float x_1, y_1, x_2, y_2;
-
-  _cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2);
-
-  /* If the path is a simple rectangle then we can divert to pushing a
-     rectangle clip instead which usually won't involve the stencil
-     buffer */
-  if (_cogl_path_is_rectangle (path))
-    return _cogl_clip_stack_push_rectangle (stack,
-                                            x_1, y_1,
-                                            x_2, y_2,
-                                            modelview_entry,
-                                            projection_entry,
-                                            viewport);
-  else
-    {
-      CoglClipStackPath *entry;
-      CoglMatrix modelview;
-      CoglMatrix projection;
-      float transformed_corners[8];
-
-      entry = _cogl_clip_stack_push_entry (stack,
-                                           sizeof (CoglClipStackPath),
-                                           COGL_CLIP_STACK_PATH);
-
-      entry->path = cogl_path_copy (path);
-
-      entry->matrix_entry = cogl_matrix_entry_ref (modelview_entry);
-
-      cogl_matrix_entry_get (modelview_entry, &modelview);
-      cogl_matrix_entry_get (projection_entry, &projection);
-
-      get_transformed_corners (x_1, y_1, x_2, y_2,
-                               &modelview,
-                               &projection,
-                               viewport,
-                               transformed_corners);
-      _cogl_clip_stack_entry_set_bounds ((CoglClipStack *) entry,
-                                         transformed_corners);
-
-      return (CoglClipStack *) entry;
-    }
-}
-
-CoglClipStack *
 _cogl_clip_stack_push_primitive (CoglClipStack *stack,
                                  CoglPrimitive *primitive,
                                  float bounds_x1,
@@ -378,15 +326,6 @@ _cogl_clip_stack_unref (CoglClipStack *entry)
         case COGL_CLIP_STACK_WINDOW_RECT:
           g_slice_free1 (sizeof (CoglClipStackWindowRect), entry);
           break;
-
-        case COGL_CLIP_STACK_PATH:
-          {
-            CoglClipStackPath *path_entry = (CoglClipStackPath *) entry;
-            cogl_matrix_entry_unref (path_entry->matrix_entry);
-            cogl_object_unref (path_entry->path);
-            g_slice_free1 (sizeof (CoglClipStackPath), entry);
-            break;
-          }
         case COGL_CLIP_STACK_PRIMITIVE:
           {
             CoglClipStackPrimitive *primitive_entry =
diff --git a/cogl/cogl-clip-stack.h b/cogl/cogl-clip-stack.h
index 674405dd..2e0bd891 100644
--- a/cogl/cogl-clip-stack.h
+++ b/cogl/cogl-clip-stack.h
@@ -24,7 +24,6 @@
 #ifndef __COGL_CLIP_STACK_H
 #define __COGL_CLIP_STACK_H
 
-#include "cogl2-path.h"
 #include "cogl-matrix.h"
 #include "cogl-primitive.h"
 #include "cogl-framebuffer.h"
@@ -41,14 +40,12 @@
 typedef struct _CoglClipStack CoglClipStack;
 typedef struct _CoglClipStackRect CoglClipStackRect;
 typedef struct _CoglClipStackWindowRect CoglClipStackWindowRect;
-typedef struct _CoglClipStackPath CoglClipStackPath;
 typedef struct _CoglClipStackPrimitive CoglClipStackPrimitive;
 
 typedef enum
   {
     COGL_CLIP_STACK_RECT,
     COGL_CLIP_STACK_WINDOW_RECT,
-    COGL_CLIP_STACK_PATH,
     COGL_CLIP_STACK_PRIMITIVE
   } CoglClipStackType;
 
@@ -65,14 +62,14 @@ typedef enum
  * CoglClipStack *stack_a = NULL;
  * stack_a = _cogl_clip_stack_push_rectangle (stack_a, ...);
  * stack_a = _cogl_clip_stack_push_rectangle (stack_a, ...);
- * stack_a = _cogl_clip_stack_push_from_path (stack_a, ...);
+ * stack_a = _cogl_clip_stack_push_primitive (stack_a, ...);
  * CoglClipStack *stack_b = NULL;
  * stack_b = cogl_clip_stack_push_window_rectangle (stack_b, ...);
  *
  *  stack_a
  *         \ holds a ref to
  *          +-----------+
- *          | path node |
+ *          | prim node |
  *          |ref count 1|
  *          +-----------+
  *                       \
@@ -143,16 +140,6 @@ struct _CoglClipStackWindowRect
      just adds to the scissor clip */
 };
 
-struct _CoglClipStackPath
-{
-  CoglClipStack _parent_data;
-
-  /* The matrix that was current when the clip was set */
-  CoglMatrixEntry *matrix_entry;
-
-  CoglPath *path;
-};
-
 struct _CoglClipStackPrimitive
 {
   CoglClipStack _parent_data;
@@ -186,13 +173,6 @@ _cogl_clip_stack_push_rectangle (CoglClipStack *stack,
                                  const float *viewport);
 
 CoglClipStack *
-_cogl_clip_stack_push_from_path (CoglClipStack *stack,
-                                 CoglPath *path,
-                                 CoglMatrixEntry *modelview_entry,
-                                 CoglMatrixEntry *projection_entry,
-                                 const float *viewport);
-
-CoglClipStack *
 _cogl_clip_stack_push_primitive (CoglClipStack *stack,
                                  CoglPrimitive *primitive,
                                  float bounds_x1,
diff --git a/cogl/cogl-clip-state.c b/cogl/cogl-clip-state.c
index cbf5599b..4b70f3f8 100644
--- a/cogl/cogl-clip-state.c
+++ b/cogl/cogl-clip-state.c
@@ -39,6 +39,7 @@
 #include "cogl-matrix-private.h"
 #include "cogl-clip-state.h"
 #include "cogl1-context.h"
+#include "cogl-path/cogl-path.h"
 
 void
 cogl_clip_push_window_rectangle (int x_offset,
@@ -84,26 +85,6 @@ cogl_clip_push (float x_offset,
 }
 
 void
-cogl_clip_push_from_path_preserve (void)
-{
-  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-  cogl_framebuffer_push_path_clip (cogl_get_draw_framebuffer (),
-                                   ctx->current_path);
-}
-
-#undef cogl_clip_push_from_path
-void
-cogl_clip_push_from_path (void)
-{
-  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
-  cogl_clip_push_from_path_preserve ();
-
-  cogl_object_unref (ctx->current_path);
-  ctx->current_path = cogl2_path_new ();
-}
-
-void
 cogl_clip_push_primitive (CoglPrimitive *primitive,
                           float bounds_x1,
                           float bounds_y1,
diff --git a/cogl/cogl-clip-state.h b/cogl/cogl-clip-state.h
index d7100a07..2d71fbf6 100644
--- a/cogl/cogl-clip-state.h
+++ b/cogl/cogl-clip-state.h
@@ -32,19 +32,6 @@
 
 COGL_BEGIN_DECLS
 
-/**
- * cogl_clip_push_from_path:
- *
- * Sets a new clipping area using the current path. The current path
- * is then cleared. The clipping area is intersected with the previous
- * clipping area. To restore the previous clipping area, call
- * cogl_clip_pop().
- *
- * Since: 1.0
- */
-void
-cogl_clip_push_from_path (void);
-
 COGL_END_DECLS
 
 #endif /* __COGL_CLIP_STATE_H */
diff --git a/cogl/cogl-context-private.h b/cogl/cogl-context-private.h
index d5e52917..3d7ab6da 100644
--- a/cogl/cogl-context-private.h
+++ b/cogl/cogl-context-private.h
@@ -53,6 +53,7 @@
 #include "cogl-onscreen-private.h"
 #include "cogl-fence-private.h"
 #include "cogl-poll-private.h"
+#include "cogl-path/cogl-path-types.h"
 
 typedef struct
 {
diff --git a/cogl/cogl-context.c b/cogl/cogl-context.c
index f8a7af7b..12f51a2d 100644
--- a/cogl/cogl-context.c
+++ b/cogl/cogl-context.c
@@ -44,7 +44,6 @@
 #include "cogl-pipeline-opengl-private.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-onscreen-private.h"
-#include "cogl2-path.h"
 #include "cogl-attribute-private.h"
 #include "cogl1-context.h"
 #include "cogl-gpu-info-private.h"
@@ -378,7 +377,7 @@ cogl_context_new (CoglDisplay *display,
       cogl_object_unref (COGL_FRAMEBUFFER (window));
     }
 
-  context->current_path = cogl2_path_new ();
+  context->current_path = NULL;
   context->stencil_pipeline = cogl_pipeline_new (context);
 
   context->in_begin_gl_block = FALSE;
diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c
index b6a31166..25fa937e 100644
--- a/cogl/cogl-framebuffer.c
+++ b/cogl/cogl-framebuffer.c
@@ -47,7 +47,6 @@
 #include "cogl1-context.h"
 #include "cogl-private.h"
 #include "cogl-primitives-private.h"
-#include "cogl-path-private.h"
 #include "cogl-error-private.h"
 #include "cogl-texture-gl-private.h"
 
@@ -1949,36 +1948,6 @@ cogl_framebuffer_push_rectangle_clip (CoglFramebuffer *framebuffer,
 }
 
 void
-cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
-                                 CoglPath *path)
-{
-  CoglClipState *clip_state = _cogl_framebuffer_get_clip_state (framebuffer);
-  CoglMatrixEntry *modelview_entry =
-    _cogl_framebuffer_get_modelview_entry (framebuffer);
-  CoglMatrixEntry *projection_entry =
-    _cogl_framebuffer_get_projection_entry (framebuffer);
-  /* XXX: It would be nicer if we stored the private viewport as a
-   * vec4 so we could avoid this redundant copy. */
-  float viewport[] = {
-      framebuffer->viewport_x,
-      framebuffer->viewport_y,
-      framebuffer->viewport_width,
-      framebuffer->viewport_height
-  };
-
-  clip_state->stacks->data =
-    _cogl_clip_stack_push_from_path (clip_state->stacks->data,
-                                     path,
-                                     modelview_entry,
-                                     projection_entry,
-                                     viewport);
-
-  if (framebuffer->context->current_draw_buffer == framebuffer)
-    framebuffer->context->current_draw_buffer_changes |=
-      COGL_FRAMEBUFFER_STATE_CLIP;
-}
-
-void
 cogl_framebuffer_push_primitive_clip (CoglFramebuffer *framebuffer,
                                       CoglPrimitive *primitive,
                                       float bounds_x1,
@@ -2603,27 +2572,3 @@ cogl_framebuffer_draw_textured_rectangles (CoglFramebuffer *framebuffer,
                                                    n_rectangles,
                                                    TRUE);
 }
-
-void
-cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
-                            CoglPipeline *pipeline,
-                            CoglPath *path)
-{
-  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
-  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
-  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
-
-  _cogl_path_fill_nodes (path, framebuffer, pipeline, 0 /* flags */);
-}
-
-void
-cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
-                              CoglPipeline *pipeline,
-                              CoglPath *path)
-{
-  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
-  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
-  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
-
-  _cogl_path_stroke_nodes (path, framebuffer, pipeline);
-}
diff --git a/cogl/cogl-framebuffer.h b/cogl/cogl-framebuffer.h
index 899d7357..b83d2796 100644
--- a/cogl/cogl-framebuffer.h
+++ b/cogl/cogl-framebuffer.h
@@ -37,12 +37,6 @@
  */
 typedef struct _CoglFramebuffer CoglFramebuffer;
 
-#ifdef COGL_ENABLE_EXPERIMENTAL_2_0_API
-#include <cogl/cogl2-path.h>
-#else
-#include <cogl/cogl-path.h>
-#endif
-
 #include <cogl/cogl-pipeline.h>
 #include <cogl/cogl-indices.h>
 #include <cogl/cogl-bitmap.h>
@@ -599,23 +593,6 @@ cogl_framebuffer_push_rectangle_clip (CoglFramebuffer *framebuffer,
                                       float y_2);
 
 /**
- * cogl_framebuffer_push_path_clip:
- * @framebuffer: A #CoglFramebuffer pointer
- * @path: The path to clip with.
- *
- * Sets a new clipping area using the silhouette of the specified,
- * filled @path.  The clipping area is intersected with the previous
- * clipping area. To restore the previous clipping area, call
- * cogl_framebuffer_pop_clip().
- *
- * Since: 1.0
- * Stability: unstable
- */
-void
-cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
-                                 CoglPath *path);
-
-/**
  * cogl_framebuffer_push_primitive_clip:
  * @framebuffer: A #CoglFramebuffer pointer
  * @primitive: A #CoglPrimitive describing a flat 2D shape
@@ -1387,47 +1364,6 @@ cogl_framebuffer_draw_textured_rectangles (CoglFramebuffer *framebuffer,
                                            const float *coordinates,
                                            unsigned int n_rectangles);
 
-/**
- * cogl_framebuffer_fill_path:
- * @framebuffer: A #CoglFramebuffer
- * @pipeline: A #CoglPipeline to render with
- * @path: The #CoglPath to fill
- *
- * Fills the interior of the path using the fragment operations
- * defined by the pipeline.
- *
- * The interior of the shape is determined using the fill rule of the
- * path. See %CoglPathFillRule for details.
- *
- * <note>The result of referencing sliced textures in your current
- * pipeline when filling a path are undefined. You should pass
- * the %COGL_TEXTURE_NO_SLICING flag when loading any texture you will
- * use while filling a path.</note>
- *
- * Since: 2.0
- */
-void
-cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
-                            CoglPipeline *pipeline,
-                            CoglPath *path);
-
-/**
- * cogl_framebuffer_stroke_path:
- * @framebuffer: A #CoglFramebuffer
- * @pipeline: A #CoglPipeline to render with
- * @path: The #CoglPath to stroke
- *
- * Strokes the edge of the path using the fragment operations defined
- * by the pipeline. The stroke line will have a width of 1 pixel
- * regardless of the current transformation matrix.
- *
- * Since: 2.0
- */
-void
-cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
-                              CoglPipeline *pipeline,
-                              CoglPath *path);
-
 /* XXX: Should we take an n_buffers + buffer id array instead of using
  * the CoglBufferBits type which doesn't seem future proof? */
 /**
diff --git a/cogl/cogl.h b/cogl/cogl.h
index 8a49d62c..28ea0caf 100644
--- a/cogl/cogl.h
+++ b/cogl/cogl.h
@@ -64,7 +64,6 @@
  * 1.x only api...
  */
 #ifndef COGL_ENABLE_EXPERIMENTAL_2_0_API
-#include <cogl/cogl-path.h>
 #include <cogl/cogl-clip-state.h>
 #include <cogl/cogl-vertex-buffer.h>
 #include <cogl/cogl-enum-types.h>
@@ -130,18 +129,20 @@
 #endif
 
 /*
- * 2.0 only api...
+ * API deprecations
  */
-#ifdef COGL_ENABLE_EXPERIMENTAL_2_0_API
-#include <cogl/cogl2-path.h>
-/* This header will be removed in Cogl 1.12 */
-#include <cogl/cogl2-compatibility.h>
-#endif
+#include <cogl/cogl-deprecated.h>
 
 /*
- * API deprecations
+ * Cogl Path api compatability
+ *
+ * The cogl_path_ api used to be part of the core Cogl api so for
+ * compatability we include cogl-path.h via cogl.h
  */
-#include <cogl/cogl-deprecated.h>
+#if defined (COGL_ENABLE_EXPERIMENTAL_2_0_API) && \
+    defined (COGL_HAS_COGL_PATH_SUPPORT)
+#include <cogl-path/cogl-path.h>
+#endif
 
 /**
  * SECTION:cogl
diff --git a/cogl/cogl1-context.h b/cogl/cogl1-context.h
index de755710..2fafae05 100644
--- a/cogl/cogl1-context.h
+++ b/cogl/cogl1-context.h
@@ -839,21 +839,6 @@ cogl_clip_push_rectangle (float x0,
      COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_rectangle_clip);
 
 /**
- * cogl_clip_push_from_path_preserve:
- *
- * Sets a new clipping area using the current path. The current path
- * is then cleared. The clipping area is intersected with the previous
- * clipping area. To restore the previous clipping area, call
- * cogl_clip_pop().
- *
- * Since: 1.0
- * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
- */
-void
-cogl_clip_push_from_path_preserve (void)
-     COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_path_clip);
-
-/**
  * cogl_clip_push_primitive:
  * @primitive: A #CoglPrimitive describing a flat 2D shape
  * @bounds_x1: x coordinate for the top-left corner of the primitives
diff --git a/cogl/cogl2-compatibility.c b/cogl/cogl2-compatibility.c
index 2b4142ce..e6b65a26 100644
--- a/cogl/cogl2-compatibility.c
+++ b/cogl/cogl2-compatibility.c
@@ -29,18 +29,11 @@
    to maintain ABI compatibility. They will be removed again
    immediately once the branch for 1.12.x is created */
 
-#include "cogl2-compatibility.h"
 #include "cogl-framebuffer.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-index-buffer.h"
 #include "cogl-pipeline.h"
 
-void
-cogl_clip_push_from_path (CoglPath *path)
-{
-  cogl_framebuffer_push_path_clip (cogl_get_draw_framebuffer (), path);
-}
-
 /* These were never declared in a public header so we might as well
    keep it that way. The declarations here are just to avoid a
    warning */
diff --git a/cogl/cogl2-compatibility.h b/cogl/cogl2-compatibility.h
deleted file mode 100644
index 487d7557..00000000
--- a/cogl/cogl2-compatibility.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Cogl
- *
- * An object oriented GL/GLES Abstraction/Utility Layer
- *
- * Copyright (C) 2012 Intel Corporation.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- *
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL2_COMPATIBILITY_H__
-#define __COGL2_COMPATIBILITY_H__
-
-#include <cogl/cogl-types.h>
-#include <cogl/cogl2-path.h>
-#include <cogl/cogl-macros.h>
-
-COGL_BEGIN_DECLS
-
-#define cogl_clip_push_from_path cogl2_clip_push_from_path
-/**
- * cogl_clip_push_from_path:
- * @path: The path to clip with.
- *
- * Sets a new clipping area using the silhouette of the specified,
- * filled @path.  The clipping area is intersected with the previous
- * clipping area. To restore the previous clipping area, call
- * call cogl_clip_pop().
- *
- * Since: 1.8
- * Stability: Unstable
- * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
- */
-void
-cogl_clip_push_from_path (CoglPath *path)
-     COGL_DEPRECATED_IN_1_16_FOR (cogl_framebuffer_push_path_clip);
-
-COGL_END_DECLS
-
-#endif /* __COGL2_COMPATIBILITY_H__ */
-
diff --git a/cogl/driver/gl/cogl-clip-stack-gl.c b/cogl/driver/gl/cogl-clip-stack-gl.c
index 6bdcb075..e10141bd 100644
--- a/cogl/driver/gl/cogl-clip-stack-gl.c
+++ b/cogl/driver/gl/cogl-clip-stack-gl.c
@@ -33,7 +33,6 @@
 #include "cogl-util-gl-private.h"
 #include "cogl-primitives-private.h"
 #include "cogl-pipeline-opengl-private.h"
-#include "cogl-path-private.h"
 #include "cogl-clip-stack-gl-private.h"
 #include "cogl-primitive-private.h"
 
@@ -362,41 +361,6 @@ add_stencil_clip_silhouette (CoglFramebuffer *framebuffer,
 }
 
 static void
-paint_path_silhouette (CoglFramebuffer *framebuffer,
-                       CoglPipeline *pipeline,
-                       void *user_data)
-{
-  CoglPath *path = user_data;
-  if (path->data->path_nodes->len >= 3)
-    _cogl_path_fill_nodes (path,
-                           framebuffer,
-                           pipeline,
-                           COGL_DRAW_SKIP_JOURNAL_FLUSH |
-                           COGL_DRAW_SKIP_PIPELINE_VALIDATION |
-                           COGL_DRAW_SKIP_FRAMEBUFFER_FLUSH);
-}
-
-static void
-add_stencil_clip_path (CoglFramebuffer *framebuffer,
-                       CoglMatrixEntry *modelview_entry,
-                       CoglPath *path,
-                       CoglBool merge,
-                       CoglBool need_clear)
-{
-  CoglPathData *data = path->data;
-  add_stencil_clip_silhouette (framebuffer,
-                               paint_path_silhouette,
-                               modelview_entry,
-                               data->path_nodes_min.x,
-                               data->path_nodes_min.y,
-                               data->path_nodes_max.x,
-                               data->path_nodes_max.y,
-                               merge,
-                               need_clear,
-                               path);
-}
-
-static void
 paint_primitive_silhouette (CoglFramebuffer *framebuffer,
                             CoglPipeline *pipeline,
                             void *user_data)
@@ -578,21 +542,6 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
     {
       switch (entry->type)
         {
-        case COGL_CLIP_STACK_PATH:
-            {
-              CoglClipStackPath *path_entry = (CoglClipStackPath *) entry;
-
-              COGL_NOTE (CLIPPING, "Adding stencil clip for path");
-
-              add_stencil_clip_path (framebuffer,
-                                     path_entry->matrix_entry,
-                                     path_entry->path,
-                                     using_stencil_buffer,
-                                     TRUE);
-
-              using_stencil_buffer = TRUE;
-              break;
-            }
         case COGL_CLIP_STACK_PRIMITIVE:
             {
               CoglClipStackPrimitive *primitive_entry =
diff --git a/configure.ac b/configure.ac
index 7b1decf8..8600f514 100644
--- a/configure.ac
+++ b/configure.ac
@@ -536,6 +536,21 @@ AS_IF([test "x$enable_cogl_gst" = "xyes"],
       ]
 )
 
+dnl     ============================================================
+dnl     Should cogl-path be built?
+dnl     ============================================================
+
+AC_ARG_ENABLE(
+  [cogl-path],
+  [AC_HELP_STRING([--enable-cogl-path=@<:@no/yes@:>@], [Enable 2D path support @<:@default=no@:>@])],
+  [],
+  enable_cogl_path=yes
+)
+AS_IF([test "x$enable_cogl_path" = "xyes"],
+      [
+        COGL_DEFINES_SYMBOLS="$COGL_DEFINES_SYMBOLS COGL_HAS_COGL_PATH_SUPPORT"
+      ]
+)
 
 dnl     ============================================================
 dnl     Choose image loading backend
@@ -1273,6 +1288,8 @@ AS_IF([test "x$enable_cogl_pango" = "xyes"],
 )
 AM_CONDITIONAL([BUILD_COGL_PANGO], [test "x$enable_cogl_pango" = "xyes"])
 
+AM_CONDITIONAL([BUILD_COGL_PATH], [test "x$enable_cogl_path" = "xyes"])
+
 AC_SUBST(COGL_GST_PKG_REQUIRES)
 
 AS_IF([test "x$enable_cogl_gst" = "xyes"],
@@ -1451,6 +1468,7 @@ cogl-pango/Makefile
 cogl-pango/cogl-pango-1.0.pc
 cogl-pango/cogl-pango-2.0-experimental.pc
 cogl-pango/cogl-pango.rc
+cogl-path/Makefile
 cogl-gst/Makefile
 cogl-gst/cogl-gst.pc
 cogl-gles2/Makefile
@@ -1509,13 +1527,14 @@ echo "        Building for emscripten environment: $enable_emscripten"
 echo "        Build libcogl-gles2 GLES 2.0 frontend api: ${enable_cogl_gles2}"
 echo "        Image backend: ${COGL_IMAGE_BACKEND}"
 echo "        Cogl Pango: ${enable_cogl_pango}"
-echo "        Profiling: ${enable_profile}"
-echo "        CoglGst: ${enable_cogl_gst}"
+echo "        Cogl Gstreamer: ${enable_cogl_gst}"
+echo "        Cogl Path: ${enable_cogl_path}"
 
 # Compiler/Debug related flags
 echo ""
-echo " • Compiler options:"
-echo "        Cogl debug: ${enable_debug}"
+echo " • Build options:"
+echo "        Debugging: ${enable_debug}"
+echo "        Profiling: ${enable_profile}"
 echo "        Enable deprecated symbols: ${enable_deprecated}"
 echo "        Compiler flags: ${CFLAGS} ${COGL_EXTRA_CFLAGS}"
 echo "        Linker flags: ${LDFLAGS} ${COGL_EXTRA_LDFLAGS}"
diff --git a/tests/conform/Makefile.am b/tests/conform/Makefile.am
index 8cadab1a..c4fae0ec 100644
--- a/tests/conform/Makefile.am
+++ b/tests/conform/Makefile.am
@@ -33,7 +33,6 @@ test_sources = \
 	test-color-mask.c \
 	test-backface-culling.c \
 	test-just-vertex-shader.c \
-	test-path.c \
 	test-pipeline-user-matrix.c \
 	test-pipeline-uniforms.c \
 	test-pixel-buffer.c \
@@ -75,6 +74,10 @@ if !USING_EMSCRIPTEN
 test_sources += test-fence.c
 endif
 
+if BUILD_COGL_PATH
+test_sources += test-path.c
+endif
+
 test_conformance_SOURCES = $(common_sources) $(test_sources)
 
 if OS_WIN32
@@ -145,6 +148,9 @@ test_conformance_LDADD = \
 if !USE_GLIB
 test_conformance_LDADD += $(top_builddir)/deps/glib/libglib.la
 endif
+if BUILD_COGL_PATH
+test_conformance_LDADD += $(top_builddir)/cogl-path/libcogl-path.la
+endif
 test_conformance_LDFLAGS = -export-dynamic
 
 test: wrappers
diff --git a/tests/conform/test-conform-main.c b/tests/conform/test-conform-main.c
index c4543dc4..4a8e08d6 100644
--- a/tests/conform/test-conform-main.c
+++ b/tests/conform/test-conform-main.c
@@ -57,7 +57,9 @@ main (int argc, char **argv)
   ADD_TEST (test_blend, 0, 0);
   ADD_TEST (test_premult, 0, 0);
   UNPORTED_TEST (test_readpixels);
+#ifdef COGL_HAS_COGL_PATH_SUPPORT
   ADD_TEST (test_path, 0, 0);
+#endif
   ADD_TEST (test_depth_test, 0, 0);
   ADD_TEST (test_color_mask, 0, 0);
   ADD_TEST (test_backface_culling, 0, TEST_REQUIREMENT_NPOT);
diff --git a/tests/conform/test-path.c b/tests/conform/test-path.c
index 066b782a..11f7f158 100644
--- a/tests/conform/test-path.c
+++ b/tests/conform/test-path.c
@@ -1,4 +1,6 @@
+#define COGL_ENABLE_EXPERIMENTAL_2_0_API
 #include <cogl/cogl.h>
+#include <cogl-path/cogl-path.h>
 
 #include <string.h>
 
@@ -20,7 +22,9 @@ draw_path_at (CoglPath *path, CoglPipeline *pipeline, int x, int y)
   cogl_framebuffer_push_matrix (test_fb);
   cogl_framebuffer_translate (test_fb, x * BLOCK_SIZE, y * BLOCK_SIZE, 0.0f);
 
-  cogl_framebuffer_fill_path (test_fb, pipeline, path);
+  cogl_set_framebuffer (test_fb);
+  cogl_set_source (pipeline);
+  cogl_path_fill (path);
 
   cogl_framebuffer_pop_matrix (test_fb);
 }
@@ -73,18 +77,18 @@ paint (TestState *state)
 
   /* Create a path filling just a quarter of a block. It will use two
      rectangles so that we have a sub path in the path */
-  cogl_path_new ();
-  cogl_path_rectangle (BLOCK_SIZE * 3 / 4, BLOCK_SIZE / 2,
+  path_a = cogl_path_new ();
+  cogl_path_rectangle (path_a,
+                       BLOCK_SIZE * 3 / 4, BLOCK_SIZE / 2,
                        BLOCK_SIZE, BLOCK_SIZE);
-  cogl_path_rectangle (BLOCK_SIZE / 2, BLOCK_SIZE / 2,
+  cogl_path_rectangle (path_a,
+                       BLOCK_SIZE / 2, BLOCK_SIZE / 2,
                        BLOCK_SIZE * 3 / 4, BLOCK_SIZE);
-  path_a = cogl_object_ref (cogl_get_path ());
   draw_path_at (path_a, white, 0, 0);
 
   /* Create another path filling the whole block */
-  cogl_path_new ();
-  cogl_path_rectangle (0, 0, BLOCK_SIZE, BLOCK_SIZE);
-  path_b = cogl_object_ref (cogl_get_path ());
+  path_b = cogl_path_new ();
+  cogl_path_rectangle (path_b, 0, 0, BLOCK_SIZE, BLOCK_SIZE);
   draw_path_at (path_b, white, 1, 0);
 
   /* Draw the first path again */
@@ -97,11 +101,10 @@ paint (TestState *state)
   /* Add another rectangle to path a. We'll use line_to's instead of
      cogl_rectangle so that we don't create another sub-path because
      that is more likely to break the copy */
-  cogl_set_path (path_a);
-  cogl_path_line_to (0, BLOCK_SIZE / 2);
-  cogl_path_line_to (0, 0);
-  cogl_path_line_to (BLOCK_SIZE / 2, 0);
-  cogl_path_line_to (BLOCK_SIZE / 2, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, 0, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, 0, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, BLOCK_SIZE / 2);
   draw_path_at (path_a, white, 4, 0);
 
   /* Draw the copy again. It should not have changed */
@@ -110,16 +113,15 @@ paint (TestState *state)
   /* Add another rectangle to path c. It will be added in two halves,
      one as an extension of the previous path and the other as a new
      sub path */
-  cogl_set_path (path_c);
-  cogl_path_line_to (BLOCK_SIZE / 2, 0);
-  cogl_path_line_to (BLOCK_SIZE * 3 / 4, 0);
-  cogl_path_line_to (BLOCK_SIZE * 3 / 4, BLOCK_SIZE / 2);
-  cogl_path_line_to (BLOCK_SIZE / 2, BLOCK_SIZE / 2);
-  cogl_path_rectangle (BLOCK_SIZE * 3 / 4, 0, BLOCK_SIZE, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_c, BLOCK_SIZE / 2, 0);
+  cogl_path_line_to (path_c, BLOCK_SIZE * 3 / 4, 0);
+  cogl_path_line_to (path_c, BLOCK_SIZE * 3 / 4, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_c, BLOCK_SIZE / 2, BLOCK_SIZE / 2);
+  cogl_path_rectangle (path_c,
+                       BLOCK_SIZE * 3 / 4, 0, BLOCK_SIZE, BLOCK_SIZE / 2);
   draw_path_at (path_c, white, 6, 0);
 
   /* Draw the original path again. It should not have changed */
-  cogl_set_path (path_a);
   draw_path_at (path_a, white, 7, 0);
 
   cogl_object_unref (path_a);
@@ -128,51 +130,48 @@ paint (TestState *state)
 
   /* Draw a self-intersecting path. The part that intersects should be
      inverted */
-  cogl_path_new ();
-  cogl_path_rectangle (0, 0, BLOCK_SIZE, BLOCK_SIZE);
-  cogl_path_line_to (0, BLOCK_SIZE / 2);
-  cogl_path_line_to (BLOCK_SIZE / 2, BLOCK_SIZE / 2);
-  cogl_path_line_to (BLOCK_SIZE / 2, 0);
-  cogl_path_close ();
-  path_a = cogl_object_ref (cogl_get_path ());
+  path_a = cogl_path_new ();
+  cogl_path_rectangle (path_a, 0, 0, BLOCK_SIZE, BLOCK_SIZE);
+  cogl_path_line_to (path_a, 0, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, 0);
+  cogl_path_close (path_a);
   draw_path_at (path_a, white, 8, 0);
   cogl_object_unref (path_a);
 
   /* Draw two sub paths. Where the paths intersect it should be
      inverted */
-  cogl_path_new ();
-  cogl_path_rectangle (0, 0, BLOCK_SIZE, BLOCK_SIZE);
-  cogl_path_rectangle (BLOCK_SIZE / 2, BLOCK_SIZE / 2, BLOCK_SIZE, BLOCK_SIZE);
-  path_a = cogl_object_ref (cogl_get_path ());
+  path_a = cogl_path_new ();
+  cogl_path_rectangle (path_a, 0, 0, BLOCK_SIZE, BLOCK_SIZE);
+  cogl_path_rectangle (path_a,
+                       BLOCK_SIZE / 2, BLOCK_SIZE / 2, BLOCK_SIZE, BLOCK_SIZE);
   draw_path_at (path_a, white, 9, 0);
   cogl_object_unref (path_a);
 
   /* Draw a clockwise outer path */
-  cogl_path_new ();
-  cogl_path_move_to (0, 0);
-  cogl_path_line_to (BLOCK_SIZE, 0);
-  cogl_path_line_to (BLOCK_SIZE, BLOCK_SIZE);
-  cogl_path_line_to (0, BLOCK_SIZE);
-  cogl_path_close ();
+  path_a = cogl_path_new ();
+  cogl_path_move_to (path_a, 0, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE, BLOCK_SIZE);
+  cogl_path_line_to (path_a, 0, BLOCK_SIZE);
+  cogl_path_close (path_a);
   /* Add a clockwise sub path in the upper left quadrant */
-  cogl_path_move_to (0, 0);
-  cogl_path_line_to (BLOCK_SIZE / 2, 0);
-  cogl_path_line_to (BLOCK_SIZE / 2, BLOCK_SIZE / 2);
-  cogl_path_line_to (0, BLOCK_SIZE / 2);
-  cogl_path_close ();
+  cogl_path_move_to (path_a, 0, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, 0, BLOCK_SIZE / 2);
+  cogl_path_close (path_a);
   /* Add a counter-clockwise sub path in the upper right quadrant */
-  cogl_path_move_to (BLOCK_SIZE / 2, 0);
-  cogl_path_line_to (BLOCK_SIZE / 2, BLOCK_SIZE / 2);
-  cogl_path_line_to (BLOCK_SIZE, BLOCK_SIZE / 2);
-  cogl_path_line_to (BLOCK_SIZE, 0);
-  cogl_path_close ();
+  cogl_path_move_to (path_a, BLOCK_SIZE / 2, 0);
+  cogl_path_line_to (path_a, BLOCK_SIZE / 2, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, BLOCK_SIZE, BLOCK_SIZE / 2);
+  cogl_path_line_to (path_a, BLOCK_SIZE, 0);
+  cogl_path_close (path_a);
   /* Retain the path for the next test */
-  path_a = cogl_object_ref (cogl_get_path ());
   draw_path_at (path_a, white, 10, 0);
 
   /* Draw the same path again with the other fill rule */
-  cogl_set_path (path_a);
-  cogl_path_set_fill_rule (COGL_PATH_FILL_RULE_NON_ZERO);
+  cogl_path_set_fill_rule (path_a, COGL_PATH_FILL_RULE_NON_ZERO);
   draw_path_at (path_a, white, 11, 0);
 
   cogl_object_unref (path_a);