More work on Cairo bindings

lime/graphics/CairoRenderContext.hx

@@ -2,6 +2,8 @@ package lime.graphics;
 
 
 import lime.graphics.cairo.Cairo;
+import lime.graphics.cairo.CairoFormat;
+import lime.graphics.cairo.CairoSurface;
 
 
 class CairoRenderContext {

lime/graphics/cairo/Cairo.hx

@@ -1,6 +1,7 @@
 package lime.graphics.cairo;
 
 
+import lime.math.Matrix3;
 import lime.system.System;
 
 
@@ -10,11 +11,133 @@ class Cairo {
 	public static var version (get, null):Int;
 	public static var versionString (get, null):String;
 	
+	public var lineCap (get, set):CairoLineCap;
+	public var lineJoin (get, set):CairoLineJoin;
+	public var lineWidth (get, set):Float;
+	public var matrix (get, set):Matrix3;
+	public var miterLimit (get, set):Float;
+	public var operator (get, set):CairoOperator;
+	public var source (get, set):CairoPattern;
 	
-	public static function imageSurfaceCreate (format:CairoFormat, width:Int, height:Int):CairoSurface {
+	private var handle:Dynamic;
+	
+	
+	public function new (surface:CairoSurface = null):Void {
+		
+		if (surface != null) {
+			
+			#if lime_cairo
+			handle = lime_cairo_create (surface);
+			#end
+			
+		}
+		
+	}
+	
+	
+	public function clip ():Void {
 		
 		#if lime_cairo
-		return lime_cairo_image_surface_create (format, width, height);
+		lime_cairo_clip (handle);
+		#end
+		
+	}
+	
+	
+	public function closePath ():Void {
+		
+		#if lime_cairo
+		lime_cairo_close_path (handle);
+		#end
+		
+	}
+	
+	
+	public function destroy ():Void {
+		
+		#if lime_cairo
+		lime_cairo_destroy (handle);
+		#end
+		
+	}
+	
+	
+	public function fill ():Void {
+		
+		#if lime_cairo
+		lime_cairo_fill (handle);
+		#end
+		
+	}
+	
+	
+	public function fillPreserve ():Void {
+		
+		#if lime_cairo
+		lime_cairo_fill_preserve (handle);
+		#end
+		
+	}
+	
+	
+	public function lineTo (x:Float, y:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_line_to (handle, x, y);
+		#end
+		
+	}
+	
+	
+	public function moveTo (x:Float, y:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_move_to (handle, x, y);
+		#end
+		
+	}
+	
+	
+	public function mask (pattern:CairoPattern):Void {
+		
+		#if lime_cairo
+		lime_cairo_mask (handle, pattern);
+		#end
+		
+	}
+	
+	
+	public function newPath ():Void {
+		
+		#if lime_cairo
+		lime_cairo_new_path (handle);
+		#end
+		
+	}
+	
+	
+	public function paint ():Void {
+		
+		#if lime_cairo
+		lime_cairo_paint (handle);
+		#end
+		
+	}
+	
+	
+	public function paintWithAlpha (alpha:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_paint_with_alpha (handle, alpha);
+		#end
+		
+	}
+	
+	
+	public function popGroup ():CairoPattern {
+		
+		#if lime_cairo
+		return lime_cairo_pop_group (handle);
 		#else
 		return null;
 		#end
@@ -22,11 +145,276 @@ class Cairo {
 	}
 	
 	
+	public function popGroupToSource ():Void {
+		
+		#if lime_cairo
+		lime_cairo_pop_group_to_source (handle);
+		#end
+		
+	}
+	
+	
+	public function pushGroup ():Void {
+		
+		#if lime_cairo
+		lime_cairo_push_group (handle);
+		#end
+		
+	}
+	
+	
+	public function pushGroupWithContent (content:CairoContent):Void {
+		
+		#if lime_cairo
+		lime_cairo_push_group_with_content (handle, content);
+		#end
+		
+	}
+	
+	
+	public function rectangle (x:Float, y:Float, width:Float, height:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_rectangle (handle, x, y, width, height);
+		#end
+		
+	}
+	
+	
+	public function resetClip ():Void {
+		
+		#if lime_cairo
+		lime_cairo_reset_clip (handle);
+		#end
+		
+	}
+	
+	
+	public function restore ():Void {
+		
+		#if lime_cairo
+		lime_cairo_restore (handle);
+		#end
+		
+	}
+	
+	
+	public function save ():Void {
+		
+		#if lime_cairo
+		lime_cairo_save (handle);
+		#end
+		
+	}
+	
+	
+	public function setSourceRGBA (r:Float, g:Float, b:Float, a:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_set_source_rgba (handle, r, g, b, a);
+		#end
+		
+	}
+	
+	
+	public function setSourceSurface (surface:CairoSurface, x:Float, y:Float):Void {
+		
+		#if lime_cairo
+		lime_cairo_set_source_surface (handle, surface, x, y);
+		#end
+		
+	}
+	
+	
+	public function stroke ():Void {
+		
+		#if lime_cairo
+		lime_cairo_stroke (handle);
+		#end
+		
+	}
+	
+	
+	public function strokePreserve ():Void {
+		
+		#if lime_cairo
+		lime_cairo_stroke_preserve (handle);
+		#end
+		
+	}
+	
+	
+	public function transform (matrix:Matrix3):Void {
+		
+		#if lime_cairo
+		lime_cairo_transform (handle, matrix);
+		#end
+		
+	}
+	
+	
+	
+	
 	// Get & Set Methods
 	
 	
 	
 	
+	private function get_lineCap ():CairoLineCap {
+		
+		#if lime_cairo
+		return lime_cairo_get_line_cap (handle);
+		#end
+		
+		return 0;
+		
+	}
+	
+	
+	private function set_lineCap (value:CairoLineCap):CairoLineCap {
+		
+		#if lime_cairo
+		lime_cairo_set_line_cap (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_lineJoin ():CairoLineJoin {
+		
+		#if lime_cairo
+		return lime_cairo_get_line_join (handle);
+		#end
+		
+		return 0;
+		
+	}
+	
+	
+	private function set_lineJoin (value:CairoLineJoin):CairoLineJoin {
+		
+		#if lime_cairo
+		lime_cairo_set_line_join (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_lineWidth ():Float {
+		
+		#if lime_cairo
+		return lime_cairo_get_line_width (handle);
+		#end
+		
+		return 0;
+		
+	}
+	
+	
+	private function set_lineWidth (value:Float):Float {
+		
+		#if lime_cairo
+		lime_cairo_set_line_width (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_matrix ():Matrix3 {
+		
+		#if lime_cairo
+		var m = lime_cairo_get_matrix (handle);
+		return new Matrix3 (m.a, m.b, m.c, m.d, m.tx, m.ty);
+		#end
+		
+		return null;
+		
+	}
+	
+	
+	private function set_matrix (value:Matrix3):Matrix3 {
+		
+		#if lime_cairo
+		lime_cairo_set_matrix (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_miterLimit ():Float {
+		
+		#if lime_cairo
+		return lime_cairo_get_miter_limit (handle);
+		#end
+		
+		return 0;
+		
+	}
+	
+	
+	private function set_miterLimit (value:Float):Float {
+		
+		#if lime_cairo
+		lime_cairo_set_miter_limit (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_operator ():CairoOperator {
+		
+		#if lime_cairo
+		return lime_cairo_get_operator (handle);
+		#end
+		
+		return cast 0;
+		
+	}
+	
+	
+	private function set_operator (value:CairoOperator):CairoOperator {
+		
+		#if lime_cairo
+		lime_cairo_set_operator (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	private function get_source ():CairoPattern {
+		
+		#if lime_cairo
+		return lime_cairo_get_source (handle);
+		#end
+		
+		return cast 0;
+		
+	}
+	
+	
+	private function set_source (value:CairoPattern):CairoPattern {
+		
+		#if lime_cairo
+		lime_cairo_set_source (handle, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
 	private static function get_version ():Int {
 		
 		#if lime_cairo
@@ -57,7 +445,45 @@ class Cairo {
 	
 	
 	#if lime_cairo
-	private static var lime_cairo_image_surface_create = System.load ("lime", "lime_cairo_image_surface_create", 3);
+	private static var lime_cairo_clip = System.load ("lime", "lime_cairo_clip", 1);
+	private static var lime_cairo_close_path = System.load ("lime", "lime_cairo_close_path", 1);
+	private static var lime_cairo_create = System.load ("lime", "lime_cairo_create", 1);
+	private static var lime_cairo_destroy = System.load ("lime", "lime_cairo_destroy", 1);
+	private static var lime_cairo_fill = System.load ("lime", "lime_cairo_fill", 1);
+	private static var lime_cairo_fill_preserve = System.load ("lime", "lime_cairo_fill_preserve", 1);
+	private static var lime_cairo_get_line_cap = System.load ("lime", "lime_cairo_get_line_cap", 1);
+	private static var lime_cairo_get_line_join = System.load ("lime", "lime_cairo_get_line_join", 1);
+	private static var lime_cairo_get_line_width = System.load ("lime", "lime_cairo_get_line_width", 1);
+	private static var lime_cairo_get_matrix = System.load ("lime", "lime_cairo_get_matrix", 1);
+	private static var lime_cairo_get_miter_limit = System.load ("lime", "lime_cairo_get_miter_limit", 1);
+	private static var lime_cairo_get_operator = System.load ("lime", "lime_cairo_get_operator", 1);
+	private static var lime_cairo_get_source = System.load ("lime", "lime_cairo_get_source", 1);
+	private static var lime_cairo_line_to = System.load ("lime", "lime_cairo_line_to", 3);
+	private static var lime_cairo_mask = System.load ("lime", "lime_cairo_mask", 2);
+	private static var lime_cairo_move_to = System.load ("lime", "lime_cairo_move_to", 3);
+	private static var lime_cairo_new_path = System.load ("lime", "lime_cairo_new_path", 1);
+	private static var lime_cairo_paint = System.load ("lime", "lime_cairo_paint", 1);
+	private static var lime_cairo_paint_with_alpha = System.load ("lime", "lime_cairo_paint_with_alpha", 2);
+	private static var lime_cairo_pop_group = System.load ("lime", "lime_cairo_pop_group", 1);
+	private static var lime_cairo_pop_group_to_source = System.load ("lime", "lime_cairo_pop_group_to_source", 1);
+	private static var lime_cairo_push_group = System.load ("lime", "lime_cairo_push_group", 1);
+	private static var lime_cairo_push_group_with_content = System.load ("lime", "lime_cairo_push_group_with_content", 2);
+	private static var lime_cairo_rectangle = System.load ("lime", "lime_cairo_rectangle", 5);
+	private static var lime_cairo_reset_clip = System.load ("lime", "lime_cairo_reset_clip", 1);
+	private static var lime_cairo_restore = System.load ("lime", "lime_cairo_restore", 1);
+	private static var lime_cairo_save = System.load ("lime", "lime_cairo_save", 1);
+	private static var lime_cairo_set_line_cap = System.load ("lime", "lime_cairo_set_line_cap", 2);
+	private static var lime_cairo_set_line_join = System.load ("lime", "lime_cairo_set_line_join", 2);
+	private static var lime_cairo_set_line_width = System.load ("lime", "lime_cairo_set_line_width", 2);
+	private static var lime_cairo_set_matrix = System.load ("lime", "lime_cairo_set_matrix", 2);
+	private static var lime_cairo_set_miter_limit = System.load ("lime", "lime_cairo_set_miter_limit", 2);
+	private static var lime_cairo_set_operator = System.load ("lime", "lime_cairo_set_operator", 2);
+	private static var lime_cairo_set_source = System.load ("lime", "lime_cairo_set_source", 2);
+	private static var lime_cairo_set_source_rgba = System.load ("lime", "lime_cairo_set_source_rgba", 5);
+	private static var lime_cairo_set_source_surface = System.load ("lime", "lime_cairo_set_source_surface", 4);
+	private static var lime_cairo_stroke = System.load ("lime", "lime_cairo_stroke", 1);
+	private static var lime_cairo_stroke_preserve = System.load ("lime", "lime_cairo_stroke_preserve", 1);
+	private static var lime_cairo_transform = System.load ("lime", "lime_cairo_transform", 2);
 	private static var lime_cairo_version = System.load ("lime", "lime_cairo_version", 0);
 	private static var lime_cairo_version_string = System.load ("lime", "lime_cairo_version_string", 0);
 	#end

lime/graphics/cairo/CairoContent.hx

@@ -0,0 +1,10 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoContent(Int) from Int to Int {
+	
+	public var COLOR = 0x1000;
+    public var ALPHA = 0x2000;
+    public var COLOR_ALPHA = 0x3000;
+	
+}

lime/graphics/cairo/CairoExtend.hx

@@ -0,0 +1,11 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoExtend(Int) from Int to Int {
+	
+	public var NONE = 0;
+	public var REPEAT = 1;
+	public var REFLECT = 2;
+	public var PAD = 3;
+	
+}

lime/graphics/cairo/CairoFilter.hx

@@ -0,0 +1,13 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoFilter(Int) from Int to Int {
+	
+	public var FAST = 0;
+	public var GOOD = 1;
+	public var BEST = 2;
+	public var NEAREST = 3;
+	public var BILINEAR = 4;
+	public var GAUSSIAN = 5;
+	
+}

lime/graphics/cairo/CairoLineCap.hx

@@ -0,0 +1,10 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoLineCap(Int) from Int to Int {
+	
+	public var BUTT = 0;
+	public var ROUND = 1;
+	public var SQUARE = 2;
+	
+}

lime/graphics/cairo/CairoLineJoin.hx

@@ -0,0 +1,10 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoLineJoin(Int) from Int to Int {
+	
+	public var MITER = 0;
+	public var ROUND = 1;
+	public var BEVEL = 2;
+	
+}

lime/graphics/cairo/CairoOperator.hx

@@ -0,0 +1,36 @@
+package lime.graphics.cairo;
+
+
+@:enum abstract CairoOperator(Int) from Int to Int {
+	
+	public var CLEAR = 0;
+	public var SOURCE = 1;
+	public var OVER = 2;
+	public var IN = 3;
+	public var OUT = 4;
+	public var ATOP = 5;
+	public var DEST = 6;
+	public var DEST_OVER = 7;
+	public var DEST_IN = 8;
+	public var DEST_OUT = 9;
+	public var DEST_ATOP = 10;
+	public var XOR = 11;
+	public var ADD = 12;
+	public var SATURATE = 13;
+	public var MULTIPLY = 14;
+	public var SCREEN = 15;
+	public var OVERLAY = 16;
+	public var DARKEN = 17;
+	public var LIGHTEN = 18;
+	public var COLOR_DODGE = 19;
+	public var COLOR_BURN = 20;
+	public var HARD_LIGHT = 21;
+	public var SOFT_LIGHT = 22;
+	public var DIFFERENCE = 23;
+	public var EXCLUSION = 24;
+	public var HSL_HUE = 25;
+	public var HSL_SATURATION = 26;
+	public var HSL_COLOR = 27;
+	public var HSL_LUMINOSITY = 28;
+	
+}

lime/graphics/cairo/CairoPattern.hx

@@ -0,0 +1,132 @@
+package lime.graphics.cairo;
+
+
+import lime.math.Matrix3;
+import lime.system.System;
+
+
+abstract CairoPattern(Dynamic) {
+	
+	
+	public var extend (get, set):CairoExtend;
+	public var filter (get, set):CairoFilter;
+	public var matrix (get, set):Matrix3;
+	
+	
+	public function new (handle) {
+		
+		this = handle;
+		
+	}
+	
+	
+	public static function createForSurface (surface:CairoSurface):CairoPattern {
+		
+		return lime_cairo_pattern_create_for_surface (surface);
+		
+	}
+	
+	
+	public function destroy ():Void {
+		
+		#if lime_cairo
+		lime_cairo_pattern_destroy (this);
+		#end
+		
+	}
+	
+	
+	
+	
+	// Get & Set Methods
+	
+	
+	
+	
+	public function get_extend ():CairoExtend {
+		
+		#if lime_cairo
+		return lime_cairo_pattern_get_extend (this);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public function set_extend (value:CairoExtend):CairoExtend {
+		
+		#if lime_cairo
+		lime_cairo_pattern_set_extend (this, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	public function get_filter ():CairoFilter {
+		
+		#if lime_cairo
+		return lime_cairo_pattern_get_filter (this);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public function set_filter (value:CairoFilter):CairoFilter {
+		
+		#if lime_cairo
+		lime_cairo_pattern_set_filter (this, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	public function get_matrix ():Matrix3 {
+		
+		#if lime_cairo
+		var m = lime_cairo_pattern_get_matrix (this);
+		return new Matrix3 (m.a, m.b, m.c, m.d, m.tx, m.ty);
+		#else
+		return null;
+		#end
+		
+	}
+	
+	
+	public function set_matrix (value:Matrix3):Matrix3 {
+		
+		#if lime_cairo
+		lime_cairo_pattern_set_matrix (this, value);
+		#end
+		
+		return value;
+		
+	}
+	
+	
+	
+	
+	// Native Methods
+	
+	
+	
+	
+	#if lime_cairo
+	private static var lime_cairo_pattern_create_for_surface = System.load ("lime", "lime_cairo_pattern_create_for_surface", 1);
+	private static var lime_cairo_pattern_destroy = System.load ("lime", "lime_cairo_pattern_destroy", 1);
+	private static var lime_cairo_pattern_get_extend = System.load ("lime", "lime_cairo_pattern_get_extend", 1);
+	private static var lime_cairo_pattern_get_filter = System.load ("lime", "lime_cairo_pattern_get_filter", 1);
+	private static var lime_cairo_pattern_get_matrix = System.load ("lime", "lime_cairo_pattern_get_matrix", 1);
+	private static var lime_cairo_pattern_set_extend = System.load ("lime", "lime_cairo_pattern_set_extend", 2);
+	private static var lime_cairo_pattern_set_filter = System.load ("lime", "lime_cairo_pattern_set_filter", 2);
+	private static var lime_cairo_pattern_set_matrix = System.load ("lime", "lime_cairo_pattern_set_matrix", 2);
+	#end
+	
+	
+}

lime/graphics/cairo/CairoSurface.hx

@@ -1,14 +1,55 @@
 package lime.graphics.cairo;
 
 
+import lime.system.System;
+
+
 abstract CairoSurface(Dynamic) {
 	
 	
-	public function new (handle) {
+	public function new (format:CairoFormat, width:Int, height:Int):CairoSurface {
 		
-		this = handle;
+		#if lime_cairo
+		this = lime_cairo_image_surface_create (format, width, height);
+		#else
+		this = 0;
+		#end
 		
 	}
 	
 	
+	public static function createForData (data:Dynamic, format:CairoFormat, width:Int, height:Int, stride:Int):CairoSurface {
+		
+		#if lime_cairo
+		return lime_cairo_image_surface_create_for_data (data, format, width, height, stride);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public function destroy ():Void {
+		
+		#if lime_cairo
+		lime_cairo_surface_destroy (this);
+		#end
+		
+	}
+	
+	
+	
+	
+	// Native Methods
+	
+	
+	
+	
+	#if lime_cairo
+	private static var lime_cairo_image_surface_create = System.load ("lime", "lime_cairo_image_surface_create", 3);
+	private static var lime_cairo_image_surface_create_for_data = System.load ("lime", "lime_cairo_image_surface_create_for_data", 5);
+	private static var lime_cairo_surface_destroy = System.load ("lime", "lime_cairo_surface_destroy", 1);
+	#end
+	
+	
 }

project/Build.xml

@@ -183,6 +183,7 @@
 		<file name="src/graphics/ImageBuffer.cpp" />
 		<file name="src/graphics/RenderEvent.cpp" />
 		<file name="src/math/ColorMatrix.cpp" />
+		<file name="src/math/Matrix3.cpp" />
 		<file name="src/math/Rectangle.cpp" />
 		<file name="src/math/Vector2.cpp" />
 		<file name="src/ui/GamepadEvent.cpp" />

project/include/math/Matrix3.h

@@ -0,0 +1,36 @@
+#ifndef LIME_MATH_MATRIX_3_H
+#define LIME_MATH_MATRIX_3_H
+
+
+#include <hx/CFFI.h>
+
+
+namespace lime {
+	
+	
+	class Matrix3 {
+		
+		
+		public:
+			
+			Matrix3 ();
+			Matrix3 (double a, double b, double c, double d, double tx, double ty);
+			Matrix3 (value matrix3);
+			
+			value Value ();
+			
+			double a;
+			double b;
+			double c;
+			double d;
+			double tx;
+			double ty;
+		
+		
+	};
+	
+	
+}
+
+
+#endif

project/include/math/Rectangle.h

@@ -14,6 +14,7 @@ namespace lime {
 		public:
 			
 			Rectangle ();
+			Rectangle (double x, double y, double width, double height);
 			Rectangle (value rect);
 			
 			double height;

project/src/graphics/cairo/CairoBindings.cpp

@@ -1,10 +1,110 @@
 #include <cairo.h>
+#include <math/Matrix3.h>
 #include <hx/CFFI.h>
 
 
 namespace lime {
 	
 	
+	value lime_cairo_clip (value handle) {
+		
+		cairo_clip ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_close_path (value handle) {
+		
+		cairo_close_path ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_create (value surface) {
+		
+		return alloc_float ((intptr_t)cairo_create ((cairo_surface_t*)(intptr_t)val_float (surface)));
+		
+	}
+	
+	
+	value lime_cairo_destroy (value handle) {
+		
+		cairo_destroy ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_fill (value handle) {
+		
+		cairo_fill ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_fill_preserve (value handle) {
+		
+		cairo_fill_preserve ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_get_line_cap (value handle) {
+		
+		return alloc_int (cairo_get_line_cap ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_get_line_join (value handle) {
+		
+		return alloc_int (cairo_get_line_join ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_get_line_width (value handle) {
+		
+		return alloc_float (cairo_get_line_width ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_get_matrix (value handle) {
+		
+		cairo_matrix_t cm;
+		cairo_get_matrix ((cairo_t*)(intptr_t)val_float (handle), &cm);
+		Matrix3 mat3 = Matrix3 (cm.xx, cm.yx, cm.xy, cm.yy, cm.x0, cm.y0);
+		return mat3.Value ();
+		
+	}
+	
+	
+	value lime_cairo_get_miter_limit (value handle) {
+		
+		return alloc_float (cairo_get_miter_limit ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_get_operator (value handle) {
+		
+		return alloc_int (cairo_get_operator ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_get_source (value handle) {
+		
+		return alloc_float ((intptr_t)cairo_get_source ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
 	value lime_cairo_image_surface_create (value format, value width, value height) {
 		
 		return alloc_float ((intptr_t)cairo_image_surface_create ((cairo_format_t)val_int (format), val_int (width), val_int (height)));
@@ -12,6 +112,306 @@ namespace lime {
 	}
 	
 	
+	value lime_cairo_image_surface_create_for_data (value data, value format, value width, value height, value stride) {
+		
+		return alloc_float ((intptr_t)cairo_image_surface_create_for_data ((unsigned char*)(intptr_t)val_float (data), (cairo_format_t)val_int (format), val_int (width), val_int (height), val_int (stride)));
+		
+	}
+	
+	
+	value lime_cairo_line_to (value handle, value x, value y) {
+		
+		cairo_line_to ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_mask (value handle, value pattern) {
+		
+		cairo_mask ((cairo_t*)(intptr_t)val_float (handle), (cairo_pattern_t*)(intptr_t)val_float (pattern));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_move_to (value handle, value x, value y) {
+		
+		cairo_move_to ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_new_path (value handle) {
+		
+		cairo_new_path ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_paint (value handle) {
+		
+		cairo_paint ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_paint_with_alpha (value handle, value alpha) {
+		
+		cairo_paint_with_alpha ((cairo_t*)(intptr_t)val_float (handle), val_float (alpha));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_pop_group (value handle) {
+		
+		return alloc_float ((intptr_t)cairo_pop_group ((cairo_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_pop_group_to_source (value handle) {
+		
+		cairo_pop_group_to_source ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_push_group (value handle) {
+		
+		cairo_push_group ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_push_group_with_content (value handle, value content) {
+		
+		cairo_push_group_with_content ((cairo_t*)(intptr_t)val_float (handle), (cairo_content_t)val_int (content));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_rectangle (value handle, value x, value y, value width, value height) {
+		
+		cairo_rectangle ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y), val_float (width), val_float (height));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_reset_clip (value handle) {
+		
+		cairo_reset_clip ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_restore (value handle) {
+		
+		cairo_restore ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_save (value handle) {
+		
+		cairo_save ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_line_cap (value handle, value cap) {
+		
+		cairo_set_line_cap ((cairo_t*)(intptr_t)val_float (handle), (cairo_line_cap_t)val_int (cap));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_line_join (value handle, value join) {
+		
+		cairo_set_line_join ((cairo_t*)(intptr_t)val_float (handle), (cairo_line_join_t)val_int (join));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_line_width (value handle, value width) {
+		
+		cairo_set_line_width ((cairo_t*)(intptr_t)val_float (handle), val_float (width));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_matrix (value handle, value matrix) {
+		
+		Matrix3 mat3 = Matrix3 (matrix);
+		
+		cairo_matrix_t cm;
+		cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty);
+		
+		cairo_set_matrix ((cairo_t*)(intptr_t)val_float (handle), &cm);
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_miter_limit (value handle, value miterLimit) {
+		
+		cairo_set_miter_limit ((cairo_t*)(intptr_t)val_float (handle), val_float (miterLimit));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_operator (value handle, value op) {
+		
+		cairo_set_operator ((cairo_t*)(intptr_t)val_float (handle), (cairo_operator_t)val_int (op));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_source (value handle, value pattern) {
+		
+		cairo_set_source ((cairo_t*)(intptr_t)val_float (handle), (cairo_pattern_t*)(intptr_t)val_float (pattern));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_source_rgba (value handle, value r, value g, value b, value a) {
+		
+		cairo_set_source_rgba ((cairo_t*)(intptr_t)val_float (handle), val_float (r), val_float (g), val_float (b), val_float (a));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_set_source_surface (value handle, value surface, value x, value y) {
+		
+		cairo_set_source_surface ((cairo_t*)(intptr_t)val_float (handle), (cairo_surface_t*)(intptr_t)val_float (surface), val_float (x), val_float (y));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_stroke (value handle) {
+		
+		cairo_stroke ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_stroke_preserve (value handle) {
+		
+		cairo_stroke_preserve ((cairo_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_transform (value handle, value matrix) {
+		
+		Matrix3 mat3 = Matrix3 (matrix);
+		
+		cairo_matrix_t cm;
+		cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty);
+		
+		cairo_transform ((cairo_t*)(intptr_t)val_float (handle), &cm);
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_pattern_create_for_surface (value surface) {
+		
+		return alloc_float ((intptr_t)cairo_pattern_create_for_surface ((cairo_surface_t*)(intptr_t)val_float (surface)));
+		
+	}
+	
+	
+	value lime_cairo_pattern_destroy (value handle) {
+		
+		cairo_pattern_destroy ((cairo_pattern_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_pattern_get_extend (value handle) {
+		
+		return alloc_int (cairo_pattern_get_extend ((cairo_pattern_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_pattern_set_extend (value handle, value extend) {
+		
+		cairo_pattern_set_extend ((cairo_pattern_t*)(intptr_t)val_float (handle), (cairo_extend_t)val_int (extend));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_pattern_get_filter (value handle) {
+		
+		return alloc_int (cairo_pattern_get_filter ((cairo_pattern_t*)(intptr_t)val_float (handle)));
+		
+	}
+	
+	
+	value lime_cairo_pattern_set_filter (value handle, value filter) {
+		
+		cairo_pattern_set_filter ((cairo_pattern_t*)(intptr_t)val_float (handle), (cairo_filter_t)val_int (filter));
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_pattern_get_matrix (value handle) {
+		
+		cairo_matrix_t cm;
+		cairo_pattern_get_matrix ((cairo_pattern_t*)(intptr_t)val_float (handle), &cm);
+		Matrix3 mat3 = Matrix3 (cm.xx, cm.yx, cm.xy, cm.yy, cm.x0, cm.y0);
+		return mat3.Value ();
+		
+	}
+	
+	
+	value lime_cairo_pattern_set_matrix (value handle, value matrix) {
+		
+		Matrix3 mat3 = Matrix3 (matrix);
+		
+		cairo_matrix_t cm;
+		cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty);
+		
+		cairo_pattern_set_matrix ((cairo_pattern_t*)(intptr_t)val_float (handle), &cm);
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_cairo_surface_destroy (value handle) {
+		
+		cairo_surface_destroy ((cairo_surface_t*)(intptr_t)val_float (handle));
+		return alloc_null ();
+		
+	}
+	
+	
 	value lime_cairo_version () {
 		
 		return alloc_int (cairo_version ());
@@ -26,7 +426,56 @@ namespace lime {
 	}
 	
 	
+	DEFINE_PRIM (lime_cairo_clip, 1);
+	DEFINE_PRIM (lime_cairo_close_path, 1);
+	DEFINE_PRIM (lime_cairo_create, 1);
+	DEFINE_PRIM (lime_cairo_destroy, 1);
+	DEFINE_PRIM (lime_cairo_fill, 1);
+	DEFINE_PRIM (lime_cairo_fill_preserve, 1);
+	DEFINE_PRIM (lime_cairo_get_line_cap, 1);
+	DEFINE_PRIM (lime_cairo_get_line_join, 1);
+	DEFINE_PRIM (lime_cairo_get_line_width, 1);
+	DEFINE_PRIM (lime_cairo_get_matrix, 1);
+	DEFINE_PRIM (lime_cairo_get_miter_limit, 1);
+	DEFINE_PRIM (lime_cairo_get_operator, 1);
+	DEFINE_PRIM (lime_cairo_get_source, 1);
 	DEFINE_PRIM (lime_cairo_image_surface_create, 3);
+	DEFINE_PRIM (lime_cairo_image_surface_create_for_data, 5);
+	DEFINE_PRIM (lime_cairo_line_to, 3);
+	DEFINE_PRIM (lime_cairo_mask, 2);
+	DEFINE_PRIM (lime_cairo_move_to, 3);
+	DEFINE_PRIM (lime_cairo_new_path, 1);
+	DEFINE_PRIM (lime_cairo_paint, 1);
+	DEFINE_PRIM (lime_cairo_paint_with_alpha, 2);
+	DEFINE_PRIM (lime_cairo_pop_group, 1);
+	DEFINE_PRIM (lime_cairo_pop_group_to_source, 1);
+	DEFINE_PRIM (lime_cairo_push_group, 1);
+	DEFINE_PRIM (lime_cairo_push_group_with_content, 2);
+	DEFINE_PRIM (lime_cairo_rectangle, 5);
+	DEFINE_PRIM (lime_cairo_reset_clip, 1);
+	DEFINE_PRIM (lime_cairo_restore, 1);
+	DEFINE_PRIM (lime_cairo_save, 1);
+	DEFINE_PRIM (lime_cairo_set_line_cap, 2);
+	DEFINE_PRIM (lime_cairo_set_line_join, 2);
+	DEFINE_PRIM (lime_cairo_set_line_width, 2);
+	DEFINE_PRIM (lime_cairo_set_matrix, 2);
+	DEFINE_PRIM (lime_cairo_set_miter_limit, 2);
+	DEFINE_PRIM (lime_cairo_set_operator, 2);
+	DEFINE_PRIM (lime_cairo_set_source, 2);
+	DEFINE_PRIM (lime_cairo_set_source_rgba, 5);
+	DEFINE_PRIM (lime_cairo_set_source_surface, 4);
+	DEFINE_PRIM (lime_cairo_stroke, 1);
+	DEFINE_PRIM (lime_cairo_stroke_preserve, 1);
+	DEFINE_PRIM (lime_cairo_transform, 2);
+	DEFINE_PRIM (lime_cairo_pattern_create_for_surface, 1);
+	DEFINE_PRIM (lime_cairo_pattern_destroy, 1);
+	DEFINE_PRIM (lime_cairo_pattern_get_extend, 1);
+	DEFINE_PRIM (lime_cairo_pattern_get_filter, 1);
+	DEFINE_PRIM (lime_cairo_pattern_get_matrix, 1);
+	DEFINE_PRIM (lime_cairo_pattern_set_extend, 2);
+	DEFINE_PRIM (lime_cairo_pattern_set_filter, 2);
+	DEFINE_PRIM (lime_cairo_pattern_set_matrix, 2);
+	DEFINE_PRIM (lime_cairo_surface_destroy, 1);
 	DEFINE_PRIM (lime_cairo_version, 0);
 	DEFINE_PRIM (lime_cairo_version_string, 0);
 	

project/src/math/Matrix3.cpp

@@ -0,0 +1,78 @@
+#include <math/Matrix3.h>
+
+
+namespace lime {
+	
+	
+	static int id_a;
+	static int id_b;
+	static int id_c;
+	static int id_d;
+	static int id_tx;
+	static int id_ty;
+	static bool init = false;
+	
+	
+	Matrix3::Matrix3 () {
+		
+		a = 1;
+		b = 0;
+		c = 0;
+		d = 1;
+		tx = 0;
+		ty = 0;
+		
+	}
+	
+	
+	Matrix3::Matrix3 (double a, double b, double c, double d, double tx, double ty) {
+		
+		this->a = a;
+		this->b = b;
+		this->c = c;
+		this->d = d;
+		this->tx = tx;
+		this->ty = ty;
+		
+	}
+	
+	
+	Matrix3::Matrix3 (value mat3) {
+		
+		if (!init) {
+			
+			id_a = val_id ("a");
+			id_b = val_id ("b");
+			id_c = val_id ("c");
+			id_d = val_id ("d");
+			id_tx = val_id ("tx");
+			id_ty = val_id ("ty");
+			init = true;
+			
+		}
+		
+		a = val_number (val_field (mat3, id_a));
+		b = val_number (val_field (mat3, id_b));
+		c = val_number (val_field (mat3, id_c));
+		d = val_number (val_field (mat3, id_d));
+		tx = val_number (val_field (mat3, id_tx));
+		ty = val_number (val_field (mat3, id_ty));
+		
+	}
+	
+	
+	value Matrix3::Value () {
+		
+		value result = alloc_empty_object ();
+		alloc_field (result, id_a, alloc_float (a));
+		alloc_field (result, id_b, alloc_float (b));
+		alloc_field (result, id_c, alloc_float (c));
+		alloc_field (result, id_d, alloc_float (d));
+		alloc_field (result, id_tx, alloc_float (tx));
+		alloc_field (result, id_ty, alloc_float (ty));
+		return result;
+		
+	}
+	
+	
+}

project/src/math/Rectangle.cpp

@@ -21,6 +21,16 @@ namespace lime {
 	}
 	
 	
+	Rectangle::Rectangle (double x, double y, double width, double height) {
+		
+		this->height = height;
+		this->width = width;
+		this->x = x;
+		this->y = y;
+		
+	}
+	
+	
 	Rectangle::Rectangle (value rect) {
 		
 		if (!init) {