rays 0.1.3 → 0.1.4

data/ext/rays/native.cpp

@@ -6,6 +6,9 @@ using namespace Rucy;
 
 
 void Init_rays ();
+void Init_point ();
+void Init_bounds ();
+void Init_color ();
 void Init_bitmap ();
 void Init_texture ();
 void Init_image ();
@@ -20,6 +23,9 @@ Init_native ()
 		raise(rb_eLoadError, "Rucy::init() failed.");
 
 	Init_rays();
+	Init_point();
+	Init_bounds();
+	Init_color();
 	Init_bitmap();
 	Init_texture();
 	Init_image();

data/ext/rays/painter.cpp

@@ -2,8 +2,11 @@
 
 
 #include <rucy.h>
-#include <rays/ruby/image.h>
+#include <rays/ruby/bounds.h>
+#include <rays/ruby/color.h>
+#include <rays/ruby/matrix.h>
 #include <rays/ruby/font.h>
+#include <rays/ruby/image.h>
 #include "defs.h"
 
 
@@ -12,12 +15,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cPainter;
+
+
 namespace Rays
 {
 
 
-	static Class cPainter;
-
 	Class
 	painter_class ()
 	{
@@ -33,25 +37,30 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Painter& painter)
+	value (const Rays::Painter& obj)
 	{
-		return new_type<Rays::Painter>(
-			Rays::painter_class(), new Rays::Painter(painter));
+		return new_type(cPainter, new Rays::Painter(obj));
+	}
+
+	Value
+	value (const Rays::Painter* obj)
+	{
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Painter*>(self)
+#define THIS to<Rays::Painter*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Painter, Rays::painter_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Painter, cPainter)
 
 
 static
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Rays::Painter>(klass, new Rays::Painter);
+	return new_type<Rays::Painter>(klass);
 }
 RUBY_END
 
@@ -64,56 +73,32 @@ RUBY_DEF4(canvas, x, y, width, height)
 	coord yy = to<coord>(y);
 	coord ww = to<coord>(width);
 	coord hh = to<coord>(height);
-	if (!this->canvas(xx, yy, ww, hh))
-		error("Painter#canvas(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	if (!THIS->canvas(xx, yy, ww, hh))
+		rays_error("Painter#canvas(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
 
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(begin)
+RUBY_DEF0(begin_paint)
 {
 	CHECK;
 
-	if (!this->begin())
-		error("Painter#begin() failed.");
+	if (!THIS->begin())
+		rays_error("Painter#begin_paint() failed.");
 
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(end)
+RUBY_DEF0(end_paint)
 {
 	CHECK;
 
-	if (!this->end())
-		error("Painter#end() failed.");
-
-	return self;
-}
-RUBY_END
-
-static
-RUBY_DEF0(push_matrix)
-{
-	CHECK;
-
-	if (!this->push_matrix())
-		error("Painter#push_matrix() failed.");
-
-	return self;
-}
-RUBY_END
-
-static
-RUBY_DEF0(pop_matrix)
-{
-	CHECK;
-
-	if (!this->pop_matrix())
-		error("Painter#pop_matrix() failed.");
+	if (!THIS->end())
+		rays_error("Painter#end_paint() failed.");
 
 	return self;
 }
@@ -129,8 +114,8 @@ RUBY_DEF4(line, x1_, y1_, x2_, y2_)
 	coord y1 = to<coord>(y1_);
 	coord x2 = to<coord>(x2_);
 	coord y2 = to<coord>(y2_);
-	if (!this->line(x1, y1, x2, y2))
-		error("Painter#line(%f, %f, %f, %f) failed.", x1, y1, x2, y2);
+	if (!THIS->line(x1, y1, x2, y2))
+		rays_error("Painter#line(%f, %f, %f, %f) failed.", x1, y1, x2, y2);
 
 	return self;
 }
@@ -145,8 +130,8 @@ RUBY_DEF4(rect, x, y, width, height)
 	coord yy = to<coord>(y);
 	coord ww = to<coord>(width);
 	coord hh = to<coord>(height);
-	if (!this->rect(xx, yy, ww, hh))
-		error("Painter#rect(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	if (!THIS->rect(xx, yy, ww, hh))
+		rays_error("Painter#rect(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
 
 	return self;
 }
@@ -165,9 +150,9 @@ RUBY_DEFN(ellipse)
 	coord hh   = (argc >= 4) ? to<coord>(argv[3]) : 0;
 	coord min_ = (argc >= 5) ? to<coord>(argv[4]) : 0;
 	uint nseg  = (argc >= 6) ? to<uint>(argv[5])  : 0;
-	if (!this->ellipse(xx, yy, ww, hh, min_, nseg))
+	if (!THIS->ellipse(xx, yy, ww, hh, min_, nseg))
 	{
-		error(
+		rays_error(
 			"Painter#ellipse(%f, %f, %f, %f, %f, %d) failed.",
 			xx, yy, ww, hh, min_, nseg);
 	}
@@ -191,9 +176,9 @@ RUBY_DEFN(arc)
 	float to_  = (argc >= 6) ? to<float>(argv[5]) : 360;
 	coord min_ = (argc >= 7) ? to<coord>(argv[6]) : 0;
 	uint nseg  = (argc >= 8) ? to<uint>(argv[7])  : 0;
-	if (!this->arc(xx, yy, ww, hh, from, to_, min_, nseg))
+	if (!THIS->arc(xx, yy, ww, hh, from, to_, min_, nseg))
 	{
-		error(
+		rays_error(
 			"Painter#arc(%f, %f, %f, %f, %f, %f, %f, %d) failed.",
 			xx, yy, ww, hh, from, to_, min_, nseg);
 	}
@@ -215,15 +200,15 @@ RUBY_DEFN(image)
 
 	if (argc == 1)
 	{
-		if (!this->image(*image))
-			error("Painter#image(%s) failed.", argv[0].inspect().c_str());
+		if (!THIS->image(*image))
+			rays_error("Painter#image(%s) failed.", argv[0].inspect().c_str());
 	}
 	else if (argc == 3)
 	{
 		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
-		if (!this->image(*image, x, y))
+		if (!THIS->image(*image, x, y))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f) failed.",
 				argv[0].inspect().c_str(), x, y);
 		}
@@ -232,9 +217,9 @@ RUBY_DEFN(image)
 	{
 		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
 		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
-		if (!this->image(*image, x, y, w, h))
+		if (!THIS->image(*image, x, y, w, h))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f, %f, %f) failed.",
 				argv[0].inspect().c_str(), x, y, w, h);
 		}
@@ -245,9 +230,9 @@ RUBY_DEFN(image)
 		coord sy = to<coord>(argv[2]), dy = to<coord>(argv[6]);
 		coord sw = to<coord>(argv[3]);
 		coord sh = to<coord>(argv[4]);
-		if (!this->image(*image, sx, sy, sw, sh, dx, dy))
+		if (!THIS->image(*image, sx, sy, sw, sh, dx, dy))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f, %f, %f, %f, %f) failed.",
 				argv[0].inspect().c_str(), sx, sy, sw, sh, dx, dy);
 		}
