static gboolean
clutter_behaviour_path_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node)
{
if (strcmp ("path", name) == 0)
{
ClutterPath *path;
GValue node_value = { 0 };
path = g_object_ref_sink (clutter_path_new ());
json_node_get_value (node, &node_value);
if (!G_VALUE_HOLDS (&node_value, G_TYPE_STRING)
|| !clutter_path_set_description (path,
g_value_get_string (&node_value)))
g_warning ("Invalid path description");
g_value_unset (&node_value);
g_value_init (value, G_TYPE_OBJECT);
g_value_take_object (value, path);
return TRUE;
}
/* chain up */
else if (parent_scriptable_iface->parse_custom_node)
return parent_scriptable_iface->parse_custom_node (scriptable, script,
value, name, node);
else
return FALSE;
}
static void
snra_json_node_into_val (JsonNode *element_node, GValue *v)
{
if (JSON_NODE_HOLDS_OBJECT (element_node)) {
GstStructure *child = snra_json_to_gst_structure (element_node);
g_value_init (v, GST_TYPE_STRUCTURE);
gst_value_set_structure (v, child);
} else if (JSON_NODE_HOLDS_ARRAY (element_node)) {
JsonArray *arr = json_node_get_array (element_node);
g_value_init (v, GST_TYPE_ARRAY);
json_array_foreach_element (arr,
(JsonArrayForeach) snra_json_array_add_to_val, v);
} else {
json_node_get_value (element_node, v);
}
}
static gchar *dump_json_value(JsonNode * node)
{
GValue value = { 0, };
GString *buffer;
buffer = g_string_new("");
json_node_get_value(node, &value);
switch (G_VALUE_TYPE(&value)) {
case G_TYPE_INT64:
g_string_append_printf(buffer, "%" G_GINT64_FORMAT,
g_value_get_int64(&value));
break;
case G_TYPE_STRING:
{
gchar *tmp;
tmp = g_strescape(g_value_get_string(&value), json_exceptions);
g_string_append(buffer, tmp);
g_free(tmp);
}
break;
case G_TYPE_DOUBLE:
{
gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
g_string_append(buffer,
g_ascii_dtostr(buf, sizeof(buf),
g_value_get_double(&value)));
}
break;
case G_TYPE_BOOLEAN:
g_string_append_printf(buffer, "%s",
g_value_get_boolean(&value) ? "true" :
"false");
break;
default:
break;
}
g_value_unset(&value);
return g_string_free(buffer, FALSE);
}
static gboolean
reader_fill_simple_gvalue (JsonReader *reader, TopicValueType type, GValue *value)
{
gboolean retval = TRUE;
gint64 datetime;
json_reader_read_member (reader, "value");
if (json_reader_get_error (reader) != NULL) {
json_reader_end_member (reader);
return FALSE;
}
switch (type) {
case TYPE_BOOL:
case TYPE_INT:
case TYPE_DOUBLE:
case TYPE_STRING:
json_node_get_value (json_reader_get_value (reader), value);
break;
case TYPE_DATETIME:
if (gdata_parser_int64_from_iso8601 (json_reader_get_string_value (reader), &datetime) ||
gdata_parser_int64_from_date (json_reader_get_string_value (reader), &datetime)) {
g_value_init (value, G_TYPE_INT64);
g_value_set_int64 (value, datetime);
} else {
retval = FALSE;
}
break;
case TYPE_NONE:
case TYPE_COMPOUND:
case TYPE_OBJECT:
case TYPE_KEY:
case TYPE_URI:
default:
retval = FALSE;
}
json_reader_end_member (reader);
return retval;
}
/*
* For a given parent @node, get the child node called @name and return a copy
* of the content, or NULL. If the content is the empty string, NULL is
* returned.
*/
char *
get_child_node_value (JsonNode *node, const char *name)
{
JsonNode *subnode;
JsonObject *object;
GValue value = {0};
const char *string;
char *result = NULL;
if (!node || !name)
return NULL;
if (json_node_get_node_type (node) == JSON_NODE_OBJECT) {
object = json_node_get_object (node);
} else {
return NULL;
}
if (!json_object_has_member (object, name)) {
return NULL;
}
subnode = json_object_get_member (object, name);
if (!subnode)
return NULL;
json_node_get_value (subnode, &value);
string = g_value_get_string (&value);
if (string && string[0]) {
result = g_strdup (string);
}
g_value_unset (&value);
return result;
}
gboolean
json_deserialize_pspec (GValue *value,
GParamSpec *pspec,
JsonNode *node)
{
GValue node_value = { 0, };
gboolean retval = FALSE;
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED)
{
JsonNodeType node_type = json_node_get_node_type (node);
GType boxed_type = G_VALUE_TYPE (value);
if (json_boxed_can_deserialize (boxed_type, node_type))
{
gpointer boxed = json_boxed_deserialize (boxed_type, node);
g_value_take_boxed (value, boxed);
return TRUE;
}
}
switch (JSON_NODE_TYPE (node))
{
case JSON_NODE_OBJECT:
if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT))
{
GObject *object;
object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node));
if (object != NULL)
g_value_take_object (value, object);
else
g_value_set_object (value, NULL);
retval = TRUE;
}
break;
case JSON_NODE_ARRAY:
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
JsonArray *array = json_node_get_array (node);
guint i, array_len = json_array_get_length (array);
GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1);
for (i = 0; i < array_len; i++)
{
JsonNode *val = json_array_get_element (array, i);
if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE)
continue;
if (json_node_get_string (val) != NULL)
g_ptr_array_add (str_array, (gpointer) json_node_get_string (val));
}
g_ptr_array_add (str_array, NULL);
g_value_set_boxed (value, str_array->pdata);
g_ptr_array_free (str_array, TRUE);
retval = TRUE;
}
break;
case JSON_NODE_VALUE:
json_node_get_value (node, &node_value);
#if 0
{
gchar *node_str = g_strdup_value_contents (&node_value);
g_debug ("%s: value type '%s' := node value type '%s' -> '%s'",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (&node_value)),
node_str);
g_free (node_str);
}
#endif
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))
{
case G_TYPE_BOOLEAN:
case G_TYPE_INT64:
case G_TYPE_STRING:
if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value)))
{
g_value_copy (&node_value, value);
retval = TRUE;
}
break;
case G_TYPE_INT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_int (value, (gint) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_CHAR:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UINT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uint (value, (guint) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UCHAR:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_LONG:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_long (value, (glong) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_ULONG:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_ulong (value, (gulong) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_UINT64:
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_uint64 (value, (guint64) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_DOUBLE:
if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE))
{
g_value_set_double (value, g_value_get_double (&node_value));
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_FLOAT:
if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE))
{
g_value_set_float (value, (gfloat) g_value_get_double (&node_value));
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value));
retval = TRUE;
}
break;
case G_TYPE_ENUM:
{
gint enum_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
enum_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = enum_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&enum_value);
}
if (retval)
g_value_set_enum (value, enum_value);
}
break;
case G_TYPE_FLAGS:
{
gint flags_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
flags_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = flags_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&flags_value);
}
if (retval)
g_value_set_flags (value, flags_value);
}
break;
default:
retval = FALSE;
break;
}
g_value_unset (&node_value);
break;
case JSON_NODE_NULL:
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING)
{
g_value_set_string (value, NULL);
retval = TRUE;
}
else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT)
{
g_value_set_object (value, NULL);
retval = TRUE;
}
else
retval = FALSE;
break;
}
return retval;
}
static void
ui_connection_handle_message(UiConnection *self,
const gchar *protocol, const gchar *command, JsonObject *payload,
SoupWebsocketConnection *ws)
{
if (g_strcmp0(protocol, "graph") == 0) {
handle_graph_message(self, command, payload, ws);
} else if (g_strcmp0(protocol, "network") == 0) {
handle_network_message(self, command, payload, ws);
} else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "list") == 0) {
gint no_components = 0;
gchar **operation_names = library_list_components(self->component_lib, &no_components);
for (int i=0; i<no_components; i++) {
const gchar *op = operation_names[i];
if (op) {
JsonObject *component = library_get_component(self->component_lib, op);
send_response(ws, "component", "component", component);
}
}
g_strfreev(operation_names);
} else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "source") == 0) {
const gchar *name = json_object_get_string_member(payload, "name");
gchar *actual_name = library_set_source(self->component_lib,
name,
json_object_get_string_member(payload, "code")
);
if (actual_name) {
JsonObject *component = library_get_component(self->component_lib, name);
send_response(ws, "component", "component", component);
} else {
// TODO: error response
}
g_free(actual_name);
} else if (g_strcmp0(protocol, "component") == 0 && g_strcmp0(command, "getsource") == 0) {
const gchar *name = json_object_get_string_member(payload, "name");
JsonObject *source_info = json_object_new();
// TODO: generalize for subgraphs-as-components
if (g_strcmp0(name, self->main_network) == 0) {
json_object_set_string_member(source_info, "name", "main"); // FIXME: dont hardcode
json_object_set_string_member(source_info, "library", "default"); // FIXME: dont hardcode
Network *n = g_hash_table_lookup(self->network_map, self->main_network);
g_assert(n);
JsonObject *g = graph_save_json(n->graph);
gsize len = 0;
gchar *code = json_stringify(g, &len);
g_assert(len);
json_object_set_string_member(source_info, "language", "json");
json_object_set_string_member(source_info, "code", code);
} else {
json_object_set_string_member(source_info, "name", name);
gchar *code = library_get_source(self->component_lib, name);
json_object_set_string_member(source_info, "library", "imgflo");
json_object_set_string_member(source_info, "language", "c");
json_object_set_string_member(source_info, "code", code);
}
send_response(ws, "component", "source", source_info);
} else if (g_strcmp0(protocol, "runtime") == 0 && g_strcmp0(command, "getruntime") == 0) {
JsonObject *runtime = json_object_new();
json_object_set_string_member(runtime, "version", "0.4"); // protocol version
json_object_set_string_member(runtime, "type", "imgflo");
json_object_set_string_member(runtime, "graph", self->main_network);
JsonArray *capabilities = json_array_new();
json_array_add_string_element(capabilities, "protocol:component");
json_array_add_string_element(capabilities, "protocol:graph");
json_array_add_string_element(capabilities, "protocol:runtime");
json_array_add_string_element(capabilities, "protocol:network");
json_array_add_string_element(capabilities, "component:getsource");
json_array_add_string_element(capabilities, "component:setsource");
json_object_set_array_member(runtime, "capabilities", capabilities);
send_response(ws, "runtime", "runtime", runtime);
if (self->main_network) {
send_ports(g_hash_table_lookup(self->network_map, self->main_network), ws);
}
} else if (g_strcmp0(protocol, "runtime") == 0 && g_strcmp0(command, "packet") == 0) {
gchar *graph_id = g_strdup(json_object_get_string_member(payload, "graph"));
const gchar *port = json_object_get_string_member(payload, "port");
const gchar *event = json_object_get_string_member(payload, "event");
if (!graph_id) {
// NoFlo RemoteSubGraph currently does not send graph info
graph_id = g_strdup(self->main_network);
}
Network *network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL;
g_free(graph_id);
g_return_if_fail(network);
if (g_strcmp0(event, "data") == 0) {
GValue data = G_VALUE_INIT;
json_node_get_value(json_object_get_member(payload, "payload"), &data);
network_send_packet(network, port, &data);
} else {
// TODO: support connect/disconnect?
imgflo_warning("Unknown runtime:packet event: %s", event);
}
} else {
imgflo_warning("Unhandled message: protocol='%s', command='%s'", protocol, command);
}
}
static void
handle_graph_message(UiConnection *self, const gchar *command, JsonObject *payload,
SoupWebsocketConnection *ws)
{
g_return_if_fail(payload);
Graph *graph = NULL;
if (g_strcmp0(command, "clear") != 0) {
// All other commands must have graph
// TODO: change FBP protocol to use 'graph' instead of 'id'?
const gchar *graph_id = json_object_get_string_member(payload, "graph");
Network *net = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL;
graph = (net) ? net->graph : NULL;
g_return_if_fail(graph);
}
if (g_strcmp0(command, "clear") == 0) {
const gchar *graph_id = json_object_get_string_member(payload, "id");
Graph *graph = graph_new(graph_id, self->component_lib);
Network *network = network_new(graph);
ui_connection_add_network(self, graph_id, network);
} else if (g_strcmp0(command, "addnode") == 0) {
graph_add_node(graph,
json_object_get_string_member(payload, "id"),
json_object_get_string_member(payload, "component")
);
} else if (g_strcmp0(command, "removenode") == 0) {
graph_remove_node(graph,
json_object_get_string_member(payload, "id")
);
} else if (g_strcmp0(command, "changenode") == 0) {
// Just metadata, ignored
} else if (g_strcmp0(command, "addinitial") == 0) {
JsonObject *tgt = json_object_get_object_member(payload, "tgt");
JsonObject *src = json_object_get_object_member(payload, "src");
GValue data = G_VALUE_INIT;
json_node_get_value(json_object_get_member(src, "data"), &data);
graph_add_iip(graph,
json_object_get_string_member(tgt, "node"),
json_object_get_string_member(tgt, "port"),
&data
);
g_value_unset(&data);
} else if (g_strcmp0(command, "removeinitial") == 0) {
JsonObject *tgt = json_object_get_object_member(payload, "tgt");
graph_remove_iip(graph,
json_object_get_string_member(tgt, "node"),
json_object_get_string_member(tgt, "port")
);
} else if (g_strcmp0(command, "addedge") == 0) {
JsonObject *src = json_object_get_object_member(payload, "src");
JsonObject *tgt = json_object_get_object_member(payload, "tgt");
graph_add_edge(graph,
json_object_get_string_member(src, "node"),
json_object_get_string_member(src, "port"),
json_object_get_string_member(tgt, "node"),
json_object_get_string_member(tgt, "port")
);
} else if (g_strcmp0(command, "removeedge") == 0) {
JsonObject *src = json_object_get_object_member(payload, "src");
JsonObject *tgt = json_object_get_object_member(payload, "tgt");
graph_remove_edge(graph,
json_object_get_string_member(src, "node"),
json_object_get_string_member(src, "port"),
json_object_get_string_member(tgt, "node"),
json_object_get_string_member(tgt, "port")
);
} else if (g_strcmp0(command, "changeedge") == 0) {
// Just metadata, ignored
} else {
imgflo_warning("Unhandled message on protocol 'graph', command='%s'", command);
}
}
static void
attach (GeglOperation *operation)
{
JsonOp *self = (JsonOp *)operation;
GeglNode *gegl = operation->node;
JsonArray *connections;
GList *l;
// Processes
JsonObject *root = self->json_root;
JsonObject *processes = json_object_get_object_member(root, "processes");
GList *process_names = json_object_get_members(processes);
for (l = process_names; l != NULL; l = l->next) {
const gchar *name = l->data;
JsonObject *proc = json_object_get_object_member(processes, name);
const gchar *component = json_object_get_string_member(proc, "component");
gchar *opname = component2geglop(component);
GeglNode *node = gegl_node_new_child (gegl, "operation", opname, NULL);
gegl_operation_meta_watch_node (operation, node);
g_assert(node);
g_hash_table_insert(self->nodes, (gpointer)g_strdup(name), (gpointer)node);
g_free(opname);
}
g_list_free(process_names);
// Connections
connections = json_object_get_array_member(root, "connections");
g_assert(connections);
for (int i=0; i<json_array_get_length(connections); i++) {
JsonObject *conn = json_array_get_object_element(connections, i);
JsonObject *tgt = json_object_get_object_member(conn, "tgt");
const gchar *tgt_proc = json_object_get_string_member(tgt, "process");
const gchar *tgt_port = json_object_get_string_member(tgt, "port");
GeglNode *tgt_node = g_hash_table_lookup(self->nodes, tgt_proc);
JsonNode *srcnode;
g_assert(tgt_node);
srcnode = json_object_get_member(conn, "src");
if (srcnode) {
// Connection
JsonObject *src = json_object_get_object_member(conn, "src");
const gchar *src_proc = json_object_get_string_member(src, "process");
const gchar *src_port = json_object_get_string_member(src, "port");
GeglNode *src_node = g_hash_table_lookup(self->nodes, src_proc);
g_assert(src_node);
gegl_node_connect_to (src_node, src_port, tgt_node, tgt_port);
} else {
// IIP
JsonNode *datanode = json_object_get_member(conn, "data");
GValue value = G_VALUE_INIT;
GParamSpec *paramspec;
g_assert(JSON_NODE_HOLDS_VALUE(datanode));
json_node_get_value(datanode, &value);
paramspec = gegl_node_find_property(tgt_node, tgt_port);
set_prop(tgt_node, tgt_port, paramspec, &value);
g_value_unset(&value);
}
}
// Exported ports
if (json_object_has_member(root, "inports")) {
JsonObject *inports = json_object_get_object_member(root, "inports");
GList *inport_names = json_object_get_members(inports);
for (l = inport_names; l != NULL; l = l->next) {
const gchar *name = l->data;
JsonObject *conn = json_object_get_object_member(inports, name);
const gchar *proc = json_object_get_string_member(conn, "process");
const gchar *port = json_object_get_string_member(conn, "port");
GeglNode *node = g_hash_table_lookup(self->nodes, proc);
g_assert(node);
if (g_strcmp0(name, "input") == 0) {
GeglNode *input = gegl_node_get_input_proxy (gegl, "input");
gegl_node_connect_to (input, "output", node, "input");
} else {
gegl_operation_meta_redirect (operation, name, node, port);
}
}
g_list_free(inport_names);
}
if (json_object_has_member(root, "outports")) {
JsonObject *outports = json_object_get_object_member(root, "outports");
GList *outport_names = json_object_get_members(outports);
for (l = outport_names; l != NULL; l = l->next) {
const gchar *name = l->data;
JsonObject *conn = json_object_get_object_member(outports, name);
const gchar *proc = json_object_get_string_member(conn, "process");
const gchar *port = json_object_get_string_member(conn, "port");
GeglNode *node = g_hash_table_lookup(self->nodes, proc);
g_assert(node);
if (g_strcmp0(name, "output") == 0) {
GeglNode *proxy = gegl_node_get_output_proxy (gegl, "output");
gegl_node_connect_to (node, port, proxy, "input");
} else {
g_warning("Unsupported output '%s' exported in .json file", name);
}
}
g_list_free(outport_names);
}
}
//Constructor.
GobjectImplScalar::GobjectImplScalar(JsonNode * const node):mNode(node),mValue(){
if (mNode && ((json_node_get_node_type(((mNode))) == (JSON_NODE_VALUE)))) {
json_node_get_value(mNode,&mValue); //Fetch the value if possible.
}
}
