path: root/liblogdiag/ld-lua.c

/*
 * ld-lua.c
 *
 * This file is a part of logdiag.
 * Copyright Přemysl Janouch 2010, 2011, 2012. All rights reserved.
 *
 * See the file LICENSE for licensing information.
 *
 */

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#include "liblogdiag.h"
#include "config.h"

#include "ld-lua-private.h"
#include "ld-lua-symbol-private.h"


/**
 * SECTION:ld-lua
 * @short_description: Lua symbol engine
 * @see_also: #LdLuaSymbol
 *
 * #LdLua is a symbol engine that uses Lua scripts to manage symbols.
 */

/*
 * LdLuaPrivate:
 * @L: Lua state.
 *
 * The library contains the real function for rendering.
 */
struct _LdLuaPrivate
{
	lua_State *L;
};

/* registry.logdiag_symbols
 *   -> A table indexed by pointers to LdLuaSymbol objects
 * registry.logdiag_symbols.object.render(cr)
 *   -> The rendering function
 */

#define LD_LUA_LIBRARY_NAME   "logdiag"
#define LD_LUA_DATA_INDEX     LD_LUA_LIBRARY_NAME "_data"
#define LD_LUA_SYMBOLS_INDEX  LD_LUA_LIBRARY_NAME "_symbols"
#define LD_LUA_META_INDEX     LD_LUA_LIBRARY_NAME "_meta"

/*
 * LdLuaData:
 * @self: a reference to self.
 * @load_callback: a callback for newly registered symbols.
 * @load_user_data: user data to be passed to the callback.
 *
 * Full user data to be stored in Lua registry.
 */
typedef struct _LdLuaData LdLuaData;

struct _LdLuaData
{
	LdLua *self;
	LdLuaLoadCallback load_callback;
	gpointer load_user_data;
};

typedef struct _LdLuaDrawData LdLuaDrawData;

struct _LdLuaDrawData
{
	LdLuaSymbol *symbol;
	cairo_t *cr;
	unsigned save_count;
};

static void ld_lua_finalize (GObject *gobject);

static void *ld_lua_alloc (void *ud, void *ptr, size_t osize, size_t nsize);

static int ld_lua_private_draw_cb (lua_State *L);
static int ld_lua_private_unregister_cb (lua_State *L);

static int ld_lua_logdiag_register (lua_State *L);
static int process_registration (lua_State *L);
static gchar *get_translation (lua_State *L, int index);
static gboolean read_symbol_area (lua_State *L, int index, LdRectangle *area);
static gboolean read_terminals (lua_State *L, int index,
	LdPointArray **terminals);

static gdouble get_cairo_scale (cairo_t *cr);
static int ld_lua_cairo_save (lua_State *L);
static int ld_lua_cairo_restore (lua_State *L);
static int ld_lua_cairo_get_line_width (lua_State *L);
static int ld_lua_cairo_set_line_width (lua_State *L);
static int ld_lua_cairo_translate (lua_State *L);
static int ld_lua_cairo_scale (lua_State *L);
static int ld_lua_cairo_rotate (lua_State *L);
static int ld_lua_cairo_move_to (lua_State *L);
static int ld_lua_cairo_line_to (lua_State *L);
static int ld_lua_cairo_curve_to (lua_State *L);
static int ld_lua_cairo_arc (lua_State *L);
static int ld_lua_cairo_arc_negative (lua_State *L);
static int ld_lua_cairo_new_path (lua_State *L);
static int ld_lua_cairo_new_sub_path (lua_State *L);
static int ld_lua_cairo_close_path (lua_State *L);
static int ld_lua_cairo_stroke (lua_State *L);
static int ld_lua_cairo_stroke_preserve (lua_State *L);
static int ld_lua_cairo_fill (lua_State *L);
static int ld_lua_cairo_fill_preserve (lua_State *L);
static int ld_lua_cairo_clip (lua_State *L);
static int ld_lua_cairo_clip_preserve (lua_State *L);
static int ld_lua_cairo_show_text (lua_State *L);


