static void _mouse(int button, int status, int x, int y)
{
int has_callback;
if (GLUT_UP == status)
has_callback = get_callback(glutGetWindow(), "mousereleased");
else
has_callback = get_callback(glutGetWindow(), "mousepressed");
if (!has_callback)
return;
const char* name;
switch (button)
{
case GLUT_LEFT_BUTTON:
name = "left";
break;
case GLUT_MIDDLE_BUTTON:
name = "middle";
break;
case GLUT_RIGHT_BUTTON:
name = "right";
break;
default:
name = "unknown";
}
lua_pushinteger(LUA, x);
lua_pushinteger(LUA, y);
lua_pushstring(LUA, name);
lua_call(LUA, 3, 0);
}
static void _entry(int state)
{
int has_callback;
if (GLUT_LEFT == state)
has_callback = get_callback(glutGetWindow(), "mouseleave");
else
has_callback = get_callback(glutGetWindow(), "mouseenter");
if (has_callback)
lua_call(LUA, 0, 0);
}
static void _visibility(int state)
{
if (!get_callback(glutGetWindow(), "visibility"))
return;
lua_pushboolean(LUA, GLUT_VISIBLE == state);
lua_call(LUA, 1, 0);
}
int purple_signal_connect_glue(MonoObject* h, MonoObject *plugin, MonoString *signal, MonoObject *func)
{
char *sig;
void **instance = NULL;
SignalData *sig_data;
PurpleMonoPlugin *mplug;
MonoClass *klass;
sig = mono_string_to_utf8(signal);
purple_debug(PURPLE_DEBUG_INFO, "mono", "connecting signal: %s\n", sig);
instance = (void*)mono_object_unbox(h);
sig_data = g_new0(SignalData, 1);
sig_data->func = func;
sig_data->signal = sig;
purple_signal_get_values(*instance, sig, &sig_data->ret_value, &sig_data->num_vals, &sig_data->values);
klass = mono_object_get_class(plugin);
mplug = ml_find_plugin_by_class(klass);
mplug->signal_data = g_list_append(mplug->signal_data, (gpointer)sig_data);
return purple_signal_connect(*instance, sig, (gpointer)klass, get_callback(sig_data), (gpointer)sig_data);
}
main ()
{
func callme = get_callback ();
if (callme (0, 0, 0, 0x1234, 0x1234567890abcdefLL))
abort ();
return 0;
}
static void _reshape(int width, int height)
{
if (!get_callback(glutGetWindow(), "reshape"))
return;
lua_pushinteger(LUA, width);
lua_pushinteger(LUA, height);
lua_call(LUA, 2, 0);
}
bool IniSetting::GetMode(const std::string& name, Mode& mode) {
auto cb = get_callback(name);
if (!cb) {
return false;
}
mode = cb->mode;
return true;
}
static bool ini_set(const std::string& name, const Variant& value,
IniSetting::Mode mode) {
auto cb = get_callback(name);
if (!cb || !(cb->mode & mode)) {
return false;
}
return cb->updateCallback(value);
}
bool IniSetting::Get(const String& name, Variant& value) {
auto cb = get_callback(name.toCppString());
if (!cb) {
return false;
}
value = cb->getCallback();
return true;
}
bool IniSetting::Get(const std::string& name, folly::dynamic& value) {
auto cb = get_callback(name);
if (!cb) {
return false;
}
value = cb->getCallback();
return true;
}
static void _passiveMotion(int x, int y)
{
if (!get_callback(glutGetWindow(), "mousemove"))
return;
lua_pushinteger(LUA, x);
lua_pushinteger(LUA, y);
lua_call(LUA, 2, 0);
}
static void _keyboard(unsigned char key, int x, int y)
{
if (!get_callback(glutGetWindow(), "keyboard"))
return;
lua_pushlstring(LUA, (const char*)(&key), 1);
lua_pushinteger(LUA, x);
lua_pushinteger(LUA, y);
lua_call(LUA, 3, 0);
}
static int l_window___index(lua_State* L)
{
luaL_getmetatable(L, INTERNAL_NAME);
lua_pushvalue(L, 2);
lua_gettable(L, -2);
if (!lua_isnoneornil(L, -1))
return 1;
if (!lua_isstring(L, 2))
return 0;
const char* key = lua_tostring(L, 2);
Window* win = l_toWindow(L, 1);
if (get_callback(win->id, key))
return 1;
int current = glutGetWindow();
glutSetWindow(win->id);
if (0 == strcmp("pos", key))
{
lua_createtable(L, 2, 0);
lua_pushinteger(L, glutGet(GLUT_WINDOW_X));
lua_setfield(L, -2, "x");
lua_pushinteger(L, glutGet(GLUT_WINDOW_Y));
lua_setfield(L, -2, "y");
}
else if (0 == strcmp("x", key))
{
lua_pushinteger(L, glutGet(GLUT_WINDOW_X));
}
else if (0 == strcmp("y", key))
{
lua_pushinteger(L, glutGet(GLUT_WINDOW_Y));
}
else if (0 == strcmp("size", key))
{
lua_createtable(L, 2, 0);
lua_pushinteger(L, glutGet(GLUT_WINDOW_WIDTH));
lua_setfield(L, -2, "width");
lua_pushinteger(L, glutGet(GLUT_WINDOW_HEIGHT));
lua_setfield(L, -2, "height");
}
else if (0 == strcmp("width", key))
{
lua_pushinteger(L, glutGet(GLUT_WINDOW_WIDTH));
}
else if (0 == strcmp("height", key))
{
lua_pushinteger(L, glutGet(GLUT_WINDOW_HEIGHT));
}
else
{
lua_pushnil(L);
}
glutSetWindow(current);
return 1;
}
static void _motion(int x, int y)
{
if (!get_callback(glutGetWindow(), "mousedrag"))
return;
// TODO: get mouse buttons
lua_pushinteger(LUA, x);
lua_pushinteger(LUA, y);
lua_call(LUA, 2, 0);
}
ISR(TWI_vect, ISR_BLOCK) {
status_set(true);
//uart_send("TWI ISR");
//DUMP_ERROR();
if (TW_STATUS == TW_SR_SLA_ACK) {
//uart_send("Got my SLA+W");
command = 0xFF;
} else if (TW_STATUS == TW_ST_SLA_ACK) {
if (command == 0x0) {
//uart_send("Got into a ST with a PUT --- wwwwat");
} else {
//uart_send("Got a GET");
if (get_callback) {
TWDR = get_callback();
} else {
//uart_send("No callback, sending 0xFF");
TWDR = 0xFF;
}
// For the last data byte we need to set ack to 0
SEND(0, 0);
return;
}
} else if (TW_STATUS == TW_SR_DATA_ACK) {
if (command == 0xFF) {
command = TWDR;
//sprintf(str, "Got command = %x", command);
//uart_send(str);
} else if (command == 0x0) {
//uart_send("Got a PUT");
if (put_callback) {
put_callback(TWDR);
}
} else {
//uart_send("WAAAAAAT -- Got a DATA ACK on a GET");
}
} else if (TW_STATUS == TW_ST_DATA_ACK) {
//uart_send("WTF - Got DATA ACK on ST");
}
SEND(1, 0);
}
void
LocalProperty::Get(void)
{
if (address == NULL && var == NULL) {
client->ORState(STATUS_MALFORMED_COMMAND);
return;
}
int new_var;
client->WriteCommand(COMMAND_RETURN);
if (set_callback != NULL) {
new_var = get_callback();
client->WriteInt(&new_var);
} else if (var != NULL) {
client->WriteInt(var);
} else {
/* Shouldn't get here (tm) */
}
}
static void _special(int key, int x, int y)
{
if (!get_callback(glutGetWindow(), "keyboard"))
return;
const char* name;
switch (key) {
case GLUT_KEY_F1: name = "F1"; break;
case GLUT_KEY_F2: name = "F2"; break;
case GLUT_KEY_F3: name = "F3"; break;
case GLUT_KEY_F4: name = "F4"; break;
case GLUT_KEY_F5: name = "F5"; break;
case GLUT_KEY_F6: name = "F6"; break;
case GLUT_KEY_F7: name = "F7"; break;
case GLUT_KEY_F8: name = "F8"; break;
case GLUT_KEY_F9: name = "F9"; break;
case GLUT_KEY_F10: name = "F10"; break;
case GLUT_KEY_F11: name = "F11"; break;
case GLUT_KEY_F12: name = "F12"; break;
case GLUT_KEY_LEFT: name = "left"; break;
case GLUT_KEY_UP: name = "up"; break;
case GLUT_KEY_RIGHT: name = "right"; break;
case GLUT_KEY_DOWN: name = "down"; break;
case GLUT_KEY_PAGE_UP: name = "pageup"; break;
case GLUT_KEY_PAGE_DOWN: name = "pagedown"; break;
case GLUT_KEY_HOME: name = "home"; break;
case GLUT_KEY_END: name = "end"; break;
case GLUT_KEY_INSERT: name = "insert"; break;
default: name = "unknown";
}
lua_pushstring(LUA, name);
lua_pushinteger(LUA, x);
lua_pushinteger(LUA, y);
lua_call(LUA, 3, 0);
}
static void _draw()
{
if (get_callback(glutGetWindow(), "draw"))
lua_call(LUA, 0, 0);
}
static HRESULT Binding_Create(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
BOOL to_obj, REFIID riid, Binding **binding)
{
Binding *ret;
HRESULT hres;
URLMON_LockModule();
ret = heap_alloc_zero(sizeof(Binding));
ret->lpBindingVtbl = &BindingVtbl;
ret->lpIInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
ret->lpWinInetHttpInfoVtbl = &WinInetHttpInfoVtbl;
ret->lpServiceProviderVtbl = &ServiceProviderVtbl;
ret->ref = 1;
ret->to_object = to_obj;
ret->iid = *riid;
ret->notif_hwnd = get_notif_hwnd();
ret->report_mime = !binding_ctx;
ret->download_state = BEFORE_DOWNLOAD;
if(to_obj) {
IBindCtx_AddRef(pbc);
ret->bctx = pbc;
}
if(mon) {
IMoniker_AddRef(mon);
ret->mon = mon;
}
ret->bindinfo.cbSize = sizeof(BINDINFO);
InitializeCriticalSection(&ret->section);
ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": Binding.section");
hres = get_callback(pbc, &ret->callback);
if(FAILED(hres)) {
WARN("Could not get IBindStatusCallback\n");
IBinding_Release(BINDING(ret));
return hres;
}
IBindStatusCallback_QueryInterface(ret->callback, &IID_IServiceProvider,
(void**)&ret->service_provider);
if(binding_ctx) {
ret->protocol = binding_ctx->protocol;
IInternetProtocol_AddRef(ret->protocol);
} else {
hres = create_binding_protocol(TRUE, &ret->protocol);
if(FAILED(hres)) {
WARN("Could not get protocol handler\n");
IBinding_Release(BINDING(ret));
return hres;
}
}
hres = IBindStatusCallback_GetBindInfo(ret->callback, &ret->bindf, &ret->bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
IBinding_Release(BINDING(ret));
return hres;
}
TRACE("bindf %08x\n", ret->bindf);
dump_BINDINFO(&ret->bindinfo);
ret->bindf |= BINDF_FROMURLMON;
if(to_obj)
ret->bindinfo.dwOptions |= 0x100000;
if(!(ret->bindf & BINDF_ASYNCHRONOUS) || !(ret->bindf & BINDF_PULLDATA)) {
ret->bindf |= BINDF_NEEDFILE;
ret->use_cache_file = TRUE;
} else if(!is_urlmon_protocol(uri)) {
ret->bindf |= BINDF_NEEDFILE;
}
hres = IUri_GetDisplayUri(uri, &ret->url);
if(FAILED(hres)) {
IBinding_Release(BINDING(ret));
return hres;
}
if(binding_ctx) {
ret->stgmed_buf = binding_ctx->stgmed_buf;
IUnknown_AddRef(STGMEDUNK(ret->stgmed_buf));
ret->clipboard_format = binding_ctx->clipboard_format;
} else {
ret->stgmed_buf = create_stgmed_buf(ret->protocol);
}
if(to_obj) {
ret->stgmed_obj = NULL;
} else if(IsEqualGUID(&IID_IStream, riid)) {
ret->stgmed_obj = create_stgmed_stream(ret->stgmed_buf);
} else if(IsEqualGUID(&IID_IUnknown, riid)) {
ret->bindf |= BINDF_NEEDFILE;
ret->stgmed_obj = create_stgmed_file(ret->stgmed_buf);
} else {
FIXME("Unsupported riid %s\n", debugstr_guid(riid));
IBinding_Release(BINDING(ret));
return E_NOTIMPL;
}
*binding = ret;
return S_OK;
}
