#include <lua.h>
#include <lauxlib.h>
#include <glib.h>
#include "glib_types.h"
/// g.main_context
/// Glib main context object. Mainly useful when lua needs to
/// manage glib-based libs.
/// g.main_context.new
/// Creates new main context object.
/// R: g main context object
static int lglib_main_context_new (lua_State *L)
{
GMainContext *context = g_main_context_new ();
lglib_main_context_bless (L, context);
g_main_context_unref (context);
return 1;
}
/// g.main_context.bless
/// Blesses given pointer to g main context object.
/// A: lightuserdata (C g main context object)
/// R: g main context object
static int lglib_main_context_bless_lua (lua_State *L)
{
luaL_argcheck (L, lua_islightuserdata (L, 1), 1, "g main context lightuserdata expected");
lglib_main_context_bless (L, lua_touserdata (L, 1));
return 1;
}
/// g.main_context.default
/// Returns default main context object.
/// R: g main context object
static int lglib_main_context_default (lua_State *L)
{
GMainContext *context = g_main_context_default ();
lglib_main_context_bless (L, context);
// XXX g_main_context_unref (context);
return 1;
}
/// main_context:iteration
/// Performs single full iteration in blocking or non-blocking manner,
/// depending on value of argument.
/// Returns true, if some events have been handled.
/// A: boolean (optional)
/// R: boolean
static int lglib_main_context_iteration (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
int may_block = 0;
if ( lua_gettop (L) > 1 ) {
luaL_checktype (L, 2, LUA_TBOOLEAN);
may_block = lua_toboolean (L, 2);
}
lua_pushboolean (L, g_main_context_iteration (object->main_context, may_block));
return 1;
}
/// main_context:pending
/// Indicates, if there are present events in sources.
/// R: boolean
static int lglib_main_context_pending (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
lua_pushboolean (L, g_main_context_pending (object->main_context));
return 1;
}
/// main_context:find_source
/// Returns source with given id.
/// A: integer (source id)
/// R: g main context object or nil
static int lglib_main_context_find_source (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
int id = luaL_checkint (L, 2);
GSource *source = g_main_context_find_source_by_id (object->main_context, id);
if (source) {
lglib_source_bless (L, source);
// XXX g_source_unref (source)
} else
lua_pushnil (L);
return 1;
}
/// main_context:wakeup
/// Awakes main context if it currently poll() ing.
/// XXX Seems to be threading-related routine, how lua will work in this case?
static int lglib_main_context_wakeup (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
g_main_context_wakeup (object->main_context);
return 0;
}
/// main_context:acquire
/// Tries to own main context.
/// R: boolean (success)
static int lglib_main_context_acquire (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
lua_pushboolean (L, g_main_context_acquire (object->main_context));
return 1;
}
/// main_context:release
/// Disowns acquired context.
/// Note: release context as many times, as you acquired it.
static int lglib_main_context_release (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
g_main_context_release (object->main_context);
return 0;
}
/// main_context:owner
/// Indicates if current thread is owner of context.
/// R: boolean
static int lglib_main_context_owner (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
lua_pushboolean (L, g_main_context_is_owner (object->main_context));
return 1;
}
/// main_context:wait
/// For now this will not be implemented, as it requires threading part of glib
/// WARNING: conventions for next four methods are likely to change
/// as I become more familiar with all that stuff.
/// main_context:prepare
/// Polling preparation step.
/// R: boolean (indicates readiness for dispatching before polling), integer (priority of most important ready source, if first value is true)
static int lglib_main_context_prepare (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
gint priority;
gboolean ready = g_main_context_prepare (object->main_context, &priority);
lua_pushboolean (L, ready);
if (!ready)
return 1;
lua_pushnumber (L, priority);
return 0;
}
/// main_context:query
/// Get necessary for polling information.
/// A: integer (maximum priority), integer (number of fds to allocate)
/// R: userdata (GPollFDs), integer (number of fds required), integer (timeout)
static int lglib_main_context_query (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
int priority = luaL_checkint (L, 2);
int nfds = luaL_checkint (L, 3);
gint timeout;
GPollFD *fds = lua_newuserdata (L, sizeof (GPollFD) * nfds);
lua_pushnumber (L, g_main_context_query (object->main_context, priority, &timeout, fds, nfds));
lua_pushnumber (L, timeout);
return 3;
}
/// main_context:check
/// Passes results of polling back to main loop.
/// A: integer (priority), userdata (GPollFDs), integer (number of fds)
/// R: boolean (readiness for dispatching)
static int lglib_main_context_check (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
int priority = luaL_checkint (L, 2);
GPollFD *fds = lua_touserdata (L, 3); // FIXME
int nfds = luaL_checkint (L, 4);
lua_pushboolean (L, g_main_context_check (object->main_context, priority, fds, nfds));
return 1;
}
/// main_context:dispatch
/// Actually dispatches pending event sources
static int lglib_main_context_dispatch (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
g_main_context_dispatch (object->main_context);
return 0;
}
/// main_context:poll_function
/// main_context:add_poll
/// main_context:remove_poll
/// Let's delay implementing this until fd objects will be ready...
/// main_context:pointer
/// Returns pointe to underlying C structure.
/// A: g main context object
/// R: lightuserdata
static int lglib_main_context_pointer (lua_State *L)
{
lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);
lua_pushlightuserdata (L, object->main_context);
return 1;
}
static int lglib_main_context_gc (lua_State *L)
{
lglib_main_context_t *object = lua_touserdata (L, 1);
g_main_context_unref (object->main_context);
return 0;
}
static const luaL_Reg lglib_main_context_reg_f[] = {
{ "new", lglib_main_context_new },
{ "bless", lglib_main_context_bless_lua },
{ "default", lglib_main_context_default },
{ NULL, NULL },
};
static const luaL_Reg lglib_main_context_reg_m[] = {
{ "iteration", lglib_main_context_iteration },
{ "pending", lglib_main_context_pending },
{ "find_source", lglib_main_context_find_source },
{ "wakeup", lglib_main_context_wakeup },
{ "acquire", lglib_main_context_acquire },
{ "release", lglib_main_context_release },
{ "owner", lglib_main_context_owner },
{ "prepare", lglib_main_context_prepare },
{ "query", lglib_main_context_query },
{ "check", lglib_main_context_check },
{ "dispatch", lglib_main_context_dispatch },
{ "pointer", lglib_main_context_pointer },
{ "__gc", lglib_main_context_gc },
{ NULL, NULL },
};
int luaopen_glib_main_context (lua_State *L)
{
luaL_newmetatable (L, "glib.main_context" );
lua_pushstring (L, "__index");
lua_pushvalue (L, -2);
lua_settable (L, -3);
luaL_register (L, NULL, lglib_main_context_reg_m);
lua_pop (L, 1);
luaL_register (L, "g.main_context", lglib_main_context_reg_f);
return 1;
}