static luaL_Reg ld_lua_logdiag_lib[] =
{
	{"register", ld_lua_logdiag_register},
	{NULL, NULL}
};

static luaL_Reg ld_lua_cairo_table[] =
{
	{"save", ld_lua_cairo_save},
	{"restore", ld_lua_cairo_restore},
	{"get_line_width", ld_lua_cairo_get_line_width},
	{"set_line_width", ld_lua_cairo_set_line_width},
	{"translate", ld_lua_cairo_translate},
	{"scale", ld_lua_cairo_scale},
	{"rotate", ld_lua_cairo_rotate},
	{"move_to", ld_lua_cairo_move_to},
	{"line_to", ld_lua_cairo_line_to},
	{"curve_to", ld_lua_cairo_curve_to},
	{"arc", ld_lua_cairo_arc},
	{"arc_negative", ld_lua_cairo_arc_negative},
	{"new_path", ld_lua_cairo_new_path},
	{"new_sub_path", ld_lua_cairo_new_sub_path},
	{"close_path", ld_lua_cairo_close_path},
	{"stroke", ld_lua_cairo_stroke},
	{"stroke_preserve", ld_lua_cairo_stroke_preserve},
	{"fill", ld_lua_cairo_fill},
	{"fill_preserve", ld_lua_cairo_fill_preserve},
	{"clip", ld_lua_cairo_clip},
	{"clip_preserve", ld_lua_cairo_clip_preserve},
	{"show_text", ld_lua_cairo_show_text},
	{NULL, NULL}
};


/* ===== Generic =========================================================== */

G_DEFINE_TYPE (LdLua, ld_lua, G_TYPE_OBJECT);

static void
ld_lua_class_init (LdLuaClass *klass)
{
	GObjectClass *object_class;

	object_class = G_OBJECT_CLASS (klass);
	object_class->finalize = ld_lua_finalize;

	g_type_class_add_private (klass, sizeof (LdLuaPrivate));
}

static void
push_cairo_metatable (lua_State *L)
{
	luaL_Reg *fn;

	luaL_newmetatable (L, LD_LUA_META_INDEX);

	/* Create a method table. */
	lua_newtable (L);
	for (fn = ld_lua_cairo_table; fn->name; fn++)
	{
		lua_pushcfunction (L, fn->func);
		lua_setfield (L, -2, fn->name);
	}

	lua_setfield (L, -2, "__index");
}

static void
ld_lua_init (LdLua *self)
{
	lua_State *L;
	LdLuaData *ud;

	self->priv = G_TYPE_INSTANCE_GET_PRIVATE
		(self, LD_TYPE_LUA, LdLuaPrivate);

	L = self->priv->L = lua_newstate (ld_lua_alloc, NULL);
	g_return_if_fail (L != NULL);

	/* XXX: Might not be a bad idea to use lua_atpanic(). */

	/* Load some safe libraries. */
	luaL_requiref (L, "string", luaopen_string, TRUE);
	luaL_requiref (L, "table",  luaopen_table,  TRUE);
	luaL_requiref (L, "math",   luaopen_math,   TRUE);
	lua_pop (L, 3);

	/* Load the application library. */
	luaL_newlib (L, ld_lua_logdiag_lib);
	lua_setglobal (L, LD_LUA_LIBRARY_NAME);

	/* Store user data to the registry. */
	ud = lua_newuserdata (L, sizeof *ud);
	ud->self = self;
	ud->load_callback = NULL;
	ud->load_user_data = NULL;

	lua_setfield (L, LUA_REGISTRYINDEX, LD_LUA_DATA_INDEX);

	/* Create an empty symbol table. */
	lua_newtable (L);
	lua_setfield (L, LUA_REGISTRYINDEX, LD_LUA_SYMBOLS_INDEX);

	push_cairo_metatable (L);
}