@@ -258,9 +243,9 @@ RUBY_DEFN(image)
 		coord sy = to<coord>(argv[2]), dy = to<coord>(argv[6]);
 		coord sw = to<coord>(argv[3]), dw = to<coord>(argv[7]);
 		coord sh = to<coord>(argv[4]), dh = to<coord>(argv[8]);
-		if (!this->image(*image, sx, sy, sw, sh, dx, dy, dw, dh))
+		if (!THIS->image(*image, sx, sy, sw, sh, dx, dy, dw, dh))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f, %f, %f, %f, %f, %f, %f) failed.",
 				argv[0].inspect().c_str(), sx, sy, sw, sh, dx, dy, dw, dh);
 		}
@@ -279,15 +264,15 @@ RUBY_DEFN(text)
 
 	if (argc == 1)
 	{
-		if (!this->text(argv[0].c_str()))
-			error("Painter#text(%s) failed.", argv[0].inspect().c_str());
+		if (!THIS->text(argv[0].c_str()))
+			rays_error("Painter#text(%s) failed.", argv[0].inspect().c_str());
 	}
 	else if (argc == 3)
 	{
 		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
-		if (!this->text(argv[0].c_str(), x, y))
+		if (!THIS->text(argv[0].c_str(), x, y))
 		{
-			error(
+			rays_error(
 				"Painter#text(%s, %f, %f) failed.",
 				argv[0].inspect().c_str(), x, y);
 		}
@@ -296,12 +281,12 @@ RUBY_DEFN(text)
 	{
 		const Rays::Font* font = to<Rays::Font*>(argv[3]);
 		if (!font || !*font)
-			error("Painter#text: invalid font.");
+			rays_error("Painter#text: invalid font.");
 
 		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
-		if (!this->text(argv[0].c_str(), x, y, *font))
+		if (!THIS->text(argv[0].c_str(), x, y, font))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f, %s) failed.",
 				argv[0].inspect().c_str(), x, y, argv[3].inspect().c_str());
 		}
