1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
// Copyright (c) 2015-2018, Loïc Hoguin <[email protected]>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "esdl2.h"
// SDL_HintCallback
typedef struct esdl2_callback {
char* module;
char* function;
} esdl2_callback;
static void esdl2_hint_callback(void* userdata, const char* name, const char* oldValue, const char* newValue)
{
ErlNifEnv* env = enif_alloc_env();
esdl2_callback* callback = (esdl2_callback*)userdata;
ERL_NIF_TERM old;
ERL_NIF_TERM new;
if (oldValue == NULL)
old = atom_undefined;
else
old = enif_make_string(env, oldValue, ERL_NIF_LATIN1);
if (newValue == NULL)
new = atom_undefined;
else
new = enif_make_string(env, newValue, ERL_NIF_LATIN1);
enif_send(NULL, get_callback_process(), env,
enif_make_tuple4(env, atom_callback,
enif_make_atom(env, callback->module),
enif_make_atom(env, callback->function),
enif_make_list3(env,
enif_make_string(env, name, ERL_NIF_LATIN1),
old,
new)));
enif_free_env(env);
}
// add_hint_callback
// @todo We must free the userdata in SDL_DelHintCallback.
NIF_CAST_HANDLER(thread_add_hint_callback)
{
esdl2_callback* callback = (esdl2_callback*)enif_alloc(sizeof(esdl2_callback));
callback->module = args[1];
callback->function = args[2];
SDL_AddHintCallback(args[0], &esdl2_hint_callback, callback);
enif_free(args[0]);
}
NIF_FUNCTION(add_hint_callback)
{
unsigned int hint_len, module_len, function_len;
char* hint;
char* module;
char* function;
BADARG_IF(!enif_get_list_length(env, argv[0], &hint_len));
BADARG_IF(!enif_get_atom_length(env, argv[1], &module_len, ERL_NIF_LATIN1));
BADARG_IF(!enif_get_atom_length(env, argv[2], &function_len, ERL_NIF_LATIN1));
hint = (char*)enif_alloc(hint_len + 1);
if (!enif_get_string(env, argv[0], hint, hint_len + 1, ERL_NIF_LATIN1)) {
enif_free(hint);
return enif_make_badarg(env);
}
module = (char*)enif_alloc(module_len + 1);
if (!enif_get_atom(env, argv[1], module, module_len + 1, ERL_NIF_LATIN1)) {
enif_free(hint);
enif_free(module);
return enif_make_badarg(env);
}
function = (char*)enif_alloc(function_len + 1);
if (!enif_get_atom(env, argv[2], function, function_len + 1, ERL_NIF_LATIN1)) {
enif_free(hint);
enif_free(module);
enif_free(function);
return enif_make_badarg(env);
}
return nif_thread_cast(env, thread_add_hint_callback, 3, hint, module, function);
}
|