static void
ld_lua_finalize (GObject *gobject)
{
	LdLua *self;

	self = LD_LUA (gobject);
	lua_close (self->priv->L);

	/* Chain up to the parent class. */
	G_OBJECT_CLASS (ld_lua_parent_class)->finalize (gobject);
}

/**
 * ld_lua_new:
 *
 * Create an instance of #LdLua.
 */
LdLua *
ld_lua_new (void)
{
	return g_object_new (LD_TYPE_LUA, NULL);
}

static void *
ld_lua_alloc (void *ud, void *ptr, size_t osize, size_t nsize)
{
	if (!nsize)
	{
		g_free (ptr);
		return NULL;
	}
	else
		return g_try_realloc (ptr, nsize);
}

/**
 * ld_lua_check_file:
 * @self: an #LdLua object.
 * @filename: the file to be checked.
 *
 * Check if the given filename can be loaded by #LdLua.
 */
gboolean
ld_lua_check_file (LdLua *self, const gchar *filename)
{
	g_return_val_if_fail (LD_IS_LUA (self), FALSE);
	g_return_val_if_fail (filename != NULL, FALSE);

	return g_str_has_suffix (filename, ".lua")
		&& g_file_test (filename, G_FILE_TEST_IS_REGULAR);
}

/**
 * ld_lua_load_file:
 * @self: an #LdLua object.
 * @filename: the file to be loaded.
 * @callback: a callback for newly registered symbols.
 * The callee is responsible for referencing the symbol.
 * @user_data: user data to be passed to the callback.
 *
 * Loads a file and creates #LdLuaSymbol objects for contained symbols.
 *
 * Returns: %TRUE if no error has occured, %FALSE otherwise.
 */
gboolean
ld_lua_load_file (LdLua *self, const gchar *filename,
	LdLuaLoadCallback callback, gpointer user_data)
{
	gint retval;
	LdLuaData *ud;

	g_return_val_if_fail (LD_IS_LUA (self), FALSE);
	g_return_val_if_fail (filename != NULL, FALSE);
	g_return_val_if_fail (callback != NULL, FALSE);

	/* XXX: If something from the following fails, Lua will panic. */
	lua_getfield (self->priv->L, LUA_REGISTRYINDEX, LD_LUA_DATA_INDEX);
	ud = lua_touserdata (self->priv->L, -1);
	lua_pop (self->priv->L, 1);
	g_return_val_if_fail (ud != NULL, FALSE);

	ud->load_callback = callback;
	ud->load_user_data = user_data;

	retval = luaL_loadfile (self->priv->L, filename);
	if (retval)
		goto ld_lua_lftc_fail;

	retval = lua_pcall (self->priv->L, 0, 0, 0);
	if (retval)
		goto ld_lua_lftc_fail;

	ud->load_callback = NULL;
	ud->load_user_data = NULL;
	return TRUE;

ld_lua_lftc_fail:
	g_warning ("Lua error: %s", lua_tostring (self->priv->L, -1));
	lua_remove (self->priv->L, -1);

	ud->load_callback = NULL;
	ud->load_user_data = NULL;
	return FALSE;
}

/* ===== LdLuaSymbol callbacks ============================================= */

/**
 * ld_lua_private_draw:
 * @self: an #LdLua object.
 * @symbol: a symbol to be drawn.
 * @cr: a Cairo context to be drawn onto.
 *
 * Draw a symbol onto a Cairo context.
 */
void
ld_lua_private_draw (LdLua *self, LdLuaSymbol *symbol, cairo_t *cr)
{
	LdLuaDrawData data;

	g_return_if_fail (LD_IS_LUA (self));
	g_return_if_fail (LD_IS_LUA_SYMBOL (symbol));
	g_return_if_fail (cr != NULL);

	data.symbol = symbol;
	data.cr = cr;
	data.save_count = 0;

	lua_pushcfunction (self->priv->L, ld_lua_private_draw_cb);
	lua_pushlightuserdata (self->priv->L, &data);
	if (lua_pcall (self->priv->L, 1, 0, 0))
	{
		g_warning ("Lua error: %s", lua_tostring (self->priv->L, -1));
		lua_pop (self->priv->L, 1);
	}

	while (data.save_count--)
		cairo_restore (cr);
}