@@ -310,9 +295,9 @@ RUBY_DEFN(text)
 	{
 		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
 		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
-		if (!this->text(argv[0].c_str(), x, y, w, h))
+		if (!THIS->text(argv[0].c_str(), x, y, w, h))
 		{
-			error(
+			rays_error(
 				"Painter#text(%s, %f, %f, %f, %f) failed.",
 				argv[0].inspect().c_str(), x, y, w, h);
 		}
@@ -321,13 +306,13 @@ RUBY_DEFN(text)
 	{
 		const Rays::Font* font = to<Rays::Font*>(argv[3]);
 		if (!font || !*font)
-			error("Painter#text: invalid font.");
+			rays_error("Painter#text: invalid font.");
 
 		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
 		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
-		if (!this->text(argv[0].c_str(), x, y, w, h, *font))
+		if (!THIS->text(argv[0].c_str(), x, y, w, h, font))
 		{
-			error(
+			rays_error(
 				"Painter#image(%s, %f, %f, %f, %f, %s) failed.",
 				argv[0].inspect().c_str(), x, y, w, h, argv[3].inspect().c_str());
 		}
@@ -338,32 +323,18 @@ RUBY_DEFN(text)
 RUBY_END
 
 static
-RUBY_DEF0(get_clear)
-{
-	CHECK;
-
-	coord red = 0, green = 0, blue = 0, alpha = 0;
-	if (!this->get_clear(&red, &green, &blue, &alpha))
-		error("failed to get color for clear.");
-
-	Value ret[] = {red, green, blue, alpha};
-	return value(4, ret);
-}
-RUBY_END
-
-static
-RUBY_DEFN(set_clear)
+RUBY_DEFN(set_background)
 {
 	CHECK;
 	if (argc < 1 || 4 < argc)
-		arg_count_error("Painter#set_clear", argc, 1, 2, 3, 4);
+		arg_count_error("Painter#set_background", argc, 1, 2, 3, 4);
 
 	if (argc == 1 || argc == 2)
 	{
 		float v = to<float>(argv[0]);
 		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		if (!this->set_clear(v, v, v, a))
-			error("Painter#set_clear(%f, %f) failed.", v, a);
+		if (!THIS->set_background(v, v, v, a))
+			rays_error("Painter#set_background(%f, %f) failed.", v, a);
 	}
 	else
 	{
@@ -371,8 +342,8 @@ RUBY_DEFN(set_clear)
 		float g = to<float>(argv[1]);
 		float b = to<float>(argv[2]);
 		float a = (argc == 4) ? to<float>(argv[3]) : 1;
-		if (!this->set_clear(r, g, b, a))
-			error("Painter#set_clear(%f, %f, %f, %f) failed.", r, g, b, a);
+		if (!THIS->set_background(r, g, b, a))
+			rays_error("Painter#set_background(%f, %f, %f, %f) failed.", r, g, b, a);
 	}
 
 	return self;
@@ -380,28 +351,23 @@ RUBY_DEFN(set_clear)
 RUBY_END
 
 static
-RUBY_DEF0(no_clear)
+RUBY_DEF0(no_background)
 {
 	CHECK;
 
-	if (!this->no_clear())
-		error("Painter#no_clear() failed.");
+	if (!THIS->no_background())
+		rays_error("Painter#no_clear() failed.");
 
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(get_fill)
+RUBY_DEF0(get_background)
 {
 	CHECK;
 
-	coord red = 0, green = 0, blue = 0, alpha = 0;
-	if (!this->get_fill(&red, &green, &blue, &alpha))
-		error("failed to get color for fill.");
-
-	Value ret[] = {red, green, blue, alpha};
-	return value(4, ret);
+	return value(THIS->background());
 }
 RUBY_END
 
@@ -416,8 +382,8 @@ RUBY_DEFN(set_fill)
 	{
 		float v = to<float>(argv[0]);
 		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		if (!this->set_fill(v, v, v, a))
-			error("Painter#set_fill(%f, %f) failed.", v, a);
+		if (!THIS->set_fill(v, v, v, a))
+			rays_error("Painter#set_fill(%f, %f) failed.", v, a);
 	}
 	else
 	{
@@ -425,8 +391,8 @@ RUBY_DEFN(set_fill)
 		float g = to<float>(argv[1]);
 		float b = to<float>(argv[2]);
 		float a = (argc == 4) ? to<float>(argv[3]) : 1;
-		if (!this->set_fill(r, g, b, a))
-			error("Painter#set_fill(%f, %f, %f, %f) failed.", r, g, b, a);
+		if (!THIS->set_fill(r, g, b, a))
+			rays_error("Painter#set_fill(%f, %f, %f, %f) failed.", r, g, b, a);
 	}
 
 	return self;
@@ -438,24 +404,19 @@ RUBY_DEF0(no_fill)
 {
 	CHECK;
 
-	if (!this->no_fill())
-		error("Painter#no_fill() failed.");
+	if (!THIS->no_fill())
+		rays_error("Painter#no_fill() failed.");
 
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(get_stroke)
+RUBY_DEF0(get_fill)
 {
 	CHECK;
 
-	coord red = 0, green = 0, blue = 0, alpha = 0;
-	if (!this->get_stroke(&red, &green, &blue, &alpha))
-		error("failed to get color for stroke.");
-
-	Value ret[] = {red, green, blue, alpha};
-	return value(4, ret);
+	return value(THIS->fill());
 }
 RUBY_END
 
@@ -470,8 +431,8 @@ RUBY_DEFN(set_stroke)
 	{
 		float v = to<float>(argv[0]);
 		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		if (!this->set_stroke(v, v, v, a))
-			error("Painter#set_stroke(%f, %f) failed.", v, a);
+		if (!THIS->set_stroke(v, v, v, a))
+			rays_error("Painter#set_stroke(%f, %f) failed.", v, a);
 	}
 	else
 	{
@@ -479,8 +440,8 @@ RUBY_DEFN(set_stroke)
 		float g = to<float>(argv[1]);
 		float b = to<float>(argv[2]);
 		float a = (argc == 4) ? to<float>(argv[3]) : 1;
-		if (!this->set_stroke(r, g, b, a))
-			error("Painter#set_stroke(%f, %f, %f, %f) failed.", r, g, b, a);
+		if (!THIS->set_stroke(r, g, b, a))
+			rays_error("Painter#set_stroke(%f, %f, %f, %f) failed.", r, g, b, a);
 	}
 
 	return self;
@@ -492,24 +453,19 @@ RUBY_DEF0(no_stroke)
 {
 	CHECK;
 
-	if (!this->no_stroke())
-		error("Painter#no_stroke() failed.");
+	if (!THIS->no_stroke())
+		rays_error("Painter#no_stroke() failed.");
 
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(get_clip)
+RUBY_DEF0(get_stroke)
 {
 	CHECK;
 
-	coord x = 0, y = 0, width = 0, height = 0;
-	if (!this->get_clip(&x, &y, &width, &height))
-		error("failed to get clip rect.");
-
-	Value ret[] = {x, y, width, height};
-	return value(4, ret);
+	return value(THIS->stroke());
 }
 RUBY_END
 
@@ -520,8 +476,8 @@ RUBY_DEF4(set_clip, x, y, width, height)
 
 	coord xx = to<coord>(x), ww = to<coord>(width);
 	coord yy = to<coord>(y), hh = to<coord>(height);
-	if (!this->set_clip(xx, yy, ww, hh))
-		error("Painter#set_clip(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	if (!THIS->set_clip(xx, yy, ww, hh))
+		rays_error("Painter#set_clip(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
 
 	return self;
 }
@@ -532,8 +488,169 @@ RUBY_DEF0(no_clip)
 {
 	CHECK;
 
-	if (!this->no_clip())
-		error("Painter#no_clip() failed.");
+	if (!THIS->no_clip())
+		rays_error("Painter#no_clip() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_clip)
+{
+	CHECK;
+
+	return value(THIS->clip());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_font, font)
+{
+	CHECK;
+
+	const Rays::Font* f = font.is_nil()
+		? &Rays::default_font()
+		: to<Rays::Font*>(font);
+	if (!f || !*f) argument_error();
+
+	if (!THIS->set_font(*f))
+		rays_error("Painter#set_font(%s) failed.", font.inspect().c_str());
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_font)
+{
+	CHECK;
+
+	return value(THIS->font());
+}
+RUBY_END
+
+static
+RUBY_DEF0(push_attrs)
+{
+	CHECK;
+
+	if (!THIS->push_attrs())
+		rays_error("Painter#push_attrs() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(pop_attrs)
+{
+	CHECK;
+
+	if (!THIS->pop_attrs())
+		rays_error("Painter#pop_attrs() failed.");
+
+	return self;
+}
+RUBY_END
+
+
+static
+RUBY_DEFN(translate)
+{
+	CHECK;
+	if (argc < 2 || 3 < argc)
+		arg_count_error("Painter#translate", argc, 2, 3);
+
+	coord xx = to<coord>(argv[0]);
+	coord yy = to<coord>(argv[1]);
+	coord zz = (argc >= 3) ? to<coord>(argv[2]) : 0;
+	if (!THIS->translate(xx, yy, zz))
+		rays_error("Painter#translate(%f %f %f) failed.", xx, yy, zz);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(scale)
+{
+	CHECK;
+	if (argc < 2 || 3 < argc)
+		arg_count_error("Painter#scale", argc, 2, 3);
+
+	coord xx = to<coord>(argv[0]);
+	coord yy = to<coord>(argv[1]);
+	coord zz = (argc >= 3) ? to<coord>(argv[2]) : 1;
+	if (!THIS->scale(xx, yy, zz))
+		rays_error("Painter#scale(%f %f %f) failed.", xx, yy, zz);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(rotate)
+{
+	CHECK;
+	if (argc != 1 && argc != 3 && argc != 4)
+		arg_count_error("Painter#rotate", argc, 1, 3, 4);
+
+	coord aa = to<coord>(argv[0]), xx = 0, yy = 0, zz = 1;
+	if (argc >= 3)
+	{
+		xx = to<coord>(argv[1]);
+		yy = to<coord>(argv[2]);
+		zz = argc >= 4 ? to<coord>(argv[3]) : 0;
+	}
+
+	if (!THIS->rotate(aa, xx, yy, zz))
+		rays_error("Painter#rotate(%f %f %f %f) failed.", aa, xx, yy, zz);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(set_matrix)
+{
+	CHECK;
+
+	if (!THIS->set_matrix())
+		rays_error("Painter#set_matrix() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_matrix)
+{
+	CHECK;
+
+	return value(THIS->matrix());
+}
+RUBY_END
+
+static
+RUBY_DEF0(push_matrix)
+{
+	CHECK;
+
+	if (!THIS->push_matrix())
+		rays_error("Painter#push_matrix() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(pop_matrix)
+{
+	CHECK;
+
+	if (!THIS->pop_matrix())
+		rays_error("Painter#pop_matrix() failed.");
 
 	return self;
 }
@@ -543,36 +660,44 @@ RUBY_END
 void
 Init_painter ()
 {
-	Module m = define_module("Rays");
-
-	Class c = m.define_class("Painter");
-	Rays::cPainter = c;
-
-	c.define_alloc_func(alloc);
-
-	c.define_method("canvas", canvas);
-	c.define_method("begin", begin);
-	c.define_method("end", end);
-	c.define_method("push_matrix", push_matrix);
-	c.define_method("pop_matrix", pop_matrix);
-
-	c.define_private_method("draw_line", line);
-	c.define_private_method("draw_rect", rect);
-	c.define_private_method("draw_ellipse", ellipse);
-	c.define_private_method("draw_arc", arc);
-	c.define_private_method("draw_image", image);
-	c.define_private_method("draw_text", text);
-
-	c.define_method("get_fill", get_fill);
-	c.define_method("set_fill", set_fill);
-	c.define_method("no_fill",  no_fill);
-	c.define_method("get_stroke", get_stroke);
-	c.define_method("set_stroke", set_stroke);
-	c.define_method("no_stroke",  no_stroke);
-	c.define_method("get_clear", get_clear);
-	c.define_method("set_clear", set_clear);
-	c.define_method("no_clear",  no_clear);
-	c.define_method("get_clip", get_clip);
-	c.define_method("set_clip", set_clip);
-	c.define_method("no_clip",  no_clip);
+	Module mRays = define_module("Rays");
+
+	cPainter= mRays.define_class("Painter");
+	cPainter.define_alloc_func(alloc);
+
+	cPainter.define_method("canvas", canvas);
+	cPainter.define_method("begin_paint", begin_paint);
+	cPainter.define_method("end_paint", end_paint);
+
+	cPainter.define_method("line", line);
+	cPainter.define_method("rect", rect);
+	cPainter.define_method("ellipse", ellipse);
+	cPainter.define_method("arc", arc);
+	cPainter.define_method("image", image);
+	cPainter.define_method("text", text);
+
+	cPainter.define_method("set_background", set_background);
+	cPainter.define_method("no_background",  no_background);
+	cPainter.define_method("get_background", get_background);
+	cPainter.define_method("set_fill", set_fill);
+	cPainter.define_method("no_fill",  no_fill);
+	cPainter.define_method("get_fill", get_fill);
+	cPainter.define_method("set_stroke", set_stroke);
+	cPainter.define_method("no_stroke",  no_stroke);
+	cPainter.define_method("get_stroke", get_stroke);
+	cPainter.define_method("set_clip", set_clip);
+	cPainter.define_method("no_clip",  no_clip);
+	cPainter.define_method("get_clip", get_clip);
+	cPainter.define_method("set_font", set_font);
+	cPainter.define_method("get_font", get_font);
+	cPainter.define_method("push_attrs", push_attrs);
+	cPainter.define_method("pop_attrs", pop_attrs);
+
+	cPainter.define_method("translate", translate);
+	cPainter.define_method("scale", push_matrix);
+	cPainter.define_method("rotate", push_matrix);
+	cPainter.define_method("set_matrix", push_matrix);
+	cPainter.define_method("get_matrix", push_matrix);
+	cPainter.define_method("push_matrix", push_matrix);
+	cPainter.define_method("pop_matrix", pop_matrix);
 }