static int
ld_lua_private_draw_cb (lua_State *L)
{
	LdLuaDrawData *data, *luadata;

	data = lua_touserdata (L, -1);

	/* Retrieve the function for rendering from the registry. */
	lua_getfield (L, LUA_REGISTRYINDEX, LD_LUA_SYMBOLS_INDEX);
	lua_pushlightuserdata (L, data->symbol);
	lua_gettable (L, -2);

	luaL_checktype (L, -1, LUA_TTABLE);
	lua_getfield (L, -1, "render");
	luaL_checktype (L, -1, LUA_TFUNCTION);

	/* Create a Cairo wrapper object. */
	luadata = lua_newuserdata (L, sizeof *data);
	memcpy (luadata, data, sizeof *data);
	lua_getfield (L, LUA_REGISTRYINDEX, LD_LUA_META_INDEX);
	lua_setmetatable (L, -2);

	/* Force it to stay alive for a bit longer. */
	lua_pushvalue (L, -1);
	lua_insert (L, 1);

	/* Draw the symbol. */
	if (lua_pcall (L, 1, 0, 0))
	{
		g_warning ("Lua error: %s", lua_tostring (L, -1));
		lua_pop (L, 1);
	}

	/* Copy the userdata back and invalidate it, so that malicious Lua
	 * scripts won't succeed at drawing onto a long invalid Cairo context.
	 */
	memcpy (data, luadata, sizeof *data);
	memset (luadata, 0, sizeof *data);
	return 0;
}

/**
 * ld_lua_private_unregister:
 * @self: an #LdLua object.
 * @symbol: a symbol to be unregistered.
 *
 * Unregister a symbol from the internal Lua state.
 */
void
ld_lua_private_unregister (LdLua *self, LdLuaSymbol *symbol)
{
	g_return_if_fail (LD_IS_LUA (self));
	g_return_if_fail (LD_IS_LUA_SYMBOL (symbol));

	lua_pushcfunction (self->priv->L, ld_lua_private_unregister_cb);
	lua_pushlightuserdata (self->priv->L, symbol);
	if (lua_pcall (self->priv->L, 1, 0, 0))
	{
		g_warning ("Lua error: %s", lua_tostring (self->priv->L, -1));
		lua_pop (self->priv->L, 1);
	}
}

static int
ld_lua_private_unregister_cb (lua_State *L)
{
	/* Set the entry in the symbol table to nil. */
	lua_getfield (L, LUA_REGISTRYINDEX, LD_LUA_SYMBOLS_INDEX);
	lua_insert (L, -2);
	lua_pushnil (L);
	lua_settable (L, -3);
	return 0;
}

/* ===== Application library =============================================== */

static int
ld_lua_logdiag_register (lua_State *L)
{
	LdLuaData *ud;
	LdLuaSymbol *symbol;

	lua_getfield (L, LUA_REGISTRYINDEX, LD_LUA_DATA_INDEX);
	ud = lua_touserdata (L, -1);
	lua_pop (L, 1);
	g_return_val_if_fail (ud != NULL, 0);

	/* Use a protected environment, so script errors won't cause leaking
	 * of the symbol object. Only a failure of the last three function calls
	 * before lua_pcall() may cause the symbol to leak.
	 */
	lua_checkstack (L, 3);
	symbol = g_object_new (LD_TYPE_LUA_SYMBOL, NULL);

	lua_pushlightuserdata (L, symbol);
	lua_pushcclosure (L, process_registration, 1);
	lua_insert (L, 1);

	/* On the stack, there are function arguments plus the function itself. */
	if (lua_pcall (L, lua_gettop (L) - 1, 0, 0))
	{
		luaL_where (L, 1);
		lua_insert (L, -2);
		lua_concat (L, 2);

		g_warning ("Lua symbol registration failed: %s",
			lua_tostring (L, -1));
		lua_pushboolean (L, FALSE);
	}
	else
	{
		/* We don't want an extra LdLua reference either. */
		symbol->priv->lua = ud->self;
		g_object_ref (ud->self);

		ud->load_callback (LD_SYMBOL (symbol), ud->load_user_data);
		lua_pushboolean (L, TRUE);
	}
	g_object_unref (symbol);

	return 1;
}

/*
 * process_registration:
 * @L: a Lua state.
 *
 * Parse arguments, write them to a symbol object and register the object.
 */
static int
process_registration (lua_State *L)
{
	LdLuaSymbol *symbol;
	const gchar *name;
	gchar *human_name;

	int i, type, types[] =
		{LUA_TSTRING, LUA_TTABLE, LUA_TTABLE, LUA_TTABLE, LUA_TFUNCTION};
	int n_args_needed = sizeof (types) / sizeof (int);

	if (lua_gettop (L) < n_args_needed)
		return luaL_error (L, "Too few arguments.");

	for (i = 0; i < n_args_needed; i++)
		if ((type = lua_type (L, i + 1)) != types[i])
			return luaL_error (L, "Bad type of argument #%d."
				" Expected %s, got %s.", i + 1,
				lua_typename (L, types[i]), lua_typename (L, type));

	symbol = LD_LUA_SYMBOL (lua_touserdata (L, lua_upvalueindex (1)));
	name = lua_tostring (L, 1);
	if (g_strstr_len (name, -1, LD_LIBRARY_IDENTIFIER_SEPARATOR))
		return luaL_error (L, "Invalid symbol name.");
	symbol->priv->name = g_strdup (name);

	human_name = get_translation (L, 2);
	if (!human_name)
		human_name = g_strdup (symbol->priv->name);
	symbol->priv->human_name = human_name;

	if (!read_symbol_area (L, 3, &symbol->priv->area))
		return luaL_error (L, "Malformed symbol area array.");
	if (!read_terminals (L, 4, &symbol->priv->terminals))
		return luaL_error (L, "Malformed terminals array.");

	lua_getfield (L, LUA_REGISTRYINDEX, LD_LUA_SYMBOLS_INDEX);
	lua_pushlightuserdata (L, symbol);

	lua_newtable (L);
	lua_pushvalue (L, 5);
	lua_setfield (L, -2, "render");

	lua_settable (L, -3);
	return 0;
}

/*
 * get_translation:
 * @L: a Lua state.
 * @index: stack index of the table.
 *
 * Select an applicable translation from a table.
 * The return value has to be freed with g_free().
 *
 * Return value: the translation, if found. If none was found, returns %NULL.
 */
static gchar *
get_translation (lua_State *L, int index)
{
	const gchar *const *lang;
	gchar *result;

	for (lang = g_get_language_names (); *lang; lang++)
	{
		lua_getfield (L, 2, *lang);
		if (lua_isstring (L, -1))
		{
			result = g_strdup (lua_tostring (L, -1));
			lua_pop (L, 1);
			return result;
		}
		lua_pop (L, 1);
	}
	return NULL;
}

/*
 * read_symbol_area:
 * @L: a Lua state.
 * @index: stack index of the table.
 * @area: where the area will be returned.
 *
 * Read a symbol area from a Lua table.
 *
 * Return value: %TRUE on success, %FALSE on failure.
 */
static gboolean
read_symbol_area (lua_State *L, int index, LdRectangle *area)
{
	lua_Number x1, x2, y1, y2;

	if (lua_rawlen (L, index) != 4)
		return FALSE;

	lua_rawgeti (L, index, 1);
	if (!lua_isnumber (L, -1))
		return FALSE;
	x1 = lua_tonumber (L, -1);

	lua_rawgeti (L, index, 2);
	if (!lua_isnumber (L, -1))
		return FALSE;
	y1 = lua_tonumber (L, -1);

	lua_rawgeti (L, index, 3);
	if (!lua_isnumber (L, -1))
		return FALSE;
	x2 = lua_tonumber (L, -1);

	lua_rawgeti (L, index, 4);
	if (!lua_isnumber (L, -1))
		return FALSE;
	y2 = lua_tonumber (L, -1);

	area->x = MIN (x1, x2);
	area->y = MIN (y1, y2);
	area->width  = ABS (x2 - x1);
	area->height = ABS (y2 - y1);

	lua_pop (L, 4);
	return TRUE;
}

/*
 * read_terminals:
 * @L: a Lua state.
 * @index: stack index of the table.
 * @area: where the point array will be returned.
 *
 * Read symbol terminals from a Lua table.
 *
 * Return value: %TRUE on success, %FALSE on failure.
 */
static gboolean
read_terminals (lua_State *L, int index, LdPointArray **terminals)
{
	LdPointArray *points;
	size_t num_points;

	num_points = lua_rawlen (L, index);
	points = ld_point_array_sized_new (num_points);

	lua_pushnil (L);
	while (lua_next (L, index) != 0)
	{
		g_assert (points->length < points->size);

		if (!lua_istable (L, -1) || lua_rawlen (L, -1) != 2)
			goto read_terminals_fail;

		lua_rawgeti (L, -1, 1);
		if (!lua_isnumber (L, -1))
			goto read_terminals_fail;
		points->points[points->length].x = lua_tonumber (L, -1);
		lua_pop (L, 1);

		lua_rawgeti (L, -1, 2);
		if (!lua_isnumber (L, -1))
			goto read_terminals_fail;
		points->points[points->length].y = lua_tonumber (L, -1);

		lua_pop (L, 2);
		points->length++;
	}
	*terminals = points;
	return TRUE;

read_terminals_fail:
	ld_point_array_free (points);
	*terminals = NULL;
	return FALSE;
}


/* ===== Cairo ============================================================= */

static gdouble
get_cairo_scale (cairo_t *cr)
{
	double dx = 1, dy = 0;

	cairo_user_to_device_distance (cr, &dx, &dy);
	return dx;
}

#define LD_LUA_CAIRO_GET_DATA \
	data = luaL_checkudata (L, 1, LD_LUA_META_INDEX); \
	if (!data->cr) \
		return luaL_error (L, "Tried to use an invalid Cairo object");

#define LD_LUA_CAIRO_BEGIN(name) \
static int \
ld_lua_cairo_ ## name (lua_State *L) \
{ \
	LdLuaDrawData *data; \

#define LD_LUA_CAIRO_END(n_values) \
	return (n_values); \
}

#define LD_LUA_CAIRO_TRIVIAL(name) \
LD_LUA_CAIRO_BEGIN (name) \
	LD_LUA_CAIRO_GET_DATA \
	cairo_ ## name (data->cr); \
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_TRIVIAL (new_path)
LD_LUA_CAIRO_TRIVIAL (new_sub_path)
LD_LUA_CAIRO_TRIVIAL (close_path)

LD_LUA_CAIRO_TRIVIAL (stroke)
LD_LUA_CAIRO_TRIVIAL (stroke_preserve)
LD_LUA_CAIRO_TRIVIAL (fill)
LD_LUA_CAIRO_TRIVIAL (fill_preserve)
LD_LUA_CAIRO_TRIVIAL (clip)
LD_LUA_CAIRO_TRIVIAL (clip_preserve)

LD_LUA_CAIRO_BEGIN (save)
	LD_LUA_CAIRO_GET_DATA
	if (data->save_count + 1)
	{
		data->save_count++;
		cairo_save (data->cr);
	}
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (restore)
	LD_LUA_CAIRO_GET_DATA
	if (data->save_count)
	{
		data->save_count--;
		cairo_restore (data->cr);
	}
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (get_line_width)
	LD_LUA_CAIRO_GET_DATA
	lua_pushnumber (L, cairo_get_line_width (data->cr)
		* get_cairo_scale (data->cr));
LD_LUA_CAIRO_END (1)

LD_LUA_CAIRO_BEGIN (set_line_width)
	LD_LUA_CAIRO_GET_DATA
	cairo_set_line_width (data->cr, luaL_checknumber (L, 2)
		/ get_cairo_scale (data->cr));
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (translate)
	lua_Number x, y;

	LD_LUA_CAIRO_GET_DATA
	x = luaL_checknumber (L, 2);
	y = luaL_checknumber (L, 3);

	cairo_translate (data->cr, x, y);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (scale)
	lua_Number sx, sy;

	LD_LUA_CAIRO_GET_DATA
	sx = luaL_checknumber (L, 2);
	sy = luaL_checknumber (L, 3);

	cairo_scale (data->cr, sx, sy);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (rotate)
	lua_Number angle;

	LD_LUA_CAIRO_GET_DATA
	angle = luaL_checknumber (L, 2);
	cairo_rotate (data->cr, angle);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (move_to)
	lua_Number x, y;

	LD_LUA_CAIRO_GET_DATA
	x = luaL_checknumber (L, 2);
	y = luaL_checknumber (L, 3);

	cairo_move_to (data->cr, x, y);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (line_to)
	lua_Number x, y;

	LD_LUA_CAIRO_GET_DATA
	x = luaL_checknumber (L, 2);
	y = luaL_checknumber (L, 3);

	cairo_line_to (data->cr, x, y);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (curve_to)
	lua_Number x1, y1, x2, y2, x3, y3;

	LD_LUA_CAIRO_GET_DATA
	x1 = luaL_checknumber (L, 2);
	y1 = luaL_checknumber (L, 3);
	x2 = luaL_checknumber (L, 4);
	y2 = luaL_checknumber (L, 5);
	x3 = luaL_checknumber (L, 6);
	y3 = luaL_checknumber (L, 7);

	cairo_curve_to (data->cr, x1, y1, x2, y2, x3, y3);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (arc)
	lua_Number xc, yc, radius, angle1, angle2;

	LD_LUA_CAIRO_GET_DATA
	xc = luaL_checknumber (L, 2);
	yc = luaL_checknumber (L, 3);
	radius = luaL_checknumber (L, 4);
	angle1 = luaL_checknumber (L, 5);
	angle2 = luaL_checknumber (L, 6);

	cairo_arc (data->cr, xc, yc, radius, angle1, angle2);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (arc_negative)
	lua_Number xc, yc, radius, angle1, angle2;

	LD_LUA_CAIRO_GET_DATA
	xc = luaL_checknumber (L, 2);
	yc = luaL_checknumber (L, 3);
	radius = luaL_checknumber (L, 4);
	angle1 = luaL_checknumber (L, 5);
	angle2 = luaL_checknumber (L, 6);

	cairo_arc_negative (data->cr, xc, yc, radius, angle1, angle2);
LD_LUA_CAIRO_END (0)

LD_LUA_CAIRO_BEGIN (show_text)
	const char *text;
	GtkStyle *style;
	PangoLayout *layout;
	int width, height;
	double x, y;

	LD_LUA_CAIRO_GET_DATA
	text = luaL_checkstring (L, 2);

	layout = pango_cairo_create_layout (data->cr);
	pango_layout_set_text (layout, text, -1);

	style = gtk_style_new ();
	pango_font_description_set_size (style->font_desc, 1 * PANGO_SCALE);
	pango_layout_set_font_description (layout, style->font_desc);
	g_object_unref (style);

	pango_layout_get_size (layout, &width, &height);
	cairo_get_current_point (data->cr, &x, &y);
	x -= (double) width  / PANGO_SCALE / 2;
	y -= (double) height / PANGO_SCALE / 2;

	cairo_save (data->cr);
	cairo_move_to (data->cr, x, y);
	pango_cairo_show_layout (data->cr, layout);
	cairo_restore (data->cr);

	g_object_unref (layout);
LD_LUA_CAIRO_END (0)